use std::sync::Arc;
use serde_json::Value;
use url::Url;
use crate::envelope::Envelope;
use crate::error::Error;
use crate::links;
use crate::routes;
use crate::transport::{RequestBody, Transport};
#[derive(Debug)]
pub struct ReservationsApi {
transport: Arc<Transport>,
}
impl ReservationsApi {
#[must_use]
pub fn new(transport: Arc<Transport>) -> Self {
Self { transport }
}
pub async fn get_reservations(
&self,
network_id: &str,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.transport
.resource(
&routes::reservations::RESERVATIONS_GET,
network_id,
parent,
&[],
RequestBody::None,
)
.await
}
pub async fn create_reservation(
&self,
network_id: &str,
reservation_data: Value,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = routes::reservations::RESERVATIONS_CREATE.resolve(
self.transport.api_host(),
network_id,
parent,
)?;
links::warn_uncharacterised_write("create reservation for network");
self.transport
.request(
routes::reservations::RESERVATIONS_CREATE.method.clone(),
url,
&[],
RequestBody::Json(reservation_data),
)
.await
}
pub async fn update_reservation(
&self,
reservation: &str,
data: Value,
network: Option<&str>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = self.resolve_reservation_url(reservation, network, parent)?;
links::warn_uncharacterised_write("update_reservation");
self.transport
.request(reqwest::Method::PUT, url, &[], RequestBody::Json(data))
.await
}
pub async fn delete_reservation(
&self,
network_id: &str,
reservation: &str,
delete_forwards: Option<bool>,
) -> Result<Envelope, Error> {
let url = routes::reservations::RESERVATIONS_DELETE.resolve(
self.transport.api_host(),
network_id,
reservation,
None,
)?;
let query: Vec<(&str, String)> = match delete_forwards {
Some(true) => vec![("delete_forwards", "true".to_owned())],
Some(false) => vec![("delete_forwards", "false".to_owned())],
None => Vec::new(),
};
links::warn_uncharacterised_write("delete reservation for network");
self.transport
.request(
routes::reservations::RESERVATIONS_DELETE.method.clone(),
url,
&query,
RequestBody::None,
)
.await
}
fn resolve_reservation_url(
&self,
reservation: &str,
network: Option<&str>,
parent: Option<&Value>,
) -> Result<Url, Error> {
let host = self.transport.api_host();
if let Some(parent) = parent {
return links::self_url(host, parent)?.ok_or_else(|| {
Error::validation("reservation", "envelope has no resolvable 'url' field")
});
}
if reservation.starts_with("http://")
|| reservation.starts_with("https://")
|| reservation.starts_with('/')
{
return routes::reservations::RESERVATIONS_UPDATE.resolve(
host,
network.unwrap_or(""),
reservation,
None,
);
}
let network = network.ok_or_else(|| {
Error::validation(
"network",
"required when 'reservation' is a bare ID rather than a path/URL",
)
})?;
routes::reservations::RESERVATIONS_UPDATE.resolve(host, network, reservation, None)
}
}