editoast: adapt signal layer for new sprite system

Author: flomonster

editoast/map_layers.yml

@@ -25,13 +25,13 @@ layers:
       geo:
         on_field: geographic
         cache_duration: 3600
-        data_expr: signal.data || jsonb_build_object('angle', layer.angle_geo)
+        data_expr: signal.data - 'logical_signals' || jsonb_build_object('angle', layer.angle_geo, 'signaling_system', layer.signaling_system, 'sprite', layer.sprite)
         joins:
           - inner join infra_object_signal signal on signal.obj_id = layer.obj_id and signal.infra_id = layer.infra_id
       sch:
         on_field: schematic
         cache_duration: 3600
-        data_expr: signal.data || jsonb_build_object('angle', layer.angle_sch)
+        data_expr: signal.data - 'logical_signals' || jsonb_build_object('angle', layer.angle_sch, 'signaling_system', layer.signaling_system, 'sprite', layer.sprite)
         joins:
           - inner join infra_object_signal signal on signal.obj_id = layer.obj_id and signal.infra_id = layer.infra_id
 

editoast/migrations/2023-10-11-135746_adapt_signal_layer_sprites/down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE infra_layer_signal DROP signaling_system;
+ALTER TABLE infra_layer_signal DROP sprite;

editoast/migrations/2023-10-11-135746_adapt_signal_layer_sprites/up.sql

@@ -0,0 +1,4 @@
+ALTER TABLE infra_layer_signal
+ADD signaling_system VARCHAR(255) NULL;
+ALTER TABLE infra_layer_signal
+ADD sprite VARCHAR(255) NULL;

editoast/src/generated_data/signal.rs

@@ -2,31 +2,98 @@ use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
 use diesel::sql_query;
-use diesel::sql_types::{Array, BigInt, Text};
+use diesel::sql_types::{Array, BigInt, Nullable, Text};
 use diesel_async::{AsyncPgConnection as PgConnection, RunQueryDsl};
+use std::collections::HashMap;
 use std::iter::Iterator;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
 use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::InfraCache;
-use crate::schema::ObjectType;
+use crate::schema::sprite_config::{SpriteConfig, SpriteConfigs};
+use crate::schema::{LogicalSignal, ObjectType};
 use crate::tables::infra_layer_signal::dsl;
 
 pub struct SignalLayer;
 
+/// Found the corresponding sprite id for a given logical signal
+fn find_sprite_id(sprite_config: &SpriteConfigs, logical_signal: &LogicalSignal) -> Option<String> {
+    let sprite_config = sprite_config.get(&logical_signal.signaling_system)?;
+    'sprite: for conditional_sprite in &sprite_config.sprites {
+        for (cond_key, cond_value) in &conditional_sprite.conditions {
+            match logical_signal.settings.get(&cond_key.clone().into()) {
+                Some(value) if &value.0 == cond_value => continue,
+                _ => continue 'sprite,
+            }
+        }
+        // All conditions are met
+        return Some(conditional_sprite.sprite.clone());
+    }
+    Some(sprite_config.default.clone())
+}
+
+/// Generate the signaling system and sprite fields of the layer.
+/// Only updated_signals are updated
+async fn generate_signaling_system_and_sprite<'a, T: Iterator<Item = &'a String>>(
+    conn: &mut PgConnection,
+    infra: i64,
+    infra_cache: &InfraCache,
+    updated_signals: T,
+) -> Result<()> {
+    let sprite_configs = SpriteConfig::load();
+    let mut group_by_sprite: HashMap<_, Vec<_>> = HashMap::new();
+
+    for signal_id in updated_signals {
+        let signal = match infra_cache.signals().get(signal_id) {
+            Some(signal) => signal,
+            None => continue,
+        };
+        let logical_signal = match signal.unwrap_signal().logical_signals.get(0) {
+            Some(logical_signal) => logical_signal,
+            None => continue,
+        };
+
+        let signaling_system = &logical_signal.signaling_system;
+        let sprite_id = find_sprite_id(&sprite_configs, logical_signal);
+
+        group_by_sprite
+            .entry((signaling_system, sprite_id))
+            .or_default()
+            .push(signal_id);
+    }
+
+    for ((signaling_system, sprite_id), signals) in group_by_sprite {
+        sql_query("UPDATE infra_layer_signal SET signaling_system = $2, sprite = $3 WHERE infra_id = $1 AND obj_id = ANY($4)")
+            .bind::<BigInt, _>(infra)
+            .bind::<Text, _>(signaling_system)
+            .bind::<Nullable<Text>, _>(sprite_id)
+            .bind::<Array<Text>, _>(signals)
+            .execute(conn)
+            .await?;
+    }
+    Ok(())
+}
+
 #[async_trait]
 impl GeneratedData for SignalLayer {
     fn table_name() -> &'static str {
         "infra_layer_signal"
     }
 
-    async fn generate(conn: &mut PgConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
+    async fn generate(conn: &mut PgConnection, infra: i64, infra_cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_signal_layer.sql"))
             .bind::<BigInt, _>(infra)
             .execute(conn)
             .await?;
+        generate_signaling_system_and_sprite(
+            conn,
+            infra,
+            infra_cache,
+            infra_cache.signals().keys(), // All signals
+        )
+        .await?;
         Ok(())
     }
 
@@ -52,11 +119,19 @@ impl GeneratedData for SignalLayer {
 
         // Update elements
         if !involved_objects.updated.is_empty() {
+            let updated_signals = involved_objects.updated.into_iter().collect::<Vec<_>>();
             sql_query(include_str!("sql/insert_update_signal_layer.sql"))
                 .bind::<BigInt, _>(infra)
-                .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
+                .bind::<Array<Text>, _>(&updated_signals)
                 .execute(conn)
                 .await?;
+            generate_signaling_system_and_sprite(
+                conn,
+                infra,
+                infra_cache,
+                updated_signals.into_iter(),
+            )
+            .await?;
         }
         Ok(())
     }

editoast/src/infra_cache/mod.rs

@@ -373,7 +373,7 @@ impl InfraCache {
 
         // Load signal tracks references
         sql_query(
-            "SELECT obj_id, data->>'track' AS track, (data->>'position')::float AS position FROM infra_object_signal WHERE infra_id = $1")
+            "SELECT obj_id, data->>'track' AS track, (data->>'position')::float AS position, data->'logical_signals' as logical_signals FROM infra_object_signal WHERE infra_id = $1")
         .bind::<BigInt, _>(infra_id)
         .load::<SignalCache>(conn).await?.into_iter().for_each(|signal|
             infra_cache.add(signal)
@@ -799,6 +799,7 @@ pub mod tests {
             obj_id: obj_id.as_ref().into(),
             track: track.as_ref().into(),
             position,
+            logical_signals: Default::default(),
         }
     }
 

editoast/src/schema/signal.rs

@@ -12,7 +12,8 @@ use super::Side;
 use crate::infra_cache::Cache;
 use crate::infra_cache::ObjectCache;
 use derivative::Derivative;
-use diesel::sql_types::{Double, Text};
+use diesel::sql_types::{Double, Jsonb, Text};
+use diesel_json::Json as DieselJson;
 
 use editoast_derive::InfraModel;
 use serde::{Deserialize, Serialize};
@@ -91,6 +92,9 @@ pub struct SignalCache {
     #[derivative(Hash = "ignore", PartialEq = "ignore")]
     #[diesel(sql_type = Double)]
     pub position: f64,
+    #[derivative(Hash = "ignore", PartialEq = "ignore")]
+    #[diesel(sql_type = Jsonb)]
+    pub logical_signals: DieselJson<Vec<LogicalSignal>>,
 }
 
 impl OSRDTyped for SignalCache {
@@ -116,18 +120,24 @@ impl Cache for SignalCache {
 }
 
 impl SignalCache {
-    pub fn new(obj_id: String, track: String, position: f64) -> Self {
+    pub fn new(
+        obj_id: String,
+        track: String,
+        position: f64,
+        logical_signals: Vec<LogicalSignal>,
+    ) -> Self {
         Self {
             obj_id,
             track,
             position,
+            logical_signals: DieselJson(logical_signals),
         }
     }
 }
 
 impl From<Signal> for SignalCache {
     fn from(sig: Signal) -> Self {
-        Self::new(sig.id.0, sig.track.0, sig.position)
+        Self::new(sig.id.0, sig.track.0, sig.position, sig.logical_signals)
     }
 }
 

editoast/src/tables.rs

@@ -156,6 +156,10 @@ diesel::table! {
         infra_id -> Int8,
         angle_geo -> Float8,
         angle_sch -> Float8,
+        #[max_length = 255]
+        signaling_system -> Nullable<Varchar>,
+        #[max_length = 255]
+        sprite -> Nullable<Varchar>,
     }
 }