Skip to main content

loops_so/client/
groups.rs

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    /// List campaign groups.
16    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    /// Get a campaign group.
35    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    /// Create a campaign group.
50    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    /// Rename a campaign group and/or change its description.
71    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    /// List transactional groups.
97    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    /// Get a transactional group.
116    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    /// Create a transactional group.
138    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    /// Rename a transactional group and/or change its description.
159    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    /// List workflow groups, most recently created first.
187    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    /// Get a workflow group.
206    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    /// Create a workflow group.
221    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    /// Rename a workflow group and/or change its description.
242    ///
243    /// The reserved "Unsorted" group cannot be edited.
244    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}