Handle updates of newmessage

3 files changed, 303 insertions, 4 deletions

diff --git a/telegram/client.go b/telegram/client.go
index e8643ce..a7fe332 100644
--- a/telegram/client.go
+++ b/telegram/client.go
@@ -53,6 +53,7 @@ type Client struct {
 	xmpp    *xmpp.Component
 	jid     string
 	Session *persistence.Session
+	content *config.TelegramContentConfig
 
 	locks  clientLocks
 	online bool
@@ -101,6 +102,7 @@ func NewClient(conf config.TelegramConfig, jid string, component *xmpp.Component
 		xmpp:         component,
 		jid:          jid,
 		Session:      session,
+		content:      &conf.Content,
 		logVerbosity: logVerbosity,
 		locks:        clientLocks{},
 	}, nil
diff --git a/telegram/handlers.go b/telegram/handlers.go
index 5ff5dad..d2d5b61 100644
--- a/telegram/handlers.go
+++ b/telegram/handlers.go
@@ -2,6 +2,7 @@ package telegram
 
 import (
 	"strconv"
+	"strings"
 
 	"dev.narayana.im/narayana/telegabber/xmpp/gateway"
 
@@ -38,6 +39,12 @@ func (c *Client) updateHandler() {
 					uhOh()
 				}
 				c.updateNewChat(typedUpdate)
+			case client.TypeUpdateNewMessage:
+				typedUpdate, ok := update.(*client.UpdateNewMessage)
+				if !ok {
+					uhOh()
+				}
+				c.updateNewMessage(typedUpdate)
 			default:
 				// log only handled types
 				continue
@@ -97,3 +104,54 @@ func (c *Client) updateNewChat(update *client.UpdateNewChat) {
 		c.processStatusUpdate(int32(update.Chat.Id), update.Chat.Title, "chat")
 	}
 }
+
+func (c *Client) updateNewMessage(update *client.UpdateNewMessage) {
+	// ignore self outgoing messages
+	if update.Message.IsOutgoing &&
+		update.Message.SendingState != nil &&
+		update.Message.SendingState.MessageSendingStateType() == client.TypeMessageSendingStatePending {
+		return
+	}
+
+	log.WithFields(log.Fields{
+		"chat_id": update.Message.ChatId,
+	}).Warn("New message from chat")
+
+	text := c.messageToText(update.Message)
+	file, filename := c.contentToFilename(update.Message.Content)
+
+	// download file(s)
+	if file != nil && !file.Local.IsDownloadingCompleted {
+		c.client.DownloadFile(&client.DownloadFileRequest{
+			FileId:      file.Id,
+			Priority:    32,
+			Synchronous: true,
+		})
+	}
+	// OTR support (I do not know why would you need it, seriously)
+	if !strings.HasPrefix(text, "?OTR") {
+		var prefix strings.Builder
+		prefix.WriteString(c.messageToPrefix(update.Message, c.formatContent(file, filename)))
+		if text != "" {
+			// \n if it is groupchat and message is not empty
+			if update.Message.ChatId < 0 {
+				prefix.WriteString("\n")
+			} else if update.Message.ChatId > 0 {
+				prefix.WriteString(" | ")
+			}
+
+			prefix.WriteString(text)
+		}
+
+		text = prefix.String()
+	}
+
+	// mark message as read
+	c.client.ViewMessages(&client.ViewMessagesRequest{
+		ChatId:     update.Message.ChatId,
+		MessageIds: []int64{update.Message.Id},
+		ForceRead:  true,
+	})
+	// forward message to XMPP
+	gateway.SendMessage(c.jid, strconv.Itoa(int(update.Message.ChatId)), text, c.xmpp)
+}
diff --git a/telegram/utils.go b/telegram/utils.go
index ac17906..6ec4405 100644
--- a/telegram/utils.go
+++ b/telegram/utils.go
@@ -2,10 +2,15 @@ package telegram
 
 import (
 	"crypto/sha1"
+	"crypto/sha256"
+	"fmt"
 	"github.com/pkg/errors"
 	"io"
 	"os"
+	"path/filepath"
+	"regexp"
 	"strconv"
+	"strings"
 	"time"
 
 	"dev.narayana.im/narayana/telegabber/xmpp/gateway"
@@ -17,6 +22,10 @@ import (
 
 var errOffline = errors.New("TDlib instance is offline")
 
+var spaceRegex = regexp.MustCompile(`\s+`)
+
+const newlineChar string = "\n"
+
 // GetContactByUsername resolves username to user id retrieves user and chat information
 func (c *Client) GetContactByUsername(username string) (*client.Chat, *client.User, error) {
 	if !c.online {
@@ -95,10 +104,7 @@ func userStatusToText(status client.UserStatus) (string, string) {
 	case client.TypeUserStatusEmpty:
 		show, textStatus = "unavailable", "Last seen a long time ago"
 	case client.TypeUserStatusOffline:
-		offlineStatus, ok := status.(*client.UserStatusOffline)
-		if !ok {
-			log.Fatal("Status type changed before conversion!")
-		}
+		offlineStatus, _ := status.(*client.UserStatusOffline)
 		// this will stop working in 2038 O\
 		elapsed := time.Now().Unix() - int64(offlineStatus.WasOnline)
 		if elapsed < 3600 {
@@ -167,6 +173,239 @@ func (c *Client) processStatusUpdate(chatID int32, status string, show string, a
 	return nil
 }
 
+func (c *Client) formatContact(chatID int32) string {
+	if chatID == 0 {
+		return ""
+	}
+
+	chat, user, err := c.GetContactByID(chatID, nil)
+	if err != nil {
+		return "unknown contact: " + err.Error()
+	}
+
+	var str string
+	if chat != nil {
+		str = fmt.Sprintf("%s (%v)", chat.Title, chat.Id)
+	} else if user != nil {
+		username := user.Username
+		if username == "" {
+			username = strconv.Itoa(int(user.Id))
+		}
+
+		str = fmt.Sprintf("%s %s (%v)", user.FirstName, user.LastName, username)
+	} else {
+		str = strconv.Itoa(int(chatID))
+	}
+
+	str = spaceRegex.ReplaceAllString(str, " ")
+
+	return str
+}
+
+func (c *Client) formatMessage(chatID int64, messageID int64, preview bool, message *client.Message) string {
+	var err error
+	if message == nil {
+		message, err = c.client.GetMessage(&client.GetMessageRequest{
+			ChatId:    chatID,
+			MessageId: messageID,
+		})
+		if err != nil {
+			return "<error fetching message>"
+		}
+	}
+
+	if message == nil {
+		return ""
+	}
+
+	var str strings.Builder
+	str.WriteString(fmt.Sprintf("%v | %s | ", message.Id, c.formatContact(message.SenderUserId)))
+	// TODO: timezone
+	if !preview {
+		str.WriteString(time.Unix(int64(message.Date), 0).Format("02 Jan 2006 15:04:05 | "))
+	}
+
+	var text string
+	switch message.Content.MessageContentType() {
+	case client.TypeMessageText:
+		messageText, _ := message.Content.(*client.MessageText)
+		text = messageText.Text.Text
+		// TODO: handle other message types with labels (not supported in Zhabogram!)
+	}
+	if text != "" {
+		if !preview {
+			str.WriteString(text)
+		} else {
+			newlinePos := strings.Index(text, newlineChar)
+			if !preview || newlinePos == -1 {
+				str.WriteString(text)
+			} else {
+				str.WriteString(text[0:newlinePos])
+			}
+		}
+	}
+
+	return str.String()
+}
+
+func (c *Client) formatContent(file *client.File, filename string) string {
+	if file == nil {
+		return ""
+	}
+
+	return fmt.Sprintf(
+		"%s (%v kbytes) | %s/%s%s",
+		filename,
+		file.Size/1024,
+		c.content.Link,
+		fmt.Sprintf("%x", sha256.Sum256([]byte(file.Remote.Id))),
+		filepath.Ext(filename),
+	)
+}
+
+func (c *Client) messageToText(message *client.Message) string {
+	switch message.Content.MessageContentType() {
+	case client.TypeMessageSticker:
+		sticker, _ := message.Content.(*client.MessageSticker)
+		return sticker.Sticker.Emoji
+	case client.TypeMessageBasicGroupChatCreate, client.TypeMessageSupergroupChatCreate:
+		return "has created chat"
+	case client.TypeMessageChatJoinByLink:
+		return "joined chat via invite link"
+	case client.TypeMessageChatAddMembers:
+		addMembers, _ := message.Content.(*client.MessageChatAddMembers)
+
+		text := "invited "
+		if len(addMembers.MemberUserIds) > 0 {
+			text += c.formatContact(addMembers.MemberUserIds[0])
+		}
+
+		return text
+	case client.TypeMessageChatDeleteMember:
+		deleteMember, _ := message.Content.(*client.MessageChatDeleteMember)
+		return "kicked " + c.formatContact(deleteMember.UserId)
+	case client.TypeMessagePinMessage:
+		pinMessage, _ := message.Content.(*client.MessagePinMessage)
+		return "pinned message: " + c.formatMessage(message.ChatId, pinMessage.MessageId, false, nil)
+	case client.TypeMessageChatChangeTitle:
+		changeTitle, _ := message.Content.(*client.MessageChatChangeTitle)
+		return "chat title set to: " + changeTitle.Title
+	case client.TypeMessageLocation:
+		location, _ := message.Content.(*client.MessageLocation)
+		return fmt.Sprintf(
+			"coordinates: %v,%v | https://www.google.com/maps/search/%v,%v/",
+			location.Location.Latitude,
+			location.Location.Longitude,
+			location.Location.Latitude,
+			location.Location.Longitude,
+		)
+	case client.TypeMessagePhoto:
+		photo, _ := message.Content.(*client.MessagePhoto)
+		return photo.Caption.Text
+	case client.TypeMessageAudio:
+		audio, _ := message.Content.(*client.MessageAudio)
+		return audio.Caption.Text
+	case client.TypeMessageVideo:
+		video, _ := message.Content.(*client.MessageVideo)
+		return video.Caption.Text
+	case client.TypeMessageDocument:
+		document, _ := message.Content.(*client.MessageDocument)
+		return document.Caption.Text
+	case client.TypeMessageText:
+		text, _ := message.Content.(*client.MessageText)
+		return text.Text.Text
+	case client.TypeMessageVoiceNote:
+		voice, _ := message.Content.(*client.MessageVoiceNote)
+		return voice.Caption.Text
+	case client.TypeMessageVideoNote:
+		return ""
+	case client.TypeMessageAnimation:
+		animation, _ := message.Content.(*client.MessageAnimation)
+		return animation.Caption.Text
+	}
+
+	return fmt.Sprintf("unknown message (%s)", message.Content.MessageContentType())
+}
+
+func (c *Client) contentToFilename(content client.MessageContent) (*client.File, string) {
+	switch content.MessageContentType() {
+	case client.TypeMessageSticker:
+		sticker, _ := content.(*client.MessageSticker)
+		return sticker.Sticker.Sticker, "sticker.webp"
+	case client.TypeMessageVoiceNote:
+		voice, _ := content.(*client.MessageVoiceNote)
+		return voice.VoiceNote.Voice, fmt.Sprintf("voice note (%v s.).oga", voice.VoiceNote.Duration)
+	case client.TypeMessageVideoNote:
+		video, _ := content.(*client.MessageVideoNote)
+		return video.VideoNote.Video, fmt.Sprintf("video note (%v s.).mp4", video.VideoNote.Duration)
+	case client.TypeMessageAnimation:
+		animation, _ := content.(*client.MessageAnimation)
+		return animation.Animation.Animation, "animation.mp4"
+	case client.TypeMessagePhoto:
+		photo, _ := content.(*client.MessagePhoto)
+		sizes := photo.Photo.Sizes
+		file := sizes[len(sizes)-1].Photo
+		if len(sizes) > 1 {
+			return file, strconv.Itoa(int(file.Id)) + ".jpg"
+		} else {
+			return nil, ""
+		}
+	case client.TypeMessageAudio:
+		audio, _ := content.(*client.MessageAudio)
+		return audio.Audio.Audio, audio.Audio.FileName
+	case client.TypeMessageVideo:
+		video, _ := content.(*client.MessageVideo)
+		return video.Video.Video, video.Video.FileName
+	case client.TypeMessageDocument:
+		document, _ := content.(*client.MessageDocument)
+		return document.Document.Document, document.Document.FileName
+	}
+
+	return nil, ""
+}
+
+func (c *Client) messageToPrefix(message *client.Message, fileString string) string {
+	prefix := []string{}
+	// message direction
+	var directionChar string
+	if message.IsOutgoing {
+		directionChar = "➡ "
+	} else {
+		directionChar = "⬅ "
+	}
+	prefix = append(prefix, directionChar+strconv.Itoa(int(message.Id)))
+	// show sender in group chats
+	if message.ChatId < 0 && message.SenderUserId != 0 {
+		prefix = append(prefix, c.formatContact(message.SenderUserId))
+	}
+	if message.ForwardInfo != nil {
+		switch message.ForwardInfo.Origin.MessageForwardOriginType() {
+		case client.TypeMessageForwardOriginUser:
+			originUser := message.ForwardInfo.Origin.(*client.MessageForwardOriginUser)
+			prefix = append(prefix, "fwd: "+c.formatContact(originUser.SenderUserId))
+		case client.TypeMessageForwardOriginHiddenUser:
+			originUser := message.ForwardInfo.Origin.(*client.MessageForwardOriginHiddenUser)
+			prefix = append(prefix, fmt.Sprintf("fwd: anonymous (%s)", originUser.SenderName))
+		case client.TypeMessageForwardOriginChannel:
+			channel := message.ForwardInfo.Origin.(*client.MessageForwardOriginChannel)
+			var signature string
+			if channel.AuthorSignature != "" {
+				signature = fmt.Sprintf(" (%s)", channel.AuthorSignature)
+			}
+			prefix = append(prefix, "fwd: "+c.formatContact(int32(channel.ChatId))+signature)
+		}
+	}
+	// reply to
+	if message.ReplyToMessageId != 0 {
+		prefix = append(prefix, "reply: "+c.formatMessage(message.ChatId, message.ReplyToMessageId, true, nil))
+	}
+	if fileString != "" {
+		prefix = append(prefix, "file: "+fileString)
+	}
+
+	return strings.Join(prefix, " | ")
+}
+
 func (c *Client) ProcessOutgoingMessage(chatID int, text string, messageID int) {
 	// TODO
 }