fopost 0.1.0

Official Rust SDK for the FoPost API. Schedule and publish to +30 social platforms from your code.
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

//! `client.analytics()` — the read-only reporting surface.

use reqwest::Method;

use crate::error::Result;
use crate::http::{push_opt, Envelope, HttpClient, Query};
use crate::models::{
    AnalyticsOverview, AnalyticsQuery, Audience, CollectSummary, Demographics, LabelAnalytics,
    PostsTable, StreakDay, TimeSeries, TopPost,
};

/// Reporting across every connected account.
#[derive(Debug, Clone)]
pub struct Analytics<'a> {
    pub(crate) http: &'a HttpClient,
}

fn base_query(params: &AnalyticsQuery) -> Query {
    let mut query: Query = Vec::new();
    push_opt(&mut query, "workspace_id", params.workspace_id.as_ref());
    push_opt(&mut query, "accountId", params.account_id.as_ref());
    push_opt(&mut query, "days", params.days);
    push_opt(&mut query, "from", params.from.as_ref());
    push_opt(&mut query, "to", params.to.as_ref());
    query
}

impl Analytics<'_> {
    /// Everything on the analytics dashboard, in one call.
    pub async fn overview(&self, params: &AnalyticsQuery) -> Result<AnalyticsOverview> {
        let body: Envelope<AnalyticsOverview> = self
            .http
            .send::<_, ()>(
                Method::GET,
                "/analytics/overview",
                Some(base_query(params)),
                None,
            )
            .await?;
        Ok(body.data)
    }

    /// Daily metrics over the window.
    pub async fn time_series(&self, params: &AnalyticsQuery) -> Result<TimeSeries> {
        let body: Envelope<TimeSeries> = self
            .http
            .send::<_, ()>(
                Method::GET,
                "/analytics/time-series",
                Some(base_query(params)),
                None,
            )
            .await?;
        Ok(body.data)
    }

    /// The best performing posts, by engagement unless `sort` says otherwise.
    pub async fn top_posts(&self, params: &AnalyticsQuery) -> Result<Vec<TopPost>> {
        let mut query = base_query(params);
        push_opt(&mut query, "limit", params.limit);
        push_opt(&mut query, "label", params.label.as_ref());
        push_opt(&mut query, "sort", params.sort.as_ref());
        let body: Envelope<Vec<TopPost>> = self
            .http
            .send::<_, ()>(Method::GET, "/analytics/top-posts", Some(query), None)
            .await?;
        Ok(body.data)
    }

    /// A campaign roll-up: how everything under each label did.
    pub async fn labels(&self, params: &AnalyticsQuery) -> Result<Vec<LabelAnalytics>> {
        let body: Envelope<Vec<LabelAnalytics>> = self
            .http
            .send::<_, ()>(
                Method::GET,
                "/analytics/labels",
                Some(base_query(params)),
                None,
            )
            .await?;
        Ok(body.data)
    }

    /// Posts with their delivery breakdown, paginated.
    pub async fn posts_table(&self, params: &AnalyticsQuery) -> Result<PostsTable> {
        let mut query = base_query(params);
        push_opt(&mut query, "page", params.page);
        push_opt(&mut query, "limit", params.limit);
        let body: Envelope<PostsTable> = self
            .http
            .send::<_, ()>(Method::GET, "/analytics/posts-table", Some(query), None)
            .await?;
        Ok(body.data)
    }

    /// 365 days of posting activity, for a contribution-graph style view.
    pub async fn posting_streak(&self, workspace_id: Option<&str>) -> Result<Vec<StreakDay>> {
        #[derive(serde::Deserialize)]
        struct Streak {
            #[serde(default)]
            streak: Vec<StreakDay>,
        }
        let mut query: Query = Vec::new();
        push_opt(&mut query, "workspace_id", workspace_id);
        let body: Envelope<Streak> = self
            .http
            .send::<_, ()>(Method::GET, "/analytics/posting-streak", Some(query), None)
            .await?;
        Ok(body.data.streak)
    }

    /// Who the audience is, across the accounts whose platform reports it.
    pub async fn demographics(
        &self,
        audience: Option<Audience>,
        params: &AnalyticsQuery,
    ) -> Result<Demographics> {
        let mut query: Query = Vec::new();
        push_opt(&mut query, "audience", audience);
        push_opt(&mut query, "workspace_id", params.workspace_id.as_ref());
        push_opt(&mut query, "accountId", params.account_id.as_ref());
        let body: Envelope<Demographics> = self
            .http
            .send::<_, ()>(Method::GET, "/analytics/demographics", Some(query), None)
            .await?;
        Ok(body.data)
    }

    /// Pull fresh numbers from the platforms now, instead of waiting for the
    /// scheduled collection. Rate limited by every platform involved.
    pub async fn collect(&self, account_id: Option<&str>) -> Result<CollectSummary> {
        let mut query: Query = Vec::new();
        push_opt(&mut query, "accountId", account_id);
        let body: Envelope<CollectSummary> = self
            .http
            .send::<_, ()>(Method::POST, "/analytics/collect", Some(query), None)
            .await?;
        Ok(body.data)
    }
}