editoast: adapt to the new stdcm endpoint

Author: Khoyo

editoast/src/core/stdcm.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::models::RollingStockModel;
+use crate::models::{RollingStockModel, SpacingRequirement};
 
 use crate::core::{pathfinding::Waypoint, simulation::SimulationResponse};
 use crate::schema::rolling_stock::RollingStockComfortType;
@@ -15,7 +15,7 @@ pub struct STDCMCoreRequest {
     pub expected_version: String,
     pub rolling_stock: RollingStockModel,
     pub comfort: RollingStockComfortType,
-    pub route_occupancies: Vec<STDCMCoreRouteOccupancy>,
+    pub spacing_requirements: Vec<SpacingRequirement>,
     pub steps: Vec<STDCMCoreStep>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub start_time: Option<f64>,
@@ -43,13 +43,6 @@ pub struct STDCMCoreStep {
     pub waypoints: Vec<Waypoint>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct STDCMCoreRouteOccupancy {
-    pub id: String,
-    pub start_occupancy_time: f64,
-    pub end_occupancy_time: f64,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct STDCMCoreResponse {
     pub simulation: SimulationResponse,

editoast/src/models/train_schedule.rs

@@ -265,7 +265,6 @@ pub struct ResultTrain {
     pub speeds: Vec<ResultSpeed>,
     pub head_positions: Vec<ResultPosition>,
     pub stops: Vec<ResultStops>,
-    pub route_occupancies: HashMap<String, ResultOccupancyTiming>,
     pub mechanical_energy_consumed: f64,
     pub signal_sightings: Vec<SignalSighting>,
     pub zone_updates: Vec<ZoneUpdate>,

editoast/src/views/stdcm/mod.rs

@@ -1,12 +1,9 @@
-use crate::core::stdcm::{
-    STDCMCoreRequest, STDCMCoreResponse, STDCMCoreRouteOccupancy, STDCMCoreStep,
-};
+use crate::core::stdcm::{STDCMCoreRequest, STDCMCoreResponse, STDCMCoreStep};
 use crate::core::{AsCoreRequest, CoreClient};
-use crate::diesel::BelongingToDsl;
+
 use crate::error::Result;
-use crate::models::train_schedule::filter_invalid_trains;
 pub use crate::models::train_schedule::AllowanceValue;
-use crate::models::{Create, SimulationOutput};
+use crate::models::{Create, SpacingRequirement};
 use crate::models::{
     CurveGraph, Infra, PathWaypoint, Pathfinding, PathfindingChangeset, PathfindingPayload,
     Retrieve, SlopeGraph, TrainSchedule,
@@ -16,14 +13,15 @@ use crate::DbPool;
 use actix_web::dev::HttpServiceFactory;
 use actix_web::web::{self, Data, Json};
 use actix_web::{post, HttpResponse, Responder};
-use diesel_async::RunQueryDsl;
+
 use editoast_derive::EditoastError;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use super::pathfinding::{
     fetch_pathfinding_payload_track_map, parse_pathfinding_payload_waypoints, StepPayload,
 };
+use super::timetable::get_simulated_schedules_from_timetable;
 use super::train_schedule::process_simulation_response;
 use super::train_schedule::projection::Projection;
 use super::train_schedule::simulation_report::{create_simulation_report, SimulationReport};
@@ -153,15 +151,14 @@ async fn call_core_stdcm(
     let infra_version = infra.clone().version.unwrap();
     let rolling_stock = retrieve_existing_rolling_stock(&db_pool, data.rolling_stock_id).await?;
     let steps = parse_stdcm_steps(db_pool.clone(), data, &infra).await?;
-    let route_occupancies =
-        make_route_occupancies(infra_version.clone(), db_pool, data.timetable_id).await?;
+    let spacing_requirements = make_spacing_requirements(db_pool, data.timetable_id).await?;
     STDCMCoreRequest {
         infra: infra.id.unwrap().to_string(),
         expected_version: infra_version,
         rolling_stock,
         comfort: data.comfort.clone(),
         steps,
-        route_occupancies,
+        spacing_requirements,
         // end_time is not used by backend currently
         // but at least one must be defined
         start_time: data.start_time,
@@ -207,47 +204,33 @@ async fn parse_stdcm_steps(
 
 /// Create route occupancies, adjusted by simulation departure time.
 /// uses base_simulation by default, or eco_simulation if given
-async fn make_route_occupancies(
-    infra_version: String,
+async fn make_spacing_requirements(
     db_pool: Data<DbPool>,
     timetable_id: i64,
-) -> Result<Vec<STDCMCoreRouteOccupancy>> {
-    let schedules = filter_invalid_trains(db_pool.clone(), timetable_id, infra_version).await?;
-    let mut conn = db_pool.get().await?;
-    let (simulations, schedules): (Vec<SimulationOutput>, Vec<TrainSchedule>) = (
-        SimulationOutput::belonging_to(&schedules)
-            .load::<SimulationOutput>(&mut conn)
-            .await?,
-        schedules,
-    );
-    Ok(simulations
-        .iter()
-        .filter_map(|simulation| {
-            if let Some(schedule) = schedules
-                .iter()
-                .find(|s| s.id == simulation.train_schedule_id)
-            {
-                let sim = simulation
-                    .eco_simulation
-                    .as_ref()
-                    .unwrap_or(&simulation.base_simulation);
-                Some(
-                    sim.route_occupancies
-                        .iter()
-                        .map(|(route_id, occupancy)| STDCMCoreRouteOccupancy {
-                            id: route_id.to_string(),
-                            start_occupancy_time: occupancy.time_head_occupy
-                                + schedule.departure_time,
-                            end_occupancy_time: occupancy.time_tail_free + schedule.departure_time,
-                        })
-                        .collect::<Vec<_>>(),
-                )
-            } else {
-                None
-            }
+) -> Result<Vec<SpacingRequirement>> {
+    let (schedules, simulations) =
+        get_simulated_schedules_from_timetable(timetable_id, db_pool).await?;
+
+    let res = simulations
+        .into_iter()
+        .zip(schedules)
+        .flat_map(|(simulation, schedule)| {
+            let sim = simulation
+                .eco_simulation
+                .map(|sim| sim.0)
+                .unwrap_or(simulation.base_simulation.0);
+
+            sim.spacing_requirements
+                .into_iter()
+                .map(|req| SpacingRequirement {
+                    zone: req.zone,
+                    begin_time: req.begin_time + schedule.departure_time,
+                    end_time: req.end_time + schedule.departure_time,
+                })
+                .collect::<Vec<_>>()
         })
-        .flatten()
-        .collect())
+        .collect();
+    Ok(res)
 }
 
 /// Creates a Pathfinding using the same function used with core /pathfinding response

editoast/src/views/timetable.rs

@@ -95,6 +95,40 @@ struct Conflict {
     conflict_type: ConflictType,
 }
 
+pub async fn get_simulated_schedules_from_timetable(
+    timetable_id: i64,
+    db_pool: Data<DbPool>,
+) -> Result<(Vec<TrainSchedule>, Vec<SimulationOutput>)> {
+    let mut conn = db_pool.get().await?;
+    use crate::tables::train_schedule;
+    use diesel::{BelongingToDsl, ExpressionMethods, GroupedBy, QueryDsl};
+    use diesel_async::RunQueryDsl;
+
+    let train_schedules = train_schedule::table
+        .filter(train_schedule::timetable_id.eq(timetable_id))
+        .load::<TrainSchedule>(&mut conn)
+        .await?;
+
+    SimulationOutput::belonging_to(&train_schedules)
+        .load::<SimulationOutput>(&mut conn)
+        .await?
+        .grouped_by(&train_schedules)
+        .into_iter()
+        .zip(train_schedules)
+        .map(|(mut sim_output, train_schedule)| {
+            if sim_output.is_empty() {
+                return Err(TrainScheduleError::UnsimulatedTrainSchedule {
+                    train_schedule_id: train_schedule.id.expect("TrainSchedule should have an id"),
+                }
+                .into());
+            }
+            assert!(sim_output.len() == 1);
+            Ok((train_schedule, sim_output.remove(0)))
+        })
+        .collect::<Result<Vec<(TrainSchedule, SimulationOutput)>>>()
+        .map(|v| v.into_iter().unzip())
+}
+
 /// Compute spacing conflicts for a given timetable
 /// TODO: This should compute itinary conflicts too
 #[utoipa::path(
@@ -114,38 +148,8 @@ async fn get_conflicts(
 ) -> Result<Json<Vec<Conflict>>> {
     let timetable_id = timetable_id.into_inner();
 
-    let (schedules, simulations): (Vec<TrainSchedule>, Vec<SimulationOutput>) = {
-        let mut conn = db_pool.get().await?;
-        use crate::tables::train_schedule;
-        use diesel::{BelongingToDsl, ExpressionMethods, GroupedBy, QueryDsl};
-        use diesel_async::RunQueryDsl;
-
-        let train_schedules = train_schedule::table
-            .filter(train_schedule::timetable_id.eq(timetable_id))
-            .load::<TrainSchedule>(&mut conn)
-            .await?;
-
-        SimulationOutput::belonging_to(&train_schedules)
-            .load::<SimulationOutput>(&mut conn)
-            .await?
-            .grouped_by(&train_schedules)
-            .into_iter()
-            .zip(train_schedules)
-            .map(|(mut sim_output, train_schedule)| {
-                if sim_output.is_empty() {
-                    return Err(TrainScheduleError::UnsimulatedTrainSchedule {
-                        train_schedule_id: train_schedule
-                            .id
-                            .expect("TrainSchedule should have an id"),
-                    }
-                    .into());
-                }
-                assert!(sim_output.len() == 1);
-                Ok((train_schedule, sim_output.remove(0)))
-            })
-            .collect::<Result<Vec<(TrainSchedule, SimulationOutput)>>>()
-            .map(|v| v.into_iter().unzip())
-    }?;
+    let (schedules, simulations) =
+        get_simulated_schedules_from_timetable(timetable_id, db_pool).await?;
 
     let mut id_to_name = HashMap::new();
     let mut trains_requirements = Vec::new();