diff --git a/api.go b/api.go index 9a2babc..e4c6645 100644 --- a/api.go +++ b/api.go @@ -3,48 +3,56 @@ package laniakea import ( "bytes" "encoding/json" - "errors" "fmt" "io" "net/http" "strings" ) -type ApiResponse struct { +type ApiResponse[R any] struct { Ok bool `json:"ok"` Description string `json:"description,omitempty"` - Result any `json:"result,omitempty"` + Result R `json:"result,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]any, error) { +type TelegramRequest[R, P any] struct { + method string + params P +} + +func NewRequest[R, P any](method string, params P) TelegramRequest[R, P] { + return TelegramRequest[R, P]{method: method, params: params} +} +func (r TelegramRequest[R, P]) Do(bot *Bot) (*R, error) { var buf bytes.Buffer - err := json.NewEncoder(&buf).Encode(params) + err := json.NewEncoder(&buf).Encode(r.params) if err != nil { return nil, err } - if b.debug && b.requestLogger != nil { - b.requestLogger.Debugln(strings.ReplaceAll(fmt.Sprintf( + if bot.requestLogger != nil { + bot.requestLogger.Debugln(strings.ReplaceAll(fmt.Sprintf( "POST https://api.telegram.org/bot%s/%s %s", - "", - methodName, - buf.String(), + "", r.method, 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.Debugln(fmt.Sprintf("RES %s %s", methodName, string(data))) - response := new(ApiResponse) + req, err := http.Post(fmt.Sprintf("https://api.telegram.org/bot%s/%s", bot.token, r.method), "application/json", &buf) + if err != nil { + return nil, err + } + defer req.Body.Close() + data, err := io.ReadAll(req.Body) + if err != nil { + return nil, err + } + + if bot.requestLogger != nil { + bot.requestLogger.Debugln(fmt.Sprintf("RES %s %s", r.method, string(data))) + } + + response := new(ApiResponse[R]) err = json.Unmarshal(data, &response) if err != nil { return nil, err @@ -53,16 +61,5 @@ func (b *Bot) request(methodName string, params any) (map[string]any, error) { if !response.Ok { return nil, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description) } - if res, ok := response.Result.(bool); ok { - return map[string]any{ - "data": res, - }, nil - } else if res, ok := response.Result.([]any); ok { - return map[string]any{ - "data": res, - }, nil - } else if res, ok := response.Result.(map[string]any); ok { - return res, nil - } - return map[string]any{}, errors.New("can't parse response") + return &response.Result, nil } diff --git a/bot.go b/bot.go index 91b92b9..58c386b 100644 --- a/bot.go +++ b/bot.go @@ -1,7 +1,6 @@ package laniakea import ( - "encoding/json" "fmt" "log" "os" @@ -180,19 +179,20 @@ func (b *Bot) AddPlugins(plugin ...*Plugin) *Bot { 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.Debugln(fmt.Sprintf("middleware with name \"%s\" registered", m.Name)) } + + sort.Slice(&b.middlewares, func(i, j int) bool { + first := b.middlewares[i] + second := b.middlewares[j] + if first.Order == second.Order { + return first.Name < second.Name + } + return first.Order < second.Order + }) + return b } func (b *Bot) AddRunner(runner Runner) *Bot { @@ -243,6 +243,7 @@ func (b *Bot) Run() { b.logger.Errorln("update is nil") continue } + ctx := &MsgContext{ Bot: b, Update: u, } @@ -263,78 +264,3 @@ func (b *Bot) Run() { } } } - -// {"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) { - if update.Message == nil { - return - } - - var text string - if len(update.Message.Text) > 0 { - text = update.Message.Text - } else { - text = update.Message.Caption - } - - text = strings.TrimSpace(text) - prefix, hasPrefix := b.checkPrefixes(text) - if !hasPrefix { - return - } - ctx.Prefix = prefix - ctx.FromID = update.Message.From.ID - ctx.From = update.Message.From - ctx.Msg = update.Message - - 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) - return - } - } -} - -func (b *Bot) handleCallback(update *Update, ctx *MsgContext) { - data := new(CallbackData) - err := json.Unmarshal([]byte(update.CallbackQuery.Data), data) - if err != nil { - b.logger.Errorln(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) - return - } -} - -func (b *Bot) checkPrefixes(text string) (string, bool) { - for _, prefix := range b.prefixes { - if strings.HasPrefix(text, prefix) { - return prefix, true - } - } - return "", false -} diff --git a/handler.go b/handler.go new file mode 100644 index 0000000..3559d60 --- /dev/null +++ b/handler.go @@ -0,0 +1,79 @@ +package laniakea + +import ( + "encoding/json" + "strings" +) + +func (b *Bot) handleMessage(update *Update, ctx *MsgContext) { + if update.Message == nil { + return + } + + var text string + if len(update.Message.Text) > 0 { + text = update.Message.Text + } else { + text = update.Message.Caption + } + + text = strings.TrimSpace(text) + prefix, hasPrefix := b.checkPrefixes(text) + if !hasPrefix { + return + } + ctx.Prefix = prefix + ctx.FromID = update.Message.From.ID + ctx.From = update.Message.From + ctx.Msg = update.Message + + 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) + return + } + } +} + +func (b *Bot) handleCallback(update *Update, ctx *MsgContext) { + data := new(CallbackData) + err := json.Unmarshal([]byte(update.CallbackQuery.Data), data) + if err != nil { + b.logger.Errorln(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) + return + } +} + +func (b *Bot) checkPrefixes(text string) (string, bool) { + for _, prefix := range b.prefixes { + if strings.HasPrefix(text, prefix) { + return prefix, true + } + } + return "", false +} diff --git a/methods.go b/methods.go index f80cfa7..d2f02fe 100644 --- a/methods.go +++ b/methods.go @@ -5,31 +5,36 @@ import ( "fmt" ) -var NoParams = make(map[string]any) +type EmptyParams struct{} + +var NoParams = EmptyParams{} + +type UpdateParams struct { + Offset int `json:"offset"` + Timeout int `json:"timeout"` + AllowedUpdates []string `json:"allowed_updates"` +} func (b *Bot) Updates() ([]*Update, error) { - params := make(map[string]any) - params["offset"] = b.updateOffset - params["timeout"] = 30 - params["allowed_updates"] = b.updateTypes + params := UpdateParams{ + Offset: b.updateOffset, + Timeout: 30, + AllowedUpdates: b.updateTypes, + } - data, err := b.request("getUpdates", params) + req := NewRequest[[]*Update]("getUpdates", params) + res, err := req.Do(b) if err != nil { - return nil, err + return []*Update{}, err } - res := make([]*Update, 0) - err = AnyToStruct(data["data"], &res) - if err != nil { - return res, err - } - - for _, u := range res { + updates := *res + + for _, u := range updates { b.updateOffset = u.UpdateID + 1 err = b.updateQueue.Enqueue(u) if err != nil { - return res, err + return updates, err } - res = append(res, u) if b.debug && b.requestLogger != nil { j, err := json.Marshal(u) @@ -39,17 +44,12 @@ func (b *Bot) Updates() ([]*Update, error) { b.requestLogger.Debugln(fmt.Sprintf("UPDATE %s", j)) } } - return res, err + return updates, 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 + req := NewRequest[User, EmptyParams]("getMe", NoParams) + return req.Do(b) } type SendMessageP struct { @@ -69,13 +69,8 @@ type SendMessageP struct { } 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 + req := NewRequest[Message, SendMessageP]("sendMessage", *params) + return req.Do(b) } type SendPhotoP struct { @@ -96,13 +91,8 @@ type SendPhotoP struct { } 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 + req := NewRequest[Message]("sendPhoto", params) + return req.Do(b) } type EditMessageTextP struct { @@ -116,13 +106,8 @@ type EditMessageTextP struct { } 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 + req := NewRequest[Message]("editMessageText", params) + return req.Do(b) } type EditMessageCaptionP struct { @@ -136,13 +121,8 @@ type EditMessageCaptionP struct { } 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 + req := NewRequest[Message]("editMessageCaption", params) + return req.Do(b) } type DeleteMessageP struct { @@ -151,11 +131,6 @@ type DeleteMessageP struct { } 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 + req := NewRequest[Message]("deleteMessage", params) + return req.Do(b) } diff --git a/queue.go b/queue.go index 3789918..d319ce7 100644 --- a/queue.go +++ b/queue.go @@ -5,7 +5,7 @@ import ( "sync" ) -var QueueFullErr = errors.New("queue is full") +var QueueFullErr = errors.New("queue full") type Queue[T any] struct { size uint64 diff --git a/runners.go b/runners.go index 75daaa2..64988ec 100644 --- a/runners.go +++ b/runners.go @@ -61,10 +61,15 @@ func (b *Bot) ExecRunners() { } }() } else if !runner.Async && runner.Onetime { + t := time.Now() err := runner.Fn(b) if err != nil { b.logger.Warnf("Runner %s failed: %s\n", runner.Name, err) } + elapsed := time.Since(t) + if elapsed > time.Second*2 { + b.logger.Warnf("Runner %s too slow. Elapsed time %s>=2s", runner.Name, elapsed) + } } else if !runner.Onetime { go func() { for { diff --git a/version.go b/version.go index aa6cbec..eda06e3 100644 --- a/version.go +++ b/version.go @@ -1,8 +1,8 @@ package laniakea const ( - VersionString = "0.3.0" + VersionString = "0.3.2" VersionMajor = 0 VersionMinor = 3 - VersionPatch = 0 + VersionPatch = 2 )