status-im/status-go

package protocol

import (
    "context"
    "crypto/ecdsa"
    "errors"

    "github.com/golang/protobuf/proto"

    "github.com/status-im/status-go/protocol/common"
    "github.com/status-im/status-go/protocol/protobuf"
    "github.com/status-im/status-go/protocol/requests"

    "go.uber.org/zap"
)

var ErrInvalidEditOrDeleteAuthor = errors.New("sender is not the author of the message")
var ErrInvalidDeleteTypeAuthor = errors.New("message type cannot be deleted")
var ErrInvalidEditContentType = errors.New("only text or emoji messages can be replaced")
var ErrInvalidDeletePermission = errors.New("don't have enough permission to delete")

func (m *Messenger) EditMessage(ctx context.Context, request *requests.EditMessage) (*MessengerResponse, error) {
    err := request.Validate()
    if err != nil {
        return nil, err
    }
    message, err := m.persistence.MessageByID(request.ID.String())
    if err != nil {
        return nil, err
    }

    if message.From != common.PubkeyToHex(&m.identity.PublicKey) {
        return nil, ErrInvalidEditOrDeleteAuthor
    }

    if message.ContentType != protobuf.ChatMessage_TEXT_PLAIN && message.ContentType != protobuf.ChatMessage_EMOJI && message.ContentType != protobuf.ChatMessage_IMAGE && message.ContentType != protobuf.ChatMessage_BRIDGE_MESSAGE {
        return nil, ErrInvalidEditContentType
    }

    // A valid added chat is required.
    chat, ok := m.allChats.Load(message.ChatId)
    if !ok {
        return nil, ErrChatNotFound
    }

    messages, err := m.getOtherMessagesInAlbum(message, message.LocalChatID)
    if err != nil {
        return nil, err
    }

    response := &MessengerResponse{}

    for _, message := range messages {
        //Add LinkPreviews only to first message
        if len(request.LinkPreviews) > 0 {
            message.LinkPreviews = request.LinkPreviews
        }
        if len(request.StatusLinkPreviews) > 0 {
            message.StatusLinkPreviews = request.StatusLinkPreviews
        }

        clock, _ := chat.NextClockAndTimestamp(m.getTimesource())

        editMessage := NewEditMessage()

        replacedText, err := m.mentionsManager.ReplaceWithPublicKey(message.ChatId, request.Text)
        if err != nil {
            m.logger.Error("failed to replace text with public key", zap.String("chatID", message.ChatId), zap.String("text", request.Text))
            // use original text as fallback
            replacedText = request.Text
        }
        editMessage.Text = replacedText
        editMessage.ContentType = request.ContentType
        editMessage.ChatId = message.ChatId
        editMessage.MessageId = message.ID
        editMessage.Clock = clock

        // We consider link previews non-critical data, so we do not want to block
        // messages from being sent.

        unfurledLinks, err := message.ConvertLinkPreviewsToProto()
        if err != nil {
            m.logger.Error("failed to convert link previews", zap.Error(err))
        } else {
            editMessage.UnfurledLinks = unfurledLinks
        }

        unfurledStatusLinks, err := message.ConvertStatusLinkPreviewsToProto()
        if err != nil {
            m.logger.Error("failed to convert status link previews", zap.Error(err))
        } else {
            editMessage.UnfurledStatusLinks = unfurledStatusLinks
        }

        err = m.applyEditMessage(editMessage.EditMessage, message)
        if err != nil {
            return nil, err
        }

        encodedMessage, err := m.encodeChatEntity(chat, editMessage)
        if err != nil {
            return nil, err
        }

        rawMessage := common.RawMessage{
            LocalChatID:          chat.ID,
            Payload:              encodedMessage,
            MessageType:          protobuf.ApplicationMetadataMessage_EDIT_MESSAGE,
            SkipGroupMessageWrap: true,
            ResendType:           chat.DefaultResendType(),
        }
        _, err = m.dispatchMessage(ctx, rawMessage)
        if err != nil {
            return nil, err
        }

        if chat.LastMessage != nil && chat.LastMessage.ID == message.ID {
            chat.LastMessage = message
            err := m.saveChat(chat)
            if err != nil {
                return nil, err
            }
        }

        response.AddMessage(message)
    }

    // pull updated messages
    updatedMessages, err := m.persistence.MessagesByResponseTo(request.ID.String())
    if err != nil {
        return nil, err
    }
    response.AddMessages(updatedMessages)
    err = m.prepareMessages(response.messages)
    if err != nil {
        return nil, err
    }
    response.AddChat(chat)

    return response, nil
}

func (m *Messenger) CanDeleteMessageForEveryoneInCommunity(communityID string, publicKey *ecdsa.PublicKey) bool {
    if communityID != "" {
        community, err := m.communitiesManager.GetByIDString(communityID)
        if err != nil {
            m.logger.Error("failed to find community", zap.String("communityID", communityID), zap.Error(err))
            return false
        }
        return community.CanDeleteMessageForEveryone(publicKey)
    }
    return false
}

func (m *Messenger) CanDeleteMessageForEveryoneInPrivateGroupChat(chat *Chat, publicKey *ecdsa.PublicKey) bool {
    group, err := newProtocolGroupFromChat(chat)
    if err != nil {
        m.logger.Error("failed to find group", zap.String("chatID", chat.ID), zap.Error(err))
        return false
    }
    admins := group.Admins()
    return stringSliceContains(admins, common.PubkeyToHex(publicKey))
}

func (m *Messenger) DeleteMessageAndSend(ctx context.Context, messageID string) (*MessengerResponse, error) {
    message, err := m.persistence.MessageByID(messageID)
    if err != nil {
        return nil, err
    }

    // A valid added chat is required.
    chat, ok := m.allChats.Load(message.ChatId)
    if !ok {
        return nil, ErrChatNotFound
    }

    var canDeleteMessageForEveryone = false
    var deletedBy string
    if message.From != common.PubkeyToHex(&m.identity.PublicKey) {
        if message.MessageType == protobuf.MessageType_COMMUNITY_CHAT {
            communityID := chat.CommunityID
            canDeleteMessageForEveryone = m.CanDeleteMessageForEveryoneInCommunity(communityID, &m.identity.PublicKey)
            if !canDeleteMessageForEveryone {
                return nil, ErrInvalidDeletePermission
            }
        } else if message.MessageType == protobuf.MessageType_PRIVATE_GROUP {
            canDeleteMessageForEveryone = m.CanDeleteMessageForEveryoneInPrivateGroupChat(chat, &m.identity.PublicKey)
            if !canDeleteMessageForEveryone {
                return nil, ErrInvalidDeletePermission
            }
        }

        // only add DeletedBy when not deleted by message.From
        deletedBy = contactIDFromPublicKey(m.IdentityPublicKey())

        if !canDeleteMessageForEveryone {
            return nil, ErrInvalidEditOrDeleteAuthor
        }
    }

    // Only certain types of messages can be deleted
    if message.ContentType != protobuf.ChatMessage_TEXT_PLAIN &&
        message.ContentType != protobuf.ChatMessage_BRIDGE_MESSAGE &&
        message.ContentType != protobuf.ChatMessage_STICKER &&
        message.ContentType != protobuf.ChatMessage_EMOJI &&
        message.ContentType != protobuf.ChatMessage_IMAGE &&
        message.ContentType != protobuf.ChatMessage_AUDIO {
        return nil, ErrInvalidDeleteTypeAuthor
    }

    messagesToDelete, err := m.getOtherMessagesInAlbum(message, message.ChatId)
    if err != nil {
        return nil, err
    }

    clock, _ := chat.NextClockAndTimestamp(m.getTimesource())

    deleteMessage := NewDeleteMessage()
    deleteMessage.ChatId = message.ChatId
    deleteMessage.MessageId = messageID
    deleteMessage.Clock = clock
    deleteMessage.DeletedBy = deletedBy

    encodedMessage, err := m.encodeChatEntity(chat, deleteMessage)

    if err != nil {
        return nil, err
    }

    rawMessage := common.RawMessage{
        LocalChatID:          chat.ID,
        Payload:              encodedMessage,
        MessageType:          protobuf.ApplicationMetadataMessage_DELETE_MESSAGE,
        SkipGroupMessageWrap: true,
        ResendType:           chat.DefaultResendType(),
    }

    _, err = m.dispatchMessage(ctx, rawMessage)
    if err != nil {
        return nil, err
    }

    response := &MessengerResponse{}
    for _, messageToDelete := range messagesToDelete {
        messageToDelete.Deleted = true
        messageToDelete.DeletedBy = deletedBy
        err = m.persistence.SaveMessages([]*common.Message{messageToDelete})
        if err != nil {
            return nil, err
        }
        response.AddMessage(messageToDelete)
        response.AddRemovedMessage(&RemovedMessage{MessageID: messageToDelete.ID, ChatID: chat.ID, DeletedBy: deletedBy})

        if chat.LastMessage != nil && chat.LastMessage.ID == messageToDelete.ID {
            chat.LastMessage = messageToDelete

            err = m.saveChat(chat)
            if err != nil {
                return nil, err
            }
        }
        // pull updated messages
        updatedMessages, err := m.persistence.MessagesByResponseTo(messageToDelete.ID)
        if err != nil {
            return nil, err
        }

        response.AddMessages(updatedMessages)
        err = m.prepareMessages(response.messages)
        if err != nil {
            return nil, err
        }
    }

    response.AddChat(chat)

    return response, nil
}

func (m *Messenger) DeleteMessageForMeAndSync(ctx context.Context, localChatID string, messageID string) (*MessengerResponse, error) {
    message, err := m.persistence.MessageByID(messageID)
    if err != nil {
        return nil, err
    }

    // A valid added chat is required.
    chat, ok := m.allChats.Load(localChatID)
    if !ok {
        return nil, ErrChatNotFound
    }

    // Only certain types of messages can be deleted
    if message.ContentType != protobuf.ChatMessage_TEXT_PLAIN &&
        message.ContentType != protobuf.ChatMessage_STICKER &&
        message.ContentType != protobuf.ChatMessage_EMOJI &&
        message.ContentType != protobuf.ChatMessage_IMAGE &&
        message.ContentType != protobuf.ChatMessage_AUDIO {
        return nil, ErrInvalidDeleteTypeAuthor
    }

    messagesToDelete, err := m.getOtherMessagesInAlbum(message, localChatID)
    if err != nil {
        return nil, err
    }

    response := &MessengerResponse{}
    for _, messageToDelete := range messagesToDelete {
        messageToDelete.DeletedForMe = true
        err = m.persistence.SaveMessages([]*common.Message{messageToDelete})
        if err != nil {
            return nil, err
        }

        if chat.LastMessage != nil && chat.LastMessage.ID == messageToDelete.ID {
            chat.LastMessage = messageToDelete
            err = m.saveChat(chat)
            if err != nil {
                return nil, err
            }
        }

        response.AddMessage(messageToDelete)

        // pull updated messages
        updatedMessages, err := m.persistence.MessagesByResponseTo(messageToDelete.ID)
        if err != nil {
            return nil, err
        }

        response.AddMessages(updatedMessages)

        err = m.prepareMessages(response.messages)
        if err != nil {
            return nil, err
        }

    }
    response.AddChat(chat)

    err = m.withChatClock(func(chatID string, clock uint64) error {
        deletedForMeMessage := &protobuf.SyncDeleteForMeMessage{
            MessageId: messageID,
            Clock:     clock,
        }

        if m.hasPairedDevices() {
            encodedMessage, err2 := proto.Marshal(deletedForMeMessage)

            if err2 != nil {
                return err2
            }

            rawMessage := common.RawMessage{
                LocalChatID: chatID,
                Payload:     encodedMessage,
                MessageType: protobuf.ApplicationMetadataMessage_SYNC_DELETE_FOR_ME_MESSAGE,
                ResendType:  common.ResendTypeDataSync,
            }
            _, err2 = m.dispatchMessage(ctx, rawMessage)
            return err2
        }

        return m.persistence.SaveOrUpdateDeleteForMeMessage(deletedForMeMessage)
    })

    if err != nil {
        return response, err
    }

    return response, nil
}

func (m *Messenger) applyEditMessage(editMessage *protobuf.EditMessage, message *common.Message) error {
    if err := ValidateText(editMessage.Text); err != nil {
        return err
    }

    if editMessage.ContentType != protobuf.ChatMessage_BRIDGE_MESSAGE {
        message.Text = editMessage.Text
    } else {
        message.GetBridgeMessage().Content = editMessage.Text
    }

    message.EditedAt = editMessage.Clock
    message.UnfurledLinks = editMessage.UnfurledLinks
    message.UnfurledStatusLinks = editMessage.UnfurledStatusLinks
    if editMessage.ContentType != protobuf.ChatMessage_UNKNOWN_CONTENT_TYPE {
        message.ContentType = editMessage.ContentType
    }

    // Save original message as edit so we can retrieve history
    if message.EditedAt == 0 {
        originalEdit := NewEditMessage()
        originalEdit.Clock = message.Clock
        originalEdit.LocalChatID = message.LocalChatID
        originalEdit.MessageId = message.ID
        originalEdit.Text = message.Text
        originalEdit.ContentType = message.ContentType
        originalEdit.From = message.From
        originalEdit.UnfurledLinks = message.UnfurledLinks
        originalEdit.UnfurledStatusLinks = message.UnfurledStatusLinks
        err := m.persistence.SaveEdit(originalEdit)
        if err != nil {
            return err
        }
    }

    err := message.PrepareContent(common.PubkeyToHex(&m.identity.PublicKey))
    if err != nil {
        return err
    }

    return m.persistence.SaveMessages([]*common.Message{message})
}

func (m *Messenger) applyDeleteMessage(messageDeletes []*DeleteMessage, message *common.Message) error {
    if messageDeletes[0].From != message.From {
        return ErrInvalidEditOrDeleteAuthor
    }

    message.Deleted = true
    message.DeletedBy = messageDeletes[0].DeletedBy

    err := message.PrepareContent(common.PubkeyToHex(&m.identity.PublicKey))
    if err != nil {
        return err
    }

    err = m.persistence.SaveMessages([]*common.Message{message})
    if err != nil {
        return err
    }

    return nil
}

func (m *Messenger) applyDeleteForMeMessage(message *common.Message) error {
    message.DeletedForMe = true

    err := message.PrepareContent(m.myHexIdentity())
    if err != nil {
        return err
    }

    err = m.persistence.SaveMessages([]*common.Message{message})
    if err != nil {
        return err
    }

    return nil
}

func (m *Messenger) addContactRequestPropagatedState(message *common.Message) error {
    chat, ok := m.allChats.Load(message.LocalChatID)
    if !ok {
        return ErrChatNotFound
    }
    if !chat.OneToOne() {
        return nil
    }

    contact, err := m.BuildContact(&requests.BuildContact{PublicKey: chat.ID})
    if err != nil {
        return err
    }

    message.ContactRequestPropagatedState = contact.ContactRequestPropagatedState()
    return nil
}

func (m *Messenger) SendOneToOneMessage(request *requests.SendOneToOneMessage) (*MessengerResponse, error) {
    if err := request.Validate(); err != nil {
        return nil, err
    }

    chatID, err := request.HexID()
    if err != nil {
        return nil, err
    }

    _, ok := m.allChats.Load(chatID)
    if !ok {
        // Only one to one chan be muted when it's not in the database
        publicKey, err := common.HexToPubkey(chatID)
        if err != nil {
            return nil, err
        }

        // Create a one to one chat
        chat := CreateOneToOneChat(chatID, publicKey, m.getTimesource())
        err = m.initChatSyncFields(chat)
        if err != nil {
            return nil, err
        }
        err = m.saveChat(chat)
        if err != nil {
            return nil, err
        }
    }

    message := common.NewMessage()
    message.Text = request.Message
    message.ChatId = chatID
    message.ContentType = protobuf.ChatMessage_TEXT_PLAIN

    return m.sendChatMessage(context.Background(), message)
}

func (m *Messenger) SendGroupChatMessage(request *requests.SendGroupChatMessage) (*MessengerResponse, error) {
    if err := request.Validate(); err != nil {
        return nil, err
    }

    chatID := request.ID

    _, ok := m.allChats.Load(chatID)
    if !ok {
        return nil, ErrChatNotFound
    }

    message := common.NewMessage()
    message.Text = request.Message
    message.ChatId = chatID
    message.ContentType = protobuf.ChatMessage_TEXT_PLAIN

    return m.sendChatMessage(context.Background(), message)
}

func (m *Messenger) deleteCommunityMemberMessages(member string, communityID string, deleteMessages []*protobuf.DeleteCommunityMemberMessage) (*MessengerResponse, error) {
    messagesToDelete := deleteMessages
    var err error
    if len(deleteMessages) == 0 {
        messagesToDelete, err = m.persistence.GetCommunityMemberMessagesToDelete(member, communityID)
        if err != nil {
            return nil, err
        }
    }

    response := &MessengerResponse{}

    if len(messagesToDelete) == 0 {
        return response, nil
    }

    for _, messageToDelete := range messagesToDelete {
        updatedMessages, err := m.persistence.MessagesByResponseTo(messageToDelete.Id)
        if err != nil {
            return nil, err
        }
        response.AddMessages(updatedMessages)
    }

    response.AddDeletedMessages(messagesToDelete)

    messageIDs := make([]string, 0, len(messagesToDelete))

    for _, rm := range messagesToDelete {
        messageIDs = append(messageIDs, rm.Id)
    }

    if err = m.persistence.DeleteMessages(messageIDs); err != nil {
        return nil, err
    }

    return response, nil
}