use std::sync::Arc;
use serde_json::Value;
use url::Url;
use crate::envelope::Envelope;
use crate::error::Error;
use crate::routes::{self, Resource};
use crate::transport::{RequestBody, Transport};
pub const CHANNEL_UTILIZATION_BANDS: &[&str] = &[
"band_2_4GHz",
"band_5GHz_low",
"band_5GHz_high",
"band_5GHz_full",
"band_6GHz",
];
#[derive(Debug, Default, Clone)]
pub struct GetChannelUtilizationOptions<'a> {
pub busy_threshold: Option<u32>,
pub eero_id: Option<&'a str>,
pub band: Option<&'a str>,
pub granularity: Option<u32>,
pub gap_data_placeholder: Option<&'a str>,
}
#[derive(Debug)]
pub struct EventsApi {
transport: Arc<Transport>,
}
impl EventsApi {
#[must_use]
pub fn new(transport: Arc<Transport>) -> Self {
Self { transport }
}
fn resolve_network_scoped_url(
&self,
route: &Resource,
network_id: &str,
parent: Option<&Value>,
) -> Result<Url, Error> {
let suffix = route.template.split("{id}").nth(1).unwrap_or("");
let base = crate::params::resolve_network_url(
self.transport.api_host(),
network_id,
parent,
route.version,
)?;
let joined = format!("{}{suffix}", base.as_str().trim_end_matches('/'));
Url::parse(&joined)
.map_err(|err| Error::validation("url", format!("not a valid URL: {err}")))
}
pub async fn get_app_events(
&self,
network_id: &str,
page_size: Option<u32>,
timestamp: Option<&str>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = self.resolve_network_scoped_url(&routes::GET_APP_EVENTS, network_id, parent)?;
let mut query = Vec::new();
if let Some(page_size) = page_size {
query.push(("page_size", page_size.to_string()));
}
if let Some(timestamp) = timestamp {
query.push(("timestamp", timestamp.to_owned()));
}
self.transport
.request(
routes::GET_APP_EVENTS.method.clone(),
url,
&query,
RequestBody::None,
)
.await
}
pub async fn get_network_scan(
&self,
network_id: &str,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = self.resolve_network_scoped_url(&routes::GET_NETWORK_SCAN, network_id, parent)?;
self.transport
.request(
routes::GET_NETWORK_SCAN.method.clone(),
url,
&[],
RequestBody::None,
)
.await
}
pub async fn get_channel_utilization(
&self,
network_id: &str,
start: &str,
end: &str,
options: &GetChannelUtilizationOptions<'_>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
if let Some(busy_threshold) = options.busy_threshold {
validate_positive("busy_threshold", busy_threshold)?;
}
if let Some(band) = options.band
&& !CHANNEL_UTILIZATION_BANDS.contains(&band)
{
return Err(Error::validation(
"band",
format!(
"must be one of {}, got {}",
crate::params::py_tuple(CHANNEL_UTILIZATION_BANDS),
crate::params::py_quote(band)
),
));
}
if let Some(granularity) = options.granularity {
validate_positive("granularity", granularity)?;
}
let url =
self.resolve_network_scoped_url(&routes::GET_CHANNEL_UTILIZATION, network_id, parent)?;
let mut query: Vec<(&str, String)> =
vec![("start", start.to_owned()), ("end", end.to_owned())];
if let Some(busy_threshold) = options.busy_threshold {
query.push(("busy_threshold", busy_threshold.to_string()));
}
if let Some(eero_id) = options.eero_id {
query.push(("eero_id", eero_id.to_owned()));
}
if let Some(band) = options.band {
query.push(("band", band.to_owned()));
}
if let Some(granularity) = options.granularity {
query.push(("granularity", granularity.to_string()));
}
if let Some(gap_data_placeholder) = options.gap_data_placeholder {
query.push(("gap_data_placeholder", gap_data_placeholder.to_owned()));
}
self.transport
.request(
routes::GET_CHANNEL_UTILIZATION.method.clone(),
url,
&query,
RequestBody::None,
)
.await
}
}
fn validate_positive(field: &str, value: u32) -> Result<u32, Error> {
if value == 0 {
return Err(Error::validation(
field,
format!("must be a positive integer, got {value}"),
));
}
Ok(value)
}