546 lines
13 KiB
Go
546 lines
13 KiB
Go
package laniakea
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
"github.com/vinovest/sqlx"
|
|
"go.mongodb.org/mongo-driver/v2/mongo"
|
|
)
|
|
|
|
type ParseMode string
|
|
|
|
const (
|
|
ParseMDV2 ParseMode = "MarkdownV2"
|
|
ParseHTML ParseMode = "HTML"
|
|
ParseMD ParseMode = "Markdown"
|
|
)
|
|
|
|
type Bot struct {
|
|
token string
|
|
debug bool
|
|
errorTemplate string
|
|
|
|
logger *Logger
|
|
requestLogger *Logger
|
|
|
|
plugins []*Plugin
|
|
middlewares []*Middleware
|
|
prefixes []string
|
|
|
|
dbContext *DatabaseContext
|
|
|
|
updateOffset int
|
|
updateTypes []string
|
|
updateQueue *Queue[*Update]
|
|
}
|
|
|
|
type BotSettings struct {
|
|
Token string
|
|
Debug bool
|
|
ErrorTemplate string
|
|
Prefixes []string
|
|
UpdateTypes []string
|
|
LoggerBasePath string
|
|
UseRequestLogger bool
|
|
WriteToFile bool
|
|
}
|
|
|
|
func LoadSettingsFromEnv() *BotSettings {
|
|
return &BotSettings{
|
|
Token: os.Getenv("TG_TOKEN"),
|
|
Debug: os.Getenv("DEBUG") == "true",
|
|
ErrorTemplate: os.Getenv("ERROR_TEMPLATE"),
|
|
Prefixes: LoadPrefixesFromEnv(),
|
|
UpdateTypes: strings.Split(os.Getenv("UPDATE_TYPES"), ";"),
|
|
UseRequestLogger: os.Getenv("USE_REQ_LOG") == "true",
|
|
WriteToFile: os.Getenv("WRITE_TO_FILE") == "true",
|
|
}
|
|
}
|
|
|
|
type MsgContext struct {
|
|
Bot *Bot
|
|
Msg *Message
|
|
Update *Update
|
|
From *User
|
|
CallbackMsgId int
|
|
FromID int
|
|
Prefix string
|
|
Text string
|
|
Args []string
|
|
}
|
|
|
|
type DatabaseContext struct {
|
|
PostgresSQL *sqlx.DB
|
|
MongoDB *mongo.Client
|
|
Redis *redis.Client
|
|
}
|
|
|
|
func NewBot(settings *BotSettings) *Bot {
|
|
updateQueue := CreateQueue[*Update](256)
|
|
bot := &Bot{
|
|
updateOffset: 0, plugins: make([]*Plugin, 0), debug: settings.Debug, errorTemplate: "%s",
|
|
prefixes: settings.Prefixes, updateTypes: make([]string, 0),
|
|
updateQueue: updateQueue,
|
|
token: settings.Token,
|
|
}
|
|
|
|
if len(settings.ErrorTemplate) > 0 {
|
|
bot.errorTemplate = settings.ErrorTemplate
|
|
}
|
|
|
|
if len(settings.LoggerBasePath) == 0 {
|
|
settings.LoggerBasePath = "./"
|
|
}
|
|
level := FATAL
|
|
if settings.Debug {
|
|
level = DEBUG
|
|
}
|
|
bot.logger = CreateLogger().Level(level)
|
|
if settings.WriteToFile {
|
|
bot.logger = bot.logger.OpenFile(fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/")))
|
|
}
|
|
bot.logger = bot.logger.PrintTraceback(true)
|
|
if settings.UseRequestLogger {
|
|
bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS")
|
|
if settings.WriteToFile {
|
|
bot.requestLogger = bot.requestLogger.OpenFile(fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/")))
|
|
}
|
|
}
|
|
|
|
return bot
|
|
}
|
|
|
|
func (b *Bot) Close() {
|
|
err := b.logger.f.Close()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
} else {
|
|
fmt.Println("log closed")
|
|
}
|
|
}
|
|
|
|
func (b *Bot) InitDatabaseContext(ctx *DatabaseContext) *Bot {
|
|
b.dbContext = ctx
|
|
return b
|
|
}
|
|
func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) LoggerWriter) *Bot {
|
|
w := []LoggerWriter{writer(b.dbContext)}
|
|
b.logger.AddWriters(w)
|
|
if b.requestLogger != nil {
|
|
b.requestLogger.AddWriters(w)
|
|
}
|
|
return b
|
|
}
|
|
|
|
func (b *Bot) UpdateTypes(t ...string) *Bot {
|
|
b.updateTypes = make([]string, 0)
|
|
b.updateTypes = append(b.updateTypes, t...)
|
|
return b
|
|
}
|
|
func (b *Bot) AddUpdateType(t ...string) *Bot {
|
|
b.updateTypes = append(b.updateTypes, t...)
|
|
return b
|
|
}
|
|
|
|
func (b *Bot) AddPrefixes(prefixes ...string) *Bot {
|
|
b.prefixes = append(b.prefixes, prefixes...)
|
|
return b
|
|
}
|
|
|
|
func LoadPrefixesFromEnv() []string {
|
|
prefixesS, exists := os.LookupEnv("PREFIXES")
|
|
if !exists {
|
|
return []string{"!"}
|
|
}
|
|
return strings.Split(prefixesS, ";")
|
|
}
|
|
|
|
func (b *Bot) ErrorTemplate(s string) *Bot {
|
|
b.errorTemplate = s
|
|
return b
|
|
}
|
|
|
|
func (b *Bot) Debug(debug bool) *Bot {
|
|
b.debug = debug
|
|
return b
|
|
}
|
|
|
|
func (b *Bot) AddPlugins(plugin ...*Plugin) *Bot {
|
|
b.plugins = append(b.plugins, plugin...)
|
|
for _, p := range plugin {
|
|
b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" was registered", p.Name))
|
|
}
|
|
return b
|
|
}
|
|
|
|
func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
|
|
sort.Slice(middleware, func(a, b int) bool {
|
|
first := middleware[a]
|
|
second := middleware[b]
|
|
if first.Order == second.Order {
|
|
return first.Name < second.Name
|
|
}
|
|
return middleware[a].Order < middleware[b].Order
|
|
})
|
|
|
|
b.middlewares = append(b.middlewares, middleware...)
|
|
for _, m := range middleware {
|
|
b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" was registered", m.Name))
|
|
}
|
|
return b
|
|
}
|
|
|
|
func (b *Bot) Run() {
|
|
if len(b.prefixes) == 0 {
|
|
b.logger.Fatal("no prefixes defined")
|
|
return
|
|
}
|
|
|
|
if len(b.plugins) == 0 {
|
|
b.logger.Fatal("no plugins defined")
|
|
return
|
|
}
|
|
|
|
b.logger.Info("Bot running. Press CTRL+C to exit.")
|
|
|
|
go func() {
|
|
for {
|
|
_, err := b.Updates()
|
|
if err != nil {
|
|
b.logger.Error(err)
|
|
}
|
|
}
|
|
}()
|
|
|
|
for {
|
|
queue := b.updateQueue
|
|
if queue.IsEmpty() {
|
|
time.Sleep(time.Millisecond * 25)
|
|
continue
|
|
}
|
|
|
|
u := queue.Dequeue()
|
|
if u == nil {
|
|
b.logger.Error("update is nil")
|
|
continue
|
|
}
|
|
ctx := &MsgContext{
|
|
Bot: b,
|
|
Update: u,
|
|
}
|
|
for _, middleware := range b.middlewares {
|
|
middleware.Execute(ctx, b.dbContext)
|
|
}
|
|
|
|
for _, plugin := range b.plugins {
|
|
if plugin.UpdateListener != nil {
|
|
(*plugin.UpdateListener)(ctx, b.dbContext)
|
|
}
|
|
}
|
|
|
|
if u.CallbackQuery != nil {
|
|
b.handleCallback(u, ctx)
|
|
} else {
|
|
b.handleMessage(u, ctx)
|
|
}
|
|
}
|
|
}
|
|
|
|
// {"callback_query":{"chat_instance":"6202057960757700762","data":"aboba","from":{"first_name":"scuroneko","id":314834933,"is_bot":false,"language_code":"ru","username":"scuroneko"},"id":"1352205741990111553","message":{"chat":{"first_name":"scuroneko","id":314834933,"type":"private","username":"scuroneko"},"date":1734338107,"from":{"first_name":"Kurumi","id":7718900880,"is_bot":true,"username":"kurumi_game_bot"},"message_id":19,"reply_markup":{"inline_keyboard":[[{"callback_data":"aboba","text":"Test"},{"callback_data":"another","text":"Another"}]]},"text":"Aboba"}},"update_id":350979488}
|
|
|
|
func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
|
|
var text string
|
|
if update.Message == nil {
|
|
return
|
|
}
|
|
if len(update.Message.Text) > 0 {
|
|
text = update.Message.Text
|
|
} else {
|
|
text = update.Message.Caption
|
|
}
|
|
|
|
ctx.FromID = update.Message.From.ID
|
|
ctx.From = update.Message.From
|
|
ctx.Msg = update.Message
|
|
text = strings.TrimSpace(text)
|
|
prefix, hasPrefix := b.checkPrefixes(text)
|
|
if !hasPrefix {
|
|
return
|
|
}
|
|
ctx.Prefix = prefix
|
|
|
|
text = strings.TrimSpace(text[len(prefix):])
|
|
|
|
for _, plugin := range b.plugins {
|
|
// Check every command
|
|
for cmd := range plugin.Commands {
|
|
if !strings.HasPrefix(text, cmd) {
|
|
continue
|
|
}
|
|
|
|
ctx.Text = strings.TrimSpace(text[len(cmd):])
|
|
ctx.Args = strings.Split(ctx.Text, " ")
|
|
|
|
go plugin.Execute(cmd, ctx, b.dbContext)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
|
|
data := new(CallbackData)
|
|
err := json.Unmarshal([]byte(update.CallbackQuery.Data), data)
|
|
if err != nil {
|
|
b.logger.Error(err)
|
|
return
|
|
}
|
|
|
|
ctx.FromID = update.CallbackQuery.From.ID
|
|
ctx.From = update.CallbackQuery.From
|
|
ctx.Msg = update.CallbackQuery.Message
|
|
ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
|
|
ctx.Args = data.Args
|
|
|
|
for _, plugin := range b.plugins {
|
|
_, ok := plugin.Payloads[data.Command]
|
|
if !ok {
|
|
continue
|
|
}
|
|
go plugin.ExecutePayload(data.Command, ctx, b.dbContext)
|
|
break
|
|
}
|
|
}
|
|
|
|
func (b *Bot) checkPrefixes(text string) (string, bool) {
|
|
for _, prefix := range b.prefixes {
|
|
if strings.HasPrefix(text, prefix) {
|
|
return prefix, true
|
|
}
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
type AnswerMessage struct {
|
|
MessageID int
|
|
Text string
|
|
IsMedia bool
|
|
Keyboard *InlineKeyboard
|
|
ctx *MsgContext
|
|
}
|
|
|
|
func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard) *AnswerMessage {
|
|
params := &EditMessageTextP{
|
|
MessageID: messageId,
|
|
ChatID: ctx.Msg.Chat.ID,
|
|
Text: text,
|
|
ParseMode: ParseMD,
|
|
}
|
|
if keyboard != nil {
|
|
params.ReplyMarkup = keyboard.Get()
|
|
}
|
|
msg, err := ctx.Bot.EditMessageText(params)
|
|
if err != nil {
|
|
ctx.Bot.logger.Error(err)
|
|
return nil
|
|
}
|
|
return &AnswerMessage{
|
|
MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: false,
|
|
}
|
|
}
|
|
func (m *AnswerMessage) Edit(text string) *AnswerMessage {
|
|
return m.ctx.edit(m.MessageID, text, nil)
|
|
}
|
|
func (ctx *MsgContext) EditCallback(text string, keyboard *InlineKeyboard) *AnswerMessage {
|
|
if ctx.CallbackMsgId == 0 {
|
|
ctx.Bot.logger.Error("Can't edit non-callback update message")
|
|
return nil
|
|
}
|
|
|
|
return ctx.edit(ctx.CallbackMsgId, text, keyboard)
|
|
}
|
|
func (ctx *MsgContext) EditCallbackf(format string, keyboard *InlineKeyboard, args ...any) *AnswerMessage {
|
|
return ctx.EditCallback(fmt.Sprintf(format, args...), keyboard)
|
|
}
|
|
|
|
func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeyboard) *AnswerMessage {
|
|
params := &EditMessageCaptionP{
|
|
ChatID: ctx.Msg.Chat.ID,
|
|
MessageID: messageId,
|
|
Caption: text,
|
|
ParseMode: ParseMD,
|
|
}
|
|
if kb != nil {
|
|
params.ReplyMarkup = kb.Get()
|
|
}
|
|
msg, err := ctx.Bot.EditMessageCaption(params)
|
|
if err != nil {
|
|
ctx.Bot.logger.Error(err)
|
|
}
|
|
return &AnswerMessage{
|
|
MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
|
|
}
|
|
}
|
|
func (m *AnswerMessage) EditCaption(text string) *AnswerMessage {
|
|
return m.ctx.editPhotoText(m.MessageID, text, nil)
|
|
}
|
|
func (m *AnswerMessage) EditCaptionKeyboard(text string, kb *InlineKeyboard) *AnswerMessage {
|
|
return m.ctx.editPhotoText(m.MessageID, text, kb)
|
|
}
|
|
|
|
func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard) *AnswerMessage {
|
|
params := &SendMessageP{
|
|
ChatID: ctx.Msg.Chat.ID,
|
|
Text: text,
|
|
ParseMode: ParseMD,
|
|
}
|
|
if keyboard != nil {
|
|
params.ReplyMarkup = keyboard.Get()
|
|
}
|
|
|
|
msg, err := ctx.Bot.SendMessage(params)
|
|
if err != nil {
|
|
ctx.Bot.logger.Error(err)
|
|
return nil
|
|
}
|
|
return &AnswerMessage{
|
|
MessageID: msg.MessageID, ctx: ctx, IsMedia: false, Text: text,
|
|
}
|
|
}
|
|
func (ctx *MsgContext) Answer(text string) *AnswerMessage {
|
|
return ctx.answer(text, nil)
|
|
}
|
|
func (ctx *MsgContext) Answerf(template string, args ...any) *AnswerMessage {
|
|
return ctx.answer(fmt.Sprintf(template, args...), nil)
|
|
}
|
|
func (ctx *MsgContext) Keyboard(text string, kb *InlineKeyboard) *AnswerMessage {
|
|
return ctx.answer(text, kb)
|
|
}
|
|
|
|
func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
|
|
params := &SendPhotoP{
|
|
ChatID: ctx.Msg.Chat.ID,
|
|
Caption: text,
|
|
Photo: photoId,
|
|
ParseMode: ParseMD,
|
|
}
|
|
if kb != nil {
|
|
params.ReplyMarkup = kb.Get()
|
|
}
|
|
msg, err := ctx.Bot.SendPhoto(params)
|
|
if err != nil {
|
|
ctx.Bot.logger.Error(err)
|
|
}
|
|
return &AnswerMessage{
|
|
MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
|
|
}
|
|
}
|
|
func (ctx *MsgContext) AnswerPhoto(photoId, text string) *AnswerMessage {
|
|
return ctx.answerPhoto(photoId, text, nil)
|
|
}
|
|
func (ctx *MsgContext) AnswerPhotoKeyboard(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
|
|
return ctx.answerPhoto(photoId, text, kb)
|
|
}
|
|
|
|
func (ctx *MsgContext) delete(messageId int) {
|
|
_, err := ctx.Bot.DeleteMessage(&DeleteMessageP{
|
|
ChatID: ctx.Msg.Chat.ID,
|
|
MessageID: messageId,
|
|
})
|
|
if err != nil {
|
|
ctx.Bot.logger.Error(err)
|
|
}
|
|
}
|
|
func (m *AnswerMessage) Delete() {
|
|
m.ctx.delete(m.MessageID)
|
|
}
|
|
func (ctx *MsgContext) CallbackDelete() {
|
|
ctx.delete(ctx.CallbackMsgId)
|
|
}
|
|
|
|
func (ctx *MsgContext) Error(err error) {
|
|
_, sendErr := ctx.Bot.SendMessage(&SendMessageP{
|
|
ChatID: ctx.Msg.Chat.ID,
|
|
Text: fmt.Sprintf(ctx.Bot.errorTemplate, EscapeMarkdown(err.Error())),
|
|
})
|
|
ctx.Bot.logger.Error(err)
|
|
|
|
if sendErr != nil {
|
|
ctx.Bot.logger.Error(sendErr)
|
|
}
|
|
}
|
|
|
|
func (b *Bot) Logger() *Logger {
|
|
return b.logger
|
|
}
|
|
|
|
type ApiResponse struct {
|
|
Ok bool `json:"ok"`
|
|
Result map[string]any `json:"result,omitempty"`
|
|
Description string `json:"description,omitempty"`
|
|
ErrorCode int `json:"error_code,omitempty"`
|
|
}
|
|
|
|
type ApiResponseA struct {
|
|
Ok bool `json:"ok"`
|
|
Result []any `json:"result,omitempty"`
|
|
Description string `json:"description,omitempty"`
|
|
ErrorCode int `json:"error_code,omitempty"`
|
|
}
|
|
|
|
// request is a low-level call to api.
|
|
func (b *Bot) request(methodName string, params any) (map[string]interface{}, error) {
|
|
var buf bytes.Buffer
|
|
err := json.NewEncoder(&buf).Encode(params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if b.debug && b.requestLogger != nil {
|
|
b.requestLogger.Debug(strings.ReplaceAll(fmt.Sprintf(
|
|
"POST https://api.telegram.org/bot%s/%s %s",
|
|
"<TOKEN>",
|
|
methodName,
|
|
buf.String(),
|
|
), "\n", ""))
|
|
}
|
|
r, err := http.Post(fmt.Sprintf("https://api.telegram.org/bot%s/%s", b.token, methodName), "application/json", &buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer r.Body.Close()
|
|
data, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b.requestLogger.Debug(fmt.Sprintf("RES %s %s", methodName, string(data)))
|
|
response := new(ApiResponse)
|
|
|
|
var result map[string]any
|
|
|
|
err = json.Unmarshal(data, &response)
|
|
if err != nil {
|
|
responseArray := new(ApiResponseA)
|
|
err = json.Unmarshal(data, responseArray)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result = map[string]interface{}{
|
|
"data": responseArray.Result,
|
|
}
|
|
} else {
|
|
result = response.Result
|
|
}
|
|
if !response.Ok {
|
|
return nil, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
|
|
}
|
|
return result, err
|
|
}
|