Modeled Coverage - Phase 3

Cargo.toml

@@ -57,7 +57,7 @@ sqlx = {version = "0", features = [
 ]}
 
 helium-crypto = {version = "0.6.8", features=["sqlx-postgres", "multisig"]}
-helium-proto = {git = "https://github.com/helium/proto", branch = "master", features = ["services"]}
+helium-proto = {git = "https://github.com/helium/proto", branch = "map/modeled-coverage", features = ["services"]}
 hextree = "*"
 solana-client = "1.14"
 solana-sdk = "1.14"
@@ -83,8 +83,8 @@ prost = "*"
 once_cell = "1"
 lazy_static = "1"
 config = {version="0", default-features=false, features=["toml"]}
-h3o = "0"
-xorf = {version = "0", features = ["serde"] }
+h3o = {version = "0", features = ["serde"]}
+xorf = {version = "0", features = ["serde"]}
 bytes = "*"
 structopt = "0"
 bincode = "1"
@@ -97,6 +97,7 @@ itertools = "*"
 data-credits = {git = "https://github.com/helium/helium-program-library.git", tag = "v0.1.0"}
 helium-sub-daos = {git = "https://github.com/helium/helium-program-library.git", tag = "v0.1.0"}
 price-oracle = {git = "https://github.com/helium/helium-program-library.git", tag = "v0.1.0"}
+uuid = {version = "1.3.4", features = ["v4", "serde"]}
 
 [patch.crates-io]
 sqlx = { git = "https://github.com/helium/sqlx.git", rev = "92a2268f02e0cac6fccb34d3e926347071dbb88d" }

file_store/Cargo.toml

@@ -46,6 +46,8 @@ sqlx = {workspace = true}
 async-trait = {workspace = true}
 derive_builder = "0"
 retainer = {workspace = true}
+uuid = {workspace = true}
+h3o = {workspace = true}
 
 [dev-dependencies]
 hex-literal = "0"

file_store/src/coverage.rs

@@ -0,0 +1,102 @@
+use crate::{
+    error::DecodeError,
+    traits::{MsgDecode, TimestampDecode},
+    Error, Result,
+};
+use chrono::{DateTime, Utc};
+use helium_crypto::PublicKeyBinary;
+use helium_proto::services::poc_mobile::{
+    CoverageObjectIngestReportV1, CoverageObjectReqV1,
+    RadioHexSignalLevel as RadioHexSignalLevelProto, SignalLevel,
+};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct RadioHexSignalLevel {
+    pub location: h3o::CellIndex,
+    pub signal_level: SignalLevel,
+    pub signal_power: f64,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CoverageObject {
+    pub pub_key: PublicKeyBinary,
+    pub uuid: Uuid,
+    pub cbsd_id: String,
+    pub coverage_claim_time: DateTime<Utc>,
+    pub indoor: bool,
+    pub coverage: Vec<RadioHexSignalLevel>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CoverageObjectIngestReport {
+    pub received_timestamp: DateTime<Utc>,
+    pub report: CoverageObject,
+}
+
+impl MsgDecode for CoverageObject {
+    type Msg = CoverageObjectReqV1;
+}
+
+impl MsgDecode for CoverageObjectIngestReport {
+    type Msg = CoverageObjectIngestReportV1;
+}
+
+impl TryFrom<CoverageObjectIngestReportV1> for CoverageObjectIngestReport {
+    type Error = Error;
+
+    fn try_from(v: CoverageObjectIngestReportV1) -> Result<Self> {
+        Ok(Self {
+            received_timestamp: v.received_timestamp.to_timestamp_millis()?,
+            report: v
+                .report
+                .ok_or_else(|| Error::not_found("ingest coverage object report"))?
+                .try_into()?,
+        })
+    }
+}
+
+impl TryFrom<CoverageObjectReqV1> for CoverageObject {
+    type Error = Error;
+
+    fn try_from(v: CoverageObjectReqV1) -> Result<Self> {
+        let coverage: Result<Vec<RadioHexSignalLevel>> = v
+            .coverage
+            .into_iter()
+            .map(RadioHexSignalLevel::try_from)
+            .collect();
+        Ok(Self {
+            pub_key: v.pub_key.into(),
+            uuid: Uuid::from_slice(&v.uuid).map_err(DecodeError::from)?,
+            cbsd_id: v.cbsd_id,
+            coverage_claim_time: v.coverage_claim_time.to_timestamp()?,
+            indoor: v.indoor,
+            coverage: coverage?,
+        })
+    }
+}
+
+impl TryFrom<RadioHexSignalLevelProto> for RadioHexSignalLevel {
+    type Error = Error;
+
+    fn try_from(v: RadioHexSignalLevelProto) -> Result<Self> {
+        Ok(Self {
+            signal_level: SignalLevel::from_i32(v.signal_level).ok_or_else(|| {
+                DecodeError::unsupported_signal_level("coverage_object_req_v1", v.signal_level)
+            })?,
+            signal_power: v.signal_power,
+            location: v.location.parse().map_err(DecodeError::from)?,
+        })
+    }
+}
+
+impl Into<RadioHexSignalLevelProto> for RadioHexSignalLevel {
+    fn into(self) -> RadioHexSignalLevelProto {
+        RadioHexSignalLevelProto {
+            signal_level: self.signal_level as i32,
+            signal_power: self.signal_power,
+            location: self.location.to_string(),
+        }
+    }
+}

file_store/src/error.rs

@@ -54,8 +54,14 @@ pub enum DecodeError {
     UnsupportedParticipantSide(String, i32),
     #[error("unsupported verification status, type: {0}, value: {1}")]
     UnsupportedStatusReason(String, i32),
+    #[error("unsupported signal level, type: {0}, value: {1}")]
+    UnsupportedSignalLevel(String, i32),
     #[error("invalid unix timestamp {0}")]
     InvalidTimestamp(u64),
+    #[error("Uuid error: {0}")]
+    UuidError(#[from] uuid::Error),
+    #[error("Ivalid cell index error: {0}")]
+    InvalidCellIndexError(#[from] h3o::error::InvalidCellIndex),
 }
 
 #[derive(Error, Debug)]
@@ -127,6 +133,10 @@ impl DecodeError {
     pub fn unsupported_status_reason<E: ToString>(msg1: E, msg2: i32) -> Error {
         Error::Decode(Self::UnsupportedInvalidReason(msg1.to_string(), msg2))
     }
+
+    pub fn unsupported_signal_level(msg1: impl ToString, msg2: i32) -> Error {
+        Error::Decode(Self::UnsupportedSignalLevel(msg1.to_string(), msg2))
+    }
 }
 
 impl From<helium_crypto::Error> for Error {