package chat import ( "context" "errors" "strings" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/images" "github.com/status-im/status-go/protocol" "github.com/status-im/status-go/protocol/common" "github.com/status-im/status-go/protocol/communities" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/requests" v1protocol "github.com/status-im/status-go/protocol/v1" ) var ( ErrChatNotFound = errors.New("can't find chat") ErrCommunityNotFound = errors.New("can't find community") ErrCommunitiesNotSupported = errors.New("communities are not supported") ErrChatTypeNotSupported = errors.New("chat type not supported") ) type ChannelGroupType string const Personal ChannelGroupType = "personal" const Community ChannelGroupType = "community" type PinnedMessages struct { Cursor string PinnedMessages []*common.PinnedMessage } type Member struct { // Community Role Role protobuf.CommunityMember_Roles `json:"role,omitempty"` // Joined indicates if the member has joined the group chat Joined bool `json:"joined"` } type Chat struct { ID string `json:"id"` Name string `json:"name"` Description string `json:"description"` Color string `json:"color"` Emoji string `json:"emoji"` Active bool `json:"active"` ChatType protocol.ChatType `json:"chatType"` Timestamp int64 `json:"timestamp"` LastClockValue uint64 `json:"lastClockValue"` DeletedAtClockValue uint64 `json:"deletedAtClockValue"` ReadMessagesAtClockValue uint64 `json:"readMessagesAtClockValue"` UnviewedMessagesCount uint `json:"unviewedMessagesCount"` UnviewedMentionsCount uint `json:"unviewedMentionsCount"` LastMessage *common.Message `json:"lastMessage"` Members map[string]Member `json:"members,omitempty"` MembershipUpdates []v1protocol.MembershipUpdateEvent `json:"membershipUpdateEvents"` Alias string `json:"alias,omitempty"` Identicon string `json:"identicon"` Muted bool `json:"muted"` InvitationAdmin string `json:"invitationAdmin,omitempty"` ReceivedInvitationAdmin string `json:"receivedInvitationAdmin,omitempty"` Profile string `json:"profile,omitempty"` CommunityID string `json:"communityId"` CategoryID string `json:"categoryId"` Position int32 `json:"position,omitempty"` Permissions *protobuf.CommunityPermissions `json:"permissions,omitempty"` Joined int64 `json:"joined,omitempty"` SyncedTo uint32 `json:"syncedTo,omitempty"` SyncedFrom uint32 `json:"syncedFrom,omitempty"` FirstMessageTimestamp uint32 `json:"firstMessageTimestamp,omitempty"` Highlight bool `json:"highlight,omitempty"` PinnedMessages *PinnedMessages `json:"pinnedMessages,omitempty"` CanPost bool `json:"canPost"` Base64Image string `json:"image,omitempty"` } type ChannelGroup struct { Type ChannelGroupType `json:"channelGroupType"` Name string `json:"name"` Images map[string]images.IdentityImage `json:"images"` Color string `json:"color"` Chats map[string]*Chat `json:"chats"` Categories map[string]communities.CommunityCategory `json:"categories"` EnsName string `json:"ensName"` MemberRole protobuf.CommunityMember_Roles `json:"memberRole"` Verified bool `json:"verified"` Description string `json:"description"` IntroMessage string `json:"introMessage"` OutroMessage string `json:"outroMessage"` Tags []communities.CommunityTag `json:"tags"` Permissions *protobuf.CommunityPermissions `json:"permissions"` Members map[string]*protobuf.CommunityMember `json:"members"` CanManageUsers bool `json:"canManageUsers"` Muted bool `json:"muted"` BanList []string `json:"banList"` Encrypted bool `json:"encrypted"` CommunityTokensMetadata []*protobuf.CommunityTokenMetadata `json:"communityTokensMetadata"` UnviewedMessagesCount int `json:"unviewedMessagesCount"` UnviewedMentionsCount int `json:"unviewedMentionsCount"` } func NewAPI(service *Service) *API { return &API{ s: service, } } type API struct { s *Service } func unique(communities []*communities.Community) (result []*communities.Community) { inResult := make(map[string]bool) for _, community := range communities { if _, ok := inResult[community.IDString()]; !ok { inResult[community.IDString()] = true result = append(result, community) } } return result } func (api *API) getChannelGroups(ctx context.Context, channelGroupID string) (map[string]ChannelGroup, error) { joinedCommunities, err := api.s.messenger.JoinedCommunities() if err != nil { return nil, err } spectatedCommunities, err := api.s.messenger.SpectatedCommunities() if err != nil { return nil, err } pubKey := types.EncodeHex(crypto.FromECDSAPub(api.s.messenger.IdentityPublicKey())) result := make(map[string]ChannelGroup) // Get chats from cache to get unviewed messages counts channels := api.s.messenger.Chats() totalUnviewedMessageCount := 0 totalUnviewedMentionsCount := 0 if channelGroupID == "" || channelGroupID == pubKey { chats := make(map[string]*Chat) for _, chat := range channels { if !chat.IsActivePersonalChat() { continue } if !chat.Muted || chat.UnviewedMentionsCount > 0 { totalUnviewedMessageCount += int(chat.UnviewedMessagesCount) } totalUnviewedMentionsCount += int(chat.UnviewedMentionsCount) c, err := api.toAPIChat(chat, nil, pubKey, true) if err != nil { return nil, err } chats[chat.ID] = c } result[pubKey] = ChannelGroup{ Type: Personal, Name: "", Images: make(map[string]images.IdentityImage), Color: "", Chats: chats, Categories: make(map[string]communities.CommunityCategory), EnsName: "", // Not implemented yet in communities MemberRole: protobuf.CommunityMember_ROLE_OWNER, Verified: true, Description: "", IntroMessage: "", OutroMessage: "", Tags: []communities.CommunityTag{}, Permissions: &protobuf.CommunityPermissions{}, Muted: false, CommunityTokensMetadata: []*protobuf.CommunityTokenMetadata{}, UnviewedMessagesCount: totalUnviewedMessageCount, UnviewedMentionsCount: totalUnviewedMentionsCount, } } if channelGroupID == pubKey { // They asked for the personal channel group only, so we return now return result, nil } for _, community := range unique(append(joinedCommunities, spectatedCommunities...)) { if channelGroupID != "" && channelGroupID != community.IDString() { continue } totalUnviewedMessageCount = 0 totalUnviewedMentionsCount = 0 for _, chat := range channels { if chat.CommunityID != community.IDString() || !chat.Active { continue } if !chat.Muted || chat.UnviewedMentionsCount > 0 { totalUnviewedMessageCount += int(chat.UnviewedMessagesCount) } totalUnviewedMentionsCount += int(chat.UnviewedMentionsCount) } chGrp := ChannelGroup{ Type: Community, Name: community.Name(), Color: community.Color(), Images: make(map[string]images.IdentityImage), Chats: make(map[string]*Chat), Categories: make(map[string]communities.CommunityCategory), MemberRole: community.MemberRole(community.MemberIdentity()), Verified: community.Verified(), Description: community.DescriptionText(), IntroMessage: community.IntroMessage(), OutroMessage: community.OutroMessage(), Tags: community.Tags(), Permissions: community.Description().Permissions, Members: community.Description().Members, CanManageUsers: community.CanManageUsers(community.MemberIdentity()), Muted: community.Muted(), BanList: community.Description().BanList, Encrypted: community.Encrypted(), CommunityTokensMetadata: community.Description().CommunityTokensMetadata, UnviewedMessagesCount: totalUnviewedMessageCount, UnviewedMentionsCount: totalUnviewedMentionsCount, } for t, i := range community.Images() { chGrp.Images[t] = images.IdentityImage{Name: t, Payload: i.Payload} } for _, cat := range community.Categories() { chGrp.Categories[cat.CategoryId] = communities.CommunityCategory{ ID: cat.CategoryId, Name: cat.Name, Position: int(cat.Position), } } for _, chat := range channels { if chat.CommunityID == community.IDString() && chat.Active { c, err := api.toAPIChat(chat, community, pubKey, true) if err != nil { return nil, err } chGrp.Chats[c.ID] = c } } result[community.IDString()] = chGrp if channelGroupID == community.IDString() { // We asked for this particular community, so we return now return result, nil } } return result, nil } func (api *API) GetChannelGroups(ctx context.Context) (map[string]ChannelGroup, error) { return api.getChannelGroups(ctx, "") } func (api *API) GetChannelGroupByID(ctx context.Context, channelGroupID string) (map[string]ChannelGroup, error) { return api.getChannelGroups(ctx, channelGroupID) } func (api *API) GetChat(ctx context.Context, communityID types.HexBytes, chatID string) (*Chat, error) { pubKey := types.EncodeHex(crypto.FromECDSAPub(api.s.messenger.IdentityPublicKey())) messengerChat, community, err := api.getChatAndCommunity(pubKey, communityID, chatID) if err != nil { return nil, err } if messengerChat == nil { return nil, ErrChatNotFound } result, err := api.toAPIChat(messengerChat, community, pubKey, false) if err != nil { return nil, err } return result, nil } func (api *API) GetMembers(ctx context.Context, communityID types.HexBytes, chatID string) (map[string]Member, error) { pubKey := types.EncodeHex(crypto.FromECDSAPub(api.s.messenger.IdentityPublicKey())) messengerChat, community, err := api.getChatAndCommunity(pubKey, communityID, chatID) if err != nil { return nil, err } return getChatMembers(messengerChat, community, pubKey) } func (api *API) JoinChat(ctx context.Context, communityID types.HexBytes, chatID string) (*Chat, error) { if len(communityID) != 0 { return nil, ErrCommunitiesNotSupported } response, err := api.s.messenger.CreatePublicChat(&requests.CreatePublicChat{ID: chatID}) if err != nil { return nil, err } pubKey := types.EncodeHex(crypto.FromECDSAPub(api.s.messenger.IdentityPublicKey())) return api.toAPIChat(response.Chats()[0], nil, pubKey, false) } func (api *API) toAPIChat(protocolChat *protocol.Chat, community *communities.Community, pubKey string, skipPinnedMessages bool) (*Chat, error) { chat := &Chat{ ID: strings.TrimPrefix(protocolChat.ID, protocolChat.CommunityID), Name: protocolChat.Name, Description: protocolChat.Description, Color: protocolChat.Color, Emoji: protocolChat.Emoji, Active: protocolChat.Active, ChatType: protocolChat.ChatType, Timestamp: protocolChat.Timestamp, LastClockValue: protocolChat.LastClockValue, DeletedAtClockValue: protocolChat.DeletedAtClockValue, ReadMessagesAtClockValue: protocolChat.ReadMessagesAtClockValue, UnviewedMessagesCount: protocolChat.UnviewedMessagesCount, UnviewedMentionsCount: protocolChat.UnviewedMentionsCount, LastMessage: protocolChat.LastMessage, MembershipUpdates: protocolChat.MembershipUpdates, Alias: protocolChat.Alias, Identicon: protocolChat.Identicon, Muted: protocolChat.Muted, InvitationAdmin: protocolChat.InvitationAdmin, ReceivedInvitationAdmin: protocolChat.ReceivedInvitationAdmin, Profile: protocolChat.Profile, CommunityID: protocolChat.CommunityID, CategoryID: protocolChat.CategoryID, Joined: protocolChat.Joined, SyncedTo: protocolChat.SyncedTo, SyncedFrom: protocolChat.SyncedFrom, FirstMessageTimestamp: protocolChat.FirstMessageTimestamp, Highlight: protocolChat.Highlight, Base64Image: protocolChat.Base64Image, } if protocolChat.OneToOne() { chat.Name = "" // Emptying since it contains non useful data } if !skipPinnedMessages { pinnedMessages, cursor, err := api.s.messenger.PinnedMessageByChatID(protocolChat.ID, "", -1) if err != nil { return nil, err } if len(pinnedMessages) != 0 { chat.PinnedMessages = &PinnedMessages{ Cursor: cursor, PinnedMessages: pinnedMessages, } } } err := chat.populateCommunityFields(community) if err != nil { return nil, err } chatMembers, err := getChatMembers(protocolChat, community, pubKey) if err != nil { return nil, err } chat.Members = chatMembers return chat, nil } func getChatMembers(sourceChat *protocol.Chat, community *communities.Community, userPubKey string) (map[string]Member, error) { result := make(map[string]Member) if sourceChat != nil { if sourceChat.ChatType == protocol.ChatTypePrivateGroupChat && len(sourceChat.Members) > 0 { for _, m := range sourceChat.Members { result[m.ID] = Member{ Role: func() protobuf.CommunityMember_Roles { if m.Admin { return protobuf.CommunityMember_ROLE_OWNER } return protobuf.CommunityMember_ROLE_NONE }(), Joined: true, } } return result, nil } if sourceChat.ChatType == protocol.ChatTypeOneToOne { result[sourceChat.ID] = Member{ Joined: true, } result[userPubKey] = Member{ Joined: true, } return result, nil } } if community != nil { for member := range community.Description().Members { pubKey, err := common.HexToPubkey(member) if err != nil { return nil, err } result[member] = Member{ Role: community.MemberRole(pubKey), Joined: community.Joined(), } } return result, nil } return nil, nil } func (api *API) getCommunityByID(id string) (*communities.Community, error) { communityID, err := hexutil.Decode(id) if err != nil { return nil, err } community, err := api.s.messenger.GetCommunityByID(communityID) if community == nil && err == nil { return nil, ErrCommunityNotFound } return community, err } func (chat *Chat) populateCommunityFields(community *communities.Community) error { if community == nil { return nil } commChat, exists := community.Chats()[chat.ID] if !exists { // Skip unknown community chats. They might be channels that were deleted return nil } canPost, err := community.CanMemberIdentityPost(chat.ID) if err != nil { return err } chat.CategoryID = commChat.CategoryId chat.Position = commChat.Position chat.Permissions = commChat.Permissions chat.Emoji = commChat.Identity.Emoji chat.Name = commChat.Identity.DisplayName chat.Description = commChat.Identity.Description chat.CanPost = canPost return nil } func (api *API) getChatAndCommunity(pubKey string, communityID types.HexBytes, chatID string) (*protocol.Chat, *communities.Community, error) { fullChatID := chatID if string(communityID.Bytes()) == pubKey { // Obtaining chats from personal communityID = []byte{} } if len(communityID) != 0 { id := string(communityID.Bytes()) if chatID == "" { community, err := api.getCommunityByID(id) return nil, community, err } fullChatID = id + chatID } messengerChat := api.s.messenger.Chat(fullChatID) if messengerChat == nil { return nil, nil, ErrChatNotFound } var community *communities.Community if messengerChat.CommunityID != "" { var err error community, err = api.getCommunityByID(messengerChat.CommunityID) if err != nil { return nil, nil, err } } return messengerChat, community, nil } func (api *API) EditChat(ctx context.Context, communityID types.HexBytes, chatID string, name string, color string, image images.CroppedImage) (*Chat, error) { if len(communityID) != 0 { return nil, ErrCommunitiesNotSupported } chatToEdit := api.s.messenger.Chat(chatID) if chatToEdit == nil { return nil, ErrChatNotFound } if chatToEdit.ChatType != protocol.ChatTypePrivateGroupChat { return nil, ErrChatTypeNotSupported } response, err := api.s.messenger.EditGroupChat(ctx, chatID, name, color, image) if err != nil { return nil, err } pubKey := types.EncodeHex(crypto.FromECDSAPub(api.s.messenger.IdentityPublicKey())) return api.toAPIChat(response.Chats()[0], nil, pubKey, false) }