X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/48d7bce28b18ecef4c52c98821675605464cecb9..80e348724041a694002fc38f57e8868b9b9a2be9:/telegram_api.go

diff --git a/telegram_api.go b/telegram_api.go
index a04b2fa..3a44a0d 100644
--- a/telegram_api.go
+++ b/telegram_api.go
@@ -7,136 +7,211 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"mime/multipart"
 	"net/http"
 	"net/url"
 	"path"
+	"strconv"
 	"strings"
 	"time"
 )
 
 const (
-	// telegramPollSeconds is how long one getUpdates call waits for an
-	// update.
-	telegramPollSeconds = 50
+	// telegramUpdateWaitTimeout is how long one getUpdates call waits for
+	// an update.
+	telegramUpdateWaitTimeout = 50 * time.Second
 
-	// telegramPollSlack is how much longer than telegramPollSeconds a
+	// telegramPollSlack is how much longer than telegramUpdateWaitTimeout a
 	// getUpdates call can take before the bot gives it up.
 	telegramPollSlack = 20 * time.Second
 
 	// telegramPollTimeout is how long one getUpdates call can take.
-	telegramPollTimeout = telegramPollSeconds*time.Second + telegramPollSlack
-
-	// telegramSendTimeout is how long a sendMessage, sendRichMessage, or
-	// sendChatAction call can take. A connection that stops without a
-	// close, such as after a network change, then fails the call, and the
-	// sender tries again, instead of a wait until TCP gives up. The client
-	// has no timeout of its own, because the long poll of getUpdates needs
-	// a longer limit.
+	telegramPollTimeout = telegramUpdateWaitTimeout + telegramPollSlack
+
+	// telegramSendTimeout is how long a sendMessage or sendRichMessage call
+	// can take. A connection that stops without a close, such as after a
+	// network change, then fails the call, and the sender tries again,
+	// instead of a wait until TCP gives up. The client has no timeout of
+	// its own, because the long poll of getUpdates needs a longer limit.
 	telegramSendTimeout = 30 * time.Second
 
+	// telegramFileLookupTimeout is the longest wait for media file details.
+	telegramFileLookupTimeout = 30 * time.Second
+
+	// telegramFileDownloadTimeout is the longest wait for downloaded media
+	// bytes.
+	telegramFileDownloadTimeout = 30 * time.Second
+
+	// telegramTypingTimeout is the longest wait to show the typing action.
+	telegramTypingTimeout = 30 * time.Second
+
 	// telegramAnswerBytes is the most bytes of one answer of the Bot API.
 	telegramAnswerBytes = 16 << 20
 )
 
-// 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{},
-	}
+// 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.
+type TelegramAPI struct {
+	base  string
+	token string
+	http  *http.Client
 }
 
-// telegramRetryable tells if a later try of a failed Bot API call can work:
-// after a network error, HTTP 429, or a server error. It returns the wait that
-// the Bot API asks for, or 0.
-func telegramRetryable(err error) (bool, time.Duration) {
-	var network *TelegramNetworkError
+// TelegramNetworkError tells that a Bot API call got no valid answer, such as
+// after a network error. A later call can work. Cause tells why in plain words,
+// with no URL and no token.
+type TelegramNetworkError struct {
+	Cause string
+}
 
-	if errors.As(err, &network) {
-		return true, 0
-	}
+// TelegramError is an answer of the Bot API that tells of a failure. Its text
+// gives the HTTP status and the description, such as "502 Bad Gateway".
+// RetryAfter is the wait that the Bot API asks for after HTTP 429. Refused
+// tells that the answer is a Bot API answer with ok false, not a page of a
+// proxy or of a server error.
+type TelegramError struct {
+	Status      int
+	Description string
+	RetryAfter  time.Duration
+	Refused     bool
+}
 
-	var answer *TelegramError
+// TelegramUpdate is one update of getUpdates. Message is nil for the kinds of
+// updates that are not a new message.
+type TelegramUpdate struct {
+	UpdateID int64            `json:"update_id"`
+	Message  *TelegramMessage `json:"message"`
+}
 
-	if errors.As(err, &answer) {
-		return answer.Status == http.StatusTooManyRequests || answer.Status >= 500, answer.RetryAfter
-	}
+// TelegramEntity is a message entity of sendMessage: a part of the text with a
+// format, such as bold or a link. Offset and Length count UTF-16 code units.
+// URL is the target of a text_link, and Language the language of a pre.
+type TelegramEntity struct {
+	Type     string `json:"type"`
+	Offset   int    `json:"offset"`
+	Length   int    `json:"length"`
+	URL      string `json:"url,omitempty"`
+	Language string `json:"language,omitempty"`
+}
 
-	return false, 0
+// TelegramAnswer is the envelope of each answer of the Bot API.
+type TelegramAnswer struct {
+	OK          bool            `json:"ok"`
+	Result      json.RawMessage `json:"result"`
+	ErrorCode   int             `json:"error_code"`
+	Description string          `json:"description"`
+	Parameters  struct {
+		RetryAfter int `json:"retry_after"`
+	} `json:"parameters"`
 }
 
-// telegramRejected tells if the Bot API refused a call with ok false and HTTP
-// 400 or 404. Then the call did nothing: 400 refuses the request, and 404 tells
-// that the method is not there. An error page with no Bot API answer does not
-// tell this, so it is not a refusal.
-func telegramRejected(err error) bool {
-	var answer *TelegramError
+// TelegramMessage holds text and supported media metadata of a bot message.
+type TelegramMessage struct {
+	Chat     TelegramChat      `json:"chat"`
+	From     *TelegramUser     `json:"from"`
+	Text     string            `json:"text"`
+	Caption  string            `json:"caption"`
+	Photo    []TelegramPhoto   `json:"photo"`
+	Document *TelegramDocument `json:"document"`
+	Voice    *TelegramVoice    `json:"voice"`
+}
 
-	return errors.As(err, &answer) && answer.Refused && (answer.Status == http.StatusBadRequest || answer.Status == http.StatusNotFound)
+// TelegramVoice identifies a voice note in the authenticated file API.
+type TelegramVoice struct {
+	FileID   string `json:"file_id"`
+	FileSize int64  `json:"file_size"`
 }
 
-// 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.
-type TelegramAPI struct {
-	base  string
-	token string
-	http  *http.Client
+// TelegramPhoto is one supplied size of a photo.
+type TelegramPhoto struct {
+	FileID   string `json:"file_id"`
+	Width    int    `json:"width"`
+	Height   int    `json:"height"`
+	FileSize int64  `json:"file_size"`
+}
+
+// TelegramDocument is a file sent without photo compression.
+type TelegramDocument struct {
+	FileID   string `json:"file_id"`
+	MimeType string `json:"mime_type"`
+	FileSize int64  `json:"file_size"`
+}
+
+// TelegramChat is the chat of a message. Type is private for a chat with one
+// user.
+type TelegramChat struct {
+	ID   int64  `json:"id"`
+	Type string `json:"type"`
 }
 
-// GetUpdates waits for the updates from offset on, up to telegramPollSeconds,
-// and returns them. Telegram forgets each update before offset. Only new
-// messages are asked for.
+// TelegramUser is the sender of a message.
+type TelegramUser struct {
+	ID int64 `json:"id"`
+}
+
+// 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{},
+	}
+}
+
+// GetUpdates waits for the updates from offset on, up to
+// telegramUpdateWaitTimeout, and returns them. Telegram forgets each update
+// before offset. Only new messages are asked for.
 func (b *TelegramAPI) GetUpdates(ctx context.Context, offset int64) ([]TelegramUpdate, error) {
 	var updates []TelegramUpdate
 
 	err := b.call(ctx, telegramPollTimeout, "getUpdates", map[string]any{
 		"offset":          offset,
-		"timeout":         telegramPollSeconds,
+		"timeout":         int(telegramUpdateWaitTimeout / time.Second),
 		"allowed_updates": []string{"message"},
 	}, &updates)
 
 	return updates, err
 }
 
-// GetImage downloads a file through the authenticated file endpoint. Errors
-// never include its token or URL, and the body is limited before storage.
-func (b *TelegramAPI) GetImage(ctx context.Context, id string) (data []byte, err error) {
+// GetFile downloads bounded media through the authenticated file endpoint.
+// Errors never include its token or URL, and the body is limited before
+// storage.
+func (b *TelegramAPI) GetFile(ctx context.Context, id string, limit int64, tooLarge error) (data []byte, err error) {
 	var file struct {
 		Path string `json:"file_path"`
 		Size int64  `json:"file_size"`
 	}
 
-	err = b.call(ctx, telegramSendTimeout, "getFile", map[string]any{"file_id": id}, &file)
+	err = b.call(ctx, telegramFileLookupTimeout, "getFile", map[string]any{"file_id": id}, &file)
 	if err != nil {
-		return nil, fmt.Errorf("get image file: %w", err)
+		return nil, fmt.Errorf("get media file: %w", err)
 	}
 
-	if file.Size > imageMaxBytes {
-		return nil, errImageSize
+	if file.Size > limit {
+		return nil, tooLarge
 	}
 
 	if file.Path == "" || path.Clean(file.Path) != file.Path || strings.HasPrefix(file.Path, "/") || strings.HasPrefix(file.Path, "../") || strings.ContainsAny(file.Path, "?%#\\") {
-		return nil, errors.New("invalid image file path")
+		return nil, errors.New("invalid media file path")
 	}
 
-	ctx, cancel := context.WithTimeout(ctx, telegramSendTimeout)
+	ctx, cancel := context.WithTimeout(ctx, telegramFileDownloadTimeout)
 	defer cancel()
 
 	request, err := http.NewRequestWithContext(ctx, http.MethodGet, b.base+"/file/bot"+b.token+"/"+file.Path, nil)
 	if err != nil {
-		return nil, fmt.Errorf("make image request: %s", b.redact(err))
+		return nil, fmt.Errorf("make media request: %s", b.redact(err))
 	}
 
 	response, err := b.http.Do(request)
 	if err != nil {
-		return nil, b.networkError("image download failed", err, telegramSendTimeout)
+		return nil, b.networkError("media download failed", err, telegramFileDownloadTimeout)
 	}
 
 	defer func() {
 		closeErr := response.Body.Close()
 		if closeErr != nil {
-			err = errors.Join(err, b.networkError("close image download", closeErr, telegramSendTimeout))
+			err = errors.Join(err, b.networkError("close media download", closeErr, telegramFileDownloadTimeout))
 		}
 	}()
 
@@ -147,13 +222,13 @@ func (b *TelegramAPI) GetImage(ctx context.Context, id string) (data []byte, err
 		}
 	}
 
-	data, err = io.ReadAll(io.LimitReader(response.Body, imageMaxBytes+1))
+	data, err = io.ReadAll(io.LimitReader(response.Body, limit+1))
 	if err != nil {
-		return nil, b.networkError("image cut off", err, telegramSendTimeout)
+		return nil, b.networkError("media cut off", err, telegramFileDownloadTimeout)
 	}
 
-	if len(data) > imageMaxBytes {
-		return nil, errImageSize
+	if int64(len(data)) > limit {
+		return nil, tooLarge
 	}
 
 	return data, nil
@@ -188,10 +263,69 @@ func (b *TelegramAPI) SendRichMessage(ctx context.Context, chat int64, markdown
 	}, nil)
 }
 
+// SendImage uploads an image to the owner as a photo, or as a document when the
+// Bot API refuses the photo. Network failures do not trigger a second send.
+func (b *TelegramAPI) SendImage(ctx context.Context, chat int64, name string, data []byte, caption string) error {
+	err := b.sendImage(ctx, "sendPhoto", "photo", chat, name, data, caption)
+	if telegramRejected(err) {
+		err = b.sendImage(ctx, "sendDocument", "document", chat, name, data, caption)
+	}
+
+	return err
+}
+
+func (b *TelegramAPI) sendImage(ctx context.Context, method, field string, chat int64, name string, data []byte, caption string) error {
+	ctx, cancel := context.WithTimeout(ctx, telegramSendTimeout)
+	defer cancel()
+
+	var body bytes.Buffer
+
+	writer := multipart.NewWriter(&body)
+	err := writer.WriteField("chat_id", strconv.FormatInt(chat, 10))
+	if err != nil {
+		return fmt.Errorf("write image chat: %w", err)
+	}
+
+	err = writer.WriteField("caption", caption)
+	if err != nil {
+		return fmt.Errorf("write image caption: %w", err)
+	}
+
+	part, err := writer.CreateFormFile(field, name)
+	if err != nil {
+		return fmt.Errorf("make image part: %w", err)
+	}
+
+	_, err = part.Write(data)
+	if err != nil {
+		return fmt.Errorf("write image part: %w", err)
+	}
+
+	err = writer.Close()
+	if err != nil {
+		return fmt.Errorf("close image form: %w", err)
+	}
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodPost, b.base+"/bot"+b.token+"/"+method, &body)
+	if err != nil {
+		return fmt.Errorf("make image upload: %s", b.redact(err))
+	}
+
+	request.Header.Set("Content-Type", writer.FormDataContentType())
+
+	err = b.answer(request, telegramSendTimeout, nil)
+	if err != nil {
+		return fmt.Errorf("upload image: %w", err)
+	}
+
+	return nil
+}
+
 // SendTyping shows the typing action in chat for about five seconds. A call
-// that takes longer than telegramSendTimeout fails with a TelegramNetworkError.
+// that takes longer than telegramTypingTimeout fails with a
+// TelegramNetworkError.
 func (b *TelegramAPI) SendTyping(ctx context.Context, chat int64) error {
-	return b.call(ctx, telegramSendTimeout, "sendChatAction", map[string]any{
+	return b.call(ctx, telegramTypingTimeout, "sendChatAction", map[string]any{
 		"chat_id": chat,
 		"action":  "typing",
 	}, nil)
@@ -217,6 +351,11 @@ func (b *TelegramAPI) call(ctx context.Context, timeout time.Duration, method st
 
 	request.Header.Set("Content-Type", "application/json")
 
+	return b.answer(request, timeout, result)
+}
+
+// answer reads the bounded Bot API response without keeping its request URL.
+func (b *TelegramAPI) answer(request *http.Request, timeout time.Duration, result any) error {
 	response, err := b.http.Do(request)
 	if err != nil {
 		return b.networkError("no answer", err, timeout)
@@ -292,95 +431,39 @@ func (b *TelegramAPI) redact(err error) string {
 	return strings.ReplaceAll(err.Error(), b.token, "TOKEN")
 }
 
-// TelegramNetworkError tells that a Bot API call got no valid answer, such as
-// after a network error. A later call can work. Cause tells why in plain words,
-// with no URL and no token.
-type TelegramNetworkError struct {
-	Cause string
-}
-
 func (e *TelegramNetworkError) Error() string {
 	return e.Cause
 }
 
-// TelegramError is an answer of the Bot API that tells of a failure. Its text
-// gives the HTTP status and the description, such as "502 Bad Gateway".
-// RetryAfter is the wait that the Bot API asks for after HTTP 429. Refused
-// tells that the answer is a Bot API answer with ok false, not a page of a
-// proxy or of a server error.
-type TelegramError struct {
-	Status      int
-	Description string
-	RetryAfter  time.Duration
-	Refused     bool
-}
-
 func (e *TelegramError) Error() string {
 	return fmt.Sprintf("%d %s", e.Status, e.Description)
 }
 
-// TelegramUpdate is one update of getUpdates. Message is nil for the kinds of
-// updates that are not a new message.
-type TelegramUpdate struct {
-	UpdateID int64            `json:"update_id"`
-	Message  *TelegramMessage `json:"message"`
-}
-
-// TelegramEntity is a message entity of sendMessage: a part of the text with a
-// format, such as bold or a link. Offset and Length count UTF-16 code units.
-// URL is the target of a text_link, and Language the language of a pre.
-type TelegramEntity struct {
-	Type     string `json:"type"`
-	Offset   int    `json:"offset"`
-	Length   int    `json:"length"`
-	URL      string `json:"url,omitempty"`
-	Language string `json:"language,omitempty"`
-}
+// telegramRetryable tells if a later try of a failed Bot API call can work:
+// after a network error, HTTP 429, or a server error. It returns the wait that
+// the Bot API asks for, or 0.
+func telegramRetryable(err error) (bool, time.Duration) {
+	var network *TelegramNetworkError
 
-// TelegramAnswer is the envelope of each answer of the Bot API.
-type TelegramAnswer struct {
-	OK          bool            `json:"ok"`
-	Result      json.RawMessage `json:"result"`
-	ErrorCode   int             `json:"error_code"`
-	Description string          `json:"description"`
-	Parameters  struct {
-		RetryAfter int `json:"retry_after"`
-	} `json:"parameters"`
-}
+	if errors.As(err, &network) {
+		return true, 0
+	}
 
-// TelegramMessage holds the text, caption, and image sizes of a bot message.
-type TelegramMessage struct {
-	Chat     TelegramChat      `json:"chat"`
-	From     *TelegramUser     `json:"from"`
-	Text     string            `json:"text"`
-	Caption  string            `json:"caption"`
-	Photo    []TelegramPhoto   `json:"photo"`
-	Document *TelegramDocument `json:"document"`
-}
+	var answer *TelegramError
 
-// TelegramPhoto is one supplied size of a photo.
-type TelegramPhoto struct {
-	FileID   string `json:"file_id"`
-	Width    int    `json:"width"`
-	Height   int    `json:"height"`
-	FileSize int64  `json:"file_size"`
-}
+	if errors.As(err, &answer) {
+		return answer.Status == http.StatusTooManyRequests || answer.Status >= 500, answer.RetryAfter
+	}
 
-// TelegramDocument is a file sent without photo compression.
-type TelegramDocument struct {
-	FileID   string `json:"file_id"`
-	MimeType string `json:"mime_type"`
-	FileSize int64  `json:"file_size"`
+	return false, 0
 }
 
-// TelegramChat is the chat of a message. Type is private for a chat with one
-// user.
-type TelegramChat struct {
-	ID   int64  `json:"id"`
-	Type string `json:"type"`
-}
+// telegramRejected tells if the Bot API refused a call with ok false and HTTP
+// 400 or 404. Then the call did nothing: 400 refuses the request, and 404 tells
+// that the method is not there. An error page with no Bot API answer does not
+// tell this, so it is not a refusal.
+func telegramRejected(err error) bool {
+	var answer *TelegramError
 
-// TelegramUser is the sender of a message.
-type TelegramUser struct {
-	ID int64 `json:"id"`
+	return errors.As(err, &answer) && answer.Refused && (answer.Status == http.StatusBadRequest || answer.Status == http.StatusNotFound)
 }