telegram-bot-api/configs.go

1986 lines
50 KiB
Go
Raw Normal View History

2015-11-20 11:42:26 +01:00
package tgbotapi
import (
"io"
"net/url"
2020-01-25 04:42:19 +01:00
"strconv"
2015-11-20 11:42:26 +01:00
)
// Telegram constants
const (
// APIEndpoint is the endpoint for all API methods,
// with formatting for Sprintf.
2015-11-20 11:42:26 +01:00
APIEndpoint = "https://api.telegram.org/bot%s/%s"
// FileEndpoint is the endpoint for downloading a file from Telegram.
2015-11-20 11:42:26 +01:00
FileEndpoint = "https://api.telegram.org/file/bot%s/%s"
)
// Constant values for ChatActions
const (
2020-07-21 20:46:14 +02:00
ChatTyping = "typing"
ChatUploadPhoto = "upload_photo"
ChatRecordVideo = "record_video"
ChatUploadVideo = "upload_video"
ChatRecordAudio = "record_audio"
ChatUploadAudio = "upload_audio"
ChatUploadDocument = "upload_document"
ChatFindLocation = "find_location"
ChatRecordVideoNote = "record_video_note"
ChatUploadVideoNote = "upload_video_note"
2015-11-20 11:42:26 +01:00
)
// API errors
const (
// ErrAPIForbidden happens when a token is bad
ErrAPIForbidden = "forbidden"
2015-11-20 11:42:26 +01:00
)
// Constant values for ParseMode in MessageConfig
const (
2020-01-06 08:44:13 +01:00
ModeMarkdown = "Markdown"
ModeMarkdownV2 = "MarkdownV2"
ModeHTML = "HTML"
2015-11-20 11:42:26 +01:00
)
// Library errors
const (
// ErrBadFileType happens when you pass an unknown type
ErrBadFileType = "bad file type"
2016-04-14 00:06:18 +02:00
ErrBadURL = "bad or empty url"
)
// Chattable is any config type that can be sent.
2015-11-20 15:08:53 +01:00
type Chattable interface {
params() (Params, error)
method() string
2015-11-20 15:08:53 +01:00
}
// Fileable is any config type that can be sent that includes a file.
2015-11-20 15:08:53 +01:00
type Fileable interface {
Chattable
name() string
getFile() interface{}
useExistingFile() bool
2015-11-20 15:08:53 +01:00
}
2020-11-05 22:53:37 +01:00
// LogOutConfig is a request to log out of the cloud Bot API server.
//
// Note that you may not log back in for at least 10 minutes.
type LogOutConfig struct{}
func (LogOutConfig) method() string {
return "logOut"
}
func (LogOutConfig) params() (Params, error) {
return nil, nil
}
// CloseConfig is a request to close the bot instance on a local server.
//
// Note that you may not close an instance for the first 10 minutes after the
// bot has started.
type CloseConfig struct{}
func (CloseConfig) method() string {
return "close"
}
func (CloseConfig) params() (Params, error) {
return nil, nil
}
// BaseChat is base type for all chat config types.
2015-11-20 15:08:53 +01:00
type BaseChat struct {
2020-11-05 22:53:37 +01:00
ChatID int64 // required
ChannelUsername string
ReplyToMessageID int
ReplyMarkup interface{}
DisableNotification bool
AllowSendingWithoutReply bool
2015-11-20 11:42:26 +01:00
}
func (chat *BaseChat) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2015-11-20 16:30:50 +01:00
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", chat.ChatID, chat.ChannelUsername)
params.AddNonZero("reply_to_message_id", chat.ReplyToMessageID)
params.AddBool("disable_notification", chat.DisableNotification)
2020-11-05 22:53:37 +01:00
params.AddBool("allow_sending_without_reply", chat.AllowSendingWithoutReply)
2015-11-20 16:30:50 +01:00
2018-10-09 01:37:18 +02:00
err := params.AddInterface("reply_markup", chat.ReplyMarkup)
2015-11-20 16:30:50 +01:00
2018-10-09 01:37:18 +02:00
return params, err
2015-11-20 12:06:51 +01:00
}
// BaseFile is a base type for all file config types.
2015-11-20 15:08:53 +01:00
type BaseFile struct {
BaseChat
File interface{}
FileID string
UseExisting bool
MimeType string
FileSize int
2015-11-20 15:08:53 +01:00
}
func (file BaseFile) params() (Params, error) {
params, err := file.BaseChat.params()
params.AddNonEmpty("mime_type", file.MimeType)
params.AddNonZero("file_size", file.FileSize)
return params, err
2015-11-20 15:08:53 +01:00
}
func (file BaseFile) getFile() interface{} {
2016-01-04 05:48:52 +01:00
return file.File
2015-11-20 15:08:53 +01:00
}
func (file BaseFile) useExistingFile() bool {
2015-11-20 15:31:01 +01:00
return file.UseExisting
}
2016-04-12 19:53:19 +02:00
// BaseEdit is base type of all chat edits.
type BaseEdit struct {
ChatID int64
ChannelUsername string
MessageID int
InlineMessageID string
ReplyMarkup *InlineKeyboardMarkup
}
func (edit BaseEdit) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2016-04-12 19:53:19 +02:00
if edit.InlineMessageID != "" {
2018-10-09 01:37:18 +02:00
params["inline_message_id"] = edit.InlineMessageID
2016-04-12 19:53:19 +02:00
} else {
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", edit.ChatID, edit.ChannelUsername)
params.AddNonZero("message_id", edit.MessageID)
2016-04-12 19:53:19 +02:00
}
2018-10-09 01:37:18 +02:00
err := params.AddInterface("reply_markup", edit.ReplyMarkup)
2016-04-12 19:53:19 +02:00
2018-10-09 01:37:18 +02:00
return params, err
2016-04-12 19:53:19 +02:00
}
2015-11-20 11:42:26 +01:00
// MessageConfig contains information about a SendMessage request.
type MessageConfig struct {
2015-11-20 15:08:53 +01:00
BaseChat
2015-11-20 11:42:26 +01:00
Text string
ParseMode string
2020-11-05 22:53:37 +01:00
Entities []MessageEntity
2015-11-20 11:42:26 +01:00
DisableWebPagePreview bool
}
func (config MessageConfig) params() (Params, error) {
params, err := config.BaseChat.params()
if err != nil {
return params, err
}
params.AddNonEmpty("text", config.Text)
params.AddBool("disable_web_page_preview", config.DisableWebPagePreview)
params.AddNonEmpty("parse_mode", config.ParseMode)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("entities", config.Entities)
2015-11-20 12:06:51 +01:00
2020-11-05 22:53:37 +01:00
return params, err
2015-11-20 12:06:51 +01:00
}
func (config MessageConfig) method() string {
return "sendMessage"
2015-11-20 15:55:32 +01:00
}
2015-11-20 11:42:26 +01:00
// ForwardConfig contains information about a ForwardMessage request.
type ForwardConfig struct {
2015-11-20 15:08:53 +01:00
BaseChat
2016-03-24 19:22:40 +01:00
FromChatID int64 // required
2015-11-20 11:42:26 +01:00
FromChannelUsername string
MessageID int // required
2015-11-20 11:42:26 +01:00
}
func (config ForwardConfig) params() (Params, error) {
params, err := config.BaseChat.params()
if err != nil {
return params, err
}
params.AddNonZero64("from_chat_id", config.FromChatID)
params.AddNonZero("message_id", config.MessageID)
return params, nil
2015-11-20 12:06:51 +01:00
}
func (config ForwardConfig) method() string {
2015-11-20 15:55:32 +01:00
return "forwardMessage"
}
2020-11-05 22:53:37 +01:00
// CopyMessageConfig contains information about a copyMessage request.
type CopyMessageConfig struct {
BaseChat
FromChatID int64
FromChannelUsername string
MessageID int
Caption string
ParseMode string
CaptionEntities []MessageEntity
}
func (config CopyMessageConfig) params() (Params, error) {
params, err := config.BaseChat.params()
if err != nil {
return params, err
}
params.AddFirstValid("from_chat_id", config.FromChatID, config.FromChannelUsername)
params.AddNonZero("message_id", config.MessageID)
params.AddNonEmpty("caption", config.Caption)
params.AddNonEmpty("parse_mode", config.ParseMode)
err = params.AddInterface("caption_entities", config.CaptionEntities)
return params, err
}
2020-11-06 18:36:00 +01:00
func (config CopyMessageConfig) method() string {
return "copyMessage"
}
2015-11-20 11:42:26 +01:00
// PhotoConfig contains information about a SendPhoto request.
type PhotoConfig struct {
2015-11-20 15:08:53 +01:00
BaseFile
2020-11-05 22:53:37 +01:00
Caption string
ParseMode string
CaptionEntities []MessageEntity
2015-11-20 11:42:26 +01:00
}
func (config PhotoConfig) params() (Params, error) {
params, err := config.BaseFile.params()
2020-11-05 22:53:37 +01:00
if err != nil {
return params, err
}
2015-11-20 12:06:51 +01:00
params.AddNonEmpty(config.name(), config.FileID)
params.AddNonEmpty("caption", config.Caption)
params.AddNonEmpty("parse_mode", config.ParseMode)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("caption_entities", config.CaptionEntities)
return params, err
2015-11-20 12:06:51 +01:00
}
func (config PhotoConfig) name() string {
2015-11-20 15:31:01 +01:00
return "photo"
}
func (config PhotoConfig) method() string {
return "sendPhoto"
2015-11-20 15:55:32 +01:00
}
2015-11-20 11:42:26 +01:00
// AudioConfig contains information about a SendAudio request.
type AudioConfig struct {
2015-11-20 15:08:53 +01:00
BaseFile
2020-11-05 22:53:37 +01:00
Caption string
ParseMode string
CaptionEntities []MessageEntity
Duration int
Performer string
Title string
2015-11-20 11:42:26 +01:00
}
func (config AudioConfig) params() (Params, error) {
params, err := config.BaseChat.params()
if err != nil {
return params, err
}
2015-11-20 12:06:51 +01:00
params.AddNonEmpty(config.name(), config.FileID)
params.AddNonZero("duration", config.Duration)
params.AddNonEmpty("performer", config.Performer)
params.AddNonEmpty("title", config.Title)
params.AddNonEmpty("caption", config.Caption)
params.AddNonEmpty("parse_mode", config.ParseMode)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("caption_entities", config.CaptionEntities)
2015-11-20 12:06:51 +01:00
2020-11-05 22:53:37 +01:00
return params, err
2015-11-20 12:06:51 +01:00
}
func (config AudioConfig) name() string {
2015-11-20 15:31:01 +01:00
return "audio"
}
func (config AudioConfig) method() string {
return "sendAudio"
2015-11-20 15:55:32 +01:00
}
2015-11-20 11:42:26 +01:00
// DocumentConfig contains information about a SendDocument request.
type DocumentConfig struct {
2015-11-20 15:08:53 +01:00
BaseFile
2020-11-05 22:53:37 +01:00
Caption string
ParseMode string
CaptionEntities []MessageEntity
DisableContentTypeDetection bool
2015-11-20 11:42:26 +01:00
}
func (config DocumentConfig) params() (Params, error) {
params, err := config.BaseFile.params()
2017-02-11 15:13:49 +01:00
params.AddNonEmpty(config.name(), config.FileID)
params.AddNonEmpty("caption", config.Caption)
params.AddNonEmpty("parse_mode", config.ParseMode)
2020-11-05 22:53:37 +01:00
params.AddBool("disable_content_type_detection", config.DisableContentTypeDetection)
return params, err
2015-11-20 15:08:53 +01:00
}
func (config DocumentConfig) name() string {
2015-11-20 15:31:01 +01:00
return "document"
}
func (config DocumentConfig) method() string {
2015-11-20 15:55:32 +01:00
return "sendDocument"
}
2015-11-20 11:42:26 +01:00
// StickerConfig contains information about a SendSticker request.
type StickerConfig struct {
2015-11-20 15:08:53 +01:00
BaseFile
2015-11-20 11:42:26 +01:00
}
func (config StickerConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2015-11-20 12:06:51 +01:00
params.AddNonEmpty(config.name(), config.FileID)
2015-11-20 15:08:53 +01:00
return params, err
2015-11-20 15:08:53 +01:00
}
func (config StickerConfig) name() string {
2015-11-20 15:31:01 +01:00
return "sticker"
}
func (config StickerConfig) method() string {
2015-11-20 15:55:32 +01:00
return "sendSticker"
}
2015-11-20 11:42:26 +01:00
// VideoConfig contains information about a SendVideo request.
type VideoConfig struct {
2015-11-20 15:08:53 +01:00
BaseFile
Duration int
Caption string
ParseMode string
2020-11-05 22:53:37 +01:00
CaptionEntities []MessageEntity
SupportsStreaming bool
2015-11-20 11:42:26 +01:00
}
func (config VideoConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2020-11-05 22:53:37 +01:00
if err != nil {
return params, err
}
2015-11-20 12:06:51 +01:00
params.AddNonEmpty(config.name(), config.FileID)
params.AddNonZero("duration", config.Duration)
params.AddNonEmpty("caption", config.Caption)
params.AddNonEmpty("parse_mode", config.ParseMode)
params.AddBool("supports_streaming", config.SupportsStreaming)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("caption_entities", config.CaptionEntities)
2015-11-20 12:06:51 +01:00
return params, err
2015-11-20 15:08:53 +01:00
}
func (config VideoConfig) name() string {
2015-11-20 16:30:50 +01:00
return "video"
2015-11-20 15:31:01 +01:00
}
func (config VideoConfig) method() string {
2015-11-20 15:55:32 +01:00
return "sendVideo"
}
2018-09-06 14:44:42 +02:00
// AnimationConfig contains information about a SendAnimation request.
type AnimationConfig struct {
BaseFile
2020-11-05 22:53:37 +01:00
Duration int
Caption string
ParseMode string
CaptionEntities []MessageEntity
2018-09-06 14:44:42 +02:00
}
func (config AnimationConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2020-11-05 22:53:37 +01:00
if err != nil {
return params, err
}
2018-09-06 14:44:42 +02:00
params.AddNonEmpty(config.name(), config.FileID)
params.AddNonZero("duration", config.Duration)
params.AddNonEmpty("caption", config.Caption)
params.AddNonEmpty("parse_mode", config.ParseMode)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("caption_entities", config.CaptionEntities)
2018-09-06 14:44:42 +02:00
return params, err
2018-09-06 14:44:42 +02:00
}
func (config AnimationConfig) name() string {
return "animation"
}
func (config AnimationConfig) method() string {
return "sendAnimation"
}
2017-05-22 00:04:12 +02:00
// VideoNoteConfig contains information about a SendVideoNote request.
type VideoNoteConfig struct {
BaseFile
Duration int
Length int
}
func (config VideoNoteConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2017-05-22 00:04:12 +02:00
params.AddNonEmpty(config.name(), config.FileID)
params.AddNonZero("duration", config.Duration)
params.AddNonZero("length", config.Length)
2017-05-22 00:04:12 +02:00
return params, err
2017-05-22 00:04:12 +02:00
}
func (config VideoNoteConfig) name() string {
return "video_note"
}
func (config VideoNoteConfig) method() string {
return "sendVideoNote"
}
2015-11-20 11:42:26 +01:00
// VoiceConfig contains information about a SendVoice request.
type VoiceConfig struct {
2015-11-20 15:08:53 +01:00
BaseFile
2020-11-05 22:53:37 +01:00
Caption string
ParseMode string
CaptionEntities []MessageEntity
Duration int
2015-11-20 11:42:26 +01:00
}
func (config VoiceConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2020-11-05 22:53:37 +01:00
if err != nil {
return params, err
}
2015-11-20 15:08:53 +01:00
params.AddNonEmpty(config.name(), config.FileID)
params.AddNonZero("duration", config.Duration)
params.AddNonEmpty("caption", config.Caption)
params.AddNonEmpty("parse_mode", config.ParseMode)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("caption_entities", config.CaptionEntities)
2015-11-20 15:08:53 +01:00
return params, err
2015-11-20 15:08:53 +01:00
}
func (config VoiceConfig) name() string {
2015-11-20 15:31:01 +01:00
return "voice"
}
func (config VoiceConfig) method() string {
2015-11-20 15:55:32 +01:00
return "sendVoice"
}
2015-11-20 11:42:26 +01:00
// LocationConfig contains information about a SendLocation request.
type LocationConfig struct {
2015-11-20 15:08:53 +01:00
BaseChat
2020-11-05 22:53:37 +01:00
Latitude float64 // required
Longitude float64 // required
HorizontalAccuracy float64 // optional
LivePeriod int // optional
Heading int // optional
ProximityAlertRadius int // optional
2015-11-20 11:42:26 +01:00
}
func (config LocationConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2015-11-20 12:06:51 +01:00
params.AddNonZeroFloat("latitude", config.Latitude)
params.AddNonZeroFloat("longitude", config.Longitude)
2020-11-05 22:53:37 +01:00
params.AddNonZeroFloat("horizontal_accuracy", config.HorizontalAccuracy)
params.AddNonZero("live_period", config.LivePeriod)
2020-11-05 22:53:37 +01:00
params.AddNonZero("heading", config.Heading)
params.AddNonZero("proximity_alert_radius", config.ProximityAlertRadius)
2015-11-20 12:19:37 +01:00
return params, err
2015-11-20 12:06:51 +01:00
}
func (config LocationConfig) method() string {
2015-11-20 15:55:32 +01:00
return "sendLocation"
}
2017-12-30 00:06:33 +01:00
// EditMessageLiveLocationConfig allows you to update a live location.
type EditMessageLiveLocationConfig struct {
BaseEdit
2020-11-05 22:53:37 +01:00
Latitude float64 // required
Longitude float64 // required
HorizontalAccuracy float64 // optional
Heading int // optional
ProximityAlertRadius int // optional
}
func (config EditMessageLiveLocationConfig) params() (Params, error) {
params, err := config.BaseEdit.params()
params.AddNonZeroFloat("latitude", config.Latitude)
params.AddNonZeroFloat("longitude", config.Longitude)
2020-11-05 22:53:37 +01:00
params.AddNonZeroFloat("horizontal_accuracy", config.HorizontalAccuracy)
params.AddNonZero("heading", config.Heading)
params.AddNonZero("proximity_alert_radius", config.ProximityAlertRadius)
return params, err
}
func (config EditMessageLiveLocationConfig) method() string {
return "editMessageLiveLocation"
}
2017-12-30 00:06:33 +01:00
// StopMessageLiveLocationConfig stops updating a live location.
type StopMessageLiveLocationConfig struct {
BaseEdit
}
func (config StopMessageLiveLocationConfig) params() (Params, error) {
return config.BaseEdit.params()
}
func (config StopMessageLiveLocationConfig) method() string {
return "stopMessageLiveLocation"
}
2016-04-12 15:28:46 +02:00
// VenueConfig contains information about a SendVenue request.
type VenueConfig struct {
BaseChat
2020-11-05 22:53:37 +01:00
Latitude float64 // required
Longitude float64 // required
Title string // required
Address string // required
FoursquareID string
FoursquareType string
GooglePlaceID string
GooglePlaceType string
2016-04-12 15:28:46 +02:00
}
func (config VenueConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2016-04-12 15:28:46 +02:00
params.AddNonZeroFloat("latitude", config.Latitude)
params.AddNonZeroFloat("longitude", config.Longitude)
params["title"] = config.Title
params["address"] = config.Address
params.AddNonEmpty("foursquare_id", config.FoursquareID)
2020-11-05 22:53:37 +01:00
params.AddNonEmpty("foursquare_type", config.FoursquareType)
params.AddNonEmpty("google_place_id", config.GooglePlaceID)
params.AddNonEmpty("google_place_type", config.GooglePlaceType)
2016-04-12 15:28:46 +02:00
return params, err
2016-04-12 15:28:46 +02:00
}
func (config VenueConfig) method() string {
return "sendVenue"
}
2016-04-12 20:02:08 +02:00
// ContactConfig allows you to send a contact.
type ContactConfig struct {
BaseChat
PhoneNumber string
FirstName string
LastName string
VCard string
2016-04-12 20:02:08 +02:00
}
func (config ContactConfig) params() (Params, error) {
params, err := config.BaseChat.params()
params["phone_number"] = config.PhoneNumber
params["first_name"] = config.FirstName
2016-04-12 20:02:08 +02:00
params.AddNonEmpty("last_name", config.LastName)
params.AddNonEmpty("vcard", config.VCard)
2016-04-12 20:02:08 +02:00
return params, err
2016-04-12 20:02:08 +02:00
}
func (config ContactConfig) method() string {
return "sendContact"
}
// SendPollConfig allows you to send a poll.
type SendPollConfig struct {
BaseChat
2020-01-25 04:42:19 +01:00
Question string
Options []string
IsAnonymous bool
Type string
AllowsMultipleAnswers bool
CorrectOptionID int64
2020-04-24 20:18:26 +02:00
Explanation string
ExplanationParseMode string
2020-11-05 22:53:37 +01:00
ExplanationEntities []MessageEntity
2020-04-24 20:18:26 +02:00
OpenPeriod int
CloseDate int
2020-01-25 04:42:19 +01:00
IsClosed bool
}
func (config SendPollConfig) params() (Params, error) {
params, err := config.BaseChat.params()
if err != nil {
return params, err
}
params["question"] = config.Question
2020-11-05 22:53:37 +01:00
if err = params.AddInterface("options", config.Options); err != nil {
return params, err
}
2020-01-25 04:42:19 +01:00
params["is_anonymous"] = strconv.FormatBool(config.IsAnonymous)
params.AddNonEmpty("type", config.Type)
params["allows_multiple_answers"] = strconv.FormatBool(config.AllowsMultipleAnswers)
params["correct_option_id"] = strconv.FormatInt(config.CorrectOptionID, 10)
2020-01-25 04:44:44 +01:00
params.AddBool("is_closed", config.IsClosed)
2020-04-24 20:18:26 +02:00
params.AddNonEmpty("explanation", config.Explanation)
params.AddNonEmpty("explanation_parse_mode", config.ExplanationParseMode)
params.AddNonZero("open_period", config.OpenPeriod)
params.AddNonZero("close_date", config.CloseDate)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("explanation_entities", config.ExplanationEntities)
return params, err
}
func (SendPollConfig) method() string {
return "sendPoll"
}
// GameConfig allows you to send a game.
type GameConfig struct {
BaseChat
GameShortName string
}
func (config GameConfig) params() (Params, error) {
params, err := config.BaseChat.params()
params["game_short_name"] = config.GameShortName
return params, err
}
func (config GameConfig) method() string {
return "sendGame"
}
// SetGameScoreConfig allows you to update the game score in a chat.
type SetGameScoreConfig struct {
2021-03-09 18:38:15 +01:00
UserID int64
Score int
Force bool
DisableEditMessage bool
ChatID int64
ChannelUsername string
MessageID int
InlineMessageID string
}
func (config SetGameScoreConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
2018-10-09 01:37:18 +02:00
params.AddNonZero("scrore", config.Score)
params.AddBool("disable_edit_message", config.DisableEditMessage)
if config.InlineMessageID != "" {
2018-10-09 01:37:18 +02:00
params["inline_message_id"] = config.InlineMessageID
} else {
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
params.AddNonZero("message_id", config.MessageID)
}
2018-10-09 01:37:18 +02:00
return params, nil
}
func (config SetGameScoreConfig) method() string {
return "setGameScore"
}
// GetGameHighScoresConfig allows you to fetch the high scores for a game.
type GetGameHighScoresConfig struct {
2021-03-09 18:38:15 +01:00
UserID int64
ChatID int64
ChannelUsername string
MessageID int
InlineMessageID string
}
func (config GetGameHighScoresConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
if config.InlineMessageID != "" {
2018-10-09 01:37:18 +02:00
params["inline_message_id"] = config.InlineMessageID
} else {
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
params.AddNonZero("message_id", config.MessageID)
}
2018-10-09 01:37:18 +02:00
return params, nil
}
func (config GetGameHighScoresConfig) method() string {
return "getGameHighScores"
}
2015-11-20 11:42:26 +01:00
// ChatActionConfig contains information about a SendChatAction request.
type ChatActionConfig struct {
2015-11-20 15:08:53 +01:00
BaseChat
Action string // required
2015-11-20 11:42:26 +01:00
}
func (config ChatActionConfig) params() (Params, error) {
params, err := config.BaseChat.params()
params["action"] = config.Action
return params, err
2015-11-20 12:06:51 +01:00
}
func (config ChatActionConfig) method() string {
2015-11-21 12:44:26 +01:00
return "sendChatAction"
}
2016-04-12 19:53:19 +02:00
// EditMessageTextConfig allows you to modify the text in a message.
type EditMessageTextConfig struct {
BaseEdit
Text string
ParseMode string
2020-11-05 22:53:37 +01:00
Entities []MessageEntity
2016-04-12 19:53:19 +02:00
DisableWebPagePreview bool
}
func (config EditMessageTextConfig) params() (Params, error) {
params, err := config.BaseEdit.params()
2020-11-05 22:53:37 +01:00
if err != nil {
return params, err
}
2016-04-12 19:53:19 +02:00
params["text"] = config.Text
params.AddNonEmpty("parse_mode", config.ParseMode)
params.AddBool("disable_web_page_preview", config.DisableWebPagePreview)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("entities", config.Entities)
2016-04-12 19:53:19 +02:00
return params, err
2016-04-12 19:53:19 +02:00
}
func (config EditMessageTextConfig) method() string {
return "editMessageText"
}
// EditMessageCaptionConfig allows you to modify the caption of a message.
type EditMessageCaptionConfig struct {
BaseEdit
2020-11-05 22:53:37 +01:00
Caption string
ParseMode string
CaptionEntities []MessageEntity
2016-04-12 19:53:19 +02:00
}
func (config EditMessageCaptionConfig) params() (Params, error) {
params, err := config.BaseEdit.params()
2020-11-05 22:53:37 +01:00
if err != nil {
return params, err
}
2016-04-12 19:53:19 +02:00
params["caption"] = config.Caption
params.AddNonEmpty("parse_mode", config.ParseMode)
2020-11-05 22:53:37 +01:00
err = params.AddInterface("caption_entities", config.CaptionEntities)
2016-04-12 19:53:19 +02:00
return params, err
2016-04-12 19:53:19 +02:00
}
func (config EditMessageCaptionConfig) method() string {
return "editMessageCaption"
}
// EditMessageMediaConfig contains information about editing a message's media.
type EditMessageMediaConfig struct {
BaseEdit
Media interface{}
}
func (EditMessageMediaConfig) method() string {
return "editMessageMedia"
}
func (config EditMessageMediaConfig) params() (Params, error) {
params, err := config.BaseEdit.params()
params.AddInterface("media", config.Media)
return params, err
}
// EditMessageReplyMarkupConfig allows you to modify the reply markup
2016-04-12 19:53:19 +02:00
// of a message.
type EditMessageReplyMarkupConfig struct {
2016-04-12 19:53:19 +02:00
BaseEdit
}
func (config EditMessageReplyMarkupConfig) params() (Params, error) {
return config.BaseEdit.params()
2016-04-12 19:53:19 +02:00
}
func (config EditMessageReplyMarkupConfig) method() string {
2016-04-12 19:53:19 +02:00
return "editMessageReplyMarkup"
}
// StopPollConfig allows you to stop a poll sent by the bot.
type StopPollConfig struct {
BaseEdit
}
func (config StopPollConfig) params() (Params, error) {
return config.BaseEdit.params()
}
func (StopPollConfig) method() string {
return "stopPoll"
}
// UserProfilePhotosConfig contains information about a
// GetUserProfilePhotos request.
2015-11-20 11:42:26 +01:00
type UserProfilePhotosConfig struct {
2021-03-09 18:38:15 +01:00
UserID int64
2015-11-20 11:42:26 +01:00
Offset int
Limit int
}
func (UserProfilePhotosConfig) method() string {
return "getUserProfilePhotos"
}
func (config UserProfilePhotosConfig) params() (Params, error) {
params := make(Params)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
params.AddNonZero("offset", config.Offset)
params.AddNonZero("limit", config.Limit)
return params, nil
}
// FileConfig has information about a file hosted on Telegram.
2015-11-20 11:42:26 +01:00
type FileConfig struct {
FileID string
}
func (FileConfig) method() string {
return "getFile"
}
func (config FileConfig) params() (Params, error) {
params := make(Params)
params["file_id"] = config.FileID
return params, nil
}
2015-11-20 11:42:26 +01:00
// UpdateConfig contains information about a GetUpdates request.
type UpdateConfig struct {
Offset int
Limit int
Timeout int
}
func (UpdateConfig) method() string {
return "getUpdates"
}
func (config UpdateConfig) params() (Params, error) {
params := make(Params)
params.AddNonZero("offset", config.Offset)
params.AddNonZero("limit", config.Limit)
params.AddNonZero("timeout", config.Timeout)
return params, nil
}
2015-11-20 11:42:26 +01:00
// WebhookConfig contains information about a SetWebhook request.
type WebhookConfig struct {
2020-11-05 22:53:37 +01:00
URL *url.URL
Certificate interface{}
IPAddress string
MaxConnections int
AllowedUpdates []string
DropPendingUpdates bool
2015-11-20 11:42:26 +01:00
}
func (config WebhookConfig) method() string {
return "setWebhook"
}
func (config WebhookConfig) params() (Params, error) {
params := make(Params)
if config.URL != nil {
params["url"] = config.URL.String()
}
2020-11-05 22:53:37 +01:00
params.AddNonEmpty("ip_address", config.IPAddress)
params.AddNonZero("max_connections", config.MaxConnections)
params.AddInterface("allowed_updates", config.AllowedUpdates)
2020-11-05 22:53:37 +01:00
params.AddBool("drop_pending_updates", config.DropPendingUpdates)
return params, nil
}
func (config WebhookConfig) name() string {
return "certificate"
}
func (config WebhookConfig) getFile() interface{} {
return config.Certificate
}
func (config WebhookConfig) useExistingFile() bool {
return config.URL != nil
}
2020-11-05 22:53:37 +01:00
// DeleteWebhookConfig is a helper to delete a webhook.
type DeleteWebhookConfig struct {
DropPendingUpdates bool
}
2020-11-05 22:53:37 +01:00
func (config DeleteWebhookConfig) method() string {
return "deleteWebhook"
}
2020-11-05 22:53:37 +01:00
func (config DeleteWebhookConfig) params() (Params, error) {
params := make(Params)
params.AddBool("drop_pending_updates", config.DropPendingUpdates)
return params, nil
}
// FileBytes contains information about a set of bytes to upload
// as a File.
2015-11-20 11:42:26 +01:00
type FileBytes struct {
Name string
Bytes []byte
}
// FileReader contains information about a reader to upload as a File.
// If Size is -1, it will read the entire Reader into memory to
// calculate a Size.
2015-11-20 11:42:26 +01:00
type FileReader struct {
Name string
Reader io.Reader
Size int64
}
// InlineConfig contains information on making an InlineQuery response.
type InlineConfig struct {
2016-04-12 15:28:46 +02:00
InlineQueryID string `json:"inline_query_id"`
Results []interface{} `json:"results"`
CacheTime int `json:"cache_time"`
IsPersonal bool `json:"is_personal"`
NextOffset string `json:"next_offset"`
SwitchPMText string `json:"switch_pm_text"`
SwitchPMParameter string `json:"switch_pm_parameter"`
}
func (config InlineConfig) method() string {
return "answerInlineQuery"
}
func (config InlineConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params["inline_query_id"] = config.InlineQueryID
params.AddNonZero("cache_time", config.CacheTime)
params.AddBool("is_personal", config.IsPersonal)
params.AddNonEmpty("next_offset", config.NextOffset)
params.AddNonEmpty("switch_pm_text", config.SwitchPMText)
params.AddNonEmpty("switch_pm_parameter", config.SwitchPMParameter)
2020-11-06 05:29:48 +01:00
err := params.AddInterface("results", config.Results)
2020-11-06 05:29:48 +01:00
return params, err
}
2016-04-12 15:28:46 +02:00
// CallbackConfig contains information on making a CallbackQuery response.
type CallbackConfig struct {
CallbackQueryID string `json:"callback_query_id"`
Text string `json:"text"`
ShowAlert bool `json:"show_alert"`
URL string `json:"url"`
CacheTime int `json:"cache_time"`
}
func (config CallbackConfig) method() string {
return "answerCallbackQuery"
}
func (config CallbackConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params["callback_query_id"] = config.CallbackQueryID
params.AddNonEmpty("text", config.Text)
params.AddBool("show_alert", config.ShowAlert)
params.AddNonEmpty("url", config.URL)
params.AddNonZero("cache_time", config.CacheTime)
2018-10-09 01:37:18 +02:00
return params, nil
}
2016-04-12 15:59:47 +02:00
// ChatMemberConfig contains information about a user in a chat for use
// with administrative functions such as kicking or unbanning a user.
type ChatMemberConfig struct {
ChatID int64
SuperGroupUsername string
ChannelUsername string
2021-03-09 18:38:15 +01:00
UserID int64
}
2016-05-22 17:16:28 +02:00
// UnbanChatMemberConfig allows you to unban a user.
type UnbanChatMemberConfig struct {
ChatMemberConfig
2020-11-05 22:53:37 +01:00
OnlyIfBanned bool
}
func (config UnbanChatMemberConfig) method() string {
return "unbanChatMember"
}
func (config UnbanChatMemberConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername, config.ChannelUsername)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
2020-11-05 22:53:37 +01:00
params.AddBool("only_if_banned", config.OnlyIfBanned)
2018-10-09 01:37:18 +02:00
return params, nil
}
2017-07-01 06:34:09 +02:00
// KickChatMemberConfig contains extra fields to kick user
type KickChatMemberConfig struct {
ChatMemberConfig
2021-03-09 18:27:17 +01:00
UntilDate int64
RevokeMessages bool
2017-07-01 06:34:09 +02:00
}
func (config KickChatMemberConfig) method() string {
return "kickChatMember"
}
func (config KickChatMemberConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
2018-10-09 01:37:18 +02:00
params.AddNonZero64("until_date", config.UntilDate)
2021-03-09 18:27:17 +01:00
params.AddBool("revoke_messages", config.RevokeMessages)
2018-10-09 01:37:18 +02:00
return params, nil
}
2017-07-01 06:34:09 +02:00
// RestrictChatMemberConfig contains fields to restrict members of chat
type RestrictChatMemberConfig struct {
ChatMemberConfig
2020-01-06 08:44:13 +01:00
UntilDate int64
Permissions *ChatPermissions
2017-07-01 06:34:09 +02:00
}
func (config RestrictChatMemberConfig) method() string {
return "restrictChatMember"
}
func (config RestrictChatMemberConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername, config.ChannelUsername)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
2020-11-06 05:29:48 +01:00
err := params.AddInterface("permissions", config.Permissions)
2018-10-09 01:37:18 +02:00
params.AddNonZero64("until_date", config.UntilDate)
2020-11-06 05:29:48 +01:00
return params, err
}
2017-07-01 06:34:09 +02:00
// PromoteChatMemberConfig contains fields to promote members of chat
type PromoteChatMemberConfig struct {
ChatMemberConfig
2021-03-09 18:27:17 +01:00
IsAnonymous bool
CanManageChat bool
CanChangeInfo bool
CanPostMessages bool
CanEditMessages bool
CanDeleteMessages bool
CanManageVoiceChats bool
CanInviteUsers bool
CanRestrictMembers bool
CanPinMessages bool
CanPromoteMembers bool
2017-07-01 06:34:09 +02:00
}
func (config PromoteChatMemberConfig) method() string {
return "promoteChatMember"
}
func (config PromoteChatMemberConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername, config.ChannelUsername)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
2020-11-05 22:53:37 +01:00
params.AddBool("is_anonymous", config.IsAnonymous)
2021-03-09 18:27:17 +01:00
params.AddBool("can_manage_chat", config.CanManageChat)
2020-01-06 08:44:13 +01:00
params.AddBool("can_change_info", config.CanChangeInfo)
params.AddBool("can_post_messages", config.CanPostMessages)
params.AddBool("can_edit_messages", config.CanEditMessages)
params.AddBool("can_delete_messages", config.CanDeleteMessages)
2021-03-09 18:27:17 +01:00
params.AddBool("can_manage_voice_chats", config.CanManageVoiceChats)
2020-01-06 08:44:13 +01:00
params.AddBool("can_invite_users", config.CanInviteUsers)
params.AddBool("can_restrict_members", config.CanRestrictMembers)
params.AddBool("can_pin_messages", config.CanPinMessages)
params.AddBool("can_promote_members", config.CanPromoteMembers)
return params, nil
}
// SetChatAdministratorCustomTitle sets the title of an administrative user
// promoted by the bot for a chat.
type SetChatAdministratorCustomTitle struct {
ChatMemberConfig
CustomTitle string
}
func (SetChatAdministratorCustomTitle) method() string {
return "setChatAdministratorCustomTitle"
}
func (config SetChatAdministratorCustomTitle) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername, config.ChannelUsername)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
2020-01-06 08:44:13 +01:00
params.AddNonEmpty("custom_title", config.CustomTitle)
2018-10-09 01:37:18 +02:00
return params, nil
}
2016-05-22 17:16:28 +02:00
// ChatConfig contains information about getting information on a chat.
type ChatConfig struct {
ChatID int64
SuperGroupUsername string
}
func (config ChatConfig) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
return params, nil
}
// ChatInfoConfig contains information about getting chat information.
type ChatInfoConfig struct {
ChatConfig
}
func (ChatInfoConfig) method() string {
return "getChat"
}
// ChatMemberCountConfig contains information about getting the number of users in a chat.
type ChatMemberCountConfig struct {
ChatConfig
}
func (ChatMemberCountConfig) method() string {
return "getChatMembersCount"
}
// ChatAdministratorsConfig contains information about getting chat administrators.
type ChatAdministratorsConfig struct {
ChatConfig
}
func (ChatAdministratorsConfig) method() string {
return "getChatAdministrators"
}
2020-01-06 08:44:13 +01:00
// SetChatPermissionsConfig allows you to set default permissions for the
// members in a group. The bot must be an administrator and have rights to
// restrict members.
type SetChatPermissionsConfig struct {
ChatConfig
Permissions *ChatPermissions
}
func (SetChatPermissionsConfig) method() string {
return "setChatPermissions"
}
func (config SetChatPermissionsConfig) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
params.AddInterface("permissions", config.Permissions)
return params, nil
}
// ChatInviteLinkConfig contains information about getting a chat link.
//
// Note that generating a new link will revoke any previous links.
type ChatInviteLinkConfig struct {
ChatConfig
}
func (ChatInviteLinkConfig) method() string {
return "exportChatInviteLink"
}
func (config ChatInviteLinkConfig) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
return params, nil
}
2021-03-09 18:27:17 +01:00
// CreateChatInviteLinkConfig allows you to create an additional invite link for
// a chat. The bot must be an administrator in the chat for this to work and
// must have the appropriate admin rights. The link can be revoked using the
// RevokeChatInviteLinkConfig.
type CreateChatInviteLinkConfig struct {
ChatConfig
ExpireDate int
MemberLimit int
}
func (CreateChatInviteLinkConfig) method() string {
return "createChatInviteLink"
}
func (config CreateChatInviteLinkConfig) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
params.AddNonZero("expire_date", config.ExpireDate)
params.AddNonZero("member_limit", config.MemberLimit)
return params, nil
}
// EditChatInviteLinkConfig allows you to edit a non-primary invite link created
// by the bot. The bot must be an administrator in the chat for this to work and
// must have the appropriate admin rights.
type EditChatInviteLinkConfig struct {
ChatConfig
InviteLink string
ExpireDate int
MemberLimit int
}
func (EditChatInviteLinkConfig) method() string {
return "editChatInviteLink"
}
func (config EditChatInviteLinkConfig) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
params["invite_link"] = config.InviteLink
params.AddNonZero("expire_date", config.ExpireDate)
params.AddNonZero("member_limit", config.MemberLimit)
return params, nil
}
// RevokeChatInviteLinkConfig allows you to revoke an invite link created by the
// bot. If the primary link is revoked, a new link is automatically generated.
// The bot must be an administrator in the chat for this to work and must have
// the appropriate admin rights.
type RevokeChatInviteLinkConfig struct {
ChatConfig
InviteLink string
}
func (RevokeChatInviteLinkConfig) method() string {
return "revokeChatInviteLink"
}
func (config RevokeChatInviteLinkConfig) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
params["invite_link"] = config.InviteLink
return params, nil
}
// LeaveChatConfig allows you to leave a chat.
type LeaveChatConfig struct {
ChatID int64
ChannelUsername string
}
func (config LeaveChatConfig) method() string {
return "leaveChat"
}
func (config LeaveChatConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
2018-10-09 01:37:18 +02:00
return params, nil
}
// ChatConfigWithUser contains information about a chat and a user.
2016-05-22 17:16:28 +02:00
type ChatConfigWithUser struct {
ChatID int64
SuperGroupUsername string
2021-03-09 18:38:15 +01:00
UserID int64
2016-05-22 17:16:28 +02:00
}
2017-06-02 22:18:42 +02:00
func (config ChatConfigWithUser) params() (Params, error) {
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
return params, nil
}
// GetChatMemberConfig is information about getting a specific member in a chat.
type GetChatMemberConfig struct {
ChatConfigWithUser
}
func (GetChatMemberConfig) method() string {
return "getChatMember"
}
2017-06-03 08:59:40 +02:00
// InvoiceConfig contains information for sendInvoice request.
2017-06-02 22:18:42 +02:00
type InvoiceConfig struct {
BaseChat
2018-10-09 06:32:34 +02:00
Title string // required
Description string // required
Payload string // required
ProviderToken string // required
StartParameter string // required
Currency string // required
Prices []LabeledPrice // required
ProviderData string
PhotoURL string
PhotoSize int
PhotoWidth int
PhotoHeight int
NeedName bool
NeedPhoneNumber bool
NeedEmail bool
NeedShippingAddress bool
SendPhoneNumberToProvider bool
SendEmailToProvider bool
IsFlexible bool
2017-06-02 22:18:42 +02:00
}
func (config InvoiceConfig) params() (Params, error) {
params, err := config.BaseChat.params()
2017-06-02 22:18:42 +02:00
if err != nil {
return params, err
2017-06-02 22:18:42 +02:00
}
params["title"] = config.Title
params["description"] = config.Description
params["payload"] = config.Payload
params["provider_token"] = config.ProviderToken
params["start_parameter"] = config.StartParameter
params["currency"] = config.Currency
2020-11-06 05:29:48 +01:00
err = params.AddInterface("prices", config.Prices)
params.AddNonEmpty("provider_data", config.ProviderData)
params.AddNonEmpty("photo_url", config.PhotoURL)
params.AddNonZero("photo_size", config.PhotoSize)
params.AddNonZero("photo_width", config.PhotoWidth)
params.AddNonZero("photo_height", config.PhotoHeight)
params.AddBool("need_name", config.NeedName)
params.AddBool("need_phone_number", config.NeedPhoneNumber)
params.AddBool("need_email", config.NeedEmail)
params.AddBool("need_shipping_address", config.NeedShippingAddress)
params.AddBool("is_flexible", config.IsFlexible)
params.AddBool("send_phone_number_to_provider", config.SendPhoneNumberToProvider)
params.AddBool("send_email_to_provider", config.SendEmailToProvider)
2020-11-06 05:29:48 +01:00
return params, err
2017-06-02 22:18:42 +02:00
}
func (config InvoiceConfig) method() string {
return "sendInvoice"
}
2017-06-03 08:59:40 +02:00
// ShippingConfig contains information for answerShippingQuery request.
2017-06-02 22:18:42 +02:00
type ShippingConfig struct {
ShippingQueryID string // required
2017-06-03 08:59:40 +02:00
OK bool // required
2018-10-09 06:32:34 +02:00
ShippingOptions []ShippingOption
2017-06-02 22:18:42 +02:00
ErrorMessage string
}
2020-11-06 05:29:48 +01:00
func (config ShippingConfig) method() string {
return "answerShippingQuery"
}
func (config ShippingConfig) params() (Params, error) {
params := make(Params)
params["shipping_query_id"] = config.ShippingQueryID
params.AddBool("ok", config.OK)
err := params.AddInterface("shipping_options", config.ShippingOptions)
params.AddNonEmpty("error_message", config.ErrorMessage)
return params, err
}
2017-06-03 08:59:40 +02:00
// PreCheckoutConfig conatins information for answerPreCheckoutQuery request.
2017-06-02 22:18:42 +02:00
type PreCheckoutConfig struct {
PreCheckoutQueryID string // required
2017-06-03 08:59:40 +02:00
OK bool // required
2017-06-02 22:18:42 +02:00
ErrorMessage string
}
2020-11-06 05:29:48 +01:00
func (config PreCheckoutConfig) method() string {
return "answerPreCheckoutQuery"
}
func (config PreCheckoutConfig) params() (Params, error) {
params := make(Params)
params["pre_checkout_query_id"] = config.PreCheckoutQueryID
params.AddBool("ok", config.OK)
params.AddNonEmpty("error_message", config.ErrorMessage)
return params, nil
}
// DeleteMessageConfig contains information of a message in a chat to delete.
type DeleteMessageConfig struct {
ChannelUsername string
ChatID int64
MessageID int
}
func (config DeleteMessageConfig) method() string {
return "deleteMessage"
}
func (config DeleteMessageConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
2018-10-09 01:37:18 +02:00
params.AddNonZero("message_id", config.MessageID)
2018-10-09 01:37:18 +02:00
return params, nil
}
// PinChatMessageConfig contains information of a message in a chat to pin.
type PinChatMessageConfig struct {
ChatID int64
2017-12-29 20:22:53 +01:00
ChannelUsername string
MessageID int
DisableNotification bool
}
func (config PinChatMessageConfig) method() string {
return "pinChatMessage"
}
func (config PinChatMessageConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
params.AddNonZero("message_id", config.MessageID)
params.AddBool("disable_notification", config.DisableNotification)
2018-10-09 01:37:18 +02:00
return params, nil
}
2020-11-05 22:53:37 +01:00
// UnpinChatMessageConfig contains information of a chat message to unpin.
//
// If MessageID is not specified, it will unpin the most recent pin.
type UnpinChatMessageConfig struct {
2017-12-29 20:22:53 +01:00
ChatID int64
ChannelUsername string
2020-11-05 22:53:37 +01:00
MessageID int
}
func (config UnpinChatMessageConfig) method() string {
return "unpinChatMessage"
}
func (config UnpinChatMessageConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2020-11-05 22:53:37 +01:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
params.AddNonZero("message_id", config.MessageID)
return params, nil
}
// UnpinAllChatMessagesConfig contains information of all messages to unpin in
// a chat.
type UnpinAllChatMessagesConfig struct {
ChatID int64
ChannelUsername string
}
func (config UnpinAllChatMessagesConfig) method() string {
return "unpinAllChatMessages"
}
func (config UnpinAllChatMessagesConfig) params() (Params, error) {
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
2018-10-09 01:37:18 +02:00
return params, nil
}
// SetChatPhotoConfig allows you to set a group, supergroup, or channel's photo.
type SetChatPhotoConfig struct {
2018-03-26 19:22:16 +02:00
BaseFile
}
func (config SetChatPhotoConfig) method() string {
return "setChatPhoto"
}
func (config SetChatPhotoConfig) name() string {
return "photo"
}
func (config SetChatPhotoConfig) getFile() interface{} {
2018-03-26 19:22:16 +02:00
return config.File
}
func (config SetChatPhotoConfig) useExistingFile() bool {
2018-03-26 19:22:16 +02:00
return config.UseExisting
}
// DeleteChatPhotoConfig allows you to delete a group, supergroup, or channel's photo.
type DeleteChatPhotoConfig struct {
ChatID int64
ChannelUsername string
}
func (config DeleteChatPhotoConfig) method() string {
return "deleteChatPhoto"
}
func (config DeleteChatPhotoConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
2018-10-09 01:37:18 +02:00
return params, nil
}
// SetChatTitleConfig allows you to set the title of something other than a private chat.
type SetChatTitleConfig struct {
ChatID int64
ChannelUsername string
Title string
}
func (config SetChatTitleConfig) method() string {
return "setChatTitle"
}
func (config SetChatTitleConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
params["title"] = config.Title
2018-10-09 01:37:18 +02:00
return params, nil
}
// SetChatDescriptionConfig allows you to set the description of a supergroup or channel.
type SetChatDescriptionConfig struct {
ChatID int64
ChannelUsername string
Description string
}
func (config SetChatDescriptionConfig) method() string {
return "setChatDescription"
}
func (config SetChatDescriptionConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
params["description"] = config.Description
2018-10-09 01:37:18 +02:00
return params, nil
}
// GetStickerSetConfig allows you to get the stickers in a set.
type GetStickerSetConfig struct {
Name string
}
func (config GetStickerSetConfig) method() string {
return "getStickerSet"
}
func (config GetStickerSetConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params["name"] = config.Name
2018-10-09 01:37:18 +02:00
return params, nil
}
// UploadStickerConfig allows you to upload a sticker for use in a set later.
type UploadStickerConfig struct {
UserID int64
PNGSticker interface{}
}
func (config UploadStickerConfig) method() string {
return "uploadStickerFile"
}
func (config UploadStickerConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddNonZero64("user_id", config.UserID)
2018-10-09 01:37:18 +02:00
return params, nil
}
func (config UploadStickerConfig) name() string {
return "png_sticker"
}
func (config UploadStickerConfig) getFile() interface{} {
return config.PNGSticker
}
func (config UploadStickerConfig) useExistingFile() bool {
_, ok := config.PNGSticker.(string)
return ok
}
// NewStickerSetConfig allows creating a new sticker set.
2020-03-30 22:35:53 +02:00
//
// You must set either PNGSticker or TGSSticker.
type NewStickerSetConfig struct {
UserID int64
Name string
Title string
PNGSticker interface{}
2020-03-30 22:35:53 +02:00
TGSSticker interface{}
Emojis string
ContainsMasks bool
MaskPosition *MaskPosition
}
func (config NewStickerSetConfig) method() string {
return "createNewStickerSet"
}
func (config NewStickerSetConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddNonZero64("user_id", config.UserID)
params["name"] = config.Name
params["title"] = config.Title
if sticker, ok := config.PNGSticker.(string); ok {
2018-10-09 01:37:18 +02:00
params[config.name()] = sticker
2020-03-30 22:35:53 +02:00
} else if sticker, ok := config.TGSSticker.(string); ok {
params[config.name()] = sticker
}
2018-10-09 01:37:18 +02:00
params["emojis"] = config.Emojis
2018-10-09 01:37:18 +02:00
params.AddBool("contains_masks", config.ContainsMasks)
2018-10-09 01:37:18 +02:00
err := params.AddInterface("mask_position", config.MaskPosition)
2018-10-09 01:37:18 +02:00
return params, err
}
func (config NewStickerSetConfig) getFile() interface{} {
return config.PNGSticker
}
func (config NewStickerSetConfig) name() string {
return "png_sticker"
}
func (config NewStickerSetConfig) useExistingFile() bool {
2020-03-30 22:35:53 +02:00
if config.PNGSticker != nil {
_, ok := config.PNGSticker.(string)
return ok
}
2020-03-30 22:35:53 +02:00
if config.TGSSticker != nil {
_, ok := config.TGSSticker.(string)
return ok
}
panic("NewStickerSetConfig had nil PNGSticker and TGSSticker")
}
// AddStickerConfig allows you to add a sticker to a set.
type AddStickerConfig struct {
UserID int64
Name string
PNGSticker interface{}
2020-03-30 22:35:53 +02:00
TGSSticker interface{}
Emojis string
MaskPosition *MaskPosition
}
func (config AddStickerConfig) method() string {
return "addStickerToSet"
}
func (config AddStickerConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params.AddNonZero64("user_id", config.UserID)
params["name"] = config.Name
params["emojis"] = config.Emojis
if sticker, ok := config.PNGSticker.(string); ok {
2018-10-09 01:37:18 +02:00
params[config.name()] = sticker
2020-03-30 22:35:53 +02:00
} else if sticker, ok := config.TGSSticker.(string); ok {
params[config.name()] = sticker
}
2018-10-09 01:37:18 +02:00
err := params.AddInterface("mask_position", config.MaskPosition)
2018-10-09 01:37:18 +02:00
return params, err
}
func (config AddStickerConfig) name() string {
return "png_sticker"
}
func (config AddStickerConfig) getFile() interface{} {
return config.PNGSticker
}
func (config AddStickerConfig) useExistingFile() bool {
_, ok := config.PNGSticker.(string)
return ok
}
// SetStickerPositionConfig allows you to change the position of a sticker in a set.
type SetStickerPositionConfig struct {
Sticker string
Position int
}
func (config SetStickerPositionConfig) method() string {
return "setStickerPositionInSet"
}
func (config SetStickerPositionConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params["sticker"] = config.Sticker
params.AddNonZero("position", config.Position)
2018-10-09 01:37:18 +02:00
return params, nil
}
// DeleteStickerConfig allows you to delete a sticker from a set.
type DeleteStickerConfig struct {
Sticker string
}
func (config DeleteStickerConfig) method() string {
return "deleteStickerFromSet"
}
func (config DeleteStickerConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2018-10-09 01:37:18 +02:00
params["sticker"] = config.Sticker
2018-10-09 01:37:18 +02:00
return params, nil
}
2017-12-29 20:06:58 +01:00
2020-03-30 22:35:53 +02:00
// SetStickerSetThumbConfig allows you to set the thumbnail for a sticker set.
type SetStickerSetThumbConfig struct {
Name string
2021-03-09 18:38:15 +01:00
UserID int64
2020-03-30 22:35:53 +02:00
Thumb interface{}
}
func (config SetStickerSetThumbConfig) method() string {
return "setStickerSetThumb"
}
func (config SetStickerSetThumbConfig) params() (Params, error) {
params := make(Params)
params["name"] = config.Name
2021-03-09 18:38:15 +01:00
params.AddNonZero64("user_id", config.UserID)
2020-03-30 22:35:53 +02:00
if thumb, ok := config.Thumb.(string); ok {
params["thumb"] = thumb
}
return params, nil
}
func (config SetStickerSetThumbConfig) name() string {
return "thumb"
}
func (config SetStickerSetThumbConfig) getFile() interface{} {
return config.Thumb
}
func (config SetStickerSetThumbConfig) useExistingFile() bool {
_, ok := config.Thumb.(string)
return ok
}
2017-12-29 20:06:58 +01:00
// SetChatStickerSetConfig allows you to set the sticker set for a supergroup.
type SetChatStickerSetConfig struct {
ChatID int64
SuperGroupUsername string
StickerSetName string
}
func (config SetChatStickerSetConfig) method() string {
return "setChatStickerSet"
}
func (config SetChatStickerSetConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2017-12-29 20:06:58 +01:00
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
params["sticker_set_name"] = config.StickerSetName
2017-12-29 20:06:58 +01:00
2018-10-09 01:37:18 +02:00
return params, nil
2017-12-29 20:06:58 +01:00
}
// DeleteChatStickerSetConfig allows you to remove a supergroup's sticker set.
type DeleteChatStickerSetConfig struct {
ChatID int64
SuperGroupUsername string
}
func (config DeleteChatStickerSetConfig) method() string {
return "deleteChatStickerSet"
}
func (config DeleteChatStickerSetConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2017-12-29 20:06:58 +01:00
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
2017-12-29 20:06:58 +01:00
2018-10-09 01:37:18 +02:00
return params, nil
2017-12-29 20:06:58 +01:00
}
2017-12-29 20:22:53 +01:00
// MediaGroupConfig allows you to send a group of media.
//
// Media consist of InputMedia items (InputMediaPhoto, InputMediaVideo).
type MediaGroupConfig struct {
ChatID int64
ChannelUsername string
Media []interface{}
DisableNotification bool
ReplyToMessageID int
}
func (config MediaGroupConfig) method() string {
return "sendMediaGroup"
}
func (config MediaGroupConfig) params() (Params, error) {
2018-10-09 01:37:18 +02:00
params := make(Params)
2017-12-29 20:22:53 +01:00
2018-10-09 01:37:18 +02:00
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
if err := params.AddInterface("media", config.Media); err != nil {
return params, nil
2017-12-29 20:22:53 +01:00
}
2018-10-09 01:37:18 +02:00
params.AddBool("disable_notification", config.DisableNotification)
params.AddNonZero("reply_to_message_id", config.ReplyToMessageID)
2017-12-29 20:22:53 +01:00
2018-10-09 01:37:18 +02:00
return params, nil
2017-12-29 20:22:53 +01:00
}
2020-03-30 22:35:53 +02:00
// GetMyCommandsConfig gets a list of the currently registered commands.
type GetMyCommandsConfig struct{}
func (config GetMyCommandsConfig) method() string {
return "getMyCommands"
}
func (config GetMyCommandsConfig) params() (Params, error) {
2020-11-06 05:29:48 +01:00
return nil, nil
2020-03-30 22:35:53 +02:00
}
// SetMyCommandsConfig sets a list of commands the bot understands.
type SetMyCommandsConfig struct {
commands []BotCommand
}
func (config SetMyCommandsConfig) method() string {
return "setMyCommands"
}
func (config SetMyCommandsConfig) params() (Params, error) {
params := make(Params)
err := params.AddInterface("commands", config.commands)
return params, err
}
2020-11-06 05:29:48 +01:00
// DiceConfig contains information about a sendDice request.
type DiceConfig struct {
BaseChat
// Emoji on which the dice throw animation is based.
2021-03-09 18:27:17 +01:00
// Currently, must be one of 🎲, 🎯, 🏀, ⚽, 🎳, or 🎰.
// Dice can have values 1-6 for 🎲, 🎯, and 🎳, values 1-5 for 🏀 and ⚽,
// and values 1-64 for 🎰.
2020-11-06 05:29:48 +01:00
// Defaults to “🎲”
Emoji string
}
func (config DiceConfig) method() string {
return "sendDice"
}
func (config DiceConfig) params() (Params, error) {
params, err := config.BaseChat.params()
if err != nil {
return params, err
}
params.AddNonEmpty("emoji", config.Emoji)
return params, err
}