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::{ListPagerSet, ProjectFuzzyQryPagingParas, ProjectInfoDto, SensorBaseInfoDto};
use reqwest::Method;

impl NleCloudClient {
    /// Queries information for a single project by ID.
    ///
    /// Endpoint: `GET /projects/{projectId}`
    pub async fn get_project_info(
        &self,
        project_id: i32,
        token_override: Option<&str>,
    ) -> Result<ProjectInfoDto> {
        if project_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "ProjectId must be greater than zero".to_string(),
            ));
        }

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

    /// Queries projects with fuzzy matching and pagination.
    ///
    /// Endpoint: `GET /projects`
    pub async fn get_projects(
        &self,
        query: &ProjectFuzzyQryPagingParas,
        token_override: Option<&str>,
    ) -> Result<ListPagerSet<ProjectInfoDto>> {
        let mut params = Vec::new();
        let page_size_str;
        let page_index_str;
        let net_work_kind_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 tag) = query.project_tag {
            params.push(("ProjectTag", tag.as_str()));
        }
        if let Some(nk) = query.net_work_kind {
            net_work_kind_str = nk.to_string();
            params.push(("NetWorkKind", net_work_kind_str.as_str()));
        }

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

    /// Queries all sensors across all devices in a project.
    ///
    /// Endpoint: `GET /projects/{projectId}/sensors`
    pub async fn get_project_sensors(
        &self,
        project_id: i32,
        token_override: Option<&str>,
    ) -> Result<Vec<SensorBaseInfoDto>> {
        if project_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "ProjectId must be greater than zero".to_string(),
            ));
        }

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

    /// Queries all sensors in a project with optional `is_private` flag.
    ///
    /// Endpoint: `GET /projects/{projectId}/sensors?isPrivate={isPrivate}`
    pub async fn get_project_sensors_with_options(
        &self,
        project_id: i32,
        is_private: Option<bool>,
        token_override: Option<&str>,
    ) -> Result<Vec<SensorBaseInfoDto>> {
        if project_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "ProjectId must be greater than zero".to_string(),
            ));
        }

        let path = format!("projects/{}/sensors", project_id);
        let mut query = Vec::new();
        let is_private_str;
        if let Some(p) = is_private {
            is_private_str = p.to_string();
            query.push(("isPrivate", is_private_str.as_str()));
        }

        self.request_with_envelope(Method::GET, &path, &query, None, token_override, true)
            .await
    }

    /// Adds a new project and returns its assigned ID.
    ///
    /// Endpoint: `POST /projects`
    pub async fn add_project(
        &self,
        project: &crate::models::ProjectAddUpdateDto,
        token_override: Option<&str>,
    ) -> Result<i32> {
        let body = serde_json::to_value(project)?;
        self.request_with_envelope(
            Method::POST,
            "projects",
            &[],
            Some(body),
            token_override,
            true,
        )
        .await
    }

    /// Updates an existing project.
    ///
    /// Endpoint: `PUT /projects/{projectId}`
    pub async fn update_project(
        &self,
        project_id: i32,
        project: &crate::models::ProjectAddUpdateDto,
        token_override: Option<&str>,
    ) -> Result<()> {
        if project_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "ProjectId must be greater than zero".to_string(),
            ));
        }

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

    /// Deletes one or more projects by ID list.
    ///
    /// Endpoint: `DELETE /projects`
    pub async fn delete_projects(
        &self,
        project_ids: &[i32],
        token_override: Option<&str>,
    ) -> Result<()> {
        let body = serde_json::to_value(project_ids)?;
        self.request_empty(
            Method::DELETE,
            "projects",
            &[],
            Some(body),
            token_override,
            true,
        )
        .await
    }

    /// Queries real-time telemetry data for sensors in a project, optionally filtered by device.
    ///
    /// Endpoint: `GET /projects/{projectId}/sensorsrealtimedata`
    pub async fn get_project_sensors_realtime(
        &self,
        project_id: i32,
        device_id: Option<i32>,
        token_override: Option<&str>,
    ) -> Result<Vec<serde_json::Value>> {
        if project_id <= 0 {
            return Err(SdkError::InvalidParameter(
                "ProjectId must be greater than zero".to_string(),
            ));
        }

        let path = format!("projects/{}/sensorsrealtimedata", project_id);
        let mut query = Vec::new();
        let dev_id_str;
        if let Some(did) = device_id {
            dev_id_str = did.to_string();
            query.push(("deviceId", dev_id_str.as_str()));
        }

        self.request_with_envelope(Method::GET, &path, &query, None, token_override, true)
            .await
    }
}