810 lines
34 KiB
Nim
810 lines
34 KiB
Nim
import json, strutils, sequtils, tables, chronicles, times, sugar, algorithm
|
||
import statusgo_backend/chat as status_chat
|
||
import statusgo_backend/contacts as status_contacts
|
||
import statusgo_backend/chatCommands as status_chat_commands
|
||
import types/[message, status_update, activity_center_notification, sticker, removed_message, profile]
|
||
import types/chat as chat_type
|
||
|
||
import utils as status_utils
|
||
import stickers
|
||
import ../eventemitter
|
||
|
||
import contacts
|
||
import chat/[chat, utils]
|
||
import ens, accounts
|
||
|
||
include utils/json_utils
|
||
|
||
logScope:
|
||
topics = "chat-model"
|
||
|
||
const backToFirstChat* = "__goBackToFirstChat"
|
||
const ZERO_ADDRESS* = "0x0000000000000000000000000000000000000000"
|
||
|
||
proc buildFilter*(chat: Chat):JsonNode =
|
||
if chat.chatType == ChatType.PrivateGroupChat:
|
||
return newJNull()
|
||
result = %* { "ChatID": chat.id, "OneToOne": chat.chatType == ChatType.OneToOne }
|
||
|
||
type
|
||
ChatUpdateArgs* = ref object of Args
|
||
chats*: seq[Chat]
|
||
messages*: seq[Message]
|
||
pinnedMessages*: seq[Message]
|
||
emojiReactions*: seq[Reaction]
|
||
communities*: seq[Community]
|
||
communityMembershipRequests*: seq[CommunityMembershipRequest]
|
||
activityCenterNotifications*: seq[ActivityCenterNotification]
|
||
statusUpdates*: seq[StatusUpdate]
|
||
deletedMessages*: seq[RemovedMessage]
|
||
|
||
ChatIdArg* = ref object of Args
|
||
chatId*: string
|
||
|
||
ChannelArgs* = ref object of Args
|
||
chat*: Chat
|
||
|
||
ChatArgs* = ref object of Args
|
||
chats*: seq[Chat]
|
||
|
||
CommunityActiveChangedArgs* = ref object of Args
|
||
active*: bool
|
||
|
||
MsgsLoadedArgs* = ref object of Args
|
||
chatId*: string
|
||
messages*: seq[Message]
|
||
statusUpdates*: seq[StatusUpdate]
|
||
|
||
ActivityCenterNotificationsArgs* = ref object of Args
|
||
activityCenterNotifications*: seq[ActivityCenterNotification]
|
||
|
||
ReactionsLoadedArgs* = ref object of Args
|
||
reactions*: seq[Reaction]
|
||
|
||
MessageArgs* = ref object of Args
|
||
id*: string
|
||
channel*: string
|
||
|
||
MessageSendingSuccess* = ref object of Args
|
||
chat*: Chat
|
||
message*: Message
|
||
|
||
MarkAsReadNotificationProperties* = ref object of Args
|
||
communityId*: string
|
||
channelId*: string
|
||
notificationTypes*: seq[ActivityCenterNotificationType]
|
||
|
||
MarkAsUnreadNotificationProperties* = ref object of Args
|
||
communityId*: string
|
||
channelId*: string
|
||
notificationTypes*: seq[ActivityCenterNotificationType]
|
||
|
||
type ChatModel* = ref object
|
||
publicKey*: string
|
||
events*: EventEmitter
|
||
communitiesToFetch*: seq[string]
|
||
mailserverReady*: bool
|
||
channels*: Table[string, Chat]
|
||
msgCursor: Table[string, string]
|
||
pinnedMsgCursor: Table[string, string]
|
||
activityCenterCursor*: string
|
||
emojiCursor: Table[string, string]
|
||
lastMessageTimestamps*: Table[string, int64]
|
||
|
||
proc newChatModel*(events: EventEmitter): ChatModel =
|
||
result = ChatModel()
|
||
result.events = events
|
||
result.mailserverReady = false
|
||
result.communitiesToFetch = @[]
|
||
result.channels = initTable[string, Chat]()
|
||
result.msgCursor = initTable[string, string]()
|
||
result.pinnedMsgCursor = initTable[string, string]()
|
||
result.emojiCursor = initTable[string, string]()
|
||
result.lastMessageTimestamps = initTable[string, int64]()
|
||
|
||
proc getContacts*(self: ChatModel): Table[string, Profile] =
|
||
let (index, usedCache) = status_contacts.getContactsIndex()
|
||
if not usedCache:
|
||
let (contacts, _) = status_contacts.getContacts()
|
||
self.events.emit("contactUpdate", ContactUpdateArgs(contacts: contacts))
|
||
|
||
return index
|
||
|
||
proc update*(self: ChatModel, chats: seq[Chat], messages: seq[Message], emojiReactions: seq[Reaction], communities: seq[Community], communityMembershipRequests: seq[CommunityMembershipRequest], pinnedMessages: seq[Message], activityCenterNotifications: seq[ActivityCenterNotification], statusUpdates: seq[StatusUpdate], deletedMessages: seq[RemovedMessage]) =
|
||
for chat in chats:
|
||
self.channels[chat.id] = chat
|
||
|
||
for message in messages:
|
||
let chatId = message.chatId
|
||
let ts = times.convert(Milliseconds, Seconds, message.whisperTimestamp.parseInt())
|
||
if not self.lastMessageTimestamps.hasKey(chatId):
|
||
self.lastMessageTimestamps[chatId] = ts
|
||
else:
|
||
if self.lastMessageTimestamps[chatId] > ts:
|
||
self.lastMessageTimestamps[chatId] = ts
|
||
|
||
self.events.emit("chatUpdate", ChatUpdateArgs(messages: messages,chats: chats, emojiReactions: emojiReactions, communities: communities, communityMembershipRequests: communityMembershipRequests, pinnedMessages: pinnedMessages, activityCenterNotifications: activityCenterNotifications, statusUpdates: statusUpdates, deletedMessages: deletedMessages))
|
||
|
||
proc parseChatResponse(self: ChatModel, response: string): (seq[Chat], seq[Message]) =
|
||
var parsedResponse = parseJson(response)
|
||
var chats: seq[Chat] = @[]
|
||
var messages: seq[Message] = @[]
|
||
if parsedResponse{"result"}{"messages"} != nil:
|
||
for jsonMsg in parsedResponse["result"]["messages"]:
|
||
messages.add(jsonMsg.toMessage())
|
||
if parsedResponse{"result"}{"chats"} != nil:
|
||
for jsonChat in parsedResponse["result"]["chats"]:
|
||
let chat = jsonChat.toChat
|
||
self.channels[chat.id] = chat
|
||
chats.add(chat)
|
||
result = (chats, messages)
|
||
|
||
proc emitUpdate(self: ChatModel, response: string) =
|
||
var (chats, messages) = self.parseChatResponse(response)
|
||
self.events.emit("chatUpdate", ChatUpdateArgs(messages: messages, chats: chats))
|
||
|
||
proc removeFiltersByChatId(self: ChatModel, chatId: string, filters: JsonNode)
|
||
|
||
proc removeChatFilters(self: ChatModel, chatId: string) =
|
||
# TODO: this code should be handled by status-go / stimbus instead of the client
|
||
# Clients should not have to care about filters. For more info about filters:
|
||
# https://github.com/status-im/specs/blob/master/docs/stable/3-whisper-usage.md#keys-management
|
||
let filters = parseJson(status_chat.loadFilters(@[]))["result"]
|
||
|
||
case self.channels[chatId].chatType
|
||
of ChatType.Public:
|
||
for filter in filters:
|
||
if filter["chatId"].getStr == chatId:
|
||
status_chat.removeFilters(chatId, filter["filterId"].getStr)
|
||
of ChatType.OneToOne, ChatType.Profile:
|
||
# Check if user does not belong to any active chat group
|
||
var inGroup = false
|
||
for channel in self.channels.values:
|
||
if channel.isActive and channel.id != chatId and channel.chatType == ChatType.PrivateGroupChat:
|
||
inGroup = true
|
||
break
|
||
if not inGroup: self.removeFiltersByChatId(chatId, filters)
|
||
of ChatType.PrivateGroupChat:
|
||
for member in self.channels[chatId].members:
|
||
# Check that any of the members are not in other active group chats, or that you don’t have a one-to-one open.
|
||
var hasConversation = false
|
||
for channel in self.channels.values:
|
||
if (channel.isActive and channel.chatType == ChatType.OneToOne and channel.id == member.id) or
|
||
(channel.isActive and channel.id != chatId and channel.chatType == ChatType.PrivateGroupChat and channel.isMember(member.id)):
|
||
hasConversation = true
|
||
break
|
||
if not hasConversation: self.removeFiltersByChatId(member.id, filters)
|
||
else:
|
||
error "Unknown chat type removed", chatId
|
||
|
||
proc removeFiltersByChatId(self: ChatModel, chatId: string, filters: JsonNode) =
|
||
var partitionedTopic = ""
|
||
for filter in filters:
|
||
# Contact code filter should be removed
|
||
if filter["identity"].getStr == chatId and filter["chatId"].getStr.endsWith("-contact-code"):
|
||
status_chat.removeFilters(chatId, filter["filterId"].getStr)
|
||
|
||
# Remove partitioned topic if no other user in an active group chat or one-to-one is from the
|
||
# same partitioned topic
|
||
if filter["identity"].getStr == chatId and filter["chatId"].getStr.startsWith("contact-discovery-"):
|
||
partitionedTopic = filter["topic"].getStr
|
||
var samePartitionedTopic = false
|
||
for f in filters.filterIt(it["topic"].getStr == partitionedTopic and it["filterId"].getStr != filter["filterId"].getStr):
|
||
let fIdentity = f["identity"].getStr;
|
||
if self.channels.hasKey(fIdentity) and self.channels[fIdentity].isActive:
|
||
samePartitionedTopic = true
|
||
break
|
||
if not samePartitionedTopic:
|
||
status_chat.removeFilters(chatId, filter["filterId"].getStr)
|
||
|
||
proc hasChannel*(self: ChatModel, chatId: string): bool =
|
||
self.channels.hasKey(chatId)
|
||
|
||
proc getActiveChannel*(self: ChatModel): string =
|
||
if (self.channels.len == 0): "" else: toSeq(self.channels.values)[self.channels.len - 1].id
|
||
|
||
proc emitTopicAndJoin(self: ChatModel, chat: Chat) =
|
||
let filterResult = status_chat.loadFilters(@[buildFilter(chat)])
|
||
self.events.emit("channelJoined", ChannelArgs(chat: chat))
|
||
|
||
proc join*(self: ChatModel, chatId: string, chatType: ChatType, ensName: string = "", pubKey: string = "") =
|
||
if self.hasChannel(chatId): return
|
||
var chat = newChat(chatId, ChatType(chatType))
|
||
self.channels[chat.id] = chat
|
||
status_chat.saveChat(chatId, chatType, color=chat.color, ensName=ensName, profile=pubKey)
|
||
self.emitTopicAndJoin(chat)
|
||
|
||
proc createOneToOneChat*(self: ChatModel, publicKey: string, ensName: string = "") =
|
||
if self.hasChannel(publicKey):
|
||
# We want to show the chat to the user and for that we activate the chat
|
||
status_chat.saveChat(publicKey, ChatType.OneToOne, color=self.channels[publicKey].color, ensName=ensName)
|
||
self.emitTopicAndJoin(self.channels[publicKey])
|
||
return
|
||
|
||
var chat = newChat(publicKey, ChatType.OneToOne)
|
||
if ensName != "":
|
||
chat.name = ensName
|
||
chat.ensName = ensName
|
||
self.channels[chat.id] = chat
|
||
discard status_chat.createOneToOneChat(publicKey)
|
||
self.emitTopicAndJoin(chat)
|
||
|
||
proc createPublicChat*(self: ChatModel, chatId: string) =
|
||
if self.hasChannel(chatId): return
|
||
var chat = newChat(chatId, ChatType.Public)
|
||
self.channels[chat.id] = chat
|
||
discard status_chat.createPublicChat(chatId)
|
||
self.emitTopicAndJoin(chat)
|
||
|
||
|
||
proc requestMissingCommunityInfos*(self: ChatModel) =
|
||
if (self.communitiesToFetch.len == 0):
|
||
return
|
||
for communityId in self.communitiesToFetch:
|
||
status_chat.requestCommunityInfo(communityId)
|
||
|
||
proc sortChats(x, y: chat_type.Chat): int =
|
||
var t1 = x.lastMessage.whisperTimestamp
|
||
var t2 = y.lastMessage.whisperTimestamp
|
||
|
||
if t1 <= $x.joined:
|
||
t1 = $x.joined
|
||
if t2 <= $y.joined:
|
||
t2 = $y.joined
|
||
|
||
if t1 > t2: 1
|
||
elif t1 == t2: 0
|
||
else: -1
|
||
|
||
proc init*(self: ChatModel, pubKey: string) =
|
||
self.publicKey = pubKey
|
||
|
||
var (contacts, _) = status_contacts.getContacts()
|
||
contacts = contacts.filter(c => c.added)
|
||
var chatList = status_chat.loadChats()
|
||
chatList.sort(sortChats)
|
||
|
||
let profileUpdatesChatIds = chatList.filter(c => c.chatType == ChatType.Profile).map(c => c.id)
|
||
|
||
if chatList.filter(c => c.chatType == ChatType.Timeline).len == 0:
|
||
var timelineChannel = newChat(status_utils.getTimelineChatId(), ChatType.Timeline)
|
||
self.join(timelineChannel.id, timelineChannel.chatType)
|
||
chatList.add(timelineChannel)
|
||
|
||
let timelineChatId = status_utils.getTimelineChatId(pubKey)
|
||
|
||
if not profileUpdatesChatIds.contains(timelineChatId):
|
||
var profileUpdateChannel = newChat(timelineChatId, ChatType.Profile)
|
||
status_chat.saveChat(profileUpdateChannel.id, profileUpdateChannel.chatType, profile=pubKey)
|
||
chatList.add(profileUpdateChannel)
|
||
|
||
# For profile updates and timeline, we have to make sure that for
|
||
# each added contact, a chat has been saved for the currently logged-in
|
||
# user. Users that will use a version of Status with timeline support for the
|
||
# first time, won't have any of those otherwise.
|
||
if profileUpdatesChatIds.filter(id => id != timelineChatId).len != contacts.len:
|
||
for contact in contacts:
|
||
if not profileUpdatesChatIds.contains(status_utils.getTimelineChatId(contact.address)):
|
||
let profileUpdatesChannel = newChat(status_utils.getTimelineChatId(contact.address), ChatType.Profile)
|
||
status_chat.saveChat(profileUpdatesChannel.id, profileUpdatesChannel.chatType, ensName=contact.ensName, profile=contact.address)
|
||
chatList.add(profileUpdatesChannel)
|
||
|
||
var filters:seq[JsonNode] = @[]
|
||
for chat in chatList:
|
||
if self.hasChannel(chat.id):
|
||
continue
|
||
filters.add buildFilter(chat)
|
||
self.channels[chat.id] = chat
|
||
self.events.emit("channelLoaded", ChannelArgs(chat: chat))
|
||
|
||
if filters.len == 0: return
|
||
|
||
let filterResult = status_chat.loadFilters(filters)
|
||
|
||
self.events.emit("chatsLoaded", ChatArgs(chats: chatList))
|
||
|
||
self.events.once("mailserverAvailable") do(a: Args):
|
||
self.mailserverReady = true
|
||
self.requestMissingCommunityInfos()
|
||
|
||
proc statusUpdates*(self: ChatModel) =
|
||
let statusUpdates = status_chat.statusUpdates()
|
||
self.events.emit("messagesLoaded", MsgsLoadedArgs(statusUpdates: statusUpdates))
|
||
|
||
proc leave*(self: ChatModel, chatId: string) =
|
||
self.removeChatFilters(chatId)
|
||
|
||
if self.channels[chatId].chatType == ChatType.PrivateGroupChat:
|
||
let leaveGroupResponse = status_chat.leaveGroupChat(chatId)
|
||
self.emitUpdate(leaveGroupResponse)
|
||
|
||
discard status_chat.deactivateChat(self.channels[chatId])
|
||
|
||
self.channels.del(chatId)
|
||
discard status_chat.clearChatHistory(chatId)
|
||
self.events.emit("channelLeft", ChatIdArg(chatId: chatId))
|
||
|
||
proc clearHistory*(self: ChatModel, chatId: string) =
|
||
discard status_chat.clearChatHistory(chatId)
|
||
let chat = self.channels[chatId]
|
||
self.events.emit("chatHistoryCleared", ChannelArgs(chat: chat))
|
||
|
||
proc setActiveChannel*(self: ChatModel, chatId: string) =
|
||
self.events.emit("activeChannelChanged", ChatIdArg(chatId: chatId))
|
||
|
||
proc processMessageUpdateAfterSend(self: ChatModel, response: string): (seq[Chat], seq[Message]) =
|
||
result = self.parseChatResponse(response)
|
||
var (chats, messages) = result
|
||
if chats.len == 0 and messages.len == 0:
|
||
self.events.emit("messageSendingFailed", Args())
|
||
return
|
||
|
||
# This fixes issue#3490
|
||
var msg = messages[0]
|
||
for m in messages:
|
||
if(m.responseTo.len > 0):
|
||
msg = m
|
||
break
|
||
|
||
self.events.emit("messageSendingSuccess", MessageSendingSuccess(message: msg, chat: chats[0]))
|
||
|
||
proc sendMessage*(self: ChatModel, chatId: string, msg: string, replyTo: string = "", contentType: int = ContentType.Message.int, communityId: string = "") =
|
||
var response = status_chat.sendChatMessage(chatId, msg, replyTo, contentType, communityId)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc editMessage*(self: ChatModel, messageId: string, msg: string) =
|
||
var response = status_chat.editMessage(messageId, msg)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc sendAudio*(self: ChatModel, chatId: string, audioBase64: string, durationMs: uint64) =
|
||
var response = status_chat.sendAudioMessage(chatId, audioBase64, durationMs)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc sendImage*(self: ChatModel, chatId: string, image: string) =
|
||
var response = status_chat.sendImageMessage(chatId, image)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc sendImages*(self: ChatModel, chatId: string, images: var seq[string]) =
|
||
var response = status_chat.sendImageMessages(chatId, images)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc deleteMessageAndSend*(self: ChatModel, messageId: string) =
|
||
discard status_chat.deleteMessageAndSend(messageId)
|
||
|
||
proc sendSticker*(self: ChatModel, chatId: string, replyTo: string, sticker: Sticker) =
|
||
var response = status_chat.sendStickerMessage(chatId, replyTo, sticker)
|
||
self.events.emit("stickerSent", StickerArgs(sticker: sticker, save: true))
|
||
var (chats, messages) = self.parseChatResponse(response)
|
||
self.events.emit("chatUpdate", ChatUpdateArgs(messages: messages, chats: chats))
|
||
self.events.emit("sendingMessage", MessageArgs(id: messages[0].id, channel: messages[0].chatId))
|
||
|
||
proc addEmojiReaction*(self: ChatModel, chatId: string, messageId: string, emojiId: int) =
|
||
let reactions = status_chat.addEmojiReaction(chatId, messageId, emojiId)
|
||
self.events.emit("reactionsLoaded", ReactionsLoadedArgs(reactions: reactions))
|
||
|
||
proc removeEmojiReaction*(self: ChatModel, emojiReactionId: string) =
|
||
let reactions = status_chat.removeEmojiReaction(emojiReactionId)
|
||
self.events.emit("reactionsLoaded", ReactionsLoadedArgs(reactions: reactions))
|
||
|
||
proc onMarkMessagesRead(self: ChatModel, response: string, chatId: string): JsonNode =
|
||
result = parseJson(response)
|
||
if self.channels.hasKey(chatId):
|
||
self.channels[chatId].unviewedMessagesCount = 0
|
||
self.channels[chatId].mentionsCount = 0
|
||
self.events.emit("channelUpdate", ChatUpdateArgs(messages: @[], chats: @[self.channels[chatId]]))
|
||
|
||
proc onAsyncMarkMessagesRead*(self: ChatModel, response: string) =
|
||
let parsedResponse = parseJson(response)
|
||
discard self.onMarkMessagesRead(parsedResponse{"response"}.getStr, parsedResponse{"chatId"}.getStr)
|
||
|
||
proc markAllChannelMessagesRead*(self: ChatModel, chatId: string): JsonNode =
|
||
var response = status_chat.markAllRead(chatId)
|
||
return self.onMarkMessagesRead(response, chatId)
|
||
|
||
proc markMessagesSeen*(self: ChatModel, chatId: string, messageIds: seq[string]): JsonNode =
|
||
var response = status_chat.markMessagesSeen(chatId, messageIds)
|
||
return self.onMarkMessagesRead(response, chatId)
|
||
|
||
proc confirmJoiningGroup*(self: ChatModel, chatId: string) =
|
||
var response = status_chat.confirmJoiningGroup(chatId)
|
||
self.emitUpdate(response)
|
||
|
||
proc renameGroup*(self: ChatModel, chatId: string, newName: string) =
|
||
var response = status_chat.renameGroup(chatId, newName)
|
||
self.emitUpdate(response)
|
||
|
||
proc getUserName*(self: ChatModel, id: string, defaultUserName: string):string =
|
||
let contacts = self.getContacts()
|
||
if(contacts.hasKey(id)):
|
||
return userNameOrAlias(contacts[id])
|
||
else:
|
||
return defaultUserName
|
||
|
||
proc processGroupChatCreation*(self: ChatModel, result: string) =
|
||
var response = parseJson(result)
|
||
var (chats, messages) = formatChatUpdate(response)
|
||
let chat = chats[0]
|
||
self.channels[chat.id] = chat
|
||
self.events.emit("chatUpdate", ChatUpdateArgs(messages: messages, chats: chats))
|
||
self.events.emit("activeChannelChanged", ChatIdArg(chatId: chat.id))
|
||
|
||
proc createGroup*(self: ChatModel, groupName: string, pubKeys: seq[string]) =
|
||
var result = status_chat.createGroup(groupName, pubKeys)
|
||
self.processGroupChatCreation(result)
|
||
|
||
proc createGroupChatFromInvitation*(self: ChatModel, groupName: string, chatID: string, adminPK: string) =
|
||
var result = status_chat.createGroupChatFromInvitation(groupName, chatID, adminPK)
|
||
self.processGroupChatCreation(result)
|
||
|
||
proc addGroupMembers*(self: ChatModel, chatId: string, pubKeys: seq[string]) =
|
||
var response = status_chat.addGroupMembers(chatId, pubKeys)
|
||
self.emitUpdate(response)
|
||
|
||
proc kickGroupMember*(self: ChatModel, chatId: string, pubKey: string) =
|
||
var response = status_chat.kickGroupMember(chatId, pubKey)
|
||
self.emitUpdate(response)
|
||
|
||
proc makeAdmin*(self: ChatModel, chatId: string, pubKey: string) =
|
||
var response = status_chat.makeAdmin(chatId, pubKey)
|
||
self.emitUpdate(response)
|
||
|
||
proc resendMessage*(self: ChatModel, messageId: string) =
|
||
discard status_chat.reSendChatMessage(messageId)
|
||
|
||
proc muteChat*(self: ChatModel, chat: Chat) =
|
||
discard status_chat.muteChat(chat.id)
|
||
self.events.emit("chatUpdate", ChatUpdateArgs(messages: @[], chats: @[chat]))
|
||
|
||
proc unmuteChat*(self: ChatModel, chat: Chat) =
|
||
discard status_chat.unmuteChat(chat.id)
|
||
self.events.emit("chatUpdate", ChatUpdateArgs(messages: @[], chats: @[chat]))
|
||
|
||
proc processUpdateForTransaction*(self: ChatModel, messageId: string, response: string) =
|
||
var (chats, messages) = self.processMessageUpdateAfterSend(response)
|
||
self.events.emit("messageDeleted", MessageArgs(id: messageId, channel: chats[0].id))
|
||
|
||
proc acceptRequestAddressForTransaction*(self: ChatModel, messageId: string, address: string) =
|
||
let response = status_chat_commands.acceptRequestAddressForTransaction(messageId, address)
|
||
self.processUpdateForTransaction(messageId, response)
|
||
|
||
proc declineRequestAddressForTransaction*(self: ChatModel, messageId: string) =
|
||
let response = status_chat_commands.declineRequestAddressForTransaction(messageId)
|
||
self.processUpdateForTransaction(messageId, response)
|
||
|
||
proc declineRequestTransaction*(self: ChatModel, messageId: string) =
|
||
let response = status_chat_commands.declineRequestTransaction(messageId)
|
||
self.processUpdateForTransaction(messageId, response)
|
||
|
||
proc requestAddressForTransaction*(self: ChatModel, chatId: string, fromAddress: string, amount: string, tokenAddress: string) =
|
||
let address = if (tokenAddress == ZERO_ADDRESS): "" else: tokenAddress
|
||
let response = status_chat_commands.requestAddressForTransaction(chatId, fromAddress, amount, address)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc acceptRequestTransaction*(self: ChatModel, transactionHash: string, messageId: string, signature: string) =
|
||
let response = status_chat_commands.acceptRequestTransaction(transactionHash, messageId, signature)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc requestTransaction*(self: ChatModel, chatId: string, fromAddress: string, amount: string, tokenAddress: string) =
|
||
let address = if (tokenAddress == ZERO_ADDRESS): "" else: tokenAddress
|
||
let response = status_chat_commands.requestTransaction(chatId, fromAddress, amount, address)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc getAllComunities*(self: ChatModel): seq[Community] =
|
||
result = status_chat.getAllComunities()
|
||
|
||
proc getJoinedComunities*(self: ChatModel): seq[Community] =
|
||
result = status_chat.getJoinedComunities()
|
||
|
||
proc createCommunity*(self: ChatModel, name: string, description: string, access: int, ensOnly: bool, color: string, imageUrl: string, aX: int, aY: int, bX: int, bY: int): Community =
|
||
result = status_chat.createCommunity(name, description, access, ensOnly, color, imageUrl, aX, aY, bX, bY)
|
||
|
||
proc editCommunity*(self: ChatModel, id: string, name: string, description: string, access: int, ensOnly: bool, color: string, imageUrl: string, aX: int, aY: int, bX: int, bY: int): Community =
|
||
result = status_chat.editCommunity(id, name, description, access, ensOnly, color, imageUrl, aX, aY, bX, bY)
|
||
|
||
proc createCommunityChannel*(self: ChatModel, communityId: string, name: string, description: string): Chat =
|
||
result = status_chat.createCommunityChannel(communityId, name, description)
|
||
|
||
proc editCommunityChannel*(self: ChatModel, communityId: string, channelId: string, name: string, description: string, categoryId: string, position: int): Chat =
|
||
result = status_chat.editCommunityChannel(communityId, channelId, name, description, categoryId, position)
|
||
|
||
proc deleteCommunityChat*(self: ChatModel, communityId: string, channelId: string) =
|
||
status_chat.deleteCommunityChat(communityId, channelId)
|
||
|
||
proc reorderCommunityCategories*(self: ChatModel, communityId: string, categoryId: string, position: int) =
|
||
status_chat.reorderCommunityCategories(communityId, categoryId, position)
|
||
|
||
proc createCommunityCategory*(self: ChatModel, communityId: string, name: string, channels: seq[string]): CommunityCategory =
|
||
result = status_chat.createCommunityCategory(communityId, name, channels)
|
||
|
||
proc editCommunityCategory*(self: ChatModel, communityId: string, categoryId: string, name: string, channels: seq[string]) =
|
||
status_chat.editCommunityCategory(communityId, categoryId, name, channels)
|
||
|
||
proc deleteCommunityCategory*(self: ChatModel, communityId: string, categoryId: string) =
|
||
status_chat.deleteCommunityCategory(communityId, categoryId)
|
||
|
||
proc reorderCommunityChannel*(self: ChatModel, communityId: string, categoryId: string, chatId: string, position: int) =
|
||
status_chat.reorderCommunityChat(communityId, categoryId, chatId, position)
|
||
|
||
proc joinCommunity*(self: ChatModel, communityId: string) =
|
||
status_chat.joinCommunity(communityId)
|
||
|
||
proc requestCommunityInfo*(self: ChatModel, communityId: string) =
|
||
if (not self.mailserverReady):
|
||
self.communitiesToFetch.add(communityId)
|
||
self.communitiesToFetch = self.communitiesToFetch.deduplicate()
|
||
return
|
||
status_chat.requestCommunityInfo(communityId)
|
||
|
||
proc leaveCommunity*(self: ChatModel, communityId: string) =
|
||
status_chat.leaveCommunity(communityId)
|
||
|
||
proc inviteUserToCommunity*(self: ChatModel, communityId: string, pubKey: string) =
|
||
let response = status_chat.inviteUsersToCommunity(communityId, @[pubKey])
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc inviteUsersToCommunity*(self: ChatModel, communityId: string, pubKeys: seq[string]) =
|
||
let response = status_chat.inviteUsersToCommunity(communityId, pubKeys)
|
||
discard self.processMessageUpdateAfterSend(response)
|
||
|
||
proc removeUserFromCommunity*(self: ChatModel, communityId: string, pubKey: string) =
|
||
status_chat.removeUserFromCommunity(communityId, pubKey)
|
||
|
||
proc banUserFromCommunity*(self: ChatModel, pubKey: string, communityId: string): string =
|
||
return status_chat.banUserFromCommunity(pubKey, communityId)
|
||
|
||
proc exportCommunity*(self: ChatModel, communityId: string): string =
|
||
result = status_chat.exportCommunity(communityId)
|
||
|
||
proc importCommunity*(self: ChatModel, communityKey: string): string =
|
||
result = status_chat.importCommunity(communityKey)
|
||
|
||
proc requestToJoinCommunity*(self: ChatModel, communityKey: string, ensName: string): seq[CommunityMembershipRequest] =
|
||
status_chat.requestToJoinCommunity(communityKey, ensName)
|
||
|
||
proc acceptRequestToJoinCommunity*(self: ChatModel, requestId: string) =
|
||
status_chat.acceptRequestToJoinCommunity(requestId)
|
||
|
||
proc declineRequestToJoinCommunity*(self: ChatModel, requestId: string) =
|
||
status_chat.declineRequestToJoinCommunity(requestId)
|
||
|
||
proc pendingRequestsToJoinForCommunity*(self: ChatModel, communityKey: string): seq[CommunityMembershipRequest] =
|
||
result = status_chat.pendingRequestsToJoinForCommunity(communityKey)
|
||
|
||
proc setCommunityMuted*(self: ChatModel, communityId: string, muted: bool) =
|
||
status_chat.setCommunityMuted(communityId, muted)
|
||
|
||
proc myPendingRequestsToJoin*(self: ChatModel): seq[CommunityMembershipRequest] =
|
||
result = status_chat.myPendingRequestsToJoin()
|
||
|
||
proc setPinMessage*(self: ChatModel, messageId: string, chatId: string, pinned: bool) =
|
||
status_chat.setPinMessage(messageId, chatId, pinned)
|
||
|
||
proc activityCenterNotifications*(self: ChatModel, initialLoad: bool = true) =
|
||
# Notifications were already loaded, since cursor will
|
||
# be nil/empty if there are no more notifs
|
||
if(not initialLoad and self.activityCenterCursor == ""): return
|
||
|
||
let activityCenterNotificationsTuple = status_chat.activityCenterNotification(self.activityCenterCursor)
|
||
self.activityCenterCursor = activityCenterNotificationsTuple[0];
|
||
|
||
self.events.emit("activityCenterNotificationsLoaded", ActivityCenterNotificationsArgs(activityCenterNotifications: activityCenterNotificationsTuple[1]))
|
||
|
||
proc activityCenterNotifications*(self: ChatModel, cursor: string = "", activityCenterNotifications: seq[ActivityCenterNotification]) =
|
||
self.activityCenterCursor = cursor
|
||
|
||
self.events.emit("activityCenterNotificationsLoaded", ActivityCenterNotificationsArgs(activityCenterNotifications: activityCenterNotifications))
|
||
|
||
proc markAllActivityCenterNotificationsRead*(self: ChatModel): string =
|
||
try:
|
||
status_chat.markAllActivityCenterNotificationsRead()
|
||
except Exception as e:
|
||
error "Error marking all as read", msg = e.msg
|
||
result = e.msg
|
||
|
||
# This proc should accept ActivityCenterNotificationType in order to clear all notifications
|
||
# per type, that's why we have this part here. If we add all types to notificationsType that
|
||
# means that we need to clear all notifications for all types.
|
||
var types : seq[ActivityCenterNotificationType]
|
||
for t in ActivityCenterNotificationType:
|
||
types.add(t)
|
||
|
||
self.events.emit("markNotificationsAsRead", MarkAsReadNotificationProperties(notificationTypes: types))
|
||
|
||
proc markActivityCenterNotificationRead*(self: ChatModel, notificationId: string,
|
||
markAsReadProps: MarkAsReadNotificationProperties): string =
|
||
try:
|
||
status_chat.markActivityCenterNotificationsRead(@[notificationId])
|
||
except Exception as e:
|
||
error "Error marking as read", msg = e.msg
|
||
result = e.msg
|
||
|
||
self.events.emit("markNotificationsAsRead", markAsReadProps)
|
||
|
||
proc markActivityCenterNotificationUnread*(self: ChatModel, notificationId: string,
|
||
markAsUnreadProps: MarkAsUnreadNotificationProperties): string =
|
||
try:
|
||
status_chat.markActivityCenterNotificationsUnread(@[notificationId])
|
||
except Exception as e:
|
||
error "Error marking as unread", msg = e.msg
|
||
result = e.msg
|
||
|
||
self.events.emit("markNotificationsAsUnread", markAsUnreadProps)
|
||
|
||
proc acceptActivityCenterNotifications*(self: ChatModel, ids: seq[string]): string =
|
||
try:
|
||
let response = status_chat.acceptActivityCenterNotifications(ids)
|
||
|
||
let (chats, messages) = self.parseChatResponse(response)
|
||
self.events.emit("chatUpdate", ChatUpdateArgs(messages: messages, chats: chats))
|
||
|
||
except Exception as e:
|
||
error "Error marking as accepted", msg = e.msg
|
||
result = e.msg
|
||
|
||
proc dismissActivityCenterNotifications*(self: ChatModel, ids: seq[string]): string =
|
||
try:
|
||
discard status_chat.dismissActivityCenterNotifications(ids)
|
||
except Exception as e:
|
||
error "Error marking as dismissed", msg = e.msg
|
||
result = e.msg
|
||
|
||
proc unreadActivityCenterNotificationsCount*(self: ChatModel): int =
|
||
status_chat.unreadActivityCenterNotificationsCount()
|
||
|
||
proc getLinkPreviewData*(link: string, success: var bool): JsonNode =
|
||
result = status_chat.getLinkPreviewData(link, success)
|
||
|
||
proc getCommunityIdForChat*(self: ChatModel, chatId: string): string =
|
||
if (not self.hasChannel(chatId)):
|
||
return ""
|
||
return self.channels[chatId].communityId
|
||
|
||
proc onAsyncSearchMessages*(self: ChatModel, response: string) =
|
||
let responseObj = response.parseJson
|
||
if (responseObj.kind != JObject):
|
||
info "search messages response is not an json object"
|
||
return
|
||
|
||
var chatId: string
|
||
discard responseObj.getProp("chatId", chatId)
|
||
|
||
var messagesObj: JsonNode
|
||
if (not responseObj.getProp("messages", messagesObj)):
|
||
info "search messages response doesn't contain messages property"
|
||
return
|
||
|
||
var messagesArray: JsonNode
|
||
if (not messagesObj.getProp("messages", messagesArray)):
|
||
info "search messages response doesn't contain messages array"
|
||
return
|
||
|
||
var messages: seq[Message] = @[]
|
||
if (messagesArray.kind == JArray):
|
||
for jsonMsg in messagesArray:
|
||
messages.add(jsonMsg.toMessage())
|
||
|
||
self.events.emit("searchMessagesLoaded", MsgsLoadedArgs(chatId: chatId, messages: messages))
|
||
|
||
proc onLoadMoreMessagesForChannel*(self: ChatModel, response: string) =
|
||
let responseObj = response.parseJson
|
||
if (responseObj.kind != JObject):
|
||
info "load more messages response is not an json object"
|
||
|
||
# notify view
|
||
self.events.emit("messagesLoaded", MsgsLoadedArgs())
|
||
self.events.emit("reactionsLoaded", ReactionsLoadedArgs())
|
||
self.events.emit("pinnedMessagesLoaded", MsgsLoadedArgs())
|
||
return
|
||
|
||
var chatId: string
|
||
discard responseObj.getProp("chatId", chatId)
|
||
|
||
# handling chat messages
|
||
var chatMessagesObj: JsonNode
|
||
var chatCursor: string
|
||
discard responseObj.getProp("messages", chatMessagesObj)
|
||
discard responseObj.getProp("messagesCursor", chatCursor)
|
||
|
||
self.msgCursor[chatId] = chatCursor
|
||
|
||
var messages: seq[Message] = @[]
|
||
if (chatMessagesObj.kind == JArray):
|
||
for jsonMsg in chatMessagesObj:
|
||
messages.add(jsonMsg.toMessage())
|
||
|
||
if messages.len > 0:
|
||
let lastMsgIndex = messages.len - 1
|
||
let ts = times.convert(Milliseconds, Seconds, messages[lastMsgIndex].whisperTimestamp.parseInt())
|
||
self.lastMessageTimestamps[chatId] = ts
|
||
|
||
# handling reactions
|
||
var reactionsObj: JsonNode
|
||
var reactionsCursor: string
|
||
discard responseObj.getProp("reactions", reactionsObj)
|
||
discard responseObj.getProp("reactionsCursor", reactionsCursor)
|
||
|
||
self.emojiCursor[chatId] = reactionsCursor;
|
||
|
||
var reactions: seq[Reaction] = @[]
|
||
if (reactionsObj.kind == JArray):
|
||
for jsonMsg in reactionsObj:
|
||
reactions.add(jsonMsg.toReaction)
|
||
|
||
# handling pinned messages
|
||
var pinnedMsgObj: JsonNode
|
||
var pinnedMsgCursor: string
|
||
discard responseObj.getProp("pinnedMessages", pinnedMsgObj)
|
||
discard responseObj.getProp("pinnedMessagesCursor", pinnedMsgCursor)
|
||
|
||
self.pinnedMsgCursor[chatId] = pinnedMsgCursor
|
||
|
||
var pinnedMessages: seq[Message] = @[]
|
||
if (pinnedMsgObj.kind == JArray):
|
||
for jsonMsg in pinnedMsgObj:
|
||
var msgObj: JsonNode
|
||
if(jsonMsg.getProp("message", msgObj)):
|
||
var msg: Message
|
||
msg = msgObj.toMessage()
|
||
discard jsonMsg.getProp("pinnedBy", msg.pinnedBy)
|
||
pinnedMessages.add(msg)
|
||
|
||
# notify view
|
||
self.events.emit("messagesLoaded", MsgsLoadedArgs(chatId: chatId, messages: messages))
|
||
self.events.emit("reactionsLoaded", ReactionsLoadedArgs(reactions: reactions))
|
||
self.events.emit("pinnedMessagesLoaded", MsgsLoadedArgs(chatId: chatId, messages: pinnedMessages))
|
||
|
||
proc userNameOrAlias*(self: ChatModel, pubKey: string,
|
||
prettyForm: bool = false): string =
|
||
## Returns ens name or alias, in case if prettyForm is true and ens name
|
||
## ends with ".stateofus.eth" that part will be removed.
|
||
var alias: string
|
||
let contacts = self.getContacts()
|
||
if contacts.hasKey(pubKey):
|
||
alias = ens.userNameOrAlias(contacts[pubKey])
|
||
else:
|
||
alias = generateAlias(pubKey)
|
||
|
||
if (prettyForm and alias.endsWith(".stateofus.eth")):
|
||
alias = alias[0 .. ^15]
|
||
|
||
return alias
|
||
|
||
proc chatName*(self: ChatModel, chatItem: Chat): string =
|
||
if (not chatItem.chatType.isOneToOne):
|
||
return chatItem.name
|
||
|
||
let contacts = self.getContacts()
|
||
if (contacts.hasKey(chatItem.id) and contacts[chatItem.id].hasNickname()):
|
||
return contacts[chatItem.id].localNickname
|
||
|
||
if chatItem.ensName != "":
|
||
return "@" & userName(chatItem.ensName).userName(true)
|
||
|
||
return self.userNameOrAlias(chatItem.id)
|
||
|
||
proc isMessageCursorSet*(self: ChatModel, channelId: string): bool =
|
||
self.msgCursor.hasKey(channelId)
|
||
|
||
proc getCurrentMessageCursor*(self: ChatModel, channelId: string): string =
|
||
if(not self.msgCursor.hasKey(channelId)):
|
||
self.msgCursor[channelId] = ""
|
||
|
||
return self.msgCursor[channelId]
|
||
|
||
proc isEmojiCursorSet*(self: ChatModel, channelId: string): bool =
|
||
self.emojiCursor.hasKey(channelId)
|
||
|
||
proc getCurrentEmojiCursor*(self: ChatModel, channelId: string): string =
|
||
if(not self.emojiCursor.hasKey(channelId)):
|
||
self.emojiCursor[channelId] = ""
|
||
|
||
return self.emojiCursor[channelId]
|
||
|
||
proc isPinnedMessageCursorSet*(self: ChatModel, channelId: string): bool =
|
||
self.pinnedMsgCursor.hasKey(channelId)
|
||
|
||
proc getCurrentPinnedMessageCursor*(self: ChatModel, channelId: string): string =
|
||
if(not self.pinnedMsgCursor.hasKey(channelId)):
|
||
self.pinnedMsgCursor[channelId] = ""
|
||
|
||
return self.pinnedMsgCursor[channelId] |