290 lines
8.4 KiB
Go
290 lines
8.4 KiB
Go
package cache
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"sort"
|
|
|
|
"go.mau.fi/mautrix-gmessages/libgm/binary"
|
|
)
|
|
|
|
type SmallInfo struct {
|
|
Type int64 `json:"type,omitempty"`
|
|
Number string `json:"number,omitempty"`
|
|
ParticipantId string `json:"participantId,omitempty"`
|
|
}
|
|
|
|
type Participant struct {
|
|
SmallInfo *SmallInfo `json:"smallInfo,omitempty"`
|
|
HexHash string `json:"hexHash,omitempty"`
|
|
IsMe bool `json:"isMe,omitempty"`
|
|
Bs int64 `json:"bs,omitempty"`
|
|
DisplayName string `json:"displayName,omitempty"`
|
|
}
|
|
|
|
type ImagePixels struct {
|
|
Width int64 `json:"width,omitempty"`
|
|
Height int64 `json:"height,omitempty"`
|
|
}
|
|
|
|
type ImageMessage struct {
|
|
SomeNumber int64 `json:"someNumber"`
|
|
ImageId string `json:"imageId"`
|
|
ImageName string `json:"imageName"`
|
|
Size int64 `json:"size"`
|
|
Pixels ImagePixels `json:"pixels"`
|
|
ImageBuffer []byte `json:"imageBuffer"`
|
|
DecryptionKey []byte `json:"decryptionKey"`
|
|
}
|
|
|
|
type TextMessage struct {
|
|
Content string `json:"content"`
|
|
}
|
|
|
|
type IsFromMe struct {
|
|
FromMe bool `json:"fromMe"`
|
|
}
|
|
|
|
type MessageData struct {
|
|
OrderInternal string `json:"orderInternal"`
|
|
TextData *TextMessage `json:"textData,omitempty"`
|
|
ImageData *ImageMessage `json:"imageData,omitempty"`
|
|
}
|
|
|
|
type MessageStatus struct {
|
|
Code int64 `json:"code,omitempty"`
|
|
ErrMsg string `json:"errMsg,omitempty"`
|
|
MsgType string `json:"msgType,omitempty"`
|
|
}
|
|
|
|
type Message struct {
|
|
cache *Cache
|
|
|
|
MessageId string `json:"messageId"`
|
|
From IsFromMe `json:"from"`
|
|
MessageStatus MessageStatus `json:"details"`
|
|
Timestamp int64 `json:"timestamp"`
|
|
ConvId string `json:"convId"`
|
|
ParticipantId string `json:"participantId"`
|
|
MessageData []MessageData `json:"messageData"`
|
|
MessageType string `json:"messageType"`
|
|
}
|
|
|
|
func (m *Message) FromMe() bool {
|
|
conv, _ := m.cache.Conversations.GetConversation(m.ConvId)
|
|
return m.ParticipantId == conv.SelfParticipantId
|
|
}
|
|
|
|
type LatestMessage struct {
|
|
Content string `json:"content,omitempty"`
|
|
FromMe bool `json:"fromMe,omitempty"`
|
|
DisplayName string `json:"displayName,omitempty"`
|
|
MessageId string `json:"messageId,omitempty"`
|
|
}
|
|
|
|
type Conversation struct {
|
|
cache *Cache
|
|
|
|
MessageOrder map[int]string `json:"messageOrder"`
|
|
Messages map[string]Message `json:"messages"`
|
|
ConversationId string `json:"conversationId"`
|
|
DisplayName string `json:"displayName"`
|
|
LatestMessage LatestMessage `json:"latestMessage"`
|
|
IsGroupChat bool `json:"isGroupChat,omitempty"`
|
|
Timestamp int64 `json:"timestamp"`
|
|
Status int64 `json:"status"`
|
|
HexHash string `json:"hexHash"`
|
|
Type int64 `json:"type"`
|
|
SelfParticipantId string `json:"selfParticipantId,omitempty"`
|
|
Participants []Participant `json:"participants"`
|
|
ParticipantIds []string `json:"participantIds,omitempty"` // excluded self id
|
|
}
|
|
|
|
type Conversations struct {
|
|
cache *Cache
|
|
/*
|
|
{0: "1", 1: "4"}
|
|
order -> conversationId
|
|
index 0 = first conversation in order
|
|
*/
|
|
Order map[int]string `json:"order"`
|
|
/*
|
|
Map conversations by conversationId
|
|
*/
|
|
Conversations map[string]*Conversation `json:"conversations"`
|
|
}
|
|
|
|
func (c *Conversations) SetCache(cache *Cache) {
|
|
c.cache = cache
|
|
}
|
|
|
|
func (c *Conversations) DeleteConversation(convId string) {
|
|
delete(c.Conversations, convId)
|
|
}
|
|
|
|
func (c *Conversations) UpdateConversation(conversation *binary.Conversation) *Conversation {
|
|
newConversation := NewConversation(c.cache, conversation)
|
|
c.Conversations[conversation.ConversationId] = newConversation
|
|
return newConversation
|
|
}
|
|
|
|
func (c *Conversation) GetMessage(msgId string) (Message, error) {
|
|
message, foundMsg := c.Messages[msgId]
|
|
if !foundMsg {
|
|
return Message{}, fmt.Errorf("could not find that message cached")
|
|
}
|
|
return message, nil
|
|
}
|
|
|
|
func (c *Conversation) Delete() {
|
|
c.cache.Conversations.DeleteConversation(c.ConversationId)
|
|
}
|
|
|
|
func (c *Conversation) UpdateMessage(msg *binary.Message) Message {
|
|
newMsg := NewMessage(c.cache, msg)
|
|
|
|
if c.Messages == nil {
|
|
log.Println("c.messages was nil so created new map")
|
|
c.Messages = make(map[string]Message)
|
|
}
|
|
|
|
c.Messages[msg.MessageId] = newMsg
|
|
return newMsg
|
|
}
|
|
|
|
func (c *Conversations) GetConversationByOrder(order int) (*Conversation, error) {
|
|
convId, ok := c.Order[order]
|
|
if !ok {
|
|
return &Conversation{}, fmt.Errorf("could not find a conversation that occupies that order")
|
|
}
|
|
conversation, foundConvo := c.Conversations[convId]
|
|
if !foundConvo {
|
|
return &Conversation{}, fmt.Errorf("could not find that conversation cached, oddly enough it seems to be cached in the order map though... investigate further")
|
|
}
|
|
return conversation, nil
|
|
}
|
|
|
|
func (c *Conversation) GetOrderSlice() []string {
|
|
keys := make([]string, 0, len(c.Messages))
|
|
for k := range c.Messages {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Slice(keys, func(i, j int) bool {
|
|
return c.Messages[keys[i]].Timestamp < c.Messages[keys[j]].Timestamp
|
|
})
|
|
return keys
|
|
}
|
|
|
|
func (c *Conversations) GetOrderSlice() []int {
|
|
s := make([]int, 0)
|
|
for i := range c.Order {
|
|
s = append(s, i)
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (c *Conversations) GetConversation(convId string) (*Conversation, error) {
|
|
convo, ok := c.Conversations[convId]
|
|
if !ok {
|
|
// handle error, such as creating a new conversation or returning
|
|
return &Conversation{}, fmt.Errorf("could not find conversation cached")
|
|
} else {
|
|
return convo, nil
|
|
}
|
|
}
|
|
|
|
func NewConversation(cache *Cache, conv *binary.Conversation) *Conversation {
|
|
currConv, convErr := cache.Conversations.GetConversation(conv.ConversationId)
|
|
participants := ParseParticipants(conv.Participants)
|
|
newConversation := Conversation{
|
|
cache: cache,
|
|
ConversationId: conv.ConversationId,
|
|
DisplayName: conv.Name,
|
|
Timestamp: conv.TimestampMs,
|
|
Status: conv.Status,
|
|
HexHash: conv.HashHex,
|
|
Type: conv.Type,
|
|
Participants: participants,
|
|
ParticipantIds: conv.OtherParticipants,
|
|
SelfParticipantId: conv.SelfParticipantId,
|
|
}
|
|
|
|
if conv.LatestMessage != nil {
|
|
newConversation.LatestMessage = LatestMessage{
|
|
Content: conv.LatestMessage.Content,
|
|
FromMe: conv.LatestMessage.FromMe,
|
|
DisplayName: conv.LatestMessage.DisplayName,
|
|
MessageId: conv.MessageId,
|
|
}
|
|
}
|
|
|
|
if convErr == nil {
|
|
newConversation.MessageOrder = currConv.MessageOrder
|
|
newConversation.Messages = currConv.Messages
|
|
} else {
|
|
newConversation.MessageOrder = make(map[int]string)
|
|
newConversation.Messages = make(map[string]Message)
|
|
}
|
|
return &newConversation
|
|
}
|
|
|
|
func ParseParticipants(participants []*binary.Participant) []Participant {
|
|
partSlice := make([]Participant, 0)
|
|
for _, p := range participants {
|
|
partSlice = append(partSlice, Participant{
|
|
SmallInfo: &SmallInfo{
|
|
Type: p.SmallInfo.Type,
|
|
Number: p.SmallInfo.Number,
|
|
ParticipantId: p.SmallInfo.ParticipantId,
|
|
},
|
|
HexHash: p.HashHex,
|
|
IsMe: p.IsMe,
|
|
Bs: p.Bs,
|
|
DisplayName: p.DisplayName,
|
|
})
|
|
}
|
|
return partSlice
|
|
}
|
|
|
|
func NewMessage(cache *Cache, message *binary.Message) Message {
|
|
msg := Message{
|
|
cache: cache,
|
|
MessageId: message.MessageId,
|
|
ConvId: message.ConversationId,
|
|
From: IsFromMe{
|
|
FromMe: message.From.FromMe,
|
|
},
|
|
Timestamp: message.Timestamp,
|
|
ParticipantId: message.ParticipantId,
|
|
MessageType: message.Type.String(),
|
|
MessageStatus: MessageStatus{
|
|
Code: message.MessageStatus.Code,
|
|
ErrMsg: message.MessageStatus.ErrMsg,
|
|
MsgType: message.MessageStatus.MsgStatus,
|
|
},
|
|
MessageData: make([]MessageData, 0),
|
|
}
|
|
for _, data := range message.MessageInfo {
|
|
msgData := MessageData{
|
|
OrderInternal: data.OrderInternal,
|
|
}
|
|
switch d := data.Data.(type) {
|
|
case *binary.MessageInfo_ImageContent:
|
|
msgData.ImageData = &ImageMessage{
|
|
SomeNumber: d.ImageContent.SomeNumber,
|
|
ImageId: d.ImageContent.ImageId,
|
|
ImageName: d.ImageContent.ImageName,
|
|
Size: d.ImageContent.Size,
|
|
Pixels: ImagePixels{Width: d.ImageContent.Pixels.Width, Height: d.ImageContent.Pixels.Height},
|
|
ImageBuffer: d.ImageContent.ImageData,
|
|
DecryptionKey: d.ImageContent.DecryptionKey,
|
|
}
|
|
case *binary.MessageInfo_MessageContent:
|
|
msgData.TextData = &TextMessage{
|
|
Content: d.MessageContent.Content,
|
|
}
|
|
}
|
|
msg.MessageData = append(msg.MessageData, msgData)
|
|
}
|
|
return msg
|
|
}
|