package protocol import ( "context" "github.com/golang/protobuf/proto" "github.com/pkg/errors" "go.uber.org/zap" v1protocol "github.com/status-im/status-go/protocol/v1" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/protocol/common" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/requests" ) var errOnlyOneNotificationID = errors.New("only one notification id is supported") func toHexBytes(b [][]byte) []types.HexBytes { hb := make([]types.HexBytes, len(b)) for i, v := range b { hb[i] = types.HexBytes(v) } return hb } func fromHexBytes(hb []types.HexBytes) [][]byte { b := make([][]byte, len(hb)) for i, v := range hb { b[i] = v } return b } func (m *Messenger) ActivityCenterNotifications(request ActivityCenterNotificationsRequest) (*ActivityCenterPaginationResponse, error) { cursor, notifications, err := m.persistence.ActivityCenterNotifications(request.Cursor, request.Limit, request.ActivityTypes, request.ReadType, true) if err != nil { return nil, err } if m.httpServer != nil { for _, notification := range notifications { if notification.Message != nil { m.prepareMessage(notification.Message, m.httpServer) image := notification.Message.GetImage() if image != nil && image.AlbumId != "" { album, err := m.persistence.albumMessages(notification.Message.LocalChatID, image.AlbumId) if err != nil { return nil, err } notification.AlbumMessages = album } } if notification.AlbumMessages != nil { for _, message := range notification.AlbumMessages { m.prepareMessage(message, m.httpServer) } } } } return &ActivityCenterPaginationResponse{ Cursor: cursor, Notifications: notifications, }, nil } func (m *Messenger) ActivityCenterNotificationsCount(request ActivityCenterCountRequest) (*ActivityCenterCountResponse, error) { response := make(ActivityCenterCountResponse) for _, activityType := range request.ActivityTypes { count, err := m.persistence.ActivityCenterNotificationsCount([]ActivityCenterType{activityType}, request.ReadType, true) if err != nil { return nil, err } response[activityType] = count } return &response, nil } func (m *Messenger) HasUnseenActivityCenterNotifications() (bool, error) { seen, _, err := m.persistence.HasUnseenActivityCenterNotifications() return seen, err } func (m *Messenger) GetActivityCenterState() (*ActivityCenterState, error) { return m.persistence.GetActivityCenterState() } func (m *Messenger) MarkAsSeenActivityCenterNotifications() (*MessengerResponse, error) { response := &MessengerResponse{} s := &ActivityCenterState{ UpdatedAt: m.GetCurrentTimeInMillis(), HasSeen: true, } _, err := m.persistence.UpdateActivityCenterNotificationState(s) if err != nil { return nil, err } state, err := m.persistence.GetActivityCenterState() if err != nil { return nil, err } response.SetActivityCenterState(state) return response, nil } func (m *Messenger) MarkAllActivityCenterNotificationsRead(ctx context.Context) (*MessengerResponse, error) { ids, err := m.persistence.GetNotReadActivityCenterNotificationIds() if err != nil { return nil, err } updateAt := m.GetCurrentTimeInMillis() return m.MarkActivityCenterNotificationsRead(ctx, toHexBytes(ids), updateAt, true) } func (m *Messenger) MarkActivityCenterNotificationsRead(ctx context.Context, ids []types.HexBytes, updatedAt uint64, sync bool) (*MessengerResponse, error) { // Mark notifications as read in the database if updatedAt == 0 { updatedAt = m.GetCurrentTimeInMillis() } err := m.persistence.MarkActivityCenterNotificationsRead(ids, updatedAt) if err != nil { return nil, err } notifications, err := m.persistence.GetActivityCenterNotificationsByID(ids) if err != nil { return nil, err } response := &MessengerResponse{} repliesAndMentions := make(map[string][]string) // When marking as read Mention or Reply notification, the corresponding chat message should also be read. for _, notification := range notifications { response.AddActivityCenterNotification(notification) if notification.Message != nil && (notification.Type == ActivityCenterNotificationTypeMention || notification.Type == ActivityCenterNotificationTypeReply) { repliesAndMentions[notification.ChatID] = append(repliesAndMentions[notification.ChatID], notification.Message.ID) } } // Mark messages as seen for chatID, messageIDs := range repliesAndMentions { _, _, err := m.markMessagesSeenImpl(chatID, messageIDs) if err != nil { return nil, err } } state, err := m.persistence.GetActivityCenterState() if err != nil { return nil, err } response.SetActivityCenterState(state) if !sync { response2, err := m.processActivityCenterNotifications(notifications, true) if err != nil { return nil, err } if err = response2.Merge(response); err != nil { return nil, err } return response2, nil } return response, m.syncActivityCenterReadByIDs(ctx, ids, updatedAt) } func (m *Messenger) MarkActivityCenterNotificationsUnread(ctx context.Context, ids []types.HexBytes, updatedAt uint64, sync bool) (*MessengerResponse, error) { response := &MessengerResponse{} notifications, err := m.persistence.MarkActivityCenterNotificationsUnread(ids, updatedAt) if err != nil { return nil, err } state, err := m.persistence.GetActivityCenterState() if err != nil { return nil, err } response.SetActivityCenterState(state) if sync && len(notifications) > 0 { err = m.syncActivityCenterUnreadByIDs(ctx, ids, updatedAt) } return response, err } func (m *Messenger) MarkActivityCenterNotificationsDeleted(ctx context.Context, ids []types.HexBytes, updatedAt uint64, sync bool) (*MessengerResponse, error) { response := &MessengerResponse{} notifications, err := m.persistence.MarkActivityCenterNotificationsDeleted(ids, updatedAt) if err != nil { return nil, err } response.AddActivityCenterNotifications(notifications) state, err := m.persistence.GetActivityCenterState() if err != nil { return nil, err } response.SetActivityCenterState(state) if sync { err = m.syncActivityCenterDeletedByIDs(ctx, ids, updatedAt) if err != nil { m.logger.Error("MarkActivityCenterNotificationsDeleted, failed to sync activity center notifications as deleted", zap.Error(err)) return nil, err } } return response, nil } func (m *Messenger) addActivityCenterNotification(response *MessengerResponse, notification *ActivityCenterNotification, syncAction func(context.Context, []types.HexBytes, uint64) error) error { _, err := m.persistence.SaveActivityCenterNotification(notification, true) if err != nil { m.logger.Error("failed to save notification", zap.Error(err)) return err } state, err := m.persistence.GetActivityCenterState() if err != nil { m.logger.Error("failed to obtain activity center state", zap.Error(err)) return err } response.AddActivityCenterNotification(notification) response.SetActivityCenterState(state) if syncAction != nil { //TODO a way to pass context err = syncAction(context.TODO(), []types.HexBytes{notification.ID}, notification.UpdatedAt) if err != nil { m.logger.Error("[addActivityCenterNotification] failed to sync activity center notification", zap.Error(err)) return err } } return nil } func (m *Messenger) syncActivityCenterReadByIDs(ctx context.Context, ids []types.HexBytes, clock uint64) error { syncMessage := &protobuf.SyncActivityCenterRead{ Clock: clock, Ids: fromHexBytes(ids), } encodedMessage, err := proto.Marshal(syncMessage) if err != nil { return err } return m.sendToPairedDevices(ctx, common.RawMessage{ Payload: encodedMessage, MessageType: protobuf.ApplicationMetadataMessage_SYNC_ACTIVITY_CENTER_READ, ResendAutomatically: true, }) } func (m *Messenger) syncActivityCenterUnreadByIDs(ctx context.Context, ids []types.HexBytes, clock uint64) error { syncMessage := &protobuf.SyncActivityCenterUnread{ Clock: clock, Ids: fromHexBytes(ids), } encodedMessage, err := proto.Marshal(syncMessage) if err != nil { return err } return m.sendToPairedDevices(ctx, common.RawMessage{ Payload: encodedMessage, MessageType: protobuf.ApplicationMetadataMessage_SYNC_ACTIVITY_CENTER_UNREAD, ResendAutomatically: true, }) } func (m *Messenger) processActivityCenterNotifications(notifications []*ActivityCenterNotification, addNotifications bool) (*MessengerResponse, error) { response := &MessengerResponse{} var chats []*Chat for _, notification := range notifications { if notification.ChatID != "" { chat, ok := m.allChats.Load(notification.ChatID) if !ok { // This should not really happen, but ignore just in case it was deleted in the meantime m.logger.Warn("chat not found") continue } chat.Active = true if chat.PrivateGroupChat() { // Send Joined message for backward compatibility _, err := m.ConfirmJoiningGroup(context.Background(), chat.ID) if err != nil { m.logger.Error("failed to join group", zap.Error(err)) return nil, err } } chats = append(chats, chat) response.AddChat(chat) } if addNotifications { response.AddActivityCenterNotification(notification) } } if len(chats) != 0 { err := m.saveChats(chats) if err != nil { return nil, err } } return response, nil } func (m *Messenger) processAcceptedActivityCenterNotifications(ctx context.Context, notifications []*ActivityCenterNotification, sync bool) (*MessengerResponse, error) { ids := make([]types.HexBytes, len(notifications)) for i := range notifications { ids[i] = notifications[i].ID } state, err := m.persistence.GetActivityCenterState() if err != nil { return nil, err } if sync { err = m.syncActivityCenterAcceptedByIDs(ctx, ids, m.GetCurrentTimeInMillis()) if err != nil { return nil, err } } response, err := m.processActivityCenterNotifications(notifications, !sync) if err != nil { return nil, err } response.SetActivityCenterState(state) return response, nil } func (m *Messenger) AcceptActivityCenterNotificationsForInvitesFromUser(ctx context.Context, userPublicKey string, updatedAt uint64) ([]*ActivityCenterNotification, error) { notifications, err := m.persistence.AcceptActivityCenterNotificationsForInvitesFromUser(userPublicKey, updatedAt) if err != nil { return nil, err } if len(notifications) > 0 { err = m.syncActivityCenterAccepted(ctx, notifications, updatedAt) } return notifications, err } func (m *Messenger) syncActivityCenterAccepted(ctx context.Context, notifications []*ActivityCenterNotification, updatedAt uint64) error { ids := make([]types.HexBytes, len(notifications)) for _, notification := range notifications { ids = append(ids, notification.ID) } return m.syncActivityCenterAcceptedByIDs(ctx, ids, updatedAt) } func (m *Messenger) syncActivityCenterAcceptedByIDs(ctx context.Context, ids []types.HexBytes, clock uint64) error { syncMessage := &protobuf.SyncActivityCenterAccepted{ Clock: clock, Ids: fromHexBytes(ids), } encodedMessage, err := proto.Marshal(syncMessage) if err != nil { return err } return m.sendToPairedDevices(ctx, common.RawMessage{ Payload: encodedMessage, MessageType: protobuf.ApplicationMetadataMessage_SYNC_ACTIVITY_CENTER_ACCEPTED, ResendAutomatically: true, }) } func (m *Messenger) syncActivityCenterCommunityRequestDecisionAdapter(ctx context.Context, ids []types.HexBytes, _ uint64) error { if len(ids) != 1 { return errOnlyOneNotificationID } id := ids[0] notification, err := m.persistence.GetActivityCenterNotificationByID(id) if err != nil { return err } return m.syncActivityCenterCommunityRequestDecision(ctx, notification) } func (m *Messenger) syncActivityCenterCommunityRequestDecision(ctx context.Context, notification *ActivityCenterNotification) error { var decision protobuf.SyncActivityCenterCommunityRequestDecisionCommunityRequestDecision if notification.Accepted { decision = protobuf.SyncActivityCenterCommunityRequestDecision_ACCEPTED } else if notification.Dismissed { decision = protobuf.SyncActivityCenterCommunityRequestDecision_DECLINED } else { return errors.New("[syncActivityCenterCommunityRequestDecision] notification is not accepted or dismissed") } syncMessage := &protobuf.SyncActivityCenterCommunityRequestDecision{ Clock: notification.UpdatedAt, Id: notification.ID, MembershipStatus: uint32(notification.MembershipStatus), Decision: decision, } encodedMessage, err := proto.Marshal(syncMessage) if err != nil { return err } return m.sendToPairedDevices(ctx, common.RawMessage{ Payload: encodedMessage, MessageType: protobuf.ApplicationMetadataMessage_SYNC_ACTIVITY_CENTER_COMMUNITY_REQUEST_DECISION, ResendAutomatically: true, }) } func (m *Messenger) AcceptActivityCenterNotifications(ctx context.Context, ids []types.HexBytes, updatedAt uint64, sync bool) (*MessengerResponse, error) { if len(ids) == 0 { return nil, errors.New("notifications ids are not provided") } notifications, err := m.persistence.AcceptActivityCenterNotifications(ids, updatedAt) if err != nil { return nil, err } return m.processAcceptedActivityCenterNotifications(ctx, notifications, sync) } func (m *Messenger) DismissAllActivityCenterNotificationsFromUser(ctx context.Context, userPublicKey string, updatedAt uint64) ([]*ActivityCenterNotification, error) { notifications, err := m.persistence.DismissAllActivityCenterNotificationsFromUser(userPublicKey, updatedAt) if err != nil { return nil, err } if notifications == nil { return nil, nil } return notifications, m.syncActivityCenterDismissed(ctx, notifications, updatedAt) } func (m *Messenger) DismissActivityCenterNotificationsByCommunity(ctx context.Context, request *requests.DismissCommunityNotifications) error { err := request.Validate() if err != nil { return err } updatedAt := m.GetCurrentTimeInMillis() notifications, err := m.persistence.DismissActivityCenterNotificationsByCommunity(request.CommunityID.String(), updatedAt) if err != nil { return err } return m.syncActivityCenterDismissed(ctx, notifications, updatedAt) } func (m *Messenger) DismissAllActivityCenterNotificationsFromCommunity(ctx context.Context, communityID string, updatedAt uint64) ([]*ActivityCenterNotification, error) { notifications, err := m.persistence.DismissAllActivityCenterNotificationsFromCommunity(communityID, updatedAt) if err != nil { return nil, err } return notifications, m.syncActivityCenterDismissed(ctx, notifications, updatedAt) } func (m *Messenger) DismissAllActivityCenterNotificationsFromChatID(ctx context.Context, chatID string, updatedAt uint64) ([]*ActivityCenterNotification, error) { notifications, err := m.persistence.DismissAllActivityCenterNotificationsFromChatID(chatID, updatedAt) if err != nil { return nil, err } return notifications, m.syncActivityCenterDismissed(ctx, notifications, updatedAt) } func (m *Messenger) syncActivityCenterDeleted(ctx context.Context, notifications []*ActivityCenterNotification, updatedAt uint64) error { ids := make([]types.HexBytes, len(notifications)) for _, notification := range notifications { ids = append(ids, notification.ID) } return m.syncActivityCenterDeletedByIDs(ctx, ids, updatedAt) } func (m *Messenger) syncActivityCenterDeletedByIDs(ctx context.Context, ids []types.HexBytes, clock uint64) error { syncMessage := &protobuf.SyncActivityCenterDeleted{ Clock: clock, Ids: fromHexBytes(ids), } encodedMessage, err := proto.Marshal(syncMessage) if err != nil { return err } return m.sendToPairedDevices(ctx, common.RawMessage{ Payload: encodedMessage, MessageType: protobuf.ApplicationMetadataMessage_SYNC_ACTIVITY_CENTER_DELETED, ResendAutomatically: true, }) } func (m *Messenger) syncActivityCenterDismissed(ctx context.Context, notifications []*ActivityCenterNotification, updatedAt uint64) error { ids := make([]types.HexBytes, len(notifications)) for _, notification := range notifications { ids = append(ids, notification.ID) } return m.syncActivityCenterDismissedByIDs(ctx, ids, updatedAt) } func (m *Messenger) syncActivityCenterDismissedByIDs(ctx context.Context, ids []types.HexBytes, clock uint64) error { syncMessage := &protobuf.SyncActivityCenterDismissed{ Clock: clock, Ids: fromHexBytes(ids), } encodedMessage, err := proto.Marshal(syncMessage) if err != nil { return err } return m.sendToPairedDevices(ctx, common.RawMessage{ Payload: encodedMessage, MessageType: protobuf.ApplicationMetadataMessage_SYNC_ACTIVITY_CENTER_DISMISSED, ResendAutomatically: true, }) } func (m *Messenger) DismissActivityCenterNotifications(ctx context.Context, ids []types.HexBytes, updatedAt uint64, sync bool) (*MessengerResponse, error) { if updatedAt == 0 { updatedAt = m.GetCurrentTimeInMillis() } err := m.persistence.DismissActivityCenterNotifications(ids, updatedAt) if err != nil { return nil, err } state, err := m.persistence.GetActivityCenterState() if err != nil { return nil, err } response := &MessengerResponse{} response.SetActivityCenterState(state) if !sync { notifications, err := m.persistence.GetActivityCenterNotificationsByID(ids) if err != nil { return nil, err } response2, err := m.processActivityCenterNotifications(notifications, true) if err != nil { return nil, err } err = response2.Merge(response) return response, err } return response, m.syncActivityCenterDismissedByIDs(ctx, ids, updatedAt) } func (m *Messenger) ActivityCenterNotification(id types.HexBytes) (*ActivityCenterNotification, error) { notification, err := m.persistence.GetActivityCenterNotificationByID(id) if err != nil { return nil, err } if notification.Message != nil { image := notification.Message.GetImage() if image != nil && image.AlbumId != "" { album, err := m.persistence.albumMessages(notification.Message.LocalChatID, image.AlbumId) if err != nil { return nil, err } notification.AlbumMessages = album } } return notification, nil } func (m *Messenger) HandleSyncActivityCenterRead(state *ReceivedMessageState, message *protobuf.SyncActivityCenterRead, statusMessage *v1protocol.StatusMessage) error { resp, err := m.MarkActivityCenterNotificationsRead(context.TODO(), toHexBytes(message.Ids), message.Clock, false) if err != nil { return err } return state.Response.Merge(resp) } func (m *Messenger) HandleSyncActivityCenterUnread(state *ReceivedMessageState, message *protobuf.SyncActivityCenterUnread, statusMessage *v1protocol.StatusMessage) error { resp, err := m.MarkActivityCenterNotificationsUnread(context.TODO(), toHexBytes(message.Ids), message.Clock, false) if err != nil { return err } return state.Response.Merge(resp) } func (m *Messenger) HandleSyncActivityCenterDeleted(state *ReceivedMessageState, message *protobuf.SyncActivityCenterDeleted, statusMessage *v1protocol.StatusMessage) error { response, err := m.MarkActivityCenterNotificationsDeleted(context.TODO(), toHexBytes(message.Ids), message.Clock, false) if err != nil { return err } return state.Response.Merge(response) } func (m *Messenger) HandleSyncActivityCenterAccepted(state *ReceivedMessageState, message *protobuf.SyncActivityCenterAccepted, statusMessage *v1protocol.StatusMessage) error { resp, err := m.AcceptActivityCenterNotifications(context.TODO(), toHexBytes(message.Ids), message.Clock, false) if err != nil { return err } return state.Response.Merge(resp) } func (m *Messenger) HandleSyncActivityCenterDismissed(state *ReceivedMessageState, message *protobuf.SyncActivityCenterDismissed, statusMessage *v1protocol.StatusMessage) error { resp, err := m.DismissActivityCenterNotifications(context.TODO(), toHexBytes(message.Ids), message.Clock, false) if err != nil { return err } return state.Response.Merge(resp) } func (m *Messenger) HandleSyncActivityCenterCommunityRequestDecision(state *ReceivedMessageState, a *protobuf.SyncActivityCenterCommunityRequestDecision, statusMessage *v1protocol.StatusMessage) error { notification, err := m.persistence.GetActivityCenterNotificationByID(a.Id) if err != nil { return err } if notification == nil { return errors.New("[HandleSyncActivityCenterCommunityRequestDecision] notification not found") } notification.MembershipStatus = ActivityCenterMembershipStatus(a.MembershipStatus) notification.UpdatedAt = a.Clock if a.Decision == protobuf.SyncActivityCenterCommunityRequestDecision_DECLINED { notification.Dismissed = true } else if a.Decision == protobuf.SyncActivityCenterCommunityRequestDecision_ACCEPTED { notification.Accepted = true } else { return errors.New("[HandleSyncActivityCenterCommunityRequestDecision] invalid decision") } _, err = m.persistence.SaveActivityCenterNotification(notification, false) if err != nil { return err } resp := state.Response resp.AddActivityCenterNotification(notification) s, err := m.persistence.UpdateActivityCenterState(notification.UpdatedAt) if err != nil { return err } resp.SetActivityCenterState(s) return nil }