624 lines
21 KiB
Go
624 lines
21 KiB
Go
package rpc
|
|
|
|
import (
|
|
"context"
|
|
"telesrv/internal/domain"
|
|
)
|
|
|
|
type captureMessages struct {
|
|
list domain.MessageList
|
|
filter domain.MessageFilter
|
|
sendResult domain.SendPrivateTextResult
|
|
sendUserID int64
|
|
sendReq domain.SendPrivateTextRequest
|
|
setThemeUserID int64
|
|
setThemeReq domain.SetPrivateChatThemeRequest
|
|
setThemeRes domain.SetPrivateChatThemeResult
|
|
forwardUserID int64
|
|
forwardReq domain.ForwardPrivateMessagesRequest
|
|
forwardRes domain.ForwardPrivateMessagesResult
|
|
readResult domain.ReadHistoryResult
|
|
readReq domain.ReadHistoryRequest
|
|
readPeer domain.Peer
|
|
readMaxID int
|
|
readContentsReq domain.ReadMessageContentsRequest
|
|
readContentsRes domain.ReadMessageContentsResult
|
|
setReactionReq domain.SetPrivateMessageReactionsRequest
|
|
setReactionRes domain.PrivateMessageReactionsResult
|
|
getReactionReq domain.PrivateMessageReactionsRequest
|
|
getReactionRes domain.PrivateMessageReactionsResult
|
|
savedTagPeer domain.Peer
|
|
savedTags []domain.SavedReactionTag
|
|
updatedSavedTag domain.SavedReactionTag
|
|
savedTagErr error
|
|
getMessagesCalls int
|
|
getMessagesIDs [][]int
|
|
getMessagesListed bool
|
|
editReq domain.EditMessageRequest
|
|
editRes domain.EditMessageResult
|
|
outboxReadDateReq domain.OutboxReadDateRequest
|
|
outboxReadDate int
|
|
deleteMessagesReq domain.DeleteMessagesRequest
|
|
deleteMessagesRes domain.DeleteMessagesResult
|
|
deleteHistoryReq domain.DeleteHistoryRequest
|
|
deleteHistoryRes domain.DeleteMessagesResult
|
|
mediaReq domain.MediaSearchRequest
|
|
}
|
|
|
|
type scheduledCaptureMessages struct {
|
|
*captureMessages
|
|
scheduled []domain.ScheduledMessage
|
|
scheduleReq domain.ScheduleMessageRequest
|
|
editScheduledReq domain.EditScheduledMessageRequest
|
|
claimScheduledReq domain.ScheduledMessageClaim
|
|
deletedScheduled domain.ScheduledMessageFilter
|
|
markedScheduledID int
|
|
markedSentID int
|
|
releasedScheduled int
|
|
releasedErrMessage string
|
|
}
|
|
|
|
type ttlCaptureMessages struct {
|
|
*captureMessages
|
|
setTTLUserID int64
|
|
setTTLPeer domain.Peer
|
|
setTTLPeriod int
|
|
defaultTTLUserID int64
|
|
defaultTTLPeriod int
|
|
expiredPrivateClaims []domain.DeleteMessagesRequest
|
|
}
|
|
|
|
func (s *ttlCaptureMessages) GetPrivateHistoryTTL(_ context.Context, _ int64, _ domain.Peer) (int, error) {
|
|
return s.setTTLPeriod, nil
|
|
}
|
|
|
|
func (s *ttlCaptureMessages) SetPrivateHistoryTTL(_ context.Context, userID int64, peer domain.Peer, period int) error {
|
|
s.setTTLUserID = userID
|
|
s.setTTLPeer = peer
|
|
s.setTTLPeriod = period
|
|
return nil
|
|
}
|
|
|
|
func (s *ttlCaptureMessages) DefaultHistoryTTL(_ context.Context, userID int64) (int, error) {
|
|
s.defaultTTLUserID = userID
|
|
return s.defaultTTLPeriod, nil
|
|
}
|
|
|
|
func (s *ttlCaptureMessages) SetDefaultHistoryTTL(_ context.Context, userID int64, period int) error {
|
|
s.defaultTTLUserID = userID
|
|
s.defaultTTLPeriod = period
|
|
return nil
|
|
}
|
|
|
|
func (s *ttlCaptureMessages) ClaimExpiredPrivateMessages(context.Context, int, int) ([]domain.DeleteMessagesRequest, error) {
|
|
return append([]domain.DeleteMessagesRequest(nil), s.expiredPrivateClaims...), nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) ScheduleMessage(_ context.Context, userID int64, req domain.ScheduleMessageRequest) (domain.ScheduledMessage, error) {
|
|
s.scheduleReq = req
|
|
if req.OwnerUserID == 0 {
|
|
req.OwnerUserID = userID
|
|
}
|
|
msg := domain.ScheduledMessage{
|
|
OwnerUserID: req.OwnerUserID,
|
|
ID: len(s.scheduled) + 41,
|
|
Peer: req.Peer,
|
|
RandomID: req.RandomID,
|
|
Message: req.Message,
|
|
Entities: append([]domain.MessageEntity(nil), req.Entities...),
|
|
Media: req.Media,
|
|
Silent: req.Silent,
|
|
NoForwards: req.NoForwards,
|
|
ReplyTo: req.ReplyTo,
|
|
Forward: req.Forward,
|
|
SendAs: req.SendAs,
|
|
ScheduleDate: req.ScheduleDate,
|
|
ScheduleRepeatPeriod: req.ScheduleRepeatPeriod,
|
|
CreatedAt: req.Date,
|
|
UpdatedAt: req.Date,
|
|
State: "pending",
|
|
}
|
|
s.scheduled = append(s.scheduled, msg)
|
|
return msg, nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) EditScheduledMessage(_ context.Context, userID int64, req domain.EditScheduledMessageRequest) (domain.ScheduledMessage, error) {
|
|
s.editScheduledReq = req
|
|
if req.OwnerUserID == 0 {
|
|
req.OwnerUserID = userID
|
|
}
|
|
for i := range s.scheduled {
|
|
if s.scheduled[i].OwnerUserID == req.OwnerUserID && s.scheduled[i].Peer == req.Peer && s.scheduled[i].ID == req.ID {
|
|
if req.SetMessage {
|
|
s.scheduled[i].Message = req.Message
|
|
s.scheduled[i].Entities = append([]domain.MessageEntity(nil), req.Entities...)
|
|
}
|
|
s.scheduled[i].ScheduleDate = req.ScheduleDate
|
|
s.scheduled[i].UpdatedAt = req.Date
|
|
return s.scheduled[i], nil
|
|
}
|
|
}
|
|
return domain.ScheduledMessage{}, domain.ErrMessageIDInvalid
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) ListScheduledMessages(_ context.Context, userID int64, filter domain.ScheduledMessageFilter) (domain.ScheduledMessageList, error) {
|
|
if filter.OwnerUserID == 0 {
|
|
filter.OwnerUserID = userID
|
|
}
|
|
items := s.matchScheduled(filter)
|
|
return domain.ScheduledMessageList{Messages: items, Count: len(items)}, nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) GetScheduledMessages(_ context.Context, userID int64, filter domain.ScheduledMessageFilter) (domain.ScheduledMessageList, error) {
|
|
if filter.OwnerUserID == 0 {
|
|
filter.OwnerUserID = userID
|
|
}
|
|
items := s.matchScheduled(filter)
|
|
return domain.ScheduledMessageList{Messages: items, Count: len(items)}, nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) DeleteScheduledMessages(_ context.Context, userID int64, filter domain.ScheduledMessageFilter, _ int) ([]domain.ScheduledMessage, error) {
|
|
if filter.OwnerUserID == 0 {
|
|
filter.OwnerUserID = userID
|
|
}
|
|
s.deletedScheduled = filter
|
|
deleted := s.matchScheduled(filter)
|
|
s.removeScheduled(filter)
|
|
return deleted, nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) ClaimScheduledMessages(_ context.Context, userID int64, claim domain.ScheduledMessageClaim) ([]domain.ScheduledMessage, error) {
|
|
if claim.OwnerUserID == 0 {
|
|
claim.OwnerUserID = userID
|
|
}
|
|
s.claimScheduledReq = claim
|
|
return s.matchScheduled(domain.ScheduledMessageFilter{OwnerUserID: claim.OwnerUserID, Peer: claim.Peer, IDs: claim.IDs}), nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) ClaimDueScheduledMessages(context.Context, int, int, int) ([]domain.ScheduledMessage, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) MarkScheduledMessageSent(_ context.Context, _ int64, id, sentMessageID, _ int) error {
|
|
s.markedScheduledID = id
|
|
s.markedSentID = sentMessageID
|
|
s.removeScheduled(domain.ScheduledMessageFilter{OwnerUserID: s.scheduleReq.OwnerUserID, Peer: s.scheduleReq.Peer, IDs: []int{id}})
|
|
return nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) ReleaseScheduledMessage(_ context.Context, _ int64, id int, errText string) error {
|
|
s.releasedScheduled = id
|
|
s.releasedErrMessage = errText
|
|
return nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) HasScheduledMessages(_ context.Context, userID int64, peer domain.Peer) (bool, error) {
|
|
return len(s.matchScheduled(domain.ScheduledMessageFilter{OwnerUserID: userID, Peer: peer})) > 0, nil
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) matchScheduled(filter domain.ScheduledMessageFilter) []domain.ScheduledMessage {
|
|
idSet := make(map[int]struct{}, len(filter.IDs))
|
|
for _, id := range filter.IDs {
|
|
idSet[id] = struct{}{}
|
|
}
|
|
out := make([]domain.ScheduledMessage, 0, len(s.scheduled))
|
|
for _, msg := range s.scheduled {
|
|
if filter.OwnerUserID != 0 && msg.OwnerUserID != filter.OwnerUserID {
|
|
continue
|
|
}
|
|
if filter.Peer.ID != 0 && msg.Peer != filter.Peer {
|
|
continue
|
|
}
|
|
if len(idSet) > 0 {
|
|
if _, ok := idSet[msg.ID]; !ok {
|
|
continue
|
|
}
|
|
}
|
|
out = append(out, msg)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (s *scheduledCaptureMessages) removeScheduled(filter domain.ScheduledMessageFilter) {
|
|
idSet := make(map[int]struct{}, len(filter.IDs))
|
|
for _, id := range filter.IDs {
|
|
idSet[id] = struct{}{}
|
|
}
|
|
kept := s.scheduled[:0]
|
|
for _, msg := range s.scheduled {
|
|
if filter.OwnerUserID != 0 && msg.OwnerUserID != filter.OwnerUserID {
|
|
kept = append(kept, msg)
|
|
continue
|
|
}
|
|
if filter.Peer.ID != 0 && msg.Peer != filter.Peer {
|
|
kept = append(kept, msg)
|
|
continue
|
|
}
|
|
if len(idSet) > 0 {
|
|
if _, ok := idSet[msg.ID]; ok {
|
|
continue
|
|
}
|
|
}
|
|
kept = append(kept, msg)
|
|
}
|
|
s.scheduled = kept
|
|
}
|
|
|
|
func (s *captureMessages) SendPrivateText(_ context.Context, userID int64, req domain.SendPrivateTextRequest) (domain.SendPrivateTextResult, error) {
|
|
s.sendUserID = userID
|
|
s.sendReq = req
|
|
if s.sendResult.SenderMessage.ID == 0 {
|
|
s.sendResult.SenderMessage = domain.Message{
|
|
ID: 1,
|
|
OwnerUserID: req.SenderUserID,
|
|
RandomID: req.RandomID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: req.RecipientUserID},
|
|
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.SenderUserID},
|
|
Date: req.Date,
|
|
Out: true,
|
|
Silent: req.Silent,
|
|
NoForwards: req.NoForwards,
|
|
Body: req.Message,
|
|
Entities: req.Entities,
|
|
Media: req.Media,
|
|
ReplyTo: req.ReplyTo,
|
|
Forward: req.Forward,
|
|
ViaBotID: req.ViaBotID,
|
|
Pts: 1,
|
|
}
|
|
s.sendResult.SenderEvent = domain.UpdateEvent{
|
|
UserID: req.SenderUserID,
|
|
Type: domain.UpdateEventNewMessage,
|
|
Pts: 1,
|
|
PtsCount: 1,
|
|
Date: req.Date,
|
|
Message: s.sendResult.SenderMessage,
|
|
}
|
|
}
|
|
return s.sendResult, nil
|
|
}
|
|
|
|
func (s *captureMessages) SetChatTheme(_ context.Context, userID int64, req domain.SetPrivateChatThemeRequest) (domain.SetPrivateChatThemeResult, error) {
|
|
s.setThemeUserID = userID
|
|
s.setThemeReq = req
|
|
if s.setThemeRes.OwnerUserID == 0 {
|
|
s.setThemeRes = domain.SetPrivateChatThemeResult{
|
|
OwnerUserID: userID,
|
|
Peer: req.Peer,
|
|
Emoticon: req.Emoticon,
|
|
Changed: true,
|
|
Send: domain.SendPrivateTextResult{
|
|
SenderMessage: domain.Message{
|
|
ID: 1,
|
|
OwnerUserID: userID,
|
|
Peer: req.Peer,
|
|
From: domain.Peer{Type: domain.PeerTypeUser, ID: userID},
|
|
Date: req.Date,
|
|
Out: true,
|
|
Media: &domain.MessageMedia{
|
|
Kind: domain.MessageMediaKindService,
|
|
ServiceAction: &domain.MessageServiceAction{
|
|
Kind: domain.MessageServiceActionSetChatTheme,
|
|
ChatThemeEmoticon: req.Emoticon,
|
|
},
|
|
},
|
|
Pts: 1,
|
|
},
|
|
SenderEvent: domain.UpdateEvent{
|
|
UserID: userID,
|
|
Type: domain.UpdateEventNewMessage,
|
|
Pts: 1,
|
|
PtsCount: 1,
|
|
Date: req.Date,
|
|
},
|
|
},
|
|
}
|
|
s.setThemeRes.Send.SenderEvent.Message = s.setThemeRes.Send.SenderMessage
|
|
}
|
|
return s.setThemeRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) ForwardPrivateMessages(_ context.Context, userID int64, req domain.ForwardPrivateMessagesRequest) (domain.ForwardPrivateMessagesResult, error) {
|
|
s.forwardUserID = userID
|
|
s.forwardReq = req
|
|
if len(s.forwardRes.SenderMessages) == 0 {
|
|
s.forwardRes.OwnerUserID = userID
|
|
s.forwardRes.SenderMessages = make([]domain.Message, 0, len(req.MessageIDs))
|
|
s.forwardRes.SenderEvents = make([]domain.UpdateEvent, 0, len(req.MessageIDs))
|
|
for i := range req.MessageIDs {
|
|
msg := domain.Message{
|
|
ID: i + 1,
|
|
OwnerUserID: req.OwnerUserID,
|
|
RandomID: req.RandomIDs[i],
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: req.ToUserID},
|
|
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.OwnerUserID},
|
|
Date: req.Date,
|
|
Out: true,
|
|
Silent: req.Silent,
|
|
NoForwards: req.NoForwards,
|
|
Body: "forwarded",
|
|
ReplyTo: req.ReplyTo,
|
|
Forward: &domain.MessageForward{From: domain.Peer{Type: domain.PeerTypeUser, ID: req.FromPeer.ID}, Date: req.Date - 1},
|
|
Pts: i + 1,
|
|
}
|
|
event := domain.UpdateEvent{
|
|
UserID: req.OwnerUserID,
|
|
Type: domain.UpdateEventNewMessage,
|
|
Pts: msg.Pts,
|
|
PtsCount: 1,
|
|
Date: req.Date,
|
|
Message: msg,
|
|
}
|
|
s.forwardRes.SenderMessages = append(s.forwardRes.SenderMessages, msg)
|
|
s.forwardRes.SenderEvents = append(s.forwardRes.SenderEvents, event)
|
|
}
|
|
}
|
|
return s.forwardRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) GetMessages(_ context.Context, _ int64, ids []int) (domain.MessageList, error) {
|
|
s.getMessagesCalls++
|
|
s.getMessagesIDs = append(s.getMessagesIDs, append([]int(nil), ids...))
|
|
byID := make(map[int]domain.Message, len(s.list.Messages))
|
|
for _, msg := range s.list.Messages {
|
|
byID[msg.ID] = msg
|
|
}
|
|
out := domain.MessageList{Messages: make([]domain.Message, 0, len(ids)), Users: s.list.Users}
|
|
if s.getMessagesListed {
|
|
for _, msg := range s.list.Messages {
|
|
for _, id := range ids {
|
|
if msg.ID == id {
|
|
out.Messages = append(out.Messages, msg)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
for _, id := range ids {
|
|
if msg, ok := byID[id]; ok {
|
|
out.Messages = append(out.Messages, msg)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *captureMessages) GetHistory(_ context.Context, _ int64, filter domain.MessageFilter) (domain.MessageList, error) {
|
|
s.filter = filter
|
|
return s.list, nil
|
|
}
|
|
|
|
func (s *captureMessages) Search(_ context.Context, _ int64, filter domain.MessageFilter) (domain.MessageList, error) {
|
|
s.filter = filter
|
|
return s.list, nil
|
|
}
|
|
|
|
func (s *captureMessages) SearchPrivateMedia(_ context.Context, _, _ int64, req domain.MediaSearchRequest) (domain.MessageList, error) {
|
|
s.mediaReq = req
|
|
return domain.MessageList{}, nil
|
|
}
|
|
|
|
func (s *captureMessages) CountPrivateMediaCategories(_ context.Context, _, _ int64) (domain.MediaCategoryCounts, error) {
|
|
return domain.MediaCategoryCounts{}, nil
|
|
}
|
|
|
|
func (s *captureMessages) ReadHistory(_ context.Context, _ int64, req domain.ReadHistoryRequest) (domain.ReadHistoryResult, error) {
|
|
s.readReq = req
|
|
s.readPeer = req.Peer
|
|
s.readMaxID = req.MaxID
|
|
if s.readResult.OwnerUserID == 0 {
|
|
s.readResult.OwnerUserID = req.OwnerUserID
|
|
}
|
|
if s.readResult.Peer.ID == 0 {
|
|
s.readResult.Peer = req.Peer
|
|
}
|
|
if s.readResult.MaxID == 0 {
|
|
s.readResult.MaxID = req.MaxID
|
|
}
|
|
return s.readResult, nil
|
|
}
|
|
|
|
func (s *captureMessages) ReadMessageContents(_ context.Context, userID int64, req domain.ReadMessageContentsRequest) (domain.ReadMessageContentsResult, error) {
|
|
s.readContentsReq = req
|
|
if s.readContentsRes.OwnerUserID == 0 {
|
|
s.readContentsRes.OwnerUserID = userID
|
|
}
|
|
return s.readContentsRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) GetOutboxReadDate(_ context.Context, _ int64, req domain.OutboxReadDateRequest) (int, error) {
|
|
s.outboxReadDateReq = req
|
|
if s.outboxReadDate == 0 {
|
|
return 0, domain.ErrMessageNotReadYet
|
|
}
|
|
return s.outboxReadDate, nil
|
|
}
|
|
|
|
func (s *captureMessages) SetMessageReactions(_ context.Context, userID int64, req domain.SetPrivateMessageReactionsRequest) (domain.PrivateMessageReactionsResult, error) {
|
|
s.setReactionReq = req
|
|
if len(s.setReactionRes.Messages) == 0 {
|
|
if len(req.Reactions) == 0 {
|
|
reactions := domain.ChannelMessageReactions{
|
|
CanSeeList: req.Peer.ID != userID,
|
|
AsTags: req.Peer.ID == userID,
|
|
Results: []domain.ChannelMessageReactionCount{},
|
|
Recent: []domain.ChannelMessagePeerReaction{},
|
|
}
|
|
s.setReactionRes = domain.PrivateMessageReactionsResult{
|
|
Messages: []domain.Message{{
|
|
ID: req.MessageID,
|
|
OwnerUserID: userID,
|
|
Peer: req.Peer,
|
|
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.Peer.ID},
|
|
Date: req.Date,
|
|
Reactions: &reactions,
|
|
}},
|
|
Reactions: reactions,
|
|
}
|
|
return s.setReactionRes, nil
|
|
}
|
|
reactions := domain.ChannelMessageReactions{
|
|
CanSeeList: req.Peer.ID != userID,
|
|
AsTags: req.Peer.ID == userID,
|
|
Results: []domain.ChannelMessageReactionCount{{
|
|
Reaction: req.Reactions[0],
|
|
Count: 1,
|
|
ChosenOrder: 1,
|
|
}},
|
|
}
|
|
if req.Peer.ID != userID {
|
|
reactions.Recent = []domain.ChannelMessagePeerReaction{{
|
|
UserID: userID,
|
|
Reaction: req.Reactions[0],
|
|
My: true,
|
|
Big: req.Big,
|
|
ChosenOrder: 1,
|
|
Date: req.Date,
|
|
}}
|
|
}
|
|
s.setReactionRes = domain.PrivateMessageReactionsResult{
|
|
Messages: []domain.Message{{
|
|
ID: req.MessageID,
|
|
OwnerUserID: userID,
|
|
Peer: req.Peer,
|
|
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.Peer.ID},
|
|
Date: req.Date,
|
|
Reactions: &reactions,
|
|
}},
|
|
Reactions: reactions,
|
|
}
|
|
}
|
|
return s.setReactionRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) VoteMessagePoll(_ context.Context, _ int64, _ domain.VotePrivateMessagePollRequest) (domain.PrivateMessagePollResult, error) {
|
|
return domain.PrivateMessagePollResult{}, domain.ErrMessageIDInvalid
|
|
}
|
|
|
|
func (s *captureMessages) CloseMessagePoll(_ context.Context, _ int64, _ domain.ClosePrivateMessagePollRequest) (domain.PrivateMessagePollResult, error) {
|
|
return domain.PrivateMessagePollResult{}, domain.ErrMessageIDInvalid
|
|
}
|
|
|
|
func (s *captureMessages) GetMessageReactions(_ context.Context, userID int64, req domain.PrivateMessageReactionsRequest) (domain.PrivateMessageReactionsResult, error) {
|
|
s.getReactionReq = req
|
|
if len(s.getReactionRes.Messages) == 0 && len(req.IDs) > 0 {
|
|
reactions := domain.ChannelMessageReactions{CanSeeList: true, Results: []domain.ChannelMessageReactionCount{}, Recent: []domain.ChannelMessagePeerReaction{}}
|
|
s.getReactionRes = domain.PrivateMessageReactionsResult{
|
|
Messages: []domain.Message{{
|
|
ID: req.IDs[0],
|
|
OwnerUserID: userID,
|
|
Peer: req.Peer,
|
|
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.Peer.ID},
|
|
Reactions: &reactions,
|
|
}},
|
|
Reactions: reactions,
|
|
}
|
|
}
|
|
return s.getReactionRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) SavedReactionTags(_ context.Context, _ int64, savedPeer domain.Peer, _ int) ([]domain.SavedReactionTag, error) {
|
|
s.savedTagPeer = savedPeer
|
|
return append([]domain.SavedReactionTag(nil), s.savedTags...), s.savedTagErr
|
|
}
|
|
|
|
func (s *captureMessages) UpdateSavedReactionTag(_ context.Context, _ int64, tag domain.SavedReactionTag) error {
|
|
s.updatedSavedTag = tag
|
|
for i := range s.savedTags {
|
|
if s.savedTags[i].Reaction.Key() == tag.Reaction.Key() {
|
|
s.savedTags[i].Title = tag.Title
|
|
return s.savedTagErr
|
|
}
|
|
}
|
|
return s.savedTagErr
|
|
}
|
|
|
|
func (s *captureMessages) EditMessage(_ context.Context, userID int64, req domain.EditMessageRequest) (domain.EditMessageResult, error) {
|
|
s.editReq = req
|
|
if s.editRes.OwnerUserID == 0 {
|
|
s.editRes.OwnerUserID = userID
|
|
}
|
|
if len(s.editRes.Edited) == 0 {
|
|
msg := domain.Message{
|
|
ID: req.ID,
|
|
OwnerUserID: req.OwnerUserID,
|
|
Peer: req.Peer,
|
|
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.OwnerUserID},
|
|
Date: req.EditDate - 10,
|
|
EditDate: req.EditDate,
|
|
Out: true,
|
|
Body: req.Message,
|
|
Entities: append([]domain.MessageEntity(nil), req.Entities...),
|
|
Pts: 7,
|
|
}
|
|
s.editRes.Edited = []domain.EditedMessageForUser{{
|
|
UserID: req.OwnerUserID,
|
|
Message: msg,
|
|
Event: domain.UpdateEvent{
|
|
UserID: req.OwnerUserID,
|
|
Type: domain.UpdateEventEditMessage,
|
|
Pts: 7,
|
|
PtsCount: 1,
|
|
Date: req.EditDate,
|
|
Message: msg,
|
|
},
|
|
}}
|
|
}
|
|
return s.editRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) DeleteMessages(_ context.Context, userID int64, req domain.DeleteMessagesRequest) (domain.DeleteMessagesResult, error) {
|
|
s.deleteMessagesReq = req
|
|
if s.deleteMessagesRes.OwnerUserID == 0 {
|
|
s.deleteMessagesRes.OwnerUserID = userID
|
|
}
|
|
return s.deleteMessagesRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) GetSavedDialogs(_ context.Context, _ int64, _ domain.SavedDialogsFilter) (domain.SavedDialogList, error) {
|
|
return domain.SavedDialogList{}, nil
|
|
}
|
|
|
|
func (s *captureMessages) GetPinnedSavedDialogs(_ context.Context, _ int64) (domain.SavedDialogList, error) {
|
|
return domain.SavedDialogList{}, nil
|
|
}
|
|
|
|
func (s *captureMessages) GetSavedDialogsByPeers(_ context.Context, _ int64, _ []domain.Peer) (domain.SavedDialogList, error) {
|
|
return domain.SavedDialogList{}, nil
|
|
}
|
|
|
|
func (s *captureMessages) ToggleSavedDialogPin(_ context.Context, _ int64, _ domain.Peer, _ bool) (bool, error) {
|
|
return false, nil
|
|
}
|
|
|
|
func (s *captureMessages) ReorderPinnedSavedDialogs(_ context.Context, _ int64, _ []domain.Peer, _ bool) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *captureMessages) DeleteSavedHistory(_ context.Context, _ int64, _ domain.DeleteSavedHistoryRequest) (domain.DeleteSavedHistoryResult, error) {
|
|
return domain.DeleteSavedHistoryResult{}, nil
|
|
}
|
|
|
|
func (s *captureMessages) DeleteHistory(_ context.Context, userID int64, req domain.DeleteHistoryRequest) (domain.DeleteMessagesResult, error) {
|
|
s.deleteHistoryReq = req
|
|
if s.deleteHistoryRes.OwnerUserID == 0 {
|
|
s.deleteHistoryRes.OwnerUserID = userID
|
|
}
|
|
return s.deleteHistoryRes, nil
|
|
}
|
|
|
|
func (s *captureMessages) PinPrivateMessage(_ context.Context, userID int64, req domain.PinPrivateMessageRequest) (domain.PinPrivateMessageResult, error) {
|
|
return domain.PinPrivateMessageResult{OwnerUserID: userID}, nil
|
|
}
|
|
|
|
func (s *captureMessages) UnpinAllPrivateMessages(_ context.Context, userID int64, req domain.UnpinAllPrivateMessagesRequest) (domain.PinPrivateMessageResult, error) {
|
|
return domain.PinPrivateMessageResult{OwnerUserID: userID}, nil
|
|
}
|
|
|
|
func (s *captureMessages) ListUnreadReactionMessages(_ context.Context, _ int64, _ domain.Peer, _ int) ([]domain.Message, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *captureMessages) ReadPeerReactions(_ context.Context, _ int64, _ domain.Peer) (int, error) {
|
|
return 0, nil
|
|
}
|