nle-cloud-sdk 0.1.1

Unofficial asynchronous Rust SDK for the NLECloud (新大陆物联网云平台) IoT platform
Documentation
use crate::client::NleCloudClient;
use crate::error::{Result, SdkError};
use crate::models::{
    DeviceAddUpdateDto, DeviceBaseInfoDto, DeviceFuzzyQryPagingParas, DeviceInfoDto,
    DeviceSensorDataDto, ListPagerSet, OnlineDataDto,
};
use reqwest::Method;

impl NleCloudClient {
    /// Batch queries latest telemetry data for multiple devices (comma-separated IDs, up to 100).
    ///
    /// Endpoint: `GET /devices/datas?devIds={devIds}`
    pub async fn get_devices_datas(
        &self,
        dev_ids: &str,
        token_override: Option<&str>,
    ) -> Result<Vec<DeviceSensorDataDto>> {
        if dev_ids.trim().is_empty() {
            return Err(SdkError::InvalidParameter(
                "dev_ids cannot be empty".to_string(),
            ));
        }

        self.request_with_envelope(
            Method::GET,
            "devices/datas",
            &[("devIds", dev_ids)],
            None,
            token_override,
            true,
        )
        .await
    }

    /// Batch queries simulation telemetry data for multiple devices (comma-separated IDs).
    ///
    /// Endpoint: `GET /devices/simulationdatas?devIds={devIds}`
    pub async fn get_devices_simulation_datas(
        &self,
        dev_ids: &str,
        token_override: Option<&str>,
    ) -> Result<Vec<DeviceSensorDataDto>> {
        if dev_ids.trim().is_empty() {
            return Err(SdkError::InvalidParameter(
                "dev_ids cannot be empty".to_string(),
            ));
        }

        self.request_with_envelope(
            Method::GET,
            "devices/simulationdatas",
            &[("devIds", dev_ids)],
            None,
            token_override,
            true,
        )
        .await
    }

    /// Batch queries online status for multiple devices (comma-separated IDs).
    ///
    /// Endpoint: `GET /devices/status?devids={devids}`
    pub async fn get_devices_status(
        &self,
        dev_ids: &str,
        token_override: Option<&str>,
    ) -> Result<Vec<OnlineDataDto>> {
        if dev_ids.trim().is_empty() {
            return Err(SdkError::InvalidParameter(
                "dev_ids cannot be empty".to_string(),
            ));
        }

        self.request_with_envelope(
            Method::GET,
            "devices/status",
            &[("devids", dev_ids)],
            None,
            token_override,
            true,
        )
        .await
    }

    /// Queries information and sensors for a single device by ID.
    ///
    /// Endpoint: `GET /devices/{deviceId}`
    pub async fn get_device_info(
        &self,
        device_id: i32,
        token_override: Option<&str>,
    ) -> Result<DeviceInfoDto> {
        if device_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "DeviceId must be greater than zero".to_string(),
            ));
        }

        let path = format!("devices/{}", device_id);
        self.request_with_envelope(Method::GET, &path, &[], None, token_override, true)
            .await
    }

    /// Queries devices with fuzzy parameters and pagination.
    ///
    /// Endpoint: `GET /devices`
    pub async fn get_devices(
        &self,
        query: &DeviceFuzzyQryPagingParas,
        token_override: Option<&str>,
    ) -> Result<ListPagerSet<DeviceBaseInfoDto>> {
        let mut params = Vec::new();
        let page_size_str;
        let page_index_str;

        if let Some(ps) = query.page_size {
            page_size_str = ps.to_string();
            params.push(("PageSize", page_size_str.as_str()));
        }
        if let Some(pi) = query.page_index {
            page_index_str = pi.to_string();
            params.push(("PageIndex", page_index_str.as_str()));
        }
        if let Some(ref sd) = query.start_date {
            params.push(("StartDate", sd.as_str()));
        }
        if let Some(ref ed) = query.end_date {
            params.push(("EndDate", ed.as_str()));
        }
        if let Some(ref kw) = query.keyword {
            params.push(("Keyword", kw.as_str()));
        }
        if let Some(ref dids) = query.device_ids {
            params.push(("DeviceIds", dids.as_str()));
        }
        if let Some(ref tag) = query.tag {
            params.push(("Tag", tag.as_str()));
        }
        if let Some(ref onl) = query.is_online {
            params.push(("IsOnline", onl.as_str()));
        }
        if let Some(ref share) = query.is_share {
            params.push(("IsShare", share.as_str()));
        }
        if let Some(ref pkw) = query.project_key_word {
            params.push(("ProjectKeyWord", pkw.as_str()));
        }

        self.request_with_envelope(Method::GET, "devices", &params, None, token_override, true)
            .await
    }

    /// Creates a new device and returns its assigned ID.
    ///
    /// Endpoint: `POST /devices`
    pub async fn add_device(
        &self,
        device: &DeviceAddUpdateDto,
        token_override: Option<&str>,
    ) -> Result<i32> {
        let body = serde_json::to_value(device)?;
        self.request_with_envelope(
            Method::POST,
            "devices",
            &[],
            Some(body),
            token_override,
            true,
        )
        .await
    }

    /// Updates configuration for an existing device.
    ///
    /// Endpoint: `PUT /devices/{deviceid}`
    pub async fn update_device(
        &self,
        device_id: i32,
        device: &DeviceAddUpdateDto,
        token_override: Option<&str>,
    ) -> Result<()> {
        if device_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "DeviceId must be greater than zero".to_string(),
            ));
        }

        let path = format!("devices/{}", device_id);
        let body = serde_json::to_value(device)?;
        self.request_empty(Method::PUT, &path, &[], Some(body), token_override, true)
            .await
    }

    /// Deletes a device by ID.
    ///
    /// Endpoint: `DELETE /devices/{deviceid}`
    pub async fn delete_device(&self, device_id: i32, token_override: Option<&str>) -> Result<()> {
        if device_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "DeviceId must be greater than zero".to_string(),
            ));
        }

        let path = format!("devices/{}", device_id);
        self.request_empty(Method::DELETE, &path, &[], None, token_override, true)
            .await
    }
}