unifly-api 0.8.0

Async Rust client, reactive data layer, and domain model for UniFi controller APIs
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

// ── Filter predicates for entity streams ──
//
// Used by the TUI to filter snapshots without re-querying the API.

use crate::model::{Client, ClientType, Device, DeviceState, DeviceType, EntityId, MacAddress};

/// Filter predicate for device collections.
pub enum DeviceFilter {
    All,
    ByType(DeviceType),
    ByState(DeviceState),
    BySite(EntityId),
    Online,
    Offline,
    Custom(Box<dyn Fn(&Device) -> bool + Send + Sync>),
}

impl DeviceFilter {
    pub fn matches(&self, device: &Device) -> bool {
        match self {
            Self::All => true,
            Self::ByType(dt) => device.device_type == *dt,
            Self::ByState(ds) => device.state == *ds,
            // All devices in the DataStore belong to the configured site,
            // so BySite is effectively a no-op in single-site mode.
            // Multi-site support would require adding site_id to Device.
            Self::BySite(_sid) => true,
            Self::Online => device.state.is_online(),
            Self::Offline => matches!(device.state, DeviceState::Offline),
            Self::Custom(f) => f(device),
        }
    }
}

/// Filter predicate for client collections.
pub enum ClientFilter {
    All,
    ByType(ClientType),
    ByNetwork(EntityId),
    ByDevice(MacAddress),
    Guests,
    Blocked,
    Custom(Box<dyn Fn(&Client) -> bool + Send + Sync>),
}

impl ClientFilter {
    pub fn matches(&self, client: &Client) -> bool {
        match self {
            Self::All => true,
            Self::ByType(ct) => client.client_type == *ct,
            Self::ByNetwork(nid) => client.network_id.as_ref() == Some(nid),
            Self::ByDevice(mac) => client.uplink_device_mac.as_ref() == Some(mac),
            Self::Guests => client.is_guest,
            Self::Blocked => client.blocked,
            Self::Custom(f) => f(client),
        }
    }
}