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

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

/// Downloads a file from the cloud. Download progress and completion of the download will be notified through updateFile updates
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DownloadFile {
    #[doc(hidden)]
    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
    extra: Option<String>,
    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
    client_id: Option<i32>,
    /// Identifier of the file to download

    #[serde(default)]
    file_id: i32,
    /// Priority of the download (1-32). The higher the priority, the earlier the file will be downloaded. If the priorities of two files are equal, then the last one for which downloadFile was called will be downloaded first

    #[serde(default)]
    priority: i32,
    /// The starting position from which the file needs to be downloaded

    #[serde(default)]
    offset: i32,
    /// Number of bytes which need to be downloaded starting from the "offset" position before the download will automatically be canceled; use 0 to download without a limit

    #[serde(default)]
    limit: i32,
    /// If false, this request returns file state just after the download has been started. If true, this request returns file state only after the download has succeeded, has failed, has been canceled or a new downloadFile request with different offset/limit parameters was sent

    #[serde(default)]
    synchronous: bool,

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

impl RObject for DownloadFile {
    #[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 DownloadFile {}

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

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

        DownloadFileBuilder { inner }
    }

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

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

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

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

    pub fn synchronous(&self) -> bool {
        self.synchronous
    }
}

#[doc(hidden)]
pub struct DownloadFileBuilder {
    inner: DownloadFile,
}

#[deprecated]
pub type RTDDownloadFileBuilder = DownloadFileBuilder;

impl DownloadFileBuilder {
    pub fn build(&self) -> DownloadFile {
        self.inner.clone()
    }

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

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

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

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

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

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

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