use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use super::os::MachineStatus;
use crate::authentification::CredentialsOrApiKey;
use crate::billing::PageQuery;
use crate::drive::{DriveAuthorization, File, FileDates, Progress, parse_stream, wrap};
use crate::error::{Error, Result};
use crate::groups::Group;
use crate::http::{client, encode, ok};
use crate::marmot::media::mime_from_file_name;
use crate::shared::schema::Schema;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Return {
pub code: u16,
pub description: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub body: Option<Schema>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum RouteMethod {
Get,
Post,
Put,
Patch,
Delete,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Route {
pub method: RouteMethod,
pub path: String,
pub description: String,
pub deprecated: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub body: Option<Schema>,
pub r#return: Vec<Return>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum LineKind {
Addition,
Deletion,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Line {
pub path: String,
pub index: u64,
pub kind: LineKind,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct Change {
pub revision: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub rollback: Option<u64>,
pub head: String,
pub lines: Vec<Line>,
pub date: DateTime<Utc>,
}
impl Change {
pub fn from_json(json: &Value) -> Change {
Change {
revision: json["revision"].as_f64().unwrap_or_default() as u64,
rollback: json["rollback"]
.as_f64()
.filter(|rollback| *rollback != 0.0)
.map(|rollback| rollback as u64),
head: match &json["head"] {
Value::Null => String::new(),
Value::String(head) => head.clone(),
head => head.to_string(),
},
lines: json["lines"]
.as_array()
.into_iter()
.flatten()
.filter_map(|line| serde_json::from_value(line.clone()).ok())
.collect(),
date: crate::tickets::parse_date(&json["date"]).unwrap_or_default(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct RepositoryMachine {
pub id: u64,
pub status: MachineStatus,
}
#[derive(Debug, Clone)]
#[allow(clippy::large_enum_variant)]
pub enum FileOrFiles {
File(File),
Files(Vec<File>),
}
#[derive(Debug, Clone)]
pub struct Repository {
pub id: u64,
pub name: String,
pub size_bytes: u64,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
pub machine: Option<RepositoryMachine>,
pub group: Option<Group>,
authorization: CredentialsOrApiKey,
}
impl Repository {
pub fn from_json(
json: &Value,
authorization: &CredentialsOrApiKey,
group: Option<&Group>,
) -> Repository {
Repository {
authorization: authorization.clone(),
group: group.cloned(),
id: json["id"].as_f64().unwrap_or_default() as u64,
name: json["name"].as_str().unwrap_or_default().to_string(),
size_bytes: json["sizeBytes"].as_f64().unwrap_or_default() as u64,
created_at: crate::tickets::parse_date(&json["createdAt"]).unwrap_or_default(),
updated_at: crate::tickets::parse_date(&json["updatedAt"]).unwrap_or_default(),
machine: if json["machine"].is_object() {
serde_json::from_value(json!({
"id": json["machine"]["id"].as_f64().unwrap_or_default() as u64,
"status": json["machine"]["status"],
}))
.ok()
} else {
None
},
}
}
fn request(&self, request: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
let request = request.header(
"Authorization",
match &self.authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
match &self.group {
Some(group) => request.header("Group", &group.id),
None => request,
}
}
pub fn routes(&self) -> Result<Vec<Route>> {
Err(Error::Message(
"Termite routes are not implemented.".to_string(),
))
}
pub async fn changes(&self, query: PageQuery) -> Result<Vec<Change>> {
let response = self
.request(client().get(format!(
"{}/termite/repositories/{}/changes?cursor={}&max={}",
super::get_url(),
self.id,
query.cursor,
query.max
)))
.send()
.await?;
let parts = parse_stream(ok(response).await?, None::<fn(u64)>).await?;
parts
.iter()
.filter(|part| !part.is_empty())
.map(|part| Ok(Change::from_json(&serde_json::from_slice(part)?)))
.collect()
}
fn file_authorization(&self, path: &str) -> DriveAuthorization {
DriveAuthorization::Repository {
authorization: self.authorization.clone(),
repository: self.id,
path: path.to_string(),
group: self.group.as_ref().map(|group| group.id.clone()),
}
}
pub async fn open(&self, path: Option<&str>) -> Result<FileOrFiles> {
let tail = path
.unwrap_or("/")
.split('/')
.filter(|segment| !segment.is_empty())
.map(encode)
.collect::<Vec<_>>()
.join("/");
let response = self
.request(client().get(format!(
"{}/termite/repositories/{}/files{}",
super::get_url(),
self.id,
if tail.is_empty() {
String::new()
} else {
format!("/{tail}")
}
)))
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
let entry = |entry: &Value| {
File::from_json(
entry,
self.file_authorization(entry["path"].as_str().unwrap_or_default()),
)
};
Ok(match &json {
Value::Array(entries) => FileOrFiles::Files(entries.iter().map(entry).collect()),
json => FileOrFiles::File(entry(json)),
})
}
pub async fn write(
&self,
path: &str,
data: impl AsRef<[u8]>,
on_progress: Option<Progress>,
) -> Result<File> {
let name = path
.split('/')
.rfind(|segment| !segment.is_empty())
.unwrap_or_default();
let mut file = wrap(
self.file_authorization(path),
name,
mime_from_file_name(name).unwrap_or("application/octet-stream"),
data.as_ref().to_vec(),
FileDates::default(),
)
.await?;
file.upload(on_progress).await?;
Ok(file)
}
pub async fn rollback(&self, revision: u64) -> Result<()> {
let response = self
.request(client().post(format!(
"{}/termite/repositories/{}/rollback",
super::get_url(),
self.id
)))
.json(&json!({ "revision": revision }))
.send()
.await?;
ok(response).await?;
Ok(())
}
pub async fn rename(&self, name: &str) -> Result<Repository> {
let response = self
.request(client().patch(format!(
"{}/termite/repositories/{}",
super::get_url(),
self.id
)))
.json(&json!({ "name": name }))
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
Ok(Repository::from_json(
&json,
&self.authorization,
self.group.as_ref(),
))
}
pub async fn delete(&self) -> Result<()> {
let response = self
.request(client().delete(format!(
"{}/termite/repositories/{}",
super::get_url(),
self.id
)))
.send()
.await?;
ok(response).await?;
Ok(())
}
}
#[derive(Debug, Clone, Default)]
pub struct CreateOptions {
pub name: Option<String>,
pub group: Option<Group>,
}
#[derive(Debug, Clone, Default)]
pub struct GroupOptions {
pub group: Option<Group>,
}
fn authorized(
request: reqwest::RequestBuilder,
authorization: &CredentialsOrApiKey,
group: Option<&Group>,
) -> reqwest::RequestBuilder {
let request = request.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => format!("Token {}", credentials.token),
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
match group {
Some(group) => request.header("Group", &group.id),
None => request,
}
}
pub async fn create(
authorization: &CredentialsOrApiKey,
opts: CreateOptions,
) -> Result<Repository> {
let response = authorized(
client().post(format!("{}/termite/repositories", super::get_url())),
authorization,
opts.group.as_ref(),
)
.json(&json!({ "name": opts.name }))
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
Ok(Repository::from_json(
&json,
authorization,
opts.group.as_ref(),
))
}
pub async fn get(
authorization: &CredentialsOrApiKey,
id: u64,
opts: GroupOptions,
) -> Result<Repository> {
let response = authorized(
client().get(format!("{}/termite/repositories/{id}", super::get_url())),
authorization,
opts.group.as_ref(),
)
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
Ok(Repository::from_json(
&json,
authorization,
opts.group.as_ref(),
))
}
pub async fn list(
authorization: &CredentialsOrApiKey,
opts: GroupOptions,
) -> Result<Vec<Repository>> {
let response = authorized(
client().get(format!("{}/termite/repositories", super::get_url())),
authorization,
opts.group.as_ref(),
)
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
Ok(json
.as_array()
.into_iter()
.flatten()
.map(|row| Repository::from_json(row, authorization, opts.group.as_ref()))
.collect())
}