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

use crate::errors::Result;
use crate::types::*;
use uuid::Uuid;

/// Asynchronously uploads a file to the cloud without sending it in a message. updateFile will be used to notify about upload progress and successful completion of the upload. The file will not have a persistent remote identifier until it will be sent in a message
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UploadFile {
    #[doc(hidden)]
    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
    extra: Option<String>,
    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
    client_id: Option<i32>,
    /// File to upload

    #[serde(skip_serializing_if = "InputFile::_is_default")]
    file: InputFile,
    /// File type; pass null if unknown

    #[serde(skip_serializing_if = "FileType::_is_default")]
    file_type: FileType,
    /// Priority of the upload (1-32). The higher the priority, the earlier the file will be uploaded. If the priorities of two files are equal, then the first one for which uploadFile was called will be uploaded first

    #[serde(default)]
    priority: i32,

    #[serde(rename(serialize = "@type"))]
    td_type: String,
}

impl RObject for UploadFile {
    #[doc(hidden)]
    fn extra(&self) -> Option<&str> {
        self.extra.as_deref()
    }
    #[doc(hidden)]
    fn client_id(&self) -> Option<i32> {
        self.client_id
    }
}

impl RFunction for UploadFile {}

impl UploadFile {
    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
        Ok(serde_json::from_str(json.as_ref())?)
    }
    pub fn builder() -> UploadFileBuilder {
        let mut inner = UploadFile::default();
        inner.extra = Some(Uuid::new_v4().to_string());

        inner.td_type = "uploadFile".to_string();

        UploadFileBuilder { inner }
    }

    pub fn file(&self) -> &InputFile {
        &self.file
    }

    pub fn file_type(&self) -> &FileType {
        &self.file_type
    }

    pub fn priority(&self) -> i32 {
        self.priority
    }
}

#[doc(hidden)]
pub struct UploadFileBuilder {
    inner: UploadFile,
}

#[deprecated]
pub type RTDUploadFileBuilder = UploadFileBuilder;

impl UploadFileBuilder {
    pub fn build(&self) -> UploadFile {
        self.inner.clone()
    }

    pub fn file<T: AsRef<InputFile>>(&mut self, file: T) -> &mut Self {
        self.inner.file = file.as_ref().clone();
        self
    }

    pub fn file_type<T: AsRef<FileType>>(&mut self, file_type: T) -> &mut Self {
        self.inner.file_type = file_type.as_ref().clone();
        self
    }

    pub fn priority(&mut self, priority: i32) -> &mut Self {
        self.inner.priority = priority;
        self
    }
}

impl AsRef<UploadFile> for UploadFile {
    fn as_ref(&self) -> &UploadFile {
        self
    }
}

impl AsRef<UploadFile> for UploadFileBuilder {
    fn as_ref(&self) -> &UploadFile {
        &self.inner
    }
}