use std::sync::Arc;
use serde_json::{Map, Value, json};
use crate::envelope::Envelope;
use crate::error::Error;
use crate::links::warn_uncharacterised_write;
use crate::routes;
use crate::transport::{RequestBody, Transport};
#[derive(Debug, Default, Clone)]
pub struct UpdateBackupAccessPointOptions<'a> {
pub ssid: Option<&'a str>,
pub password: Option<&'a str>,
pub enabled: Option<bool>,
pub uuid: Option<&'a str>,
pub connectivity: Option<Value>,
pub created: Option<&'a str>,
pub last_updated_at: Option<&'a str>,
}
#[derive(Debug)]
pub struct BackupAccessPointsApi {
transport: Arc<Transport>,
}
impl BackupAccessPointsApi {
#[must_use]
pub fn new(transport: Arc<Transport>) -> Self {
Self { transport }
}
pub async fn list(&self, network_id: &str, parent: Option<&Value>) -> Result<Envelope, Error> {
self.transport
.resource(
&routes::BACKUP_ACCESS_POINTS_LIST,
network_id,
parent,
&[],
RequestBody::None,
)
.await
}
pub async fn add(
&self,
network_id: &str,
ssid: &str,
password: &str,
uuid: Option<&str>,
) -> Result<Envelope, Error> {
let mut body = Map::new();
body.insert("ssid".to_owned(), Value::String(ssid.to_owned()));
body.insert("password".to_owned(), Value::String(password.to_owned()));
if let Some(uuid) = uuid {
body.insert("uuid".to_owned(), Value::String(uuid.to_owned()));
}
let url = routes::BACKUP_ACCESS_POINTS_ADD.resolve(
self.transport.api_host(),
network_id,
None,
)?;
warn_uncharacterised_write("add backup access point for network");
self.transport
.request(
routes::BACKUP_ACCESS_POINTS_ADD.method.clone(),
url,
&[],
RequestBody::Json(Value::Object(body)),
)
.await
}
pub async fn update(
&self,
network_id: &str,
backup_network_id: &str,
options: &UpdateBackupAccessPointOptions<'_>,
) -> Result<Envelope, Error> {
let mut body = Map::new();
if let Some(ssid) = options.ssid {
body.insert("ssid".to_owned(), Value::String(ssid.to_owned()));
}
if let Some(password) = options.password {
body.insert("password".to_owned(), Value::String(password.to_owned()));
}
if let Some(enabled) = options.enabled {
body.insert("enabled".to_owned(), Value::Bool(enabled));
}
if let Some(uuid) = options.uuid {
body.insert("uuid".to_owned(), Value::String(uuid.to_owned()));
}
if let Some(connectivity) = options.connectivity.clone() {
body.insert("connectivity".to_owned(), connectivity);
}
if let Some(created) = options.created {
body.insert("created".to_owned(), Value::String(created.to_owned()));
}
if let Some(last_updated_at) = options.last_updated_at {
body.insert(
"last_updated_at".to_owned(),
Value::String(last_updated_at.to_owned()),
);
}
let url = routes::BACKUP_ACCESS_POINTS_UPDATE.resolve(
self.transport.api_host(),
network_id,
backup_network_id,
None,
)?;
warn_uncharacterised_write("update backup access point for network");
self.transport
.request(
routes::BACKUP_ACCESS_POINTS_UPDATE.method.clone(),
url,
&[],
RequestBody::Json(Value::Object(body)),
)
.await
}
pub async fn delete_backup_access_point(
&self,
network_id: &str,
backup_network_id: &str,
) -> Result<Envelope, Error> {
let url = routes::BACKUP_ACCESS_POINTS_DELETE.resolve(
self.transport.api_host(),
network_id,
backup_network_id,
None,
)?;
warn_uncharacterised_write("delete backup access point for network");
self.transport
.request(
routes::BACKUP_ACCESS_POINTS_DELETE.method.clone(),
url,
&[],
RequestBody::None,
)
.await
}
pub async fn rearrange(&self, network_id: &str, order: &[&str]) -> Result<Envelope, Error> {
let url = routes::BACKUP_ACCESS_POINTS_REARRANGE.resolve(
self.transport.api_host(),
network_id,
None,
)?;
warn_uncharacterised_write("rearrange backup access points for network");
self.transport
.request(
routes::BACKUP_ACCESS_POINTS_REARRANGE.method.clone(),
url,
&[],
RequestBody::Json(json!({ "rearranged_ids": order })),
)
.await
}
pub async fn discover_ssids(&self, network_id: &str) -> Result<Envelope, Error> {
self.transport
.resource(
&routes::BACKUP_ACCESS_POINTS_DISCOVER_SSIDS,
network_id,
None,
&[],
RequestBody::None,
)
.await
}
pub async fn start_ssid_discovery(&self, network_id: &str) -> Result<Envelope, Error> {
let url = routes::BACKUP_ACCESS_POINTS_START_SSID_DISCOVERY.resolve(
self.transport.api_host(),
network_id,
None,
)?;
warn_uncharacterised_write("start SSID discovery for network");
self.transport
.request(
routes::BACKUP_ACCESS_POINTS_START_SSID_DISCOVERY
.method
.clone(),
url,
&[],
RequestBody::EmptyJsonString,
)
.await
}
pub async fn connectivity_check(&self, network_id: &str) -> Result<Envelope, Error> {
let url = routes::BACKUP_ACCESS_POINTS_CONNECTIVITY_CHECK.resolve(
self.transport.api_host(),
network_id,
None,
)?;
warn_uncharacterised_write("start backup connectivity check for network");
self.transport
.request(
routes::BACKUP_ACCESS_POINTS_CONNECTIVITY_CHECK
.method
.clone(),
url,
&[],
RequestBody::EmptyJsonString,
)
.await
}
}