1use super::{LoopsClient, Page, check};
2use crate::error::Result;
3use crate::generated::{
4 CreateCampaignGroupRequest, CreateCampaignGroupResponse, CreateGroupRequest,
5 CreateTransactionalGroupRequest, CreateWorkflowGroupRequest, GetCampaignGroupRequest,
6 GetCampaignGroupResponse, GetTransactionalGroupRequest, GetWorkflowGroupRequest, GroupResponse,
7 ListCampaignGroupsRequest, ListCampaignGroupsRequestQuery, ListCampaignGroupsResponse,
8 ListGroupsResponse, ListTransactionalGroupsRequest, ListTransactionalGroupsRequestQuery,
9 ListWorkflowGroupsRequest, ListWorkflowGroupsRequestQuery, UpdateCampaignGroupRequest,
10 UpdateGroupRequest, UpdateTransactionalGroupRequest, UpdateWorkflowGroupRequest,
11};
12use crate::routes::Route;
13
14impl LoopsClient {
15 pub async fn list_campaign_groups(&self, page: Page) -> Result<ListGroupsResponse> {
17 const ACTION: &str = "list campaign groups";
18 let query = ListCampaignGroupsRequestQuery {
19 per_page: page.per_page_param(),
20 cursor: page.cursor,
21 };
22 let raw = self
23 .send(Route::ListCampaignGroups, &[], |r| r.query(&query))
24 .await?;
25 match raw
26 .parse(ACTION, ListCampaignGroupsRequest::parse_response)
27 .await?
28 {
29 ListCampaignGroupsResponse::Ok(groups) => Ok(groups),
30 _ => Err(raw.unexpected(ACTION)),
31 }
32 }
33
34 pub async fn get_campaign_group(&self, campaign_group_id: &str) -> Result<GroupResponse> {
36 const ACTION: &str = "get campaign group";
37 let raw = self
38 .send(Route::GetCampaignGroup, &[campaign_group_id], |r| r)
39 .await?;
40 match raw
41 .parse(ACTION, GetCampaignGroupRequest::parse_response)
42 .await?
43 {
44 GetCampaignGroupResponse::Ok(group) => Ok(group),
45 _ => Err(raw.unexpected(ACTION)),
46 }
47 }
48
49 pub async fn create_campaign_group(
51 &self,
52 name: &str,
53 description: Option<&str>,
54 ) -> Result<GroupResponse> {
55 const ACTION: &str = "create campaign group";
56 let body = group_body(name, description);
57 check(&body)?;
58 let raw = self
59 .send(Route::CreateCampaignGroup, &[], |r| r.json(&body))
60 .await?;
61 match raw
62 .parse(ACTION, CreateCampaignGroupRequest::parse_response)
63 .await?
64 {
65 CreateCampaignGroupResponse::Ok(group) => Ok(group),
66 _ => Err(raw.unexpected(ACTION)),
67 }
68 }
69
70 pub async fn update_campaign_group(
72 &self,
73 campaign_group_id: &str,
74 name: Option<&str>,
75 description: Option<&str>,
76 ) -> Result<GroupResponse> {
77 const ACTION: &str = "update campaign group";
78 let body = UpdateGroupRequest {
79 name: name.map(str::to_owned),
80 description: description.map(str::to_owned),
81 };
82 let raw = self
83 .send(Route::UpdateCampaignGroup, &[campaign_group_id], |r| {
84 r.json(&body)
85 })
86 .await?;
87 match raw
88 .parse(ACTION, UpdateCampaignGroupRequest::parse_response)
89 .await?
90 {
91 GetCampaignGroupResponse::Ok(group) => Ok(group),
92 _ => Err(raw.unexpected(ACTION)),
93 }
94 }
95
96 pub async fn list_transactional_groups(&self, page: Page) -> Result<ListGroupsResponse> {
98 const ACTION: &str = "list transactional groups";
99 let query = ListTransactionalGroupsRequestQuery {
100 per_page: page.per_page_param(),
101 cursor: page.cursor,
102 };
103 let raw = self
104 .send(Route::ListTransactionalGroups, &[], |r| r.query(&query))
105 .await?;
106 match raw
107 .parse(ACTION, ListTransactionalGroupsRequest::parse_response)
108 .await?
109 {
110 ListCampaignGroupsResponse::Ok(groups) => Ok(groups),
111 _ => Err(raw.unexpected(ACTION)),
112 }
113 }
114
115 pub async fn get_transactional_group(
117 &self,
118 transactional_group_id: &str,
119 ) -> Result<GroupResponse> {
120 const ACTION: &str = "get transactional group";
121 let raw = self
122 .send(
123 Route::GetTransactionalGroup,
124 &[transactional_group_id],
125 |r| r,
126 )
127 .await?;
128 match raw
129 .parse(ACTION, GetTransactionalGroupRequest::parse_response)
130 .await?
131 {
132 GetCampaignGroupResponse::Ok(group) => Ok(group),
133 _ => Err(raw.unexpected(ACTION)),
134 }
135 }
136
137 pub async fn create_transactional_group(
139 &self,
140 name: &str,
141 description: Option<&str>,
142 ) -> Result<GroupResponse> {
143 const ACTION: &str = "create transactional group";
144 let body = group_body(name, description);
145 check(&body)?;
146 let raw = self
147 .send(Route::CreateTransactionalGroup, &[], |r| r.json(&body))
148 .await?;
149 match raw
150 .parse(ACTION, CreateTransactionalGroupRequest::parse_response)
151 .await?
152 {
153 CreateCampaignGroupResponse::Ok(group) => Ok(group),
154 _ => Err(raw.unexpected(ACTION)),
155 }
156 }
157
158 pub async fn update_transactional_group(
160 &self,
161 transactional_group_id: &str,
162 name: Option<&str>,
163 description: Option<&str>,
164 ) -> Result<GroupResponse> {
165 const ACTION: &str = "update transactional group";
166 let body = UpdateGroupRequest {
167 name: name.map(str::to_owned),
168 description: description.map(str::to_owned),
169 };
170 let raw = self
171 .send(
172 Route::UpdateTransactionalGroup,
173 &[transactional_group_id],
174 |r| r.json(&body),
175 )
176 .await?;
177 match raw
178 .parse(ACTION, UpdateTransactionalGroupRequest::parse_response)
179 .await?
180 {
181 GetCampaignGroupResponse::Ok(group) => Ok(group),
182 _ => Err(raw.unexpected(ACTION)),
183 }
184 }
185
186 pub async fn list_workflow_groups(&self, page: Page) -> Result<ListGroupsResponse> {
188 const ACTION: &str = "list workflow groups";
189 let query = ListWorkflowGroupsRequestQuery {
190 per_page: page.per_page_param(),
191 cursor: page.cursor,
192 };
193 let raw = self
194 .send(Route::ListWorkflowGroups, &[], |r| r.query(&query))
195 .await?;
196 match raw
197 .parse(ACTION, ListWorkflowGroupsRequest::parse_response)
198 .await?
199 {
200 ListCampaignGroupsResponse::Ok(groups) => Ok(groups),
201 _ => Err(raw.unexpected(ACTION)),
202 }
203 }
204
205 pub async fn get_workflow_group(&self, workflow_group_id: &str) -> Result<GroupResponse> {
207 const ACTION: &str = "get workflow group";
208 let raw = self
209 .send(Route::GetWorkflowGroup, &[workflow_group_id], |r| r)
210 .await?;
211 match raw
212 .parse(ACTION, GetWorkflowGroupRequest::parse_response)
213 .await?
214 {
215 GetCampaignGroupResponse::Ok(group) => Ok(group),
216 _ => Err(raw.unexpected(ACTION)),
217 }
218 }
219
220 pub async fn create_workflow_group(
222 &self,
223 name: &str,
224 description: Option<&str>,
225 ) -> Result<GroupResponse> {
226 const ACTION: &str = "create workflow group";
227 let body = group_body(name, description);
228 check(&body)?;
229 let raw = self
230 .send(Route::CreateWorkflowGroup, &[], |r| r.json(&body))
231 .await?;
232 match raw
233 .parse(ACTION, CreateWorkflowGroupRequest::parse_response)
234 .await?
235 {
236 CreateCampaignGroupResponse::Ok(group) => Ok(group),
237 _ => Err(raw.unexpected(ACTION)),
238 }
239 }
240
241 pub async fn update_workflow_group(
245 &self,
246 workflow_group_id: &str,
247 name: Option<&str>,
248 description: Option<&str>,
249 ) -> Result<GroupResponse> {
250 const ACTION: &str = "update workflow group";
251 let body = UpdateGroupRequest {
252 name: name.map(str::to_owned),
253 description: description.map(str::to_owned),
254 };
255 let raw = self
256 .send(Route::UpdateWorkflowGroup, &[workflow_group_id], |r| {
257 r.json(&body)
258 })
259 .await?;
260 match raw
261 .parse(ACTION, UpdateWorkflowGroupRequest::parse_response)
262 .await?
263 {
264 GetCampaignGroupResponse::Ok(group) => Ok(group),
265 _ => Err(raw.unexpected(ACTION)),
266 }
267 }
268}
269
270fn group_body(name: &str, description: Option<&str>) -> CreateGroupRequest {
271 CreateGroupRequest {
272 name: name.to_owned(),
273 description: description.filter(|d| !d.is_empty()).map(str::to_owned),
274 }
275}