editoast: move rolling stock and rs with liveries to schemas to schemas

editoast/editoast_schemas/src/rolling_stock.rs

@@ -0,0 +1,87 @@
+mod gamma;
+pub use gamma::Gamma;
+
+mod effort_curves;
+pub use effort_curves::ConditionalEffortCurve;
+pub use effort_curves::EffortCurve;
+pub use effort_curves::EffortCurveConditions;
+pub use effort_curves::EffortCurves;
+pub use effort_curves::ModeEffortCurves;
+pub use effort_curves::RollingStockComfortType;
+
+mod rolling_resistance;
+pub use rolling_resistance::RollingResistance;
+
+mod energy_source;
+pub use energy_source::EnergySource;
+pub use energy_source::EnergyStorage;
+pub use energy_source::RefillLaw;
+pub use energy_source::SpeedDependantPower;
+
+mod supported_signaling_systems;
+pub use supported_signaling_systems::RollingStockSupportedSignalingSystems;
+
+mod rolling_stock_metadata;
+pub use rolling_stock_metadata::RollingStockMetadata;
+
+mod loading_gauge_type;
+pub use loading_gauge_type::LoadingGaugeType;
+
+mod rolling_stock_livery;
+pub use rolling_stock_livery::RollingStockLivery;
+pub use rolling_stock_livery::RollingStockLiveryMetadata;
+
+use serde::Deserialize;
+use serde::Serialize;
+use std::collections::HashMap;
+use utoipa::ToSchema;
+
+editoast_common::schemas! {
+    RollingStock,
+    gamma::schemas(),
+    effort_curves::schemas(),
+    energy_source::schemas(),
+    rolling_stock_livery::schemas(),
+    rolling_resistance::schemas(),
+    supported_signaling_systems::schemas(),
+    rolling_stock_metadata::schemas(),
+    loading_gauge_type::schemas(),
+}
+
+pub const ROLLING_STOCK_RAILJSON_VERSION: &str = "3.2";
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ToSchema)]
+pub struct RollingStock {
+    pub id: i64,
+    pub name: String,
+    pub effort_curves: EffortCurves,
+    #[schema(example = "5", required)]
+    pub base_power_class: Option<String>,
+    pub length: f64,
+    pub max_speed: f64,
+    pub startup_time: f64,
+    pub startup_acceleration: f64,
+    pub comfort_acceleration: f64,
+    pub gamma: Gamma,
+    pub inertia_coefficient: f64,
+    pub mass: f64,
+    pub rolling_resistance: RollingResistance,
+    pub loading_gauge: LoadingGaugeType,
+    /// Mapping of power restriction code to power class
+    #[serde(default)]
+    #[schema(required)]
+    pub power_restrictions: HashMap<String, String>,
+    #[serde(default)]
+    pub energy_sources: Vec<EnergySource>,
+    /// The time the train takes before actually using electrical power (in seconds). Is null if the train is not electric.
+    #[schema(example = 5.0)]
+    pub electrical_power_startup_time: Option<f64>,
+    /// The time it takes to raise this train's pantograph in seconds. Is null if the train is not electric.
+    #[schema(example = 15.0)]
+    pub raise_pantograph_time: Option<f64>,
+    pub supported_signaling_systems: RollingStockSupportedSignalingSystems,
+    pub railjson_version: String,
+    /// Whether the rolling stock can be edited/deleted or not.
+    pub locked: bool,
+    pub metadata: RollingStockMetadata,
+}

editoast/editoast_schemas/src/rolling_stock/effort_curves.rs

@@ -7,6 +7,15 @@ use strum::Display;
 use strum::EnumString;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    ConditionalEffortCurve,
+    EffortCurve,
+    EffortCurves,
+    EffortCurveConditions,
+    ModeEffortCurves,
+    RollingStockComfortType,
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize, ToSchema, Hash)]
 #[serde(deny_unknown_fields)]
 pub struct EffortCurves {

editoast/editoast_schemas/src/rolling_stock/energy_source.rs

@@ -2,6 +2,13 @@ use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    EnergySource,
+    EnergyStorage,
+    RefillLaw,
+    SpeedDependantPower,
+}
+
 // Energy sources schema
 
 /// energy source of a rolling stock

editoast/editoast_schemas/src/rolling_stock/gamma.rs

@@ -3,6 +3,10 @@ use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    Gamma,
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize, ToSchema, Derivative)]
 #[serde(deny_unknown_fields)]
 #[derivative(Hash)]

editoast/editoast_schemas/src/rolling_stock/loading_gauge_type.rs

@@ -3,6 +3,10 @@ use serde::Serialize;
 use strum::FromRepr;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    LoadingGaugeType,
+}
+
 #[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq, ToSchema, Hash, FromRepr)]
 pub enum LoadingGaugeType {
     G1,

editoast/editoast_schemas/src/rolling_stock/rolling_resistance.rs

@@ -3,6 +3,10 @@ use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    RollingResistance,
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize, ToSchema, Derivative)]
 #[derivative(Hash)]
 #[serde(deny_unknown_fields)]

editoast/editoast_schemas/src/rolling_stock/rolling_stock_livery.rs

@@ -2,6 +2,11 @@ use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    RollingStockLivery,
+    RollingStockLiveryMetadata,
+}
+
 #[derive(Debug, Deserialize, Serialize, ToSchema)]
 pub struct RollingStockLivery {
     pub id: i64,

editoast/editoast_schemas/src/rolling_stock/rolling_stock_metadata.rs

@@ -2,6 +2,10 @@ use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    RollingStockMetadata,
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize, ToSchema)]
 #[serde(deny_unknown_fields)]
 pub struct RollingStockMetadata {

editoast/editoast_schemas/src/rolling_stock/supported_signaling_systems.rs

@@ -2,6 +2,10 @@ use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
+editoast_common::schemas! {
+    RollingStockSupportedSignalingSystems,
+}
+
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize, ToSchema)]
 pub struct RollingStockSupportedSignalingSystems(pub Vec<String>);