Keep time limits with their operations

[onechat] / telegram_api.go

diff --git a/telegram_api.go b/telegram_api.go
index 32ad9a93b7616ad1dc6371de439386a35c948ac1..a04b2fa56e88af4aca8480d0dc29bbad964846af 100644 (file)
--- a/telegram_api.go
+++ b/telegram_api.go
@@ -41,10 +41,9 @@ const (
 // newTelegramAPI returns the client of the Bot API at base with token.
 func newTelegramAPI(base, token string) *TelegramAPI {
        return &TelegramAPI{
 // newTelegramAPI returns the client of the Bot API at base with token.
 func newTelegramAPI(base, token string) *TelegramAPI {
        return &TelegramAPI{

-               base:        base,
-               token:       token,
-               http:        &http.Client{},
-               sendTimeout: telegramSendTimeout,
+               base:  base,
+               token: token,
+               http:  &http.Client{},

        }
 }
 
        }
 }
 


@@ -78,14 +77,11 @@ func telegramRejected(err error) bool {
 }
 
 // TelegramAPI calls the Telegram Bot API. The bot token is a part of each URL,
 }
 
 // TelegramAPI calls the Telegram Bot API. The bot token is a part of each URL,

-// so no error of TelegramAPI holds a URL, a net/http error, or the token. Its
-// sendTimeout field limits each sendMessage, sendRichMessage, and
-// sendChatAction call.
+// so no error of TelegramAPI holds a URL, a net/http error, or the token.

 type TelegramAPI struct {
 type TelegramAPI struct {

-       base        string
-       token       string
-       http        *http.Client
-       sendTimeout time.Duration
+       base  string
+       token string
+       http  *http.Client

 }
 
 // GetUpdates waits for the updates from offset on, up to telegramPollSeconds,
 }
 
 // GetUpdates waits for the updates from offset on, up to telegramPollSeconds,


@@ -111,7 +107,7 @@ func (b *TelegramAPI) GetImage(ctx context.Context, id string) (data []byte, err
                Size int64  `json:"file_size"`
        }
 
                Size int64  `json:"file_size"`
        }
 

-       err = b.call(ctx, b.sendTimeout, "getFile", map[string]any{"file_id": id}, &file)
+       err = b.call(ctx, telegramSendTimeout, "getFile", map[string]any{"file_id": id}, &file)

        if err != nil {
                return nil, fmt.Errorf("get image file: %w", err)
        }
        if err != nil {
                return nil, fmt.Errorf("get image file: %w", err)
        }


@@ -124,7 +120,7 @@ func (b *TelegramAPI) GetImage(ctx context.Context, id string) (data []byte, err
                return nil, errors.New("invalid image file path")
        }
 
                return nil, errors.New("invalid image file path")
        }
 

-       ctx, cancel := context.WithTimeout(ctx, b.sendTimeout)
+       ctx, cancel := context.WithTimeout(ctx, telegramSendTimeout)

        defer cancel()
 
        request, err := http.NewRequestWithContext(ctx, http.MethodGet, b.base+"/file/bot"+b.token+"/"+file.Path, nil)
        defer cancel()
 
        request, err := http.NewRequestWithContext(ctx, http.MethodGet, b.base+"/file/bot"+b.token+"/"+file.Path, nil)


@@ -134,13 +130,13 @@ func (b *TelegramAPI) GetImage(ctx context.Context, id string) (data []byte, err
 
        response, err := b.http.Do(request)
        if err != nil {
 
        response, err := b.http.Do(request)
        if err != nil {

-               return nil, b.networkError("image download failed", err, b.sendTimeout)
+               return nil, b.networkError("image download failed", err, telegramSendTimeout)

        }
 
        defer func() {
                closeErr := response.Body.Close()
                if closeErr != nil {
        }
 
        defer func() {
                closeErr := response.Body.Close()
                if closeErr != nil {

-                       err = errors.Join(err, b.networkError("close image download", closeErr, b.sendTimeout))
+                       err = errors.Join(err, b.networkError("close image download", closeErr, telegramSendTimeout))

                }
        }()
 
                }
        }()
 


@@ -153,7 +149,7 @@ func (b *TelegramAPI) GetImage(ctx context.Context, id string) (data []byte, err
 
        data, err = io.ReadAll(io.LimitReader(response.Body, imageMaxBytes+1))
        if err != nil {
 
        data, err = io.ReadAll(io.LimitReader(response.Body, imageMaxBytes+1))
        if err != nil {

-               return nil, b.networkError("image cut off", err, b.sendTimeout)
+               return nil, b.networkError("image cut off", err, telegramSendTimeout)

        }
 
        if len(data) > imageMaxBytes {
        }
 
        if len(data) > imageMaxBytes {


@@ -177,14 +173,14 @@ func (b *TelegramAPI) SendMessage(ctx context.Context, chat int64, text string,
                params["entities"] = entities
        }
 
                params["entities"] = entities
        }
 

-       return b.call(ctx, b.sendTimeout, "sendMessage", params, nil)
+       return b.call(ctx, telegramSendTimeout, "sendMessage", params, nil)

 }
 
 // SendRichMessage sends markdown to chat as a rich message, which Telegram
 // renders itself, tables included. A call that takes longer than
 // telegramSendTimeout fails with a TelegramNetworkError.
 func (b *TelegramAPI) SendRichMessage(ctx context.Context, chat int64, markdown string) error {
 }
 
 // SendRichMessage sends markdown to chat as a rich message, which Telegram
 // renders itself, tables included. A call that takes longer than
 // telegramSendTimeout fails with a TelegramNetworkError.
 func (b *TelegramAPI) SendRichMessage(ctx context.Context, chat int64, markdown string) error {

-       return b.call(ctx, b.sendTimeout, "sendRichMessage", map[string]any{
+       return b.call(ctx, telegramSendTimeout, "sendRichMessage", map[string]any{

                "chat_id": chat,
                "rich_message": map[string]any{
                        "markdown": markdown,
                "chat_id": chat,
                "rich_message": map[string]any{
                        "markdown": markdown,


@@ -195,7 +191,7 @@ func (b *TelegramAPI) SendRichMessage(ctx context.Context, chat int64, markdown
 // SendTyping shows the typing action in chat for about five seconds. A call
 // that takes longer than telegramSendTimeout fails with a TelegramNetworkError.
 func (b *TelegramAPI) SendTyping(ctx context.Context, chat int64) error {
 // SendTyping shows the typing action in chat for about five seconds. A call
 // that takes longer than telegramSendTimeout fails with a TelegramNetworkError.
 func (b *TelegramAPI) SendTyping(ctx context.Context, chat int64) error {

-       return b.call(ctx, b.sendTimeout, "sendChatAction", map[string]any{
+       return b.call(ctx, telegramSendTimeout, "sendChatAction", map[string]any{

                "chat_id": chat,
                "action":  "typing",
        }, nil)
                "chat_id": chat,
                "action":  "typing",
        }, nil)