nullnet-wallguard-server 0.2.0

mod latest_device_info;

use crate::datastore::DatastoreWrapper;
use chrono::Utc;
use latest_device_info::LatestDeviceInfo;
use nullnet_libdatastore::{
    CreateParams, CreateRequest, GetByIdRequest, Params, Query, ResponseData,
};
use nullnet_liberror::Error;
use serde_json::json;

impl DatastoreWrapper {
    pub async fn heartbeat(
        &self,
        token: &str,
        device_id: String,
    ) -> Result<LatestDeviceInfo, Error> {
        let (create_result, fetch_result) = tokio::join!(
            self.internal_hb_create_hb_record(device_id.clone(), token),
            self.internal_hb_fetch_device_info(device_id, token)
        );

        let _ = create_result?;

        fetch_result
    }

    async fn internal_hb_create_hb_record(
        &self,
        device_id: String,
        token: &str,
    ) -> Result<ResponseData, Error> {
        let request = CreateRequest {
            params: Some(CreateParams {
                table: String::from("device_heartbeats"),
            }),
            query: Some(Query {
                pluck: String::new(),
                durability: String::from("soft"),
            }),
            body: json!({
                "device_id": device_id.clone(),
                "timestamp": Utc::now().to_rfc3339(),
                "entity_prefix": String::from("HB")
            })
            .to_string(),
        };

        let retval = self.inner.create(request, token).await?;

        Ok(retval)
    }

    async fn internal_hb_fetch_device_info(
        &self,
        device_id: String,
        token: &str,
    ) -> Result<LatestDeviceInfo, Error> {
        let request = GetByIdRequest {
            params: Some(Params {
                id: device_id,
                table: String::from("devices"),
            }),
            query: Some(Query {
                pluck: String::from("status,is_monitoring_enabled,is_remote_access_enabled"),
                durability: String::from("soft"),
            }),
        };

        let response = self.inner.get_by_id(request, token).await?;
        LatestDeviceInfo::from_response_data(response)
    }
}