Refactor Models for InfluxDB (#1)

Update to InfluxDB 2.0 and update all interfaces to work with it.

MAC has been deprecated, since current `influxdb2` doesn't support non built-in types for read/write into the DB.

Co-authored-by: Felipe Diniello <felipediniello@pm.me>
Reviewed-on: #1

xyz-engine/src/handler.rs

@@ -1,23 +1,29 @@
 pub mod device {
-    use kairo_common::influxdb_models::BeaconMeasure;
-    use kairo_common::{unit_conversion::UnitsConversion, DeviceReport, MAC};
+    use kairo_common::{
+        influx::{self, Bucket},
+        unit_conversion::UnitsConversion,
+        BeaconMeasure, DeviceReport, MAC,
+    };
 
     use crate::position_solver::solve_for;
 
     pub async fn report(device_id: &str, payload: &str) {
         if let Ok(device_report) = serde_json::from_str::<DeviceReport>(payload) {
-            // device_report.data.sort_by(|a, b| b.pwr.cmp(&a.pwr));
+            // split the report into individual measures
+            let measures = device_report
+                .data
+                .iter()
+                .map(|f| BeaconMeasure::new(device_id, &f.beacon_id, f.rssi.dBm_to_W()))
+                // sort them as a vector of write queries
+                .collect::<Vec<BeaconMeasure>>();
 
-            let mut count = 0;
-            for beacon in device_report.data.iter() {
-                let measure = BeaconMeasure::new(&beacon.beacon_id, beacon.rssi.dBm_to_W());
-                if (measure.write_for(device_id).await).is_ok() {
-                    count += 1;
-                }
-            }
+            let more_than_three = measures.len() >= 3;
+            let result = influx::Client::get()
+                .write(Bucket::Tmp, futures::stream::iter(measures))
+                .await;
 
             // If I added more than 3 valid measures it's worth to process the position
-            if count >= 3 {
+            if result.is_ok() && more_than_three {
                 let device_id = MAC::new(device_id);
                 tokio::spawn(async move {
                     let _r = solve_for(device_id).await;

xyz-engine/src/position_solver.rs

@@ -2,8 +2,8 @@ use itertools::Itertools;
 use std::collections::HashMap;
 
 use kairo_common::{
-    influxdb_models::{BeaconMeasure, KnownPosition},
-    Antenna, Point, MAC,
+    influx::{self, Bucket},
+    Antenna, BeaconMeasure, KnownPosition, Point, MAC,
 };
 struct KnownDistance {
     point: Point,
@@ -13,7 +13,21 @@ struct KnownDistance {
 pub async fn solve_for(device_id: MAC) -> Result<Point, ()> {
     let antennas = anntennas_hashmap();
 
-    let measure = BeaconMeasure::get_for(device_id.as_str()).await.unwrap();
+    // let measure = BeaconMeasure::get_for(device_id.as_str()).await.unwrap();
+
+    let query = format!(
+        "
+            |> range(start: -1s)
+            |> filter(fn: (r) => r[\"_measurement\"] == \"beacon_measures\")
+            |> filter(fn: (r) => r[\"device_id\"] == \"{}\" )
+        ",
+        device_id
+    );
+
+    let measure = influx::Client::get()
+        .query::<BeaconMeasure>(Bucket::Tmp, query)
+        .await
+        .unwrap();
 
     let known_distance = measure
         .iter()
@@ -38,13 +52,25 @@ pub async fn solve_for(device_id: MAC) -> Result<Point, ()> {
 
     print!("Old len(): {} \t", posible_positions.len());
 
-    if let Some(last_position) = KnownPosition::get_last_for(device_id.as_str(), 2)
+    let query = format!(
+        "|> range(start: -1s)
+        |> filter(fn: (r) => r[\"_measurement\"] == \"known_positions\")
+        |> filter(fn: (r) => r[\"device_id\"] == \"{}\" )
+        |> last()
+    ",
+        device_id
+    );
+
+    if let Ok(last_position) = influx::Client::get()
+        .query::<KnownPosition>(Bucket::Perm, query)
         .await
-        .unwrap()
     {
-        let last_position = Point::new(last_position.x, last_position.y);
-        posible_positions.retain(|p| last_position.distance_to(&p.point) < 3.0);
+        if !last_position.is_empty() {
+            let last_position = Point::new(last_position[0].x, last_position[0].y);
+            posible_positions.retain(|p| last_position.distance_to(&p.point) < 3.0);
+        }
     }
+
     println!("New len(): {}", posible_positions.len());
 
     let mut pos = Point::new(0.0, 0.0);
@@ -57,8 +83,11 @@ pub async fn solve_for(device_id: MAC) -> Result<Point, ()> {
 
     pos /= divisor;
 
-    // println!("Pos: {}", pos);
-    let _r = KnownPosition::new(pos).write_for(device_id.as_str()).await;
+    println!("Pos: {}", pos);
+    let known_pos = KnownPosition::new(device_id.as_str(), pos);
+    let _r = influx::Client::get()
+        .write(Bucket::Perm, futures::stream::iter([known_pos]))
+        .await;
 
     Ok(pos)
 }
@@ -132,16 +161,16 @@ fn trilat(a: &KnownDistance, b: &KnownDistance, c: &KnownDistance) -> Option<Kno
     }
 }
 
-fn anntennas_hashmap() -> HashMap<MAC, Antenna> {
+fn anntennas_hashmap() -> HashMap<String, Antenna> {
     let data = vec![
         Antenna::new("e6:ad:0b:2e:d7:11", 30.0, Point::new(15.0, 15.0)),
         Antenna::new("c2:b5:f5:cc:e6:88", 30.0, Point::new(15.0, -15.0)),
         Antenna::new("e6:2e:e6:88:f5:cc", 30.0, Point::new(-15.0, 15.0)),
         Antenna::new("c2:ad:0b:b5:11:d7", 30.0, Point::new(-15.0, -15.0)),
     ];
-    let mut map: HashMap<MAC, Antenna> = HashMap::new();
+    let mut map: HashMap<String, Antenna> = HashMap::new();
     for a in data.iter() {
-        map.insert(a.id, a.clone());
+        map.insert(a.id.clone(), a.clone());
     }
     map
 }