pattrick 0.5.0

Pattrick is a command line tool for managing Personal Access Tokens (PAT) in Azure DevOps.
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

//! # Pattrick
//!
//! `pattrick` is a library to manage personal access tokens (PAT) for Azure DevOps.
//! It allows you to easily create, list, get and delete PAT tokens.
//!
//! # Example
//! ```no_run
//!
//! use pattrick::{PatTokenManager, PatTokenListRequest, DisplayFilterOption};
//! use pattrick::azure::get_ad_token_for_devops;
//!
//! # tokio_test::block_on(async {
//! let pat_manager = PatTokenManager::new(get_ad_token_for_devops(1).await?).await?;
//!
//! let pat_tokens = pat_manager.list_pat_tokens(
//!     PatTokenListRequest {
//!         display_filter_option: DisplayFilterOption::All
//!     }
//! ).await?;
//! # Ok::<(), Box<dyn std::error::Error>>(())});
//! ```

#![warn(rustdoc::broken_intra_doc_links)]
#![warn(missing_docs)]
#![warn(rustdoc::missing_crate_level_docs)]

use std::error::Error;
/// Azure AD related functions
pub mod azure;
mod crud;
mod model;
use azure::AzureADToken;
use model::release::GitHubRelease;
pub use model::{
    requests::{
        DisplayFilterOption, ListTokenResponse, PatTokenCreateRequest, PatTokenDeleteRequest,
        PatTokenGetRequest, PatTokenListRequest, PatTokenResult,
    },
    token::PatToken,
};
use reqwest::header;
use reqwest::Client;
use reqwest::IntoUrl;
use reqwest::Method;

const API_VERSION: &str = "7.1-preview.1";

/// PatTokenManager is a struct that manages the creation, listing, getting and deletion of PAT tokens.
/// It uses the Azure AD token to authenticate with Azure DevOps.
///
/// # Example
///
/// ```rust,no_run
/// use pattrick::PatTokenManager;
/// use pattrick::azure::get_ad_token_for_devops;
/// use reqwest::Client;
///
/// # tokio_test::block_on(async {
/// let pat_manager = PatTokenManager::new(get_ad_token_for_devops(1).await?).await?;
/// # Ok::<(), Box<dyn std::error::Error>>(())});
/// ```
pub struct PatTokenManager {
    /// Azure AD token used to authenticate with Azure DevOps
    pub ad_token: AzureADToken,
    /// Reqwest client used to make requests
    pub client: Client,
    /// Azure DevOps PAT API URL for the organization
    pub pat_url: String,
}

impl PatTokenManager {
    /// Create a new PatTokenManager
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use pattrick::PatTokenManager;
    /// use pattrick::azure::get_ad_token_for_devops;
    ///
    /// # tokio_test::block_on(async {
    /// let pat_manager = PatTokenManager::new(get_ad_token_for_devops(1).await?).await?;
    /// # Ok::<(), Box<dyn std::error::Error>>(())});
    /// ```
    pub async fn new(ad_token: AzureADToken) -> Result<Self, Box<dyn Error>> {
        let organization = azure::get_organization(&ad_token).await?;
        let pat_url = format!("https://vssps.dev.azure.com/{}/_apis/tokens/pats", organization);

        Ok(Self {
            ad_token,
            client: Client::new(),
            pat_url,
        })
    }
    fn base_request<U>(&self, method: Method, url: U) -> reqwest::RequestBuilder
    where
        U: IntoUrl,
    {
        self.client
            .request(method, url)
            .header("Authorization", format!("Bearer {}", self.ad_token))
            .header("Content-Type", "application/json")
            .header("Accept", "application/json")
            .query(&[("api-version", API_VERSION)])
    }
    /// Get the lastest released version of the Pattrick CLI from GitHub
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use pattrick::PatTokenManager;
    /// use pattrick::azure::get_ad_token_for_devops;
    ///
    /// # tokio_test::block_on(async {
    /// let pat_manager = PatTokenManager::new(get_ad_token_for_devops(1).await?).await?;
    ///
    /// let latest_version = pat_manager.get_latest_version().await?;
    ///
    /// println!("Latest version: {}", latest_version);
    /// # Ok::<(), Box<dyn std::error::Error>>(())});
    pub async fn get_latest_version(self) -> Result<String, Box<dyn Error>> {
        let response = self
            .client
            .request(
                Method::GET,
                "https://api.github.com/repos/jvanbuel/pattrick/releases",
            )
            .header(header::USER_AGENT, "Pattrick")
            .header(header::HOST, "api.github.com")
            .send()
            .await?;

        let gh_response = response.json::<Vec<GitHubRelease>>().await?;
        Ok(gh_response[0].tag_name.clone())
    }
}