fix

bot.go

@@ -5,16 +5,14 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
 	"os"
 	"sort"
 	"strings"
-	"time"
 
 	"github.com/redis/go-redis/v9"
-	"github.com/vinovest/sqlx"
 	"go.mongodb.org/mongo-driver/v2/mongo"
+	"gorm.io/gorm"
 )
 
 type ParseMode string
@@ -52,7 +50,6 @@ type BotSettings struct {
 	UpdateTypes      []string
 	LoggerBasePath   string
 	UseRequestLogger bool
-	WriteToFile      bool
 }
 
 func LoadSettingsFromEnv() *BotSettings {
@@ -63,7 +60,6 @@ func LoadSettingsFromEnv() *BotSettings {
 		Prefixes:         LoadPrefixesFromEnv(),
 		UpdateTypes:      strings.Split(os.Getenv("UPDATE_TYPES"), ";"),
 		UseRequestLogger: os.Getenv("USE_REQ_LOG") == "true",
-		WriteToFile:      os.Getenv("WRITE_TO_FILE") == "true",
 	}
 }
 
@@ -71,8 +67,6 @@ type MsgContext struct {
 	Bot    *Bot
 	Msg    *Message
 	Update *Update
-	From          *User
-	CallbackMsgId int
 	FromID int
 	Prefix string
 	Text   string
@@ -80,7 +74,7 @@ type MsgContext struct {
 }
 
 type DatabaseContext struct {
-	PostgresSQL *sqlx.DB
+	PostgresSQL *gorm.DB
 	MongoDB     *mongo.Client
 	Redis       *redis.Client
 }
@@ -105,40 +99,21 @@ func NewBot(settings *BotSettings) *Bot {
 	if settings.Debug {
 		level = DEBUG
 	}
-
+	bot.logger = CreateLogger().Level(level).OpenFile(fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/")))
-	bot.logger = CreateLogger().Level(level)
+	bot.logger = bot.logger.PrintTraceback(true)
-	bot.logger.AddWriter(bot.logger.CreateJsonStdoutWriter())
-	if settings.WriteToFile {
-		path := fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/"))
-		fileWriter, err := bot.logger.CreateTextFileWriter(path)
-		if err != nil {
-			bot.logger.Fatal(err)
-		}
-		bot.logger.AddWriter(fileWriter)
-	}
-
 	if settings.UseRequestLogger {
-		bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS")
+		bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS").OpenFile(fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/")))
-		bot.requestLogger.AddWriter(bot.requestLogger.CreateJsonStdoutWriter())
-		if settings.WriteToFile {
-			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/"))
-			fileWriter, err := bot.requestLogger.CreateTextFileWriter(path)
-			if err != nil {
-				bot.logger.Fatal(err)
-			}
-			bot.requestLogger.AddWriter(fileWriter)
-		}
 	}
 
 	return bot
 }
 
 func (b *Bot) Close() {
-	for _, writer := range b.logger.writers {
+	err := b.logger.f.Close()
-		err := writer.Close()
 	if err != nil {
-			log.Println(err)
+		fmt.Println(err)
-		}
+	} else {
+		fmt.Println("log closed")
 	}
 }
 
@@ -147,10 +122,10 @@ func (b *Bot) InitDatabaseContext(ctx *DatabaseContext) *Bot {
 	return b
 }
 func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) LoggerWriter) *Bot {
-	w := writer(b.dbContext)
+	w := []LoggerWriter{writer(b.dbContext)}
-	b.logger.AddWriter(w)
+	b.logger.AddWriters(w)
 	if b.requestLogger != nil {
-		b.requestLogger.AddWriter(w)
+		b.requestLogger.AddWriters(w)
 	}
 	return b
 }
@@ -171,11 +146,11 @@ func (b *Bot) AddPrefixes(prefixes ...string) *Bot {
 }
 
 func LoadPrefixesFromEnv() []string {
-	prefixesS, exists := os.LookupEnv("PREFIXES")
+	prefixes, exists := os.LookupEnv("PREFIXES")
 	if !exists {
 		return []string{"!"}
 	}
-	return strings.Split(prefixesS, ";")
+	return strings.Split(prefixes, ";")
 }
 
 func (b *Bot) ErrorTemplate(s string) *Bot {
@@ -191,7 +166,7 @@ func (b *Bot) Debug(debug bool) *Bot {
 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\" registered", p.Name))
+		b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" was registered", p.Name))
 	}
 	return b
 }
@@ -208,7 +183,7 @@ func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
 
 	b.middlewares = append(b.middlewares, middleware...)
 	for _, m := range middleware {
-		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
+		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" was registered", m.Name))
 	}
 	return b
 }
@@ -232,22 +207,16 @@ func (b *Bot) Run() {
 			if err != nil {
 				b.logger.Error(err)
 			}
-			time.Sleep(time.Millisecond * 10)
 		}
 	}()
 
 	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,
@@ -284,7 +253,6 @@ func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
 	}
 
 	ctx.FromID = update.Message.From.ID
-	ctx.From = update.Message.From
 	ctx.Msg = update.Message
 	text = strings.TrimSpace(text)
 	prefix, hasPrefix := b.checkPrefixes(text)
@@ -311,26 +279,13 @@ func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
 }
 
 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]
+		for payload := range plugin.Payloads {
-		if !ok {
+			if !strings.HasPrefix(update.CallbackQuery.Data, payload) {
 				continue
 			}
-		go plugin.ExecutePayload(data.Command, ctx, b.dbContext)
+			go plugin.ExecutePayload(payload, ctx, b.dbContext)
-		break
+		}
 	}
 }
 
@@ -343,149 +298,34 @@ func (b *Bot) checkPrefixes(text string) (string, bool) {
 	return "", false
 }
 
-type AnswerMessage struct {
+func (ctx *MsgContext) Answer(text string) {
-	MessageID int
+	_, err := ctx.Bot.SendMessage(&SendMessageP{
-	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) AnswerPhoto(photoId string, text string) {
+	_, err := ctx.Bot.SendPhoto(&SendPhotoP{
+		ChatID:    ctx.Msg.Chat.ID,
+		Caption:   text,
+		Photo:     photoId,
+		ParseMode: ParseMD,
+	})
+	if err != nil {
+		ctx.Bot.logger.Error(err)
 	}
-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())),
+		Text:   fmt.Sprintf(ctx.Bot.errorTemplate, err.Error()),
 	})
-	ctx.Bot.logger.Error(err)
 
 	if sendErr != nil {
 		ctx.Bot.logger.Error(sendErr)
@@ -511,7 +351,7 @@ type ApiResponseA struct {
 }
 
 // request is a low-level call to api.
-func (b *Bot) request(methodName string, params any) (map[string]interface{}, error) {
+func (b *Bot) request(methodName string, params map[string]any) (map[string]any, error) {
 	var buf bytes.Buffer
 	err := json.NewEncoder(&buf).Encode(params)
 	if err != nil {
@@ -530,12 +370,10 @@ func (b *Bot) request(methodName string, params any) (map[string]interface{}, er
 	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

go.mod

@@ -1,28 +0,0 @@
-module git.nix13.pw/scuroneko/laniakea
-
-go 1.25.6
-
-require (
-	github.com/fatih/color v1.18.0
-	github.com/redis/go-redis/v9 v9.17.3
-	github.com/vinovest/sqlx v1.7.1
-	go.mongodb.org/mongo-driver/v2 v2.4.2
-)
-
-require (
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/golang/snappy v1.0.0 // indirect
-	github.com/klauspost/compress v1.16.7 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/muir/sqltoken v0.1.0 // indirect
-	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
-	github.com/xdg-go/scram v1.1.2 // indirect
-	github.com/xdg-go/stringprep v1.0.4 // indirect
-	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
-	golang.org/x/sync v0.11.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
-)

go.sum

@@ -1,87 +0,0 @@
-filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
-filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
-github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
-github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
-github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
-github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/go-sql-driver/mysql v1.9.0 h1:Y0zIbQXhQKmQgTp44Y1dp3wTXcn804QoTptLZT1vtvo=
-github.com/go-sql-driver/mysql v1.9.0/go.mod h1:pDetrLJeA3oMujJuvXc8RJoasr589B6A9fwzD3QMrqw=
-github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
-github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
-github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
-github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
-github.com/muir/sqltoken v0.1.0 h1:edosEGsOClOZNfgGQNQSgxR9O6LiVefm2rDRqp2InuI=
-github.com/muir/sqltoken v0.1.0/go.mod h1:lgOIORnKekMsuc/ZwdPOfwz/PtWLPCke43cEbT3uDuY=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis/v9 v9.17.3 h1:fN29NdNrE17KttK5Ndf20buqfDZwGNgoUr9qjl1DQx4=
-github.com/redis/go-redis/v9 v9.17.3/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/vinovest/sqlx v1.7.1 h1:kdq4v0N9kRLpytWGSWOw4aulOGdQPmIoMR6Y+cTBxow=
-github.com/vinovest/sqlx v1.7.1/go.mod h1:3fAv74r4iDMv2PpFomADb+vex5ukzfYn4GseC9KngD8=
-github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
-github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
-github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
-github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
-github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
-github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
-github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
-github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.mongodb.org/mongo-driver/v2 v2.4.2 h1:HrJ+Auygxceby9MLp3YITobef5a8Bv4HcPFIkml1U7U=
-go.mongodb.org/mongo-driver/v2 v2.4.2/go.mod h1:jHeEDJHJq7tm6ZF45Issun9dbogjfnPySb1vXA7EeAI=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
-golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

keyboard.go

@@ -0,0 +1,4 @@
+package laniakea
+
+type InlineKeyboard struct {
+}

laniakea/keyboard.go

@@ -1,74 +0,0 @@
-package laniakea
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-type InlineKeyboard struct {
-	CurrentLine []InlineKeyboardButton
-	Lines       [][]InlineKeyboardButton
-	maxRow      int
-}
-
-func NewInlineKeyboard(maxRow int) *InlineKeyboard {
-	return &InlineKeyboard{
-		CurrentLine: make([]InlineKeyboardButton, 0),
-		Lines:       make([][]InlineKeyboardButton, 0),
-		maxRow:      maxRow,
-	}
-}
-
-func (in *InlineKeyboard) append(button InlineKeyboardButton) *InlineKeyboard {
-	if len(in.CurrentLine) == in.maxRow {
-		in.AddLine()
-	}
-	in.CurrentLine = append(in.CurrentLine, button)
-	return in
-}
-func (in *InlineKeyboard) AddUrlButton(text, url string) *InlineKeyboard {
-	return in.append(InlineKeyboardButton{Text: text, URL: url})
-}
-func (in *InlineKeyboard) AddCallbackButton(text string, cmd string, args ...any) *InlineKeyboard {
-	return in.append(InlineKeyboardButton{Text: text, CallbackData: NewCallbackData(cmd, args...).ToJson()})
-}
-
-func (in *InlineKeyboard) AddLine() *InlineKeyboard {
-	if len(in.CurrentLine) == 0 {
-		return in
-	}
-	in.Lines = append(in.Lines, in.CurrentLine)
-	in.CurrentLine = make([]InlineKeyboardButton, 0)
-	return in
-}
-func (in *InlineKeyboard) Get() InlineKeyboardMarkup {
-	if len(in.CurrentLine) > 0 {
-		in.Lines = append(in.Lines, in.CurrentLine)
-	}
-	return InlineKeyboardMarkup{
-		InlineKeyboard: in.Lines,
-	}
-}
-
-type CallbackData struct {
-	Command string   `json:"cmd"`
-	Args    []string `json:"args"`
-}
-
-func NewCallbackData(command string, args ...any) *CallbackData {
-	stringArgs := make([]string, len(args))
-	for i, arg := range args {
-		stringArgs[i] = fmt.Sprint(arg)
-	}
-	return &CallbackData{
-		Command: command,
-		Args:    stringArgs,
-	}
-}
-func (d *CallbackData) ToJson() string {
-	data, err := json.Marshal(d)
-	if err != nil {
-		return `{"cmd":""}`
-	}
-	return string(data)
-}

laniakea/logger.go

@@ -1,372 +0,0 @@
-package laniakea
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/fatih/color"
-)
-
-type LoggerWriter interface {
-	Close() error
-	Write(p []byte) (n int, err error)
-	Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error
-}
-type LoggerTextWriter struct {
-	LoggerWriter
-	writer         io.Writer
-	printTraceback bool
-	printTime      bool
-}
-
-func (w *LoggerTextWriter) Write(p []byte) (n int, err error) {
-	n, err = w.writer.Write(p)
-	if err != nil {
-		return n, err
-	}
-	err = bufio.NewWriter(w.writer).Flush()
-	return n, err
-}
-func (w *LoggerTextWriter) Print(level LogLevel, prefix string, tb []*MethodTraceback, messages ...any) error {
-	s := buildString(level, prefix, true, w.printTraceback, w.printTime, messages...)
-	_, err := w.Write([]byte(s))
-	return err
-}
-func (w *LoggerTextWriter) Close() error {
-	return w.writer.(io.Closer).Close()
-}
-
-type LoggerJsonWriter struct {
-	LoggerWriter
-	writer io.Writer
-	pretty bool
-}
-type LoggerJsonMessage struct {
-	Time      time.Time          `json:"time"`
-	Level     string             `json:"level"`
-	Prefix    string             `json:"prefix"`
-	Message   string             `json:"message"`
-	Traceback []*MethodTraceback `json:"traceback"`
-}
-
-func (w *LoggerJsonWriter) Write(data []byte) (int, error) {
-	n, err := w.writer.Write(data)
-	if err != nil {
-		return n, err
-	}
-	err = bufio.NewWriter(w.writer).Flush()
-	return n, err
-}
-func (w *LoggerJsonWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error {
-	msg := Map(messages, func(el any) string {
-		return fmt.Sprintf("%v", el)
-	})
-	m := LoggerJsonMessage{
-		Time:      time.Now(),
-		Level:     level.GetName(),
-		Prefix:    prefix,
-		Message:   strings.Join(msg, " "),
-		Traceback: traceback,
-	}
-	var data []byte
-	var err error
-	if w.pretty {
-		data, err = json.MarshalIndent(m, "", "  ")
-	} else {
-		data, err = json.Marshal(m)
-	}
-	if err != nil {
-		return err
-	}
-	_, err = w.Write(append(data, []byte("\n")...))
-	return err
-}
-func (w *LoggerJsonWriter) Close() error {
-	return w.writer.(io.Closer).Close()
-}
-
-type Logger struct {
-	prefix         string
-	level          LogLevel
-	printTraceback bool
-	printTime      bool
-	jsonPretty     bool
-	writers        []LoggerWriter
-}
-
-type LogLevel struct {
-	n uint8
-	t string
-	c color.Attribute
-}
-
-func (l *LogLevel) GetName() string {
-	return l.t
-}
-
-type MethodTraceback struct {
-	Package   string `json:"package"`
-	Method    string `json:"method"`
-	fullPath  string
-	signature string
-	Filename  string `json:"filename"`
-	Line      int    `json:"line"`
-}
-
-var (
-	INFO  = LogLevel{n: 0, t: "info", c: color.FgWhite}
-	WARN  = LogLevel{n: 1, t: "warn", c: color.FgHiYellow}
-	ERROR = LogLevel{n: 2, t: "error", c: color.FgHiRed}
-	FATAL = LogLevel{n: 3, t: "fatal", c: color.FgRed}
-	DEBUG = LogLevel{n: 4, t: "debug", c: color.FgGreen}
-)
-
-func CreateLogger() *Logger {
-	return &Logger{
-		prefix:         "LOG",
-		level:          FATAL,
-		printTraceback: false,
-		printTime:      true,
-	}
-}
-
-func (l *Logger) CreateTextFileWriter(path string) (*LoggerTextWriter, error) {
-	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
-	if err != nil {
-		return nil, err
-	}
-	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if err != nil {
-		return nil, err
-	}
-
-	writer := &LoggerTextWriter{
-		writer: file, printTraceback: l.printTraceback, printTime: l.printTime,
-	}
-	return writer, nil
-}
-func (l *Logger) CreateTextStdoutWriter() *LoggerTextWriter {
-	writer := &LoggerTextWriter{
-		writer: os.Stdout, printTraceback: l.printTraceback, printTime: l.printTime,
-	}
-	return writer
-}
-func (l *Logger) CreateJsonStdoutWriter() *LoggerJsonWriter {
-	writer := &LoggerJsonWriter{
-		writer: os.Stdout, pretty: l.jsonPretty,
-	}
-	return writer
-}
-func (l *Logger) CreateJsonFileWriter(path string) (*LoggerJsonWriter, error) {
-	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
-	if err != nil {
-		return nil, err
-	}
-	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if err != nil {
-		return nil, err
-	}
-	writer := &LoggerJsonWriter{
-		writer: file, pretty: l.jsonPretty,
-	}
-	return writer, nil
-}
-func (l *Logger) CreateTextWriter(w io.Writer) *LoggerTextWriter {
-	writer := &LoggerTextWriter{
-		writer: w, printTraceback: l.printTraceback, printTime: l.printTime,
-	}
-	return writer
-}
-func (l *Logger) CreateJsonWriter(w io.Writer) *LoggerJsonWriter {
-	writer := &LoggerJsonWriter{
-		writer: w, pretty: l.jsonPretty,
-	}
-	return writer
-}
-
-func (l *Logger) Prefix(prefix string) *Logger {
-	l.prefix = prefix
-	return l
-}
-func (l *Logger) Level(level LogLevel) *Logger {
-	l.level = level
-	return l
-}
-func (l *Logger) PrintTraceback(b bool) *Logger {
-	l.printTraceback = b
-	return l
-}
-func (l *Logger) PrintTime(b bool) *Logger {
-	l.printTime = b
-	return l
-}
-func (l *Logger) JsonPretty(b bool) *Logger {
-	l.jsonPretty = b
-	return l
-}
-func (l *Logger) AddWriters(writers ...LoggerWriter) *Logger {
-	l.writers = append(l.writers, writers...)
-	return l
-}
-func (l *Logger) AddWriter(writer LoggerWriter) *Logger {
-	l.writers = append(l.writers, writer)
-	return l
-}
-
-func (l *Logger) Infof(format string, args ...any) {
-	l.print(INFO, fmt.Sprintf(format, args...))
-}
-func (l *Logger) Info(m ...any) {
-	l.println(INFO, m...)
-}
-
-func (l *Logger) Warnf(format string, args ...any) {
-	l.print(WARN, fmt.Sprintf(format, args...))
-}
-func (l *Logger) Warn(m ...any) {
-	l.println(WARN, m...)
-}
-
-func (l *Logger) Error(m ...any) {
-	l.println(ERROR, m...)
-}
-
-func (l *Logger) Fatal(m ...any) {
-	l.println(FATAL, m...)
-	os.Exit(1)
-}
-
-func (l *Logger) Debug(m ...any) {
-	l.println(DEBUG, m...)
-}
-
-func formatTime(t time.Time) string {
-	return fmt.Sprintf("%02d.%02d.%02d %02d:%02d:%02d", t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute(), t.Second())
-}
-func formatTraceback(mt *MethodTraceback) string {
-	return fmt.Sprintf("%s:%s:%d", mt.Filename, mt.Method, mt.Line)
-}
-func FormatFullTraceback(tracebacks []*MethodTraceback) string {
-	formatted := make([]string, 0)
-	for _, tb := range tracebacks {
-		formatted = append(formatted, formatTraceback(tb))
-	}
-	return strings.Join(formatted, "->")
-}
-
-func getTraceback() *MethodTraceback {
-	caller, _, _, _ := runtime.Caller(4)
-	details := runtime.FuncForPC(caller)
-	signature := details.Name()
-	path, line := details.FileLine(caller)
-	splitPath := strings.Split(path, "/")
-
-	splitSignature := strings.Split(signature, ".")
-	pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
-
-	tb := &MethodTraceback{
-		Filename:  splitPath[len(splitPath)-1],
-		fullPath:  path,
-		Line:      line,
-		signature: signature,
-		Package:   pkg,
-		Method:    method,
-	}
-
-	return tb
-}
-func getFullTraceback(skip int) []*MethodTraceback {
-	pc := make([]uintptr, 15)
-	runtime.Callers(skip, pc)
-	list := make([]*MethodTraceback, 0)
-	frames := runtime.CallersFrames(pc)
-	for {
-		frame, more := frames.Next()
-		if !more {
-			break
-		}
-		details := runtime.FuncForPC(frame.PC)
-		signature := details.Name()
-		path, line := details.FileLine(frame.PC)
-		splitPath := strings.Split(path, "/")
-
-		splitSignature := strings.Split(signature, ".")
-		pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
-
-		tb := &MethodTraceback{
-			Filename:  splitPath[len(splitPath)-1],
-			fullPath:  path,
-			Line:      line,
-			signature: signature,
-			Package:   pkg,
-			Method:    method,
-		}
-		list = append(list, tb)
-	}
-	sort.Slice(list, func(i, j int) bool {
-		return j < i
-	})
-	return list
-}
-
-func buildString(level LogLevel, prefix string, newline, printTime, printTraceback bool, m ...any) string {
-	args := []string{
-		fmt.Sprintf("[%s]", prefix),
-		fmt.Sprintf("[%s]", strings.ToUpper(level.t)),
-	}
-
-	if printTraceback {
-		args = append(args, fmt.Sprintf("[%s]", formatTraceback(getTraceback())))
-	}
-
-	if printTime {
-		args = append(args, fmt.Sprintf("[%s]", formatTime(time.Now())))
-	}
-
-	msg := Map(m, func(el any) string {
-		return fmt.Sprintf("%v", el)
-	})
-	s := fmt.Sprintf("%s %s", strings.Join(args, " "), strings.Join(msg, " "))
-	if newline {
-		s += "\n"
-	}
-	return s
-}
-
-func (l *Logger) print(level LogLevel, m ...any) {
-	if l.level.n < level.n {
-		return
-	}
-
-	tb := getFullTraceback(0)
-	for _, writer := range l.writers {
-		err := writer.Print(level, l.prefix, tb, m...)
-		if err != nil {
-			l.Error(err)
-		}
-	}
-}
-
-// Docker requires "\n" at end to write to log.
-// print not work for docker, otherwise it will work and write into stdout
-func (l *Logger) println(level LogLevel, m ...any) {
-	if l.level.n < level.n {
-		return
-	}
-
-	tb := getFullTraceback(0)
-	for _, writer := range l.writers {
-		err := writer.Print(level, l.prefix, tb, m...)
-		if err != nil {
-			l.Error(err)
-		}
-	}
-}

laniakea/methods.go

@@ -1,169 +0,0 @@
-package laniakea
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-var NoParams = make(map[string]any)
-
-func (b *Bot) Updates() ([]*Update, error) {
-	params := make(map[string]any)
-	params["offset"] = b.updateOffset
-	params["timeout"] = 30
-	params["allowed_updates"] = b.updateTypes
-
-	data, err := b.request("getUpdates", params)
-	if err != nil {
-		return nil, err
-	}
-	res := make([]*Update, 0)
-	for _, u := range data["data"].([]any) {
-		updateObj := new(Update)
-		data, err := json.Marshal(u)
-		if err != nil {
-			return res, err
-		}
-		err = json.Unmarshal(data, updateObj)
-		if err != nil {
-			return res, err
-		}
-		//err = MapToStruct(u.(map[string]any), updateObj)
-		//if err != nil {
-		//	return res, err
-		//}
-		b.updateOffset = updateObj.UpdateID + 1
-		err = b.updateQueue.Enqueue(updateObj)
-		if err != nil {
-			return res, err
-		}
-		res = append(res, updateObj)
-
-		if b.debug && b.requestLogger != nil {
-			j, err := MapToJson(u.(map[string]interface{}))
-			if err != nil {
-				b.logger.Error(err)
-			}
-			b.requestLogger.Debug(fmt.Sprintf("UPDATE %s", j))
-		}
-	}
-	return res, err
-}
-
-func (b *Bot) GetMe() (*User, error) {
-	data, err := b.request("getMe", NoParams)
-	if err != nil {
-		return nil, err
-	}
-	user := new(User)
-	err = MapToStruct(data, user)
-	return user, err
-}
-
-type SendMessageP struct {
-	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
-	ChatID               int                  `json:"chat_id"`
-	MessageThreadID      int                  `json:"message_thread_id,omitempty"`
-	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
-	Text                 string               `json:"text"`
-	Entities             []*MessageEntity     `json:"entities,omitempty"`
-	LinkPreviewOptions   *LinkPreviewOptions  `json:"link_preview_options,omitempty"`
-	DisableNotifications bool                 `json:"disable_notifications,omitempty"`
-	ProtectContent       bool                 `json:"protect_content,omitempty"`
-	AllowPaidBroadcast   bool                 `json:"allow_paid_broadcast,omitempty"`
-	MessageEffectID      string               `json:"message_effect_id,omitempty"`
-	ReplyParameters      *ReplyParameters     `json:"reply_parameters,omitempty"`
-	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) SendMessage(params *SendMessageP) (*Message, error) {
-	data, err := b.request("sendMessage", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type SendPhotoP struct {
-	BusinessConnectionID  string               `json:"business_connection_id,omitempty"`
-	ChatID                int                  `json:"chat_id"`
-	MessageThreadID       int                  `json:"message_thread_id,omitempty"`
-	ParseMode             ParseMode            `json:"parse_mode,omitempty"`
-	Photo                 string               `json:"photo"`
-	Caption               string               `json:"caption,omitempty"`
-	CaptionEntities       []*MessageEntity     `json:"caption_entities,omitempty"`
-	ShowCaptionAboveMedia bool                 `json:"show_caption_above_media"`
-	HasSpoiler            bool                 `json:"has_spoiler"`
-	DisableNotifications  bool                 `json:"disable_notifications,omitempty"`
-	ProtectContent        bool                 `json:"protect_content,omitempty"`
-	AllowPaidBroadcast    bool                 `json:"allow_paid_broadcast,omitempty"`
-	MessageEffectID       string               `json:"message_effect_id,omitempty"`
-	ReplyMarkup           InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) SendPhoto(params *SendPhotoP) (*Message, error) {
-	data, err := b.request("sendPhoto", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type EditMessageTextP struct {
-	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
-	ChatID               int                  `json:"chat_id,omitempty"`
-	MessageID            int                  `json:"message_id,omitempty"`
-	InlineMessageID      string               `json:"inline_message_id,omitempty"`
-	Text                 string               `json:"text"`
-	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
-	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) EditMessageText(params *EditMessageTextP) (*Message, error) {
-	data, err := b.request("editMessageText", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type EditMessageCaptionP struct {
-	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
-	ChatID               int                  `json:"chat_id,omitempty"`
-	MessageID            int                  `json:"message_id,omitempty"`
-	InlineMessageID      string               `json:"inline_message_id,omitempty"`
-	Caption              string               `json:"caption"`
-	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
-	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) EditMessageCaption(params *EditMessageCaptionP) (*Message, error) {
-	data, err := b.request("editMessageCaption", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type DeleteMessageP struct {
-	ChatID    int `json:"chat_id"`
-	MessageID int `json:"message_id"`
-}
-
-func (b *Bot) DeleteMessage(params *DeleteMessageP) (*Message, error) {
-	data, err := b.request("deleteMessage", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}

laniakea/utils.go

@@ -1,108 +0,0 @@
-package laniakea
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-)
-
-func MapToStruct(m map[string]interface{}, s interface{}) error {
-	data, err := json.Marshal(m)
-	if err != nil {
-		return err
-	}
-	err = json.Unmarshal(data, s)
-	return err
-}
-
-func MapToJson(m map[string]interface{}) (string, error) {
-	data, err := json.Marshal(m)
-	return string(data), err
-}
-
-func StructToMap(s interface{}) (map[string]interface{}, error) {
-	data, err := json.Marshal(s)
-	if err != nil {
-		return nil, err
-	}
-	m := make(map[string]interface{})
-	err = json.Unmarshal(data, &m)
-	return m, err
-}
-
-func Map[T, V any](ts []T, fn func(T) V) []V {
-	result := make([]V, len(ts))
-	for i, t := range ts {
-		result[i] = fn(t)
-	}
-	return result
-}
-
-func EscapeMarkdown(s string) string {
-	s = strings.ReplaceAll(s, "_", `\_`)
-	s = strings.ReplaceAll(s, "*", `\*`)
-	s = strings.ReplaceAll(s, "[", `\[`)
-	return strings.ReplaceAll(s, "`", "\\`")
-}
-
-func EscapeMarkdownV2(s string) string {
-	symbols := []string{"_", "*", "[", "]", "(", ")", "~", "`", ">", "#", "+", "-", "=", "|", "{", "}", ".", "!"}
-	for _, symbol := range symbols {
-		s = strings.ReplaceAll(s, symbol, fmt.Sprintf("\\%s", symbol))
-	}
-	return s
-}
-
-func GetUnclosedTag(markdown string) string {
-	// order is important!
-	var tags = []string{
-		"```",
-		"`",
-		"*",
-		"_",
-	}
-	var currentTag = ""
-
-	markdownRunes := []rune(markdown)
-
-	var i = 0
-outer:
-	for i < len(markdownRunes) {
-		// skip escaped characters (only outside tags)
-		if markdownRunes[i] == '\\' && currentTag == "" {
-			i += 2
-			continue
-		}
-		if currentTag != "" {
-			if strings.HasPrefix(string(markdownRunes[i:]), currentTag) {
-				// turn a tag off
-				i += len(currentTag)
-				currentTag = ""
-				continue
-			}
-		} else {
-			for _, tag := range tags {
-				if strings.HasPrefix(string(markdownRunes[i:]), tag) {
-					// turn a tag on
-					currentTag = tag
-					i += len(currentTag)
-					continue outer
-				}
-			}
-		}
-		i++
-	}
-
-	return currentTag
-}
-func IsValid(markdown string) bool {
-	return GetUnclosedTag(markdown) == ""
-}
-
-func FixMarkdown(markdown string) string {
-	tag := GetUnclosedTag(markdown)
-	if tag == "" {
-		return markdown
-	}
-	return markdown + tag
-}

logger.go

@@ -0,0 +1,230 @@
+package laniakea
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/fatih/color"
+)
+
+type LoggerWriter func(level LogLevel, prefix, traceback string, message []any)
+
+type Logger struct {
+	prefix         string
+	level          LogLevel
+	printTraceback bool
+	printTime      bool
+	writers        []LoggerWriter
+
+	f *os.File
+}
+
+type LogLevel struct {
+	n uint8
+	t string
+	c color.Attribute
+}
+
+func (l *LogLevel) GetName() string {
+	return l.t
+}
+
+type MethodTraceback struct {
+	Package   string
+	Method    string
+	fullPath  string
+	signature string
+	filename  string
+	line      int
+}
+
+var (
+	INFO  = LogLevel{n: 0, t: "info", c: color.FgWhite}
+	WARN  = LogLevel{n: 1, t: "warn", c: color.FgHiYellow}
+	ERROR = LogLevel{n: 2, t: "error", c: color.FgHiRed}
+	FATAL = LogLevel{n: 3, t: "fatal", c: color.FgRed}
+	DEBUG = LogLevel{n: 4, t: "debug", c: color.FgGreen}
+)
+
+func CreateLogger() *Logger {
+	return &Logger{
+		prefix:         "LOG",
+		level:          FATAL,
+		printTraceback: false,
+		printTime:      true,
+	}
+}
+
+func (l *Logger) OpenFile(name string) *Logger {
+	err := os.MkdirAll(filepath.Dir(name), os.ModePerm)
+	if err != nil {
+		l.Fatal(err)
+	}
+	l.f, err = os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		l.Fatal(err)
+	}
+	return l
+}
+
+func (l *Logger) Prefix(prefix string) *Logger {
+	l.prefix = prefix
+	return l
+}
+func (l *Logger) Level(level LogLevel) *Logger {
+	l.level = level
+	return l
+}
+func (l *Logger) PrintTraceback(b bool) *Logger {
+	l.printTraceback = b
+	return l
+}
+func (l *Logger) PrintTime(b bool) *Logger {
+	l.printTime = b
+	return l
+}
+func (l *Logger) AddWriters(writers []LoggerWriter) *Logger {
+	l.writers = append(l.writers, writers...)
+	return l
+}
+
+func (l *Logger) Info(m ...any) {
+	l.print(INFO, m)
+}
+
+func (l *Logger) Warn(m ...any) {
+	l.print(WARN, m)
+}
+
+func (l *Logger) Error(m ...any) {
+	l.print(ERROR, m)
+}
+
+func (l *Logger) Fatal(m ...any) {
+	l.print(FATAL, m)
+	os.Exit(1)
+}
+
+func (l *Logger) Debug(m ...any) {
+	l.print(DEBUG, m)
+}
+
+func (l *Logger) formatTime(t time.Time) string {
+	return fmt.Sprintf("%02d.%02d.%02d %02d:%02d:%02d", t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute(), t.Second())
+}
+
+func (l *Logger) getTraceback() *MethodTraceback {
+	caller, _, _, _ := runtime.Caller(4)
+	details := runtime.FuncForPC(caller)
+	signature := details.Name()
+	path, line := details.FileLine(caller)
+	splitPath := strings.Split(path, "/")
+
+	splitSignature := strings.Split(signature, ".")
+	pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
+
+	tb := &MethodTraceback{
+		filename:  splitPath[len(splitPath)-1],
+		fullPath:  path,
+		line:      line,
+		signature: signature,
+		Package:   pkg,
+		Method:    method,
+	}
+
+	return tb
+}
+func (l *Logger) formatTraceback(mt *MethodTraceback) string {
+	return fmt.Sprintf("%s:%s:%d", mt.filename, mt.Method, mt.line)
+}
+
+func (l *Logger) getFullTraceback(skip int) []*MethodTraceback {
+	pc := make([]uintptr, 15)
+	runtime.Callers(skip, pc)
+	list := make([]*MethodTraceback, 0)
+	frames := runtime.CallersFrames(pc)
+	for {
+		frame, more := frames.Next()
+		if !more {
+			break
+		}
+		details := runtime.FuncForPC(frame.PC)
+		signature := details.Name()
+		path, line := details.FileLine(frame.PC)
+		splitPath := strings.Split(path, "/")
+
+		splitSignature := strings.Split(signature, ".")
+		pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
+
+		tb := &MethodTraceback{
+			filename:  splitPath[len(splitPath)-1],
+			fullPath:  path,
+			line:      line,
+			signature: signature,
+			Package:   pkg,
+			Method:    method,
+		}
+		list = append(list, tb)
+	}
+	sort.Slice(list, func(i, j int) bool {
+		return j < i
+	})
+	return list
+}
+func (l *Logger) formatFullTraceback(tracebacks []*MethodTraceback) string {
+	formatted := make([]string, 0)
+	for _, tb := range tracebacks {
+		formatted = append(formatted, l.formatTraceback(tb))
+	}
+	return strings.Join(formatted, "->")
+}
+
+func (l *Logger) buildString(level LogLevel, m []any) string {
+	args := []string{
+		fmt.Sprintf("[%s]", l.prefix),
+		fmt.Sprintf("[%s]", strings.ToUpper(level.t)),
+	}
+
+	if l.printTraceback {
+		args = append(args, fmt.Sprintf("[%s]", l.formatTraceback(l.getTraceback())))
+	}
+
+	if l.printTime {
+		args = append(args, fmt.Sprintf("[%s]", l.formatTime(time.Now())))
+	}
+
+	msg := Map(m, func(el any) string {
+		return fmt.Sprintf("%v", el)
+	})
+
+	return fmt.Sprintf("%s %v", strings.Join(args, " "), strings.Join(msg, " "))
+}
+
+func (l *Logger) print(level LogLevel, m []any) {
+	if l.level.n < level.n {
+		return
+	}
+	_, err := color.New(level.c).Println(l.buildString(level, m))
+	if err != nil {
+		l.Fatal(err)
+		return
+	}
+
+	for _, writer := range l.writers {
+		writer(level, l.prefix, l.formatFullTraceback(l.getFullTraceback(4)), m)
+	}
+
+	if l.f != nil {
+		writeToFiles := os.Getenv("WRITE_TO_FILE")
+		if writeToFiles != "false" {
+			if _, err := l.f.Write([]byte(l.buildString(level, m) + "\n")); err != nil {
+				l.Fatal(err)
+			}
+		}
+	}
+}

methods.go

@@ -0,0 +1,111 @@
+package laniakea
+
+import "fmt"
+
+var NO_PARAMS = make(map[string]interface{})
+
+func (b *Bot) Updates() ([]*Update, error) {
+	params := make(map[string]interface{})
+	params["offset"] = b.updateOffset
+	params["timeout"] = 30
+	params["allowed_updates"] = b.updateTypes
+
+	data, err := b.request("getUpdates", params)
+	if err != nil {
+		return nil, err
+	}
+	res := make([]*Update, 0)
+	for _, u := range data["data"].([]interface{}) {
+		updateObj := new(Update)
+		err = MapToStruct(u.(map[string]interface{}), updateObj)
+		if err != nil {
+			return res, err
+		}
+		b.updateOffset = updateObj.UpdateID + 1
+		err = b.updateQueue.Enqueue(updateObj)
+		if err != nil {
+			return res, err
+		}
+		res = append(res, updateObj)
+
+		if b.debug && b.requestLogger != nil {
+			j, err := MapToJson(u.(map[string]interface{}))
+			if err != nil {
+				b.logger.Error(err)
+			}
+			b.requestLogger.Debug(fmt.Sprintf("UPDATE %s", j))
+		}
+	}
+	return res, err
+}
+
+func (b *Bot) GetMe() (*User, error) {
+	data, err := b.request("getMe", NO_PARAMS)
+	if err != nil {
+		return nil, err
+	}
+	user := new(User)
+	err = MapToStruct(data, user)
+	return user, err
+}
+
+type SendMessageP struct {
+	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
+	ChatID               int                   `json:"chat_id"`
+	MessageThreadID      int                   `json:"message_thread_id,omitempty"`
+	Text                 string                `json:"text"`
+	ParseMode            ParseMode             `json:"parse_mode,omitempty"`
+	Entities             []*MessageEntity      `json:"entities,omitempty"`
+	LinkPreviewOptions   *LinkPreviewOptions   `json:"link_preview_options,omitempty"`
+	DisableNotifications bool                  `json:"disable_notifications,omitempty"`
+	ProtectContent       bool                  `json:"protect_content,omitempty"`
+	AllowPaidBroadcast   bool                  `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID      string                `json:"message_effect_id,omitempty"`
+	ReplyParameters      *ReplyParameters      `json:"reply_parameters,omitempty"`
+	InlineKeyboardMarkup *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	// ReplyKeyboardMarkup  *ReplyKeyboardMarkup  `json:"reply_markup,omitempty"`
+}
+
+func (b *Bot) SendMessage(params *SendMessageP) (*Message, error) {
+	dataP, err := StructToMap(params)
+	if err != nil {
+		return nil, err
+	}
+	data, err := b.request("sendMessage", dataP)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
+}
+
+type SendPhotoP struct {
+	BusinessConnectionID  string           `json:"business_connection_id,omitempty"`
+	ChatID                int              `json:"chat_id"`
+	MessageThreadID       int              `json:"message_thread_id,omitempty"`
+	Photo                 string           `json:"photo"`
+	Caption               string           `json:"caption,omitempty"`
+	ParseMode             ParseMode        `json:"parse_mode,omitempty"`
+	CaptionEntities       []*MessageEntity `json:"caption_entities,omitempty"`
+	ShowCaptionAboveMedia bool             `json:"show_caption_above_media"`
+	HasSpoiler            bool             `json:"has_spoiler"`
+	DisableNotifications  bool             `json:"disable_notifications,omitempty"`
+	ProtectContent        bool             `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool             `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string           `json:"message_effect_id,omitempty"`
+}
+
+func (b *Bot) SendPhoto(params *SendPhotoP) (*Message, error) {
+	dataP, err := StructToMap(params)
+	if err != nil {
+		return nil, err
+	}
+	data, err := b.request("sendPhoto", dataP)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
+}

plugins.go

@@ -1,7 +1,5 @@
 package laniakea
 
-import "log"
-
 type CommandExecutor func(ctx *MsgContext, dbContext *DatabaseContext)
 
 type PluginBuilder struct {
@@ -46,8 +44,8 @@ func (p *PluginBuilder) UpdateListener(listener CommandExecutor) *PluginBuilder
 }
 
 func (p *PluginBuilder) Build() *Plugin {
-	if len(p.commands) == 0 && len(p.payloads) == 0 {
+	if len(p.commands) == 0 {
-		log.Println("no command or payloads")
+		return nil
 	}
 	plugin := &Plugin{
 		Name:           p.name,

queue.go

@@ -1,7 +1,7 @@
 package laniakea
 
 import (
-	"fmt"
+	"errors"
 	"sync"
 )
 
@@ -11,6 +11,8 @@ type Queue[T any] struct {
 	queue []T
 }
 
+var QueueFullError = errors.New("queue full")
+
 func CreateQueue[T any](size uint64) *Queue[T] {
 	return &Queue[T]{
 		queue: make([]T, 0),
@@ -20,7 +22,7 @@ func CreateQueue[T any](size uint64) *Queue[T] {
 
 func (q *Queue[T]) Enqueue(el T) error {
 	if q.IsFull() {
-		return fmt.Errorf("queue full")
+		return QueueFullError
 	}
 	q.queue = append(q.queue, el)
 	return nil

types.go

@@ -12,9 +12,9 @@ type Update struct {
 	DeletedBusinessMessage *Message                     `json:"deleted_business_messages,omitempty"`
 	MessageReaction        *MessageReactionUpdated      `json:"message_reaction,omitempty"`
 	MessageReactionCount   *MessageReactionCountUpdated `json:"message_reaction_count,omitempty"`
-	CallbackQuery          *CallbackQuery               `json:"callback_query,omitempty"`
 	InlineQuery            int
 	ChosenInlineResult     int
+	CallbackQuery          *CallbackQuery `json:"callback_query,omitempty"`
 }
 
 type User struct {
@@ -43,10 +43,6 @@ type Chat struct {
 	IsForum   bool   `json:"is_forum,omitempty"`
 }
 
-type MessageReplyMarkup struct {
-	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
-}
-
 type Message struct {
 	MessageID       int    `json:"message_id"`
 	MessageThreadID int    `json:"message_thread_id,omitempty"`
@@ -57,8 +53,6 @@ type Message struct {
 	Photo          []*PhotoSize `json:"photo,omitempty"`
 	Caption        string       `json:"caption,omitempty"`
 	ReplyToMessage *Message     `json:"reply_to_message"`
-
-	ReplyMarkup *MessageReplyMarkup `json:"reply_markup,omitempty"`
 }
 
 type InaccessableMessage struct {
@@ -68,6 +62,8 @@ type InaccessableMessage struct {
 }
 
 type MaybeInaccessibleMessage struct {
+	Message
+	InaccessableMessage
 }
 
 type MessageEntity struct {
@@ -107,7 +103,7 @@ type LinkPreviewOptions struct {
 }
 
 type InlineKeyboardMarkup struct {
-	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard,omitempty"`
+	InlineKeyboard [][]*InlineKeyboardButton `json:"inline_keyboard"`
 }
 
 type InlineKeyboardButton struct {
@@ -122,8 +118,8 @@ type ReplyKeyboardMarkup struct {
 
 type CallbackQuery struct {
 	ID      string                    `json:"id"`
-	From    *User    `json:"from"`
+	From    *User                     `json:"user"`
-	Message *Message `json:"message"`
+	Message *MaybeInaccessibleMessage `json:"message"`
 
 	Data string `json:"data"`
 }

utils.go

@@ -0,0 +1,35 @@
+package laniakea
+
+import "encoding/json"
+
+func MapToStruct(m map[string]any, dst interface{}) error {
+	data, err := json.Marshal(m)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(data, dst)
+	return err
+}
+
+func MapToJson(m map[string]any) (string, error) {
+	data, err := json.Marshal(m)
+	return string(data), err
+}
+
+func StructToMap(s interface{}) (map[string]any, error) {
+	data, err := json.Marshal(s)
+	if err != nil {
+		return nil, err
+	}
+	m := make(map[string]any)
+	err = json.Unmarshal(data, &m)
+	return m, err
+}
+
+func Map[T, V any](ts []T, fn func(T) V) []V {
+	result := make([]V, len(ts))
+	for i, t := range ts {
+		result[i] = fn(t)
+	}
+	return result
+}

version.go

@@ -3,10 +3,10 @@ package laniakea
 import "os"
 
 const (
-	VersionString = "0.2.0"
+	VersionString = "0.1.4"
 	VersionMajor  = 0
-	VersionMinor  = 2
+	VersionMinor  = 1
-	VersionPatch  = 0
+	VersionPatch  = 4
 )
 
 var GoVersion = os.Getenv("GoV")