2469 lines
62 KiB
Go
2469 lines
62 KiB
Go
package tgbotapi
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"net/url"
|
|
"os"
|
|
"strconv"
|
|
)
|
|
|
|
// Telegram constants
|
|
const (
|
|
// APIEndpoint is the endpoint for all API methods,
|
|
// with formatting for Sprintf.
|
|
APIEndpoint = "https://api.telegram.org/bot%s/%s"
|
|
// FileEndpoint is the endpoint for downloading a file from Telegram.
|
|
FileEndpoint = "https://api.telegram.org/file/bot%s/%s"
|
|
)
|
|
|
|
// Constant values for ChatActions
|
|
const (
|
|
ChatTyping = "typing"
|
|
ChatUploadPhoto = "upload_photo"
|
|
ChatRecordVideo = "record_video"
|
|
ChatUploadVideo = "upload_video"
|
|
ChatRecordVoice = "record_voice"
|
|
ChatUploadVoice = "upload_voice"
|
|
ChatUploadDocument = "upload_document"
|
|
ChatChooseSticker = "choose_sticker"
|
|
ChatFindLocation = "find_location"
|
|
ChatRecordVideoNote = "record_video_note"
|
|
ChatUploadVideoNote = "upload_video_note"
|
|
)
|
|
|
|
// API errors
|
|
const (
|
|
// ErrAPIForbidden happens when a token is bad
|
|
ErrAPIForbidden = "forbidden"
|
|
)
|
|
|
|
// Constant values for ParseMode in MessageConfig
|
|
const (
|
|
ModeMarkdown = "Markdown"
|
|
ModeMarkdownV2 = "MarkdownV2"
|
|
ModeHTML = "HTML"
|
|
)
|
|
|
|
// Constant values for update types
|
|
const (
|
|
// UpdateTypeMessage is new incoming message of any kind — text, photo, sticker, etc.
|
|
UpdateTypeMessage = "message"
|
|
|
|
// UpdateTypeEditedMessage is new version of a message that is known to the bot and was edited
|
|
UpdateTypeEditedMessage = "edited_message"
|
|
|
|
// UpdateTypeChannelPost is new incoming channel post of any kind — text, photo, sticker, etc.
|
|
UpdateTypeChannelPost = "channel_post"
|
|
|
|
// UpdateTypeEditedChannelPost is new version of a channel post that is known to the bot and was edited
|
|
UpdateTypeEditedChannelPost = "edited_channel_post"
|
|
|
|
// UpdateTypeInlineQuery is new incoming inline query
|
|
UpdateTypeInlineQuery = "inline_query"
|
|
|
|
// UpdateTypeChosenInlineResult i the result of an inline query that was chosen by a user and sent to their
|
|
// chat partner. Please see the documentation on the feedback collecting for
|
|
// details on how to enable these updates for your bot.
|
|
UpdateTypeChosenInlineResult = "chosen_inline_result"
|
|
|
|
// UpdateTypeCallbackQuery is new incoming callback query
|
|
UpdateTypeCallbackQuery = "callback_query"
|
|
|
|
// UpdateTypeShippingQuery is new incoming shipping query. Only for invoices with flexible price
|
|
UpdateTypeShippingQuery = "shipping_query"
|
|
|
|
// UpdateTypePreCheckoutQuery is new incoming pre-checkout query. Contains full information about checkout
|
|
UpdateTypePreCheckoutQuery = "pre_checkout_query"
|
|
|
|
// UpdateTypePoll is new poll state. Bots receive only updates about stopped polls and polls
|
|
// which are sent by the bot
|
|
UpdateTypePoll = "poll"
|
|
|
|
// UpdateTypePollAnswer is when user changed their answer in a non-anonymous poll. Bots receive new votes
|
|
// only in polls that were sent by the bot itself.
|
|
UpdateTypePollAnswer = "poll_answer"
|
|
|
|
// UpdateTypeMyChatMember is when the bot's chat member status was updated in a chat. For private chats, this
|
|
// update is received only when the bot is blocked or unblocked by the user.
|
|
UpdateTypeMyChatMember = "my_chat_member"
|
|
|
|
// UpdateTypeChatMember is when the bot must be an administrator in the chat and must explicitly specify
|
|
// this update in the list of allowed_updates to receive these updates.
|
|
UpdateTypeChatMember = "chat_member"
|
|
)
|
|
|
|
// Library errors
|
|
const (
|
|
ErrBadURL = "bad or empty url"
|
|
)
|
|
|
|
// Chattable is any config type that can be sent.
|
|
type Chattable interface {
|
|
params() (Params, error)
|
|
method() string
|
|
}
|
|
|
|
// Fileable is any config type that can be sent that includes a file.
|
|
type Fileable interface {
|
|
Chattable
|
|
files() []RequestFile
|
|
}
|
|
|
|
// RequestFile represents a file associated with a field name.
|
|
type RequestFile struct {
|
|
// The file field name.
|
|
Name string
|
|
// The file data to include.
|
|
Data RequestFileData
|
|
}
|
|
|
|
// RequestFileData represents the data to be used for a file.
|
|
type RequestFileData interface {
|
|
// NeedsUpload shows if the file needs to be uploaded.
|
|
NeedsUpload() bool
|
|
|
|
// UploadData gets the file name and an `io.Reader` for the file to be uploaded. This
|
|
// must only be called when the file needs to be uploaded.
|
|
UploadData() (string, io.Reader, error)
|
|
// SendData gets the file data to send when a file does not need to be uploaded. This
|
|
// must only be called when the file does not need to be uploaded.
|
|
SendData() string
|
|
}
|
|
|
|
// FileBytes contains information about a set of bytes to upload
|
|
// as a File.
|
|
type FileBytes struct {
|
|
Name string
|
|
Bytes []byte
|
|
}
|
|
|
|
func (fb FileBytes) NeedsUpload() bool {
|
|
return true
|
|
}
|
|
|
|
func (fb FileBytes) UploadData() (string, io.Reader, error) {
|
|
return fb.Name, bytes.NewReader(fb.Bytes), nil
|
|
}
|
|
|
|
func (fb FileBytes) SendData() string {
|
|
panic("FileBytes must be uploaded")
|
|
}
|
|
|
|
// FileReader contains information about a reader to upload as a File.
|
|
type FileReader struct {
|
|
Name string
|
|
Reader io.Reader
|
|
}
|
|
|
|
func (fr FileReader) NeedsUpload() bool {
|
|
return true
|
|
}
|
|
|
|
func (fr FileReader) UploadData() (string, io.Reader, error) {
|
|
return fr.Name, fr.Reader, nil
|
|
}
|
|
|
|
func (fr FileReader) SendData() string {
|
|
panic("FileReader must be uploaded")
|
|
}
|
|
|
|
// FilePath is a path to a local file.
|
|
type FilePath string
|
|
|
|
func (fp FilePath) NeedsUpload() bool {
|
|
return true
|
|
}
|
|
|
|
func (fp FilePath) UploadData() (string, io.Reader, error) {
|
|
fileHandle, err := os.Open(string(fp))
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
|
|
name := fileHandle.Name()
|
|
return name, fileHandle, err
|
|
}
|
|
|
|
func (fp FilePath) SendData() string {
|
|
panic("FilePath must be uploaded")
|
|
}
|
|
|
|
// FileURL is a URL to use as a file for a request.
|
|
type FileURL string
|
|
|
|
func (fu FileURL) NeedsUpload() bool {
|
|
return false
|
|
}
|
|
|
|
func (fu FileURL) UploadData() (string, io.Reader, error) {
|
|
panic("FileURL cannot be uploaded")
|
|
}
|
|
|
|
func (fu FileURL) SendData() string {
|
|
return string(fu)
|
|
}
|
|
|
|
// FileID is an ID of a file already uploaded to Telegram.
|
|
type FileID string
|
|
|
|
func (fi FileID) NeedsUpload() bool {
|
|
return false
|
|
}
|
|
|
|
func (fi FileID) UploadData() (string, io.Reader, error) {
|
|
panic("FileID cannot be uploaded")
|
|
}
|
|
|
|
func (fi FileID) SendData() string {
|
|
return string(fi)
|
|
}
|
|
|
|
// fileAttach is an internal file type used for processed media groups.
|
|
type fileAttach string
|
|
|
|
func (fa fileAttach) NeedsUpload() bool {
|
|
return false
|
|
}
|
|
|
|
func (fa fileAttach) UploadData() (string, io.Reader, error) {
|
|
panic("fileAttach cannot be uploaded")
|
|
}
|
|
|
|
func (fa fileAttach) SendData() string {
|
|
return string(fa)
|
|
}
|
|
|
|
// 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.
|
|
type BaseChat struct {
|
|
ChatID int64 // required
|
|
ChannelUsername string
|
|
ReplyToMessageID int
|
|
ReplyMarkup interface{}
|
|
DisableNotification bool
|
|
AllowSendingWithoutReply bool
|
|
}
|
|
|
|
func (chat *BaseChat) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", chat.ChatID, chat.ChannelUsername)
|
|
params.AddNonZero("reply_to_message_id", chat.ReplyToMessageID)
|
|
params.AddBool("disable_notification", chat.DisableNotification)
|
|
params.AddBool("allow_sending_without_reply", chat.AllowSendingWithoutReply)
|
|
|
|
err := params.AddInterface("reply_markup", chat.ReplyMarkup)
|
|
|
|
return params, err
|
|
}
|
|
|
|
// BaseFile is a base type for all file config types.
|
|
type BaseFile struct {
|
|
BaseChat
|
|
File RequestFileData
|
|
}
|
|
|
|
func (file BaseFile) params() (Params, error) {
|
|
return file.BaseChat.params()
|
|
}
|
|
|
|
// 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) {
|
|
params := make(Params)
|
|
|
|
if edit.InlineMessageID != "" {
|
|
params["inline_message_id"] = edit.InlineMessageID
|
|
} else {
|
|
params.AddFirstValid("chat_id", edit.ChatID, edit.ChannelUsername)
|
|
params.AddNonZero("message_id", edit.MessageID)
|
|
}
|
|
|
|
err := params.AddInterface("reply_markup", edit.ReplyMarkup)
|
|
|
|
return params, err
|
|
}
|
|
|
|
// MessageConfig contains information about a SendMessage request.
|
|
type MessageConfig struct {
|
|
BaseChat
|
|
Text string
|
|
ParseMode string
|
|
Entities []MessageEntity
|
|
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)
|
|
err = params.AddInterface("entities", config.Entities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config MessageConfig) method() string {
|
|
return "sendMessage"
|
|
}
|
|
|
|
// ForwardConfig contains information about a ForwardMessage request.
|
|
type ForwardConfig struct {
|
|
BaseChat
|
|
FromChatID int64 // required
|
|
FromChannelUsername string
|
|
MessageID int // required
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (config ForwardConfig) method() string {
|
|
return "forwardMessage"
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
func (config CopyMessageConfig) method() string {
|
|
return "copyMessage"
|
|
}
|
|
|
|
// PhotoConfig contains information about a SendPhoto request.
|
|
type PhotoConfig struct {
|
|
BaseFile
|
|
Thumb RequestFileData
|
|
Caption string
|
|
ParseMode string
|
|
CaptionEntities []MessageEntity
|
|
}
|
|
|
|
func (config PhotoConfig) params() (Params, error) {
|
|
params, err := config.BaseFile.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params.AddNonEmpty("caption", config.Caption)
|
|
params.AddNonEmpty("parse_mode", config.ParseMode)
|
|
err = params.AddInterface("caption_entities", config.CaptionEntities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config PhotoConfig) method() string {
|
|
return "sendPhoto"
|
|
}
|
|
|
|
func (config PhotoConfig) files() []RequestFile {
|
|
files := []RequestFile{{
|
|
Name: "photo",
|
|
Data: config.File,
|
|
}}
|
|
|
|
if config.Thumb != nil {
|
|
files = append(files, RequestFile{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
})
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// AudioConfig contains information about a SendAudio request.
|
|
type AudioConfig struct {
|
|
BaseFile
|
|
Thumb RequestFileData
|
|
Caption string
|
|
ParseMode string
|
|
CaptionEntities []MessageEntity
|
|
Duration int
|
|
Performer string
|
|
Title string
|
|
}
|
|
|
|
func (config AudioConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
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)
|
|
err = params.AddInterface("caption_entities", config.CaptionEntities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config AudioConfig) method() string {
|
|
return "sendAudio"
|
|
}
|
|
|
|
func (config AudioConfig) files() []RequestFile {
|
|
files := []RequestFile{{
|
|
Name: "audio",
|
|
Data: config.File,
|
|
}}
|
|
|
|
if config.Thumb != nil {
|
|
files = append(files, RequestFile{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
})
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// DocumentConfig contains information about a SendDocument request.
|
|
type DocumentConfig struct {
|
|
BaseFile
|
|
Thumb RequestFileData
|
|
Caption string
|
|
ParseMode string
|
|
CaptionEntities []MessageEntity
|
|
DisableContentTypeDetection bool
|
|
}
|
|
|
|
func (config DocumentConfig) params() (Params, error) {
|
|
params, err := config.BaseFile.params()
|
|
|
|
params.AddNonEmpty("caption", config.Caption)
|
|
params.AddNonEmpty("parse_mode", config.ParseMode)
|
|
params.AddBool("disable_content_type_detection", config.DisableContentTypeDetection)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config DocumentConfig) method() string {
|
|
return "sendDocument"
|
|
}
|
|
|
|
func (config DocumentConfig) files() []RequestFile {
|
|
files := []RequestFile{{
|
|
Name: "document",
|
|
Data: config.File,
|
|
}}
|
|
|
|
if config.Thumb != nil {
|
|
files = append(files, RequestFile{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
})
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// StickerConfig contains information about a SendSticker request.
|
|
type StickerConfig struct {
|
|
BaseFile
|
|
}
|
|
|
|
func (config StickerConfig) params() (Params, error) {
|
|
return config.BaseChat.params()
|
|
}
|
|
|
|
func (config StickerConfig) method() string {
|
|
return "sendSticker"
|
|
}
|
|
|
|
func (config StickerConfig) files() []RequestFile {
|
|
return []RequestFile{{
|
|
Name: "sticker",
|
|
Data: config.File,
|
|
}}
|
|
}
|
|
|
|
// VideoConfig contains information about a SendVideo request.
|
|
type VideoConfig struct {
|
|
BaseFile
|
|
Thumb RequestFileData
|
|
Duration int
|
|
Caption string
|
|
ParseMode string
|
|
CaptionEntities []MessageEntity
|
|
SupportsStreaming bool
|
|
}
|
|
|
|
func (config VideoConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params.AddNonZero("duration", config.Duration)
|
|
params.AddNonEmpty("caption", config.Caption)
|
|
params.AddNonEmpty("parse_mode", config.ParseMode)
|
|
params.AddBool("supports_streaming", config.SupportsStreaming)
|
|
err = params.AddInterface("caption_entities", config.CaptionEntities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config VideoConfig) method() string {
|
|
return "sendVideo"
|
|
}
|
|
|
|
func (config VideoConfig) files() []RequestFile {
|
|
files := []RequestFile{{
|
|
Name: "video",
|
|
Data: config.File,
|
|
}}
|
|
|
|
if config.Thumb != nil {
|
|
files = append(files, RequestFile{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
})
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// AnimationConfig contains information about a SendAnimation request.
|
|
type AnimationConfig struct {
|
|
BaseFile
|
|
Duration int
|
|
Thumb RequestFileData
|
|
Caption string
|
|
ParseMode string
|
|
CaptionEntities []MessageEntity
|
|
}
|
|
|
|
func (config AnimationConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params.AddNonZero("duration", config.Duration)
|
|
params.AddNonEmpty("caption", config.Caption)
|
|
params.AddNonEmpty("parse_mode", config.ParseMode)
|
|
err = params.AddInterface("caption_entities", config.CaptionEntities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config AnimationConfig) method() string {
|
|
return "sendAnimation"
|
|
}
|
|
|
|
func (config AnimationConfig) files() []RequestFile {
|
|
files := []RequestFile{{
|
|
Name: "animation",
|
|
Data: config.File,
|
|
}}
|
|
|
|
if config.Thumb != nil {
|
|
files = append(files, RequestFile{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
})
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// VideoNoteConfig contains information about a SendVideoNote request.
|
|
type VideoNoteConfig struct {
|
|
BaseFile
|
|
Thumb RequestFileData
|
|
Duration int
|
|
Length int
|
|
}
|
|
|
|
func (config VideoNoteConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
|
|
params.AddNonZero("duration", config.Duration)
|
|
params.AddNonZero("length", config.Length)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config VideoNoteConfig) method() string {
|
|
return "sendVideoNote"
|
|
}
|
|
|
|
func (config VideoNoteConfig) files() []RequestFile {
|
|
files := []RequestFile{{
|
|
Name: "video_note",
|
|
Data: config.File,
|
|
}}
|
|
|
|
if config.Thumb != nil {
|
|
files = append(files, RequestFile{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
})
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// VoiceConfig contains information about a SendVoice request.
|
|
type VoiceConfig struct {
|
|
BaseFile
|
|
Thumb RequestFileData
|
|
Caption string
|
|
ParseMode string
|
|
CaptionEntities []MessageEntity
|
|
Duration int
|
|
}
|
|
|
|
func (config VoiceConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params.AddNonZero("duration", config.Duration)
|
|
params.AddNonEmpty("caption", config.Caption)
|
|
params.AddNonEmpty("parse_mode", config.ParseMode)
|
|
err = params.AddInterface("caption_entities", config.CaptionEntities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config VoiceConfig) method() string {
|
|
return "sendVoice"
|
|
}
|
|
|
|
func (config VoiceConfig) files() []RequestFile {
|
|
files := []RequestFile{{
|
|
Name: "voice",
|
|
Data: config.File,
|
|
}}
|
|
|
|
if config.Thumb != nil {
|
|
files = append(files, RequestFile{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
})
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// LocationConfig contains information about a SendLocation request.
|
|
type LocationConfig struct {
|
|
BaseChat
|
|
Latitude float64 // required
|
|
Longitude float64 // required
|
|
HorizontalAccuracy float64 // optional
|
|
LivePeriod int // optional
|
|
Heading int // optional
|
|
ProximityAlertRadius int // optional
|
|
}
|
|
|
|
func (config LocationConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
|
|
params.AddNonZeroFloat("latitude", config.Latitude)
|
|
params.AddNonZeroFloat("longitude", config.Longitude)
|
|
params.AddNonZeroFloat("horizontal_accuracy", config.HorizontalAccuracy)
|
|
params.AddNonZero("live_period", config.LivePeriod)
|
|
params.AddNonZero("heading", config.Heading)
|
|
params.AddNonZero("proximity_alert_radius", config.ProximityAlertRadius)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config LocationConfig) method() string {
|
|
return "sendLocation"
|
|
}
|
|
|
|
// EditMessageLiveLocationConfig allows you to update a live location.
|
|
type EditMessageLiveLocationConfig struct {
|
|
BaseEdit
|
|
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)
|
|
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"
|
|
}
|
|
|
|
// 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"
|
|
}
|
|
|
|
// VenueConfig contains information about a SendVenue request.
|
|
type VenueConfig struct {
|
|
BaseChat
|
|
Latitude float64 // required
|
|
Longitude float64 // required
|
|
Title string // required
|
|
Address string // required
|
|
FoursquareID string
|
|
FoursquareType string
|
|
GooglePlaceID string
|
|
GooglePlaceType string
|
|
}
|
|
|
|
func (config VenueConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
|
|
params.AddNonZeroFloat("latitude", config.Latitude)
|
|
params.AddNonZeroFloat("longitude", config.Longitude)
|
|
params["title"] = config.Title
|
|
params["address"] = config.Address
|
|
params.AddNonEmpty("foursquare_id", config.FoursquareID)
|
|
params.AddNonEmpty("foursquare_type", config.FoursquareType)
|
|
params.AddNonEmpty("google_place_id", config.GooglePlaceID)
|
|
params.AddNonEmpty("google_place_type", config.GooglePlaceType)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config VenueConfig) method() string {
|
|
return "sendVenue"
|
|
}
|
|
|
|
// ContactConfig allows you to send a contact.
|
|
type ContactConfig struct {
|
|
BaseChat
|
|
PhoneNumber string
|
|
FirstName string
|
|
LastName string
|
|
VCard string
|
|
}
|
|
|
|
func (config ContactConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
|
|
params["phone_number"] = config.PhoneNumber
|
|
params["first_name"] = config.FirstName
|
|
|
|
params.AddNonEmpty("last_name", config.LastName)
|
|
params.AddNonEmpty("vcard", config.VCard)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config ContactConfig) method() string {
|
|
return "sendContact"
|
|
}
|
|
|
|
// SendPollConfig allows you to send a poll.
|
|
type SendPollConfig struct {
|
|
BaseChat
|
|
Question string
|
|
Options []string
|
|
IsAnonymous bool
|
|
Type string
|
|
AllowsMultipleAnswers bool
|
|
CorrectOptionID int64
|
|
Explanation string
|
|
ExplanationParseMode string
|
|
ExplanationEntities []MessageEntity
|
|
OpenPeriod int
|
|
CloseDate int
|
|
IsClosed bool
|
|
}
|
|
|
|
func (config SendPollConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params["question"] = config.Question
|
|
if err = params.AddInterface("options", config.Options); err != nil {
|
|
return params, err
|
|
}
|
|
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)
|
|
params.AddBool("is_closed", config.IsClosed)
|
|
params.AddNonEmpty("explanation", config.Explanation)
|
|
params.AddNonEmpty("explanation_parse_mode", config.ExplanationParseMode)
|
|
params.AddNonZero("open_period", config.OpenPeriod)
|
|
params.AddNonZero("close_date", config.CloseDate)
|
|
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 {
|
|
UserID int64
|
|
Score int
|
|
Force bool
|
|
DisableEditMessage bool
|
|
ChatID int64
|
|
ChannelUsername string
|
|
MessageID int
|
|
InlineMessageID string
|
|
}
|
|
|
|
func (config SetGameScoreConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
params.AddNonZero("scrore", config.Score)
|
|
params.AddBool("disable_edit_message", config.DisableEditMessage)
|
|
|
|
if config.InlineMessageID != "" {
|
|
params["inline_message_id"] = config.InlineMessageID
|
|
} else {
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params.AddNonZero("message_id", config.MessageID)
|
|
}
|
|
|
|
return params, nil
|
|
}
|
|
|
|
func (config SetGameScoreConfig) method() string {
|
|
return "setGameScore"
|
|
}
|
|
|
|
// GetGameHighScoresConfig allows you to fetch the high scores for a game.
|
|
type GetGameHighScoresConfig struct {
|
|
UserID int64
|
|
ChatID int64
|
|
ChannelUsername string
|
|
MessageID int
|
|
InlineMessageID string
|
|
}
|
|
|
|
func (config GetGameHighScoresConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
|
|
if config.InlineMessageID != "" {
|
|
params["inline_message_id"] = config.InlineMessageID
|
|
} else {
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params.AddNonZero("message_id", config.MessageID)
|
|
}
|
|
|
|
return params, nil
|
|
}
|
|
|
|
func (config GetGameHighScoresConfig) method() string {
|
|
return "getGameHighScores"
|
|
}
|
|
|
|
// ChatActionConfig contains information about a SendChatAction request.
|
|
type ChatActionConfig struct {
|
|
BaseChat
|
|
Action string // required
|
|
}
|
|
|
|
func (config ChatActionConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
|
|
params["action"] = config.Action
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config ChatActionConfig) method() string {
|
|
return "sendChatAction"
|
|
}
|
|
|
|
// EditMessageTextConfig allows you to modify the text in a message.
|
|
type EditMessageTextConfig struct {
|
|
BaseEdit
|
|
Text string
|
|
ParseMode string
|
|
Entities []MessageEntity
|
|
DisableWebPagePreview bool
|
|
}
|
|
|
|
func (config EditMessageTextConfig) params() (Params, error) {
|
|
params, err := config.BaseEdit.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params["text"] = config.Text
|
|
params.AddNonEmpty("parse_mode", config.ParseMode)
|
|
params.AddBool("disable_web_page_preview", config.DisableWebPagePreview)
|
|
err = params.AddInterface("entities", config.Entities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config EditMessageTextConfig) method() string {
|
|
return "editMessageText"
|
|
}
|
|
|
|
// EditMessageCaptionConfig allows you to modify the caption of a message.
|
|
type EditMessageCaptionConfig struct {
|
|
BaseEdit
|
|
Caption string
|
|
ParseMode string
|
|
CaptionEntities []MessageEntity
|
|
}
|
|
|
|
func (config EditMessageCaptionConfig) params() (Params, error) {
|
|
params, err := config.BaseEdit.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params["caption"] = config.Caption
|
|
params.AddNonEmpty("parse_mode", config.ParseMode)
|
|
err = params.AddInterface("caption_entities", config.CaptionEntities)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config EditMessageCaptionConfig) method() string {
|
|
return "editMessageCaption"
|
|
}
|
|
|
|
// EditMessageMediaConfig allows you to make an editMessageMedia request.
|
|
type EditMessageMediaConfig struct {
|
|
BaseEdit
|
|
|
|
Media interface{}
|
|
}
|
|
|
|
func (EditMessageMediaConfig) method() string {
|
|
return "editMessageMedia"
|
|
}
|
|
|
|
func (config EditMessageMediaConfig) params() (Params, error) {
|
|
params, err := config.BaseEdit.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
err = params.AddInterface("media", prepareInputMediaParam(config.Media, 0))
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config EditMessageMediaConfig) files() []RequestFile {
|
|
return prepareInputMediaFile(config.Media, 0)
|
|
}
|
|
|
|
// EditMessageReplyMarkupConfig allows you to modify the reply markup
|
|
// of a message.
|
|
type EditMessageReplyMarkupConfig struct {
|
|
BaseEdit
|
|
}
|
|
|
|
func (config EditMessageReplyMarkupConfig) params() (Params, error) {
|
|
return config.BaseEdit.params()
|
|
}
|
|
|
|
func (config EditMessageReplyMarkupConfig) method() string {
|
|
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.
|
|
type UserProfilePhotosConfig struct {
|
|
UserID int64
|
|
Offset int
|
|
Limit int
|
|
}
|
|
|
|
func (UserProfilePhotosConfig) method() string {
|
|
return "getUserProfilePhotos"
|
|
}
|
|
|
|
func (config UserProfilePhotosConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
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.
|
|
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
|
|
}
|
|
|
|
// UpdateConfig contains information about a GetUpdates request.
|
|
type UpdateConfig struct {
|
|
Offset int
|
|
Limit int
|
|
Timeout int
|
|
AllowedUpdates []string
|
|
}
|
|
|
|
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)
|
|
params.AddInterface("allowed_updates", config.AllowedUpdates)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// WebhookConfig contains information about a SetWebhook request.
|
|
type WebhookConfig struct {
|
|
URL *url.URL
|
|
Certificate RequestFileData
|
|
IPAddress string
|
|
MaxConnections int
|
|
AllowedUpdates []string
|
|
DropPendingUpdates bool
|
|
}
|
|
|
|
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()
|
|
}
|
|
|
|
params.AddNonEmpty("ip_address", config.IPAddress)
|
|
params.AddNonZero("max_connections", config.MaxConnections)
|
|
err := params.AddInterface("allowed_updates", config.AllowedUpdates)
|
|
params.AddBool("drop_pending_updates", config.DropPendingUpdates)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config WebhookConfig) files() []RequestFile {
|
|
if config.Certificate != nil {
|
|
return []RequestFile{{
|
|
Name: "certificate",
|
|
Data: config.Certificate,
|
|
}}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteWebhookConfig is a helper to delete a webhook.
|
|
type DeleteWebhookConfig struct {
|
|
DropPendingUpdates bool
|
|
}
|
|
|
|
func (config DeleteWebhookConfig) method() string {
|
|
return "deleteWebhook"
|
|
}
|
|
|
|
func (config DeleteWebhookConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddBool("drop_pending_updates", config.DropPendingUpdates)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// InlineConfig contains information on making an InlineQuery response.
|
|
type InlineConfig struct {
|
|
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) {
|
|
params := make(Params)
|
|
|
|
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)
|
|
err := params.AddInterface("results", config.Results)
|
|
|
|
return params, err
|
|
}
|
|
|
|
// 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) {
|
|
params := make(Params)
|
|
|
|
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)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// 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
|
|
UserID int64
|
|
}
|
|
|
|
// UnbanChatMemberConfig allows you to unban a user.
|
|
type UnbanChatMemberConfig struct {
|
|
ChatMemberConfig
|
|
OnlyIfBanned bool
|
|
}
|
|
|
|
func (config UnbanChatMemberConfig) method() string {
|
|
return "unbanChatMember"
|
|
}
|
|
|
|
func (config UnbanChatMemberConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername, config.ChannelUsername)
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
params.AddBool("only_if_banned", config.OnlyIfBanned)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// BanChatMemberConfig contains extra fields to kick user.
|
|
type BanChatMemberConfig struct {
|
|
ChatMemberConfig
|
|
UntilDate int64
|
|
RevokeMessages bool
|
|
}
|
|
|
|
func (config BanChatMemberConfig) method() string {
|
|
return "banChatMember"
|
|
}
|
|
|
|
func (config BanChatMemberConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
params.AddNonZero64("until_date", config.UntilDate)
|
|
params.AddBool("revoke_messages", config.RevokeMessages)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// KickChatMemberConfig contains extra fields to ban user.
|
|
//
|
|
// This was renamed to BanChatMember in later versions of the Telegram Bot API.
|
|
type KickChatMemberConfig = BanChatMemberConfig
|
|
|
|
// RestrictChatMemberConfig contains fields to restrict members of chat
|
|
type RestrictChatMemberConfig struct {
|
|
ChatMemberConfig
|
|
UntilDate int64
|
|
Permissions *ChatPermissions
|
|
}
|
|
|
|
func (config RestrictChatMemberConfig) method() string {
|
|
return "restrictChatMember"
|
|
}
|
|
|
|
func (config RestrictChatMemberConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername, config.ChannelUsername)
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
|
|
err := params.AddInterface("permissions", config.Permissions)
|
|
params.AddNonZero64("until_date", config.UntilDate)
|
|
|
|
return params, err
|
|
}
|
|
|
|
// PromoteChatMemberConfig contains fields to promote members of chat
|
|
type PromoteChatMemberConfig struct {
|
|
ChatMemberConfig
|
|
IsAnonymous bool
|
|
CanManageChat bool
|
|
CanChangeInfo bool
|
|
CanPostMessages bool
|
|
CanEditMessages bool
|
|
CanDeleteMessages bool
|
|
CanManageVoiceChats bool
|
|
CanInviteUsers bool
|
|
CanRestrictMembers bool
|
|
CanPinMessages bool
|
|
CanPromoteMembers bool
|
|
}
|
|
|
|
func (config PromoteChatMemberConfig) method() string {
|
|
return "promoteChatMember"
|
|
}
|
|
|
|
func (config PromoteChatMemberConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername, config.ChannelUsername)
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
|
|
params.AddBool("is_anonymous", config.IsAnonymous)
|
|
params.AddBool("can_manage_chat", config.CanManageChat)
|
|
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)
|
|
params.AddBool("can_manage_voice_chats", config.CanManageVoiceChats)
|
|
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)
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
params.AddNonEmpty("custom_title", config.CustomTitle)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// BanChatSenderChatConfig bans a channel chat in a supergroup or a channel. The
|
|
// owner of the chat will not be able to send messages and join live streams on
|
|
// behalf of the chat, unless it is unbanned first. The bot must be an
|
|
// administrator in the supergroup or channel for this to work and must have the
|
|
// appropriate administrator rights.
|
|
type BanChatSenderChatConfig struct {
|
|
ChatID int64
|
|
ChannelUsername string
|
|
SenderChatID int64
|
|
UntilDate int
|
|
}
|
|
|
|
func (config BanChatSenderChatConfig) method() string {
|
|
return "banChatSenderChat"
|
|
}
|
|
|
|
func (config BanChatSenderChatConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
_ = params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params.AddNonZero64("sender_chat_id", config.SenderChatID)
|
|
params.AddNonZero("until_date", config.UntilDate)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// UnbanChatSenderChatConfig unbans a previously banned channel chat in a
|
|
// supergroup or channel. The bot must be an administrator for this to work and
|
|
// must have the appropriate administrator rights.
|
|
type UnbanChatSenderChatConfig struct {
|
|
ChatID int64
|
|
ChannelUsername string
|
|
SenderChatID int64
|
|
}
|
|
|
|
func (config UnbanChatSenderChatConfig) method() string {
|
|
return "unbanChatSenderChat"
|
|
}
|
|
|
|
func (config UnbanChatSenderChatConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
_ = params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params.AddNonZero64("sender_chat_id", config.SenderChatID)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// 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"
|
|
}
|
|
|
|
// 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)
|
|
err := params.AddInterface("permissions", config.Permissions)
|
|
|
|
return params, err
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
Name string
|
|
ExpireDate int
|
|
MemberLimit int
|
|
CreatesJoinRequest bool
|
|
}
|
|
|
|
func (CreateChatInviteLinkConfig) method() string {
|
|
return "createChatInviteLink"
|
|
}
|
|
|
|
func (config CreateChatInviteLinkConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddNonEmpty("name", config.Name)
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
params.AddNonZero("expire_date", config.ExpireDate)
|
|
params.AddNonZero("member_limit", config.MemberLimit)
|
|
params.AddBool("creates_join_request", config.CreatesJoinRequest)
|
|
|
|
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
|
|
Name string
|
|
ExpireDate int
|
|
MemberLimit int
|
|
CreatesJoinRequest bool
|
|
}
|
|
|
|
func (EditChatInviteLinkConfig) method() string {
|
|
return "editChatInviteLink"
|
|
}
|
|
|
|
func (config EditChatInviteLinkConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
params.AddNonEmpty("name", config.Name)
|
|
params["invite_link"] = config.InviteLink
|
|
params.AddNonZero("expire_date", config.ExpireDate)
|
|
params.AddNonZero("member_limit", config.MemberLimit)
|
|
params.AddBool("creates_join_request", config.CreatesJoinRequest)
|
|
|
|
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
|
|
}
|
|
|
|
// ApproveChatJoinRequestConfig allows you to approve a chat join request.
|
|
type ApproveChatJoinRequestConfig struct {
|
|
ChatConfig
|
|
UserID int64
|
|
}
|
|
|
|
func (ApproveChatJoinRequestConfig) method() string {
|
|
return "approveChatJoinRequest"
|
|
}
|
|
|
|
func (config ApproveChatJoinRequestConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
params.AddNonZero("user_id", int(config.UserID))
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// DeclineChatJoinRequest allows you to decline a chat join request.
|
|
type DeclineChatJoinRequest struct {
|
|
ChatConfig
|
|
UserID int64
|
|
}
|
|
|
|
func (DeclineChatJoinRequest) method() string {
|
|
return "declineChatJoinRequest"
|
|
}
|
|
|
|
func (config DeclineChatJoinRequest) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
params.AddNonZero("user_id", int(config.UserID))
|
|
|
|
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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// ChatConfigWithUser contains information about a chat and a user.
|
|
type ChatConfigWithUser struct {
|
|
ChatID int64
|
|
SuperGroupUsername string
|
|
UserID int64
|
|
}
|
|
|
|
func (config ChatConfigWithUser) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
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"
|
|
}
|
|
|
|
// InvoiceConfig contains information for sendInvoice request.
|
|
type InvoiceConfig struct {
|
|
BaseChat
|
|
Title string // required
|
|
Description string // required
|
|
Payload string // required
|
|
ProviderToken string // required
|
|
Currency string // required
|
|
Prices []LabeledPrice // required
|
|
MaxTipAmount int
|
|
SuggestedTipAmounts []int
|
|
StartParameter string
|
|
ProviderData string
|
|
PhotoURL string
|
|
PhotoSize int
|
|
PhotoWidth int
|
|
PhotoHeight int
|
|
NeedName bool
|
|
NeedPhoneNumber bool
|
|
NeedEmail bool
|
|
NeedShippingAddress bool
|
|
SendPhoneNumberToProvider bool
|
|
SendEmailToProvider bool
|
|
IsFlexible bool
|
|
}
|
|
|
|
func (config InvoiceConfig) params() (Params, error) {
|
|
params, err := config.BaseChat.params()
|
|
if err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params["title"] = config.Title
|
|
params["description"] = config.Description
|
|
params["payload"] = config.Payload
|
|
params["provider_token"] = config.ProviderToken
|
|
params["currency"] = config.Currency
|
|
if err = params.AddInterface("prices", config.Prices); err != nil {
|
|
return params, err
|
|
}
|
|
|
|
params.AddNonZero("max_tip_amount", config.MaxTipAmount)
|
|
err = params.AddInterface("suggested_tip_amounts", config.SuggestedTipAmounts)
|
|
params.AddNonEmpty("start_parameter", config.StartParameter)
|
|
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)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config InvoiceConfig) method() string {
|
|
return "sendInvoice"
|
|
}
|
|
|
|
// ShippingConfig contains information for answerShippingQuery request.
|
|
type ShippingConfig struct {
|
|
ShippingQueryID string // required
|
|
OK bool // required
|
|
ShippingOptions []ShippingOption
|
|
ErrorMessage string
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
// PreCheckoutConfig conatins information for answerPreCheckoutQuery request.
|
|
type PreCheckoutConfig struct {
|
|
PreCheckoutQueryID string // required
|
|
OK bool // required
|
|
ErrorMessage string
|
|
}
|
|
|
|
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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params.AddNonZero("message_id", config.MessageID)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// PinChatMessageConfig contains information of a message in a chat to pin.
|
|
type PinChatMessageConfig struct {
|
|
ChatID int64
|
|
ChannelUsername string
|
|
MessageID int
|
|
DisableNotification bool
|
|
}
|
|
|
|
func (config PinChatMessageConfig) method() string {
|
|
return "pinChatMessage"
|
|
}
|
|
|
|
func (config PinChatMessageConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params.AddNonZero("message_id", config.MessageID)
|
|
params.AddBool("disable_notification", config.DisableNotification)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// UnpinChatMessageConfig contains information of a chat message to unpin.
|
|
//
|
|
// If MessageID is not specified, it will unpin the most recent pin.
|
|
type UnpinChatMessageConfig struct {
|
|
ChatID int64
|
|
ChannelUsername string
|
|
MessageID int
|
|
}
|
|
|
|
func (config UnpinChatMessageConfig) method() string {
|
|
return "unpinChatMessage"
|
|
}
|
|
|
|
func (config UnpinChatMessageConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
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)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// SetChatPhotoConfig allows you to set a group, supergroup, or channel's photo.
|
|
type SetChatPhotoConfig struct {
|
|
BaseFile
|
|
}
|
|
|
|
func (config SetChatPhotoConfig) method() string {
|
|
return "setChatPhoto"
|
|
}
|
|
|
|
func (config SetChatPhotoConfig) files() []RequestFile {
|
|
return []RequestFile{{
|
|
Name: "photo",
|
|
Data: config.File,
|
|
}}
|
|
}
|
|
|
|
// 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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
|
|
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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params["title"] = config.Title
|
|
|
|
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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params["description"] = config.Description
|
|
|
|
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) {
|
|
params := make(Params)
|
|
|
|
params["name"] = config.Name
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// UploadStickerConfig allows you to upload a sticker for use in a set later.
|
|
type UploadStickerConfig struct {
|
|
UserID int64
|
|
PNGSticker RequestFileData
|
|
}
|
|
|
|
func (config UploadStickerConfig) method() string {
|
|
return "uploadStickerFile"
|
|
}
|
|
|
|
func (config UploadStickerConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
func (config UploadStickerConfig) files() []RequestFile {
|
|
return []RequestFile{{
|
|
Name: "png_sticker",
|
|
Data: config.PNGSticker,
|
|
}}
|
|
}
|
|
|
|
// NewStickerSetConfig allows creating a new sticker set.
|
|
//
|
|
// You must set either PNGSticker or TGSSticker.
|
|
type NewStickerSetConfig struct {
|
|
UserID int64
|
|
Name string
|
|
Title string
|
|
PNGSticker RequestFileData
|
|
TGSSticker RequestFileData
|
|
Emojis string
|
|
ContainsMasks bool
|
|
MaskPosition *MaskPosition
|
|
}
|
|
|
|
func (config NewStickerSetConfig) method() string {
|
|
return "createNewStickerSet"
|
|
}
|
|
|
|
func (config NewStickerSetConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
params["name"] = config.Name
|
|
params["title"] = config.Title
|
|
|
|
params["emojis"] = config.Emojis
|
|
|
|
params.AddBool("contains_masks", config.ContainsMasks)
|
|
|
|
err := params.AddInterface("mask_position", config.MaskPosition)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config NewStickerSetConfig) files() []RequestFile {
|
|
if config.PNGSticker != nil {
|
|
return []RequestFile{{
|
|
Name: "png_sticker",
|
|
Data: config.PNGSticker,
|
|
}}
|
|
}
|
|
|
|
return []RequestFile{{
|
|
Name: "tgs_sticker",
|
|
Data: config.TGSSticker,
|
|
}}
|
|
}
|
|
|
|
// AddStickerConfig allows you to add a sticker to a set.
|
|
type AddStickerConfig struct {
|
|
UserID int64
|
|
Name string
|
|
PNGSticker RequestFileData
|
|
TGSSticker RequestFileData
|
|
Emojis string
|
|
MaskPosition *MaskPosition
|
|
}
|
|
|
|
func (config AddStickerConfig) method() string {
|
|
return "addStickerToSet"
|
|
}
|
|
|
|
func (config AddStickerConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
params["name"] = config.Name
|
|
params["emojis"] = config.Emojis
|
|
|
|
err := params.AddInterface("mask_position", config.MaskPosition)
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config AddStickerConfig) files() []RequestFile {
|
|
if config.PNGSticker != nil {
|
|
return []RequestFile{{
|
|
Name: "png_sticker",
|
|
Data: config.PNGSticker,
|
|
}}
|
|
}
|
|
|
|
return []RequestFile{{
|
|
Name: "tgs_sticker",
|
|
Data: config.TGSSticker,
|
|
}}
|
|
|
|
}
|
|
|
|
// 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) {
|
|
params := make(Params)
|
|
|
|
params["sticker"] = config.Sticker
|
|
params.AddNonZero("position", config.Position)
|
|
|
|
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) {
|
|
params := make(Params)
|
|
|
|
params["sticker"] = config.Sticker
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// SetStickerSetThumbConfig allows you to set the thumbnail for a sticker set.
|
|
type SetStickerSetThumbConfig struct {
|
|
Name string
|
|
UserID int64
|
|
Thumb RequestFileData
|
|
}
|
|
|
|
func (config SetStickerSetThumbConfig) method() string {
|
|
return "setStickerSetThumb"
|
|
}
|
|
|
|
func (config SetStickerSetThumbConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
params["name"] = config.Name
|
|
params.AddNonZero64("user_id", config.UserID)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
func (config SetStickerSetThumbConfig) files() []RequestFile {
|
|
return []RequestFile{{
|
|
Name: "thumb",
|
|
Data: config.Thumb,
|
|
}}
|
|
}
|
|
|
|
// 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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
params["sticker_set_name"] = config.StickerSetName
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// 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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.SuperGroupUsername)
|
|
|
|
return params, nil
|
|
}
|
|
|
|
// 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) {
|
|
params := make(Params)
|
|
|
|
params.AddFirstValid("chat_id", config.ChatID, config.ChannelUsername)
|
|
params.AddBool("disable_notification", config.DisableNotification)
|
|
params.AddNonZero("reply_to_message_id", config.ReplyToMessageID)
|
|
|
|
err := params.AddInterface("media", prepareInputMediaForParams(config.Media))
|
|
|
|
return params, err
|
|
}
|
|
|
|
func (config MediaGroupConfig) files() []RequestFile {
|
|
return prepareInputMediaForFiles(config.Media)
|
|
}
|
|
|
|
// DiceConfig contains information about a sendDice request.
|
|
type DiceConfig struct {
|
|
BaseChat
|
|
// Emoji on which the dice throw animation is based.
|
|
// Currently, must be one of 🎲, 🎯, 🏀, ⚽, 🎳, or 🎰.
|
|
// Dice can have values 1-6 for 🎲, 🎯, and 🎳, values 1-5 for 🏀 and ⚽,
|
|
// and values 1-64 for 🎰.
|
|
// 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
|
|
}
|
|
|
|
// GetMyCommandsConfig gets a list of the currently registered commands.
|
|
type GetMyCommandsConfig struct {
|
|
Scope *BotCommandScope
|
|
LanguageCode string
|
|
}
|
|
|
|
func (config GetMyCommandsConfig) method() string {
|
|
return "getMyCommands"
|
|
}
|
|
|
|
func (config GetMyCommandsConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
err := params.AddInterface("scope", config.Scope)
|
|
params.AddNonEmpty("language_code", config.LanguageCode)
|
|
|
|
return params, err
|
|
}
|
|
|
|
// SetMyCommandsConfig sets a list of commands the bot understands.
|
|
type SetMyCommandsConfig struct {
|
|
Commands []BotCommand
|
|
Scope *BotCommandScope
|
|
LanguageCode string
|
|
}
|
|
|
|
func (config SetMyCommandsConfig) method() string {
|
|
return "setMyCommands"
|
|
}
|
|
|
|
func (config SetMyCommandsConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
if err := params.AddInterface("commands", config.Commands); err != nil {
|
|
return params, err
|
|
}
|
|
err := params.AddInterface("scope", config.Scope)
|
|
params.AddNonEmpty("language_code", config.LanguageCode)
|
|
|
|
return params, err
|
|
}
|
|
|
|
type DeleteMyCommandsConfig struct {
|
|
Scope *BotCommandScope
|
|
LanguageCode string
|
|
}
|
|
|
|
func (config DeleteMyCommandsConfig) method() string {
|
|
return "deleteMyCommands"
|
|
}
|
|
|
|
func (config DeleteMyCommandsConfig) params() (Params, error) {
|
|
params := make(Params)
|
|
|
|
err := params.AddInterface("scope", config.Scope)
|
|
params.AddNonEmpty("language_code", config.LanguageCode)
|
|
|
|
return params, err
|
|
}
|
|
|
|
// prepareInputMediaParam evaluates a single InputMedia and determines if it
|
|
// needs to be modified for a successful upload. If it returns nil, then the
|
|
// value does not need to be included in the params. Otherwise, it will return
|
|
// the same type as was originally provided.
|
|
//
|
|
// The idx is used to calculate the file field name. If you only have a single
|
|
// file, 0 may be used. It is formatted into "attach://file-%d" for the primary
|
|
// media and "attach://file-%d-thumb" for thumbnails.
|
|
//
|
|
// It is expected to be used in conjunction with prepareInputMediaFile.
|
|
func prepareInputMediaParam(inputMedia interface{}, idx int) interface{} {
|
|
switch m := inputMedia.(type) {
|
|
case InputMediaPhoto:
|
|
if m.Media.NeedsUpload() {
|
|
m.Media = fileAttach(fmt.Sprintf("attach://file-%d", idx))
|
|
}
|
|
|
|
return m
|
|
case InputMediaVideo:
|
|
if m.Media.NeedsUpload() {
|
|
m.Media = fileAttach(fmt.Sprintf("attach://file-%d", idx))
|
|
}
|
|
|
|
if m.Thumb != nil && m.Thumb.NeedsUpload() {
|
|
m.Thumb = fileAttach(fmt.Sprintf("attach://file-%d-thumb", idx))
|
|
}
|
|
|
|
return m
|
|
case InputMediaAudio:
|
|
if m.Media.NeedsUpload() {
|
|
m.Media = fileAttach(fmt.Sprintf("attach://file-%d", idx))
|
|
}
|
|
|
|
if m.Thumb != nil && m.Thumb.NeedsUpload() {
|
|
m.Thumb = fileAttach(fmt.Sprintf("attach://file-%d-thumb", idx))
|
|
}
|
|
|
|
return m
|
|
case InputMediaDocument:
|
|
if m.Media.NeedsUpload() {
|
|
m.Media = fileAttach(fmt.Sprintf("attach://file-%d", idx))
|
|
}
|
|
|
|
if m.Thumb != nil && m.Thumb.NeedsUpload() {
|
|
m.Thumb = fileAttach(fmt.Sprintf("attach://file-%d-thumb", idx))
|
|
}
|
|
|
|
return m
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// prepareInputMediaFile generates an array of RequestFile to provide for
|
|
// Fileable's files method. It returns an array as a single InputMedia may have
|
|
// multiple files, for the primary media and a thumbnail.
|
|
//
|
|
// The idx parameter is used to generate file field names. It uses the names
|
|
// "file-%d" for the main file and "file-%d-thumb" for the thumbnail.
|
|
//
|
|
// It is expected to be used in conjunction with prepareInputMediaParam.
|
|
func prepareInputMediaFile(inputMedia interface{}, idx int) []RequestFile {
|
|
files := []RequestFile{}
|
|
|
|
switch m := inputMedia.(type) {
|
|
case InputMediaPhoto:
|
|
if m.Media.NeedsUpload() {
|
|
files = append(files, RequestFile{
|
|
Name: fmt.Sprintf("file-%d", idx),
|
|
Data: m.Media,
|
|
})
|
|
}
|
|
case InputMediaVideo:
|
|
if m.Media.NeedsUpload() {
|
|
files = append(files, RequestFile{
|
|
Name: fmt.Sprintf("file-%d", idx),
|
|
Data: m.Media,
|
|
})
|
|
}
|
|
|
|
if m.Thumb != nil && m.Thumb.NeedsUpload() {
|
|
files = append(files, RequestFile{
|
|
Name: fmt.Sprintf("file-%d", idx),
|
|
Data: m.Thumb,
|
|
})
|
|
}
|
|
case InputMediaDocument:
|
|
if m.Media.NeedsUpload() {
|
|
files = append(files, RequestFile{
|
|
Name: fmt.Sprintf("file-%d", idx),
|
|
Data: m.Media,
|
|
})
|
|
}
|
|
|
|
if m.Thumb != nil && m.Thumb.NeedsUpload() {
|
|
files = append(files, RequestFile{
|
|
Name: fmt.Sprintf("file-%d", idx),
|
|
Data: m.Thumb,
|
|
})
|
|
}
|
|
case InputMediaAudio:
|
|
if m.Media.NeedsUpload() {
|
|
files = append(files, RequestFile{
|
|
Name: fmt.Sprintf("file-%d", idx),
|
|
Data: m.Media,
|
|
})
|
|
}
|
|
|
|
if m.Thumb != nil && m.Thumb.NeedsUpload() {
|
|
files = append(files, RequestFile{
|
|
Name: fmt.Sprintf("file-%d", idx),
|
|
Data: m.Thumb,
|
|
})
|
|
}
|
|
}
|
|
|
|
return files
|
|
}
|
|
|
|
// prepareInputMediaForParams calls prepareInputMediaParam for each item
|
|
// provided and returns a new array with the correct params for a request.
|
|
//
|
|
// It is expected that files will get data from the associated function,
|
|
// prepareInputMediaForFiles.
|
|
func prepareInputMediaForParams(inputMedia []interface{}) []interface{} {
|
|
newMedia := make([]interface{}, len(inputMedia))
|
|
copy(newMedia, inputMedia)
|
|
|
|
for idx, media := range inputMedia {
|
|
if param := prepareInputMediaParam(media, idx); param != nil {
|
|
newMedia[idx] = param
|
|
}
|
|
}
|
|
|
|
return newMedia
|
|
}
|
|
|
|
// prepareInputMediaForFiles calls prepareInputMediaFile for each item
|
|
// provided and returns a new array with the correct files for a request.
|
|
//
|
|
// It is expected that params will get data from the associated function,
|
|
// prepareInputMediaForParams.
|
|
func prepareInputMediaForFiles(inputMedia []interface{}) []RequestFile {
|
|
files := []RequestFile{}
|
|
|
|
for idx, media := range inputMedia {
|
|
if file := prepareInputMediaFile(media, idx); file != nil {
|
|
files = append(files, file...)
|
|
}
|
|
}
|
|
|
|
return files
|
|
}
|