1955 temperature sensor schema for temperature logs and breaches

server/repository/src/db_diesel/changelog/changelog.rs

@@ -60,6 +60,9 @@ pub enum ChangelogTableName {
     NameStoreJoin,
     Document,
     Sensor,
+    TemperatureBreach,
+    TemperatureBreachConfig,
+    TemperatureLog,
 }
 
 #[derive(Clone, Queryable, Debug, PartialEq, Insertable)]

server/repository/src/db_diesel/diesel_schema.rs

@@ -10,13 +10,18 @@ use super::{
     program_requisition::program_requisition_settings_row::program_requisition_settings,
     requisition_line_row::requisition_line, requisition_row::requisition, sensor_row::sensor,
     stock_line_row::stock_line, stocktake_line_row::stocktake_line, stocktake_row::stocktake,
-    store_row::store, unit_row::unit, user_row::user_account,
+    store_row::store, temperature_breach_config_row::temperature_breach_config,
+    temperature_breach_row::temperature_breach, temperature_log_row::temperature_log,
+    unit_row::unit, user_row::user_account,
 };
 
 allow_tables_to_appear_in_same_query!(
     unit,
     location,
     sensor,
+    temperature_log,
+    temperature_breach,
+    temperature_breach_config,
     item,
     stock_line,
     name,

server/repository/src/db_diesel/mod.rs

@@ -73,6 +73,12 @@ mod store_row;
 mod sync_buffer;
 mod sync_log;
 mod sync_log_row;
+mod temperature_breach;
+mod temperature_breach_config;
+mod temperature_breach_config_row;
+mod temperature_breach_row;
+mod temperature_log;
+mod temperature_log_row;
 mod unit_row;
 mod user;
 mod user_permission;
@@ -146,6 +152,12 @@ pub use store_row::*;
 pub use sync_buffer::*;
 pub use sync_log::*;
 pub use sync_log_row::*;
+pub use temperature_breach::*;
+pub use temperature_breach_config::*;
+pub use temperature_breach_config_row::*;
+pub use temperature_breach_row::*;
+pub use temperature_log::*;
+pub use temperature_log_row::*;
 pub use unit_row::*;
 pub use user::*;
 pub use user_permission::*;

server/repository/src/db_diesel/temperature_breach.rs

@@ -0,0 +1,180 @@
+use super::{
+    temperature_breach_row::{
+        temperature_breach, temperature_breach::dsl as temperature_breach_dsl,
+    },
+    DBType, StorageConnection, TemperatureBreachRow, TemperatureBreachRowType,
+};
+use diesel::prelude::*;
+use util::inline_init;
+
+use crate::{
+    diesel_macros::{apply_date_time_filter, apply_equal_filter, apply_sort, apply_sort_no_case},
+    repository_error::RepositoryError,
+};
+
+use crate::{DatetimeFilter, EqualFilter, Pagination, Sort};
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct TemperatureBreach {
+    pub temperature_breach_row: TemperatureBreachRow,
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct TemperatureBreachFilter {
+    pub id: Option<EqualFilter<String>>,
+    pub r#type: Option<EqualFilter<TemperatureBreachRowType>>,
+    pub sensor_id: Option<EqualFilter<String>>,
+    pub store_id: Option<EqualFilter<String>>,
+    pub start_timestamp: Option<DatetimeFilter>,
+    pub end_timestamp: Option<DatetimeFilter>,
+}
+
+#[derive(PartialEq, Debug)]
+pub enum TemperatureBreachSortField {
+    Id,
+    StartTimestamp,
+    EndTimestamp,
+}
+
+pub type TemperatureBreachSort = Sort<TemperatureBreachSortField>;
+
+pub struct TemperatureBreachRepository<'a> {
+    connection: &'a StorageConnection,
+}
+
+impl<'a> TemperatureBreachRepository<'a> {
+    pub fn new(connection: &'a StorageConnection) -> Self {
+        TemperatureBreachRepository { connection }
+    }
+
+    pub fn count(&self, filter: Option<TemperatureBreachFilter>) -> Result<i64, RepositoryError> {
+        let query = create_filtered_query(filter);
+        Ok(query.count().get_result(&self.connection.connection)?)
+    }
+
+    pub fn query_by_filter(
+        &self,
+        filter: TemperatureBreachFilter,
+    ) -> Result<Vec<TemperatureBreach>, RepositoryError> {
+        self.query(Pagination::all(), Some(filter), None)
+    }
+
+    pub fn query(
+        &self,
+        pagination: Pagination,
+        filter: Option<TemperatureBreachFilter>,
+        sort: Option<TemperatureBreachSort>,
+    ) -> Result<Vec<TemperatureBreach>, RepositoryError> {
+        let mut query = create_filtered_query(filter);
+        if let Some(sort) = sort {
+            match sort.key {
+                TemperatureBreachSortField::Id => {
+                    apply_sort_no_case!(query, sort, temperature_breach_dsl::id)
+                }
+                TemperatureBreachSortField::StartTimestamp => {
+                    apply_sort!(query, sort, temperature_breach_dsl::start_timestamp)
+                }
+                TemperatureBreachSortField::EndTimestamp => {
+                    apply_sort!(query, sort, temperature_breach_dsl::end_timestamp)
+                }
+            }
+        } else {
+            query = query.order(temperature_breach_dsl::start_timestamp.asc())
+        }
+
+        let result = query
+            .offset(pagination.offset as i64)
+            .limit(pagination.limit as i64)
+            .load::<TemperatureBreachRow>(&self.connection.connection)?;
+
+        Ok(result.into_iter().map(to_domain).collect())
+    }
+}
+
+type BoxedLogQuery = temperature_breach::BoxedQuery<'static, DBType>;
+
+fn create_filtered_query(filter: Option<TemperatureBreachFilter>) -> BoxedLogQuery {
+    let mut query = temperature_breach::table.into_boxed();
+
+    if let Some(filter) = filter {
+        apply_equal_filter!(query, filter.id, temperature_breach_dsl::id);
+        apply_equal_filter!(query, filter.sensor_id, temperature_breach_dsl::sensor_id);
+        apply_equal_filter!(query, filter.store_id, temperature_breach_dsl::store_id);
+        apply_equal_filter!(query, filter.r#type, temperature_breach_dsl::type_);
+        apply_date_time_filter!(
+            query,
+            filter.start_timestamp,
+            temperature_breach_dsl::start_timestamp
+        );
+        apply_date_time_filter!(
+            query,
+            filter.end_timestamp,
+            temperature_breach_dsl::end_timestamp
+        );
+    }
+
+    query
+}
+
+impl TemperatureBreachRowType {
+    pub fn equal_to(&self) -> EqualFilter<Self> {
+        inline_init(|r: &mut EqualFilter<Self>| r.equal_to = Some(self.clone()))
+    }
+
+    pub fn not_equal_to(&self) -> EqualFilter<Self> {
+        inline_init(|r: &mut EqualFilter<Self>| r.not_equal_to = Some(self.clone()))
+    }
+
+    pub fn equal_any(value: Vec<Self>) -> EqualFilter<Self> {
+        inline_init(|r: &mut EqualFilter<Self>| r.equal_any = Some(value))
+    }
+}
+
+pub fn to_domain(temperature_breach_row: TemperatureBreachRow) -> TemperatureBreach {
+    TemperatureBreach {
+        temperature_breach_row,
+    }
+}
+
+impl TemperatureBreachFilter {
+    pub fn new() -> TemperatureBreachFilter {
+        TemperatureBreachFilter {
+            id: None,
+            sensor_id: None,
+            store_id: None,
+            start_timestamp: None,
+            end_timestamp: None,
+            r#type: None,
+        }
+    }
+
+    pub fn id(mut self, filter: EqualFilter<String>) -> Self {
+        self.id = Some(filter);
+        self
+    }
+
+    pub fn sensor_id(mut self, filter: EqualFilter<String>) -> Self {
+        self.sensor_id = Some(filter);
+        self
+    }
+
+    pub fn store_id(mut self, filter: EqualFilter<String>) -> Self {
+        self.store_id = Some(filter);
+        self
+    }
+
+    pub fn start_timestamp(mut self, filter: DatetimeFilter) -> Self {
+        self.start_timestamp = Some(filter);
+        self
+    }
+
+    pub fn end_timestamp(mut self, filter: DatetimeFilter) -> Self {
+        self.end_timestamp = Some(filter);
+        self
+    }
+
+    pub fn r#type(mut self, filter: EqualFilter<TemperatureBreachRowType>) -> Self {
+        self.r#type = Some(filter);
+        self
+    }
+}

server/repository/src/db_diesel/temperature_breach_config.rs

@@ -0,0 +1,150 @@
+use super::{
+    temperature_breach_config_row::{
+        temperature_breach_config, temperature_breach_config::dsl as temperature_breach_config_dsl,
+    },
+    DBType, StorageConnection, TemperatureBreachConfigRow, TemperatureBreachRowType,
+};
+use diesel::prelude::*;
+
+use crate::{
+    diesel_macros::{apply_equal_filter, apply_sort_no_case},
+    repository_error::RepositoryError,
+};
+
+use crate::{EqualFilter, Pagination, Sort};
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct TemperatureBreachConfig {
+    pub temperature_breach_config_row: TemperatureBreachConfigRow,
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct TemperatureBreachConfigFilter {
+    pub id: Option<EqualFilter<String>>,
+    pub r#type: Option<EqualFilter<TemperatureBreachRowType>>,
+    pub is_active: Option<bool>,
+    pub store_id: Option<EqualFilter<String>>,
+}
+
+#[derive(PartialEq, Debug)]
+pub enum TemperatureBreachConfigSortField {
+    Id,
+    Description,
+}
+
+pub type TemperatureBreachConfigSort = Sort<TemperatureBreachConfigSortField>;
+
+pub struct TemperatureBreachConfigRepository<'a> {
+    connection: &'a StorageConnection,
+}
+
+impl<'a> TemperatureBreachConfigRepository<'a> {
+    pub fn new(connection: &'a StorageConnection) -> Self {
+        TemperatureBreachConfigRepository { connection }
+    }
+
+    pub fn count(
+        &self,
+        filter: Option<TemperatureBreachConfigFilter>,
+    ) -> Result<i64, RepositoryError> {
+        let query = create_filtered_query(filter);
+        Ok(query.count().get_result(&self.connection.connection)?)
+    }
+
+    pub fn query_by_filter(
+        &self,
+        filter: TemperatureBreachConfigFilter,
+    ) -> Result<Vec<TemperatureBreachConfig>, RepositoryError> {
+        self.query(Pagination::all(), Some(filter), None)
+    }
+
+    pub fn query(
+        &self,
+        pagination: Pagination,
+        filter: Option<TemperatureBreachConfigFilter>,
+        sort: Option<TemperatureBreachConfigSort>,
+    ) -> Result<Vec<TemperatureBreachConfig>, RepositoryError> {
+        let mut query = create_filtered_query(filter);
+        if let Some(sort) = sort {
+            match sort.key {
+                TemperatureBreachConfigSortField::Id => {
+                    apply_sort_no_case!(query, sort, temperature_breach_config_dsl::id)
+                }
+                TemperatureBreachConfigSortField::Description => {
+                    apply_sort_no_case!(query, sort, temperature_breach_config_dsl::description)
+                }
+            }
+        } else {
+            query = query.order(temperature_breach_config_dsl::description.asc())
+        }
+
+        let result = query
+            .offset(pagination.offset as i64)
+            .limit(pagination.limit as i64)
+            .load::<TemperatureBreachConfigRow>(&self.connection.connection)?;
+
+        Ok(result.into_iter().map(to_domain).collect())
+    }
+}
+
+type BoxedLogQuery = temperature_breach_config::BoxedQuery<'static, DBType>;
+
+fn create_filtered_query(filter: Option<TemperatureBreachConfigFilter>) -> BoxedLogQuery {
+    let mut query = temperature_breach_config::table.into_boxed();
+
+    if let Some(filter) = filter {
+        apply_equal_filter!(query, filter.id, temperature_breach_config_dsl::id);
+        apply_equal_filter!(query, filter.r#type, temperature_breach_config_dsl::type_);
+
+        if let Some(value) = filter.is_active {
+            query = query.filter(temperature_breach_config_dsl::is_active.eq(value));
+        }
+
+        apply_equal_filter!(
+            query,
+            filter.store_id,
+            temperature_breach_config_dsl::store_id
+        );
+    }
+
+    query
+}
+
+pub fn to_domain(
+    temperature_breach_config_row: TemperatureBreachConfigRow,
+) -> TemperatureBreachConfig {
+    TemperatureBreachConfig {
+        temperature_breach_config_row,
+    }
+}
+
+impl TemperatureBreachConfigFilter {
+    pub fn new() -> TemperatureBreachConfigFilter {
+        TemperatureBreachConfigFilter {
+            id: None,
+            is_active: None,
+            r#type: None,
+            store_id: None,
+        }
+    }
+
+    pub fn id(mut self, filter: EqualFilter<String>) -> Self {
+        self.id = Some(filter);
+        self
+    }
+
+    pub fn is_active(mut self, filter: bool) -> Self {
+        self.is_active = Some(filter);
+        self
+    }
+
+    pub fn r#type(mut self, filter: EqualFilter<TemperatureBreachRowType>) -> Self {
+        self.r#type = Some(filter);
+        self
+    }
+
+    pub fn store_id(mut self, filter: EqualFilter<String>) -> Self {
+        self.store_id = Some(filter);
+        self
+    }
+}