package protocol import ( "context" "errors" "strings" "github.com/status-im/status-go/deprecation" "github.com/status-im/status-go/protocol/common" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/requests" "github.com/status-im/status-go/protocol/transport" ) func (m *Messenger) getOneToOneAndNextClock(contact *Contact) (*Chat, uint64, error) { chat, ok := m.allChats.Load(contact.ID) if !ok { publicKey, err := contact.PublicKey() if err != nil { return nil, 0, err } chat = OneToOneFromPublicKey(publicKey, m.getTimesource()) // We don't want to show the chat to the user by default chat.Active = false if err := m.saveChat(chat); err != nil { return nil, 0, err } m.allChats.Store(chat.ID, chat) } clock, _ := chat.NextClockAndTimestamp(m.getTimesource()) return chat, clock, nil } func (m *Messenger) Chats() []*Chat { var chats []*Chat m.allChats.Range(func(chatID string, chat *Chat) (shouldContinue bool) { chats = append(chats, chat) return true }) return chats } func (m *Messenger) ChatsPreview() []*ChatPreview { var chats []*ChatPreview m.allChats.Range(func(chatID string, chat *Chat) (shouldContinue bool) { if chat.Active || chat.Muted { chatPreview := &ChatPreview{ ID: chat.ID, Name: chat.Name, Description: chat.Description, Color: chat.Color, Emoji: chat.Emoji, Active: chat.Active, ChatType: chat.ChatType, Timestamp: chat.Timestamp, LastClockValue: chat.LastClockValue, DeletedAtClockValue: chat.DeletedAtClockValue, UnviewedMessagesCount: chat.UnviewedMessagesCount, UnviewedMentionsCount: chat.UnviewedMentionsCount, Alias: chat.Alias, Identicon: chat.Identicon, Muted: chat.Muted, MuteTill: chat.MuteTill, Profile: chat.Profile, CommunityID: chat.CommunityID, CategoryID: chat.CategoryID, Joined: chat.Joined, SyncedTo: chat.SyncedTo, SyncedFrom: chat.SyncedFrom, Highlight: chat.Highlight, Members: chat.Members, Base64Image: chat.Base64Image, } if chat.LastMessage != nil { chatPreview.OutgoingStatus = chat.LastMessage.OutgoingStatus chatPreview.ResponseTo = chat.LastMessage.ResponseTo chatPreview.ContentType = chat.LastMessage.ContentType chatPreview.From = chat.LastMessage.From chatPreview.Deleted = chat.LastMessage.Deleted chatPreview.DeletedForMe = chat.LastMessage.DeletedForMe if chat.LastMessage.ContentType == protobuf.ChatMessage_IMAGE { chatPreview.ParsedText = chat.LastMessage.ParsedText image := chat.LastMessage.GetImage() if image != nil { chatPreview.AlbumImagesCount = image.AlbumImagesCount chatPreview.ParsedText = chat.LastMessage.ParsedText } } if chat.LastMessage.ContentType == protobuf.ChatMessage_TEXT_PLAIN { simplifiedText, err := chat.LastMessage.GetSimplifiedText("", nil) if err == nil { if len(simplifiedText) > 100 { chatPreview.Text = simplifiedText[:100] } else { chatPreview.Text = simplifiedText } if strings.Contains(chatPreview.Text, "0x") { //if there is a mention, we would like to send parsed text as well chatPreview.ParsedText = chat.LastMessage.ParsedText } } } else if chat.LastMessage.ContentType == protobuf.ChatMessage_EMOJI || chat.LastMessage.ContentType == protobuf.ChatMessage_TRANSACTION_COMMAND { chatPreview.Text = chat.LastMessage.Text chatPreview.ParsedText = chat.LastMessage.ParsedText } if chat.LastMessage.ContentType == protobuf.ChatMessage_COMMUNITY { chatPreview.ContentCommunityID = chat.LastMessage.CommunityID } } chats = append(chats, chatPreview) } return true }) return chats } func (m *Messenger) Chat(chatID string) *Chat { chat, _ := m.allChats.Load(chatID) return chat } 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 } func (m *Messenger) initChatSyncFields(chat *Chat) error { defaultSyncPeriod, err := m.settings.GetDefaultSyncPeriod() if err != nil { return err } timestamp := uint32(m.getTimesource().GetCurrentTime()/1000) - defaultSyncPeriod chat.SyncedTo = timestamp chat.SyncedFrom = timestamp return nil } func (m *Messenger) createPublicChat(chatID string, response *MessengerResponse) (*MessengerResponse, error) { chat, ok := m.allChats.Load(chatID) if !ok { chat = CreatePublicChat(chatID, m.getTimesource()) } chat.Active = true chat.DeletedAtClockValue = 0 // Save topics _, err := m.Join(chat) if err != nil { return nil, err } // 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 { if err := m.initChatSyncFields(chat); err != nil { return nil, err } } err = m.saveChat(chat) if err != nil { return nil, err } err = m.reregisterForPushNotifications() if err != nil { return nil, err } response.AddChat(chat) return response, nil } func (m *Messenger) CreatePublicChat(request *requests.CreatePublicChat) (*MessengerResponse, error) { if err := request.Validate(); err != nil { return nil, err } chatID := request.ID response := &MessengerResponse{} return m.createPublicChat(chatID, response) } // Deprecated: CreateProfileChat shouldn't be used // and is only left here in case profile chat feature is re-introduced. func (m *Messenger) CreateProfileChat(request *requests.CreateProfileChat) (*MessengerResponse, error) { // Return error to prevent usage of deprecated function if deprecation.ChatProfileDeprecated { return nil, errors.New("profile chats are deprecated") } 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 } // Store chat m.allChats.Store(chat.ID, chat) response := &MessengerResponse{} response.AddChat(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 { if err := m.initChatSyncFields(chat); err != nil { return nil, err } } _, err = m.scheduleSyncFilters([]*transport.Filter{filter}) if err != nil { return nil, err } err = m.saveChat(chat) if err != nil { return nil, err } return response, nil } 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 } response := &MessengerResponse{} ensName := request.ENSName if ensName != "" { clock := m.getTimesource().GetCurrentTime() err := m.ensVerifier.ENSVerified(chatID, ensName, clock) if err != nil { return nil, err } contact, err := m.BuildContact(&requests.BuildContact{PublicKey: chatID}) if err != nil { return nil, err } contact.EnsName = ensName contact.ENSVerified = true err = m.persistence.SaveContact(contact, nil) if err != nil { return nil, err } response.Contacts = []*Contact{contact} } chat, ok := m.allChats.Load(chatID) if !ok { chat = CreateOneToOneChat(chatID, pk, m.getTimesource()) } chat.Active = true filters, err := m.Join(chat) if err != nil { return nil, err } // TODO(Samyoul) remove storing of an updated reference pointer? m.allChats.Store(chatID, chat) response.AddChat(chat) willSync, err := m.scheduleSyncFilters(filters) if err != nil { return nil, err } // We set the synced to, synced from to the default time if !willSync { if err := m.initChatSyncFields(chat); err != nil { return nil, err } } err = m.saveChat(chat) if err != nil { return nil, err } 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 } // We clean the cache to be able to receive the messages again later err = m.transport.ClearProcessedMessageIDsCache() if err != nil { return err } chat, ok := m.allChats.Load(chatID) if ok && chat.Active && chat.Public() { m.allChats.Delete(chatID) return m.reregisterForPushNotifications() } return nil } func (m *Messenger) SaveChat(chat *Chat) error { return m.saveChat(chat) } func (m *Messenger) DeactivateChat(request *requests.DeactivateChat) (*MessengerResponse, error) { if err := request.Validate(); err != nil { return nil, err } doClearHistory := !request.PreserveHistory return m.deactivateChat(request.ID, 0, true, doClearHistory) } func (m *Messenger) deactivateChat(chatID string, deactivationClock uint64, shouldBeSynced bool, doClearHistory bool) (*MessengerResponse, error) { var response MessengerResponse chat, ok := m.allChats.Load(chatID) if !ok { return nil, ErrChatNotFound } // Reset mailserver last request to allow re-fetching messages if joining a chat again filters, err := m.filtersForChat(chatID) if err != nil && err != ErrNoFiltersForChat { return nil, err } if m.mailserversDatabase != nil { for _, filter := range filters { if !filter.Listen || filter.Ephemeral { continue } err := m.mailserversDatabase.ResetLastRequest(filter.PubsubTopic, filter.ContentTopic.String()) if err != nil { return nil, err } } } if deactivationClock == 0 { deactivationClock, _ = chat.NextClockAndTimestamp(m.getTimesource()) } err = m.persistence.DeactivateChat(chat, deactivationClock, doClearHistory) 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() || chat.ProfileUpdates() { err := m.reregisterForPushNotifications() if err != nil { return nil, err } err = m.transport.ClearProcessedMessageIDsCache() if err != nil { return nil, err } } // TODO(samyoul) remove storing of an updated reference pointer? m.allChats.Store(chatID, chat) response.AddChat(chat) // TODO: Remove filters if shouldBeSynced { err := m.syncChatRemoving(context.Background(), chat.ID, m.dispatchMessage) if err != nil { return nil, err } } return &response, nil } func (m *Messenger) saveChats(chats []*Chat) error { err := m.persistence.SaveChats(chats) if err != nil { return err } for _, chat := range chats { m.allChats.Store(chat.ID, chat) } return nil } func (m *Messenger) saveChat(chat *Chat) error { _, ok := m.allChats.Load(chat.ID) if chat.OneToOne() { name, identicon, err := generateAliasAndIdenticon(chat.ID) if err != nil { return err } chat.Alias = name chat.Identicon = identicon } // Sync chat if it's a new public, 1-1 or group chat, but not a timeline chat if !ok && chat.shouldBeSynced() { if err := m.syncChat(context.Background(), chat, m.dispatchMessage); err != nil { return err } } err := m.persistence.SaveChat(*chat) if err != nil { return err } // We store the chat has it might not have been in the store in the first place m.allChats.Store(chat.ID, chat) 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") } } // Deprecated: buildProfileChat shouldn't be used // and is only left here in case profile chat feature is re-introduced. func (m *Messenger) buildProfileChat(id string) *Chat { // Return nil to prevent usage of deprecated function if deprecation.ChatProfileDeprecated { return nil } // Create the corresponding profile chat profileChatID := buildProfileChatID(id) profileChat, ok := m.allChats.Load(profileChatID) if !ok { profileChat = CreateProfileChat(id, m.getTimesource()) } return profileChat } // Deprecated: ensureTimelineChat shouldn't be used // and is only left here in case profile chat feature is re-introduced. func (m *Messenger) ensureTimelineChat() error { // Return error to prevent usage of deprecated function if deprecation.ChatProfileDeprecated { return errors.New("timeline chats are deprecated") } 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) } // Deprecated: ensureMyOwnProfileChat shouldn't be used // and is only left here in case profile chat feature is re-introduced. func (m *Messenger) ensureMyOwnProfileChat() error { // Return error to prevent usage of deprecated function if deprecation.ChatProfileDeprecated { return errors.New("profile chats are deprecated") } chatID := common.PubkeyToHex(&m.identity.PublicKey) _, ok := m.allChats.Load(chatID) if ok { return nil } chat := m.buildProfileChat(chatID) 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 } } err = m.syncClearHistory(context.Background(), chat, m.dispatchMessage) if err != nil { return nil, err } m.allChats.Store(id, chat) response := &MessengerResponse{} response.AddChat(chat) return response, nil } func (m *Messenger) FetchMessages(request *requests.FetchMessages) error { if err := request.Validate(); err != nil { return err } id := request.ID chat, ok := m.allChats.Load(id) if !ok { return ErrChatNotFound } _, err := m.fetchMessages(chat.ID, oneMonthDuration) if err != nil { return err } return nil }