use native_db::{native_db, ToKey};
use native_model::{native_model, Model};
use serde::{Deserialize, Serialize};
pub use super::v11::LinkType;
pub use super::v9::{Session, SessionEndReason, SessionStatus};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[native_model(id = 15, version = 7)]
#[native_db]
pub struct ConnectivityLocal {
pub id: Option<i64>,
#[primary_key]
pub id_local: Option<String>,
#[secondary_key]
pub session_id: Option<i64>,
#[secondary_key]
pub device_id: Option<i64>,
#[secondary_key]
pub ancestor_id_local: Option<String>,
pub inserted_at: Option<String>,
pub timestamp_start: String,
pub signal: Option<f64>,
pub noise: Option<f64>,
pub altitude: f64,
pub heading: f64,
pub location: Option<String>,
pub h14_index: String,
pub h13_index: String,
pub h12_index: String,
pub h11_index: String,
pub battery_percentage: Option<f32>,
pub frequency_hz: Option<f32>,
pub bandwidth_hz: Option<f32>,
pub associated_station: Option<String>,
pub mode: Option<String>,
pub battery_volts: Option<f32>,
#[serde(default)]
pub link_type: LinkType,
pub quality_normalized: Option<f32>,
pub secondary_battery_percentage: Option<f32>,
pub secondary_battery_volts: Option<f32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Connectivity {
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
pub session_id: Option<i64>,
pub device_id: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub inserted_at: Option<String>,
pub timestamp_start: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub signal: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub noise: Option<f64>,
pub altitude: f64,
pub heading: f64,
pub location: Option<String>,
pub h14_index: String,
pub h13_index: String,
pub h12_index: String,
pub h11_index: String,
pub battery_percentage: Option<f32>,
pub frequency_hz: Option<f32>,
pub bandwidth_hz: Option<f32>,
pub associated_station: Option<String>,
pub mode: Option<String>,
pub battery_volts: Option<f32>,
#[serde(default)]
pub link_type: LinkType,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quality_normalized: Option<f32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub secondary_battery_percentage: Option<f32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub secondary_battery_volts: Option<f32>,
}
impl Default for ConnectivityLocal {
fn default() -> Self {
Self {
id: None,
id_local: None,
session_id: None,
device_id: None,
ancestor_id_local: None,
inserted_at: None,
timestamp_start: String::new(),
signal: None,
noise: None,
altitude: 0.0,
heading: 0.0,
location: None,
h14_index: String::new(),
h13_index: String::new(),
h12_index: String::new(),
h11_index: String::new(),
battery_percentage: None,
frequency_hz: None,
bandwidth_hz: None,
associated_station: None,
mode: None,
battery_volts: None,
link_type: LinkType::Unknown,
quality_normalized: None,
secondary_battery_percentage: None,
secondary_battery_volts: None,
}
}
}
impl super::v1::Syncable for ConnectivityLocal {
fn id(&self) -> Option<i64> {
self.id
}
fn set_id(&mut self, id: i64) {
self.id = Some(id);
}
fn id_local(&self) -> Option<String> {
self.id_local.clone()
}
fn set_id_local(&mut self, id_local: String) {
self.id_local = Some(id_local);
}
}
impl super::v1::AncestorLocal for ConnectivityLocal {
fn ancestor_id_local(&self) -> Option<String> {
self.ancestor_id_local.clone()
}
fn set_ancestor_id_local(&mut self, ancestor_id_local: String) {
self.ancestor_id_local = Some(ancestor_id_local);
}
}
impl From<ConnectivityLocal> for Connectivity {
fn from(local: ConnectivityLocal) -> Self {
Self {
id: local.id,
session_id: local.session_id,
device_id: local.device_id,
inserted_at: local.inserted_at,
timestamp_start: local.timestamp_start,
signal: local.signal,
noise: local.noise,
altitude: local.altitude,
heading: local.heading,
location: local.location,
h14_index: local.h14_index,
h13_index: local.h13_index,
h12_index: local.h12_index,
h11_index: local.h11_index,
battery_percentage: local.battery_percentage,
frequency_hz: local.frequency_hz,
bandwidth_hz: local.bandwidth_hz,
associated_station: local.associated_station,
mode: local.mode,
battery_volts: local.battery_volts,
link_type: local.link_type,
quality_normalized: local.quality_normalized,
secondary_battery_percentage: local.secondary_battery_percentage,
secondary_battery_volts: local.secondary_battery_volts,
}
}
}
impl From<Connectivity> for ConnectivityLocal {
fn from(remote: Connectivity) -> Self {
Self {
id: remote.id,
id_local: None,
session_id: remote.session_id,
device_id: remote.device_id,
ancestor_id_local: None,
inserted_at: remote.inserted_at,
timestamp_start: remote.timestamp_start,
signal: remote.signal,
noise: remote.noise,
altitude: remote.altitude,
heading: remote.heading,
location: remote.location,
h14_index: remote.h14_index,
h13_index: remote.h13_index,
h12_index: remote.h12_index,
h11_index: remote.h11_index,
battery_percentage: remote.battery_percentage,
frequency_hz: remote.frequency_hz,
bandwidth_hz: remote.bandwidth_hz,
associated_station: remote.associated_station,
mode: remote.mode,
battery_volts: remote.battery_volts,
link_type: remote.link_type,
quality_normalized: remote.quality_normalized,
secondary_battery_percentage: remote.secondary_battery_percentage,
secondary_battery_volts: remote.secondary_battery_volts,
}
}
}
impl Connectivity {
pub fn new(
session_id: Option<i64>,
device_id: Option<i64>,
timestamp_start: u64,
signal: Option<f64>,
noise: Option<f64>,
altitude: f64,
heading: f64,
location: String,
h14_index: String,
h13_index: String,
h12_index: String,
h11_index: String,
battery_percentage: Option<f32>,
frequency_hz: Option<f32>,
bandwidth_hz: Option<f32>,
associated_station: Option<String>,
mode: Option<String>,
battery_volts: Option<f32>,
link_type: LinkType,
quality_normalized: Option<f32>,
secondary_battery_percentage: Option<f32>,
secondary_battery_volts: Option<f32>,
) -> Self {
use chrono::{DateTime, Utc};
let timestamp_start_str = DateTime::from_timestamp(timestamp_start as i64, 0)
.unwrap_or_else(|| DateTime::<Utc>::from_timestamp(0, 0).unwrap())
.to_rfc3339();
Self {
id: None,
session_id,
device_id,
inserted_at: None,
timestamp_start: timestamp_start_str,
signal,
noise,
altitude,
heading,
location: Some(location),
h14_index,
h13_index,
h12_index,
h11_index,
battery_percentage,
frequency_hz,
bandwidth_hz,
associated_station,
mode,
battery_volts,
link_type,
quality_normalized,
secondary_battery_percentage,
secondary_battery_volts,
}
}
}
impl ConnectivityLocal {
pub fn new(
session_id: Option<i64>,
device_id: Option<i64>,
timestamp_start: u64,
signal: Option<f64>,
noise: Option<f64>,
altitude: f64,
heading: f64,
location: String,
h14_index: String,
h13_index: String,
h12_index: String,
h11_index: String,
battery_percentage: Option<f32>,
frequency_hz: Option<f32>,
bandwidth_hz: Option<f32>,
associated_station: Option<String>,
mode: Option<String>,
battery_volts: Option<f32>,
link_type: LinkType,
quality_normalized: Option<f32>,
secondary_battery_percentage: Option<f32>,
secondary_battery_volts: Option<f32>,
) -> Self {
use chrono::{DateTime, Utc};
let timestamp_start_str = DateTime::from_timestamp(timestamp_start as i64, 0)
.unwrap_or_else(|| DateTime::<Utc>::from_timestamp(0, 0).unwrap())
.to_rfc3339();
Self {
id: None,
id_local: None,
session_id,
device_id,
ancestor_id_local: None,
inserted_at: None,
timestamp_start: timestamp_start_str,
signal,
noise,
altitude,
heading,
location: Some(location),
h14_index,
h13_index,
h12_index,
h11_index,
battery_percentage,
frequency_hz,
bandwidth_hz,
associated_station,
mode,
battery_volts,
link_type,
quality_normalized,
secondary_battery_percentage,
secondary_battery_volts,
}
}
}
impl From<super::v11::ConnectivityLocal> for ConnectivityLocal {
fn from(v11: super::v11::ConnectivityLocal) -> Self {
Self {
id: v11.id,
id_local: v11.id_local,
session_id: v11.session_id,
device_id: v11.device_id,
ancestor_id_local: v11.ancestor_id_local,
inserted_at: v11.inserted_at,
timestamp_start: v11.timestamp_start,
signal: v11.signal,
noise: v11.noise,
altitude: v11.altitude,
heading: v11.heading,
location: v11.location,
h14_index: v11.h14_index,
h13_index: v11.h13_index,
h12_index: v11.h12_index,
h11_index: v11.h11_index,
battery_percentage: v11.battery_percentage,
frequency_hz: v11.frequency_hz,
bandwidth_hz: v11.bandwidth_hz,
associated_station: v11.associated_station,
mode: v11.mode,
battery_volts: v11.battery_volts,
link_type: v11.link_type,
quality_normalized: v11.quality_normalized,
secondary_battery_percentage: None,
secondary_battery_volts: None,
}
}
}
impl From<super::v11::Connectivity> for Connectivity {
fn from(v11: super::v11::Connectivity) -> Self {
Self {
id: v11.id,
session_id: v11.session_id,
device_id: v11.device_id,
inserted_at: v11.inserted_at,
timestamp_start: v11.timestamp_start,
signal: v11.signal,
noise: v11.noise,
altitude: v11.altitude,
heading: v11.heading,
location: v11.location,
h14_index: v11.h14_index,
h13_index: v11.h13_index,
h12_index: v11.h12_index,
h11_index: v11.h11_index,
battery_percentage: v11.battery_percentage,
frequency_hz: v11.frequency_hz,
bandwidth_hz: v11.bandwidth_hz,
associated_station: v11.associated_station,
mode: v11.mode,
battery_volts: v11.battery_volts,
link_type: v11.link_type,
quality_normalized: v11.quality_normalized,
secondary_battery_percentage: None,
secondary_battery_volts: None,
}
}
}
impl From<super::v6::ConnectivityLocal> for ConnectivityLocal {
fn from(v6: super::v6::ConnectivityLocal) -> Self {
super::v11::ConnectivityLocal::from(v6).into()
}
}
impl From<super::v6::Connectivity> for Connectivity {
fn from(v6: super::v6::Connectivity) -> Self {
super::v11::Connectivity::from(v6).into()
}
}
impl From<super::v4::ConnectivityLocal> for ConnectivityLocal {
fn from(v4: super::v4::ConnectivityLocal) -> Self {
super::v11::ConnectivityLocal::from(v4).into()
}
}
impl From<super::v4::Connectivity> for Connectivity {
fn from(v4: super::v4::Connectivity) -> Self {
super::v11::Connectivity::from(v4).into()
}
}
impl From<super::v3::ConnectivityLocal> for ConnectivityLocal {
fn from(v3: super::v3::ConnectivityLocal) -> Self {
super::v11::ConnectivityLocal::from(v3).into()
}
}
impl From<super::v3::Connectivity> for Connectivity {
fn from(v3: super::v3::Connectivity) -> Self {
super::v11::Connectivity::from(v3).into()
}
}
impl From<super::v2::ConnectivityLocal> for ConnectivityLocal {
fn from(v2: super::v2::ConnectivityLocal) -> Self {
super::v11::ConnectivityLocal::from(v2).into()
}
}
impl From<super::v2::Connectivity> for Connectivity {
fn from(v2: super::v2::Connectivity) -> Self {
super::v11::Connectivity::from(v2).into()
}
}
impl From<super::v1::ConnectivityLocal> for ConnectivityLocal {
fn from(v1: super::v1::ConnectivityLocal) -> Self {
super::v11::ConnectivityLocal::from(v1).into()
}
}
impl From<super::v1::Connectivity> for Connectivity {
fn from(v1: super::v1::Connectivity) -> Self {
super::v11::Connectivity::from(v1).into()
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[native_model(id = 14, version = 4)]
#[native_db]
pub struct SessionLocal {
pub id: Option<i64>,
#[primary_key]
pub id_local: Option<String>,
pub device_id: i64,
pub timestamp_start: String,
pub timestamp_end: Option<String>,
pub inserted_at: Option<String>,
pub software_version: String,
pub locations: Option<String>,
pub altitude_max: f64,
pub altitude_min: f64,
pub altitude_average: f64,
pub velocity_max: f64,
pub velocity_min: f64,
pub velocity_average: f64,
pub distance_total: f64,
pub distance_max_from_start: f64,
pub battery_id: Option<i64>,
pub secondary_battery_id: Option<i64>,
pub post_approver: Option<String>,
pub start_approver: Option<String>,
pub end_approver: Option<String>,
#[serde(default)]
pub lifecycle: super::v1::EntityLifecycle,
pub lifecycle_changed_at: String,
#[serde(default)]
pub lifecycle_changed_by: Option<String>,
#[serde(default)]
pub lifecycle_reason: Option<String>,
#[serde(default)]
pub status: Option<SessionStatus>,
#[serde(default)]
pub end_reason: Option<SessionEndReason>,
}
impl Default for SessionLocal {
fn default() -> Self {
Self {
id: None,
id_local: None,
device_id: 0,
timestamp_start: String::new(),
timestamp_end: None,
inserted_at: None,
software_version: String::new(),
locations: None,
altitude_max: 0.0,
altitude_min: 0.0,
altitude_average: 0.0,
velocity_max: 0.0,
velocity_min: 0.0,
velocity_average: 0.0,
distance_total: 0.0,
distance_max_from_start: 0.0,
battery_id: None,
secondary_battery_id: None,
post_approver: None,
start_approver: None,
end_approver: None,
lifecycle: super::v1::EntityLifecycle::Active,
lifecycle_changed_at: chrono::Utc::now().to_rfc3339(),
lifecycle_changed_by: None,
lifecycle_reason: None,
status: Some(SessionStatus::InProgress),
end_reason: None,
}
}
}
impl super::v1::Syncable for SessionLocal {
fn id(&self) -> Option<i64> {
self.id
}
fn set_id(&mut self, id: i64) {
self.id = Some(id);
}
fn id_local(&self) -> Option<String> {
self.id_local.clone()
}
fn set_id_local(&mut self, id_local: String) {
self.id_local = Some(id_local);
}
}
impl From<SessionLocal> for Session {
fn from(local: SessionLocal) -> Self {
Session {
id: local.id,
device_id: local.device_id,
timestamp_start: local.timestamp_start,
timestamp_end: local.timestamp_end,
inserted_at: local.inserted_at,
software_version: local.software_version,
locations: local.locations,
altitude_max: local.altitude_max,
altitude_min: local.altitude_min,
altitude_average: local.altitude_average,
velocity_max: local.velocity_max,
velocity_min: local.velocity_min,
velocity_average: local.velocity_average,
distance_total: local.distance_total,
distance_max_from_start: local.distance_max_from_start,
battery_id: local.battery_id,
secondary_battery_id: local.secondary_battery_id,
post_approver: local.post_approver,
start_approver: local.start_approver,
end_approver: local.end_approver,
lifecycle: local.lifecycle,
lifecycle_changed_at: Some(local.lifecycle_changed_at.clone()),
lifecycle_changed_by: local.lifecycle_changed_by.clone(),
lifecycle_reason: local.lifecycle_reason.clone(),
status: local.status,
end_reason: local.end_reason,
}
}
}
impl From<Session> for SessionLocal {
fn from(session: Session) -> Self {
SessionLocal {
id: session.id,
id_local: None,
device_id: session.device_id,
timestamp_start: session.timestamp_start,
timestamp_end: session.timestamp_end,
inserted_at: session.inserted_at,
software_version: session.software_version,
locations: session.locations,
altitude_max: session.altitude_max,
altitude_min: session.altitude_min,
altitude_average: session.altitude_average,
velocity_max: session.velocity_max,
velocity_min: session.velocity_min,
velocity_average: session.velocity_average,
distance_total: session.distance_total,
distance_max_from_start: session.distance_max_from_start,
battery_id: session.battery_id,
secondary_battery_id: session.secondary_battery_id,
post_approver: session.post_approver,
start_approver: session.start_approver,
end_approver: session.end_approver,
lifecycle: session.lifecycle,
lifecycle_changed_at: session
.lifecycle_changed_at
.clone()
.unwrap_or_else(|| chrono::Utc::now().to_rfc3339()),
lifecycle_changed_by: session.lifecycle_changed_by,
lifecycle_reason: session.lifecycle_reason,
status: session.status,
end_reason: session.end_reason,
}
}
}
impl From<super::v11::SessionLocal> for SessionLocal {
fn from(v11: super::v11::SessionLocal) -> Self {
Self {
id: v11.id,
id_local: v11.id_local,
device_id: v11.device_id,
timestamp_start: v11.timestamp_start,
timestamp_end: v11.timestamp_end,
inserted_at: v11.inserted_at,
software_version: v11.software_version,
locations: v11.locations,
altitude_max: v11.altitude_max,
altitude_min: v11.altitude_min,
altitude_average: v11.altitude_average,
velocity_max: v11.velocity_max,
velocity_min: v11.velocity_min,
velocity_average: v11.velocity_average,
distance_total: v11.distance_total,
distance_max_from_start: v11.distance_max_from_start,
battery_id: v11.battery_id,
secondary_battery_id: None,
post_approver: v11.post_approver,
start_approver: None,
end_approver: None,
lifecycle: v11.lifecycle,
lifecycle_changed_at: v11.lifecycle_changed_at,
lifecycle_changed_by: v11.lifecycle_changed_by,
lifecycle_reason: v11.lifecycle_reason,
status: v11.status,
end_reason: v11.end_reason,
}
}
}
impl From<super::v9::SessionLocal> for SessionLocal {
fn from(v9: super::v9::SessionLocal) -> Self {
super::v11::SessionLocal::from(v9).into()
}
}
impl From<super::v1::SessionLocal> for SessionLocal {
fn from(v1: super::v1::SessionLocal) -> Self {
super::v11::SessionLocal::from(v1).into()
}
}
impl SessionLocal {
pub fn update_timestamp_end(&mut self, timestamp_end: u64) {
use chrono::{DateTime, Utc};
self.timestamp_end = Some(
DateTime::from_timestamp(timestamp_end as i64, 0)
.unwrap_or_else(|| DateTime::<Utc>::from_timestamp(0, 0).unwrap())
.to_rfc3339(),
);
}
pub fn end(&mut self, timestamp_end: u64, status: SessionStatus, end_reason: SessionEndReason) {
self.update_timestamp_end(timestamp_end);
self.status = Some(status);
self.end_reason = Some(end_reason);
}
}