editoast: make rolling_stock.base_power_class nullable

Author: Baptiste Prevot

editoast/migrations/2023-10-03-161614_rolling-stock-base-power-class-null/down.sql

@@ -0,0 +1,12 @@
+-- This file should undo anything in `up.sql`
+alter table rolling_stock 
+	drop constraint base_power_class_null_or_non_empty;
+
+update
+	rolling_stock
+set
+	base_power_class = ''
+where
+	base_power_class is null;
+
+alter table rolling_stock alter column base_power_class set not null;

editoast/migrations/2023-10-03-161614_rolling-stock-base-power-class-null/up.sql

@@ -0,0 +1,13 @@
+-- Your SQL goes here
+alter table rolling_stock alter column base_power_class drop not null;
+
+update
+	rolling_stock
+set
+	base_power_class = null
+where
+	base_power_class = '';
+
+alter table rolling_stock
+  add constraint base_power_class_null_or_non_empty check (base_power_class is null
+	or length(base_power_class) > 0);

editoast/openapi.yaml

@@ -1187,6 +1187,7 @@ components:
       properties:
         base_power_class:
           example: '5'
+          nullable: true
           type: string
         comfort_acceleration:
           format: float

editoast/openapi_legacy.yaml

@@ -3096,6 +3096,7 @@ components:
             - "FR3.3/GB/G2"
             - "GLOTT"
         base_power_class:
+          nullable: true
           type: string
           example: "5"
         power_restrictions:

editoast/src/models/rolling_stock/light_rolling_stock.rs

@@ -33,7 +33,7 @@ pub struct LightRollingStockModel {
     comfort_acceleration: f64,
     gamma: DieselJson<Gamma>,
     inertia_coefficient: f64,
-    base_power_class: String,
+    base_power_class: Option<String>,
     features: Vec<Option<String>>,
     mass: f64,
     rolling_resistance: DieselJson<RollingResistance>,

editoast/src/models/rolling_stock/mod.rs

@@ -7,9 +7,9 @@ pub use light_rolling_stock::LightRollingStockModel;
 pub use rolling_stock_image::RollingStockSeparatedImageModel;
 pub use rolling_stock_livery::RollingStockLiveryModel;
 
-use crate::error::Result;
+use crate::error::{InternalError, Result};
 use crate::models::rolling_stock::rolling_stock_livery::RollingStockLiveryMetadata;
-use crate::models::{Identifiable, TextArray, Update};
+use crate::models::{Create, Identifiable, TextArray, Update};
 use crate::schema::rolling_stock::{
     EffortCurves, EnergySource, Gamma, RollingResistance, RollingStock, RollingStockCommon,
     RollingStockMetadata, RollingStockWithLiveries,
@@ -19,8 +19,8 @@ use crate::views::rolling_stocks::RollingStockError;
 use crate::DbPool;
 use actix_web::web::Data;
 use derivative::Derivative;
-use diesel::result::Error as DieselError;
-use diesel::{update, ExpressionMethods, QueryDsl, SelectableHelper};
+use diesel::result::{DatabaseErrorInformation, DatabaseErrorKind, Error as DieselError};
+use diesel::{insert_into, update, ExpressionMethods, QueryDsl, SelectableHelper};
 use diesel_async::{AsyncPgConnection as PgConnection, RunQueryDsl};
 use diesel_json::Json as DieselJson;
 use editoast_derive::Model;
@@ -41,7 +41,7 @@ use serde_json::Value as JsonValue;
 )]
 #[derivative(Default, PartialEq)]
 #[model(table = "rolling_stock")]
-#[model(create, retrieve, delete)]
+#[model(retrieve, delete)]
 #[diesel(table_name = rolling_stock)]
 pub struct RollingStockModel {
     #[diesel(deserialize_as = i64)]
@@ -70,8 +70,8 @@ pub struct RollingStockModel {
     pub gamma: Option<DieselJson<Gamma>>,
     #[diesel(deserialize_as = f64)]
     pub inertia_coefficient: Option<f64>,
-    #[diesel(deserialize_as = String)]
-    pub base_power_class: Option<String>,
+    #[diesel(deserialize_as = Option<String>)]
+    pub base_power_class: Option<Option<String>>,
     #[diesel(deserialize_as = TextArray)]
     pub features: Option<Vec<String>>,
     #[diesel(deserialize_as = f64)]
@@ -136,6 +136,32 @@ impl RollingStockModel {
     }
 }
 
+fn is_given_constraint(
+    error_info: &(dyn DatabaseErrorInformation + Send + Sync),
+    column_name: &str,
+) -> bool {
+    error_info
+        .constraint_name()
+        .map(|name| name == column_name)
+        .unwrap_or(false)
+}
+
+fn map_diesel_error(e: DieselError, rs_name: String) -> InternalError {
+    match e {
+        DieselError::DatabaseError(DatabaseErrorKind::UniqueViolation, info)
+            if is_given_constraint(info.as_ref(), "rolling_stock_name_key") =>
+        {
+            RollingStockError::NameAlreadyUsed { name: rs_name }.into()
+        }
+        DieselError::DatabaseError(DatabaseErrorKind::CheckViolation, info)
+            if is_given_constraint(info.as_ref(), "base_power_class_null_or_non_empty") =>
+        {
+            RollingStockError::BasePowerClassEmpty.into()
+        }
+        e => e.into(),
+    }
+}
+
 #[async_trait]
 impl Update for RollingStockModel {
     async fn update_conn(
@@ -151,17 +177,23 @@ impl Update for RollingStockModel {
             .await
         {
             Ok(rs) => Ok(Some(rs)),
-            Err(DieselError::NotFound) => {
-                Err(RollingStockError::NotFound { rolling_stock_id }.into())
-            }
-            Err(DieselError::DatabaseError(
-                diesel::result::DatabaseErrorKind::UniqueViolation,
-                _,
-            )) => Err(RollingStockError::NameAlreadyUsed {
-                name: self.name.unwrap(),
-            }
-            .into()),
-            Err(e) => Err(e.into()),
+            Err(DieselError::NotFound) => Ok(None),
+            Err(e) => Err(map_diesel_error(e, self.name.unwrap())),
+        }
+    }
+}
+
+#[async_trait]
+impl Create for RollingStockModel {
+    async fn create_conn(self, conn: &mut PgConnection) -> Result<Self> {
+        use crate::tables::rolling_stock::dsl::*;
+        match insert_into(rolling_stock)
+            .values(&self)
+            .get_result(conn)
+            .await
+        {
+            Ok(rs) => Ok(rs),
+            Err(e) => Err(map_diesel_error(e, self.name.unwrap())),
         }
     }
 }

editoast/src/schema/rolling_stock/light_rolling_stock.rs

@@ -20,8 +20,8 @@ pub struct LightRollingStock {
     pub locked: bool,
     #[diesel(sql_type = Jsonb)]
     pub effort_curves: DieselJson<LightEffortCurves>,
-    #[diesel(sql_type = Text)]
-    pub base_power_class: String,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub base_power_class: Option<String>,
     #[diesel(sql_type = Double)]
     pub length: f64,
     #[diesel(sql_type = Double)]

editoast/src/schema/rolling_stock/mod.rs

@@ -14,7 +14,7 @@ pub const ROLLING_STOCK_RAILJSON_VERSION: &str = "3.2";
 pub struct RollingStockCommon {
     pub name: String,
     pub effort_curves: EffortCurves,
-    pub base_power_class: String,
+    pub base_power_class: Option<String>,
     pub length: f64,
     pub max_speed: f64,
     pub startup_time: f64,

editoast/src/tables.rs

@@ -431,7 +431,7 @@ diesel::table! {
         gamma -> Jsonb,
         inertia_coefficient -> Float8,
         #[max_length = 255]
-        base_power_class -> Varchar,
+        base_power_class -> Nullable<Varchar>,
         features -> Array<Nullable<Text>>,
         mass -> Float8,
         rolling_resistance -> Jsonb,

editoast/src/views/rolling_stocks/mod.rs

@@ -53,6 +53,9 @@ pub enum RollingStockError {
         rolling_stock_id: i64,
         usage: Vec<TrainScheduleScenarioStudyProject>,
     },
+    #[error("Base power class is an empty string")]
+    #[editoast_error(status = 400)]
+    BasePowerClassEmpty,
 }
 
 pub fn routes() -> impl HttpServiceFactory {
@@ -193,10 +196,13 @@ async fn update(
 
     let rolling_stock = rolling_stock
         .update(db_pool.clone(), rolling_stock_id)
-        .await?
-        .unwrap();
-    let rolling_stock_with_liveries = rolling_stock.with_liveries(db_pool).await?;
-    Ok(Json(rolling_stock_with_liveries))
+        .await?;
+    if let Some(rolling_stock) = rolling_stock {
+        let rolling_stock_with_liveries = rolling_stock.with_liveries(db_pool).await?;
+        Ok(Json(rolling_stock_with_liveries))
+    } else {
+        Err(RollingStockError::NotFound { rolling_stock_id }.into())
+    }
 }
 
 #[derive(Deserialize)]
@@ -490,6 +496,7 @@ pub mod tests {
     use crate::views::tests::create_test_service;
     use crate::{assert_editoast_error_type, assert_status_and_read, DbPool};
     use actix_http::{Request, StatusCode};
+    use actix_web::dev::ServiceResponse;
     use actix_web::http::header::ContentType;
     use actix_web::test::{call_service, read_body_json, TestRequest};
     use actix_web::web::Data;
@@ -550,6 +557,66 @@ pub mod tests {
         assert_eq!(get_response.status(), StatusCode::NOT_FOUND);
     }
 
+    async fn check_create_gave_400(db_pool: Data<DbPool>, response: ServiceResponse) {
+        if response.status() == StatusCode::OK {
+            let rolling_stock: RollingStock = read_body_json(response).await;
+            let rolling_stock_id = rolling_stock.id;
+            RollingStockModel::delete(db_pool.clone(), rolling_stock_id)
+                .await
+                .unwrap();
+            panic!("Rolling stock created but should not have been");
+        } else {
+            assert_eq!(
+                response.status(),
+                StatusCode::BAD_REQUEST,
+                "Here is the full response body {:?}",
+                response.into_body()
+            );
+        }
+    }
+
+    #[rstest]
+    async fn create_rolling_stock_with_base_power_class_empty(db_pool: Data<DbPool>) {
+        let app = create_test_service().await;
+        let mut rolling_stock: RollingStockModel = get_fast_rolling_stock();
+
+        rolling_stock.base_power_class = Some(Some("".to_string()));
+
+        let post_response = call_service(
+            &app,
+            TestRequest::post()
+                .uri("/rolling_stock")
+                .set_json(&rolling_stock)
+                .to_request(),
+        )
+        .await;
+
+        check_create_gave_400(db_pool, post_response).await;
+    }
+
+    #[rstest]
+    async fn create_rolling_stock_with_duplicate_name(
+        db_pool: Data<DbPool>,
+        #[future] fast_rolling_stock: TestFixture<RollingStockModel>,
+    ) {
+        let fast_rolling_stock = fast_rolling_stock.await;
+        let app = create_test_service().await;
+        let mut rolling_stock: RollingStockModel = get_fast_rolling_stock();
+
+        rolling_stock.name = fast_rolling_stock.model.name.clone();
+
+        let post_response = call_service(
+            &app,
+            TestRequest::post()
+                .uri("/rolling_stock")
+                .set_json(&rolling_stock)
+                .to_request(),
+        )
+        .await;
+
+        check_create_gave_400(db_pool, post_response).await;
+    }
+
     #[rstest]
     async fn update_and_delete_locked_rolling_stock_fails(db_pool: Data<DbPool>) {
         let app = create_test_service().await;

front/src/common/api/osrdEditoastApi.ts

@@ -1527,7 +1527,7 @@ export type EnergySource =
       energy_source_type: 'Battery';
     } & Battery);
 export type RollingStockBase = {
-  base_power_class: string;
+  base_power_class: string | null;
   comfort_acceleration: number;
   electrical_power_startup_time: number | null;
   energy_sources: EnergySource[];