v0.3.0

api.go

@@ -3,56 +3,48 @@ package laniakea
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"strings"
 )
 
-type ApiResponse[R any] struct {
+type ApiResponse struct {
 	Ok          bool   `json:"ok"`
 	Description string `json:"description,omitempty"`
-	Result      R      `json:"result,omitempty"`
+	Result      any    `json:"result,omitempty"`
 	ErrorCode   int    `json:"error_code,omitempty"`
 }
 
-type TelegramRequest[R, P any] struct {
+// request is a low-level call to api.
-	method string
+func (b *Bot) request(methodName string, params any) (map[string]any, error) {
-	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(r.params)
+	err := json.NewEncoder(&buf).Encode(params)
 	if err != nil {
 		return nil, err
 	}
 
-	if bot.requestLogger != nil {
+	if b.debug && b.requestLogger != nil {
-		bot.requestLogger.Debugln(strings.ReplaceAll(fmt.Sprintf(
+		b.requestLogger.Debugln(strings.ReplaceAll(fmt.Sprintf(
 			"POST https://api.telegram.org/bot%s/%s %s",
-			"<TOKEN>", r.method, buf.String(),
+			"<TOKEN>",
+			methodName,
+			buf.String(),
 		), "\n", ""))
 	}
-
+	r, err := http.Post(fmt.Sprintf("https://api.telegram.org/bot%s/%s", b.token, methodName), "application/json", &buf)
-	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()
+	defer r.Body.Close()
-	data, err := io.ReadAll(req.Body)
+	data, err := io.ReadAll(r.Body)
 	if err != nil {
 		return nil, err
 	}
+	b.requestLogger.Debugln(fmt.Sprintf("RES %s %s", methodName, string(data)))
 
-	if bot.requestLogger != nil {
+	response := new(ApiResponse)
-		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
@@ -61,5 +53,16 @@ func (r TelegramRequest[R, P]) Do(bot *Bot) (*R, error) {
 	if !response.Ok {
 		return nil, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
 	}
-	return &response.Result, nil
+	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")
 }

methods.go

@@ -5,36 +5,31 @@ import (
 	"fmt"
 )
 
-type EmptyParams struct{}
+var NoParams = make(map[string]any)
-
-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 := UpdateParams{
+	params := make(map[string]any)
-		Offset:         b.updateOffset,
+	params["offset"] = b.updateOffset
-		Timeout:        30,
+	params["timeout"] = 30
-		AllowedUpdates: b.updateTypes,
+	params["allowed_updates"] = b.updateTypes
-	}
 
-	req := NewRequest[[]*Update]("getUpdates", params)
+	data, err := b.request("getUpdates", params)
-	res, err := req.Do(b)
 	if err != nil {
-		return []*Update{}, err
+		return nil, err
+	}
+	res := make([]*Update, 0)
+	err = AnyToStruct(data["data"], &res)
+	if err != nil {
+		return res, err
 	}
-	updates := *res
 	
-	for _, u := range updates {
+	for _, u := range res {
 		b.updateOffset = u.UpdateID + 1
 		err = b.updateQueue.Enqueue(u)
 		if err != nil {
-			return updates, err
+			return res, err
 		}
+		res = append(res, u)
 
 		if b.debug && b.requestLogger != nil {
 			j, err := json.Marshal(u)
@@ -44,12 +39,17 @@ func (b *Bot) Updates() ([]*Update, error) {
 			b.requestLogger.Debugln(fmt.Sprintf("UPDATE %s", j))
 		}
 	}
-	return updates, err
+	return res, err
 }
 
 func (b *Bot) GetMe() (*User, error) {
-	req := NewRequest[User, EmptyParams]("getMe", NoParams)
+	data, err := b.request("getMe", NoParams)
-	return req.Do(b)
+	if err != nil {
+		return nil, err
+	}
+	user := new(User)
+	err = MapToStruct(data, user)
+	return user, err
 }
 
 type SendMessageP struct {
@@ -69,8 +69,13 @@ type SendMessageP struct {
 }
 
 func (b *Bot) SendMessage(params *SendMessageP) (*Message, error) {
-	req := NewRequest[Message, SendMessageP]("sendMessage", *params)
+	data, err := b.request("sendMessage", params)
-	return req.Do(b)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
 }
 
 type SendPhotoP struct {
@@ -91,8 +96,13 @@ type SendPhotoP struct {
 }
 
 func (b *Bot) SendPhoto(params *SendPhotoP) (*Message, error) {
-	req := NewRequest[Message]("sendPhoto", params)
+	data, err := b.request("sendPhoto", params)
-	return req.Do(b)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
 }
 
 type EditMessageTextP struct {
@@ -106,8 +116,13 @@ type EditMessageTextP struct {
 }
 
 func (b *Bot) EditMessageText(params *EditMessageTextP) (*Message, error) {
-	req := NewRequest[Message]("editMessageText", params)
+	data, err := b.request("editMessageText", params)
-	return req.Do(b)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
 }
 
 type EditMessageCaptionP struct {
@@ -121,8 +136,13 @@ type EditMessageCaptionP struct {
 }
 
 func (b *Bot) EditMessageCaption(params *EditMessageCaptionP) (*Message, error) {
-	req := NewRequest[Message]("editMessageCaption", params)
+	data, err := b.request("editMessageCaption", params)
-	return req.Do(b)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
 }
 
 type DeleteMessageP struct {
@@ -131,6 +151,11 @@ type DeleteMessageP struct {
 }
 
 func (b *Bot) DeleteMessage(params *DeleteMessageP) (*Message, error) {
-	req := NewRequest[Message]("deleteMessage", params)
+	data, err := b.request("deleteMessage", params)
-	return req.Do(b)
+	if err != nil {
+		return nil, err
+	}
+	message := new(Message)
+	err = MapToStruct(data, message)
+	return message, err
 }

runners.go

@@ -61,15 +61,10 @@ 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 {