593 lines
19 KiB
Go
593 lines
19 KiB
Go
package memory
|
|
|
|
import (
|
|
"context"
|
|
"hash/fnv"
|
|
"sort"
|
|
"strings"
|
|
|
|
"telesrv/internal/domain"
|
|
)
|
|
|
|
func (s *PasswordStore) GetBusinessProfile(_ context.Context, userID int64) (domain.BusinessProfile, bool, error) {
|
|
s.mu.RLock()
|
|
profile, ok := s.businessProfiles[userID]
|
|
s.mu.RUnlock()
|
|
return cloneBusinessProfile(profile), ok, nil
|
|
}
|
|
|
|
func (s *PasswordStore) SaveBusinessProfile(_ context.Context, profile domain.BusinessProfile) error {
|
|
if profile.UserID == 0 {
|
|
return domain.ErrBusinessProfileInvalid
|
|
}
|
|
s.mu.Lock()
|
|
s.businessProfiles[profile.UserID] = cloneBusinessProfile(profile)
|
|
s.mu.Unlock()
|
|
return nil
|
|
}
|
|
|
|
func (s *PasswordStore) ListBusinessChatLinks(_ context.Context, ownerUserID int64) ([]domain.BusinessChatLink, error) {
|
|
s.mu.RLock()
|
|
slugs := append([]string(nil), s.businessChatLinkSlugs[ownerUserID]...)
|
|
out := make([]domain.BusinessChatLink, 0, len(slugs))
|
|
for _, slug := range slugs {
|
|
if link, ok := s.businessChatLinks[slug]; ok {
|
|
out = append(out, cloneBusinessChatLink(link))
|
|
}
|
|
}
|
|
s.mu.RUnlock()
|
|
sort.Slice(out, func(i, j int) bool {
|
|
if out[i].CreatedAt == out[j].CreatedAt {
|
|
return out[i].Slug < out[j].Slug
|
|
}
|
|
return out[i].CreatedAt < out[j].CreatedAt
|
|
})
|
|
return out, nil
|
|
}
|
|
|
|
func (s *PasswordStore) CreateBusinessChatLink(_ context.Context, link domain.BusinessChatLink) (domain.BusinessChatLink, error) {
|
|
if link.OwnerUserID == 0 || link.Slug == "" || link.Link == "" || link.Message == "" {
|
|
return domain.BusinessChatLink{}, domain.ErrBusinessChatLinkInvalid
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if _, exists := s.businessChatLinks[link.Slug]; exists {
|
|
return domain.BusinessChatLink{}, domain.ErrBusinessChatLinkInvalid
|
|
}
|
|
if len(s.businessChatLinkSlugs[link.OwnerUserID]) >= domain.MaxBusinessChatLinks {
|
|
return domain.BusinessChatLink{}, domain.ErrBusinessChatLinksTooMuch
|
|
}
|
|
link = cloneBusinessChatLink(link)
|
|
s.businessChatLinks[link.Slug] = link
|
|
s.businessChatLinkSlugs[link.OwnerUserID] = append(s.businessChatLinkSlugs[link.OwnerUserID], link.Slug)
|
|
return cloneBusinessChatLink(link), nil
|
|
}
|
|
|
|
func (s *PasswordStore) UpdateBusinessChatLink(_ context.Context, ownerUserID int64, slug string, input domain.BusinessChatLinkInput) (domain.BusinessChatLink, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
link, ok := s.businessChatLinks[slug]
|
|
if !ok || link.OwnerUserID != ownerUserID {
|
|
return domain.BusinessChatLink{}, domain.ErrBusinessChatLinkNotFound
|
|
}
|
|
link.Message = input.Message
|
|
link.Entities = append([]domain.MessageEntity(nil), input.Entities...)
|
|
link.Title = input.Title
|
|
s.businessChatLinks[slug] = cloneBusinessChatLink(link)
|
|
return cloneBusinessChatLink(link), nil
|
|
}
|
|
|
|
func (s *PasswordStore) DeleteBusinessChatLink(_ context.Context, ownerUserID int64, slug string) (bool, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
link, ok := s.businessChatLinks[slug]
|
|
if !ok || link.OwnerUserID != ownerUserID {
|
|
return false, nil
|
|
}
|
|
delete(s.businessChatLinks, slug)
|
|
slugs := s.businessChatLinkSlugs[ownerUserID]
|
|
next := slugs[:0]
|
|
for _, item := range slugs {
|
|
if item != slug {
|
|
next = append(next, item)
|
|
}
|
|
}
|
|
s.businessChatLinkSlugs[ownerUserID] = next
|
|
return true, nil
|
|
}
|
|
|
|
func (s *PasswordStore) ResolveBusinessChatLink(_ context.Context, slug string, bumpViews bool) (domain.BusinessChatLink, bool, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
link, ok := s.businessChatLinks[slug]
|
|
if !ok {
|
|
return domain.BusinessChatLink{}, false, nil
|
|
}
|
|
if bumpViews {
|
|
link.Views++
|
|
s.businessChatLinks[slug] = link
|
|
}
|
|
return cloneBusinessChatLink(link), true, nil
|
|
}
|
|
|
|
func (s *PasswordStore) ListQuickReplies(_ context.Context, ownerUserID int64, includeTopMessages bool) (domain.QuickReplyList, error) {
|
|
s.mu.RLock()
|
|
out := s.quickReplyListLocked(ownerUserID, includeTopMessages)
|
|
s.mu.RUnlock()
|
|
return out, nil
|
|
}
|
|
|
|
func (s *PasswordStore) CheckQuickReplyShortcut(_ context.Context, ownerUserID int64, shortcut string) (bool, error) {
|
|
shortcut, err := domain.NormalizeQuickReplyShortcut(shortcut)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
s.mu.RLock()
|
|
_, ok := s.quickReplyByShortcut[ownerUserID][quickReplyShortcutKey(shortcut)]
|
|
s.mu.RUnlock()
|
|
return !ok, nil
|
|
}
|
|
|
|
func (s *PasswordStore) SaveQuickReplyText(_ context.Context, ownerUserID int64, shortcut string, msg domain.QuickReplyMessage) (domain.QuickReplyMutation, error) {
|
|
shortcut, err := domain.NormalizeQuickReplyShortcut(shortcut)
|
|
if err != nil {
|
|
return domain.QuickReplyMutation{}, err
|
|
}
|
|
if msg.Message == "" || len(msg.Entities) > domain.MaxMessageEntityCount {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.ensureQuickReplyMapsLocked(ownerUserID)
|
|
key := quickReplyShortcutKey(shortcut)
|
|
replyID, found := s.quickReplyByShortcut[ownerUserID][key]
|
|
created := false
|
|
if !found {
|
|
if len(s.quickReplies[ownerUserID]) >= domain.MaxQuickReplies {
|
|
return domain.QuickReplyMutation{}, domain.ErrQuickRepliesTooMuch
|
|
}
|
|
replyID = s.nextQuickReplyID[ownerUserID] + 1
|
|
s.nextQuickReplyID[ownerUserID] = replyID
|
|
s.quickReplyByShortcut[ownerUserID][key] = replyID
|
|
s.quickReplies[ownerUserID][replyID] = domain.QuickReply{
|
|
OwnerUserID: ownerUserID,
|
|
ID: replyID,
|
|
Shortcut: shortcut,
|
|
SortOrder: len(s.quickReplies[ownerUserID]) + 1,
|
|
}
|
|
s.quickReplyMessages[ownerUserID][replyID] = make(map[int]domain.QuickReplyMessage)
|
|
created = true
|
|
}
|
|
if len(s.quickReplyMessages[ownerUserID][replyID]) >= domain.MaxQuickReplyMessages {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
msg.OwnerUserID = ownerUserID
|
|
msg.ShortcutID = replyID
|
|
msg.ID = s.nextQuickReplyMessageID[ownerUserID] + 1
|
|
s.nextQuickReplyMessageID[ownerUserID] = msg.ID
|
|
msg.Entities = append([]domain.MessageEntity(nil), msg.Entities...)
|
|
s.quickReplyMessages[ownerUserID][replyID][msg.ID] = msg
|
|
s.refreshQuickReplyLocked(ownerUserID, replyID)
|
|
reply := cloneQuickReply(s.quickReplies[ownerUserID][replyID])
|
|
kind := domain.QuickReplyMutationMessage
|
|
if created {
|
|
kind = domain.QuickReplyMutationNew
|
|
}
|
|
return domain.QuickReplyMutation{
|
|
Kind: kind,
|
|
List: s.quickReplyListLocked(ownerUserID, true),
|
|
QuickReply: reply,
|
|
ShortcutID: replyID,
|
|
Message: cloneQuickReplyMessage(msg),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PasswordStore) GetQuickReplyMessages(_ context.Context, ownerUserID int64, shortcutID int, ids []int) (domain.QuickReplyMessages, error) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
if _, ok := s.quickReplies[ownerUserID][shortcutID]; !ok {
|
|
return domain.QuickReplyMessages{}, domain.ErrShortcutInvalid
|
|
}
|
|
msgs := s.quickReplyMessages[ownerUserID][shortcutID]
|
|
selected := make([]domain.QuickReplyMessage, 0, len(msgs))
|
|
if len(ids) == 0 {
|
|
for _, msg := range msgs {
|
|
selected = append(selected, cloneQuickReplyMessage(msg))
|
|
}
|
|
} else {
|
|
for _, id := range ids {
|
|
msg, ok := msgs[id]
|
|
if !ok {
|
|
return domain.QuickReplyMessages{}, domain.ErrShortcutInvalid
|
|
}
|
|
selected = append(selected, cloneQuickReplyMessage(msg))
|
|
}
|
|
}
|
|
sortQuickReplyMessages(selected)
|
|
return domain.QuickReplyMessages{
|
|
OwnerUserID: ownerUserID,
|
|
ShortcutID: shortcutID,
|
|
Messages: selected,
|
|
Count: len(msgs),
|
|
Hash: quickReplyMessagesHash(selected),
|
|
}, nil
|
|
}
|
|
|
|
func (s *PasswordStore) RenameQuickReplyShortcut(_ context.Context, ownerUserID int64, shortcutID int, shortcut string) (domain.QuickReplyMutation, error) {
|
|
shortcut, err := domain.NormalizeQuickReplyShortcut(shortcut)
|
|
if err != nil {
|
|
return domain.QuickReplyMutation{}, err
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
reply, ok := s.quickReplies[ownerUserID][shortcutID]
|
|
if !ok {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
key := quickReplyShortcutKey(shortcut)
|
|
if existingID, exists := s.quickReplyByShortcut[ownerUserID][key]; exists && existingID != shortcutID {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutOccupied
|
|
}
|
|
delete(s.quickReplyByShortcut[ownerUserID], quickReplyShortcutKey(reply.Shortcut))
|
|
reply.Shortcut = shortcut
|
|
s.quickReplyByShortcut[ownerUserID][key] = shortcutID
|
|
s.quickReplies[ownerUserID][shortcutID] = reply
|
|
return domain.QuickReplyMutation{Kind: domain.QuickReplyMutationList, List: s.quickReplyListLocked(ownerUserID, true)}, nil
|
|
}
|
|
|
|
func (s *PasswordStore) ReorderQuickReplies(_ context.Context, ownerUserID int64, order []int) (domain.QuickReplyMutation, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
replies := s.quickReplies[ownerUserID]
|
|
if len(order) != len(replies) {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
seen := make(map[int]struct{}, len(order))
|
|
for i, id := range order {
|
|
reply, ok := replies[id]
|
|
if !ok {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
if _, dup := seen[id]; dup {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
seen[id] = struct{}{}
|
|
reply.SortOrder = i + 1
|
|
replies[id] = reply
|
|
}
|
|
return domain.QuickReplyMutation{Kind: domain.QuickReplyMutationList, List: s.quickReplyListLocked(ownerUserID, true)}, nil
|
|
}
|
|
|
|
func (s *PasswordStore) DeleteQuickReplyShortcut(_ context.Context, ownerUserID int64, shortcutID int) (domain.QuickReplyMutation, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
reply, ok := s.quickReplies[ownerUserID][shortcutID]
|
|
if !ok {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
delete(s.quickReplyByShortcut[ownerUserID], quickReplyShortcutKey(reply.Shortcut))
|
|
delete(s.quickReplies[ownerUserID], shortcutID)
|
|
delete(s.quickReplyMessages[ownerUserID], shortcutID)
|
|
normalizeQuickReplyOrderLocked(s.quickReplies[ownerUserID])
|
|
return domain.QuickReplyMutation{
|
|
Kind: domain.QuickReplyMutationDelete,
|
|
List: s.quickReplyListLocked(ownerUserID, true),
|
|
ShortcutID: shortcutID,
|
|
}, nil
|
|
}
|
|
|
|
func (s *PasswordStore) DeleteQuickReplyMessages(_ context.Context, ownerUserID int64, shortcutID int, ids []int) (domain.QuickReplyMutation, error) {
|
|
if len(ids) == 0 {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if _, ok := s.quickReplies[ownerUserID][shortcutID]; !ok {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
msgs := s.quickReplyMessages[ownerUserID][shortcutID]
|
|
deleted := make([]int, 0, len(ids))
|
|
for _, id := range ids {
|
|
if _, ok := msgs[id]; !ok {
|
|
return domain.QuickReplyMutation{}, domain.ErrShortcutInvalid
|
|
}
|
|
delete(msgs, id)
|
|
deleted = append(deleted, id)
|
|
}
|
|
s.refreshQuickReplyLocked(ownerUserID, shortcutID)
|
|
return domain.QuickReplyMutation{
|
|
Kind: domain.QuickReplyMutationIDs,
|
|
List: s.quickReplyListLocked(ownerUserID, true),
|
|
ShortcutID: shortcutID,
|
|
MessageIDs: deleted,
|
|
}, nil
|
|
}
|
|
|
|
func (s *PasswordStore) ReserveBusinessAutomationDelivery(_ context.Context, delivery domain.BusinessAutomationDelivery) (bool, error) {
|
|
if delivery.OwnerUserID == 0 || delivery.PeerUserID == 0 || delivery.Kind == "" || delivery.TriggerMessageID == 0 {
|
|
return false, domain.ErrBusinessProfileInvalid
|
|
}
|
|
key := businessAutomationDeliveryKey{
|
|
ownerUserID: delivery.OwnerUserID,
|
|
peerUserID: delivery.PeerUserID,
|
|
kind: delivery.Kind,
|
|
triggerMessageID: delivery.TriggerMessageID,
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if _, ok := s.businessDeliveries[key]; ok {
|
|
return false, nil
|
|
}
|
|
s.businessDeliveries[key] = delivery
|
|
return true, nil
|
|
}
|
|
|
|
func (s *PasswordStore) LastBusinessAutomationDelivery(_ context.Context, ownerUserID, peerUserID int64, kind domain.BusinessAutomationKind) (domain.BusinessAutomationDelivery, bool, error) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
var out domain.BusinessAutomationDelivery
|
|
found := false
|
|
for _, delivery := range s.businessDeliveries {
|
|
if delivery.OwnerUserID != ownerUserID || delivery.PeerUserID != peerUserID || delivery.Kind != kind {
|
|
continue
|
|
}
|
|
if !found || delivery.SentAt > out.SentAt || delivery.SentAt == out.SentAt && delivery.TriggerMessageID > out.TriggerMessageID {
|
|
out = delivery
|
|
found = true
|
|
}
|
|
}
|
|
return out, found, nil
|
|
}
|
|
|
|
func (s *PasswordStore) GetConnectedBusinessBot(_ context.Context, ownerUserID int64) (domain.ConnectedBusinessBot, bool, error) {
|
|
s.mu.RLock()
|
|
bot, ok := s.connectedBusinessBots[ownerUserID]
|
|
s.mu.RUnlock()
|
|
return cloneConnectedBusinessBot(bot), ok, nil
|
|
}
|
|
|
|
func (s *PasswordStore) SaveConnectedBusinessBot(_ context.Context, bot domain.ConnectedBusinessBot) (domain.ConnectedBusinessBot, error) {
|
|
if bot.OwnerUserID == 0 || bot.BotUserID == 0 {
|
|
return domain.ConnectedBusinessBot{}, domain.ErrBotBusinessMissing
|
|
}
|
|
s.mu.Lock()
|
|
if prev, ok := s.connectedBusinessBots[bot.OwnerUserID]; ok && bot.CreatedAtUnix == 0 {
|
|
bot.CreatedAtUnix = prev.CreatedAtUnix
|
|
}
|
|
s.connectedBusinessBots[bot.OwnerUserID] = cloneConnectedBusinessBot(bot)
|
|
s.mu.Unlock()
|
|
return cloneConnectedBusinessBot(bot), nil
|
|
}
|
|
|
|
func (s *PasswordStore) DeleteConnectedBusinessBot(_ context.Context, ownerUserID, botUserID int64) (bool, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
bot, ok := s.connectedBusinessBots[ownerUserID]
|
|
if !ok || bot.BotUserID != botUserID {
|
|
return false, nil
|
|
}
|
|
delete(s.connectedBusinessBots, ownerUserID)
|
|
for key := range s.connectedBusinessBotPeerStates {
|
|
if key.ownerUserID == ownerUserID {
|
|
delete(s.connectedBusinessBotPeerStates, key)
|
|
}
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (s *PasswordStore) SetConnectedBusinessBotPaused(_ context.Context, ownerUserID, peerUserID int64, paused bool) (domain.ConnectedBusinessBotPeerState, error) {
|
|
if ownerUserID == 0 || peerUserID == 0 {
|
|
return domain.ConnectedBusinessBotPeerState{}, domain.ErrBotBusinessMissing
|
|
}
|
|
key := connectedBusinessBotPeerKey{ownerUserID: ownerUserID, peerUserID: peerUserID}
|
|
s.mu.Lock()
|
|
state := s.connectedBusinessBotPeerStates[key]
|
|
state.OwnerUserID = ownerUserID
|
|
state.PeerUserID = peerUserID
|
|
state.Paused = paused
|
|
s.connectedBusinessBotPeerStates[key] = state
|
|
s.mu.Unlock()
|
|
return state, nil
|
|
}
|
|
|
|
func (s *PasswordStore) DisableConnectedBusinessBotForPeer(_ context.Context, ownerUserID, peerUserID int64) (domain.ConnectedBusinessBotPeerState, error) {
|
|
if ownerUserID == 0 || peerUserID == 0 {
|
|
return domain.ConnectedBusinessBotPeerState{}, domain.ErrBotBusinessMissing
|
|
}
|
|
key := connectedBusinessBotPeerKey{ownerUserID: ownerUserID, peerUserID: peerUserID}
|
|
s.mu.Lock()
|
|
state := s.connectedBusinessBotPeerStates[key]
|
|
state.OwnerUserID = ownerUserID
|
|
state.PeerUserID = peerUserID
|
|
state.Paused = false
|
|
state.Disabled = true
|
|
s.connectedBusinessBotPeerStates[key] = state
|
|
s.mu.Unlock()
|
|
return state, nil
|
|
}
|
|
|
|
func (s *PasswordStore) GetConnectedBusinessBotPeerState(_ context.Context, ownerUserID, peerUserID int64) (domain.ConnectedBusinessBotPeerState, bool, error) {
|
|
key := connectedBusinessBotPeerKey{ownerUserID: ownerUserID, peerUserID: peerUserID}
|
|
s.mu.RLock()
|
|
state, ok := s.connectedBusinessBotPeerStates[key]
|
|
s.mu.RUnlock()
|
|
return state, ok, nil
|
|
}
|
|
|
|
func (s *PasswordStore) ensureQuickReplyMapsLocked(ownerUserID int64) {
|
|
if s.quickReplies[ownerUserID] == nil {
|
|
s.quickReplies[ownerUserID] = make(map[int]domain.QuickReply)
|
|
}
|
|
if s.quickReplyByShortcut[ownerUserID] == nil {
|
|
s.quickReplyByShortcut[ownerUserID] = make(map[string]int)
|
|
}
|
|
if s.quickReplyMessages[ownerUserID] == nil {
|
|
s.quickReplyMessages[ownerUserID] = make(map[int]map[int]domain.QuickReplyMessage)
|
|
}
|
|
for id := range s.quickReplies[ownerUserID] {
|
|
if s.quickReplyMessages[ownerUserID][id] == nil {
|
|
s.quickReplyMessages[ownerUserID][id] = make(map[int]domain.QuickReplyMessage)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *PasswordStore) refreshQuickReplyLocked(ownerUserID int64, shortcutID int) {
|
|
s.ensureQuickReplyMapsLocked(ownerUserID)
|
|
reply := s.quickReplies[ownerUserID][shortcutID]
|
|
reply.Count = len(s.quickReplyMessages[ownerUserID][shortcutID])
|
|
reply.TopMessage = 0
|
|
for id := range s.quickReplyMessages[ownerUserID][shortcutID] {
|
|
if id > reply.TopMessage {
|
|
reply.TopMessage = id
|
|
}
|
|
}
|
|
s.quickReplies[ownerUserID][shortcutID] = reply
|
|
}
|
|
|
|
func (s *PasswordStore) quickReplyListLocked(ownerUserID int64, includeTopMessages bool) domain.QuickReplyList {
|
|
replies := make([]domain.QuickReply, 0, len(s.quickReplies[ownerUserID]))
|
|
for id := range s.quickReplies[ownerUserID] {
|
|
s.refreshQuickReplyLocked(ownerUserID, id)
|
|
replies = append(replies, cloneQuickReply(s.quickReplies[ownerUserID][id]))
|
|
}
|
|
sortQuickReplies(replies)
|
|
messages := make([]domain.QuickReplyMessage, 0, len(replies))
|
|
if includeTopMessages {
|
|
for _, reply := range replies {
|
|
if reply.TopMessage == 0 {
|
|
continue
|
|
}
|
|
if msg, ok := s.quickReplyMessages[ownerUserID][reply.ID][reply.TopMessage]; ok {
|
|
messages = append(messages, cloneQuickReplyMessage(msg))
|
|
}
|
|
}
|
|
sortQuickReplyMessages(messages)
|
|
}
|
|
return domain.QuickReplyList{
|
|
OwnerUserID: ownerUserID,
|
|
QuickReplies: replies,
|
|
Messages: messages,
|
|
Hash: quickReplyListHash(replies),
|
|
}
|
|
}
|
|
|
|
func normalizeQuickReplyOrderLocked(replies map[int]domain.QuickReply) {
|
|
list := make([]domain.QuickReply, 0, len(replies))
|
|
for _, reply := range replies {
|
|
list = append(list, reply)
|
|
}
|
|
sortQuickReplies(list)
|
|
for i, reply := range list {
|
|
reply.SortOrder = i + 1
|
|
replies[reply.ID] = reply
|
|
}
|
|
}
|
|
|
|
func sortQuickReplies(items []domain.QuickReply) {
|
|
sort.Slice(items, func(i, j int) bool {
|
|
if items[i].SortOrder == items[j].SortOrder {
|
|
return items[i].ID < items[j].ID
|
|
}
|
|
return items[i].SortOrder < items[j].SortOrder
|
|
})
|
|
}
|
|
|
|
func sortQuickReplyMessages(items []domain.QuickReplyMessage) {
|
|
sort.Slice(items, func(i, j int) bool {
|
|
return items[i].ID < items[j].ID
|
|
})
|
|
}
|
|
|
|
func quickReplyShortcutKey(shortcut string) string {
|
|
return strings.ToLower(shortcut)
|
|
}
|
|
|
|
func quickReplyListHash(items []domain.QuickReply) int64 {
|
|
h := fnv.New64a()
|
|
for _, item := range items {
|
|
writeHashInt(h, item.ID)
|
|
writeHashString(h, item.Shortcut)
|
|
writeHashInt(h, item.TopMessage)
|
|
writeHashInt(h, item.Count)
|
|
}
|
|
return int64(h.Sum64() & 0x7fffffffffffffff)
|
|
}
|
|
|
|
func quickReplyMessagesHash(items []domain.QuickReplyMessage) int64 {
|
|
h := fnv.New64a()
|
|
for _, item := range items {
|
|
writeHashInt(h, item.ID)
|
|
writeHashString(h, item.Message)
|
|
writeHashInt(h, item.Date)
|
|
}
|
|
return int64(h.Sum64() & 0x7fffffffffffffff)
|
|
}
|
|
|
|
func writeHashInt(h interface{ Write([]byte) (int, error) }, v int) {
|
|
_, _ = h.Write([]byte{
|
|
byte(v >> 24),
|
|
byte(v >> 16),
|
|
byte(v >> 8),
|
|
byte(v),
|
|
})
|
|
}
|
|
|
|
func writeHashString(h interface{ Write([]byte) (int, error) }, v string) {
|
|
_, _ = h.Write([]byte(v))
|
|
_, _ = h.Write([]byte{0})
|
|
}
|
|
|
|
func cloneBusinessProfile(in domain.BusinessProfile) domain.BusinessProfile {
|
|
out := in
|
|
if in.WorkHours != nil {
|
|
v := *in.WorkHours
|
|
v.WeeklyOpen = append([]domain.BusinessWeeklyOpen(nil), in.WorkHours.WeeklyOpen...)
|
|
out.WorkHours = &v
|
|
}
|
|
if in.Location != nil {
|
|
v := *in.Location
|
|
if in.Location.Geo != nil {
|
|
geo := *in.Location.Geo
|
|
v.Geo = &geo
|
|
}
|
|
out.Location = &v
|
|
}
|
|
if in.Intro != nil {
|
|
v := *in.Intro
|
|
out.Intro = &v
|
|
}
|
|
if in.Greeting != nil {
|
|
v := *in.Greeting
|
|
v.Recipients.Users = append([]int64(nil), in.Greeting.Recipients.Users...)
|
|
out.Greeting = &v
|
|
}
|
|
if in.Away != nil {
|
|
v := *in.Away
|
|
v.Recipients.Users = append([]int64(nil), in.Away.Recipients.Users...)
|
|
out.Away = &v
|
|
}
|
|
return out
|
|
}
|
|
|
|
func cloneBusinessChatLink(in domain.BusinessChatLink) domain.BusinessChatLink {
|
|
out := in
|
|
out.Entities = append([]domain.MessageEntity(nil), in.Entities...)
|
|
return out
|
|
}
|
|
|
|
func cloneQuickReply(in domain.QuickReply) domain.QuickReply {
|
|
return in
|
|
}
|
|
|
|
func cloneQuickReplyMessage(in domain.QuickReplyMessage) domain.QuickReplyMessage {
|
|
out := in
|
|
out.Entities = append([]domain.MessageEntity(nil), in.Entities...)
|
|
return out
|
|
}
|
|
|
|
func cloneConnectedBusinessBot(in domain.ConnectedBusinessBot) domain.ConnectedBusinessBot {
|
|
out := in
|
|
out.Recipients.Users = append([]int64(nil), in.Recipients.Users...)
|
|
out.Recipients.ExcludeUsers = append([]int64(nil), in.Recipients.ExcludeUsers...)
|
|
return out
|
|
}
|