telegabber/telegram/commands.go

682 lines
16 KiB
Go
Raw Normal View History

2019-11-24 17:10:29 +00:00
package telegram
2019-11-26 00:04:11 +00:00
import (
2019-12-05 19:56:12 +00:00
"fmt"
2019-12-05 18:13:17 +00:00
"github.com/pkg/errors"
2019-12-08 13:32:43 +00:00
"math"
2019-12-07 16:37:14 +00:00
"regexp"
2019-12-04 23:10:08 +00:00
"strconv"
2019-11-26 00:04:11 +00:00
"strings"
2019-12-08 14:24:51 +00:00
"time"
2019-12-04 23:10:08 +00:00
"dev.narayana.im/narayana/telegabber/xmpp/gateway"
2019-12-05 23:21:39 +00:00
log "github.com/sirupsen/logrus"
2019-12-05 18:13:17 +00:00
"github.com/zelenin/go-tdlib/client"
2019-11-26 00:04:11 +00:00
)
2019-11-24 17:10:29 +00:00
const notEnoughArguments string = "Not enough arguments"
const telegramNotInitialized string = "Telegram connection is not initialized yet"
2019-11-26 00:04:11 +00:00
var transportCommands = map[string]command{
2019-12-05 18:13:17 +00:00
"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"},
2019-12-05 19:56:12 +00:00
"config": command{"[param] [value]", "view or update configuration options"},
2019-11-26 00:04:11 +00:00
}
var chatCommands = map[string]command{
2019-12-08 14:24:51 +00:00
"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"},
2019-12-08 16:04:26 +00:00
"search": command{"string [limit]", "search <string> in current chat"},
2019-12-08 16:19:35 +00:00
"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"},
2019-12-08 18:44:17 +00:00
"members": command{"[query]", "search members [by optional query] in current chat (requires admin rights)"},
2019-11-26 00:04:11 +00:00
}
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()
}
2019-12-03 00:32:53 +00:00
func parseCommand(cmdline string) (string, []string) {
bodyFields := strings.Fields(cmdline)
return bodyFields[0][1:], bodyFields[1:]
}
2019-12-08 15:35:27 +00:00
func (c *Client) unsubscribe(chatID int64) {
gateway.SendPresence(
c.xmpp,
c.jid,
gateway.SPFrom(strconv.FormatInt(chatID, 10)),
gateway.SPType("unsubscribed"),
)
}
2019-12-08 16:19:35 +00:00
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,
)
}
}
2019-12-08 13:58:17 +00:00
func (c *Client) usernameOrIdToId(username string) (int32, error) {
userID, err := strconv.ParseInt(username, 10, 32)
// 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 || userID > math.MaxInt32 {
return 0, errors.New("Not a user")
}
}
return int32(userID), nil
}
2019-12-03 00:32:53 +00:00
// ProcessTransportCommand executes a command sent directly to the component
// and returns a response
func (c *Client) ProcessTransportCommand(cmdline string) string {
cmd, args := parseCommand(cmdline)
2019-11-24 17:10:29 +00:00
switch cmd {
case "login", "code", "password":
if cmd == "login" && c.Session.Login != "" {
return ""
}
if len(args) < 1 {
return notEnoughArguments
}
if c.authorizer == nil {
return telegramNotInitialized
}
switch cmd {
2019-12-04 23:10:08 +00:00
// sign in
2019-11-24 17:10:29 +00:00
case "login":
c.authorizer.PhoneNumber <- args[0]
c.Session.Login = args[0]
2019-12-04 23:10:08 +00:00
// check auth code
2019-11-24 17:10:29 +00:00
case "code":
c.authorizer.Code <- args[0]
2019-12-04 23:10:08 +00:00
// check auth password
2019-11-24 17:10:29 +00:00
case "password":
c.authorizer.Password <- args[0]
}
2019-12-04 23:10:08 +00:00
// sign out
case "logout":
_, err := c.client.LogOut()
if err != nil {
2019-12-05 18:13:17 +00:00
return errors.Wrap(err, "Logout error").Error()
2019-12-04 23:10:08 +00:00
}
for id := range c.cache.chats {
2019-12-08 15:35:27 +00:00
c.unsubscribe(id)
2019-12-04 23:10:08 +00:00
}
c.Session.Login = ""
2019-12-05 18:13:17 +00:00
// set @username
case "setusername":
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":
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":
_, 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":
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()
}
2019-12-05 19:56:12 +00:00
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")
2019-11-26 00:04:11 +00:00
case "help":
return helpString(helpTypeTransport)
2019-11-24 17:10:29 +00:00
}
return ""
}
2019-12-03 00:32:53 +00:00
// ProcessChatCommand executes a command sent in a mapped chat
// and returns a response and the status of command support
2019-12-05 23:21:39 +00:00
func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool) {
cmd, args := parseCommand(cmdline)
2019-12-03 00:32:53 +00:00
switch cmd {
2019-12-05 23:21:39 +00:00
// delete last message(s)
case "d":
if c.me == nil {
return "@me is not initialized", true
}
2019-12-05 23:21:39 +00:00
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,
SenderUserId: 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)
}
2019-12-05 23:21:39 +00:00
}
_, err = c.client.DeleteMessages(&client.DeleteMessagesRequest{
ChatId: chatID,
MessageIds: messageIds,
Revoke: true,
})
if err != nil {
return err.Error(), true
}
2019-12-07 16:37:14 +00:00
// 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,
SenderUserId: 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, "")
2019-12-07 17:56:53 +00:00
// 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"),
)
2019-12-07 21:08:12 +00:00
// 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
}
2019-12-07 21:26:58 +00:00
// 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
}
2019-12-07 23:36:29 +00:00
// 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: int32(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: []int32{int32(chatID)},
Title: args[0],
})
if err != nil {
return err.Error(), true
}
}
2019-12-08 01:54:09 +00:00
// blacklists current user
case "block":
if chatID > 0 {
_, err := c.client.BlockUser(&client.BlockUserRequest{
UserId: int32(chatID),
})
if err != nil {
return err.Error(), true
}
}
// unblacklists current user
case "unblock":
if chatID > 0 {
_, err := c.client.UnblockUser(&client.UnblockUserRequest{
UserId: int32(chatID),
})
if err != nil {
return err.Error(), true
}
}
2019-12-08 13:32:43 +00:00
// invite @username to current groupchat
case "invite":
if len(args) < 1 {
return notEnoughArguments, true
}
if chatID < 0 {
2019-12-08 13:58:17 +00:00
userID, err := c.usernameOrIdToId(args[0])
2019-12-08 13:32:43 +00:00
if err != nil {
2019-12-08 13:58:17 +00:00
return err.Error(), true
2019-12-08 13:32:43 +00:00
}
_, err = c.client.AddChatMember(&client.AddChatMemberRequest{
ChatId: chatID,
2019-12-08 13:58:17 +00:00
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{},
2019-12-08 13:32:43 +00:00
})
if err != nil {
return err.Error(), true
}
}
2019-12-08 14:24:51 +00:00
// 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
}
}
2019-12-08 15:08:55 +00:00
// 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
}
2019-12-08 15:35:27 +00:00
c.unsubscribe(chatID)
2019-12-08 15:25:29 +00:00
}
// 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
}
2019-12-08 15:35:27 +00:00
c.unsubscribe(chatID)
2019-12-08 15:08:55 +00:00
}
2019-12-08 15:35:27 +00:00
// 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)
2019-12-08 16:04:26 +00:00
// 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{
2019-12-08 16:19:35 +00:00
ChatId: chatID,
Query: query,
Limit: limit,
Filter: &client.SearchMessagesFilterEmpty{},
2019-12-08 16:04:26 +00:00
})
if err != nil {
return err.Error(), true
}
2019-12-08 16:19:35 +00:00
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
2019-12-08 16:04:26 +00:00
}
2019-12-08 16:19:35 +00:00
c.sendMessagesReverse(chatID, messages.Messages)
2019-12-08 18:44:17 +00:00
// 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 {
entries = append(entries, fmt.Sprintf(
"%v | role: %v",
c.formatContact(int64(member.UserId)),
member.Status.ChatMemberStatusType(),
))
}
gateway.SendMessage(
c.jid,
strconv.FormatInt(chatID, 10),
strings.Join(entries, "\n"),
c.xmpp,
)
2019-12-03 00:32:53 +00:00
case "help":
2019-12-03 16:48:41 +00:00
return helpString(helpTypeChat), true
2019-12-05 23:21:39 +00:00
default:
return "", false
2019-12-03 00:32:53 +00:00
}
2019-12-05 23:21:39 +00:00
return "", true
2019-12-03 00:32:53 +00:00
}