vapix 0.1.0

Client for AXIS Communications devices' VAPIX API
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! The [basic device info API](https://www.axis.com/vapix-library/subjects/t10037719/section/t10132180/display).

use crate::v4::JsonService;
use crate::{Device, Transport};
use serde::{Deserialize, Serialize};

/// The basic device info API.
pub struct BasicDeviceInfo<'a, T: Transport>(JsonService<'a, T>);

/// A set of basic device properties.
#[derive(Debug, Deserialize, Clone, Eq, PartialEq)]
pub struct Properties {
    /// The brand of the device, likely `"AXIS"`.
    #[serde(rename = "Brand")]
    pub brand: String,
    /// The hardware ID, believed to be an internal AXIS part identifier.
    #[serde(rename = "HardwareID")]
    pub hardware_id: String,
    /// The full name of the product.
    #[serde(rename = "ProdFullName")]
    pub product_full_name: String,
    /// The product number seen in typical product catalogs.
    #[serde(rename = "ProdNbr")]
    pub product_number: String,
    /// The short name of the product.
    #[serde(rename = "ProdShortName")]
    pub product_short_name: String,
    /// TODO
    #[serde(rename = "ProdType")]
    pub product_type: String,
    /// TODO
    #[serde(rename = "ProdVariant")]
    pub product_variant: String,
    /// The device's serial number.
    #[serde(rename = "SerialNumber")]
    pub serial_number: String,
    /// The name of the system-on-chip inside the device.
    #[serde(rename = "Soc")]
    pub soc: String,
    /// The architecture of the system-on-chip inside the device.
    #[serde(rename = "Architecture")]
    pub soc_architecture: String,
    /// The system-on-chip's serial number.
    #[serde(rename = "SocSerialNumber")]
    pub soc_serial_number: String,
    /// The firmware's build date, expressed as a string.
    #[serde(rename = "BuildDate")]
    pub firmware_build_date: String,
    /// The firmware version, expressed as a string.
    #[serde(rename = "Version")]
    pub firmware_version: String,
    /// TOOD
    #[serde(rename = "WebURL")]
    pub web_url: String,
}

impl<'a, T: Transport> BasicDeviceInfo<'a, T> {
    pub(crate) fn new(device: &'a Device<T>, api_version: String) -> Self {
        Self(JsonService::new(
            device,
            "/axis-cgi/basicdeviceinfo.cgi",
            api_version,
        ))
    }

    /// Retreive `Properties`.
    pub async fn properties(&self) -> Result<Properties, crate::Error<T::Error>> {
        #[derive(Serialize)]
        #[serde(rename_all = "camelCase")]
        struct Req<'a> {
            property_list: &'a [&'a str],
        }

        #[derive(Deserialize)]
        #[serde(rename_all = "camelCase")]
        struct Resp {
            property_list: Properties,
        }

        let resp: Resp = self
            .0
            .call_method(
                "getProperties",
                Req {
                    property_list: &[
                        "Architecture",
                        "Brand",
                        "BuildDate",
                        "HardwareID",
                        "ProdFullName",
                        "ProdNbr",
                        "ProdShortName",
                        "ProdType",
                        "ProdVariant",
                        "SerialNumber",
                        "Soc",
                        "SocSerialNumber",
                        "Version",
                        "WebURL",
                    ],
                },
            )
            .await?;

        Ok(resp.property_list)
    }
}