nipaw_gitcode 1.9.7

GitCode provider for nipaw_core
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

use crate::GitCodeClientInner;
use async_trait::async_trait;
use crate::common::JsonValue;
use nipaw_core::option::release::UpdateOption;
use nipaw_core::types::release::ReleaseInfo;
use nipaw_core::types::repo::RepoPath;
use nipaw_core::{Error, Release, Result};
use std::sync::Arc;

pub struct GitCodeRelease(pub(crate) Arc<GitCodeClientInner>);

#[async_trait]
impl Release for GitCodeRelease {
	async fn create(
		&self,
		repo_path: RepoPath,
		tag_name: &str,
		name: Option<&str>,
		body: Option<&str>,
		target_commitish: Option<&str>,
	) -> Result<ReleaseInfo> {
		let (token, api_url) = (&self.0.config.token, &self.0.config.api_url);
		if token.is_none() {
			return Err(Error::TokenEmpty);
		}
		let client = self.0.client.read().await;
		let url = format!("{}/repos/{}/{}/releases", api_url, repo_path.owner, repo_path.repo);
		let request = client.post(url).bearer_auth(token.as_ref().unwrap());
		let json_body = serde_json::json!({
			"tag_name": tag_name,
			"name": name.unwrap_or(tag_name),
			"body": body.unwrap_or(tag_name),
			"target_commitish": target_commitish.unwrap_or("HEAD")
		});

		let res = request.json(&json_body).send().await?.json::<JsonValue>().await?;
		Ok(res.into())
	}

	async fn info(&self, repo_path: RepoPath, tag_name: Option<&str>) -> Result<ReleaseInfo> {
		let (token, api_url) = (&self.0.config.token, &self.0.config.api_url);
		if token.is_none() {
			return Err(Error::TokenEmpty);
		}
		let url = if let Some(tag_name) = tag_name {
			format!(
				"{}/repos/{}/{}/releases/tags/{}",
				api_url,
				repo_path.repo,
				repo_path.owner,
				tag_name
			)
		} else {
			format!("{}/repos/{}/{}/releases/latest", api_url, repo_path.owner, repo_path.repo)
		};
		let client = self.0.client.read().await;
		let mut request = client.get(url);
		if let Some(token) = token {
			request = request.bearer_auth(token);
		}
		let res = request.send().await?.json::<JsonValue>().await?;
		Ok(res.into())
	}

	async fn list(&self, repo_path: RepoPath) -> Result<Vec<ReleaseInfo>> {
		let (token, api_url) = (&self.0.config.token, &self.0.config.api_url);
		if token.is_none() {
			return Err(Error::TokenEmpty);
		}
		let url = format!("{}/repos/{}/{}/releases", api_url, repo_path.owner, repo_path.repo);
		let client = self.0.client.read().await;
		let mut request = client.get(url);
		if let Some(token) = token {
			request = request.bearer_auth(token);
		}
		let res = request.send().await?.json::<Vec<JsonValue>>().await?;
		Ok(res.into_iter().map(|x| x.into()).collect())
	}

	async fn update(
		&self,
		repo_path: RepoPath,
		tag_name: &str,
		option: UpdateOption,
	) -> Result<ReleaseInfo> {
		let (token, api_url) = (&self.0.config.token, &self.0.config.api_url);
		if token.is_none() {
			return Err(Error::TokenEmpty);
		}
		let url =
			format!("{}/repos/{}/{}/releases/{}", api_url, repo_path.owner, repo_path.repo, tag_name);
		let client = self.0.client.read().await;
		let mut request = client.patch(url);
		if let Some(token) = token {
			request = request.bearer_auth(token);
		}

		let json_body = serde_json::json!({
			"name": option.name.as_deref().unwrap_or(tag_name),
			"body": option.body.as_deref().unwrap_or(tag_name)
		});
		let res = request.json(&json_body).send().await?.json::<JsonValue>().await?;
		Ok(res.into())
	}
}