v0.2.0

laniakea/bot.go

@@ -5,10 +5,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"os"
 	"sort"
 	"strings"
+	"time"
 
 	"github.com/redis/go-redis/v9"
 	"github.com/vinovest/sqlx"
@@ -66,13 +68,15 @@ func LoadSettingsFromEnv() *BotSettings {
 }
 
 type MsgContext struct {
-	Bot    *Bot
-	Msg    *Message
-	Update *Update
-	FromID int
-	Prefix string
-	Text   string
-	Args   []string
+	Bot           *Bot
+	Msg           *Message
+	Update        *Update
+	From          *User
+	CallbackMsgId int
+	FromID        int
+	Prefix        string
+	Text          string
+	Args          []string
 }
 
 type DatabaseContext struct {
@@ -101,15 +105,28 @@ func NewBot(settings *BotSettings) *Bot {
 	if settings.Debug {
 		level = DEBUG
 	}
-	bot.logger = CreateLogger().Level(level)
+
+	bot.logger = CreateLogger().Level(level).PrintTraceback(true)
+	bot.logger.AddWriter(bot.logger.CreateStdoutWriter())
 	if settings.WriteToFile {
-		bot.logger = bot.logger.OpenFile(fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/")))
+		path := fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/"))
+		fileWriter, err := bot.logger.CreateFileWriter(path)
+		if err != nil {
+			bot.logger.Fatal(err)
+		}
+		bot.logger.AddWriter(fileWriter)
 	}
-	bot.logger = bot.logger.PrintTraceback(true)
+
 	if settings.UseRequestLogger {
 		bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS")
+		bot.requestLogger.AddWriter(bot.requestLogger.CreateStdoutWriter())
 		if settings.WriteToFile {
-			bot.requestLogger = bot.requestLogger.OpenFile(fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/")))
+			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/"))
+			fileWriter, err := bot.requestLogger.CreateFileWriter(path)
+			if err != nil {
+				bot.logger.Fatal(err)
+			}
+			bot.requestLogger.AddWriter(fileWriter)
 		}
 	}
 
@@ -117,11 +134,11 @@ func NewBot(settings *BotSettings) *Bot {
 }
 
 func (b *Bot) Close() {
-	err := b.logger.f.Close()
-	if err != nil {
-		fmt.Println(err)
-	} else {
-		fmt.Println("log closed")
+	for _, writer := range b.logger.writers {
+		err := writer.Close()
+		if err != nil {
+			log.Println(err)
+		}
 	}
 }
 
@@ -129,11 +146,11 @@ 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)
+func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) *LoggerWriter) *Bot {
+	w := writer(b.dbContext)
+	b.logger.AddWriter(w)
 	if b.requestLogger != nil {
-		b.requestLogger.AddWriters(w)
+		b.requestLogger.AddWriter(w)
 	}
 	return b
 }
@@ -174,7 +191,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\" was registered", p.Name))
+		b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" registered", p.Name))
 	}
 	return b
 }
@@ -191,7 +208,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\" was registered", m.Name))
+		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
 	}
 	return b
 }
@@ -215,12 +232,14 @@ 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
 		}
 
@@ -265,6 +284,7 @@ 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)
@@ -298,6 +318,12 @@ func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
 		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 {
@@ -325,6 +351,65 @@ type AnswerMessage struct {
 	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,
@@ -354,54 +439,46 @@ func (ctx *MsgContext) Keyboard(text string, kb *InlineKeyboard) *AnswerMessage
 	return ctx.answer(text, kb)
 }
 
-func (ctx *MsgContext) AnswerPhoto(photoId string, text string) *AnswerMessage {
-	_, err := ctx.Bot.SendPhoto(&SendPhotoP{
+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: ctx.Msg.MessageID, ctx: ctx, IsMedia: true, Text: text,
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
 	}
 }
-
-func (m *AnswerMessage) Edit(text string) *AnswerMessage {
-	var msg *Message
-	var err error
-	if m.IsMedia {
-		msg, err = m.ctx.Bot.EditMessageCaption(&EditMessageCaptionP{
-			MessageID: m.MessageID,
-			ChatID:    m.ctx.Msg.Chat.ID,
-			Caption:   text,
-			ParseMode: ParseMD,
-		})
-	} else {
-		msg, err = m.ctx.Bot.EditMessageText(&EditMessageTextP{
-			MessageID: m.MessageID,
-			ChatID:    m.ctx.Msg.Chat.ID,
-			Text:      text,
-			ParseMode: ParseMD,
-		})
-	}
-	if err != nil {
-		m.ctx.Bot.logger.Error(err)
-	}
-	m.MessageID = msg.MessageID
-	return m
+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 (m *AnswerMessage) Delete() {
-	_, err := m.ctx.Bot.DeleteMessage(&DeleteMessageP{
-		MessageID: m.MessageID, ChatID: m.ctx.Msg.Chat.ID,
+func (ctx *MsgContext) delete(messageId int) {
+	_, err := ctx.Bot.DeleteMessage(&DeleteMessageP{
+		ChatID:    ctx.Msg.Chat.ID,
+		MessageID: messageId,
 	})
 	if err != nil {
-		m.ctx.Bot.logger.Error(err)
+		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{
@@ -420,17 +497,17 @@ func (b *Bot) Logger() *Logger {
 }
 
 type ApiResponse struct {
-	Ok          bool                   `json:"ok"`
-	Result      map[string]interface{} `json:"result,omitempty"`
-	Description string                 `json:"description,omitempty"`
-	ErrorCode   int                    `json:"error_code,omitempty"`
+	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      []interface{} `json:"result,omitempty"`
-	Description string        `json:"description,omitempty"`
-	ErrorCode   int           `json:"error_code,omitempty"`
+	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.
@@ -458,9 +535,10 @@ func (b *Bot) request(methodName string, params any) (map[string]interface{}, er
 	if err != nil {
 		return nil, err
 	}
+	b.requestLogger.Debug(fmt.Sprintf("RES %s %s", methodName, string(data)))
 	response := new(ApiResponse)
 
-	var result map[string]interface{}
+	var result map[string]any
 
 	err = json.Unmarshal(data, &response)
 	if err != nil {

laniakea/keyboard.go

@@ -1,49 +1,70 @@
 package laniakea
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"fmt"
+)
 
 type InlineKeyboard struct {
 	CurrentLine []InlineKeyboardButton
 	Lines       [][]InlineKeyboardButton
+	maxRow      int
 }
 
-func NewInlineKeyboard() *InlineKeyboard {
+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, data CallbackData) *InlineKeyboard {
-	return in.append(InlineKeyboardButton{Text: text, CallbackData: data.ToJson()})
+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 {
+func (in *InlineKeyboard) Get() InlineKeyboardMarkup {
 	if len(in.CurrentLine) > 0 {
 		in.Lines = append(in.Lines, in.CurrentLine)
 	}
-	return &InlineKeyboardMarkup{
+	return InlineKeyboardMarkup{
 		InlineKeyboard: in.Lines,
 	}
 }
 
 type CallbackData struct {
-	Command string `json:"cmd"`
-	Args    []any  `json:"args"`
+	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 {

laniakea/logger.go

@@ -2,6 +2,7 @@ package laniakea
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -12,16 +13,30 @@ import (
 	"github.com/fatih/color"
 )
 
-type LoggerWriter func(level LogLevel, prefix, traceback string, message []any)
+type LoggerWriter struct {
+	writer  io.Writer
+	writeFn LoggerWriterFn
+	logger  *Logger
+}
+
+func (w *LoggerWriter) SetFn(fn LoggerWriterFn) {
+	w.writeFn = fn
+}
+func (w *LoggerWriter) Write(p []byte) (n int, err error) {
+	return w.writer.Write(p)
+}
+func (w *LoggerWriter) Close() error {
+	return w.writer.(io.Closer).Close()
+}
+
+type LoggerWriterFn func(level LogLevel, prefix, traceback string, message []any) error
 
 type Logger struct {
 	prefix         string
 	level          LogLevel
 	printTraceback bool
 	printTime      bool
-	writers        []LoggerWriter
-
-	f *os.File
+	writers        []*LoggerWriter
 }
 
 type LogLevel struct {
@@ -60,16 +75,34 @@ func CreateLogger() *Logger {
 	}
 }
 
-func (l *Logger) OpenFile(name string) *Logger {
-	err := os.MkdirAll(filepath.Dir(name), os.ModePerm)
+func (l *Logger) CreateFileWriter(path string) (*LoggerWriter, error) {
+	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
 	if err != nil {
-		l.Fatal(err)
+		return nil, err
 	}
-	l.f, err = os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
-		l.Fatal(err)
+		return nil, err
 	}
-	return l
+
+	writer := &LoggerWriter{
+		writer: file, logger: l,
+	}
+	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
+		_, err = writer.Write([]byte(writer.logger.buildString(level, message) + "\n"))
+		return err
+	}
+	return writer, nil
+}
+func (l *Logger) CreateStdoutWriter() *LoggerWriter {
+	writer := &LoggerWriter{
+		writer: os.Stdout, logger: l,
+	}
+	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
+		_, err := color.New(level.c).Fprint(writer.writer, writer.logger.buildString(level, message))
+		return err
+	}
+	return writer
 }
 
 func (l *Logger) Prefix(prefix string) *Logger {
@@ -88,11 +121,18 @@ func (l *Logger) PrintTime(b bool) *Logger {
 	l.printTime = b
 	return l
 }
-func (l *Logger) AddWriters(writers []LoggerWriter) *Logger {
+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, m ...any) {
+	l.print(INFO, []any{fmt.Sprintf(format, m...)})
+}
 func (l *Logger) Info(m ...any) {
 	l.print(INFO, m)
 }
@@ -209,19 +249,11 @@ 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 {
-		if _, err := l.f.Write([]byte(l.buildString(level, m) + "\n")); err != nil {
-			l.Fatal(err)
+		err := writer.writeFn(level, l.prefix, l.formatFullTraceback(l.getFullTraceback(0)), m)
+		if err != nil {
+			l.Error(err)
 		}
 	}
 }

laniakea/methods.go

@@ -0,0 +1,169 @@
+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/plugins.go

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

laniakea/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 {
@@ -44,7 +44,7 @@ type Chat struct {
 }
 
 type MessageReplyMarkup struct {
-	InlineKeyboard *InlineKeyboardMarkup `json:"inline_keyboard"`
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
 }
 
 type Message struct {
@@ -68,8 +68,6 @@ type InaccessableMessage struct {
 }
 
 type MaybeInaccessibleMessage struct {
-	Message
-	InaccessableMessage
 }
 
 type MessageEntity struct {
@@ -109,7 +107,7 @@ type LinkPreviewOptions struct {
 }
 
 type InlineKeyboardMarkup struct {
-	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard,omitempty"`
 }
 
 type InlineKeyboardButton struct {
@@ -123,9 +121,9 @@ type ReplyKeyboardMarkup struct {
 }
 
 type CallbackQuery struct {
-	ID      string                    `json:"id"`
-	From    *User                     `json:"user"`
-	Message *MaybeInaccessibleMessage `json:"message"`
+	ID      string   `json:"id"`
+	From    *User    `json:"from"`
+	Message *Message `json:"message"`
 
 	Data string `json:"data"`
 }

methods.go

@@ -1,156 +0,0 @@
-package laniakea
-
-import "fmt"
-
-var NoParams = 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", 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"`
-	// ReplyKeyboardMarkup  *ReplyKeyboardMarkup  `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"`
-}
-
-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"`
-}
-
-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"`
-}
-
-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
-}