notra 0.1.1

Unofficial Rust SDK for the Notra API
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

use serde::{Deserialize, Serialize};

use crate::client::Notra;
use crate::error::Result;
use crate::models::{GithubIntegration, LinearIntegration, Organization};

use super::brand_identities::DisabledItem;

// ── List Integrations ───────────────────────────────────────────────────

#[derive(Debug, Deserialize)]
pub struct ListIntegrationsResponse {
    pub organization: Organization,
    #[serde(default)]
    pub github: Vec<GithubIntegration>,
    #[serde(default)]
    pub slack: Vec<serde_json::Value>,
    #[serde(default)]
    pub linear: Vec<LinearIntegration>,
}

pub struct ListIntegrationsBuilder<'a> {
    client: &'a Notra,
}

impl<'a> ListIntegrationsBuilder<'a> {
    pub(crate) fn new(client: &'a Notra) -> Self {
        Self { client }
    }

    pub async fn send(self) -> Result<ListIntegrationsResponse> {
        self.client.get("/v1/integrations", &[]).await
    }
}

// ── Create GitHub Integration ───────────────────────────────────────────

#[derive(Debug, Deserialize)]
pub struct CreateGithubIntegrationResponse {
    pub organization: Organization,
    pub github: GithubIntegration,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct CreateGithubIntegrationBody {
    owner: String,
    repo: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    branch: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    auth_token: Option<String>,
}

pub struct CreateGithubIntegrationBuilder<'a> {
    client: &'a Notra,
    owner: String,
    repo: String,
    branch: Option<String>,
    auth_token: Option<String>,
}

impl<'a> CreateGithubIntegrationBuilder<'a> {
    pub(crate) fn new(
        client: &'a Notra,
        owner: impl Into<String>,
        repo: impl Into<String>,
    ) -> Self {
        Self {
            client,
            owner: owner.into(),
            repo: repo.into(),
            branch: None,
            auth_token: None,
        }
    }

    pub fn branch(mut self, branch: impl Into<String>) -> Self {
        self.branch = Some(branch.into());
        self
    }

    pub fn auth_token(mut self, token: impl Into<String>) -> Self {
        self.auth_token = Some(token.into());
        self
    }

    pub async fn send(self) -> Result<CreateGithubIntegrationResponse> {
        let body = CreateGithubIntegrationBody {
            owner: self.owner,
            repo: self.repo,
            branch: self.branch,
            auth_token: self.auth_token,
        };
        self.client.post("/v1/integrations/github", &body).await
    }
}

// ── Delete Integration ──────────────────────────────────────────────────

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeleteIntegrationResponse {
    pub id: String,
    pub organization: Organization,
    #[serde(default)]
    pub disabled_schedules: Vec<DisabledItem>,
    #[serde(default)]
    pub disabled_events: Vec<DisabledItem>,
}

pub struct DeleteIntegrationBuilder<'a> {
    client: &'a Notra,
    integration_id: String,
}

impl<'a> DeleteIntegrationBuilder<'a> {
    pub(crate) fn new(client: &'a Notra, integration_id: impl Into<String>) -> Self {
        Self {
            client,
            integration_id: integration_id.into(),
        }
    }

    pub async fn send(self) -> Result<DeleteIntegrationResponse> {
        let path = format!("/v1/integrations/{}", self.integration_id);
        self.client.delete(&path).await
    }
}