status-go/protocol/messenger_chats.go

443 lines
9.1 KiB
Go
Raw Normal View History

2021-01-11 10:32:51 +00:00
package protocol
import (
"context"
"errors"
2021-03-05 14:38:32 +00:00
"github.com/status-im/status-go/eth-node/types"
2021-01-11 10:32:51 +00:00
"github.com/status-im/status-go/protocol/common"
"github.com/status-im/status-go/protocol/requests"
"github.com/status-im/status-go/protocol/transport"
)
func (m *Messenger) Chats() []*Chat {
var chats []*Chat
2021-03-29 15:41:30 +00:00
m.allChats.Range(func(chatID string, chat *Chat) (shouldContinue bool) {
chats = append(chats, chat)
return true
})
2021-01-11 10:32:51 +00:00
return chats
}
func (m *Messenger) ActiveChats() []*Chat {
m.mutex.Lock()
defer m.mutex.Unlock()
var chats []*Chat
m.allChats.Range(func(chatID string, c *Chat) bool {
if c.Active {
chats = append(chats, c)
}
return true
})
return chats
}
2021-03-25 15:15:22 +00:00
func (m *Messenger) CreatePublicChat(request *requests.CreatePublicChat) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
chatID := request.ID
chat, ok := m.allChats.Load(chatID)
if !ok {
chat = CreatePublicChat(chatID, m.getTimesource())
2021-05-14 10:55:42 +00:00
2021-03-25 15:15:22 +00:00
}
chat.Active = true
// Save topics
_, err := m.Join(chat)
if err != nil {
return nil, err
}
2021-05-14 10:55:42 +00:00
// Store chat
m.allChats.Store(chat.ID, chat)
willSync, err := m.scheduleSyncChat(chat)
if err != nil {
return nil, err
}
// We set the synced to, synced from to the default time
if !willSync {
timestamp := uint32(m.getTimesource().GetCurrentTime()/1000) - defaultSyncInterval
chat.SyncedTo = timestamp
chat.SyncedFrom = timestamp
}
2021-03-25 15:15:22 +00:00
err = m.saveChat(chat)
if err != nil {
return nil, err
}
2021-05-14 10:55:42 +00:00
// Sync if it was created
if !ok {
if err := m.syncPublicChat(context.Background(), chat); err != nil {
return nil, err
}
}
2021-03-25 15:15:22 +00:00
response := &MessengerResponse{}
response.AddChat(chat)
return response, nil
}
func (m *Messenger) CreateProfileChat(request *requests.CreateProfileChat) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
publicKey, err := common.HexToPubkey(request.ID)
if err != nil {
return nil, err
}
chat := m.buildProfileChat(request.ID)
chat.Active = true
// Save topics
_, err = m.Join(chat)
if err != nil {
return nil, err
}
// Check contact code
filter, err := m.transport.JoinPrivate(publicKey)
if err != nil {
return nil, err
}
2021-05-14 10:55:42 +00:00
// Store chat
m.allChats.Store(chat.ID, chat)
response := &MessengerResponse{}
response.AddChat(chat)
willSync, err := m.scheduleSyncChat(chat)
2021-03-25 15:15:22 +00:00
if err != nil {
return nil, err
}
2021-05-14 10:55:42 +00:00
// We set the synced to, synced from to the default time
if !willSync {
timestamp := uint32(m.getTimesource().GetCurrentTime()/1000) - defaultSyncInterval
chat.SyncedTo = timestamp
chat.SyncedFrom = timestamp
}
_, err = m.scheduleSyncFilters([]*transport.Filter{filter})
if err != nil {
return nil, err
}
2021-03-25 15:15:22 +00:00
2021-05-14 10:55:42 +00:00
err = m.saveChat(chat)
if err != nil {
return nil, err
}
2021-03-25 15:15:22 +00:00
return response, nil
}
2021-01-11 10:32:51 +00:00
func (m *Messenger) CreateOneToOneChat(request *requests.CreateOneToOneChat) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
chatID := request.ID.String()
pk, err := common.HexToPubkey(chatID)
if err != nil {
return nil, err
}
2021-03-29 15:41:30 +00:00
chat, ok := m.allChats.Load(chatID)
2021-01-11 10:32:51 +00:00
if !ok {
chat = CreateOneToOneChat(chatID, pk, m.getTimesource())
}
chat.Active = true
filters, err := m.Join(chat)
if err != nil {
return nil, err
}
2021-03-29 15:41:30 +00:00
// TODO(Samyoul) remove storing of an updated reference pointer?
m.allChats.Store(chatID, chat)
2021-01-11 10:32:51 +00:00
2021-03-25 15:15:22 +00:00
response := &MessengerResponse{}
2021-01-11 10:32:51 +00:00
response.AddChat(chat)
2021-05-14 10:55:42 +00:00
willSync, err := m.scheduleSyncFilters(filters)
if err != nil {
return nil, err
}
// We set the synced to, synced from to the default time
if !willSync {
timestamp := uint32(m.getTimesource().GetCurrentTime()/1000) - defaultSyncInterval
chat.SyncedTo = timestamp
chat.SyncedFrom = timestamp
}
2021-03-25 15:15:22 +00:00
2021-05-14 10:55:42 +00:00
err = m.saveChat(chat)
if err != nil {
return nil, err
}
2021-01-11 10:32:51 +00:00
return response, nil
}
func (m *Messenger) DeleteChat(chatID string) error {
return m.deleteChat(chatID)
}
func (m *Messenger) deleteChat(chatID string) error {
err := m.persistence.DeleteChat(chatID)
if err != nil {
return err
}
2021-03-29 15:41:30 +00:00
chat, ok := m.allChats.Load(chatID)
2021-01-11 10:32:51 +00:00
if ok && chat.Active && chat.Public() {
2021-03-29 15:41:30 +00:00
m.allChats.Delete(chatID)
2021-01-11 10:32:51 +00:00
return m.reregisterForPushNotifications()
}
return nil
}
func (m *Messenger) SaveChat(chat *Chat) error {
return m.saveChat(chat)
}
2021-03-25 15:15:22 +00:00
func (m *Messenger) DeactivateChat(request *requests.DeactivateChat) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
return m.deactivateChat(request.ID)
2021-01-11 10:32:51 +00:00
}
func (m *Messenger) deactivateChat(chatID string) (*MessengerResponse, error) {
var response MessengerResponse
2021-03-29 15:41:30 +00:00
chat, ok := m.allChats.Load(chatID)
2021-01-11 10:32:51 +00:00
if !ok {
return nil, ErrChatNotFound
}
clock, _ := chat.NextClockAndTimestamp(m.getTimesource())
err := m.persistence.DeactivateChat(chat, clock)
if err != nil {
return nil, err
}
// We re-register as our options have changed and we don't want to
// receive PN from mentions in this chat anymore
if chat.Public() {
err := m.reregisterForPushNotifications()
if err != nil {
return nil, err
}
2021-03-25 15:15:22 +00:00
err = m.transport.ClearProcessedMessageIDsCache()
if err != nil {
return nil, err
}
2021-01-11 10:32:51 +00:00
}
2021-03-29 15:41:30 +00:00
// TODO(samyoul) remove storing of an updated reference pointer?
m.allChats.Store(chatID, chat)
2021-01-11 10:32:51 +00:00
response.AddChat(chat)
// TODO: Remove filters
return &response, nil
}
func (m *Messenger) saveChats(chats []*Chat) error {
err := m.persistence.SaveChats(chats)
if err != nil {
return err
}
for _, chat := range chats {
2021-03-29 15:41:30 +00:00
m.allChats.Store(chat.ID, chat)
2021-01-11 10:32:51 +00:00
}
return nil
}
func (m *Messenger) saveChat(chat *Chat) error {
2021-03-29 15:41:30 +00:00
previousChat, ok := m.allChats.Load(chat.ID)
2021-01-11 10:32:51 +00:00
if chat.OneToOne() {
// We clear all notifications so it pops up again
if !chat.Active {
err := m.persistence.DeleteActivityCenterNotification(types.FromHex(chat.ID))
if err != nil {
return err
}
}
2021-01-11 10:32:51 +00:00
name, identicon, err := generateAliasAndIdenticon(chat.ID)
if err != nil {
return err
}
chat.Alias = name
chat.Identicon = identicon
}
// Sync chat if it's a new active public chat, but not a timeline chat
2021-03-04 13:02:08 +00:00
if !ok && chat.Active && chat.Public() && !chat.ProfileUpdates() && !chat.Timeline() {
2021-01-11 10:32:51 +00:00
if err := m.syncPublicChat(context.Background(), chat); err != nil {
return err
}
}
// We check if it's a new chat, or chat.Active has changed
// we check here, but we only re-register once the chat has been
// saved an added
shouldRegisterForPushNotifications := chat.Public() && (!ok && chat.Active) || (ok && chat.Active != previousChat.Active)
err := m.persistence.SaveChat(*chat)
if err != nil {
return err
}
2021-03-29 15:41:30 +00:00
// TODO(samyoul) remove storing of an updated reference pointer?
m.allChats.Store(chat.ID, chat)
2021-01-11 10:32:51 +00:00
if shouldRegisterForPushNotifications {
// Re-register for push notifications, as we want to receive mentions
if err := m.reregisterForPushNotifications(); err != nil {
return err
}
}
return nil
}
func (m *Messenger) Join(chat *Chat) ([]*transport.Filter, error) {
switch chat.ChatType {
case ChatTypeOneToOne:
pk, err := chat.PublicKey()
if err != nil {
return nil, err
}
f, err := m.transport.JoinPrivate(pk)
if err != nil {
return nil, err
}
return []*transport.Filter{f}, nil
case ChatTypePrivateGroupChat:
members, err := chat.MembersAsPublicKeys()
if err != nil {
return nil, err
}
return m.transport.JoinGroup(members)
case ChatTypePublic, ChatTypeProfile, ChatTypeTimeline:
f, err := m.transport.JoinPublic(chat.ID)
if err != nil {
return nil, err
}
return []*transport.Filter{f}, nil
default:
return nil, errors.New("chat is neither public nor private")
}
}
2021-03-25 15:15:22 +00:00
func (m *Messenger) buildProfileChat(id string) *Chat {
// Create the corresponding profile chat
profileChatID := buildProfileChatID(id)
profileChat, ok := m.allChats.Load(profileChatID)
if !ok {
profileChat = CreateProfileChat(id, m.getTimesource())
}
return profileChat
}
func (m *Messenger) ensureTimelineChat() error {
chat, err := m.persistence.Chat(timelineChatID)
if err != nil {
return err
}
if chat != nil {
return nil
}
chat = CreateTimelineChat(m.getTimesource())
m.allChats.Store(timelineChatID, chat)
return m.saveChat(chat)
}
func (m *Messenger) ensureMyOwnProfileChat() error {
chatID := common.PubkeyToHex(&m.identity.PublicKey)
2021-05-14 10:55:42 +00:00
_, ok := m.allChats.Load(chatID)
2021-03-25 15:15:22 +00:00
if ok {
return nil
}
2021-05-14 10:55:42 +00:00
chat := m.buildProfileChat(chatID)
2021-03-25 15:15:22 +00:00
chat.Active = true
// Save topics
_, err := m.Join(chat)
if err != nil {
return err
}
return m.saveChat(chat)
}
func (m *Messenger) ClearHistory(request *requests.ClearHistory) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
return m.clearHistory(request.ID)
}
func (m *Messenger) clearHistory(id string) (*MessengerResponse, error) {
chat, ok := m.allChats.Load(id)
if !ok {
return nil, ErrChatNotFound
}
clock, _ := chat.NextClockAndTimestamp(m.transport)
err := m.persistence.ClearHistory(chat, clock)
if err != nil {
return nil, err
}
if chat.Public() {
err = m.transport.ClearProcessedMessageIDsCache()
if err != nil {
return nil, err
}
}
m.allChats.Store(id, chat)
response := &MessengerResponse{}
response.AddChat(chat)
return response, nil
}