392 lines
8.8 KiB
Go
392 lines
8.8 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"regexp"
|
|
"strconv"
|
|
"time"
|
|
|
|
tb "gopkg.in/tucnak/telebot.v2"
|
|
)
|
|
|
|
func BotHandlers(b *tb.Bot) {
|
|
b.Handle("/hello", func(m *tb.Message) {
|
|
s, err := botHello(m)
|
|
logOnError(err, "/hello")
|
|
if err == nil {
|
|
b.Send(m.Sender, s)
|
|
}
|
|
})
|
|
|
|
b.Handle("/test", botTest)
|
|
b.Handle("/msg_rescan", botMsgRescan)
|
|
b.Handle("/msg_rescan_all", botMsgRescanAll)
|
|
b.Handle("/msg_dump", botMsgDump)
|
|
|
|
b.Handle("/parse_rules", botListParsingRules)
|
|
b.Handle("/parse_rule", botListParsingRule)
|
|
|
|
b.Handle("/timer", botTimer)
|
|
|
|
b.Handle("/g_stock", botGStock)
|
|
|
|
b.Handle("/msg_export_all", botMsgExportAll)
|
|
|
|
b.Handle(tb.OnPhoto, botPhoto)
|
|
b.Handle(tb.OnChannelPost, botChannelPost)
|
|
b.Handle(tb.OnQuery, botQuery)
|
|
b.Handle(tb.OnText, botText)
|
|
b.Handle(tb.OnDocument, botDocument)
|
|
|
|
b.Start()
|
|
}
|
|
|
|
func botPhoto(m *tb.Message) {
|
|
fmt.Println("botPhoto :", m.Text)
|
|
// photos only
|
|
}
|
|
|
|
func botDocument(m *tb.Message) {
|
|
fmt.Printf("botDocument : %s (%d bytes)\n", m.Document.FileName, m.Document.File.FileSize)
|
|
// documents only
|
|
}
|
|
|
|
func botHello(m *tb.Message) (string, error) {
|
|
fmt.Println("botHello :", m.Text)
|
|
if !m.Private() {
|
|
fmt.Println("botHello : !m.Private()")
|
|
return ``, nil
|
|
}
|
|
// fmt.Println("Hello payload :", m.Payload) // <PAYLOAD>
|
|
PrintText(m)
|
|
return `hello world`, nil
|
|
}
|
|
|
|
func botChannelPost(m *tb.Message) {
|
|
fmt.Println("botChannelPost :", m.Text)
|
|
PrintText(m)
|
|
// channel posts only
|
|
}
|
|
|
|
func botQuery(q *tb.Query) {
|
|
fmt.Println("botQuery")
|
|
// incoming inline queries
|
|
}
|
|
|
|
func botText(m *tb.Message) {
|
|
fmt.Println("botText :", m.Text)
|
|
PrintText(m)
|
|
// all the text messages that weren't
|
|
// captured by existing handlers
|
|
}
|
|
|
|
func botTest(m *tb.Message) {
|
|
if !m.Private() {
|
|
return
|
|
}
|
|
if _, ok := clientsKeepAlive[m.Chat.ID]; ok {
|
|
clientSendCWMsg(m.Chat.ID, "🏅Me")
|
|
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: "Test sent",
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
} else {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: "Client not registered",
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
}
|
|
return
|
|
}
|
|
|
|
func botMsgRescan(m *tb.Message) {
|
|
if !m.Private() {
|
|
return
|
|
}
|
|
r := regexp.MustCompile("^[0-9]+$")
|
|
if r.MatchString(m.Payload) {
|
|
p := JobPayloadRescanMsg{
|
|
Query: fmt.Sprintf("SELECT o.id FROM obj o WHERE o.id = %s AND o.obj_type_id = %d AND o.obj_sub_type_id = %d;", m.Payload, objTypeMessage, objSubTypeMessageUnknown),
|
|
MsgID64: int64(m.ID),
|
|
ChatID64: m.Chat.ID,
|
|
}
|
|
b, _ := json.Marshal(p)
|
|
log.Printf("botMsgRescan : json : %s\n", string(b))
|
|
_, err := createJob(objSubTypeJobRescanMsg, objJobPriorityRescanMsg, int64(m.Sender.ID), time.Now(), b)
|
|
logOnError(err, "botMsgRescan : createJob(objSubTypeJobRescanMsg)")
|
|
if err != nil {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("Error scheduling the rescan for msg #%s", m.Payload),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
} else {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("Rescaning msg #%s", m.Payload),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
}
|
|
}
|
|
r = regexp.MustCompile("^all$")
|
|
if r.MatchString(m.Payload) {
|
|
botMsgRescanAll(m)
|
|
}
|
|
return
|
|
}
|
|
|
|
func botMsgRescanAll(m *tb.Message) {
|
|
if !m.Private() {
|
|
return
|
|
}
|
|
p := JobPayloadRescanMsg{
|
|
Query: fmt.Sprintf("SELECT o.id FROM obj o WHERE o.obj_type_id = %d AND o.obj_sub_type_id = %d ORDER BY id ASC;", objTypeMessage, objSubTypeMessageUnknown),
|
|
MsgID64: int64(m.ID),
|
|
ChatID64: m.Chat.ID,
|
|
}
|
|
b, _ := json.Marshal(p)
|
|
_, err := createJob(objSubTypeJobRescanMsg, objJobPriorityRescanAllMsg, int64(m.Sender.ID), time.Now(), b)
|
|
logOnError(err, "botMsgRescan : createJob(objSubTypeJobRescanMsg)")
|
|
|
|
if err != nil {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: "Error scheduling the rescan for all msg.",
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
} else {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: "Rescaning all msg scheduled.",
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
}
|
|
return
|
|
}
|
|
|
|
func botMsgExportAll(m *tb.Message) {
|
|
if !m.Private() {
|
|
return
|
|
}
|
|
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: `Starting messages export`,
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
|
|
b, err := zipMessages()
|
|
log.Printf("botMsgExportAll : Data returned.\n")
|
|
logOnError(err, "botMsgExportAll : exportMessages")
|
|
if err != nil {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: `Error exporting messages`,
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
|
|
return
|
|
} else {
|
|
text := fmt.Sprintf("Document size : %d bytes.", len(b))
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: text,
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
}
|
|
|
|
d := tb.Document{}
|
|
d.File = tb.FromReader(bytes.NewReader(b))
|
|
d.FileName = `backup.zip`
|
|
|
|
c = TGCommand{
|
|
Type: commandReplyDocument,
|
|
Document: d,
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
|
|
return
|
|
}
|
|
|
|
func botMsgDump(m *tb.Message) {
|
|
var res string
|
|
r := regexp.MustCompile("^[0-9]+$")
|
|
if r.MatchString(m.Payload) {
|
|
objId, _ := strconv.ParseInt(m.Payload, 10, 64)
|
|
objTypeId, err := getObjTypeId(objId)
|
|
logOnError(err, "botMsgDump : getObjSubTypeId")
|
|
if err != nil {
|
|
res = `Error retrieving the message`
|
|
} else if objTypeId != objTypeMessage {
|
|
res = `This is not a message reference`
|
|
} else {
|
|
cwm, _ := getMsg(objId)
|
|
b, _ := json.Marshal(cwm)
|
|
res = string(b)
|
|
}
|
|
} else {
|
|
res = `/msg_dump <msg_id>`
|
|
}
|
|
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: res,
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
|
|
return
|
|
}
|
|
|
|
func botListParsingRules(m *tb.Message) {
|
|
var s string = ""
|
|
if !m.Private() {
|
|
return
|
|
}
|
|
|
|
for _, v := range msgParsingRules {
|
|
s = fmt.Sprintf("%s[%d] %s\n", s, v.ID, v.Description)
|
|
}
|
|
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: s,
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
return
|
|
}
|
|
|
|
func botListParsingRule(m *tb.Message) {
|
|
if !m.Private() {
|
|
return
|
|
}
|
|
r := regexp.MustCompile("^[0-9]+$")
|
|
if r.MatchString(m.Payload) {
|
|
i, _ := strconv.ParseInt(m.Payload, 10, 64)
|
|
for _, v := range msgParsingRules {
|
|
if int64(v.ID) == i {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("%s\n", v.Rule),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
return
|
|
}
|
|
}
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("Could not find rule %s\n", m.Payload),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
} else {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("/parse_rule <id>\n"),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
}
|
|
return
|
|
}
|
|
|
|
func botGStock(m *tb.Message) {
|
|
if !m.Private() {
|
|
return
|
|
}
|
|
clientSendCWMsg(m.Chat.ID, "/g_stock_res")
|
|
clientSendCWMsg(m.Chat.ID, "/g_stock_alch")
|
|
clientSendCWMsg(m.Chat.ID, "/g_stock_misc")
|
|
clientSendCWMsg(m.Chat.ID, "/g_stock_rec")
|
|
clientSendCWMsg(m.Chat.ID, "/g_stock_parts")
|
|
clientSendCWMsg(m.Chat.ID, "/g_stock_other")
|
|
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: "Stock requested",
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
return
|
|
}
|
|
|
|
func botTimer(m *tb.Message) {
|
|
r := regexp.MustCompile("^(?P<Duration>([0-9]*(s|m|h))+) \"(?P<Msg>(.*))\"$")
|
|
if r.MatchString(m.Payload) {
|
|
d, err := time.ParseDuration(r.ReplaceAllString(m.Payload, "${Duration}"))
|
|
if err != nil {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("%s", err),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
} else {
|
|
p := JobPayloadMsgClient{
|
|
Text: r.ReplaceAllString(m.Payload, "${Msg}"),
|
|
MsgID64: int64(m.ID),
|
|
ChatID64: m.Chat.ID,
|
|
}
|
|
b, _ := json.Marshal(p)
|
|
t := time.Now().Add(d)
|
|
objID64, err := createJob(objSubTypeJobMsgClient, objJobPriority, int64(m.Chat.ID), t, b)
|
|
logOnError(err, "botTimer : createJob")
|
|
if err != nil {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("%s", err),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
} else {
|
|
c := TGCommand{
|
|
Type: commandReplyMsg,
|
|
Text: fmt.Sprintf("Job #%d scheduled at %s", objID64, t.Format(time.RFC850)),
|
|
FromMsgID64: int64(m.ID),
|
|
FromChatID64: m.Chat.ID,
|
|
}
|
|
TGCmdQueue <- c
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
}
|