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

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::create::FloatImageData;

impl SpreadsheetSheetService {
    /// 更新浮动图片
    pub async fn update_float_image(
        &self,
        request: UpdateFloatImageRequest,
        option: Option<RequestOption>,
    ) -> SDKResult<BaseResponse<UpdateFloatImageResponseData>> {
        let mut api_req = request.api_request;
        api_req.http_method = Method::PATCH;
        api_req.api_path = SHEETS_V3_SPREADSHEET_FLOAT_IMAGE_GET
            .replace("{}", &request.spreadsheet_token)
            .replace("{}", &request.sheet_id)
            .replace("{}", &request.float_image_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 UpdateFloatImageRequest {
    #[serde(skip)]
    api_request: ApiRequest,
    /// spreadsheet 的 token
    spreadsheet_token: String,
    /// sheet 的 id
    sheet_id: String,
    /// 浮动图片 ID
    float_image_id: String,
    /// 新的浮动图片信息
    float_image: FloatImageData,
}

impl UpdateFloatImageRequest {
    pub fn builder() -> UpdateFloatImageRequestBuilder {
        UpdateFloatImageRequestBuilder::default()
    }
}

#[derive(Default)]
pub struct UpdateFloatImageRequestBuilder {
    request: UpdateFloatImageRequest,
}

impl UpdateFloatImageRequestBuilder {
    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 float_image_id(mut self, float_image_id: impl ToString) -> Self {
        self.request.float_image_id = float_image_id.to_string();
        self
    }

    pub fn float_image(mut self, float_image: FloatImageData) -> Self {
        self.request.float_image = float_image;
        self
    }

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

impl_executable_builder_owned!(
    UpdateFloatImageRequestBuilder,
    SpreadsheetSheetService,
    UpdateFloatImageRequest,
    BaseResponse<UpdateFloatImageResponseData>,
    update_float_image
);

/// 更新浮动图片响应体最外层
#[derive(Deserialize, Debug)]
pub struct UpdateFloatImageResponseData {
    /// 浮动图片 ID
    pub float_image_id: String,
    /// 更新后的浮动图片信息
    #[serde(flatten)]
    pub float_image: FloatImageData,
}

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

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

    #[test]
    fn test_update_float_image_response() {
        let json = json!({
            "float_image_id": "fimg_001",
            "image_token": "img_token_456",
            "position": {
                "start_col_index": 2,
                "start_row_index": 2,
                "offset_x": 15.0,
                "offset_y": 25.0
            },
            "size": {
                "width": 300.0,
                "height": 200.0
            },
            "name": "更新后的图片"
        });

        let response: UpdateFloatImageResponseData = serde_json::from_value(json).unwrap();
        assert_eq!(response.float_image_id, "fimg_001");
        assert_eq!(response.float_image.image_token, "img_token_456");
        assert_eq!(response.float_image.size.width, 300.0);
    }
}