rusp_lib/usp_builder/
delete.rs

1use crate::usp::mod_Body::OneOfmsg_body::{request, response};
2use crate::usp::mod_DeleteResp::mod_DeletedObjectResult::mod_OperationStatus::{
3    OneOfoper_status::{oper_failure, oper_success},
4    OperationFailure, OperationSuccess,
5};
6use crate::usp::mod_DeleteResp::UnaffectedPathError;
7use crate::usp::mod_DeleteResp::{mod_DeletedObjectResult::OperationStatus, DeletedObjectResult};
8use crate::usp::mod_Request::OneOfreq_type::delete;
9use crate::usp::mod_Response::OneOfresp_type::delete_resp;
10use crate::usp::{Body, Delete, DeleteResp, Request, Response};
11use crate::usp_errors;
12
13use anyhow::Result;
14
15#[derive(Clone)]
16pub struct DeleteBuilder {
17    allow_partial: bool,
18    obj_paths: Vec<String>,
19}
20
21impl DeleteBuilder {
22    #[must_use]
23    pub const fn new() -> Self {
24        Self {
25            allow_partial: false,
26            obj_paths: vec![],
27        }
28    }
29
30    #[must_use]
31    pub const fn with_allow_partial(mut self, allow_partial: bool) -> Self {
32        self.allow_partial = allow_partial;
33        self
34    }
35
36    #[must_use]
37    pub fn with_obj_paths(mut self, params: Vec<String>) -> Self {
38        self.obj_paths = params;
39        self
40    }
41
42    pub fn build(self) -> Result<Body> {
43        Ok(Body {
44            msg_body: request({
45                Request {
46                    req_type: delete({
47                        Delete {
48                            allow_partial: self.allow_partial,
49                            obj_paths: self.obj_paths,
50                        }
51                    }),
52                }
53            }),
54        })
55    }
56}
57
58#[derive(Clone)]
59pub struct DeleteRespUnaffectedPathError {
60    pub unaffected_path: String,
61    pub err_code: u32,
62    pub err_msg: String,
63}
64
65#[derive(Clone)]
66pub struct DeleteRespOperationSuccessBuilder {
67    affected_paths: Vec<String>,
68    unaffected_path_errs: Vec<DeleteRespUnaffectedPathError>,
69}
70
71#[derive(Clone)]
72pub enum DeleteRespOperationStatus {
73    Failure { err_code: u32, err_msg: String },
74    Success(DeleteRespOperationSuccessBuilder),
75    None,
76}
77
78#[derive(Clone)]
79pub struct DeletedObjectResultsBuilder {
80    requested_path: String,
81    oper_status: DeleteRespOperationStatus,
82}
83
84impl DeletedObjectResultsBuilder {
85    #[must_use]
86    pub const fn new(requested_path: String) -> Self {
87        Self {
88            requested_path,
89            oper_status: DeleteRespOperationStatus::None,
90        }
91    }
92
93    #[must_use]
94    pub fn set_failure(mut self, err_code: u32, err_msg: Option<String>) -> Self {
95        self.oper_status = DeleteRespOperationStatus::Failure {
96            err_code,
97            err_msg: err_msg.unwrap_or_else(|| usp_errors::get_err_msg(err_code).to_string()),
98        };
99        self
100    }
101
102    #[must_use]
103    pub fn set_success(
104        mut self,
105        affected_paths: Vec<String>,
106        unaffected_path_errs: Vec<DeleteRespUnaffectedPathError>,
107    ) -> Self {
108        self.oper_status = DeleteRespOperationStatus::Success(DeleteRespOperationSuccessBuilder {
109            affected_paths,
110            unaffected_path_errs,
111        });
112        self
113    }
114
115    pub fn build(self) -> Result<DeletedObjectResult> {
116        Ok(DeletedObjectResult {
117            requested_path: self.requested_path,
118            oper_status: match self.oper_status {
119                DeleteRespOperationStatus::Success(s) => Some(OperationStatus {
120                    oper_status: oper_success(OperationSuccess {
121                        affected_paths: s.affected_paths,
122                        unaffected_path_errs: s
123                            .unaffected_path_errs
124                            .into_iter()
125                            .map(|e| UnaffectedPathError {
126                                unaffected_path: e.unaffected_path,
127                                err_code: e.err_code,
128                                err_msg: if e.err_msg.is_empty() {
129                                    usp_errors::get_err_msg(e.err_code).into()
130                                } else {
131                                    e.err_msg
132                                },
133                            })
134                            .collect(),
135                    }),
136                }),
137                DeleteRespOperationStatus::Failure { err_code, err_msg } => Some(OperationStatus {
138                    oper_status: oper_failure(OperationFailure { err_code, err_msg }),
139                }),
140                DeleteRespOperationStatus::None => Err(anyhow::anyhow!(""))?,
141            },
142        })
143    }
144}
145
146#[derive(Clone)]
147pub struct DeleteRespBuilder {
148    deleted_obj_results: Vec<DeletedObjectResultsBuilder>,
149}
150
151impl DeleteRespBuilder {
152    #[must_use]
153    pub const fn new() -> Self {
154        Self {
155            deleted_obj_results: vec![],
156        }
157    }
158
159    #[must_use]
160    pub fn with_deleted_obj_results(
161        mut self,
162        deleted_obj_results: Vec<DeletedObjectResultsBuilder>,
163    ) -> Self {
164        self.deleted_obj_results = deleted_obj_results;
165        self
166    }
167
168    pub fn build(self) -> Result<Body> {
169        Ok(Body {
170            msg_body: response({
171                Response {
172                    resp_type: delete_resp({
173                        DeleteResp {
174                            deleted_obj_results: self
175                                .deleted_obj_results
176                                .into_iter()
177                                .map(DeletedObjectResultsBuilder::build)
178                                .collect::<Result<Vec<_>>>()?,
179                        }
180                    }),
181                }
182            }),
183        })
184    }
185}
rusp_lib/usp_builder/delete.rs

rusp_lib/usp_builder/
delete.rs
