Skip to main content

loops_so/client/
segments.rs

1use serde_json::{Map, Value};
2
3use super::{LoopsClient, Page};
4use crate::error::Result;
5use crate::generated::{
6    AudienceSegmentResponse, CreateAudienceSegmentRequestParams, EventPattern,
7    GetAudienceSegmentRequest, GetAudienceSegmentResponse, GetEventPatternByNameRequest,
8    GetEventPatternRequest, GetEventPatternResponse, ListAudienceSegmentsRequest,
9    ListAudienceSegmentsRequestQuery, ListAudienceSegmentsResponse,
10    ListAudienceSegmentsResponseEnum, ListEventPatternsRequest, ListEventPatternsRequestQuery,
11    ListEventPatternsResponse, ListEventPatternsResponseEnum,
12};
13use crate::routes::Route;
14
15impl LoopsClient {
16    /// List audience segments, most recently created first.
17    pub async fn list_audience_segments(&self, page: Page) -> Result<ListAudienceSegmentsResponse> {
18        const ACTION: &str = "list audience segments";
19        let query = ListAudienceSegmentsRequestQuery {
20            per_page: page.per_page_param(),
21            cursor: page.cursor,
22        };
23        let raw = self
24            .send(Route::ListAudienceSegments, &[], |r| r.query(&query))
25            .await?;
26        match raw
27            .parse(ACTION, ListAudienceSegmentsRequest::parse_response)
28            .await?
29        {
30            ListAudienceSegmentsResponseEnum::Ok(segments) => Ok(segments),
31            _ => Err(raw.unexpected(ACTION)),
32        }
33    }
34
35    /// Get an audience segment.
36    pub async fn get_audience_segment(
37        &self,
38        audience_segment_id: &str,
39    ) -> Result<AudienceSegmentResponse> {
40        const ACTION: &str = "get audience segment";
41        let raw = self
42            .send(Route::GetAudienceSegment, &[audience_segment_id], |r| r)
43            .await?;
44        match raw
45            .parse(ACTION, GetAudienceSegmentRequest::parse_response)
46            .await?
47        {
48            GetAudienceSegmentResponse::Ok(segment) => Ok(segment),
49            _ => Err(raw.unexpected(ACTION)),
50        }
51    }
52
53    /// Create an audience segment.
54    ///
55    /// `filter` is the segment's condition tree, e.g.
56    /// `{"match": "all", "conditions": [{"type": "property", "key": "plan",
57    /// "operator": "equals", "value": "pro"}]}`. `match` is `"all"` or
58    /// `"any"`; each condition is a `property`, `optIn` or `activity`
59    /// condition (see the Loops docs for the grammar).
60    pub async fn create_audience_segment(
61        &self,
62        name: &str,
63        filter: Value,
64        description: Option<&str>,
65    ) -> Result<AudienceSegmentResponse> {
66        const ACTION: &str = "create audience segment";
67        let mut body = Map::new();
68        body.insert("name".to_owned(), Value::from(name));
69        body.insert("filter".to_owned(), filter);
70        if let Some(description) = description {
71            body.insert("description".to_owned(), Value::from(description));
72        }
73        let raw = self
74            .send(Route::CreateAudienceSegment, &[], |r| r.json(&body))
75            .await?;
76        match raw
77            .parse(ACTION, CreateAudienceSegmentRequestParams::parse_response)
78            .await?
79        {
80            GetAudienceSegmentResponse::Ok(segment) => Ok(segment),
81            _ => Err(raw.unexpected(ACTION)),
82        }
83    }
84
85    /// List event patterns: the event types workflow triggers can listen
86    /// for, custom or from integrated webhook platforms.
87    pub async fn list_event_patterns(&self, page: Page) -> Result<ListEventPatternsResponse> {
88        const ACTION: &str = "list event patterns";
89        let query = ListEventPatternsRequestQuery {
90            per_page: page.per_page_param(),
91            cursor: page.cursor,
92        };
93        let raw = self
94            .send(Route::ListEventPatterns, &[], |r| r.query(&query))
95            .await?;
96        match raw
97            .parse(ACTION, ListEventPatternsRequest::parse_response)
98            .await?
99        {
100            ListEventPatternsResponseEnum::Ok(patterns) => Ok(patterns),
101            _ => Err(raw.unexpected(ACTION)),
102        }
103    }
104
105    /// Get an event pattern by ID.
106    pub async fn get_event_pattern(&self, event_pattern_id: &str) -> Result<EventPattern> {
107        const ACTION: &str = "get event pattern";
108        let raw = self
109            .send(Route::GetEventPattern, &[event_pattern_id], |r| r)
110            .await?;
111        match raw
112            .parse(ACTION, GetEventPatternRequest::parse_response)
113            .await?
114        {
115            GetEventPatternResponse::Ok(pattern) => Ok(pattern),
116            _ => Err(raw.unexpected(ACTION)),
117        }
118    }
119
120    /// Get an event pattern by its case-sensitive event name.
121    pub async fn get_event_pattern_by_name(&self, event_name: &str) -> Result<EventPattern> {
122        const ACTION: &str = "get event pattern by name";
123        let raw = self
124            .send(Route::GetEventPatternByName, &[event_name], |r| r)
125            .await?;
126        match raw
127            .parse(ACTION, GetEventPatternByNameRequest::parse_response)
128            .await?
129        {
130            GetEventPatternResponse::Ok(pattern) => Ok(pattern),
131            _ => Err(raw.unexpected(ACTION)),
132        }
133    }
134}