concur-api 0.1.0

A Rust client for the SAP Concur REST APIs (v4 / v4.1).
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

//! SAP Concur Event Subscription Service (ESS) v4.
//!
//! Endpoints: `events/v4/...`

use crate::client::ConcurClient;
use crate::error::Result;
use reqwest::Method;
use serde::{Deserialize, Serialize};

/// Event Subscription Service API.
pub struct EssApi<'a> {
    client: &'a ConcurClient,
}

impl<'a> EssApi<'a> {
    pub fn new(client: &'a ConcurClient) -> Self {
        Self { client }
    }

    /// Browse available topics.
    pub async fn topics(&self) -> Result<Vec<String>> {
        self.client
            .request(Method::GET, "/events/v4/topics")
            .await?
            .send()
            .await?
            .json()
            .await
            .map_err(Into::into)
    }

    /// Create or update a webhook subscription.
    pub async fn create_subscription(
        &self,
        subscription: &Subscription,
    ) -> Result<SubscriptionResult> {
        let req = self
            .client
            .request(Method::PUT, "/events/v4/subscriptions/webhook")
            .await?;
        let req = ConcurClient::with_json(req, subscription)?;
        self.client.execute(req).await
    }

    /// Get a subscription by ID.
    pub async fn get_subscription(&self, subscription_id: &str) -> Result<Vec<Subscription>> {
        self.client
            .request(
                Method::GET,
                &format!("/events/v4/subscriptions/{}", subscription_id),
            )
            .await?
            .send()
            .await?
            .json()
            .await
            .map_err(Into::into)
    }

    /// List all subscriptions.
    pub async fn list_subscriptions(&self) -> Result<Vec<Subscription>> {
        self.client
            .request(Method::GET, "/events/v4/subscriptions")
            .await?
            .send()
            .await?
            .json()
            .await
            .map_err(Into::into)
    }

    /// Delete a subscription.
    pub async fn delete_subscription(&self, subscription_id: &str) -> Result<SubscriptionResult> {
        self.client
            .execute_unit(
                self.client
                    .request(
                        Method::DELETE,
                        &format!("/events/v4/subscriptions/{}", subscription_id),
                    )
                    .await?,
            )
            .await?;
        Ok(SubscriptionResult {
            message: format!("Subscription '{}' marked for deletion", subscription_id),
        })
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Subscription {
    pub id: String,
    pub filter: String,
    pub topic: String,
    #[serde(rename = "webHookConfig")]
    pub webhook_config: WebhookConfig,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "applicationId")]
    pub application_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub groups: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "companyIds")]
    pub company_ids: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebhookConfig {
    pub endpoint: String,
}

#[derive(Debug, Clone, Deserialize)]
pub struct SubscriptionResult {
    pub message: String,
}

/// Common ESS event envelope.
#[derive(Debug, Clone, Deserialize)]
pub struct EssEvent<T> {
    #[serde(rename = "eventType")]
    pub event_type: String,
    #[serde(rename = "timeStamp")]
    pub time_stamp: String,
    #[serde(rename = "correlationId")]
    pub correlation_id: Option<String>,
    #[serde(rename = "facts")]
    pub facts: T,
}