gocw2/td.go

package main

import (
	"fmt"
	"log"
	"math"
	"time"

	"github.com/Arman92/go-tdlib"
)

func ListenCW(c *tdlib.Client) {
	eventFilter := func(msg *tdlib.TdMessage) bool {
		updateMsg := (*msg).(*tdlib.UpdateNewMessage)
		chatID := updateMsg.Message.ChatID
		forwardInfo := updateMsg.Message.ForwardInfo
		if chatID == user_chtwrsbot && forwardInfo == nil {
			return true
		}
		return false
	}

	receiver := c.AddEventReceiver(&tdlib.UpdateNewMessage{}, eventFilter, 100)
	for newMsg := range receiver.Chan {
		updateMsg := (newMsg).(*tdlib.UpdateNewMessage)
		senderUserID := updateMsg.Message.SenderUserID
		if updateMsg.Message.Content.GetMessageContentEnum() == tdlib.MessageTextType {
			user, err := c.GetUser(senderUserID)
			if err != nil {
				fmt.Println("ListenCW:", err.Error())
				continue
			}

			txt := updateMsg.Message.Content.(*tdlib.MessageText).Text.Text
			t := time.Now()

			m := ChatWarsMessage{
				SenderUserID64: int64(updateMsg.Message.SenderUserID),
				Date:           updateMsg.Message.Date,
				ID64:           updateMsg.Message.ID,
				ChatID64:       updateMsg.Message.ChatID,
				Text:           txt,
			}

			MQCWMsgQueue <- m

			fmt.Printf("[%d-%02d-%02d %02d:%02d:%02d-00:00]", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
			fmt.Println(" === CHATWARS (", user.Username, ") =====================================================================")
			fmt.Println(txt, "\n")
			fmt.Println("************ DETAILS ************")
			fmt.Println("ID : ", updateMsg.Message.ID)
			fmt.Println("Date : ", updateMsg.Message.Date)
			fmt.Println("SenderUserID : ", updateMsg.Message.SenderUserID)
			fmt.Println("ChatID : ", updateMsg.Message.ChatID)
			fmt.Println("SendingState : ", updateMsg.Message.SendingState)
			fmt.Println("IsOutgoing : ", updateMsg.Message.IsOutgoing)
			fmt.Println("CanBeEdited : ", updateMsg.Message.CanBeEdited)
			fmt.Println("CanBeForwarded : ", updateMsg.Message.CanBeForwarded)
			fmt.Println("IsChannelPost : ", updateMsg.Message.IsChannelPost)
			fmt.Println("ContainsUnreadMention : ", updateMsg.Message.ContainsUnreadMention)
			fmt.Println("ForwardInfo : ", updateMsg.Message.ForwardInfo)
			fmt.Println("ReplyToMessageID : ", updateMsg.Message.ReplyToMessageID)
			fmt.Println("ViaBotUserID : ", updateMsg.Message.ViaBotUserID)
			fmt.Println("================================================================================================================")

		}
	}
}

func getHistory(c *tdlib.Client, chatID64 *int64, senderUserID64 *int64) {
	var lastMsgID64 int64 = int64(math.MaxInt64)
	var msgCount int32 = 0
	var lastMsgTime time.Time = time.Now()
	var chat int64
	var m ChatWarsMessage

	if *chatID64 == 0 {
		chat = user_chtwrsbot
	} else {
		chat = *chatID64
	}

	fmt.Printf("Exporting historic messages for chat %d from user %d ...\n", chat, *senderUserID64)

	for lastMsgID64 >= 0 {
		msgs, err := c.GetChatHistory(chat, lastMsgID64, 0, 10, false)
		if err != nil {
			if err.Error() == "timeout" {
				logOnError(err, "Waiting...")
				fmt.Printf("Waiting : %d messages retrieved from %s ...\n", msgCount, lastMsgTime.Format(time.RFC3339))
			} else {
				logOnError(err, "Cannot get history")
				lastMsgID64 = -1
			}
		} else if msgs.TotalCount > 0 {
			fmt.Printf("Exported %d messages so far.\n", msgCount)
			for _, msg := range msgs.Messages {
				switch msg.Content.GetMessageContentEnum() {
				case tdlib.MessageTextType:
					if msg.ForwardInfo == nil {
						m = ChatWarsMessage{
							SenderUserID64: int64(msg.SenderUserID),
							Date:           msg.Date,
							ID64:           msg.ID,
							ChatID64:       msg.ChatID,
							Text:           msg.Content.(*tdlib.MessageText).Text.Text,
						}
					} else if msg.ForwardInfo.GetMessageForwardInfoEnum() == tdlib.MessageForwardedFromUserType {
						m = ChatWarsMessage{
							SenderUserID64: int64(msg.ForwardInfo.(*tdlib.MessageForwardedFromUser).SenderUserID),
							Date:           msg.ForwardInfo.(*tdlib.MessageForwardedFromUser).Date,
							ID64:           msg.ForwardInfo.(*tdlib.MessageForwardedFromUser).ForwardedFromMessageID,
							ChatID64:       msg.ForwardInfo.(*tdlib.MessageForwardedFromUser).ForwardedFromChatID,
							Text:           msg.Content.(*tdlib.MessageText).Text.Text,
						}
					} else {
						m = ChatWarsMessage{
							ID64: 0,
						}
					}

					if m.ID64 != 0 && (*senderUserID64 == 0 || m.SenderUserID64 == *senderUserID64) {
						MQCWMsgQueue <- m

						if m.ID64 < lastMsgID64 {
							lastMsgID64 = m.ID64
							lastMsgTime = time.Unix(int64(m.Date), 0)
						}
						msgCount = msgCount + 1
					}
				default:
					log.Printf("getHistory : no handler for %s\n", msg.Content.GetMessageContentEnum())
				}
			}
		} else {
			lastMsgID64 = -1
		}
	}
	log.Printf("Exported %d messages.\n", msgCount)
	fmt.Printf("Exported %d messages.\n", msgCount)
}

func ForwardMsg(c *tdlib.Client, msgID int64, fromChatID int64, toChatID int64) int64 {
	msgIDs := make([]int64, 1)
	msgIDs[0] = msgID
	msgs, _ := c.ForwardMessages(toChatID, fromChatID, msgIDs, false, false, false)
	if msgs != nil {
		return msgs.Messages[0].ID
	} else {
		return 0
	}
}

func DeleteMsg(c *tdlib.Client, chatID int64, msgID int64) {
	msgIDs := make([]int64, 1)
	msgIDs[0] = msgID
	c.DeleteMessages(chatID, msgIDs, false)
	fmt.Println("Deleting message ", msgID)
}

func OwnUserID(c *tdlib.Client) int32 {
	user, _ := c.GetMe()
	return user.ID
}