editoast: refactor STDCMRequestPayload methods for encapsulation

- Moved utility functions `get_earliest_step_time`, `get_earliest_step_tolerance_window`, `get_total_stop_time`, `get_maximum_departure_delay`, `get_earliest_departure_time` and `get_latest_simulation_end` into the `STDCMRequestPayload` struct as methods.
- Updated the `stdcm` function to utilize these new methods for better readability and maintainability.
- Removed redundant function definitions and improved code organization.

Signed-off-by: hamz2a <[email protected]>

Author: hamz2a

editoast/src/views/timetable.rs

@@ -1,4 +1,5 @@
 pub mod stdcm;
+pub mod stdcm_request_payload;
 
 use std::collections::HashMap;
 
@@ -57,7 +58,7 @@ crate::routes! {
 editoast_common::schemas! {
     TimetableResult,
     TimetableDetailedResult,
-    stdcm::schemas(),
+    stdcm_request_payload::schemas(),
 }
 
 #[derive(Debug, Error, EditoastError)]

editoast/src/views/timetable/stdcm.rs

@@ -10,10 +10,10 @@ use editoast_derive::EditoastError;
 use editoast_models::DbConnection;
 use editoast_models::DbConnectionPoolV2;
 use editoast_schemas::primitives::PositiveDuration;
-use editoast_schemas::train_schedule::PathItemLocation;
+use editoast_schemas::train_schedule::MarginValue;
+use editoast_schemas::train_schedule::Margins;
 use editoast_schemas::train_schedule::ReceptionSignal;
-use editoast_schemas::train_schedule::{Comfort, Margins, PathItem};
-use editoast_schemas::train_schedule::{MarginValue, ScheduleItem};
+use editoast_schemas::train_schedule::ScheduleItem;
 use itertools::Itertools;
 use serde::Deserialize;
 use serde::Serialize;
@@ -24,14 +24,15 @@ use thiserror::Error;
 use utoipa::IntoParams;
 use utoipa::ToSchema;
 
+use super::stdcm_request_payload::convert_steps;
+use super::stdcm_request_payload::STDCMRequestPayload;
 use super::SelectionSettings;
 use crate::core::conflict_detection::ConflictDetectionRequest;
 use crate::core::conflict_detection::TrainRequirements;
 use crate::core::conflict_detection::WorkSchedulesRequest;
 use crate::core::pathfinding::InvalidPathItem;
 use crate::core::pathfinding::PathfindingResult;
 use crate::core::simulation::PhysicsRollingStock;
-use crate::core::simulation::SimulationParameters;
 use crate::core::simulation::{RoutingRequirement, SimulationResponse, SpacingRequirement};
 use crate::core::stdcm::STDCMPathItem;
 use crate::core::stdcm::STDCMRequest;
@@ -61,12 +62,6 @@ crate::routes! {
     "/stdcm" => stdcm,
 }
 
-editoast_common::schemas! {
-    STDCMRequestPayload,
-    PathfindingItem,
-    StepTimingData,
-}
-
 #[derive(Debug, Error, EditoastError, Serialize)]
 #[editoast_error(base_id = "stdcm_v2")]
 enum STDCMError {
@@ -81,80 +76,6 @@ enum STDCMError {
     InvalidPathItems { items: Vec<InvalidPathItem> },
 }
 
-/// An STDCM request
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, ToSchema)]
-pub struct STDCMRequestPayload {
-    /// Deprecated, first step arrival time should be used instead
-    start_time: Option<DateTime<Utc>>,
-    steps: Vec<PathfindingItem>,
-    rolling_stock_id: i64,
-    electrical_profile_set_id: Option<i64>,
-    work_schedule_group_id: Option<i64>,
-    temporary_speed_limit_group_id: Option<i64>,
-    comfort: Comfort,
-    /// By how long we can shift the departure time in milliseconds
-    /// Deprecated, first step data should be used instead
-    maximum_departure_delay: Option<u64>,
-    /// Specifies how long the total run time can be in milliseconds
-    /// Deprecated, first step data should be used instead
-    maximum_run_time: Option<u64>,
-    /// Train categories for speed limits
-    // TODO: rename the field and its description
-    speed_limit_tags: Option<String>,
-    /// Margin before the train passage in seconds
-    ///
-    /// Enforces that the path used by the train should be free and
-    /// available at least that many milliseconds before its passage.
-    #[serde(default)]
-    time_gap_before: u64,
-    /// Margin after the train passage in milliseconds
-    ///
-    /// Enforces that the path used by the train should be free and
-    /// available at least that many milliseconds after its passage.
-    #[serde(default)]
-    time_gap_after: u64,
-    /// Can be a percentage `X%`, a time in minutes per 100 kilometer `Xmin/100km`
-    #[serde(default)]
-    #[schema(value_type = Option<String>, example = json!(["5%", "2min/100km"]))]
-    margin: Option<MarginValue>,
-    /// Total mass of the consist in kg
-    total_mass: Option<f64>,
-    /// Total length of the consist in meters
-    total_length: Option<f64>,
-    /// Maximum speed of the consist in km/h
-    max_speed: Option<f64>,
-}
-
-impl STDCMRequestPayload {
-    pub fn simulation_parameters(&self) -> SimulationParameters {
-        SimulationParameters {
-            total_mass: self.total_mass,
-            total_length: self.total_length,
-            max_speed: self.max_speed,
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]
-struct PathfindingItem {
-    /// The stop duration in milliseconds, None if the train does not stop.
-    duration: Option<u64>,
-    /// The associated location
-    location: PathItemLocation,
-    /// Time at which the train should arrive at the location, if specified
-    timing_data: Option<StepTimingData>,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]
-struct StepTimingData {
-    /// Time at which the train should arrive at the location
-    arrival_time: DateTime<Utc>,
-    /// The train may arrive up to this duration before the expected arrival time
-    arrival_time_tolerance_before: u64,
-    /// The train may arrive up to this duration after the expected arrival time
-    arrival_time_tolerance_after: u64,
-}
-
 #[derive(Debug, Default, Clone, Serialize, Deserialize, IntoParams, ToSchema)]
 struct InfraIdQueryParam {
     infra: i64,
@@ -257,20 +178,9 @@ async fn stdcm(
         }
     };
 
-    let earliest_step_tolerance_window = get_earliest_step_tolerance_window(&stdcm_request);
-    let maximum_departure_delay = get_maximum_departure_delay(
-        &stdcm_request,
-        simulation_run_time,
-        earliest_step_tolerance_window,
-    );
-    // Maximum duration between train departure and arrival, including all stops
-    let maximum_run_time = stdcm_request
-        .maximum_run_time
-        .unwrap_or(2 * simulation_run_time + get_total_stop_time(&stdcm_request));
-
-    let earliest_departure_time = get_earliest_departure_time(&stdcm_request, maximum_run_time);
-    let latest_simulation_end = earliest_departure_time
-        + Duration::milliseconds((maximum_run_time + earliest_step_tolerance_window) as i64);
+    let earliest_departure_time = stdcm_request.get_earliest_departure_time(simulation_run_time);
+    let maximum_run_time = stdcm_request.get_maximum_run_time(simulation_run_time);
+    let latest_simulation_end = stdcm_request.get_latest_simulation_end(simulation_run_time);
 
     // 3. Get scheduled train requirements
     let trains_requirements = build_train_requirements(
@@ -319,7 +229,7 @@ async fn stdcm(
         path_items,
         start_time: earliest_departure_time,
         trains_requirements: trains_requirements.clone(),
-        maximum_departure_delay,
+        maximum_departure_delay: stdcm_request.get_maximum_departure_delay(simulation_run_time),
         maximum_run_time,
         speed_limit_tag: stdcm_request.speed_limit_tags,
         time_gap_before: stdcm_request.time_gap_before,
@@ -340,18 +250,18 @@ async fn stdcm(
     // 8. Handle PathNotFound response of STDCM
     if let STDCMResponse::PathNotFound = stdcm_response {
         let stdcm_response = handle_path_not_found(
-            virtual_train_schedule,
+            core_client,
             train_schedules,
             simulations,
+            &work_schedules,
+            virtual_train_schedule,
             virtual_train_sim_result,
             virtual_train_pathfinding_result,
             earliest_departure_time,
             maximum_run_time,
             latest_simulation_end,
-            &work_schedules,
             infra_id,
             infra.version,
-            core_client,
         )
         .await?;
 
@@ -363,18 +273,18 @@ async fn stdcm(
 
 #[allow(clippy::too_many_arguments)]
 async fn handle_path_not_found(
-    virtual_train_schedule: TrainSchedule,
+    core_client: Arc<CoreClient>,
     train_schedules: Vec<TrainSchedule>,
     simulations: Vec<(SimulationResponse, PathfindingResult)>,
+    work_schedules: &[WorkSchedule],
+    virtual_train_schedule: TrainSchedule,
     virtual_train_sim_result: SimulationResponse,
     virtual_train_pathfinding_result: PathfindingResult,
     earliest_departure_time: DateTime<Utc>,
     maximum_run_time: u64,
     latest_simulation_end: DateTime<Utc>,
-    work_schedules: &[WorkSchedule],
     infra_id: i64,
     infra_version: String,
-    core_client: Arc<CoreClient>,
 ) -> Result<STDCMResponse> {
     let virtual_train_id = virtual_train_schedule.id;
 
@@ -518,63 +428,6 @@ fn is_resource_in_range(
     abs_resource_start_time <= latest_sim_time && abs_resource_end_time >= earliest_sim_time
 }
 
-// Returns the maximum departure delay for the train.
-fn get_maximum_departure_delay(
-    data: &STDCMRequestPayload,
-    simulation_run_time: u64,
-    earliest_step_tolerance_window: u64,
-) -> u64 {
-    data.maximum_departure_delay
-        .unwrap_or(simulation_run_time + earliest_step_tolerance_window)
-}
-
-/// Returns the earliest time at which the train may start
-fn get_earliest_departure_time(data: &STDCMRequestPayload, maximum_run_time: u64) -> DateTime<Utc> {
-    // Prioritize: start time, or first step time, or (first specified time - max run time)
-    data.start_time.unwrap_or(
-        data.steps
-            .first()
-            .and_then(|step| step.timing_data.clone())
-            .and_then(|data| {
-                Option::from(
-                    data.arrival_time
-                        - Duration::milliseconds(data.arrival_time_tolerance_before as i64),
-                )
-            })
-            .unwrap_or(
-                get_earliest_step_time(data) - Duration::milliseconds(maximum_run_time as i64),
-            ),
-    )
-}
-
-/// Returns the earliest time that has been set on any step
-fn get_earliest_step_time(data: &STDCMRequestPayload) -> DateTime<Utc> {
-    // Get the earliest time that has been specified for any step
-    data.start_time
-        .or_else(|| {
-            data.steps
-                .iter()
-                .flat_map(|step| step.timing_data.iter())
-                .map(|data| {
-                    data.arrival_time
-                        - Duration::milliseconds(data.arrival_time_tolerance_before as i64)
-                })
-                .next()
-        })
-        .expect("No time specified for stdcm request")
-}
-
-/// Returns the earliest tolerance window that has been set on any step
-fn get_earliest_step_tolerance_window(data: &STDCMRequestPayload) -> u64 {
-    // Get the earliest time window that has been specified for any step, if maximum_run_time is not none
-    data.steps
-        .iter()
-        .flat_map(|step| step.timing_data.iter())
-        .map(|data| data.arrival_time_tolerance_before + data.arrival_time_tolerance_after)
-        .next()
-        .unwrap_or(0)
-}
-
 /// Returns a `Result` containing:
 /// * `TrainSchedule` - The generated train schedule based on the provided data.
 /// * `SimulationResponse` - Simulation response.
@@ -583,15 +436,15 @@ async fn simulate_train_run(
     db_pool: Arc<DbConnectionPoolV2>,
     valkey_client: Arc<ValkeyClient>,
     core_client: Arc<CoreClient>,
-    data: &STDCMRequestPayload,
+    stdcm_request: &STDCMRequestPayload,
     infra: &Infra,
     rolling_stock: &RollingStockModel,
     timetable_id: i64,
 ) -> Result<(TrainSchedule, SimulationResponse, PathfindingResult)> {
     // Doesn't matter for now, but eventually it will affect tmp speed limits
-    let approx_start_time = get_earliest_step_time(data);
+    let approx_start_time = stdcm_request.get_earliest_step_time();
 
-    let path = convert_steps(&data.steps);
+    let path = convert_steps(&stdcm_request.steps);
     let last_step = path.last().expect("empty step list");
 
     let train_schedule = TrainSchedule {
@@ -609,12 +462,12 @@ async fn simulate_train_run(
             reception_signal: ReceptionSignal::Open,
             locked: false,
         }],
-        margins: build_single_margin(data.margin),
+        margins: build_single_margin(stdcm_request.margin),
         initial_speed: 0.0,
-        comfort: data.comfort,
+        comfort: stdcm_request.comfort,
         path,
         constraint_distribution: Default::default(),
-        speed_limit_tag: data.speed_limit_tags.clone(),
+        speed_limit_tag: stdcm_request.speed_limit_tags.clone(),
         power_restrictions: vec![],
         options: Default::default(),
     };
@@ -632,26 +485,6 @@ async fn simulate_train_run(
     Ok((train_schedule, sim_result, pathfinding_result))
 }
 
-/// Returns the request's total stop time
-fn get_total_stop_time(data: &STDCMRequestPayload) -> u64 {
-    data.steps
-        .iter()
-        .map(|step: &PathfindingItem| step.duration.unwrap_or_default())
-        .sum()
-}
-
-/// Convert the list of pathfinding items into a list of path item
-fn convert_steps(steps: &[PathfindingItem]) -> Vec<PathItem> {
-    steps
-        .iter()
-        .map(|step| PathItem {
-            id: Default::default(),
-            deleted: false,
-            location: step.location.clone(),
-        })
-        .collect()
-}
-
 /// Build a margins object with one margin value covering the entire range
 fn build_single_margin(margin: Option<MarginValue>) -> Margins {
     match margin {
@@ -800,6 +633,7 @@ mod tests {
     use crate::core::simulation::CompleteReportTrain;
     use crate::core::simulation::ElectricalProfiles;
     use crate::core::simulation::ReportTrain;
+    use crate::core::simulation::SimulationParameters;
     use crate::core::simulation::SimulationResponse;
     use crate::core::simulation::SpeedLimitProperties;
     use crate::core::stdcm::STDCMResponse;