octocrab 0.54.2

A modern, extensible GitHub API client.
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use url::Url;

use crate::models::{AppId, BranchPolicyId, EnvironmentId, ProtectionRuleId, TeamId, UserId};

/// A repository environment.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Environment {
    pub id: EnvironmentId,
    pub node_id: String,
    pub name: String,
    pub url: Url,
    pub html_url: Url,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub can_admins_bypass: Option<bool>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub protection_rules: Vec<EnvironmentProtectionRule>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deployment_branch_policy: Option<DeploymentBranchPolicySettings>,
}

/// Response returned by the list environments endpoint.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Environments {
    pub total_count: u64,
    pub environments: Vec<Environment>,
}

/// A protection rule configured on an environment.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EnvironmentProtectionRule {
    pub id: u64,
    pub node_id: String,
    #[serde(rename = "type")]
    pub rule_type: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wait_timer: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prevent_self_review: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reviewers: Option<Vec<EnvironmentProtectionRuleReviewer>>,
}

/// A reviewer entry in an environment's protection rule.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EnvironmentProtectionRuleReviewer {
    #[serde(rename = "type")]
    pub reviewer_type: Option<String>,
    pub reviewer: Option<serde_json::Value>,
}

/// Deployment branch policy configuration settings for an environment.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeploymentBranchPolicySettings {
    pub protected_branches: bool,
    pub custom_branch_policies: bool,
}

impl DeploymentBranchPolicySettings {
    pub fn new(protected_branches: bool, custom_branch_policies: bool) -> Self {
        Self {
            protected_branches,
            custom_branch_policies,
        }
    }
}

/// A reviewer to configure on an environment.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EnvironmentReviewer {
    #[serde(rename = "type")]
    pub reviewer_type: ReviewerType,
    pub id: u64,
}

impl EnvironmentReviewer {
    pub fn user(user_id: impl Into<UserId>) -> Self {
        Self {
            reviewer_type: ReviewerType::User,
            id: user_id.into().0,
        }
    }

    pub fn team(team_id: impl Into<TeamId>) -> Self {
        Self {
            reviewer_type: ReviewerType::Team,
            id: team_id.into().0,
        }
    }
}

/// The type of reviewer.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ReviewerType {
    User,
    Team,
}

/// A deployment branch or tag policy.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeploymentBranchPolicy {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<BranchPolicyId>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub node_id: Option<String>,
    pub name: String,
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub policy_type: Option<BranchPolicyType>,
}

/// Response returned by the list deployment branch policies endpoint.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeploymentBranchPolicies {
    pub total_count: u64,
    pub branch_policies: Vec<DeploymentBranchPolicy>,
}

/// The type of deployment branch policy target.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum BranchPolicyType {
    Branch,
    Tag,
}

/// A custom deployment protection rule configured on an environment.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CustomDeploymentProtectionRule {
    pub id: ProtectionRuleId,
    pub node_id: String,
    pub enabled: bool,
    pub app: CustomDeploymentRuleApp,
}

/// Response returned by the list custom deployment protection rules endpoint.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CustomDeploymentProtectionRules {
    pub total_count: u64,
    pub custom_deployment_protection_rules: Vec<CustomDeploymentProtectionRule>,
}

/// GitHub App implementing a custom deployment protection rule.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CustomDeploymentRuleApp {
    pub id: AppId,
    pub slug: String,
    pub integration_url: Url,
    pub node_id: String,
}

/// Response returned by the list available custom deployment protection rule apps endpoint.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CustomDeploymentRuleApps {
    pub total_count: u64,
    pub available_custom_deployment_protection_rule_integrations: Vec<CustomDeploymentRuleApp>,
}