editoast : CRUD TimetableV2

younesschrifi · younesschrifi · commit 9358bbdb3412 · 2024-02-06T16:46:17.000+01:00
diff --git a/editoast/src/modelsv2/mod.rs b/editoast/src/modelsv2/mod.rs
@@ -3,9 +3,8 @@ pub mod infra_objects;
 pub mod scenario;
 pub mod timetable;
 pub mod trainschedule;
-pub use scenario::ScenarioV2WithCountTrains;
-
 pub use documents::Document;
+pub use timetable::TimetableV2;
 
 use async_trait::async_trait;
 use diesel::{pg::Pg, result::Error::NotFound, AsChangeset, QueryableByName};
diff --git a/editoast/src/modelsv2/scenario.rs b/editoast/src/modelsv2/scenario.rs
@@ -5,7 +5,7 @@ use editoast_derive::ModelV2;
 use serde_derive::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
-#[derive(Debug, Default, Clone, ModelV2)]
+#[derive(Debug, Default, Clone, ModelV2, Deserialize, Serialize)]
 #[model(changeset(derive(Deserialize)))]
 #[model(table = crate::tables::scenariov2)]
 pub struct ScenarioV2 {
@@ -19,232 +19,3 @@ 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));
-        }
-    }
-}
diff --git a/editoast/src/modelsv2/timetable.rs b/editoast/src/modelsv2/timetable.rs
@@ -1,7 +1,32 @@
+use std::collections::HashMap;
+
+use crate::diesel::QueryDsl;
+use crate::error::Result;
+use crate::models::LightRollingStockModel;
+use crate::models::Retrieve;
+use crate::models::{
+    train_schedule::{
+        LightTrainSchedule, MechanicalEnergyConsumedBaseEco, TrainSchedule, TrainScheduleSummary,
+    },
+    SimulationOutput,
+};
+use crate::tables::timetable;
+use crate::DbPool;
+use actix_web::web::Data;
+use derivative::Derivative;
+use diesel::prelude::*;
+use diesel::result::Error as DieselError;
+use diesel::ExpressionMethods;
+use diesel_async::AsyncPgConnection as PgConnection;
+use diesel_async::RunQueryDsl;
+use editoast_derive::Model;
 use editoast_derive::ModelV2;
+use futures::future::try_join_all;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Default, Clone, ModelV2)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize, ModelV2)]
 #[model(table = crate::tables::timetablev2)]
+#[model(changeset(public))]
 pub struct TimetableV2 {
     pub id: i64,
     pub electrical_profile_set_id: Option<i64>,
diff --git a/editoast/src/modelsv2/trainschedule.rs b/editoast/src/modelsv2/trainschedule.rs
@@ -1,5 +1,6 @@
 use crate::DieselJson;
 use chrono::NaiveDateTime;
+use diesel_async::RunQueryDsl;
 use editoast_derive::ModelV2;
 
 #[derive(Debug, Default, Clone, ModelV2)]
diff --git a/editoast/src/views/mod.rs b/editoast/src/views/mod.rs
@@ -17,6 +17,7 @@ pub mod sprites;
 pub mod stdcm;
 pub mod study;
 pub mod timetable;
+pub mod timetablev2;
 pub mod train_schedule;
 
 use self::openapi::{merge_path_items, remove_discriminator, OpenApiMerger, Routes};
diff --git a/editoast/src/views/scenario.rs b/editoast/src/views/scenario.rs
@@ -56,7 +56,7 @@ crate::schemas! {
 #[derive(Debug, Error, EditoastError)]
 #[editoast_error(base_id = "scenario")]
 #[allow(clippy::enum_variant_names)]
-enum ScenarioError {
+pub enum ScenarioError {
     /// Couldn't found the scenario with the given scenario ID
 
     #[error("Scenario '{scenario_id}', could not be found")]
diff --git a/editoast/src/views/scenariov2.rs b/editoast/src/views/scenariov2.rs
@@ -4,6 +4,7 @@ use crate::models::train_schedule::LightTrainSchedule;
 use crate::models::{
     List, Project, Retrieve, ScenarioWithCountTrains, ScenarioWithDetails, Study, Timetable, Update,
 };
+use crate::modelsv2::scenario::ScenarioV2;
 use crate::views::pagination::{PaginatedResponse, PaginationQueryParam};
 use crate::views::projects::{ProjectError, ProjectIdParam};
 use crate::views::study::{StudyError, StudyIdParam};
@@ -180,12 +181,12 @@ async fn create(
                     id: None,
                     name: Some("timetable".into()),
                 };
-                let timetable = timetable.create(db_pool.clone()).await?;
+                let timetable = timetablev2.create(db_pool.clone()).await?;
                 let timetable_id = timetable.id.unwrap();
 
                 // Create Scenario
-                let scenario: Scenario = data.into_inner().into_scenario(study_id, timetable_id);
-                let scenario = scenario.create(db_pool.clone()).await?;
+                let scenario: ScenarioV2 = data.into_inner().into_scenario(study_id, timetable_id);
+                let scenario = scenario.create().await?;
 
                 // Update study last_modification field
                 let study = study
diff --git a/editoast/src/views/timetablev2.rs b/editoast/src/views/timetablev2.rs
