package telegram import ( "fmt" "github.com/pkg/errors" "regexp" "strconv" "strings" "time" "dev.narayana.im/narayana/telegabber/xmpp/gateway" log "github.com/sirupsen/logrus" "github.com/zelenin/go-tdlib/client" ) const notEnoughArguments string = "Not enough arguments" const telegramNotInitialized string = "Telegram connection is not initialized yet" const notOnline string = "Not online" var transportCommands = map[string]command{ "login": command{"phone", "sign in"}, "logout": command{"", "sign out"}, "code": command{"", "check one-time code"}, "password": command{"", "check 2fa password"}, "setusername": command{"", "update @username"}, "setname": command{"first last", "update name"}, "setbio": command{"", "update about"}, "setpassword": command{"[old] [new]", "set or remove password"}, "config": command{"[param] [value]", "view or update configuration options"}, } var chatCommands = map[string]command{ "d": command{"[n]", "delete your last message(s)"}, "s": command{"regex replace", "edit your last message"}, "add": command{"@username", "add @username to your chat list"}, "join": command{"https://t.me/invite_link", "join to chat via invite link"}, "group": command{"title", "create groupchat «title» with current user"}, "supergroup": command{"title description", "create new supergroup «title» with «description»"}, "channel": command{"title description", "create new channel «title» with «description»"}, "secret": command{"", "create secretchat with current user"}, "search": command{"string [limit]", "search in current chat"}, "history": command{"[limit]", "get last [limit] messages from current chat"}, "block": command{"", "blacklist current user"}, "unblock": command{"", "unblacklist current user"}, "invite": command{"id or @username", "add user to current chat"}, "kick": command{"id or @username", "remove user to current chat"}, "ban": command{"id or @username [hours]", "restrict @username from current chat for [hours] or forever"}, "leave": command{"", "leave current chat"}, "close": command{"", "close current secret chat"}, "delete": command{"", "delete current chat from chat list"}, "members": command{"[query]", "search members [by optional query] in current chat (requires admin rights)"}, } var transportConfigurationOptions = map[string]configurationOption{ "timezone": configurationOption{"00:00", "adjust timezone for Telegram user statuses"}, } type command struct { arguments string description string } type configurationOption command type helpType int const ( helpTypeTransport helpType = iota helpTypeChat ) func helpString(ht helpType) string { var str strings.Builder var commandMap map[string]command switch ht { case helpTypeTransport: commandMap = transportCommands case helpTypeChat: commandMap = chatCommands } str.WriteString("Available commands:\n") for name, command := range commandMap { str.WriteString("/") str.WriteString(name) if command.arguments != "" { str.WriteString(" ") str.WriteString(command.arguments) } str.WriteString(" — ") str.WriteString(command.description) str.WriteString("\n") } if ht == helpTypeTransport { str.WriteString("Configuration options\n") for name, option := range transportConfigurationOptions { str.WriteString(name) str.WriteString(" ") str.WriteString(option.arguments) str.WriteString(" — ") str.WriteString(option.description) str.WriteString("\n") } } return str.String() } func parseCommand(cmdline string) (string, []string) { bodyFields := strings.Fields(cmdline) return bodyFields[0][1:], bodyFields[1:] } func (c *Client) unsubscribe(chatID int64) { gateway.SendPresence( c.xmpp, c.jid, gateway.SPFrom(strconv.FormatInt(chatID, 10)), gateway.SPType("unsubscribed"), ) } func (c *Client) sendMessagesReverse(chatID int64, messages []*client.Message) { for i := len(messages) - 1; i >= 0; i-- { gateway.SendMessage( c.jid, strconv.FormatInt(chatID, 10), c.formatMessage(0, 0, false, messages[i]), c.xmpp, ) } } func (c *Client) usernameOrIDToID(username string) (int64, error) { userID, err := strconv.ParseInt(username, 10, 64) // couldn't parse the id, try to lookup as a username if err != nil { chat, err := c.client.SearchPublicChat(&client.SearchPublicChatRequest{ Username: username, }) if err != nil { return 0, err } userID = chat.ID if userID <= 0 { return 0, errors.New("Not a user") } } return userID, nil } // ProcessTransportCommand executes a command sent directly to the component // and returns a response func (c *Client) ProcessTransportCommand(cmdline string) string { cmd, args := parseCommand(cmdline) switch cmd { case "login", "code", "password": if cmd == "login" && c.Session.Login != "" { return "" } if len(args) < 1 { return notEnoughArguments } if cmd == "login" { wasSessionLoginEmpty := c.Session.Login == "" c.Session.Login = args[0] if wasSessionLoginEmpty && c.authorizer == nil { go func() { err := c.Connect() if err != nil { log.Error(errors.Wrap(err, "TDlib connection failure")) } }() // a quirk for authorizer to become ready. If it's still not, // nothing bad: the command just needs to be resent again time.Sleep(1e5) } } if c.authorizer == nil { return telegramNotInitialized } switch cmd { // sign in case "login": c.authorizer.PhoneNumber <- args[0] // check auth code case "code": c.authorizer.Code <- args[0] // check auth password case "password": c.authorizer.Password <- args[0] } // sign out case "logout": if !c.Online() { return notOnline } for _, id := range c.cache.ChatsKeys() { c.unsubscribe(id) } _, err := c.client.LogOut() if err != nil { c.forceClose() return errors.Wrap(err, "Logout error").Error() } c.Session.Login = "" // set @username case "setusername": if !c.Online() { return notOnline } var username string if len(args) > 0 { username = args[0] } _, err := c.client.SetUsername(&client.SetUsernameRequest{ Username: username, }) if err != nil { return errors.Wrap(err, "Couldn't set username").Error() } // set My Name case "setname": if !c.Online() { return notOnline } var firstname string var lastname string if len(args) > 0 { firstname = args[0] } if len(args) > 1 { lastname = args[1] } _, err := c.client.SetName(&client.SetNameRequest{ FirstName: firstname, LastName: lastname, }) if err != nil { return errors.Wrap(err, "Couldn't set name").Error() } // set About case "setbio": if !c.Online() { return notOnline } _, err := c.client.SetBio(&client.SetBioRequest{ Bio: strings.Join(args, " "), }) if err != nil { return errors.Wrap(err, "Couldn't set bio").Error() } // set password case "setpassword": if !c.Online() { return notOnline } var oldPassword string var newPassword string // 0 or 1 argument is ignored and the password is reset if len(args) > 1 { oldPassword = args[0] newPassword = args[1] } _, err := c.client.SetPassword(&client.SetPasswordRequest{ OldPassword: oldPassword, NewPassword: newPassword, }) if err != nil { return errors.Wrap(err, "Couldn't set password").Error() } case "config": if len(args) > 1 { value, err := c.Session.Set(args[0], args[1]) if err != nil { return err.Error() } return fmt.Sprintf("%s set to %s", args[0], value) } else if len(args) > 0 { value, err := c.Session.Get(args[0]) if err != nil { return err.Error() } return fmt.Sprintf("%s is set to %s", args[0], value) } var entries []string for key, value := range c.Session.ToMap() { entries = append(entries, fmt.Sprintf("%s is set to %s", key, value)) } return strings.Join(entries, "\n") case "help": return helpString(helpTypeTransport) } return "" } // ProcessChatCommand executes a command sent in a mapped chat // and returns a response and the status of command support func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool) { if !c.Online() { return notOnline, true } cmd, args := parseCommand(cmdline) switch cmd { // delete last message(s) case "d": if c.me == nil { return "@me is not initialized", true } var limit int32 if len(args) > 0 { limit64, err := strconv.ParseInt(args[0], 10, 32) if err != nil { return err.Error(), true } limit = int32(limit64) } else { limit = 1 } messages, err := c.client.SearchChatMessages(&client.SearchChatMessagesRequest{ ChatID: chatID, Limit: limit, Sender: &client.MessageSenderUser{UserID: c.me.ID}, Filter: &client.SearchMessagesFilterEmpty{}, }) if err != nil { return err.Error(), true } log.Debugf("pre-deletion query: %#v %#v", messages, messages.Messages) var messageIds []int64 for _, message := range messages.Messages { if message != nil { messageIds = append(messageIds, message.ID) } } _, err = c.client.DeleteMessages(&client.DeleteMessagesRequest{ ChatID: chatID, MessageIDs: messageIds, Revoke: true, }) if err != nil { return err.Error(), true } // edit last message case "s": if c.me == nil { return "@me is not initialized", true } if len(args) < 2 { return "Not enough arguments", true } regex, err := regexp.Compile(args[0]) if err != nil { return err.Error(), true } messages, err := c.client.SearchChatMessages(&client.SearchChatMessagesRequest{ ChatID: chatID, Limit: 1, Sender: &client.MessageSenderUser{UserID: c.me.ID}, Filter: &client.SearchMessagesFilterEmpty{}, }) if err != nil { return err.Error(), true } if len(messages.Messages) == 0 { return "No last message", true } message := messages.Messages[0] if message == nil { return "Last message is empty", true } messageText, ok := message.Content.(*client.MessageText) if !ok { return "Last message is not a text!", true } text := regex.ReplaceAllString(messageText.Text.Text, strings.Join(args[1:], " ")) c.ProcessOutgoingMessage(chatID, text, message.ID, "") // add @contact case "add": if len(args) < 1 { return notEnoughArguments, true } chat, err := c.client.SearchPublicChat(&client.SearchPublicChatRequest{ Username: args[0], }) if err != nil { return err.Error(), true } if chat == nil { return "No error, but chat is nil", true } gateway.SendPresence( c.xmpp, c.jid, gateway.SPFrom(strconv.FormatInt(chat.ID, 10)), gateway.SPType("subscribe"), ) // join https://t.me/publichat case "join": if len(args) < 1 { return notEnoughArguments, true } _, err := c.client.JoinChatByInviteLink(&client.JoinChatByInviteLinkRequest{ InviteLink: args[0], }) if err != nil { return err.Error(), true } // create new supergroup case "supergroup": if len(args) < 1 { return notEnoughArguments, true } _, err := c.client.CreateNewSupergroupChat(&client.CreateNewSupergroupChatRequest{ Title: args[0], Description: strings.Join(args[1:], " "), }) if err != nil { return err.Error(), true } // create new channel case "channel": if len(args) < 1 { return notEnoughArguments, true } _, err := c.client.CreateNewSupergroupChat(&client.CreateNewSupergroupChatRequest{ Title: args[0], Description: strings.Join(args[1:], " "), IsChannel: true, }) if err != nil { return err.Error(), true } // create new secret chat with current user case "secret": _, user, err := c.GetContactByID(chatID, nil) if err != nil || user == nil { return "User not found", true } _, err = c.client.CreateNewSecretChat(&client.CreateNewSecretChatRequest{ UserID: chatID, }) if err != nil { return err.Error(), true } // create group chat with current user case "group": if len(args) < 1 { return notEnoughArguments, true } if chatID > 0 { _, err := c.client.CreateNewBasicGroupChat(&client.CreateNewBasicGroupChatRequest{ UserIDs: []int64{chatID}, Title: args[0], }) if err != nil { return err.Error(), true } } // blacklists current user case "block": if chatID > 0 { _, err := c.client.ToggleMessageSenderIsBlocked(&client.ToggleMessageSenderIsBlockedRequest{ Sender: &client.MessageSenderUser{UserID: chatID}, IsBlocked: true, }) if err != nil { return err.Error(), true } } // unblacklists current user case "unblock": if chatID > 0 { _, err := c.client.ToggleMessageSenderIsBlocked(&client.ToggleMessageSenderIsBlockedRequest{ Sender: &client.MessageSenderUser{UserID: chatID}, IsBlocked: false, }) if err != nil { return err.Error(), true } } // invite @username to current groupchat case "invite": if len(args) < 1 { return notEnoughArguments, true } if chatID < 0 { userID, err := c.usernameOrIDToID(args[0]) if err != nil { return err.Error(), true } _, err = c.client.AddChatMember(&client.AddChatMemberRequest{ ChatID: chatID, UserID: userID, }) if err != nil { return err.Error(), true } } // kick @username from current group chat case "kick": if len(args) < 1 { return notEnoughArguments, true } if chatID < 0 { userID, err := c.usernameOrIDToID(args[0]) if err != nil { return err.Error(), true } _, err = c.client.SetChatMemberStatus(&client.SetChatMemberStatusRequest{ ChatID: chatID, UserID: userID, Status: &client.ChatMemberStatusLeft{}, }) if err != nil { return err.Error(), true } } // ban @username from current chat [for N hours] case "ban": if len(args) < 1 { return notEnoughArguments, true } if chatID < 0 { userID, err := c.usernameOrIDToID(args[0]) if err != nil { return err.Error(), true } var until int32 if len(args) > 1 { hours, err := strconv.ParseInt(args[1], 10, 32) if err != nil { until = int32(time.Now().Unix() + hours*3600) } } _, err = c.client.SetChatMemberStatus(&client.SetChatMemberStatusRequest{ ChatID: chatID, UserID: userID, Status: &client.ChatMemberStatusBanned{ BannedUntilDate: until, }, }) if err != nil { return err.Error(), true } } // leave current chat case "leave": chat, _, err := c.GetContactByID(chatID, nil) if err != nil { return err.Error(), true } chatType := chat.Type.ChatTypeType() if chatType == client.TypeChatTypeBasicGroup || chatType == client.TypeChatTypeSupergroup { _, err = c.client.LeaveChat(&client.LeaveChatRequest{ ChatID: chatID, }) if err != nil { return err.Error(), true } c.unsubscribe(chatID) } // close secret chat case "close": chat, _, err := c.GetContactByID(chatID, nil) if err != nil { return err.Error(), true } chatType := chat.Type.ChatTypeType() if chatType == client.TypeChatTypeSecret { chatTypeSecret, _ := chat.Type.(*client.ChatTypeSecret) _, err = c.client.CloseSecretChat(&client.CloseSecretChatRequest{ SecretChatID: chatTypeSecret.SecretChatID, }) if err != nil { return err.Error(), true } c.unsubscribe(chatID) } // delete current chat case "delete": _, err := c.client.DeleteChatHistory(&client.DeleteChatHistoryRequest{ ChatID: chatID, RemoveFromChatList: true, }) if err != nil { return err.Error(), true } c.unsubscribe(chatID) // search messages within current chat case "search": var limit int32 = 10 if len(args) > 1 { newLimit, err := strconv.ParseInt(args[1], 10, 32) if err == nil { limit = int32(newLimit) } } var query string if len(args) > 0 { query = args[0] } messages, err := c.client.SearchChatMessages(&client.SearchChatMessagesRequest{ ChatID: chatID, Query: query, Limit: limit, Filter: &client.SearchMessagesFilterEmpty{}, }) if err != nil { return err.Error(), true } c.sendMessagesReverse(chatID, messages.Messages) // get latest entries from history case "history": var limit int32 = 10 if len(args) > 0 { newLimit, err := strconv.ParseInt(args[0], 10, 32) if err == nil { limit = int32(newLimit) } } messages, err := c.client.GetChatHistory(&client.GetChatHistoryRequest{ ChatID: chatID, Limit: limit, }) if err != nil { return err.Error(), true } c.sendMessagesReverse(chatID, messages.Messages) // members list (for admins) case "members": var query string if len(args) > 0 { query = args[0] } members, err := c.client.SearchChatMembers(&client.SearchChatMembersRequest{ ChatID: chatID, Limit: 9999, Query: query, Filter: &client.ChatMembersFilterMembers{}, }) if err != nil { return err.Error(), true } var entries []string for _, member := range members.Members { var senderId int64 switch member.MemberID.MessageSenderType() { case client.TypeMessageSenderUser: memberUser, _ := member.MemberID.(*client.MessageSenderUser) senderId = memberUser.UserID case client.TypeMessageSenderChat: memberChat, _ := member.MemberID.(*client.MessageSenderChat) senderId = memberChat.ChatID } entries = append(entries, fmt.Sprintf( "%v | role: %v", c.formatContact(senderId), member.Status.ChatMemberStatusType(), )) } gateway.SendMessage( c.jid, strconv.FormatInt(chatID, 10), strings.Join(entries, "\n"), c.xmpp, ) case "help": return helpString(helpTypeChat), true default: return "", false } return "", true }