open-lark 0.14.0

Enterprise-grade Lark/Feishu Open API SDK with comprehensive Chinese documentation and advanced error handling
Documentation 
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
149
150
151
152
153
154
155
156

use reqwest::Method;
use serde::{Deserialize, Serialize};

use crate::{
    core::{
        api_req::ApiRequest,
        api_resp::{ApiResponseTrait, BaseResponse, ResponseFormat},
        constants::AccessTokenType,
        endpoints::cloud_docs::*,
        http::Transport,
        req_option::RequestOption,
        SDKResult,
    },
    impl_executable_builder_owned,
    service::sheets::v3::SpreadsheetSheetService,
};

use super::get::FloatImageInfo;

impl SpreadsheetSheetService {
    /// 查询浮动图片
    pub async fn query_float_images(
        &self,
        request: QueryFloatImagesRequest,
        option: Option<RequestOption>,
    ) -> SDKResult<BaseResponse<QueryFloatImagesResponseData>> {
        let mut api_req = request.api_request;
        api_req.http_method = Method::GET;
        api_req.api_path = SHEETS_V3_SPREADSHEET_FLOAT_IMAGES
            .replace("{}", &request.spreadsheet_token)
            .replace("{}", &request.sheet_id);
        api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];

        let api_resp = Transport::request(api_req, &self.config, option).await?;

        Ok(api_resp)
    }
}

/// 查询浮动图片请求
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct QueryFloatImagesRequest {
    #[serde(skip)]
    api_request: ApiRequest,
    /// spreadsheet 的 token
    spreadsheet_token: String,
    /// sheet 的 id
    sheet_id: String,
}

impl QueryFloatImagesRequest {
    pub fn builder() -> QueryFloatImagesRequestBuilder {
        QueryFloatImagesRequestBuilder::default()
    }
}

#[derive(Default)]
pub struct QueryFloatImagesRequestBuilder {
    request: QueryFloatImagesRequest,
}

impl QueryFloatImagesRequestBuilder {
    pub fn spreadsheet_token(mut self, spreadsheet_token: impl ToString) -> Self {
        self.request.spreadsheet_token = spreadsheet_token.to_string();
        self
    }

    pub fn sheet_id(mut self, sheet_id: impl ToString) -> Self {
        self.request.sheet_id = sheet_id.to_string();
        self
    }

    pub fn build(mut self) -> QueryFloatImagesRequest {
        self.request.api_request.body = serde_json::to_vec(&self.request).unwrap();
        self.request
    }
}

impl_executable_builder_owned!(
    QueryFloatImagesRequestBuilder,
    SpreadsheetSheetService,
    QueryFloatImagesRequest,
    BaseResponse<QueryFloatImagesResponseData>,
    query_float_images
);

/// 查询浮动图片响应体最外层
#[derive(Deserialize, Debug)]
pub struct QueryFloatImagesResponseData {
    /// 浮动图片列表
    pub items: Vec<FloatImageInfo>,
    /// 是否还有更多数据
    #[serde(default)]
    pub has_more: bool,
    /// 下次请求的页面标记
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
}

impl ApiResponseTrait for QueryFloatImagesResponseData {
    fn data_format() -> ResponseFormat {
        ResponseFormat::Data
    }
}

#[cfg(test)]
#[allow(unused_variables, unused_unsafe)]
mod test {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_query_float_images_response() {
        let json = json!({
            "items": [
                {
                    "float_image_id": "fimg_001",
                    "image_token": "img_token_123",
                    "position": {
                        "start_col_index": 1,
                        "start_row_index": 1,
                        "offset_x": 10.0,
                        "offset_y": 20.0
                    },
                    "size": {
                        "width": 200.0,
                        "height": 150.0
                    },
                    "name": "图片1"
                },
                {
                    "float_image_id": "fimg_002",
                    "image_token": "img_token_456",
                    "position": {
                        "start_col_index": 3,
                        "start_row_index": 3,
                        "offset_x": 0.0,
                        "offset_y": 0.0
                    },
                    "size": {
                        "width": 150.0,
                        "height": 100.0
                    },
                    "name": "图片2"
                }
            ],
            "has_more": false
        });

        let response: QueryFloatImagesResponseData = serde_json::from_value(json).unwrap();
        assert_eq!(response.items.len(), 2);
        assert_eq!(response.items[0].float_image_id, "fimg_001");
        assert_eq!(response.items[1].float_image.image_token, "img_token_456");
        assert!(!response.has_more);
    }
}