1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::{
    net,
    requests::{form_builder::FormBuilder, Request, ResponseResult},
    types::{InputFile, MaskPosition, True},
    Bot,
};
use std::sync::Arc;

/// Use this method to create new sticker set owned by a user. The bot will be
/// able to edit the created sticker set.
///
/// [The official docs](https://core.telegram.org/bots/api#createnewstickerset).
#[derive(Debug, Clone)]
pub struct CreateNewStickerSet {
    bot: Arc<Bot>,
    user_id: i32,
    name: String,
    title: String,
    png_sticker: InputFile,
    emojis: String,
    contains_masks: Option<bool>,
    mask_position: Option<MaskPosition>,
}

#[async_trait::async_trait]
impl Request for CreateNewStickerSet {
    type Output = True;

    async fn send(&self) -> ResponseResult<True> {
        net::request_multipart(
            self.bot.client(),
            self.bot.token(),
            "createNewStickerSet",
            FormBuilder::new()
                .add("user_id", &self.user_id)
                .await
                .add("name", &self.name)
                .await
                .add("title", &self.title)
                .await
                .add("png_sticker", &self.png_sticker)
                .await
                .add("emojis", &self.emojis)
                .await
                .add("contains_masks", &self.contains_masks)
                .await
                .add("mask_position", &self.mask_position)
                .await
                .build(),
        )
        .await
    }
}

impl CreateNewStickerSet {
    pub(crate) fn new<N, T, E>(
        bot: Arc<Bot>,
        user_id: i32,
        name: N,
        title: T,
        png_sticker: InputFile,
        emojis: E,
    ) -> Self
    where
        N: Into<String>,
        T: Into<String>,
        E: Into<String>,
    {
        Self {
            bot,
            user_id,
            name: name.into(),
            title: title.into(),
            png_sticker,
            emojis: emojis.into(),
            contains_masks: None,
            mask_position: None,
        }
    }

    /// User identifier of created sticker set owner.
    pub fn user_id(mut self, val: i32) -> Self {
        self.user_id = val;
        self
    }

    /// Short name of sticker set, to be used in `t.me/addstickers/` URLs (e.g.,
    /// animals). Can contain only english letters, digits and underscores.
    ///
    /// Must begin with a letter, can't contain consecutive underscores and must
    /// end in `_by_<bot username>`. `<bot_username>` is case insensitive.
    /// 1-64 characters.
    pub fn name<T>(mut self, val: T) -> Self
    where
        T: Into<String>,
    {
        self.name = val.into();
        self
    }

    /// Sticker set title, 1-64 characters.
    pub fn title<T>(mut self, val: T) -> Self
    where
        T: Into<String>,
    {
        self.title = val.into();
        self
    }

    /// **Png** image with the sticker, must be up to 512 kilobytes in size,
    /// dimensions must not exceed 512px, and either width or height must be
    /// exactly 512px.
    ///
    /// Pass [`InputFile::File`] to send a file that exists on
    /// the Telegram servers (recommended), pass an [`InputFile::Url`] for
    /// Telegram to get a .webp file from the Internet, or upload a new one
    /// using [`InputFile::FileId`]. [More info on Sending Files »].
    ///
    /// [`InputFile::File`]: crate::types::InputFile::File
    /// [`InputFile::Url`]: crate::types::InputFile::Url
    /// [`InputFile::FileId`]: crate::types::InputFile::FileId
    pub fn png_sticker(mut self, val: InputFile) -> Self {
        self.png_sticker = val;
        self
    }

    /// One or more emoji corresponding to the sticker.
    pub fn emojis<T>(mut self, val: T) -> Self
    where
        T: Into<String>,
    {
        self.emojis = val.into();
        self
    }

    /// Pass `true`, if a set of mask stickers should be created.
    pub fn contains_masks(mut self, val: bool) -> Self {
        self.contains_masks = Some(val);
        self
    }

    /// A JSON-serialized object for position where the mask should be placed on
    /// faces.
    pub fn mask_position(mut self, val: MaskPosition) -> Self {
        self.mask_position = Some(val);
        self
    }
}