Unify Layer listing

services/src/contexts/in_memory.rs

@@ -60,24 +60,17 @@ impl InMemoryContext {
         exe_ctx_tiling_spec: TilingSpecification,
         query_ctx_chunk_size: ChunkByteSize,
     ) -> Self {
-        let mut workflow_registry = HashMapRegistry::default();
         let mut layer_db = HashMapLayerDb::default();
-        add_layers_from_directory(&mut layer_db, &mut workflow_registry, layer_defs_path).await;
+        add_layers_from_directory(&mut layer_db, layer_defs_path).await;
         add_layer_collections_from_directory(&mut layer_db, layer_collection_defs_path).await;
 
         let mut dataset_db = HashMapDatasetDb::default();
-        add_datasets_from_directory(
-            &mut dataset_db,
-            &mut layer_db,
-            &mut workflow_registry,
-            dataset_defs_path,
-        )
-        .await;
+        add_datasets_from_directory(&mut dataset_db, &mut layer_db, dataset_defs_path).await;
         add_providers_from_directory(&mut dataset_db, provider_defs_path).await;
 
         Self {
             project_db: Default::default(),
-            workflow_registry: Arc::new(workflow_registry),
+            workflow_registry: Default::default(),
             layer_db: Arc::new(layer_db),
             session: Default::default(),
             thread_pool: create_rayon_thread_pool(0),

services/src/datasets/add_from_directory.rs

@@ -9,7 +9,6 @@ use crate::datasets::storage::MetaDataDefinition;
 use crate::layers::layer::{AddLayer, AddLayerCollection, LayerCollectionId};
 use crate::layers::storage::LayerDb;
 use crate::util::user_input::UserInput;
-use crate::workflows::registry::WorkflowRegistry;
 use crate::workflows::workflow::Workflow;
 use crate::{contexts::MockableSession, datasets::storage::DatasetDb};
 use crate::{datasets::storage::ExternalDatasetProviderDefinition, error::Result};
@@ -41,11 +40,10 @@ pub async fn add_dataset_layer_collection<L: LayerDb>(layer_db: &mut L) -> Resul
     Ok(())
 }
 
-pub async fn add_dataset_as_layer<L: LayerDb, W: WorkflowRegistry>(
+pub async fn add_dataset_as_layer<L: LayerDb>(
     def: DatasetDefinition,
     dataset: DatasetId,
     layer_db: &mut L,
-    workflow_db: &mut W,
 ) -> Result<()> {
     let workflow = match def.meta_data {
         MetaDataDefinition::MockMetaData(_) => Workflow {
@@ -81,8 +79,6 @@ pub async fn add_dataset_as_layer<L: LayerDb, W: WorkflowRegistry>(
         },
     };
 
-    let workflow = workflow_db.register(workflow).await?;
-
     let layer = AddLayer {
         name: def.properties.name,
         description: def.properties.description,
@@ -99,26 +95,18 @@ pub async fn add_dataset_as_layer<L: LayerDb, W: WorkflowRegistry>(
     Ok(())
 }
 
-pub async fn add_datasets_from_directory<
-    S: MockableSession,
-    D: DatasetDb<S>,
-    L: LayerDb,
-    W: WorkflowRegistry,
->(
+pub async fn add_datasets_from_directory<S: MockableSession, D: DatasetDb<S>, L: LayerDb>(
     dataset_db: &mut D,
     layer_db: &mut L,
-    workflow_db: &mut W,
     file_path: PathBuf,
 ) {
     async fn add_dataset_definition_from_dir_entry<
         S: MockableSession,
         D: DatasetDb<S>,
         L: LayerDb,
-        W: WorkflowRegistry,
     >(
         db: &mut D,
         layer_db: &mut L,
-        workflow_db: &mut W,
         entry: &DirEntry,
     ) -> Result<()> {
         let def: DatasetDefinition =
@@ -132,7 +120,7 @@ pub async fn add_datasets_from_directory<
             )
             .await?; // TODO: add as system user
 
-        add_dataset_as_layer(def, id, layer_db, workflow_db).await?;
+        add_dataset_as_layer(def, id, layer_db).await?;
 
         Ok(())
     }
@@ -152,8 +140,7 @@ pub async fn add_datasets_from_directory<
         match entry {
             Ok(entry) if entry.path().extension() == Some(OsStr::new("json")) => {
                 if let Err(e) =
-                    add_dataset_definition_from_dir_entry(dataset_db, layer_db, workflow_db, &entry)
-                        .await
+                    add_dataset_definition_from_dir_entry(dataset_db, layer_db, &entry).await
                 {
                     warn!(
                         "Skipped adding dataset from directory entry: {:?} error: {}",

services/src/handlers/layers.rs

@@ -2,6 +2,7 @@ use actix_web::{web, FromRequest, Responder};
 
 use crate::error::Result;
 use crate::layers::layer::{LayerCollectionId, LayerId};
+use crate::layers::listing::LayerCollectionProvider;
 use crate::layers::storage::LayerDb;
 use crate::util::user_input::UserInput;
 use crate::{contexts::Context, layers::layer::LayerCollectionListOptions};
@@ -22,7 +23,7 @@ async fn list_root_collections_handler<C: Context>(
 ) -> Result<impl Responder> {
     let db = ctx.layer_db_ref();
     let collection = db
-        .get_root_collection_items(options.into_inner().validated()?)
+        .root_collection_items(options.into_inner().validated()?)
         .await?;
 
     Ok(web::Json(collection))
@@ -35,7 +36,7 @@ async fn list_collection_handler<C: Context>(
 ) -> Result<impl Responder> {
     let collection = ctx
         .layer_db_ref()
-        .get_collection_items(id.into_inner(), options.into_inner().validated()?)
+        .collection_items(id.into_inner(), options.into_inner().validated()?)
         .await?;
 
     Ok(web::Json(collection))

services/src/layers/add_from_directory.rs

@@ -7,38 +7,28 @@ use std::{
 };
 
 use crate::error::Result;
-use crate::{
-    layers::layer::{
-        AddLayer, AddLayerCollection, LayerCollectionDefinition, LayerCollectionId, LayerDefinition,
-    },
-    workflows::registry::WorkflowRegistry,
+use crate::layers::layer::{
+    AddLayer, AddLayerCollection, LayerCollectionDefinition, LayerCollectionId, LayerDefinition,
 };
 use crate::{layers::storage::LayerDb, util::user_input::UserInput};
 
 use log::{info, warn};
 
-pub async fn add_layers_from_directory<L: LayerDb, W: WorkflowRegistry>(
-    layer_db: &mut L,
-    workflow_db: &mut W,
-    file_path: PathBuf,
-) {
-    async fn add_layer_from_dir_entry<L: LayerDb, W: WorkflowRegistry>(
+pub async fn add_layers_from_directory<L: LayerDb>(layer_db: &mut L, file_path: PathBuf) {
+    async fn add_layer_from_dir_entry<L: LayerDb>(
         layer_db: &mut L,
-        workflow_db: &mut W,
         entry: &DirEntry,
     ) -> Result<()> {
         let def: LayerDefinition =
             serde_json::from_reader(BufReader::new(File::open(entry.path())?))?;
 
-        let workflow_id = workflow_db.register(def.workflow).await?;
-
         layer_db
             .add_layer_with_id(
                 def.id,
                 AddLayer {
                     name: def.name,
                     description: def.description,
-                    workflow: workflow_id,
+                    workflow: def.workflow,
                     symbology: def.symbology,
                 }
                 .validated()?,
@@ -58,7 +48,7 @@ pub async fn add_layers_from_directory<L: LayerDb, W: WorkflowRegistry>(
     for entry in dir {
         match entry {
             Ok(entry) if entry.path().extension() == Some(OsStr::new("json")) => {
-                match add_layer_from_dir_entry(layer_db, workflow_db, &entry).await {
+                match add_layer_from_dir_entry(layer_db, &entry).await {
                     Ok(_) => info!("Added layer from directory entry: {:?}", entry),
                     Err(e) => warn!(
                         "Skipped adding layer from directory entry: {:?} error: {}",

services/src/layers/layer.rs

@@ -3,10 +3,7 @@ use serde::{Deserialize, Serialize};
 use geoengine_datatypes::identifier;
 
 use crate::{
-    error::Result,
-    projects::Symbology,
-    util::user_input::UserInput,
-    workflows::workflow::{Workflow, WorkflowId},
+    error::Result, projects::Symbology, util::user_input::UserInput, workflows::workflow::Workflow,
 };
 
 identifier!(LayerId);
@@ -17,7 +14,7 @@ pub struct Layer {
     pub id: LayerId,
     pub name: String,
     pub description: String,
-    pub workflow: WorkflowId,
+    pub workflow: Workflow,
     pub symbology: Option<Symbology>,
 }
 
@@ -26,14 +23,13 @@ pub struct LayerListing {
     pub id: LayerId,
     pub name: String,
     pub description: String,
-    pub workflow: WorkflowId,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct AddLayer {
     pub name: String,
     pub description: String,
-    pub workflow: WorkflowId,
+    pub workflow: Workflow,
     pub symbology: Option<Symbology>,
 }
 

services/src/layers/listing.rs

@@ -0,0 +1,22 @@
+use async_trait::async_trait;
+
+use crate::util::user_input::Validated;
+use crate::{error::Result, workflows::workflow::Workflow};
+
+use super::layer::{CollectionItem, LayerCollectionId, LayerCollectionListOptions, LayerId};
+
+#[async_trait]
+pub trait LayerCollectionProvider {
+    async fn collection_items(
+        &self,
+        collection: LayerCollectionId,
+        options: Validated<LayerCollectionListOptions>,
+    ) -> Result<Vec<CollectionItem>>;
+
+    async fn root_collection_items(
+        &self,
+        options: Validated<LayerCollectionListOptions>,
+    ) -> Result<Vec<CollectionItem>>;
+
+    async fn workflow(&self, layer: LayerId) -> Result<Workflow>;
+}

services/src/layers/mod.rs

@@ -1,3 +1,4 @@
 pub mod add_from_directory;
 pub mod layer;
+pub mod listing;
 pub mod storage;