editoast: add models and views

Author: younesschrifi

editoast/migrations/2024-02-01-002011_create_v2_scenario_trainschedule_timetable/up.sql

@@ -17,13 +17,15 @@ CREATE TABLE trainschedulev2 (
     id int8 PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
     train_name varchar(128) NOT NULL,
     labels jsonb NOT NULL,
-    rolling_stock_id int8 NOT NULL REFERENCES rolling_stock(id) ON DELETE CASCADE,
+    rolling_stock_id varchar(128) NOT NULL,
     timetable_id int8 NOT NULL UNIQUE REFERENCES timetablev2(id) DEFERRABLE INITIALLY DEFERRED,
-    departure_time float8 NOT NULL,
+    departure_time timestamptz NOT NULL,
     scheduled_points jsonb NOT NULL,
     allowances jsonb NOT NULL,
     initial_speed float8 NOT NULL,
     comfort varchar(8) NOT NULL,
+    path jsonb NOT NULL,
+    tag_constrains jsonb NOT NULL,
     speed_limit_tags varchar(128) NULL,
     power_restriction_ranges jsonb NULL,
     options jsonb NULL

editoast/src/modelsv2/mod.rs

@@ -3,6 +3,7 @@ pub mod infra_objects;
 pub mod scenario;
 pub mod timetable;
 pub mod trainschedule;
+pub use scenario::ScenarioV2WithCountTrains;
 
 pub use documents::Document;
 

editoast/src/modelsv2/scenario.rs

@@ -1,7 +1,12 @@
+use actix_web::web::Data;
 use chrono::NaiveDateTime;
+use diesel::sql_types::{BigInt, Text};
 use editoast_derive::ModelV2;
+use serde_derive::{Deserialize, Serialize};
+use utoipa::ToSchema;
 
 #[derive(Debug, Default, Clone, ModelV2)]
+#[model(changeset(derive(Deserialize)))]
 #[model(table = crate::tables::scenariov2)]
 pub struct ScenarioV2 {
     pub id: i64,
@@ -14,3 +19,232 @@ pub struct ScenarioV2 {
     pub timetable_id: i64,
     pub study_id: i64,
 }
+
+crate::schemas! {
+    ScenarioV2WithCountTrains
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, QueryableByName, ToSchema)]
+pub struct ScenarioWithDetails {
+    pub id: i64,
+    pub infra_id: i64,
+    pub name: String,
+    pub description: String,
+    pub creation_date: NaiveDateTime,
+    pub last_modification: NaiveDateTime,
+    pub tags: Vec<Option<String>>,
+    pub timetable_id: i64,
+    pub study_id: i64,
+    #[diesel(sql_type = Text)]
+    pub infra_name: String,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub electrical_profile_set_name: Option<String>,
+    #[diesel(sql_type = Array<LightTrainSchedule>)]
+    pub train_schedules: Vec<LightTrainSchedule>,
+    #[diesel(sql_type = BigInt)]
+    pub trains_count: i64,
+}
+
+#[derive(Debug, Clone, Serialize, QueryableByName, ToSchema)]
+pub struct ScenarioV2WithCountTrains {
+    pub id: i64,
+    pub infra_id: i64,
+    pub name: String,
+    pub description: String,
+    pub creation_date: NaiveDateTime,
+    pub last_modification: NaiveDateTime,
+    pub tags: Vec<Option<String>>,
+    pub timetable_id: i64,
+    pub study_id: i64,
+    #[diesel(sql_type = BigInt)]
+    pub trains_count: i64,
+    #[diesel(sql_type = Text)]
+    pub infra_name: String,
+}
+
+impl ScenarioV2 {
+    pub async fn with_details(self, db_pool: Data<DbPool>) -> Result<ScenarioWithDetails> {
+        let mut conn = db_pool.get().await?;
+        self.with_details_conn(&mut conn).await
+    }
+
+    pub async fn with_details_conn(self, conn: &mut PgConnection) -> Result<ScenarioWithDetails> {
+        use crate::tables::electrical_profile_set::dsl as elec_dsl;
+        use crate::tables::infra::dsl as infra_dsl;
+        use crate::tables::train_schedule::dsl::*;
+
+        let infra_name = infra_dsl::infra
+            .filter(infra_dsl::id.eq(self.infra_id.unwrap()))
+            .select(infra_dsl::name)
+            .first::<String>(conn)
+            .await?;
+
+        let electrical_profile_set_name = match self.electrical_profile_set_id.unwrap() {
+            Some(electrical_profile_set) => Some(
+                elec_dsl::electrical_profile_set
+                    .filter(elec_dsl::id.eq(electrical_profile_set))
+                    .select(elec_dsl::name)
+                    .first::<String>(conn)
+                    .await?,
+            ),
+            None => None,
+        };
+
+        let train_schedules = train_schedule
+            .filter(timetable_id.eq(self.timetable_id.unwrap()))
+            .select((id, train_name, departure_time, path_id))
+            .load::<LightTrainSchedule>(conn)
+            .await?;
+
+        let trains_count = train_schedules.len() as i64;
+
+        Ok(ScenarioWithDetails {
+            scenario: self,
+            infra_name,
+            electrical_profile_set_name,
+            train_schedules,
+            trains_count,
+        })
+    }
+}
+
+/// Delete a scenario.
+/// When we delete a scenario, the associated timetable is deleted too.
+#[async_trait]
+impl Delete for Scenario {
+    async fn delete_conn(conn: &mut PgConnection, scenario_id: i64) -> Result<bool> {
+        use crate::tables::scenario::dsl as scenario_dsl;
+        use crate::tables::timetable::dsl as timetable_dsl;
+
+        // Delete scenario
+        let scenario = match delete(scenario_dsl::scenario.filter(scenario_dsl::id.eq(scenario_id)))
+            .get_result::<Scenario>(conn)
+            .await
+        {
+            Ok(scenario) => scenario,
+            Err(DieselError::NotFound) => return Ok(false),
+            Err(err) => return Err(err.into()),
+        };
+
+        // Delete timetable
+        delete(
+            timetable_dsl::timetable.filter(timetable_dsl::id.eq(scenario.timetable_id.unwrap())),
+        )
+        .execute(conn)
+        .await?;
+        Ok(true)
+    }
+}
+
+#[async_trait]
+impl List<(i64, Ordering)> for ScenarioWithCountTrains {
+    /// List all scenarios with the number of trains.
+    /// This functions takes a study_id to filter scenarios.
+    async fn list_conn(
+        conn: &mut PgConnection,
+        page: i64,
+        page_size: i64,
+        params: (i64, Ordering),
+    ) -> Result<PaginatedResponse<Self>> {
+        let study_id = params.0;
+        let ordering = params.1.to_sql();
+        sql_query(format!("WITH scenarios_with_train_counts AS (
+            SELECT t.*, COUNT(train_schedule.id) as trains_count
+            FROM scenario as t
+            LEFT JOIN train_schedule ON t.timetable_id = train_schedule.timetable_id WHERE t.study_id = $1
+            GROUP BY t.id ORDER BY {ordering}
+        )
+        SELECT scenarios_with_train_counts.*, infra.name as infra_name
+        FROM scenarios_with_train_counts
+        JOIN infra ON infra.id = infra_id"))
+            .bind::<BigInt, _>(study_id)
+            .paginate(page, page_size)
+            .load_and_count(conn).await
+    }
+}
+
+#[cfg(test)]
+pub mod test {
+    use super::*;
+    use crate::fixtures::tests::{db_pool, scenario_fixture_set, ScenarioFixtureSet, TestFixture};
+    use crate::models::Delete;
+    use crate::models::List;
+    use crate::models::Ordering;
+    use crate::models::Retrieve;
+    use crate::models::Timetable;
+    use rstest::rstest;
+
+    #[rstest]
+    async fn create_delete_scenario(db_pool: Data<DbPool>) {
+        let ScenarioFixtureSet { scenario, .. } = scenario_fixture_set().await;
+
+        // Delete the scenario
+        Scenario::delete(db_pool.clone(), scenario.id())
+            .await
+            .unwrap();
+
+        // Second delete should fail
+        assert!(!Scenario::delete(db_pool.clone(), scenario.id())
+            .await
+            .unwrap());
+    }
+
+    #[rstest]
+    async fn get_study(db_pool: Data<DbPool>) {
+        let ScenarioFixtureSet { study, .. } = scenario_fixture_set().await;
+
+        // Get a scenario
+        assert!(Scenario::retrieve(db_pool.clone(), study.id())
+            .await
+            .is_ok());
+        assert!(ScenarioWithCountTrains::list(
+            db_pool.clone(),
+            1,
+            25,
+            (study.id(), Ordering::LastModifiedAsc)
+        )
+        .await
+        .is_ok());
+    }
+
+    #[rstest]
+    async fn sort_scenario(db_pool: Data<DbPool>) {
+        let ScenarioFixtureSet {
+            scenario,
+            study,
+            timetable,
+            ..
+        } = scenario_fixture_set().await;
+
+        // Create second timetable
+        let timetable_2 = TestFixture::create_legacy(
+            Timetable {
+                id: None,
+                name: Some(timetable.model.name.clone().unwrap() + "_bis"),
+            },
+            db_pool.clone(),
+        )
+        .await;
+
+        // Create second scenario
+        let scenario_2 = Scenario {
+            name: Some(scenario.model.name.clone().unwrap() + "_bis"),
+            id: None,
+            timetable_id: Some(timetable_2.id()),
+            ..scenario.model.clone()
+        };
+        let _scenario_2 = TestFixture::create_legacy(scenario_2, db_pool.clone());
+
+        let scenarios =
+            ScenarioWithCountTrains::list(db_pool.clone(), 1, 25, (study.id(), Ordering::NameDesc))
+                .await
+                .unwrap()
+                .results;
+
+        for (p1, p2) in scenarios.iter().zip(scenarios.iter().skip(1)) {
+            let name_1 = p1.scenario.name.as_ref().unwrap().to_lowercase();
+            let name_2 = p2.scenario.name.as_ref().unwrap().to_lowercase();
+            assert!(name_1.ge(&name_2));
+        }
+    }
+}

editoast/src/modelsv2/trainschedule.rs

@@ -1,4 +1,5 @@
 use crate::DieselJson;
+use chrono::NaiveDateTime;
 use editoast_derive::ModelV2;
 
 #[derive(Debug, Default, Clone, ModelV2)]
@@ -7,13 +8,15 @@ pub struct TrainScheduleV2 {
     pub id: i64,
     pub train_name: String,
     pub labels: DieselJson<Vec<String>>,
-    pub rolling_stock_id: i64,
+    pub rolling_stock_id: String,
     pub timetable_id: i64,
-    pub departure_time: f64,
+    pub departure_time: NaiveDateTime,
     pub scheduled_points: DieselJson<Vec<String>>,
     pub allowances: DieselJson<Vec<String>>,
     pub initial_speed: f64,
     pub comfort: String,
+    pub path: DieselJson<Vec<String>>,
+    pub tag_constrains: DieselJson<Vec<String>>,
     pub speed_limit_tags: Option<String>,
     pub power_restriction_ranges: Option<DieselJson<Vec<String>>>,
     pub options: Option<DieselJson<Vec<String>>>,

editoast/src/tables.rs

@@ -680,14 +680,17 @@ diesel::table! {
         #[max_length = 128]
         train_name -> Varchar,
         labels -> Jsonb,
-        rolling_stock_id -> Int8,
+        #[max_length = 128]
+        rolling_stock_id -> Varchar,
         timetable_id -> Int8,
-        departure_time -> Float8,
+        departure_time -> Timestamptz,
         scheduled_points -> Jsonb,
         allowances -> Jsonb,
         initial_speed -> Float8,
         #[max_length = 8]
         comfort -> Varchar,
+        path -> Jsonb,
+        tag_constrains -> Jsonb,
         #[max_length = 128]
         speed_limit_tags -> Nullable<Varchar>,
         power_restriction_ranges -> Nullable<Jsonb>,
@@ -741,7 +744,6 @@ diesel::joinable!(timetablev2 -> electrical_profile_set (electrical_profile_set_
 diesel::joinable!(train_schedule -> pathfinding (path_id));
 diesel::joinable!(train_schedule -> rolling_stock (rolling_stock_id));
 diesel::joinable!(train_schedule -> timetable (timetable_id));
-diesel::joinable!(trainschedulev2 -> rolling_stock (rolling_stock_id));
 diesel::joinable!(trainschedulev2 -> timetablev2 (timetable_id));
 
 diesel::allow_tables_to_appear_in_same_query!(

editoast/src/views/mod.rs

@@ -10,6 +10,7 @@ pub mod pathfinding;
 pub mod projects;
 pub mod rolling_stocks;
 pub mod scenario;
+pub mod scenariov2;
 pub mod search;
 mod single_simulation;
 pub mod sprites;