status-go/protocol/messenger_chats.go

659 lines
15 KiB
Go

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,
}
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
}
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, oneMonthInSeconds)
if err != nil {
return err
}
return nil
}