From 6b9075c72260effba22f49d0b58a55d7f422582c Mon Sep 17 00:00:00 2001 From: ScuroNeko Date: Thu, 19 Mar 2026 15:10:49 +0300 Subject: [PATCH] feat(tgapi): add context-aware API/uploader methods and align params/docs with Telegram Bot API --- bot.go | 4 + tgapi/attachments_methods.go | 98 +++++++++-- tgapi/bot_methods.go | 146 +++++++++++++++++ tgapi/business_methods.go | 194 ++++++++++++++++++++++ tgapi/chat_methods.go | 258 +++++++++++++++++++++++++++++ tgapi/forum_methods.go | 106 ++++++++++++ tgapi/games_methods.go | 33 ++++ tgapi/inline_methods.go | 26 +++ tgapi/messages_methods.go | 303 ++++++++++++++++++++++++++++++++--- tgapi/methods.go | 76 ++++++++- tgapi/passport_methods.go | 10 ++ tgapi/payments_methods.go | 41 ++++- tgapi/stars_methods.go | 34 ++++ tgapi/stickers_methods.go | 138 ++++++++++++++++ tgapi/uploader_api.go | 2 + tgapi/uploader_methods.go | 110 +++++++++++++ tgapi/users_methods.go | 34 ++++ utils/version.go | 4 +- 18 files changed, 1582 insertions(+), 35 deletions(-) diff --git a/bot.go b/bot.go index cc42c25..803a0ed 100644 --- a/bot.go +++ b/bot.go @@ -193,6 +193,10 @@ func (bot *Bot[T]) Close() error { bot.logger.Errorln(err) e = append(e, err) } + if _, err := bot.api.Close(); err != nil { + bot.logger.Errorln(err) + e = append(e, err) + } if err := bot.api.CloseApi(); err != nil { bot.logger.Errorln(err) e = append(e, err) diff --git a/tgapi/attachments_methods.go b/tgapi/attachments_methods.go index 7fff755..078d1d0 100644 --- a/tgapi/attachments_methods.go +++ b/tgapi/attachments_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // SendPhotoP holds parameters for the sendPhoto method. // See https://core.telegram.org/bots/api#sendphoto type SendPhotoP struct { @@ -32,6 +34,14 @@ func (api *API) SendPhoto(params SendPhotoP) (Message, error) { return req.Do(api) } +// SendPhotoWithContext is the context-aware variant of SendPhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendphoto +func (api *API) SendPhotoWithContext(ctx context.Context, params SendPhotoP) (Message, error) { + req := NewRequestWithChatID[Message]("sendPhoto", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendAudioP holds parameters for the sendAudio method. // See https://core.telegram.org/bots/api#sendaudio type SendAudioP struct { @@ -47,6 +57,7 @@ type SendAudioP struct { Duration int `json:"duration,omitempty"` Performer string `json:"performer,omitempty"` Title string `json:"title,omitempty"` + Thumbnail string `json:"thumbnail,omitempty"` DisableNotification bool `json:"disable_notification,omitempty"` ProtectContent bool `json:"protect_content,omitempty"` @@ -65,6 +76,14 @@ func (api *API) SendAudio(params SendAudioP) (Message, error) { return req.Do(api) } +// SendAudioWithContext is the context-aware variant of SendAudio. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendaudio +func (api *API) SendAudioWithContext(ctx context.Context, params SendAudioP) (Message, error) { + req := NewRequestWithChatID[Message]("sendAudio", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendDocumentP holds parameters for the sendDocument method. // See https://core.telegram.org/bots/api#senddocument type SendDocumentP struct { @@ -73,10 +92,12 @@ type SendDocumentP struct { MessageThreadID int `json:"message_thread_id,omitempty"` DirectMessagesTopicID int `json:"direct_messages_topic_id,omitempty"` - Document string `json:"document"` - Caption string `json:"caption,omitempty"` - ParseMode ParseMode `json:"parse_mode,omitempty"` - CaptionEntities []MessageEntity `json:"caption_entities,omitempty"` + Document string `json:"document"` + Thumbnail string `json:"thumbnail,omitempty"` + Caption string `json:"caption,omitempty"` + ParseMode ParseMode `json:"parse_mode,omitempty"` + CaptionEntities []MessageEntity `json:"caption_entities,omitempty"` + DisableContentTypeDetection bool `json:"disable_content_type_detection,omitempty"` DisableNotification bool `json:"disable_notification,omitempty"` ProtectContent bool `json:"protect_content,omitempty"` @@ -95,6 +116,14 @@ func (api *API) SendDocument(params SendDocumentP) (Message, error) { return req.Do(api) } +// SendDocumentWithContext is the context-aware variant of SendDocument. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#senddocument +func (api *API) SendDocumentWithContext(ctx context.Context, params SendDocumentP) (Message, error) { + req := NewRequestWithChatID[Message]("sendDocument", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendVideoP holds parameters for the sendVideo method. // See https://core.telegram.org/bots/api#sendvideo type SendVideoP struct { @@ -103,11 +132,12 @@ type SendVideoP struct { MessageThreadID int `json:"message_thread_id,omitempty"` DirectMessagesTopicID int `json:"direct_messages_topic_id,omitempty"` - Video string `json:"video"` - Duration int `json:"duration,omitempty"` - Width int `json:"width,omitempty"` - Height int `json:"height,omitempty"` - Cover string `json:"cover,omitempty"` + Video string `json:"video"` + Thumbnail string `json:"thumbnail,omitempty"` + Duration int `json:"duration,omitempty"` + Width int `json:"width,omitempty"` + Height int `json:"height,omitempty"` + Cover string `json:"cover,omitempty"` StartTimestamp int `json:"start_timestamp,omitempty"` Caption string `json:"caption,omitempty"` @@ -134,6 +164,14 @@ func (api *API) SendVideo(params SendVideoP) (Message, error) { return req.Do(api) } +// SendVideoWithContext is the context-aware variant of SendVideo. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendvideo +func (api *API) SendVideoWithContext(ctx context.Context, params SendVideoP) (Message, error) { + req := NewRequestWithChatID[Message]("sendVideo", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendAnimationP holds parameters for the sendAnimation method. // See https://core.telegram.org/bots/api#sendanimation type SendAnimationP struct { @@ -143,6 +181,7 @@ type SendAnimationP struct { DirectMessagesTopicID int `json:"direct_messages_topic_id,omitempty"` Animation string `json:"animation"` + Thumbnail string `json:"thumbnail,omitempty"` Duration int `json:"duration,omitempty"` Width int `json:"width,omitempty"` Height int `json:"height,omitempty"` @@ -169,6 +208,14 @@ func (api *API) SendAnimation(params SendAnimationP) (Message, error) { return req.Do(api) } +// SendAnimationWithContext is the context-aware variant of SendAnimation. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendanimation +func (api *API) SendAnimationWithContext(ctx context.Context, params SendAnimationP) (Message, error) { + req := NewRequestWithChatID[Message]("sendAnimation", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendVoiceP holds parameters for the sendVoice method. // See https://core.telegram.org/bots/api#sendvoice type SendVoiceP struct { @@ -199,6 +246,14 @@ func (api *API) SendVoice(params *SendVoiceP) (Message, error) { return req.Do(api) } +// SendVoiceWithContext is the context-aware variant of SendVoice. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendvoice +func (api *API) SendVoiceWithContext(ctx context.Context, params *SendVoiceP) (Message, error) { + req := NewRequestWithChatID[Message]("sendVoice", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendVideoNoteP holds parameters for the sendVideoNote method. // See https://core.telegram.org/bots/api#sendvideonote type SendVideoNoteP struct { @@ -208,6 +263,7 @@ type SendVideoNoteP struct { DirectMessagesTopicID int `json:"direct_messages_topic_id,omitempty"` VideoNote string `json:"video_note"` + Thumbnail string `json:"thumbnail,omitempty"` Duration int `json:"duration,omitempty"` Length int `json:"length,omitempty"` DisableNotification bool `json:"disable_notification,omitempty"` @@ -227,6 +283,14 @@ func (api *API) SendVideoNote(params SendVideoNoteP) (Message, error) { return req.Do(api) } +// SendVideoNoteWithContext is the context-aware variant of SendVideoNote. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendvideonote +func (api *API) SendVideoNoteWithContext(ctx context.Context, params SendVideoNoteP) (Message, error) { + req := NewRequestWithChatID[Message]("sendVideoNote", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendPaidMediaP holds parameters for the sendPaidMedia method. // See https://core.telegram.org/bots/api#sendpaidmedia type SendPaidMediaP struct { @@ -258,6 +322,14 @@ func (api *API) SendPaidMedia(params SendPaidMediaP) (Message, error) { return req.Do(api) } +// SendPaidMediaWithContext is the context-aware variant of SendPaidMedia. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendpaidmedia +func (api *API) SendPaidMediaWithContext(ctx context.Context, params SendPaidMediaP) (Message, error) { + req := NewRequestWithChatID[Message]("sendPaidMedia", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendMediaGroupP holds parameters for the sendMediaGroup method. // See https://core.telegram.org/bots/api#sendmediagroup type SendMediaGroupP struct { @@ -280,3 +352,11 @@ func (api *API) SendMediaGroup(params SendMediaGroupP) ([]Message, error) { req := NewRequestWithChatID[[]Message]("sendMediaGroup", params, params.ChatID) return req.Do(api) } + +// SendMediaGroupWithContext is the context-aware variant of SendMediaGroup. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendmediagroup +func (api *API) SendMediaGroupWithContext(ctx context.Context, params SendMediaGroupP) ([]Message, error) { + req := NewRequestWithChatID[[]Message]("sendMediaGroup", params, params.ChatID) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/bot_methods.go b/tgapi/bot_methods.go index 28e78f7..5956755 100644 --- a/tgapi/bot_methods.go +++ b/tgapi/bot_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // SetMyCommandsP holds parameters for the setMyCommands method. // See https://core.telegram.org/bots/api#setmycommands type SetMyCommandsP struct { @@ -16,6 +18,14 @@ func (api *API) SetMyCommands(params SetMyCommandsP) (bool, error) { return req.Do(api) } +// SetMyCommandsWithContext is the context-aware variant of SetMyCommands. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setmycommands +func (api *API) SetMyCommandsWithContext(ctx context.Context, params SetMyCommandsP) (bool, error) { + req := NewRequest[bool]("setMyCommands", params) + return req.DoWithContext(ctx, api) +} + // DeleteMyCommandsP holds parameters for the deleteMyCommands method. // See https://core.telegram.org/bots/api#deletemycommands type DeleteMyCommandsP struct { @@ -31,6 +41,14 @@ func (api *API) DeleteMyCommands(params DeleteMyCommandsP) (bool, error) { return req.Do(api) } +// DeleteMyCommandsWithContext is the context-aware variant of DeleteMyCommands. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletemycommands +func (api *API) DeleteMyCommandsWithContext(ctx context.Context, params DeleteMyCommandsP) (bool, error) { + req := NewRequest[bool]("deleteMyCommands", params) + return req.DoWithContext(ctx, api) +} + // GetMyCommands holds parameters for the getMyCommands method. // See https://core.telegram.org/bots/api#getmycommands type GetMyCommands struct { @@ -45,6 +63,14 @@ func (api *API) GetMyCommands(params GetMyCommands) ([]BotCommand, error) { return req.Do(api) } +// GetMyCommandsWithContext is the context-aware variant of GetMyCommands. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getmycommands +func (api *API) GetMyCommandsWithContext(ctx context.Context, params GetMyCommands) ([]BotCommand, error) { + req := NewRequest[[]BotCommand]("getMyCommands", params) + return req.DoWithContext(ctx, api) +} + // SetMyName holds parameters for the setMyName method. // See https://core.telegram.org/bots/api#setmyname type SetMyName struct { @@ -60,6 +86,14 @@ func (api *API) SetMyName(params SetMyName) (bool, error) { return req.Do(api) } +// SetMyNameWithContext is the context-aware variant of SetMyName. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setmyname +func (api *API) SetMyNameWithContext(ctx context.Context, params SetMyName) (bool, error) { + req := NewRequest[bool]("setMyName", params) + return req.DoWithContext(ctx, api) +} + // GetMyName holds parameters for the getMyName method. // See https://core.telegram.org/bots/api#getmyname type GetMyName struct { @@ -73,6 +107,14 @@ func (api *API) GetMyName(params GetMyName) (BotName, error) { return req.Do(api) } +// GetMyNameWithContext is the context-aware variant of GetMyName. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getmyname +func (api *API) GetMyNameWithContext(ctx context.Context, params GetMyName) (BotName, error) { + req := NewRequest[BotName]("getMyName", params) + return req.DoWithContext(ctx, api) +} + // SetMyDescription holds parameters for the setMyDescription method. // See https://core.telegram.org/bots/api#setmydescription type SetMyDescription struct { @@ -88,6 +130,14 @@ func (api *API) SetMyDescription(params SetMyDescription) (bool, error) { return req.Do(api) } +// SetMyDescriptionWithContext is the context-aware variant of SetMyDescription. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setmydescription +func (api *API) SetMyDescriptionWithContext(ctx context.Context, params SetMyDescription) (bool, error) { + req := NewRequest[bool]("setMyDescription", params) + return req.DoWithContext(ctx, api) +} + // GetMyDescription holds parameters for the getMyDescription method. // See https://core.telegram.org/bots/api#getmydescription type GetMyDescription struct { @@ -101,6 +151,14 @@ func (api *API) GetMyDescription(params GetMyDescription) (BotDescription, error return req.Do(api) } +// GetMyDescriptionWithContext is the context-aware variant of GetMyDescription. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getmydescription +func (api *API) GetMyDescriptionWithContext(ctx context.Context, params GetMyDescription) (BotDescription, error) { + req := NewRequest[BotDescription]("getMyDescription", params) + return req.DoWithContext(ctx, api) +} + // SetMyShortDescription holds parameters for the setMyShortDescription method. // See https://core.telegram.org/bots/api#setmyshortdescription type SetMyShortDescription struct { @@ -116,6 +174,14 @@ func (api *API) SetMyShortDescription(params SetMyShortDescription) (bool, error return req.Do(api) } +// SetMyShortDescriptionWithContext is the context-aware variant of SetMyShortDescription. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setmyshortdescription +func (api *API) SetMyShortDescriptionWithContext(ctx context.Context, params SetMyShortDescription) (bool, error) { + req := NewRequest[bool]("setMyShortDescription", params) + return req.DoWithContext(ctx, api) +} + // GetMyShortDescription holds parameters for the getMyShortDescription method. // See https://core.telegram.org/bots/api#getmyshortdescription type GetMyShortDescription struct { @@ -129,6 +195,14 @@ func (api *API) GetMyShortDescription(params GetMyShortDescription) (BotShortDes return req.Do(api) } +// GetMyShortDescriptionWithContext is the context-aware variant of GetMyShortDescription. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getmyshortdescription +func (api *API) GetMyShortDescriptionWithContext(ctx context.Context, params GetMyShortDescription) (BotShortDescription, error) { + req := NewRequest[BotShortDescription]("getMyShortDescription", params) + return req.DoWithContext(ctx, api) +} + // SetMyProfilePhotoP holds parameters for the setMyProfilePhoto method. // See https://core.telegram.org/bots/api#setmyprofilephoto type SetMyProfilePhotoP struct { @@ -143,6 +217,14 @@ func (api *API) SetMyProfilePhoto(params SetMyProfilePhotoP) (bool, error) { return req.Do(api) } +// SetMyProfilePhotoWithContext is the context-aware variant of SetMyProfilePhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setmyprofilephoto +func (api *API) SetMyProfilePhotoWithContext(ctx context.Context, params SetMyProfilePhotoP) (bool, error) { + req := NewRequest[bool]("setMyProfilePhoto", params) + return req.DoWithContext(ctx, api) +} + // RemoveMyProfilePhoto removes the bot's profile photo. // Returns true on success. // See https://core.telegram.org/bots/api#removemyprofilephoto @@ -151,6 +233,14 @@ func (api *API) RemoveMyProfilePhoto() (bool, error) { return req.Do(api) } +// RemoveMyProfilePhotoWithContext is the context-aware variant of RemoveMyProfilePhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#removemyprofilephoto +func (api *API) RemoveMyProfilePhotoWithContext(ctx context.Context) (bool, error) { + req := NewRequest[bool]("removeMyProfilePhoto", NoParams) + return req.DoWithContext(ctx, api) +} + // SetChatMenuButtonP holds parameters for the setChatMenuButton method. // See https://core.telegram.org/bots/api#setchatmenubutton type SetChatMenuButtonP struct { @@ -166,6 +256,14 @@ func (api *API) SetChatMenuButton(params SetChatMenuButtonP) (bool, error) { return req.Do(api) } +// SetChatMenuButtonWithContext is the context-aware variant of SetChatMenuButton. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchatmenubutton +func (api *API) SetChatMenuButtonWithContext(ctx context.Context, params SetChatMenuButtonP) (bool, error) { + req := NewRequest[bool]("setChatMenuButton", params) + return req.DoWithContext(ctx, api) +} + // GetChatMenuButtonP holds parameters for the getChatMenuButton method. // See https://core.telegram.org/bots/api#getchatmenubutton type GetChatMenuButtonP struct { @@ -179,6 +277,14 @@ func (api *API) GetChatMenuButton(params GetChatMenuButtonP) (BaseMenuButton, er return req.Do(api) } +// GetChatMenuButtonWithContext is the context-aware variant of GetChatMenuButton. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getchatmenubutton +func (api *API) GetChatMenuButtonWithContext(ctx context.Context, params GetChatMenuButtonP) (BaseMenuButton, error) { + req := NewRequest[BaseMenuButton]("getChatMenuButton", params) + return req.DoWithContext(ctx, api) +} + // SetMyDefaultAdministratorRightsP holds parameters for the setMyDefaultAdministratorRights method. // See https://core.telegram.org/bots/api#setmydefaultadministratorrights type SetMyDefaultAdministratorRightsP struct { @@ -194,6 +300,14 @@ func (api *API) SetMyDefaultAdministratorRights(params SetMyDefaultAdministrator return req.Do(api) } +// SetMyDefaultAdministratorRightsWithContext is the context-aware variant of SetMyDefaultAdministratorRights. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setmydefaultadministratorrights +func (api *API) SetMyDefaultAdministratorRightsWithContext(ctx context.Context, params SetMyDefaultAdministratorRightsP) (bool, error) { + req := NewRequest[bool]("setMyDefaultAdministratorRights", params) + return req.DoWithContext(ctx, api) +} + // GetMyDefaultAdministratorRightsP holds parameters for the getMyDefaultAdministratorRights method. // See https://core.telegram.org/bots/api#getmydefaultadministratorrights type GetMyDefaultAdministratorRightsP struct { @@ -207,6 +321,14 @@ func (api *API) GetMyDefaultAdministratorRights(params GetMyDefaultAdministrator return req.Do(api) } +// GetMyDefaultAdministratorRightsWithContext is the context-aware variant of GetMyDefaultAdministratorRights. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getmydefaultadministratorrights +func (api *API) GetMyDefaultAdministratorRightsWithContext(ctx context.Context, params GetMyDefaultAdministratorRightsP) (ChatAdministratorRights, error) { + req := NewRequest[ChatAdministratorRights]("getMyDefaultAdministratorRights", params) + return req.DoWithContext(ctx, api) +} + // GetAvailableGifts returns the list of gifts that can be sent by the bot. // See https://core.telegram.org/bots/api#getavailablegifts func (api *API) GetAvailableGifts() (Gifts, error) { @@ -214,6 +336,14 @@ func (api *API) GetAvailableGifts() (Gifts, error) { return req.Do(api) } +// GetAvailableGiftsWithContext is the context-aware variant of GetAvailableGifts. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getavailablegifts +func (api *API) GetAvailableGiftsWithContext(ctx context.Context) (Gifts, error) { + req := NewRequest[Gifts]("getAvailableGifts", NoParams) + return req.DoWithContext(ctx, api) +} + // SendGiftP holds parameters for the sendGift method. // See https://core.telegram.org/bots/api#sendgift type SendGiftP struct { @@ -234,6 +364,14 @@ func (api *API) SendGift(params SendGiftP) (bool, error) { return req.Do(api) } +// SendGiftWithContext is the context-aware variant of SendGift. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendgift +func (api *API) SendGiftWithContext(ctx context.Context, params SendGiftP) (bool, error) { + req := NewRequest[bool]("sendGift", params) + return req.DoWithContext(ctx, api) +} + // GiftPremiumSubscriptionP holds parameters for the giftPremiumSubscription method. // See https://core.telegram.org/bots/api#giftpremiumsubscription type GiftPremiumSubscriptionP struct { @@ -252,3 +390,11 @@ func (api *API) GiftPremiumSubscription(params GiftPremiumSubscriptionP) (bool, req := NewRequest[bool]("giftPremiumSubscription", params) return req.Do(api) } + +// GiftPremiumSubscriptionWithContext is the context-aware variant of GiftPremiumSubscription. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#giftpremiumsubscription +func (api *API) GiftPremiumSubscriptionWithContext(ctx context.Context, params GiftPremiumSubscriptionP) (bool, error) { + req := NewRequest[bool]("giftPremiumSubscription", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/business_methods.go b/tgapi/business_methods.go index 476275c..e86a4c7 100644 --- a/tgapi/business_methods.go +++ b/tgapi/business_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // VerifyUserP holds parameters for the verifyUser method. // See https://core.telegram.org/bots/api#verifyuser type VerifyUserP struct { @@ -15,6 +17,14 @@ func (api *API) VerifyUser(params VerifyUserP) (bool, error) { return req.Do(api) } +// VerifyUserWithContext is the context-aware variant of VerifyUser. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#verifyuser +func (api *API) VerifyUserWithContext(ctx context.Context, params VerifyUserP) (bool, error) { + req := NewRequest[bool]("verifyUser", params) + return req.DoWithContext(ctx, api) +} + // VerifyChatP holds parameters for the verifyChat method. // See https://core.telegram.org/bots/api#verifychat type VerifyChatP struct { @@ -30,6 +40,14 @@ func (api *API) VerifyChat(params VerifyChatP) (bool, error) { return req.Do(api) } +// VerifyChatWithContext is the context-aware variant of VerifyChat. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#verifychat +func (api *API) VerifyChatWithContext(ctx context.Context, params VerifyChatP) (bool, error) { + req := NewRequest[bool]("verifyChat", params) + return req.DoWithContext(ctx, api) +} + // RemoveUserVerificationP holds parameters for the removeUserVerification method. // See https://core.telegram.org/bots/api#removeuserverification type RemoveUserVerificationP struct { @@ -44,6 +62,14 @@ func (api *API) RemoveUserVerification(params RemoveUserVerificationP) (bool, er return req.Do(api) } +// RemoveUserVerificationWithContext is the context-aware variant of RemoveUserVerification. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#removeuserverification +func (api *API) RemoveUserVerificationWithContext(ctx context.Context, params RemoveUserVerificationP) (bool, error) { + req := NewRequest[bool]("removeUserVerification", params) + return req.DoWithContext(ctx, api) +} + // RemoveChatVerificationP holds parameters for the removeChatVerification method. // See https://core.telegram.org/bots/api#removechatverification type RemoveChatVerificationP struct { @@ -58,6 +84,14 @@ func (api *API) RemoveChatVerification(params RemoveChatVerificationP) (bool, er return req.Do(api) } +// RemoveChatVerificationWithContext is the context-aware variant of RemoveChatVerification. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#removechatverification +func (api *API) RemoveChatVerificationWithContext(ctx context.Context, params RemoveChatVerificationP) (bool, error) { + req := NewRequest[bool]("removeChatVerification", params) + return req.DoWithContext(ctx, api) +} + // ReadBusinessMessageP holds parameters for the readBusinessMessage method. // See https://core.telegram.org/bots/api#readbusinessmessage type ReadBusinessMessageP struct { @@ -74,6 +108,14 @@ func (api *API) ReadBusinessMessage(params ReadBusinessMessageP) (bool, error) { return req.Do(api) } +// ReadBusinessMessageWithContext is the context-aware variant of ReadBusinessMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#readbusinessmessage +func (api *API) ReadBusinessMessageWithContext(ctx context.Context, params ReadBusinessMessageP) (bool, error) { + req := NewRequest[bool]("readBusinessMessage", params) + return req.DoWithContext(ctx, api) +} + // GetBusinessConnectionP holds parameters for the getBusinessConnection method. // See https://core.telegram.org/bots/api#getbusinessconnection type GetBusinessConnectionP struct { @@ -87,6 +129,14 @@ func (api *API) GetBusinessConnection(params GetBusinessConnectionP) (BusinessCo return req.Do(api) } +// GetBusinessConnectionWithContext is the context-aware variant of GetBusinessConnection. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getbusinessconnection +func (api *API) GetBusinessConnectionWithContext(ctx context.Context, params GetBusinessConnectionP) (BusinessConnection, error) { + req := NewRequest[BusinessConnection]("getBusinessConnection", params) + return req.DoWithContext(ctx, api) +} + // DeleteBusinessMessagesP holds parameters for the deleteBusinessMessages method. // See https://core.telegram.org/bots/api#deletebusinessmessages type DeleteBusinessMessagesP struct { @@ -102,6 +152,14 @@ func (api *API) DeleteBusinessMessages(params DeleteBusinessMessagesP) (bool, er return req.Do(api) } +// DeleteBusinessMessagesWithContext is the context-aware variant of DeleteBusinessMessages. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletebusinessmessages +func (api *API) DeleteBusinessMessagesWithContext(ctx context.Context, params DeleteBusinessMessagesP) (bool, error) { + req := NewRequest[bool]("deleteBusinessMessages", params) + return req.DoWithContext(ctx, api) +} + // SetBusinessAccountNameP holds parameters for the setBusinessAccountName method. // See https://core.telegram.org/bots/api#setbusinessaccountname type SetBusinessAccountNameP struct { @@ -118,6 +176,14 @@ func (api *API) SetBusinessAccountName(params SetBusinessAccountNameP) (bool, er return req.Do(api) } +// SetBusinessAccountNameWithContext is the context-aware variant of SetBusinessAccountName. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setbusinessaccountname +func (api *API) SetBusinessAccountNameWithContext(ctx context.Context, params SetBusinessAccountNameP) (bool, error) { + req := NewRequest[bool]("setBusinessAccountName", params) + return req.DoWithContext(ctx, api) +} + // SetBusinessAccountUsernameP holds parameters for the setBusinessAccountUsername method. // See https://core.telegram.org/bots/api#setbusinessaccountusername type SetBusinessAccountUsernameP struct { @@ -133,6 +199,14 @@ func (api *API) SetBusinessAccountUsername(params SetBusinessAccountUsernameP) ( return req.Do(api) } +// SetBusinessAccountUsernameWithContext is the context-aware variant of SetBusinessAccountUsername. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setbusinessaccountusername +func (api *API) SetBusinessAccountUsernameWithContext(ctx context.Context, params SetBusinessAccountUsernameP) (bool, error) { + req := NewRequest[bool]("setBusinessAccountUsername", params) + return req.DoWithContext(ctx, api) +} + // SetBusinessAccountBioP holds parameters for the setBusinessAccountBio method. // See https://core.telegram.org/bots/api#setbusinessaccountbio type SetBusinessAccountBioP struct { @@ -148,6 +222,14 @@ func (api *API) SetBusinessAccountBio(params SetBusinessAccountBioP) (bool, erro return req.Do(api) } +// SetBusinessAccountBioWithContext is the context-aware variant of SetBusinessAccountBio. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setbusinessaccountbio +func (api *API) SetBusinessAccountBioWithContext(ctx context.Context, params SetBusinessAccountBioP) (bool, error) { + req := NewRequest[bool]("setBusinessAccountBio", params) + return req.DoWithContext(ctx, api) +} + // SetBusinessAccountProfilePhoto holds parameters for the setBusinessAccountProfilePhoto method. // See https://core.telegram.org/bots/api#setbusinessaccountprofilephoto type SetBusinessAccountProfilePhoto struct { @@ -164,6 +246,14 @@ func (api *API) SetBusinessAccountProfilePhoto(params SetBusinessAccountProfileP return req.Do(api) } +// SetBusinessAccountProfilePhotoWithContext is the context-aware variant of SetBusinessAccountProfilePhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setbusinessaccountprofilephoto +func (api *API) SetBusinessAccountProfilePhotoWithContext(ctx context.Context, params SetBusinessAccountProfilePhoto) (bool, error) { + req := NewRequest[bool]("setBusinessAccountProfilePhoto", params) + return req.DoWithContext(ctx, api) +} + // RemoveBusinessAccountProfilePhotoP holds parameters for the removeBusinessAccountProfilePhoto method. // See https://core.telegram.org/bots/api#removebusinessaccountprofilephoto type RemoveBusinessAccountProfilePhotoP struct { @@ -179,6 +269,14 @@ func (api *API) RemoveBusinessAccountProfilePhoto(params RemoveBusinessAccountPr return req.Do(api) } +// RemoveBusinessAccountProfilePhotoWithContext is the context-aware variant of RemoveBusinessAccountProfilePhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#removebusinessaccountprofilephoto +func (api *API) RemoveBusinessAccountProfilePhotoWithContext(ctx context.Context, params RemoveBusinessAccountProfilePhotoP) (bool, error) { + req := NewRequest[bool]("removeBusinessAccountProfilePhoto", params) + return req.DoWithContext(ctx, api) +} + // SetBusinessAccountGiftSettingsP holds parameters for the setBusinessAccountGiftSettings method. // See https://core.telegram.org/bots/api#setbusinessaccountgiftsettings type SetBusinessAccountGiftSettingsP struct { @@ -195,6 +293,14 @@ func (api *API) SetBusinessAccountGiftSettings(params SetBusinessAccountGiftSett return req.Do(api) } +// SetBusinessAccountGiftSettingsWithContext is the context-aware variant of SetBusinessAccountGiftSettings. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setbusinessaccountgiftsettings +func (api *API) SetBusinessAccountGiftSettingsWithContext(ctx context.Context, params SetBusinessAccountGiftSettingsP) (bool, error) { + req := NewRequest[bool]("setBusinessAccountGiftSettings", params) + return req.DoWithContext(ctx, api) +} + // GetBusinessAccountStarBalanceP holds parameters for the getBusinessAccountStarBalance method. // See https://core.telegram.org/bots/api#getbusinessaccountstarbalance type GetBusinessAccountStarBalanceP struct { @@ -208,6 +314,14 @@ func (api *API) GetBusinessAccountStarBalance(params GetBusinessAccountStarBalan return req.Do(api) } +// GetBusinessAccountStarBalanceWithContext is the context-aware variant of GetBusinessAccountStarBalance. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getbusinessaccountstarbalance +func (api *API) GetBusinessAccountStarBalanceWithContext(ctx context.Context, params GetBusinessAccountStarBalanceP) (StarAmount, error) { + req := NewRequest[StarAmount]("getBusinessAccountStarBalance", params) + return req.DoWithContext(ctx, api) +} + // TransferBusinessAccountStarsP holds parameters for the transferBusinessAccountStars method. // See https://core.telegram.org/bots/api#transferbusinessaccountstars type TransferBusinessAccountStarsP struct { @@ -223,6 +337,14 @@ func (api *API) TransferBusinessAccountStars(params TransferBusinessAccountStars return req.Do(api) } +// TransferBusinessAccountStarsWithContext is the context-aware variant of TransferBusinessAccountStars. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#transferbusinessaccountstars +func (api *API) TransferBusinessAccountStarsWithContext(ctx context.Context, params TransferBusinessAccountStarsP) (bool, error) { + req := NewRequest[bool]("transferBusinessAccountStars", params) + return req.DoWithContext(ctx, api) +} + // GetBusinessAccountGiftsP holds parameters for the getBusinessAccountGifts method. // See https://core.telegram.org/bots/api#getbusinessaccountgifts type GetBusinessAccountGiftsP struct { @@ -246,6 +368,14 @@ func (api *API) GetBusinessAccountGifts(params GetBusinessAccountGiftsP) (OwnedG return req.Do(api) } +// GetBusinessAccountGiftsWithContext is the context-aware variant of GetBusinessAccountGifts. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getbusinessaccountgifts +func (api *API) GetBusinessAccountGiftsWithContext(ctx context.Context, params GetBusinessAccountGiftsP) (OwnedGifts, error) { + req := NewRequest[OwnedGifts]("getBusinessAccountGifts", params) + return req.DoWithContext(ctx, api) +} + // ConvertGiftToStarsP holds parameters for the convertGiftToStars method. // See https://core.telegram.org/bots/api#convertgifttostars type ConvertGiftToStarsP struct { @@ -261,6 +391,14 @@ func (api *API) ConvertGiftToStars(params ConvertGiftToStarsP) (bool, error) { return req.Do(api) } +// ConvertGiftToStarsWithContext is the context-aware variant of ConvertGiftToStars. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#convertgifttostars +func (api *API) ConvertGiftToStarsWithContext(ctx context.Context, params ConvertGiftToStarsP) (bool, error) { + req := NewRequest[bool]("convertGiftToStars", params) + return req.DoWithContext(ctx, api) +} + // UpgradeGiftP holds parameters for the upgradeGift method. // See https://core.telegram.org/bots/api#upgradegift type UpgradeGiftP struct { @@ -278,6 +416,14 @@ func (api *API) UpgradeGift(params UpgradeGiftP) (bool, error) { return req.Do(api) } +// UpgradeGiftWithContext is the context-aware variant of UpgradeGift. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#upgradegift +func (api *API) UpgradeGiftWithContext(ctx context.Context, params UpgradeGiftP) (bool, error) { + req := NewRequest[bool]("upgradeGift", params) + return req.DoWithContext(ctx, api) +} + // TransferGiftP holds parameters for the transferGift method. // See https://core.telegram.org/bots/api#transfergift type TransferGiftP struct { @@ -295,6 +441,14 @@ func (api *API) TransferGift(params TransferGiftP) (bool, error) { return req.Do(api) } +// TransferGiftWithContext is the context-aware variant of TransferGift. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#transfergift +func (api *API) TransferGiftWithContext(ctx context.Context, params TransferGiftP) (bool, error) { + req := NewRequest[bool]("transferGift", params) + return req.DoWithContext(ctx, api) +} + // PostStoryP holds parameters for the postStory method. // See https://core.telegram.org/bots/api#poststory type PostStoryP struct { @@ -318,6 +472,14 @@ func (api *API) PostStoryPhoto(params PostStoryP) (Story, error) { return req.Do(api) } +// PostStoryPhotoWithContext is the context-aware variant of PostStoryPhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#poststory +func (api *API) PostStoryPhotoWithContext(ctx context.Context, params PostStoryP) (Story, error) { + req := NewRequest[Story]("postStory", params) + return req.DoWithContext(ctx, api) +} + // PostStoryVideo posts a story with a video. // See https://core.telegram.org/bots/api#poststory func (api *API) PostStoryVideo(params PostStoryP) (Story, error) { @@ -325,6 +487,14 @@ func (api *API) PostStoryVideo(params PostStoryP) (Story, error) { return req.Do(api) } +// PostStoryVideoWithContext is the context-aware variant of PostStoryVideo. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#poststory +func (api *API) PostStoryVideoWithContext(ctx context.Context, params PostStoryP) (Story, error) { + req := NewRequest[Story]("postStory", params) + return req.DoWithContext(ctx, api) +} + // RepostStoryP holds parameters for the repostStory method. // See https://core.telegram.org/bots/api#repoststory type RepostStoryP struct { @@ -344,6 +514,14 @@ func (api *API) RepostStory(params RepostStoryP) (Story, error) { return req.Do(api) } +// RepostStoryWithContext is the context-aware variant of RepostStory. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#repoststory +func (api *API) RepostStoryWithContext(ctx context.Context, params RepostStoryP) (Story, error) { + req := NewRequest[Story]("repostStory", params) + return req.DoWithContext(ctx, api) +} + // EditStoryP holds parameters for the editStory method. // See https://core.telegram.org/bots/api#editstory type EditStoryP struct { @@ -365,6 +543,14 @@ func (api *API) EditStory(params EditStoryP) (Story, error) { return req.Do(api) } +// EditStoryWithContext is the context-aware variant of EditStory. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editstory +func (api *API) EditStoryWithContext(ctx context.Context, params EditStoryP) (Story, error) { + req := NewRequest[Story]("editStory", params) + return req.DoWithContext(ctx, api) +} + // DeleteStoryP holds parameters for the deleteStory method. // See https://core.telegram.org/bots/api#deletestory type DeleteStoryP struct { @@ -379,3 +565,11 @@ func (api *API) DeleteStory(params DeleteStoryP) (bool, error) { req := NewRequest[bool]("deleteStory", params) return req.Do(api) } + +// DeleteStoryWithContext is the context-aware variant of DeleteStory. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletestory +func (api *API) DeleteStoryWithContext(ctx context.Context, params DeleteStoryP) (bool, error) { + req := NewRequest[bool]("deleteStory", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/chat_methods.go b/tgapi/chat_methods.go index eb6ac4e..9799984 100644 --- a/tgapi/chat_methods.go +++ b/tgapi/chat_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // BanChatMemberP holds parameters for the banChatMember method. // See https://core.telegram.org/bots/api#banchatmember type BanChatMemberP struct { @@ -17,6 +19,14 @@ func (api *API) BanChatMember(params BanChatMemberP) (bool, error) { return req.Do(api) } +// BanChatMemberWithContext is the context-aware variant of BanChatMember. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#banchatmember +func (api *API) BanChatMemberWithContext(ctx context.Context, params BanChatMemberP) (bool, error) { + req := NewRequestWithChatID[bool]("banChatMember", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // UnbanChatMemberP holds parameters for the unbanChatMember method. // See https://core.telegram.org/bots/api#unbanchatmember type UnbanChatMemberP struct { @@ -33,6 +43,14 @@ func (api *API) UnbanChatMember(params UnbanChatMemberP) (bool, error) { return req.Do(api) } +// UnbanChatMemberWithContext is the context-aware variant of UnbanChatMember. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#unbanchatmember +func (api *API) UnbanChatMemberWithContext(ctx context.Context, params UnbanChatMemberP) (bool, error) { + req := NewRequestWithChatID[bool]("unbanChatMember", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // RestrictChatMemberP holds parameters for the restrictChatMember method. // See https://core.telegram.org/bots/api#restrictchatmember type RestrictChatMemberP struct { @@ -51,6 +69,14 @@ func (api *API) RestrictChatMember(params RestrictChatMemberP) (bool, error) { return req.Do(api) } +// RestrictChatMemberWithContext is the context-aware variant of RestrictChatMember. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#restrictchatmember +func (api *API) RestrictChatMemberWithContext(ctx context.Context, params RestrictChatMemberP) (bool, error) { + req := NewRequestWithChatID[bool]("restrictChatMember", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // PromoteChatMember holds parameters for the promoteChatMember method. // See https://core.telegram.org/bots/api#promotechatmember type PromoteChatMember struct { @@ -84,6 +110,14 @@ func (api *API) PromoteChatMember(params PromoteChatMember) (bool, error) { return req.Do(api) } +// PromoteChatMemberWithContext is the context-aware variant of PromoteChatMember. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#promotechatmember +func (api *API) PromoteChatMemberWithContext(ctx context.Context, params PromoteChatMember) (bool, error) { + req := NewRequestWithChatID[bool]("promoteChatMember", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetChatAdministratorCustomTitleP holds parameters for the setChatAdministratorCustomTitle method. // See https://core.telegram.org/bots/api#setchatadministratorcustomtitle type SetChatAdministratorCustomTitleP struct { @@ -100,6 +134,14 @@ func (api *API) SetChatAdministratorCustomTitle(params SetChatAdministratorCusto return req.Do(api) } +// SetChatAdministratorCustomTitleWithContext is the context-aware variant of SetChatAdministratorCustomTitle. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchatadministratorcustomtitle +func (api *API) SetChatAdministratorCustomTitleWithContext(ctx context.Context, params SetChatAdministratorCustomTitleP) (bool, error) { + req := NewRequestWithChatID[bool]("setChatAdministratorCustomTitle", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetChatMemberTagP holds parameters for the setChatMemberTag method. // See https://core.telegram.org/bots/api#setchatmembertag type SetChatMemberTagP struct { @@ -116,6 +158,14 @@ func (api *API) SetChatMemberTag(params SetChatMemberTagP) (bool, error) { return req.Do(api) } +// SetChatMemberTagWithContext is the context-aware variant of SetChatMemberTag. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchatmembertag +func (api *API) SetChatMemberTagWithContext(ctx context.Context, params SetChatMemberTagP) (bool, error) { + req := NewRequestWithChatID[bool]("setChatMemberTag", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // BanChatSenderChatP holds parameters for the banChatSenderChat method. // See https://core.telegram.org/bots/api#banchatsenderchat type BanChatSenderChatP struct { @@ -131,6 +181,14 @@ func (api *API) BanChatSenderChat(params BanChatSenderChatP) (bool, error) { return req.Do(api) } +// BanChatSenderChatWithContext is the context-aware variant of BanChatSenderChat. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#banchatsenderchat +func (api *API) BanChatSenderChatWithContext(ctx context.Context, params BanChatSenderChatP) (bool, error) { + req := NewRequestWithChatID[bool]("banChatSenderChat", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // UnbanChatSenderChatP holds parameters for the unbanChatSenderChat method. // See https://core.telegram.org/bots/api#unbanchatsenderchat type UnbanChatSenderChatP struct { @@ -146,6 +204,14 @@ func (api *API) UnbanChatSenderChat(params UnbanChatSenderChatP) (bool, error) { return req.Do(api) } +// UnbanChatSenderChatWithContext is the context-aware variant of UnbanChatSenderChat. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#unbanchatsenderchat +func (api *API) UnbanChatSenderChatWithContext(ctx context.Context, params UnbanChatSenderChatP) (bool, error) { + req := NewRequestWithChatID[bool]("unbanChatSenderChat", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetChatPermissionsP holds parameters for the setChatPermissions method. // See https://core.telegram.org/bots/api#setchatpermissions type SetChatPermissionsP struct { @@ -162,6 +228,14 @@ func (api *API) SetChatPermissions(params SetChatPermissionsP) (bool, error) { return req.Do(api) } +// SetChatPermissionsWithContext is the context-aware variant of SetChatPermissions. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchatpermissions +func (api *API) SetChatPermissionsWithContext(ctx context.Context, params SetChatPermissionsP) (bool, error) { + req := NewRequestWithChatID[bool]("setChatPermissions", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // ExportChatInviteLinkP holds parameters for the exportChatInviteLink method. // See https://core.telegram.org/bots/api#exportchatinvitelink type ExportChatInviteLinkP struct { @@ -176,6 +250,14 @@ func (api *API) ExportChatInviteLink(params ExportChatInviteLinkP) (string, erro return req.Do(api) } +// ExportChatInviteLinkWithContext is the context-aware variant of ExportChatInviteLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#exportchatinvitelink +func (api *API) ExportChatInviteLinkWithContext(ctx context.Context, params ExportChatInviteLinkP) (string, error) { + req := NewRequestWithChatID[string]("exportChatInviteLink", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // CreateChatInviteLinkP holds parameters for the createChatInviteLink method. // See https://core.telegram.org/bots/api#createchatinvitelink type CreateChatInviteLinkP struct { @@ -194,6 +276,14 @@ func (api *API) CreateChatInviteLink(params CreateChatInviteLinkP) (ChatInviteLi return req.Do(api) } +// CreateChatInviteLinkWithContext is the context-aware variant of CreateChatInviteLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#createchatinvitelink +func (api *API) CreateChatInviteLinkWithContext(ctx context.Context, params CreateChatInviteLinkP) (ChatInviteLink, error) { + req := NewRequestWithChatID[ChatInviteLink]("createChatInviteLink", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // EditChatInviteLinkP holds parameters for the editChatInviteLink method. // See https://core.telegram.org/bots/api#editchatinvitelink type EditChatInviteLinkP struct { @@ -214,6 +304,14 @@ func (api *API) EditChatInviteLink(params EditChatInviteLinkP) (ChatInviteLink, return req.Do(api) } +// EditChatInviteLinkWithContext is the context-aware variant of EditChatInviteLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editchatinvitelink +func (api *API) EditChatInviteLinkWithContext(ctx context.Context, params EditChatInviteLinkP) (ChatInviteLink, error) { + req := NewRequestWithChatID[ChatInviteLink]("editChatInviteLink", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // CreateChatSubscriptionInviteLinkP holds parameters for the createChatSubscriptionInviteLink method. // See https://core.telegram.org/bots/api#createchatsubscriptioninvitelink type CreateChatSubscriptionInviteLinkP struct { @@ -231,6 +329,14 @@ func (api *API) CreateChatSubscriptionInviteLink(params CreateChatSubscriptionIn return req.Do(api) } +// CreateChatSubscriptionInviteLinkWithContext is the context-aware variant of CreateChatSubscriptionInviteLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#createchatsubscriptioninvitelink +func (api *API) CreateChatSubscriptionInviteLinkWithContext(ctx context.Context, params CreateChatSubscriptionInviteLinkP) (ChatInviteLink, error) { + req := NewRequestWithChatID[ChatInviteLink]("createChatSubscriptionInviteLink", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // EditChatSubscriptionInviteLinkP holds parameters for the editChatSubscriptionInviteLink method. // See https://core.telegram.org/bots/api#editchatsubscriptioninvitelink type EditChatSubscriptionInviteLinkP struct { @@ -247,6 +353,14 @@ func (api *API) EditChatSubscriptionInviteLink(params EditChatSubscriptionInvite return req.Do(api) } +// EditChatSubscriptionInviteLinkWithContext is the context-aware variant of EditChatSubscriptionInviteLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editchatsubscriptioninvitelink +func (api *API) EditChatSubscriptionInviteLinkWithContext(ctx context.Context, params EditChatSubscriptionInviteLinkP) (ChatInviteLink, error) { + req := NewRequestWithChatID[ChatInviteLink]("editChatSubscriptionInviteLink", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // RevokeChatInviteLinkP holds parameters for the revokeChatInviteLink method. // See https://core.telegram.org/bots/api#revokechatinvitelink type RevokeChatInviteLinkP struct { @@ -262,6 +376,14 @@ func (api *API) RevokeChatInviteLink(params RevokeChatInviteLinkP) (ChatInviteLi return req.Do(api) } +// RevokeChatInviteLinkWithContext is the context-aware variant of RevokeChatInviteLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#revokechatinvitelink +func (api *API) RevokeChatInviteLinkWithContext(ctx context.Context, params RevokeChatInviteLinkP) (ChatInviteLink, error) { + req := NewRequestWithChatID[ChatInviteLink]("revokeChatInviteLink", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // ApproveChatJoinRequestP holds parameters for the approveChatJoinRequest method. // See https://core.telegram.org/bots/api#approvechatjoinrequest type ApproveChatJoinRequestP struct { @@ -277,6 +399,14 @@ func (api *API) ApproveChatJoinRequest(params ApproveChatJoinRequestP) (bool, er return req.Do(api) } +// ApproveChatJoinRequestWithContext is the context-aware variant of ApproveChatJoinRequest. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#approvechatjoinrequest +func (api *API) ApproveChatJoinRequestWithContext(ctx context.Context, params ApproveChatJoinRequestP) (bool, error) { + req := NewRequestWithChatID[bool]("approveChatJoinRequest", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // DeclineChatJoinRequestP holds parameters for the declineChatJoinRequest method. // See https://core.telegram.org/bots/api#declinechatjoinrequest type DeclineChatJoinRequestP struct { @@ -292,6 +422,14 @@ func (api *API) DeclineChatJoinRequest(params DeclineChatJoinRequestP) (bool, er return req.Do(api) } +// DeclineChatJoinRequestWithContext is the context-aware variant of DeclineChatJoinRequest. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#declinechatjoinrequest +func (api *API) DeclineChatJoinRequestWithContext(ctx context.Context, params DeclineChatJoinRequestP) (bool, error) { + req := NewRequestWithChatID[bool]("declineChatJoinRequest", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetChatPhotoP holds parameters for the setChatPhoto method. // See https://core.telegram.org/bots/api#setchatphoto type SetChatPhotoP struct { @@ -325,6 +463,14 @@ func (api *API) DeleteChatPhoto(params DeleteChatPhotoP) (bool, error) { return req.Do(api) } +// DeleteChatPhotoWithContext is the context-aware variant of DeleteChatPhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletechatphoto +func (api *API) DeleteChatPhotoWithContext(ctx context.Context, params DeleteChatPhotoP) (bool, error) { + req := NewRequestWithChatID[bool]("deleteChatPhoto", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetChatTitleP holds parameters for the setChatTitle method. // See https://core.telegram.org/bots/api#setchattitle type SetChatTitleP struct { @@ -340,6 +486,14 @@ func (api *API) SetChatTitle(params SetChatTitleP) (bool, error) { return req.Do(api) } +// SetChatTitleWithContext is the context-aware variant of SetChatTitle. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchattitle +func (api *API) SetChatTitleWithContext(ctx context.Context, params SetChatTitleP) (bool, error) { + req := NewRequestWithChatID[bool]("setChatTitle", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetChatDescriptionP holds parameters for the setChatDescription method. // See https://core.telegram.org/bots/api#setchatdescription type SetChatDescriptionP struct { @@ -355,6 +509,14 @@ func (api *API) SetChatDescription(params SetChatDescriptionP) (bool, error) { return req.Do(api) } +// SetChatDescriptionWithContext is the context-aware variant of SetChatDescription. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchatdescription +func (api *API) SetChatDescriptionWithContext(ctx context.Context, params SetChatDescriptionP) (bool, error) { + req := NewRequestWithChatID[bool]("setChatDescription", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // PinChatMessageP holds parameters for the pinChatMessage method. // See https://core.telegram.org/bots/api#pinchatmessage type PinChatMessageP struct { @@ -372,6 +534,14 @@ func (api *API) PinChatMessage(params PinChatMessageP) (bool, error) { return req.Do(api) } +// PinChatMessageWithContext is the context-aware variant of PinChatMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#pinchatmessage +func (api *API) PinChatMessageWithContext(ctx context.Context, params PinChatMessageP) (bool, error) { + req := NewRequestWithChatID[bool]("pinChatMessage", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // UnpinChatMessageP holds parameters for the unpinChatMessage method. // See https://core.telegram.org/bots/api#unpinchatmessage type UnpinChatMessageP struct { @@ -388,6 +558,14 @@ func (api *API) UnpinChatMessage(params UnpinChatMessageP) (bool, error) { return req.Do(api) } +// UnpinChatMessageWithContext is the context-aware variant of UnpinChatMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#unpinchatmessage +func (api *API) UnpinChatMessageWithContext(ctx context.Context, params UnpinChatMessageP) (bool, error) { + req := NewRequestWithChatID[bool]("unpinChatMessage", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // UnpinAllChatMessagesP holds parameters for the unpinAllChatMessages method. // See https://core.telegram.org/bots/api#unpinallchatmessages type UnpinAllChatMessagesP struct { @@ -402,6 +580,14 @@ func (api *API) UnpinAllChatMessages(params UnpinAllChatMessagesP) (bool, error) return req.Do(api) } +// UnpinAllChatMessagesWithContext is the context-aware variant of UnpinAllChatMessages. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#unpinallchatmessages +func (api *API) UnpinAllChatMessagesWithContext(ctx context.Context, params UnpinAllChatMessagesP) (bool, error) { + req := NewRequestWithChatID[bool]("unpinAllChatMessages", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // LeaveChatP holds parameters for the leaveChat method. // See https://core.telegram.org/bots/api#leavechat type LeaveChatP struct { @@ -416,6 +602,14 @@ func (api *API) LeaveChat(params LeaveChatP) (bool, error) { return req.Do(api) } +// LeaveChatWithContext is the context-aware variant of LeaveChat. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#leavechat +func (api *API) LeaveChatWithContext(ctx context.Context, params LeaveChatP) (bool, error) { + req := NewRequestWithChatID[bool]("leaveChat", params, params.ChatID) // fixed method name + return req.DoWithContext(ctx, api) +} + // GetChatP holds parameters for the getChat method. // See https://core.telegram.org/bots/api#getchat type GetChatP struct { @@ -429,6 +623,14 @@ func (api *API) GetChat(params GetChatP) (ChatFullInfo, error) { return req.Do(api) } +// GetChatWithContext is the context-aware variant of GetChat. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getchat +func (api *API) GetChatWithContext(ctx context.Context, params GetChatP) (ChatFullInfo, error) { + req := NewRequestWithChatID[ChatFullInfo]("getChat", params, params.ChatID) // fixed method name + return req.DoWithContext(ctx, api) +} + // GetChatAdministratorsP holds parameters for the getChatAdministrators method. // See https://core.telegram.org/bots/api#getchatadministrators type GetChatAdministratorsP struct { @@ -442,6 +644,14 @@ func (api *API) GetChatAdministrators(params GetChatAdministratorsP) ([]ChatMemb return req.Do(api) } +// GetChatAdministratorsWithContext is the context-aware variant of GetChatAdministrators. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getchatadministrators +func (api *API) GetChatAdministratorsWithContext(ctx context.Context, params GetChatAdministratorsP) ([]ChatMember, error) { + req := NewRequestWithChatID[[]ChatMember]("getChatAdministrators", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // GetChatMembersCountP holds parameters for the getChatMemberCount method. // See https://core.telegram.org/bots/api#getchatmembercount type GetChatMembersCountP struct { @@ -455,6 +665,14 @@ func (api *API) GetChatMemberCount(params GetChatMembersCountP) (int, error) { return req.Do(api) } +// GetChatMemberCountWithContext is the context-aware variant of GetChatMemberCount. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getchatmembercount +func (api *API) GetChatMemberCountWithContext(ctx context.Context, params GetChatMembersCountP) (int, error) { + req := NewRequestWithChatID[int]("getChatMemberCount", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // GetChatMemberP holds parameters for the getChatMember method. // See https://core.telegram.org/bots/api#getchatmember type GetChatMemberP struct { @@ -469,6 +687,14 @@ func (api *API) GetChatMember(params GetChatMemberP) (ChatMember, error) { return req.Do(api) } +// GetChatMemberWithContext is the context-aware variant of GetChatMember. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getchatmember +func (api *API) GetChatMemberWithContext(ctx context.Context, params GetChatMemberP) (ChatMember, error) { + req := NewRequestWithChatID[ChatMember]("getChatMember", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetChatStickerSetP holds parameters for the setChatStickerSet method. // See https://core.telegram.org/bots/api#setchatstickerset type SetChatStickerSetP struct { @@ -484,6 +710,14 @@ func (api *API) SetChatStickerSet(params SetChatStickerSetP) (bool, error) { return req.Do(api) } +// SetChatStickerSetWithContext is the context-aware variant of SetChatStickerSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchatstickerset +func (api *API) SetChatStickerSetWithContext(ctx context.Context, params SetChatStickerSetP) (bool, error) { + req := NewRequestWithChatID[bool]("setChatStickerSet", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // DeleteChatStickerSetP holds parameters for the deleteChatStickerSet method. // See https://core.telegram.org/bots/api#deletechatstickerset type DeleteChatStickerSetP struct { @@ -498,6 +732,14 @@ func (api *API) DeleteChatStickerSet(params DeleteChatStickerSetP) (bool, error) return req.Do(api) } +// DeleteChatStickerSetWithContext is the context-aware variant of DeleteChatStickerSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletechatstickerset +func (api *API) DeleteChatStickerSetWithContext(ctx context.Context, params DeleteChatStickerSetP) (bool, error) { + req := NewRequestWithChatID[bool]("deleteChatStickerSet", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // GetUserChatBoostsP holds parameters for the getUserChatBoosts method. // See https://core.telegram.org/bots/api#getuserchatboosts type GetUserChatBoostsP struct { @@ -512,6 +754,14 @@ func (api *API) GetUserChatBoosts(params GetUserChatBoostsP) (UserChatBoosts, er return req.Do(api) } +// GetUserChatBoostsWithContext is the context-aware variant of GetUserChatBoosts. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getuserchatboosts +func (api *API) GetUserChatBoostsWithContext(ctx context.Context, params GetUserChatBoostsP) (UserChatBoosts, error) { + req := NewRequestWithChatID[UserChatBoosts]("getUserChatBoosts", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // GetChatGiftsP holds parameters for the getChatGifts method. // See https://core.telegram.org/bots/api#getchatgifts type GetChatGiftsP struct { @@ -534,3 +784,11 @@ func (api *API) GetChatGifts(params GetChatGiftsP) (OwnedGifts, error) { req := NewRequestWithChatID[OwnedGifts]("getChatGifts", params, params.ChatID) return req.Do(api) } + +// GetChatGiftsWithContext is the context-aware variant of GetChatGifts. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getchatgifts +func (api *API) GetChatGiftsWithContext(ctx context.Context, params GetChatGiftsP) (OwnedGifts, error) { + req := NewRequestWithChatID[OwnedGifts]("getChatGifts", params, params.ChatID) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/forum_methods.go b/tgapi/forum_methods.go index e7fa6d9..bbd8c44 100644 --- a/tgapi/forum_methods.go +++ b/tgapi/forum_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // BaseForumTopicP contains common fields for forum topic operations that require a chat ID and a message thread ID. type BaseForumTopicP struct { ChatID int64 `json:"chat_id"` @@ -13,6 +15,14 @@ func (api *API) GetForumTopicIconStickers() ([]Sticker, error) { return req.Do(api) } +// GetForumTopicIconStickersWithContext is the context-aware variant of GetForumTopicIconStickers. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getforumtopiciconstickers +func (api *API) GetForumTopicIconStickersWithContext(ctx context.Context) ([]Sticker, error) { + req := NewRequest[[]Sticker]("getForumTopicIconStickers", NoParams) + return req.DoWithContext(ctx, api) +} + // CreateForumTopicP holds parameters for the createForumTopic method. // See https://core.telegram.org/bots/api#createforumtopic type CreateForumTopicP struct { @@ -30,6 +40,14 @@ func (api *API) CreateForumTopic(params CreateForumTopicP) (ForumTopic, error) { return req.Do(api) } +// CreateForumTopicWithContext is the context-aware variant of CreateForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#createforumtopic +func (api *API) CreateForumTopicWithContext(ctx context.Context, params CreateForumTopicP) (ForumTopic, error) { + req := NewRequestWithChatID[ForumTopic]("createForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // EditForumTopicP holds parameters for the editForumTopic method. // See https://core.telegram.org/bots/api#editforumtopic type EditForumTopicP struct { @@ -46,6 +64,14 @@ func (api *API) EditForumTopic(params EditForumTopicP) (bool, error) { return req.Do(api) } +// EditForumTopicWithContext is the context-aware variant of EditForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editforumtopic +func (api *API) EditForumTopicWithContext(ctx context.Context, params EditForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("editForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // CloseForumTopic closes an open forum topic. // Returns True on success. // See https://core.telegram.org/bots/api#closeforumtopic @@ -54,6 +80,14 @@ func (api *API) CloseForumTopic(params BaseForumTopicP) (bool, error) { return req.Do(api) } +// CloseForumTopicWithContext is the context-aware variant of CloseForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#closeforumtopic +func (api *API) CloseForumTopicWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("closeForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // ReopenForumTopic reopens a closed forum topic. // Returns True on success. // See https://core.telegram.org/bots/api#reopenforumtopic @@ -62,6 +96,14 @@ func (api *API) ReopenForumTopic(params BaseForumTopicP) (bool, error) { return req.Do(api) } +// ReopenForumTopicWithContext is the context-aware variant of ReopenForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#reopenforumtopic +func (api *API) ReopenForumTopicWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("reopenForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // DeleteForumTopic deletes a forum topic. // Returns True on success. // See https://core.telegram.org/bots/api#deleteforumtopic @@ -70,6 +112,14 @@ func (api *API) DeleteForumTopic(params BaseForumTopicP) (bool, error) { return req.Do(api) } +// DeleteForumTopicWithContext is the context-aware variant of DeleteForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deleteforumtopic +func (api *API) DeleteForumTopicWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("deleteForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // UnpinAllForumTopicMessages clears the list of pinned messages in a forum topic. // Returns True on success. // See https://core.telegram.org/bots/api#unpinallforumtopicmessages @@ -78,6 +128,14 @@ func (api *API) UnpinAllForumTopicMessages(params BaseForumTopicP) (bool, error) return req.Do(api) } +// UnpinAllForumTopicMessagesWithContext is the context-aware variant of UnpinAllForumTopicMessages. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#unpinallforumtopicmessages +func (api *API) UnpinAllForumTopicMessagesWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("unpinAllForumTopicMessages", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // BaseGeneralForumTopicP contains common fields for general forum topic operations that require a chat ID. type BaseGeneralForumTopicP struct { ChatID int64 `json:"chat_id"` @@ -98,6 +156,14 @@ func (api *API) EditGeneralForumTopic(params EditGeneralForumTopicP) (bool, erro return req.Do(api) } +// EditGeneralForumTopicWithContext is the context-aware variant of EditGeneralForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editgeneralforumtopic +func (api *API) EditGeneralForumTopicWithContext(ctx context.Context, params EditGeneralForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("editGeneralForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // CloseGeneralForumTopic closes the 'General' topic in a forum supergroup. // Returns True on success. // See https://core.telegram.org/bots/api#closegeneralforumtopic @@ -106,6 +172,14 @@ func (api *API) CloseGeneralForumTopic(params BaseGeneralForumTopicP) (bool, err return req.Do(api) } +// CloseGeneralForumTopicWithContext is the context-aware variant of CloseGeneralForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#closegeneralforumtopic +func (api *API) CloseGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("closeGeneralForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // ReopenGeneralForumTopic reopens the 'General' topic in a forum supergroup. // Returns True on success. // See https://core.telegram.org/bots/api#reopengeneralforumtopic @@ -114,6 +188,14 @@ func (api *API) ReopenGeneralForumTopic(params BaseGeneralForumTopicP) (bool, er return req.Do(api) } +// ReopenGeneralForumTopicWithContext is the context-aware variant of ReopenGeneralForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#reopengeneralforumtopic +func (api *API) ReopenGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("reopenGeneralForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // HideGeneralForumTopic hides the 'General' topic in a forum supergroup. // Returns True on success. // See https://core.telegram.org/bots/api#hidegeneralforumtopic @@ -122,6 +204,14 @@ func (api *API) HideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, erro return req.Do(api) } +// HideGeneralForumTopicWithContext is the context-aware variant of HideGeneralForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#hidegeneralforumtopic +func (api *API) HideGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("hideGeneralForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // UnhideGeneralForumTopic unhides the 'General' topic in a forum supergroup. // Returns True on success. // See https://core.telegram.org/bots/api#unhidegeneralforumtopic @@ -130,6 +220,14 @@ func (api *API) UnhideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, er return req.Do(api) } +// UnhideGeneralForumTopicWithContext is the context-aware variant of UnhideGeneralForumTopic. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#unhidegeneralforumtopic +func (api *API) UnhideGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("unhideGeneralForumTopic", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // UnpinAllGeneralForumTopicMessages clears the list of pinned messages in the 'General' topic. // Returns True on success. // See https://core.telegram.org/bots/api#unpinallgeneralforumtopicmessages @@ -137,3 +235,11 @@ func (api *API) UnpinAllGeneralForumTopicMessages(params BaseGeneralForumTopicP) req := NewRequestWithChatID[bool]("unpinAllGeneralForumTopicMessages", params, params.ChatID) return req.Do(api) } + +// UnpinAllGeneralForumTopicMessagesWithContext is the context-aware variant of UnpinAllGeneralForumTopicMessages. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#unpinallgeneralforumtopicmessages +func (api *API) UnpinAllGeneralForumTopicMessagesWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) { + req := NewRequestWithChatID[bool]("unpinAllGeneralForumTopicMessages", params, params.ChatID) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/games_methods.go b/tgapi/games_methods.go index 4441edb..0aa060f 100644 --- a/tgapi/games_methods.go +++ b/tgapi/games_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // SendGameP holds parameters for the sendGame method. // See https://core.telegram.org/bots/api#sendgame type SendGameP struct { @@ -24,6 +26,14 @@ func (api *API) SendGame(params SendGameP) (Message, error) { return req.Do(api) } +// SendGameWithContext is the context-aware variant of SendGame. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendgame +func (api *API) SendGameWithContext(ctx context.Context, params SendGameP) (Message, error) { + req := NewRequestWithChatID[Message]("sendGame", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetGameScoreP holds parameters for the setGameScore method. // See https://core.telegram.org/bots/api#setgamescore type SetGameScoreP struct { @@ -52,6 +62,21 @@ func (api *API) SetGameScore(params SetGameScoreP) (Message, bool, error) { return res, false, err } +// SetGameScoreWithContext is the context-aware variant of SetGameScore. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setgamescore +func (api *API) SetGameScoreWithContext(ctx context.Context, params SetGameScoreP) (Message, bool, error) { + var zero Message + if params.InlineMessageID != "" { + req := NewRequestWithChatID[bool]("setGameScore", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return zero, res, err + } + req := NewRequestWithChatID[Message]("setGameScore", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return res, false, err +} + // GetGameHighScoresP holds parameters for the getGameHighScores method. // See https://core.telegram.org/bots/api#getgamehighscores type GetGameHighScoresP struct { @@ -67,3 +92,11 @@ func (api *API) GetGameHighScores(params GetGameHighScoresP) ([]GameHighScore, e req := NewRequestWithChatID[[]GameHighScore]("getGameHighScores", params, params.ChatID) return req.Do(api) } + +// GetGameHighScoresWithContext is the context-aware variant of GetGameHighScores. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getgamehighscores +func (api *API) GetGameHighScoresWithContext(ctx context.Context, params GetGameHighScoresP) ([]GameHighScore, error) { + req := NewRequestWithChatID[[]GameHighScore]("getGameHighScores", params, params.ChatID) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/inline_methods.go b/tgapi/inline_methods.go index 1bcc48a..8b8232e 100644 --- a/tgapi/inline_methods.go +++ b/tgapi/inline_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // AnswerInlineQueryP holds parameters for the answerInlineQuery method. // See https://core.telegram.org/bots/api#answerinlinequery type AnswerInlineQueryP struct { @@ -19,6 +21,14 @@ func (api *API) AnswerInlineQuery(params AnswerInlineQueryP) (bool, error) { return req.Do(api) } +// AnswerInlineQueryWithContext is the context-aware variant of AnswerInlineQuery. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#answerinlinequery +func (api *API) AnswerInlineQueryWithContext(ctx context.Context, params AnswerInlineQueryP) (bool, error) { + req := NewRequest[bool]("answerInlineQuery", params) + return req.DoWithContext(ctx, api) +} + // AnswerWebAppQueryP holds parameters for the answerWebAppQuery method. // See https://core.telegram.org/bots/api#answerwebappquery type AnswerWebAppQueryP struct { @@ -33,6 +43,14 @@ func (api *API) AnswerWebAppQuery(params AnswerWebAppQueryP) (SentWebAppMessage, return req.Do(api) } +// AnswerWebAppQueryWithContext is the context-aware variant of AnswerWebAppQuery. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#answerwebappquery +func (api *API) AnswerWebAppQueryWithContext(ctx context.Context, params AnswerWebAppQueryP) (SentWebAppMessage, error) { + req := NewRequest[SentWebAppMessage]("answerWebAppQuery", params) + return req.DoWithContext(ctx, api) +} + // SavePreparedInlineMessageP holds parameters for the savePreparedInlineMessage method. // See https://core.telegram.org/bots/api#savepreparedinlinemessage type SavePreparedInlineMessageP struct { @@ -50,3 +68,11 @@ func (api *API) SavePreparedInlineMessage(params SavePreparedInlineMessageP) (Pr req := NewRequest[PreparedInlineMessage]("savePreparedInlineMessage", params) return req.Do(api) } + +// SavePreparedInlineMessageWithContext is the context-aware variant of SavePreparedInlineMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#savepreparedinlinemessage +func (api *API) SavePreparedInlineMessageWithContext(ctx context.Context, params SavePreparedInlineMessageP) (PreparedInlineMessage, error) { + req := NewRequest[PreparedInlineMessage]("savePreparedInlineMessage", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/messages_methods.go b/tgapi/messages_methods.go index dc87f8b..69ced5c 100644 --- a/tgapi/messages_methods.go +++ b/tgapi/messages_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // SendMessageP holds parameters for the sendMessage method. // See https://core.telegram.org/bots/api#sendmessage type SendMessageP struct { @@ -29,6 +31,14 @@ func (api *API) SendMessage(params SendMessageP) (Message, error) { return req.Do(api) } +// SendMessageWithContext is the context-aware variant of SendMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendmessage +func (api *API) SendMessageWithContext(ctx context.Context, params SendMessageP) (Message, error) { + req := NewRequestWithChatID[Message, SendMessageP]("sendMessage", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // ForwardMessageP holds parameters for the forwardMessage method. // See https://core.telegram.org/bots/api#forwardmessage type ForwardMessageP struct { @@ -53,6 +63,14 @@ func (api *API) ForwardMessage(params ForwardMessageP) (Message, error) { return req.Do(api) } +// ForwardMessageWithContext is the context-aware variant of ForwardMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#forwardmessage +func (api *API) ForwardMessageWithContext(ctx context.Context, params ForwardMessageP) (Message, error) { + req := NewRequestWithChatID[Message]("forwardMessage", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // ForwardMessagesP holds parameters for the forwardMessages method. // See https://core.telegram.org/bots/api#forwardmessages type ForwardMessagesP struct { @@ -74,6 +92,14 @@ func (api *API) ForwardMessages(params ForwardMessagesP) ([]MessageID, error) { return req.Do(api) } +// ForwardMessagesWithContext is the context-aware variant of ForwardMessages. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#forwardmessages +func (api *API) ForwardMessagesWithContext(ctx context.Context, params ForwardMessagesP) ([]MessageID, error) { + req := NewRequestWithChatID[[]MessageID]("forwardMessages", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // CopyMessageP holds parameters for the copyMessage method. // See https://core.telegram.org/bots/api#copymessage type CopyMessageP struct { @@ -110,6 +136,17 @@ func (api *API) CopyMessage(params CopyMessageP) (int, error) { return msgID.MessageID, nil } +// CopyMessageWithContext is the context-aware variant of CopyMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#copymessage +func (api *API) CopyMessageWithContext(ctx context.Context, params CopyMessageP) (int, error) { + msgID, err := NewRequestWithChatID[MessageID]("copyMessage", params, params.ChatID).DoWithContext(ctx, api) + if err != nil { + return 0, err + } + return msgID.MessageID, nil +} + // CopyMessagesP holds parameters for the copyMessages method. // See https://core.telegram.org/bots/api#copymessages type CopyMessagesP struct { @@ -132,6 +169,14 @@ func (api *API) CopyMessages(params CopyMessagesP) ([]MessageID, error) { return req.Do(api) } +// CopyMessagesWithContext is the context-aware variant of CopyMessages. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#copymessages +func (api *API) CopyMessagesWithContext(ctx context.Context, params CopyMessagesP) ([]MessageID, error) { + req := NewRequestWithChatID[[]MessageID]("copyMessages", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendLocationP holds parameters for the sendLocation method. // See https://core.telegram.org/bots/api#sendlocation type SendLocationP struct { @@ -164,6 +209,14 @@ func (api *API) SendLocation(params SendLocationP) (Message, error) { return req.Do(api) } +// SendLocationWithContext is the context-aware variant of SendLocation. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendlocation +func (api *API) SendLocationWithContext(ctx context.Context, params SendLocationP) (Message, error) { + req := NewRequestWithChatID[Message]("sendLocation", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendVenueP holds parameters for the sendVenue method. // See https://core.telegram.org/bots/api#sendvenue type SendVenueP struct { @@ -198,6 +251,14 @@ func (api *API) SendVenue(params SendVenueP) (Message, error) { return req.Do(api) } +// SendVenueWithContext is the context-aware variant of SendVenue. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendvenue +func (api *API) SendVenueWithContext(ctx context.Context, params SendVenueP) (Message, error) { + req := NewRequestWithChatID[Message]("sendVenue", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendContactP holds parameters for the sendContact method. // See https://core.telegram.org/bots/api#sendcontact type SendContactP struct { @@ -228,6 +289,14 @@ func (api *API) SendContact(params SendContactP) (Message, error) { return req.Do(api) } +// SendContactWithContext is the context-aware variant of SendContact. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendcontact +func (api *API) SendContactWithContext(ctx context.Context, params SendContactP) (Message, error) { + req := NewRequestWithChatID[Message]("sendContact", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendPollP holds parameters for the sendPoll method. // See https://core.telegram.org/bots/api#sendpoll type SendPollP struct { @@ -266,6 +335,14 @@ func (api *API) SendPoll(params SendPollP) (Message, error) { return req.Do(api) } +// SendPollWithContext is the context-aware variant of SendPoll. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendpoll +func (api *API) SendPollWithContext(ctx context.Context, params SendPollP) (Message, error) { + req := NewRequestWithChatID[Message]("sendPoll", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendChecklistP holds parameters for the sendChecklist method. // See https://core.telegram.org/bots/api#sendchecklist type SendChecklistP struct { @@ -288,6 +365,14 @@ func (api *API) SendChecklist(params SendChecklistP) (Message, error) { return req.Do(api) } +// SendChecklistWithContext is the context-aware variant of SendChecklist. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendchecklist +func (api *API) SendChecklistWithContext(ctx context.Context, params SendChecklistP) (Message, error) { + req := NewRequestWithChatID[Message]("sendChecklist", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendDiceP holds parameters for the sendDice method. // See https://core.telegram.org/bots/api#senddice type SendDiceP struct { @@ -315,6 +400,14 @@ func (api *API) SendDice(params SendDiceP) (Message, error) { return req.Do(api) } +// SendDiceWithContext is the context-aware variant of SendDice. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#senddice +func (api *API) SendDiceWithContext(ctx context.Context, params SendDiceP) (Message, error) { + req := NewRequestWithChatID[Message]("sendDice", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendMessageDraftP holds parameters for the sendMessageDraft method. // See https://core.telegram.org/bots/api#sendmessagedraft type SendMessageDraftP struct { @@ -334,6 +427,14 @@ func (api *API) SendMessageDraft(params SendMessageDraftP) (bool, error) { return req.Do(api) } +// SendMessageDraftWithContext is the context-aware variant of SendMessageDraft. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendmessagedraft +func (api *API) SendMessageDraftWithContext(ctx context.Context, params SendMessageDraftP) (bool, error) { + req := NewRequestWithChatID[bool]("sendMessageDraft", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SendChatActionP holds parameters for the sendChatAction method. // See https://core.telegram.org/bots/api#sendchataction type SendChatActionP struct { @@ -351,6 +452,14 @@ func (api *API) SendChatAction(params SendChatActionP) (bool, error) { return req.Do(api) } +// SendChatActionWithContext is the context-aware variant of SendChatAction. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendchataction +func (api *API) SendChatActionWithContext(ctx context.Context, params SendChatActionP) (bool, error) { + req := NewRequestWithChatID[bool]("sendChatAction", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // SetMessageReactionP holds parameters for the setMessageReaction method. // See https://core.telegram.org/bots/api#setmessagereaction type SetMessageReactionP struct { @@ -368,16 +477,26 @@ func (api *API) SetMessageReaction(params SetMessageReactionP) (bool, error) { return req.Do(api) } +// SetMessageReactionWithContext is the context-aware variant of SetMessageReaction. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setmessagereaction +func (api *API) SetMessageReactionWithContext(ctx context.Context, params SetMessageReactionP) (bool, error) { + req := NewRequestWithChatID[bool]("setMessageReaction", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // EditMessageTextP holds parameters for the editMessageText method. // See https://core.telegram.org/bots/api#editmessagetext type EditMessageTextP struct { - BusinessConnectionID string `json:"business_connection_id,omitempty"` - ChatID int64 `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 *ReplyMarkup `json:"reply_markup,omitempty"` + BusinessConnectionID string `json:"business_connection_id,omitempty"` + ChatID int64 `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"` + Entities []MessageEntity `json:"entities,omitempty"` + LinkPreviewOptions *LinkPreviewOptions `json:"link_preview_options,omitempty"` + ReplyMarkup *ReplyMarkup `json:"reply_markup,omitempty"` } // EditMessageText edits text messages. @@ -396,16 +515,33 @@ func (api *API) EditMessageText(params EditMessageTextP) (Message, bool, error) return res, false, err } +// EditMessageTextWithContext is the context-aware variant of EditMessageText. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editmessagetext +func (api *API) EditMessageTextWithContext(ctx context.Context, params EditMessageTextP) (Message, bool, error) { + var zero Message + if params.InlineMessageID != "" { + req := NewRequestWithChatID[bool]("editMessageText", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return zero, res, err + } + req := NewRequestWithChatID[Message]("editMessageText", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return res, false, err +} + // EditMessageCaptionP holds parameters for the editMessageCaption method. // See https://core.telegram.org/bots/api#editmessagecaption type EditMessageCaptionP struct { - BusinessConnectionID string `json:"business_connection_id,omitempty"` - ChatID int64 `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 *ReplyMarkup `json:"reply_markup,omitempty"` + BusinessConnectionID string `json:"business_connection_id,omitempty"` + ChatID int64 `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"` + CaptionEntities []MessageEntity `json:"caption_entities,omitempty"` + ShowCaptionAboveMedia bool `json:"show_caption_above_media,omitempty"` + ReplyMarkup *ReplyMarkup `json:"reply_markup,omitempty"` } // EditMessageCaption edits captions of messages. @@ -424,6 +560,21 @@ func (api *API) EditMessageCaption(params EditMessageCaptionP) (Message, bool, e return res, false, err } +// EditMessageCaptionWithContext is the context-aware variant of EditMessageCaption. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editmessagecaption +func (api *API) EditMessageCaptionWithContext(ctx context.Context, params EditMessageCaptionP) (Message, bool, error) { + var zero Message + if params.InlineMessageID != "" { + req := NewRequestWithChatID[bool]("editMessageCaption", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return zero, res, err + } + req := NewRequestWithChatID[Message]("editMessageCaption", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return res, false, err +} + // EditMessageMediaP holds parameters for the editMessageMedia method. // See https://core.telegram.org/bots/api#editmessagemedia type EditMessageMediaP struct { @@ -451,6 +602,21 @@ func (api *API) EditMessageMedia(params EditMessageMediaP) (Message, bool, error return res, false, err } +// EditMessageMediaWithContext is the context-aware variant of EditMessageMedia. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editmessagemedia +func (api *API) EditMessageMediaWithContext(ctx context.Context, params EditMessageMediaP) (Message, bool, error) { + var zero Message + if params.InlineMessageID != "" { + req := NewRequestWithChatID[bool]("editMessageMedia", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return zero, res, err + } + req := NewRequestWithChatID[Message]("editMessageMedia", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return res, false, err +} + // EditMessageLiveLocationP holds parameters for the editMessageLiveLocation method. // See https://core.telegram.org/bots/api#editmessagelivelocation type EditMessageLiveLocationP struct { @@ -484,6 +650,21 @@ func (api *API) EditMessageLiveLocation(params EditMessageLiveLocationP) (Messag return res, false, err } +// EditMessageLiveLocationWithContext is the context-aware variant of EditMessageLiveLocation. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editmessagelivelocation +func (api *API) EditMessageLiveLocationWithContext(ctx context.Context, params EditMessageLiveLocationP) (Message, bool, error) { + var zero Message + if params.InlineMessageID != "" { + req := NewRequestWithChatID[bool]("editMessageLiveLocation", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return zero, res, err + } + req := NewRequestWithChatID[Message]("editMessageLiveLocation", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return res, false, err +} + // StopMessageLiveLocationP holds parameters for the stopMessageLiveLocation method. // See https://core.telegram.org/bots/api#stopmessagelivelocation type StopMessageLiveLocationP struct { @@ -510,6 +691,21 @@ func (api *API) StopMessageLiveLocation(params StopMessageLiveLocationP) (Messag return res, false, err } +// StopMessageLiveLocationWithContext is the context-aware variant of StopMessageLiveLocation. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#stopmessagelivelocation +func (api *API) StopMessageLiveLocationWithContext(ctx context.Context, params StopMessageLiveLocationP) (Message, bool, error) { + var zero Message + if params.InlineMessageID != "" { + req := NewRequestWithChatID[bool]("stopMessageLiveLocation", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return zero, res, err + } + req := NewRequestWithChatID[Message]("stopMessageLiveLocation", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return res, false, err +} + // EditMessageChecklistP holds parameters for the editMessageChecklist method. type EditMessageChecklistP struct { BusinessConnectionID string `json:"business_connection_id"` @@ -526,6 +722,14 @@ func (api *API) EditMessageChecklist(params EditMessageChecklistP) (Message, err return req.Do(api) } +// EditMessageChecklistWithContext is the context-aware variant of EditMessageChecklist. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editmessagechecklist +func (api *API) EditMessageChecklistWithContext(ctx context.Context, params EditMessageChecklistP) (Message, error) { + req := NewRequestWithChatID[Message]("editMessageChecklist", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // EditMessageReplyMarkupP holds parameters for the editMessageReplyMarkup method. // See https://core.telegram.org/bots/api#editmessagereplymarkup type EditMessageReplyMarkupP struct { @@ -552,13 +756,28 @@ func (api *API) EditMessageReplyMarkup(params EditMessageReplyMarkupP) (Message, return res, false, err } +// EditMessageReplyMarkupWithContext is the context-aware variant of EditMessageReplyMarkup. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#editmessagereplymarkup +func (api *API) EditMessageReplyMarkupWithContext(ctx context.Context, params EditMessageReplyMarkupP) (Message, bool, error) { + var zero Message + if params.InlineMessageID != "" { + req := NewRequestWithChatID[bool]("editMessageReplyMarkup", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return zero, res, err + } + req := NewRequestWithChatID[Message]("editMessageReplyMarkup", params, params.ChatID) + res, err := req.DoWithContext(ctx, api) + return res, false, err +} + // StopPollP holds parameters for the stopPoll method. // See https://core.telegram.org/bots/api#stoppoll type StopPollP struct { - BusinessConnectionID string `json:"business_connection_id,omitempty"` - ChatID int64 `json:"chat_id"` - MessageID int `json:"message_id"` - InlineMessageID string `json:"inline_message_id,omitempty"` + BusinessConnectionID string `json:"business_connection_id,omitempty"` + ChatID int64 `json:"chat_id"` + MessageID int `json:"message_id"` + ReplyMarkup *InlineKeyboardMarkup `json:"reply_markup,omitempty"` } // StopPoll stops a poll that was sent by the bot. @@ -569,6 +788,14 @@ func (api *API) StopPoll(params StopPollP) (Poll, error) { return req.Do(api) } +// StopPollWithContext is the context-aware variant of StopPoll. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#stoppoll +func (api *API) StopPollWithContext(ctx context.Context, params StopPollP) (Poll, error) { + req := NewRequestWithChatID[Poll]("stopPoll", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // ApproveSuggestedPostP holds parameters for the approveSuggestedPost method. // See https://core.telegram.org/bots/api#approvesuggestedpost type ApproveSuggestedPostP struct { @@ -585,6 +812,14 @@ func (api *API) ApproveSuggestedPost(params ApproveSuggestedPostP) (bool, error) return req.Do(api) } +// ApproveSuggestedPostWithContext is the context-aware variant of ApproveSuggestedPost. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#approvesuggestedpost +func (api *API) ApproveSuggestedPostWithContext(ctx context.Context, params ApproveSuggestedPostP) (bool, error) { + req := NewRequestWithChatID[bool]("approveSuggestedPost", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // DeclineSuggestedPostP holds parameters for the declineSuggestedPost method. // See https://core.telegram.org/bots/api#declinesuggestedpost type DeclineSuggestedPostP struct { @@ -601,6 +836,14 @@ func (api *API) DeclineSuggestedPost(params DeclineSuggestedPostP) (bool, error) return req.Do(api) } +// DeclineSuggestedPostWithContext is the context-aware variant of DeclineSuggestedPost. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#declinesuggestedpost +func (api *API) DeclineSuggestedPostWithContext(ctx context.Context, params DeclineSuggestedPostP) (bool, error) { + req := NewRequestWithChatID[bool]("declineSuggestedPost", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // DeleteMessageP holds parameters for the deleteMessage method. // See https://core.telegram.org/bots/api#deletemessage type DeleteMessageP struct { @@ -616,6 +859,14 @@ func (api *API) DeleteMessage(params DeleteMessageP) (bool, error) { return req.Do(api) } +// DeleteMessageWithContext is the context-aware variant of DeleteMessage. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletemessage +func (api *API) DeleteMessageWithContext(ctx context.Context, params DeleteMessageP) (bool, error) { + req := NewRequestWithChatID[bool]("deleteMessage", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // DeleteMessagesP holds parameters for the deleteMessages method. // See https://core.telegram.org/bots/api#deletemessages type DeleteMessagesP struct { @@ -631,6 +882,14 @@ func (api *API) DeleteMessages(params DeleteMessagesP) (bool, error) { return req.Do(api) } +// DeleteMessagesWithContext is the context-aware variant of DeleteMessages. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletemessages +func (api *API) DeleteMessagesWithContext(ctx context.Context, params DeleteMessagesP) (bool, error) { + req := NewRequestWithChatID[bool]("deleteMessages", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // AnswerCallbackQueryP holds parameters for the answerCallbackQuery method. // See https://core.telegram.org/bots/api#answercallbackquery type AnswerCallbackQueryP struct { @@ -648,3 +907,11 @@ func (api *API) AnswerCallbackQuery(params AnswerCallbackQueryP) (bool, error) { req := NewRequest[bool]("answerCallbackQuery", params) return req.Do(api) } + +// AnswerCallbackQueryWithContext is the context-aware variant of AnswerCallbackQuery. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#answercallbackquery +func (api *API) AnswerCallbackQueryWithContext(ctx context.Context, params AnswerCallbackQueryP) (bool, error) { + req := NewRequest[bool]("answerCallbackQuery", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/methods.go b/tgapi/methods.go index 7375e9b..e4a2f9c 100644 --- a/tgapi/methods.go +++ b/tgapi/methods.go @@ -25,6 +25,14 @@ func (api *API) GetMe() (User, error) { return req.Do(api) } +// GetMeWithContext is the context-aware variant of GetMe. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getme +func (api *API) GetMeWithContext(ctx context.Context) (User, error) { + req := NewRequest[User, EmptyParams]("getMe", NoParams) + return req.DoWithContext(ctx, api) +} + // LogOut logs the bot out from the cloud Bot API server. // Returns true on success. // See https://core.telegram.org/bots/api#logout @@ -33,6 +41,14 @@ func (api *API) LogOut() (bool, error) { return req.Do(api) } +// LogOutWithContext is the context-aware variant of LogOut. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#logout +func (api *API) LogOutWithContext(ctx context.Context) (bool, error) { + req := NewRequest[bool, EmptyParams]("logOut", NoParams) + return req.DoWithContext(ctx, api) +} + // Close closes the bot instance on the local server. // Returns true on success. // See https://core.telegram.org/bots/api#close @@ -41,6 +57,14 @@ func (api *API) Close() (bool, error) { return req.Do(api) } +// CloseWithContext is the context-aware variant of Close. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#close +func (api *API) CloseWithContext(ctx context.Context) (bool, error) { + req := NewRequest[bool, EmptyParams]("close", NoParams) + return req.DoWithContext(ctx, api) +} + // GetUpdates receives incoming updates using long polling. // See https://core.telegram.org/bots/api#getupdates func (api *API) GetUpdates(params UpdateParams) ([]Update, error) { @@ -48,16 +72,19 @@ func (api *API) GetUpdates(params UpdateParams) ([]Update, error) { return req.Do(api) } +// GetUpdatesWithContext is the context-aware variant of GetUpdates. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getupdates func (api *API) GetUpdatesWithContext(ctx context.Context, params UpdateParams) ([]Update, error) { req := NewRequest[[]Update]("getUpdates", params) return req.DoWithContext(ctx, api) } // SetWebhookP holds parameters for the setWebhook method. +// To upload a self-signed certificate, use Uploader.SetWebhook. // See https://core.telegram.org/bots/api#setwebhook type SetWebhookP struct { URL string `json:"url"` - Certificate string `json:"certificate,omitempty"` IPAddress string `json:"ip_address,omitempty"` MaxConnections int `json:"max_connections,omitempty"` AllowedUpdates []UpdateType `json:"allowed_updates,omitempty"` @@ -66,6 +93,7 @@ type SetWebhookP struct { } // SetWebhook sets a webhook URL for incoming updates. +// For certificate upload, use Uploader.SetWebhook. // Returns true on success. // See https://core.telegram.org/bots/api#setwebhook func (api *API) SetWebhook(params SetWebhookP) (bool, error) { @@ -73,6 +101,15 @@ func (api *API) SetWebhook(params SetWebhookP) (bool, error) { return req.Do(api) } +// SetWebhookWithContext is the context-aware variant of SetWebhook. +// It executes the same request but uses ctx for cancellation and deadlines. +// For certificate upload, use Uploader.SetWebhook. +// See https://core.telegram.org/bots/api#setwebhook +func (api *API) SetWebhookWithContext(ctx context.Context, params SetWebhookP) (bool, error) { + req := NewRequest[bool]("setWebhook", params) + return req.DoWithContext(ctx, api) +} + // DeleteWebhookP holds parameters for the deleteWebhook method. // See https://core.telegram.org/bots/api#deletewebhook type DeleteWebhookP struct { @@ -87,6 +124,14 @@ func (api *API) DeleteWebhook(params DeleteWebhookP) (bool, error) { return req.Do(api) } +// DeleteWebhookWithContext is the context-aware variant of DeleteWebhook. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletewebhook +func (api *API) DeleteWebhookWithContext(ctx context.Context, params DeleteWebhookP) (bool, error) { + req := NewRequest[bool]("deleteWebhook", params) + return req.DoWithContext(ctx, api) +} + // GetWebhookInfo returns the current webhook status. // See https://core.telegram.org/bots/api#getwebhookinfo func (api *API) GetWebhookInfo() (WebhookInfo, error) { @@ -94,6 +139,14 @@ func (api *API) GetWebhookInfo() (WebhookInfo, error) { return req.Do(api) } +// GetWebhookInfoWithContext is the context-aware variant of GetWebhookInfo. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getwebhookinfo +func (api *API) GetWebhookInfoWithContext(ctx context.Context) (WebhookInfo, error) { + req := NewRequest[WebhookInfo]("getWebhookInfo", NoParams) + return req.DoWithContext(ctx, api) +} + // GetFileP holds parameters for the getFile method. // See https://core.telegram.org/bots/api#getfile type GetFileP struct { @@ -107,17 +160,36 @@ func (api *API) GetFile(params GetFileP) (File, error) { return req.Do(api) } +// GetFileWithContext is the context-aware variant of GetFile. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getfile +func (api *API) GetFileWithContext(ctx context.Context, params GetFileP) (File, error) { + req := NewRequest[File]("getFile", params) + return req.DoWithContext(ctx, api) +} + // GetFileByLink downloads a file from Telegram's file server using the provided file link. // The link is usually obtained from File.FilePath. // See https://core.telegram.org/bots/api#file func (api *API) GetFileByLink(link string) ([]byte, error) { + return api.getFileByLink(context.Background(), link) +} + +// GetFileByLinkWithContext is the context-aware variant of GetFileByLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#file +func (api *API) GetFileByLinkWithContext(ctx context.Context, link string) ([]byte, error) { + return api.getFileByLink(ctx, link) +} + +func (api *API) getFileByLink(ctx context.Context, link string) ([]byte, error) { methodPrefix := "" if api.useTestServer { methodPrefix = "/test" } u := fmt.Sprintf("%s/file/bot%s%s/%s", api.apiUrl, api.token, methodPrefix, link) - req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, u, nil) + req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil) if err != nil { return nil, err } diff --git a/tgapi/passport_methods.go b/tgapi/passport_methods.go index d6e5ae8..4af8fd5 100644 --- a/tgapi/passport_methods.go +++ b/tgapi/passport_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // SetPassportDataErrorsP holds parameters for the setPassportDataErrors method. // See https://core.telegram.org/bots/api#setpassportdataerrors type SetPassportDataErrorsP struct { @@ -14,3 +16,11 @@ func (api *API) SetPassportDataErrors(params SetPassportDataErrorsP) (bool, erro req := NewRequest[bool]("setPassportDataErrors", params) return req.Do(api) } + +// SetPassportDataErrorsWithContext is the context-aware variant of SetPassportDataErrors. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setpassportdataerrors +func (api *API) SetPassportDataErrorsWithContext(ctx context.Context, params SetPassportDataErrorsP) (bool, error) { + req := NewRequest[bool]("setPassportDataErrors", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/payments_methods.go b/tgapi/payments_methods.go index ef87590..3cc9966 100644 --- a/tgapi/payments_methods.go +++ b/tgapi/payments_methods.go @@ -1,12 +1,13 @@ package tgapi +import "context" + // SendInvoiceP holds parameters for the sendInvoice method. // See https://core.telegram.org/bots/api#sendinvoice type SendInvoiceP struct { - BusinessConnectionID string `json:"business_connection_id,omitempty"` - ChatID int64 `json:"chat_id"` - MessageThreadID int `json:"message_thread_id,omitempty"` - DirectMessagesTopicID int `json:"direct_messages_topic_id,omitempty"` + ChatID int64 `json:"chat_id"` + MessageThreadID int `json:"message_thread_id,omitempty"` + DirectMessagesTopicID int `json:"direct_messages_topic_id,omitempty"` Title string `json:"title"` Description string `json:"description"` @@ -47,6 +48,14 @@ func (api *API) SendInvoice(params SendInvoiceP) (Message, error) { return req.Do(api) } +// SendInvoiceWithContext is the context-aware variant of SendInvoice. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendinvoice +func (api *API) SendInvoiceWithContext(ctx context.Context, params SendInvoiceP) (Message, error) { + req := NewRequestWithChatID[Message]("sendInvoice", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // CreateInvoiceLinkP holds parameters for the createInvoiceLink method. // See https://core.telegram.org/bots/api#createinvoicelink type CreateInvoiceLinkP struct { @@ -83,6 +92,14 @@ func (api *API) CreateInvoiceLink(params CreateInvoiceLinkP) (string, error) { return req.Do(api) } +// CreateInvoiceLinkWithContext is the context-aware variant of CreateInvoiceLink. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#createinvoicelink +func (api *API) CreateInvoiceLinkWithContext(ctx context.Context, params CreateInvoiceLinkP) (string, error) { + req := NewRequest[string]("createInvoiceLink", params) + return req.DoWithContext(ctx, api) +} + // AnswerShippingQueryP holds parameters for the answerShippingQuery method. // See https://core.telegram.org/bots/api#answershippingquery type AnswerShippingQueryP struct { @@ -100,6 +117,14 @@ func (api *API) AnswerShippingQuery(params AnswerShippingQueryP) (bool, error) { return req.Do(api) } +// AnswerShippingQueryWithContext is the context-aware variant of AnswerShippingQuery. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#answershippingquery +func (api *API) AnswerShippingQueryWithContext(ctx context.Context, params AnswerShippingQueryP) (bool, error) { + req := NewRequest[bool]("answerShippingQuery", params) + return req.DoWithContext(ctx, api) +} + // AnswerPreCheckoutQueryP holds parameters for the answerPreCheckoutQuery method. // See https://core.telegram.org/bots/api#answerprecheckoutquery type AnswerPreCheckoutQueryP struct { @@ -115,3 +140,11 @@ func (api *API) AnswerPreCheckoutQuery(params AnswerPreCheckoutQueryP) (bool, er req := NewRequest[bool]("answerPreCheckoutQuery", params) return req.Do(api) } + +// AnswerPreCheckoutQueryWithContext is the context-aware variant of AnswerPreCheckoutQuery. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#answerprecheckoutquery +func (api *API) AnswerPreCheckoutQueryWithContext(ctx context.Context, params AnswerPreCheckoutQueryP) (bool, error) { + req := NewRequest[bool]("answerPreCheckoutQuery", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/stars_methods.go b/tgapi/stars_methods.go index 7e3e0ab..cec2447 100644 --- a/tgapi/stars_methods.go +++ b/tgapi/stars_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // GetStarTransactionsP holds parameters for the getStarTransactions method. // See https://core.telegram.org/bots/api#getstartransactions type GetStarTransactionsP struct { @@ -14,6 +16,14 @@ func (api *API) GetMyStarBalance() (StarAmount, error) { return req.Do(api) } +// GetMyStarBalanceWithContext is the context-aware variant of GetMyStarBalance. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getmystarbalance +func (api *API) GetMyStarBalanceWithContext(ctx context.Context) (StarAmount, error) { + req := NewRequest[StarAmount]("getMyStarBalance", NoParams) + return req.DoWithContext(ctx, api) +} + // GetStarTransactions returns Telegram Star transactions for the bot. // See https://core.telegram.org/bots/api#getstartransactions func (api *API) GetStarTransactions(params GetStarTransactionsP) (StarTransactions, error) { @@ -21,6 +31,14 @@ func (api *API) GetStarTransactions(params GetStarTransactionsP) (StarTransactio return req.Do(api) } +// GetStarTransactionsWithContext is the context-aware variant of GetStarTransactions. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getstartransactions +func (api *API) GetStarTransactionsWithContext(ctx context.Context, params GetStarTransactionsP) (StarTransactions, error) { + req := NewRequest[StarTransactions]("getStarTransactions", params) + return req.DoWithContext(ctx, api) +} + // RefundStarPaymentP holds parameters for the refundStarPayment method. // See https://core.telegram.org/bots/api#refundstarpayment type RefundStarPaymentP struct { @@ -36,6 +54,14 @@ func (api *API) RefundStarPayment(params RefundStarPaymentP) (bool, error) { return req.Do(api) } +// RefundStarPaymentWithContext is the context-aware variant of RefundStarPayment. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#refundstarpayment +func (api *API) RefundStarPaymentWithContext(ctx context.Context, params RefundStarPaymentP) (bool, error) { + req := NewRequest[bool]("refundStarPayment", params) + return req.DoWithContext(ctx, api) +} + // EditUserStarSubscriptionP holds parameters for the editUserStarSubscription method. // See https://core.telegram.org/bots/api#edituserstarsubscription type EditUserStarSubscriptionP struct { @@ -51,3 +77,11 @@ func (api *API) EditUserStarSubscription(params EditUserStarSubscriptionP) (bool req := NewRequest[bool]("editUserStarSubscription", params) return req.Do(api) } + +// EditUserStarSubscriptionWithContext is the context-aware variant of EditUserStarSubscription. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#edituserstarsubscription +func (api *API) EditUserStarSubscriptionWithContext(ctx context.Context, params EditUserStarSubscriptionP) (bool, error) { + req := NewRequest[bool]("editUserStarSubscription", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/stickers_methods.go b/tgapi/stickers_methods.go index 77cad3b..6bffcf9 100644 --- a/tgapi/stickers_methods.go +++ b/tgapi/stickers_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // SendStickerP holds parameters for the sendSticker method. // See https://core.telegram.org/bots/api#sendsticker type SendStickerP struct { @@ -14,6 +16,10 @@ type SendStickerP struct { ProtectContent bool `json:"protect_content,omitempty"` AllowPaidBroadcast bool `json:"allow_paid_broadcast,omitempty"` MessageEffectID string `json:"message_effect_id,omitempty"` + + SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"` + ReplyParameters *ReplyParameters `json:"reply_parameters,omitempty"` + ReplyMarkup *ReplyMarkup `json:"reply_markup,omitempty"` } // SendSticker sends a static .WEBP, animated .TGS, or video .WEBM sticker. @@ -23,6 +29,14 @@ func (api *API) SendSticker(params SendStickerP) (Message, error) { return req.Do(api) } +// SendStickerWithContext is the context-aware variant of SendSticker. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendsticker +func (api *API) SendStickerWithContext(ctx context.Context, params SendStickerP) (Message, error) { + req := NewRequestWithChatID[Message]("sendSticker", params, params.ChatID) + return req.DoWithContext(ctx, api) +} + // GetStickerSetP holds parameters for the getStickerSet method. // See https://core.telegram.org/bots/api#getstickerset type GetStickerSetP struct { @@ -36,6 +50,14 @@ func (api *API) GetStickerSet(params GetStickerSetP) (StickerSet, error) { return req.Do(api) } +// GetStickerSetWithContext is the context-aware variant of GetStickerSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getstickerset +func (api *API) GetStickerSetWithContext(ctx context.Context, params GetStickerSetP) (StickerSet, error) { + req := NewRequest[StickerSet]("getStickerSet", params) + return req.DoWithContext(ctx, api) +} + // GetCustomEmojiStickersP holds parameters for the getCustomEmojiStickers method. // See https://core.telegram.org/bots/api#getcustomemojistickers type GetCustomEmojiStickersP struct { @@ -49,6 +71,14 @@ func (api *API) GetCustomEmojiStickers(params GetCustomEmojiStickersP) ([]Sticke return req.Do(api) } +// GetCustomEmojiStickersWithContext is the context-aware variant of GetCustomEmojiStickers. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getcustomemojistickers +func (api *API) GetCustomEmojiStickersWithContext(ctx context.Context, params GetCustomEmojiStickersP) ([]Sticker, error) { + req := NewRequest[[]Sticker]("getCustomEmojiStickers", params) + return req.DoWithContext(ctx, api) +} + // UploadStickerFileP holds parameters for the uploadStickerFile method. // See https://core.telegram.org/bots/api#uploadstickerfile type UploadStickerFileP struct { @@ -68,6 +98,18 @@ func (api *API) UploadStickerFile(params UploadStickerFileP, sticker UploaderFil return req.Do(uploader) } +// UploadStickerFileWithContext is the context-aware variant of UploadStickerFile. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#uploadstickerfile +func (api *API) UploadStickerFileWithContext(ctx context.Context, params UploadStickerFileP, sticker UploaderFile) (File, error) { + uploader := NewUploader(api) + defer func() { + _ = uploader.Close() + }() + req := NewUploaderRequest[File]("uploadStickerFile", params, sticker.SetType(UploaderStickerType)) + return req.DoWithContext(ctx, uploader) +} + // CreateNewStickerSetP holds parameters for the createNewStickerSet method. // See https://core.telegram.org/bots/api#createnewstickerset type CreateNewStickerSetP struct { @@ -88,6 +130,14 @@ func (api *API) CreateNewStickerSet(params CreateNewStickerSetP) (bool, error) { return req.Do(api) } +// CreateNewStickerSetWithContext is the context-aware variant of CreateNewStickerSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#createnewstickerset +func (api *API) CreateNewStickerSetWithContext(ctx context.Context, params CreateNewStickerSetP) (bool, error) { + req := NewRequest[bool]("createNewStickerSet", params) + return req.DoWithContext(ctx, api) +} + // AddStickerToSetP holds parameters for the addStickerToSet method. // See https://core.telegram.org/bots/api#addstickertoset type AddStickerToSetP struct { @@ -104,6 +154,14 @@ func (api *API) AddStickerToSet(params AddStickerToSetP) (bool, error) { return req.Do(api) } +// AddStickerToSetWithContext is the context-aware variant of AddStickerToSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#addstickertoset +func (api *API) AddStickerToSetWithContext(ctx context.Context, params AddStickerToSetP) (bool, error) { + req := NewRequest[bool]("addStickerToSet", params) + return req.DoWithContext(ctx, api) +} + // SetStickerPositionInSetP holds parameters for the setStickerPositionInSet method. // See https://core.telegram.org/bots/api#setstickerpositioninset type SetStickerPositionInSetP struct { @@ -119,6 +177,14 @@ func (api *API) SetStickerPositionInSet(params SetStickerPositionInSetP) (bool, return req.Do(api) } +// SetStickerPositionInSetWithContext is the context-aware variant of SetStickerPositionInSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setstickerpositioninset +func (api *API) SetStickerPositionInSetWithContext(ctx context.Context, params SetStickerPositionInSetP) (bool, error) { + req := NewRequest[bool]("setStickerPositionInSet", params) + return req.DoWithContext(ctx, api) +} + // DeleteStickerFromSetP holds parameters for the deleteStickerFromSet method. // See https://core.telegram.org/bots/api#deletestickerfromset type DeleteStickerFromSetP struct { @@ -133,6 +199,14 @@ func (api *API) DeleteStickerFromSet(params DeleteStickerFromSetP) (bool, error) return req.Do(api) } +// DeleteStickerFromSetWithContext is the context-aware variant of DeleteStickerFromSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletestickerfromset +func (api *API) DeleteStickerFromSetWithContext(ctx context.Context, params DeleteStickerFromSetP) (bool, error) { + req := NewRequest[bool]("deleteStickerFromSet", params) + return req.DoWithContext(ctx, api) +} + // ReplaceStickerInSetP holds parameters for the replaceStickerInSet method. // See https://core.telegram.org/bots/api#replacestickerinset type ReplaceStickerInSetP struct { @@ -150,6 +224,14 @@ func (api *API) ReplaceStickerInSet(params ReplaceStickerInSetP) (bool, error) { return req.Do(api) } +// ReplaceStickerInSetWithContext is the context-aware variant of ReplaceStickerInSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#replacestickerinset +func (api *API) ReplaceStickerInSetWithContext(ctx context.Context, params ReplaceStickerInSetP) (bool, error) { + req := NewRequest[bool]("replaceStickerInSet", params) + return req.DoWithContext(ctx, api) +} + // SetStickerEmojiListP holds parameters for the setStickerEmojiList method. // See https://core.telegram.org/bots/api#setstickeremojilist type SetStickerEmojiListP struct { @@ -165,6 +247,14 @@ func (api *API) SetStickerEmojiList(params SetStickerEmojiListP) (bool, error) { return req.Do(api) } +// SetStickerEmojiListWithContext is the context-aware variant of SetStickerEmojiList. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setstickeremojilist +func (api *API) SetStickerEmojiListWithContext(ctx context.Context, params SetStickerEmojiListP) (bool, error) { + req := NewRequest[bool]("setStickerEmojiList", params) + return req.DoWithContext(ctx, api) +} + // SetStickerKeywordsP holds parameters for the setStickerKeywords method. // See https://core.telegram.org/bots/api#setstickerkeywords type SetStickerKeywordsP struct { @@ -180,6 +270,14 @@ func (api *API) SetStickerKeywords(params SetStickerKeywordsP) (bool, error) { return req.Do(api) } +// SetStickerKeywordsWithContext is the context-aware variant of SetStickerKeywords. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setstickerkeywords +func (api *API) SetStickerKeywordsWithContext(ctx context.Context, params SetStickerKeywordsP) (bool, error) { + req := NewRequest[bool]("setStickerKeywords", params) + return req.DoWithContext(ctx, api) +} + // SetStickerMaskPositionP holds parameters for the setStickerMaskPosition method. // See https://core.telegram.org/bots/api#setstickermaskposition type SetStickerMaskPositionP struct { @@ -195,6 +293,14 @@ func (api *API) SetStickerMaskPosition(params SetStickerMaskPositionP) (bool, er return req.Do(api) } +// SetStickerMaskPositionWithContext is the context-aware variant of SetStickerMaskPosition. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setstickermaskposition +func (api *API) SetStickerMaskPositionWithContext(ctx context.Context, params SetStickerMaskPositionP) (bool, error) { + req := NewRequest[bool]("setStickerMaskPosition", params) + return req.DoWithContext(ctx, api) +} + // SetStickerSetTitleP holds parameters for the setStickerSetTitle method. // See https://core.telegram.org/bots/api#setstickersettitle type SetStickerSetTitleP struct { @@ -210,6 +316,14 @@ func (api *API) SetStickerSetTitle(params SetStickerSetTitleP) (bool, error) { return req.Do(api) } +// SetStickerSetTitleWithContext is the context-aware variant of SetStickerSetTitle. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setstickersettitle +func (api *API) SetStickerSetTitleWithContext(ctx context.Context, params SetStickerSetTitleP) (bool, error) { + req := NewRequest[bool]("setStickerSetTitle", params) + return req.DoWithContext(ctx, api) +} + // SetStickerSetThumbnailP holds parameters for the setStickerSetThumbnail method. // See https://core.telegram.org/bots/api#setstickersetthumbnail type SetStickerSetThumbnailP struct { @@ -227,6 +341,14 @@ func (api *API) SetStickerSetThumbnail(params SetStickerSetThumbnailP) (bool, er return req.Do(api) } +// SetStickerSetThumbnailWithContext is the context-aware variant of SetStickerSetThumbnail. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setstickersetthumbnail +func (api *API) SetStickerSetThumbnailWithContext(ctx context.Context, params SetStickerSetThumbnailP) (bool, error) { + req := NewRequest[bool]("setStickerSetThumbnail", params) + return req.DoWithContext(ctx, api) +} + // SetCustomEmojiStickerSetThumbnailP holds parameters for the setCustomEmojiStickerSetThumbnail method. // See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail type SetCustomEmojiStickerSetThumbnailP struct { @@ -242,6 +364,14 @@ func (api *API) SetCustomEmojiStickerSetThumbnail(params SetCustomEmojiStickerSe return req.Do(api) } +// SetCustomEmojiStickerSetThumbnailWithContext is the context-aware variant of SetCustomEmojiStickerSetThumbnail. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail +func (api *API) SetCustomEmojiStickerSetThumbnailWithContext(ctx context.Context, params SetCustomEmojiStickerSetThumbnailP) (bool, error) { + req := NewRequest[bool]("setCustomEmojiStickerSetThumbnail", params) + return req.DoWithContext(ctx, api) +} + // DeleteStickerSetP holds parameters for the deleteStickerSet method. // See https://core.telegram.org/bots/api#deletestickerset type DeleteStickerSetP struct { @@ -255,3 +385,11 @@ func (api *API) DeleteStickerSet(params DeleteStickerSetP) (bool, error) { req := NewRequest[bool]("deleteStickerSet", params) return req.Do(api) } + +// DeleteStickerSetWithContext is the context-aware variant of DeleteStickerSet. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#deletestickerset +func (api *API) DeleteStickerSetWithContext(ctx context.Context, params DeleteStickerSetP) (bool, error) { + req := NewRequest[bool]("deleteStickerSet", params) + return req.DoWithContext(ctx, api) +} diff --git a/tgapi/uploader_api.go b/tgapi/uploader_api.go index a950030..732b894 100644 --- a/tgapi/uploader_api.go +++ b/tgapi/uploader_api.go @@ -30,6 +30,8 @@ const ( UploaderThumbnailType UploaderFileType = "thumbnail" // UploaderStickerType is the multipart field name for sticker uploads. UploaderStickerType UploaderFileType = "sticker" + // UploaderCertificateType is the multipart field name for webhook certificate uploads. + UploaderCertificateType UploaderFileType = "certificate" ) // UploaderFileType represents the Telegram form field name for a file upload. diff --git a/tgapi/uploader_methods.go b/tgapi/uploader_methods.go index 0ab9547..ba78abb 100644 --- a/tgapi/uploader_methods.go +++ b/tgapi/uploader_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // UploadPhotoP holds parameters for uploading a photo using the Uploader. // See https://core.telegram.org/bots/api#sendphoto type UploadPhotoP struct { @@ -32,6 +34,16 @@ func (u *Uploader) SendPhoto(params UploadPhotoP, file UploaderFile) (Message, e return req.Do(u) } +// SendPhotoWithContext is the context-aware variant of SendPhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// SendPhotoWithContext is the context-aware variant of SendPhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendphoto +func (u *Uploader) SendPhotoWithContext(ctx context.Context, params UploadPhotoP, file UploaderFile) (Message, error) { + req := NewUploaderRequestWithChatID[Message]("sendPhoto", params, params.ChatID, file) + return req.DoWithContext(ctx, u) +} + // UploadAudioP holds parameters for uploading an audio file using the Uploader. // See https://core.telegram.org/bots/api#sendaudio type UploadAudioP struct { @@ -66,6 +78,16 @@ func (u *Uploader) SendAudio(params UploadAudioP, files ...UploaderFile) (Messag return req.Do(u) } +// SendAudioWithContext is the context-aware variant of SendAudio. +// It executes the same request but uses ctx for cancellation and deadlines. +// SendAudioWithContext is the context-aware variant of SendAudio. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendaudio +func (u *Uploader) SendAudioWithContext(ctx context.Context, params UploadAudioP, files ...UploaderFile) (Message, error) { + req := NewUploaderRequestWithChatID[Message]("sendAudio", params, params.ChatID, files...) + return req.DoWithContext(ctx, u) +} + // UploadDocumentP holds parameters for uploading a document using the Uploader. // See https://core.telegram.org/bots/api#senddocument type UploadDocumentP struct { @@ -97,6 +119,16 @@ func (u *Uploader) SendDocument(params UploadDocumentP, files ...UploaderFile) ( return req.Do(u) } +// SendDocumentWithContext is the context-aware variant of SendDocument. +// It executes the same request but uses ctx for cancellation and deadlines. +// SendDocumentWithContext is the context-aware variant of SendDocument. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#senddocument +func (u *Uploader) SendDocumentWithContext(ctx context.Context, params UploadDocumentP, files ...UploaderFile) (Message, error) { + req := NewUploaderRequestWithChatID[Message]("sendDocument", params, params.ChatID, files...) + return req.DoWithContext(ctx, u) +} + // UploadVideoP holds parameters for uploading a video using the Uploader. // See https://core.telegram.org/bots/api#sendvideo type UploadVideoP struct { @@ -135,6 +167,16 @@ func (u *Uploader) SendVideo(params UploadVideoP, files ...UploaderFile) (Messag return req.Do(u) } +// SendVideoWithContext is the context-aware variant of SendVideo. +// It executes the same request but uses ctx for cancellation and deadlines. +// SendVideoWithContext is the context-aware variant of SendVideo. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendvideo +func (u *Uploader) SendVideoWithContext(ctx context.Context, params UploadVideoP, files ...UploaderFile) (Message, error) { + req := NewUploaderRequestWithChatID[Message]("sendVideo", params, params.ChatID, files...) + return req.DoWithContext(ctx, u) +} + // UploadAnimationP holds parameters for uploading an animation using the Uploader. // See https://core.telegram.org/bots/api#sendanimation type UploadAnimationP struct { @@ -171,6 +213,16 @@ func (u *Uploader) SendAnimation(params UploadAnimationP, files ...UploaderFile) return req.Do(u) } +// SendAnimationWithContext is the context-aware variant of SendAnimation. +// It executes the same request but uses ctx for cancellation and deadlines. +// SendAnimationWithContext is the context-aware variant of SendAnimation. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendanimation +func (u *Uploader) SendAnimationWithContext(ctx context.Context, params UploadAnimationP, files ...UploaderFile) (Message, error) { + req := NewUploaderRequestWithChatID[Message]("sendAnimation", params, params.ChatID, files...) + return req.DoWithContext(ctx, u) +} + // UploadVoiceP holds parameters for uploading a voice note using the Uploader. // See https://core.telegram.org/bots/api#sendvoice type UploadVoiceP struct { @@ -202,6 +254,16 @@ func (u *Uploader) SendVoice(params UploadVoiceP, files ...UploaderFile) (Messag return req.Do(u) } +// SendVoiceWithContext is the context-aware variant of SendVoice. +// It executes the same request but uses ctx for cancellation and deadlines. +// SendVoiceWithContext is the context-aware variant of SendVoice. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendvoice +func (u *Uploader) SendVoiceWithContext(ctx context.Context, params UploadVoiceP, files ...UploaderFile) (Message, error) { + req := NewUploaderRequestWithChatID[Message]("sendVoice", params, params.ChatID, files...) + return req.DoWithContext(ctx, u) +} + // UploadVideoNoteP holds parameters for uploading a video note (rounded video) using the Uploader. // See https://core.telegram.org/bots/api#sendvideonote type UploadVideoNoteP struct { @@ -231,6 +293,16 @@ func (u *Uploader) SendVideoNote(params UploadVideoNoteP, files ...UploaderFile) return req.Do(u) } +// SendVideoNoteWithContext is the context-aware variant of SendVideoNote. +// It executes the same request but uses ctx for cancellation and deadlines. +// SendVideoNoteWithContext is the context-aware variant of SendVideoNote. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#sendvideonote +func (u *Uploader) SendVideoNoteWithContext(ctx context.Context, params UploadVideoNoteP, files ...UploaderFile) (Message, error) { + req := NewUploaderRequestWithChatID[Message]("sendVideoNote", params, params.ChatID, files...) + return req.DoWithContext(ctx, u) +} + // UploadChatPhotoP holds parameters for uploading a chat photo using the Uploader. // See https://core.telegram.org/bots/api#setchatphoto type UploadChatPhotoP struct { @@ -244,3 +316,41 @@ func (u *Uploader) SetChatPhoto(params UploadChatPhotoP, photo UploaderFile) (bo req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo) return req.Do(u) } + +// SetChatPhotoWithContext is the context-aware variant of SetChatPhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// SetChatPhotoWithContext is the context-aware variant of SetChatPhoto. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setchatphoto +func (u *Uploader) SetChatPhotoWithContext(ctx context.Context, params UploadChatPhotoP, photo UploaderFile) (bool, error) { + req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo) + return req.DoWithContext(ctx, u) +} + +// UploadSetWebhookP holds multipart parameters for the setWebhook method. +// Use this type when uploading a self-signed certificate file. +// See https://core.telegram.org/bots/api#setwebhook +type UploadSetWebhookP struct { + URL string `json:"url"` + IPAddress string `json:"ip_address,omitempty"` + MaxConnections int `json:"max_connections,omitempty"` + AllowedUpdates []UpdateType `json:"allowed_updates,omitempty"` + DropPendingUpdates bool `json:"drop_pending_updates,omitempty"` + SecretToken string `json:"secret_token,omitempty"` +} + +// SetWebhook uploads a certificate and sets a webhook URL. +// certificate maps to the multipart field \"certificate\". +// See https://core.telegram.org/bots/api#setwebhook +func (u *Uploader) SetWebhook(params UploadSetWebhookP, certificate UploaderFile) (bool, error) { + req := NewUploaderRequest[bool]("setWebhook", params, certificate.SetType(UploaderCertificateType)) + return req.Do(u) +} + +// SetWebhookWithContext is the context-aware variant of SetWebhook. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setwebhook +func (u *Uploader) SetWebhookWithContext(ctx context.Context, params UploadSetWebhookP, certificate UploaderFile) (bool, error) { + req := NewUploaderRequest[bool]("setWebhook", params, certificate.SetType(UploaderCertificateType)) + return req.DoWithContext(ctx, u) +} diff --git a/tgapi/users_methods.go b/tgapi/users_methods.go index ff5ea01..08c883b 100644 --- a/tgapi/users_methods.go +++ b/tgapi/users_methods.go @@ -1,5 +1,7 @@ package tgapi +import "context" + // GetUserProfilePhotosP holds parameters for the GetUserProfilePhotos method. // See https://core.telegram.org/bots/api#getuserprofilephotos type GetUserProfilePhotosP struct { @@ -15,6 +17,14 @@ func (api *API) GetUserProfilePhotos(params GetUserProfilePhotosP) (UserProfileP return req.Do(api) } +// GetUserProfilePhotosWithContext is the context-aware variant of GetUserProfilePhotos. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getuserprofilephotos +func (api *API) GetUserProfilePhotosWithContext(ctx context.Context, params GetUserProfilePhotosP) (UserProfilePhotos, error) { + req := NewRequest[UserProfilePhotos]("getUserProfilePhotos", params) + return req.DoWithContext(ctx, api) +} + // GetUserProfileAudiosP holds parameters for the GetUserProfileAudios method. // See https://core.telegram.org/bots/api#getuserprofileaudios type GetUserProfileAudiosP struct { @@ -30,6 +40,14 @@ func (api *API) GetUserProfileAudios(params GetUserProfileAudiosP) (UserProfileA return req.Do(api) } +// GetUserProfileAudiosWithContext is the context-aware variant of GetUserProfileAudios. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getuserprofileaudios +func (api *API) GetUserProfileAudiosWithContext(ctx context.Context, params GetUserProfileAudiosP) (UserProfileAudios, error) { + req := NewRequest[UserProfileAudios]("getUserProfileAudios", params) + return req.DoWithContext(ctx, api) +} + // SetUserEmojiStatusP holds parameters for the SetUserEmojiStatus method. // See https://core.telegram.org/bots/api#setuseremojistatus type SetUserEmojiStatusP struct { @@ -46,6 +64,14 @@ func (api *API) SetUserEmojiStatus(params SetUserEmojiStatusP) (bool, error) { return req.Do(api) } +// SetUserEmojiStatusWithContext is the context-aware variant of SetUserEmojiStatus. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#setuseremojistatus +func (api *API) SetUserEmojiStatusWithContext(ctx context.Context, params SetUserEmojiStatusP) (bool, error) { + req := NewRequest[bool]("setUserEmojiStatus", params) + return req.DoWithContext(ctx, api) +} + // GetUserGiftsP holds parameters for the GetUserGifts method. // See https://core.telegram.org/bots/api#getusergifts type GetUserGiftsP struct { @@ -66,3 +92,11 @@ func (api *API) GetUserGifts(params GetUserGiftsP) (OwnedGifts, error) { req := NewRequest[OwnedGifts]("getUserGifts", params) return req.Do(api) } + +// GetUserGiftsWithContext is the context-aware variant of GetUserGifts. +// It executes the same request but uses ctx for cancellation and deadlines. +// See https://core.telegram.org/bots/api#getusergifts +func (api *API) GetUserGiftsWithContext(ctx context.Context, params GetUserGiftsP) (OwnedGifts, error) { + req := NewRequest[OwnedGifts]("getUserGifts", params) + return req.DoWithContext(ctx, api) +} diff --git a/utils/version.go b/utils/version.go index fec1438..f335c22 100644 --- a/utils/version.go +++ b/utils/version.go @@ -1,9 +1,9 @@ package utils const ( - VersionString = "1.0.0-rc.3" + VersionString = "1.0.0-rc.4" VersionMajor = 1 VersionMinor = 0 VersionPatch = 0 - VersionBeta = 3 + VersionBeta = 4 )