businessLogic: refactored repositories

src/participation-hub/business-logic-microservice/app/configs/swagger.yml

@@ -15,43 +15,37 @@ produces:
 
 basePath: "/api"
 
-
 paths:
   /use-cases:
-    delete:
+    get:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.delete_uses_cases"
+      operationId: "routes.use_case.all"
       tags:
         - "Use-Cases"
-      summary: "Delete all use-cases"
-      description: "Delete all use-cases"
+      summary: "Retrieves all Use-Cases"
+      description: "Retrieves all Use-Cases"
       responses:
         '200':
           description: "Successful Request"
-
-
-paths:
-  /use-cases/{use_case}/schema/mapping:
-    put:
+    delete:
+      operationId: "routes.use_case.delete_all"
+      tags:
+        - "Use-Cases"
+      summary: "Delete all Use-Cases"
+      description: "Delete all Use-Cases"
+      responses:
+        '200':
+          description: "Successful Request"
+  /schemas:
+    get:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.add_mapping_to_schema"
+      operationId: "routes.schema.all"
       tags:
         - "Schemas"
-      summary: "Adds an attribute mapping to the Schema of the Use-Case"
-      description: "Adds an attribute mapping to the each Layer of the Use-Case"
-      parameters:
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the Schema belongs to"
-          required: true
-          type: "string"
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            $ref: '#/definitions/Mapping'
+      summary: "Get all Use-Cases"
+      description: "Get all Use-Cases"
       responses:
         '200':
           description: "Successful Request"
@@ -59,7 +53,7 @@ paths:
     get:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.schema_for_use_case"
+      operationId: "routes.schema.get_for_use_case"
       tags:
         - "Schemas"
       summary: "Get the Schema assigned to the Use-Case"
@@ -78,7 +72,7 @@ paths:
     delete:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.delete_schema_for_use_case"
+      operationId: "routes.schema.delete_for_use_case"
       tags:
         - "Schemas"
       summary: "Delete the Schema assigned to the Use-Case"
@@ -94,41 +88,71 @@ paths:
           description: "Successful Request"
         '404':
           description: "Schema does not exist"
-  /schemas:
-    get:
+  /use-cases/{use_case}/schema/mapping:
+    put:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.all_schemas"
+      operationId: "routes.schema.add_mapping"
       tags:
         - "Schemas"
-      summary: "Get all Use-Cases"
-      description: "Get all Use-Cases"
+      summary: "Adds an attribute mapping to the Schema of the Use-Case"
+      description: "Adds an attribute mapping to the each Layer of the Use-Case"
+      parameters:
+        - name: "use_case"
+          in: "path"
+          description: "Name of the Use-Case the Schema belongs to"
+          required: true
+          type: "string"
+        - in: body
+          name: "Object"
+          required: true
+          schema:
+            $ref: '#/definitions/Mapping'
+      responses:
+        '200':
+          description: "Successful Request"
+  /layers:
+    get:
+      security:
+        - JwtRegular: []
+      operationId: "routes.layer.all"
+      tags:
+        - "Layers"
+      summary: "Retrieve all Layers from the DB"
+      description: "Retrieve all Layers from the DB"
       responses:
         '200':
           description: "Successful Request"
-  /use-cases:
     delete:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.delete_uses_cases"
+      operationId: "routes.layer.delete_all_layers"
       tags:
-        - "Use-Cases"
-      summary: "Delete all Use-Cases"
-      description: "Delete all Use-Cases"
+        - "Layers"
+      summary: "Delete all Layers from the DB"
+      description: "Delete all Layers from the DB"
       responses:
         '200':
           description: "Successful Request"
-    get:
+    post:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.use_cases"
+      operationId: "routes.layer.add_complete"
       tags:
-        - "Use-Cases"
-      summary: "Retrieves all Use-Cases"
-      description: "Retrieves all Use-Cases"
+        - "Layers"
+      summary: "Adds a complete Layer (including its properties) to the DB"
+      description: "Adds a complete Layer (including its properties) to the DB"
+      parameters:
+        - in: body
+          name: "Object"
+          required: true
+          schema:
+            $ref: '#/definitions/Layer'
       responses:
         '200':
           description: "Successful Request"
+        '400':
+          description: "Bad structure in request body or Layer already exists"
   /use-cases/{use_case}/layers:
     get:
       security:
@@ -149,19 +173,67 @@ paths:
           description: "Successful Request"
         '404':
           description: "Use-Case does not exist"
-  /use-cases/{use_case}/cluster-mapping/layers/{name}:
+  /use-cases/{use_case}/layers/{name}:
+    get:
+      security:
+        - JwtRegular: []
+      operationId: "routes.layer.one"
+      tags:
+        - "Layers"
+      summary: "Retrieve one Layer from the DB"
+      description: "Retrieve one Layer from the DB"
+      parameters:
+        - name: "use_case"
+          in: "path"
+          description: "Name of the Use-Case the Layer belongs to"
+          required: true
+          type: "string"
+        - name: "name"
+          in: "path"
+          description: "Name of the Layer"
+          required: true
+          type: "string"
+      responses:
+        '200':
+          description: "Successful Request"
+        '404':
+          description: "Layer does not exist"
+    post:
+      security:
+        - JwtRegular: []
+      operationId: "routes.layer.add_empty"
+      tags:
+        - "Layers"
+      summary: "Adds an empty Layer to the DB"
+      description: "Adds an empty Layer to the DB"
+      parameters:
+        - name: "use_case"
+          in: "path"
+          description: "Name of the Use-Case the Layer belongs to"
+          required: true
+          type: "string"
+        - name: "name"
+          in: "path"
+          description: "Name of the new Layer"
+          required: true
+          type: "string"
+      responses:
+        '200':
+          description: "Successful Request"
+        '400':
+          description: "Layer already exists"
     delete:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.delete_cluster_mapping"
+      operationId: "routes.layer.delete_one"
       tags:
         - "Layers"
-      summary: "Deletes a cluster-attribute mapping from the selected layer"
-      description: "Deletes a cluster-attribute mapping from the selected layer"
+      summary: "Delete one Layer from the DB"
+      description: "Delete one Layer from the DB"
       parameters:
         - name: "name"
           in: "path"
-          description: "Name of the layer (must exist)"
+          description: "Name of the layer to delete"
           required: true
           type: "string"
         - name: "use_case"
@@ -169,23 +241,12 @@ paths:
           description: "Name of the Use-Case the layer belongs to"
           required: true
           type: "string"
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            type: object
-            properties:
-              attribute:
-                type: string
-                example: "end_time"
-                description: "Internal name of the attribute"
       responses:
         '200':
           description: "Successful Request"
         '404':
           description: "Layer does not exist"
-        '400':
-          description: "Field in request is missing or attribute does not exist in the Layer"
+  /use-cases/{use_case}/cluster-mapping/layers/{name}:
     put:
       security:
         - JwtRegular: []
@@ -195,14 +256,14 @@ paths:
       summary: "Selects a property of the Layer as cluster property"
       description: "Selects a property of the Layer as cluster property"
       parameters:
-        - name: "name"
+        - name: "use_case"
           in: "path"
-          description: "Name of the layer (must exist)"
+          description: "Name of the Use-Case the layer belongs to"
           required: true
           type: "string"
-        - name: "use_case"
+        - name: "name"
           in: "path"
-          description: "Name of the Use-Case the layer belongs to"
+          description: "Name of the layer (must exist)"
           required: true
           type: "string"
         - in: body
@@ -222,19 +283,23 @@ paths:
           description: "Layer does not exist"
         '400':
           description: "Field in request is missing or attribute does not exist in the Layer"
-  /use-cases/{use_case}/layers/use-case:
-    put:
+    delete:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.update_use_case_for_all"
+      operationId: "routes.layer.delete_cluster_mapping"
       tags:
         - "Layers"
-      summary: "Update the Use-Case of all Layers belonging to the Use-Case in the query"
-      description: "Update the Use-Case of all Layers belonging to the Use-Case in the query"
+      summary: "Deletes a cluster-attribute mapping from the selected layer"
+      description: "Deletes a cluster-attribute mapping from the selected layer"
       parameters:
         - name: "use_case"
           in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
+          description: "Name of the Use-Case the layer belongs to"
+          required: true
+          type: "string"
+        - name: "name"
+          in: "path"
+          description: "Name of the layer (must exist)"
           required: true
           type: "string"
         - in: body
@@ -243,14 +308,17 @@ paths:
           schema:
             type: object
             properties:
-              use_case:
+              attribute:
                 type: string
-                example: "air-bnb"
+                example: "end_time"
+                description: "Internal name of the attribute"
       responses:
         '200':
           description: "Successful Request"
+        '404':
+          description: "Layer does not exist"
         '400':
-          description: "Field in request is missing"
+          description: "Field in request is missing or attribute does not exist in the Layer"
   /use-cases/{use_case}/layers/mapping:
     put:
       security:
@@ -305,37 +373,6 @@ paths:
         '400':
           description: "Field in request is missing"
   /use-cases/{use_case}/layers/{name}/mapping:
-    delete:
-      security:
-        - JwtRegular: []
-      operationId: "routes.layer.delete_mapping"
-      tags:
-        - "Layers"
-      summary: "Deletes an attribute mapping from the selected Layer"
-      description: "Deletes an attribute mapping from the selected Layer"
-      parameters:
-        - name: "name"
-          in: "path"
-          description: "Name of the Layer (must exist)"
-          required: true
-          type: "string"
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
-          required: true
-          type: "string"
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            $ref: '#/definitions/LayerMapping'
-      responses:
-        '200':
-          description: "Successful Request"
-        '404':
-          description: "Layer does not exist"
-        '400':
-          description: "Field in request is missing"
     put:
       security:
         - JwtRegular: []
@@ -345,14 +382,14 @@ paths:
       summary: "Adds an attribute mapping to the selected Layer"
       description: "Adds an attribute mapping to the selected Layer"
       parameters:
-        - name: "name"
+        - name: "use_case"
           in: "path"
-          description: "Name of the Layer (must exist)"
+          description: "Name of the Use-Case the Layer belongs to"
           required: true
           type: "string"
-        - name: "use_case"
+        - name: "name"
           in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
+          description: "Name of the Layer (must exist)"
           required: true
           type: "string"
         - in: body
@@ -367,139 +404,37 @@ paths:
           description: "Layer does not exist"
         '400':
           description: "Field in request is missing"
-  /use-cases/{use_case}/layers/{name}:
-    get:
-      security:
-        - JwtRegular: []
-      operationId: "routes.layer.one"
-      tags:
-        - "Layers"
-      summary: "Retrieve one Layer from the DB"
-      description: "Retrieve one Layer from the DB"
-      parameters:
-        - name: "name"
-          in: "path"
-          description: "Name of the Layer"
-          required: true
-          type: "string"
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
-          required: true
-          type: "string"
-      responses:
-        '200':
-          description: "Successful Request"
-        '404':
-          description: "Layer does not exist"
-    post:
+    delete:
       security:
         - JwtRegular: []
-      operationId: "routes.layer.add"
+      operationId: "routes.layer.delete_mapping"
       tags:
         - "Layers"
-      summary: "Adds an empty Layer to the DB"
-      description: "Adds an empty Layer to the DB"
+      summary: "Deletes an attribute mapping from the selected Layer"
+      description: "Deletes an attribute mapping from the selected Layer"
       parameters:
-        - name: "name"
-          in: "path"
-          description: "Name of the new Layer"
-          required: true
-          type: "string"
         - name: "use_case"
           in: "path"
           description: "Name of the Use-Case the Layer belongs to"
           required: true
           type: "string"
-      responses:
-        '200':
-          description: "Successful Request"
-        '400':
-          description: "Layer already exists"
-    delete:
-      security:
-        - JwtRegular: []
-      operationId: "routes.layer.delete_one"
-      tags:
-        - "Layers"
-      summary: "Delete one Layer from the DB"
-      description: "Delete one Layer from the DB"
-      parameters:
         - name: "name"
           in: "path"
-          description: "Name of the layer to delete"
-          required: true
-          type: "string"
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the layer belongs to"
+          description: "Name of the Layer (must exist)"
           required: true
           type: "string"
-      responses:
-        '200':
-          description: "Successful Request"
-        '404':
-          description: "Layer does not exist"
-  /layers:
-    get:
-      security:
-        - JwtRegular: []
-      operationId: "routes.layer.all"
-      tags:
-        - "Layers"
-      summary: "Retrieve all Layers from the DB"
-      description: "Retrieve all Layers from the DB"
-      responses:
-        '200':
-          description: "Successful Request"
-    delete:
-      security:
-        - JwtRegular: []
-      operationId: "routes.layer.delete_all_layers"
-      tags:
-        - "Layers"
-      summary: "Delete all Layers from the DB"
-      description: "Delete all Layers from the DB"
-      responses:
-        '200':
-          description: "Successful Request"
-    post:
-      security:
-        - JwtRegular: []
-      operationId: "routes.layer.add_complete"
-      tags:
-        - "Layers"
-      summary: "Adds a complete Layer (including its properties) to the DB"
-      description: "Adds a complete Layer (including its properties) to the DB"
-      parameters:
         - in: body
           name: "Object"
           required: true
           schema:
-            $ref: '#/definitions/Layer'
+            $ref: '#/definitions/LayerMapping'
       responses:
         '200':
           description: "Successful Request"
+        '404':
+          description: "Layer does not exist"
         '400':
-          description: "Bad structure in request body or Layer already exists"
-  /debug:
-    post:
-      security:
-        - JwtRegular: []
-      operationId: "debug.echo"
-      tags:
-        - "Echo"
-      summary: "Echo function for debugging purposes"
-      description: "Echoes the input back to the caller."
-      parameters:
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            type: object
-      responses:
-        '200':
-          description: "Successful echo of request data"
+          description: "Field in request is missing"
 
 definitions:
   LayerMapping:

src/participation-hub/business-logic-microservice/app/configs/swagger_local.yml

@@ -12,30 +12,38 @@ produces:
 basePath: "/api"
 
 paths:
-  /use-cases/{use_case}/schema/mapping:
-    put:
-      operationId: "routes.layer.add_mapping_to_schema"
+  /use-cases:
+    get:
+      operationId: "routes.use_case.all"
+      tags:
+        - "Use-Cases"
+      summary: "Retrieves all Use-Cases"
+      description: "Retrieves all Use-Cases"
+      responses:
+        '200':
+          description: "Successful Request"
+    delete:
+      operationId: "routes.use_case.delete_all"
+      tags:
+        - "Use-Cases"
+      summary: "Delete all Use-Cases"
+      description: "Delete all Use-Cases"
+      responses:
+        '200':
+          description: "Successful Request"
+  /schemas:
+    get:
+      operationId: "routes.schema.all"
       tags:
         - "Schemas"
-      summary: "Adds an attribute mapping to the Schema of the Use-Case"
-      description: "Adds an attribute mapping to the each Layer of the Use-Case"
-      parameters:
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the Schema belongs to"
-          required: true
-          type: "string"
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            $ref: '#/definitions/Mapping'
+      summary: "Get all Use-Cases"
+      description: "Get all Use-Cases"
       responses:
         '200':
           description: "Successful Request"
   /use-cases/{use_case}/schema:
     get:
-      operationId: "routes.layer.schema_for_use_case"
+      operationId: "routes.schema.get_for_use_case"
       tags:
         - "Schemas"
       summary: "Get the Schema assigned to the Use-Case"
@@ -52,7 +60,7 @@ paths:
         '404':
           description: "Schema does not exist"
     delete:
-      operationId: "routes.layer.delete_schema_for_use_case"
+      operationId: "routes.schema.delete_for_use_case"
       tags:
         - "Schemas"
       summary: "Delete the Schema assigned to the Use-Case"
@@ -68,35 +76,63 @@ paths:
           description: "Successful Request"
         '404':
           description: "Schema does not exist"
-  /schemas:
-    get:
-      operationId: "routes.layer.all_schemas"
+  /use-cases/{use_case}/schema/mapping:
+    put:
+      operationId: "routes.schema.add_mapping"
       tags:
         - "Schemas"
-      summary: "Get all Use-Cases"
-      description: "Get all Use-Cases"
+      summary: "Adds an attribute mapping to the Schema of the Use-Case"
+      description: "Adds an attribute mapping to the each Layer of the Use-Case"
+      parameters:
+        - name: "use_case"
+          in: "path"
+          description: "Name of the Use-Case the Schema belongs to"
+          required: true
+          type: "string"
+        - in: body
+          name: "Object"
+          required: true
+          schema:
+            $ref: '#/definitions/Mapping'
+      responses:
+        '200':
+          description: "Successful Request"
+  /layers:
+    get:
+      operationId: "routes.layer.all"
+      tags:
+        - "Layers"
+      summary: "Retrieve all Layers from the DB"
+      description: "Retrieve all Layers from the DB"
       responses:
         '200':
           description: "Successful Request"
-  /use-cases:
     delete:
-      operationId: "routes.layer.delete_uses_cases"
+      operationId: "routes.layer.delete_all_layers"
       tags:
-        - "Use-Cases"
-      summary: "Delete all Use-Cases"
-      description: "Delete all Use-Cases"
+        - "Layers"
+      summary: "Delete all Layers from the DB"
+      description: "Delete all Layers from the DB"
       responses:
         '200':
           description: "Successful Request"
-    get:
-      operationId: "routes.layer.use_cases"
+    post:
+      operationId: "routes.layer.add_complete"
       tags:
-        - "Use-Cases"
-      summary: "Retrieves all Use-Cases"
-      description: "Retrieves all Use-Cases"
+        - "Layers"
+      summary: "Adds a complete Layer (including its properties) to the DB"
+      description: "Adds a complete Layer (including its properties) to the DB"
+      parameters:
+        - in: body
+          name: "Object"
+          required: true
+          schema:
+            $ref: '#/definitions/Layer'
       responses:
         '200':
           description: "Successful Request"
+        '400':
+          description: "Bad structure in request body or Layer already exists"
   /use-cases/{use_case}/layers:
     get:
       operationId: "routes.layer.get_all_for_use_case"
@@ -115,17 +151,61 @@ paths:
           description: "Successful Request"
         '404':
           description: "Use-Case does not exist"
-  /use-cases/{use_case}/cluster-mapping/layers/{name}:
+  /use-cases/{use_case}/layers/{name}:
+    get:
+      operationId: "routes.layer.one"
+      tags:
+        - "Layers"
+      summary: "Retrieve one Layer from the DB"
+      description: "Retrieve one Layer from the DB"
+      parameters:
+        - name: "use_case"
+          in: "path"
+          description: "Name of the Use-Case the Layer belongs to"
+          required: true
+          type: "string"
+        - name: "name"
+          in: "path"
+          description: "Name of the Layer"
+          required: true
+          type: "string"
+      responses:
+        '200':
+          description: "Successful Request"
+        '404':
+          description: "Layer does not exist"
+    post:
+      operationId: "routes.layer.add_empty"
+      tags:
+        - "Layers"
+      summary: "Adds an empty Layer to the DB"
+      description: "Adds an empty Layer to the DB"
+      parameters:
+        - name: "use_case"
+          in: "path"
+          description: "Name of the Use-Case the Layer belongs to"
+          required: true
+          type: "string"
+        - name: "name"
+          in: "path"
+          description: "Name of the new Layer"
+          required: true
+          type: "string"
+      responses:
+        '200':
+          description: "Successful Request"
+        '400':
+          description: "Layer already exists"
     delete:
-      operationId: "routes.layer.delete_cluster_mapping"
+      operationId: "routes.layer.delete_one"
       tags:
         - "Layers"
-      summary: "Deletes a cluster-attribute mapping from the selected layer"
-      description: "Deletes a cluster-attribute mapping from the selected layer"
+      summary: "Delete one Layer from the DB"
+      description: "Delete one Layer from the DB"
       parameters:
         - name: "name"
           in: "path"
-          description: "Name of the layer (must exist)"
+          description: "Name of the layer to delete"
           required: true
           type: "string"
         - name: "use_case"
@@ -133,23 +213,12 @@ paths:
           description: "Name of the Use-Case the layer belongs to"
           required: true
           type: "string"
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            type: object
-            properties:
-              attribute:
-                type: string
-                example: "end_time"
-                description: "Internal name of the attribute"
       responses:
         '200':
           description: "Successful Request"
         '404':
           description: "Layer does not exist"
-        '400':
-          description: "Field in request is missing or attribute does not exist in the Layer"
+  /use-cases/{use_case}/cluster-mapping/layers/{name}:
     put:
       operationId: "routes.layer.add_cluster_mapping"
       tags:
@@ -157,14 +226,14 @@ paths:
       summary: "Selects a property of the Layer as cluster property"
       description: "Selects a property of the Layer as cluster property"
       parameters:
-        - name: "name"
+        - name: "use_case"
           in: "path"
-          description: "Name of the layer (must exist)"
+          description: "Name of the Use-Case the layer belongs to"
           required: true
           type: "string"
-        - name: "use_case"
+        - name: "name"
           in: "path"
-          description: "Name of the Use-Case the layer belongs to"
+          description: "Name of the layer (must exist)"
           required: true
           type: "string"
         - in: body
@@ -184,17 +253,21 @@ paths:
           description: "Layer does not exist"
         '400':
           description: "Field in request is missing or attribute does not exist in the Layer"
-  /use-cases/{use_case}/layers/use-case:
-    put:
-      operationId: "routes.layer.update_use_case_for_all"
+    delete:
+      operationId: "routes.layer.delete_cluster_mapping"
       tags:
         - "Layers"
-      summary: "Update the Use-Case of all Layers belonging to the Use-Case in the query"
-      description: "Update the Use-Case of all Layers belonging to the Use-Case in the query"
+      summary: "Deletes a cluster-attribute mapping from the selected layer"
+      description: "Deletes a cluster-attribute mapping from the selected layer"
       parameters:
         - name: "use_case"
           in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
+          description: "Name of the Use-Case the layer belongs to"
+          required: true
+          type: "string"
+        - name: "name"
+          in: "path"
+          description: "Name of the layer (must exist)"
           required: true
           type: "string"
         - in: body
@@ -203,14 +276,17 @@ paths:
           schema:
             type: object
             properties:
-              use_case:
+              attribute:
                 type: string
-                example: "air-bnb"
+                example: "end_time"
+                description: "Internal name of the attribute"
       responses:
         '200':
           description: "Successful Request"
+        '404':
+          description: "Layer does not exist"
         '400':
-          description: "Field in request is missing"
+          description: "Field in request is missing or attribute does not exist in the Layer"
   /use-cases/{use_case}/layers/mapping:
     put:
       operationId: "routes.layer.add_mapping_for_all"
@@ -261,35 +337,6 @@ paths:
         '400':
           description: "Field in request is missing"
   /use-cases/{use_case}/layers/{name}/mapping:
-    delete:
-      operationId: "routes.layer.delete_mapping"
-      tags:
-        - "Layers"
-      summary: "Deletes an attribute mapping from the selected Layer"
-      description: "Deletes an attribute mapping from the selected Layer"
-      parameters:
-        - name: "name"
-          in: "path"
-          description: "Name of the Layer (must exist)"
-          required: true
-          type: "string"
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
-          required: true
-          type: "string"
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            $ref: '#/definitions/LayerMapping'
-      responses:
-        '200':
-          description: "Successful Request"
-        '404':
-          description: "Layer does not exist"
-        '400':
-          description: "Field in request is missing"
     put:
       operationId: "routes.layer.add_mapping"
       tags:
@@ -297,14 +344,14 @@ paths:
       summary: "Adds an attribute mapping to the selected Layer"
       description: "Adds an attribute mapping to the selected Layer"
       parameters:
-        - name: "name"
+        - name: "use_case"
           in: "path"
-          description: "Name of the Layer (must exist)"
+          description: "Name of the Use-Case the Layer belongs to"
           required: true
           type: "string"
-        - name: "use_case"
+        - name: "name"
           in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
+          description: "Name of the Layer (must exist)"
           required: true
           type: "string"
         - in: body
@@ -319,125 +366,35 @@ paths:
           description: "Layer does not exist"
         '400':
           description: "Field in request is missing"
-  /use-cases/{use_case}/layers/{name}:
-    get:
-      operationId: "routes.layer.one"
-      tags:
-        - "Layers"
-      summary: "Retrieve one Layer from the DB"
-      description: "Retrieve one Layer from the DB"
-      parameters:
-        - name: "name"
-          in: "path"
-          description: "Name of the Layer"
-          required: true
-          type: "string"
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the Layer belongs to"
-          required: true
-          type: "string"
-      responses:
-        '200':
-          description: "Successful Request"
-        '404':
-          description: "Layer does not exist"
-    post:
-      operationId: "routes.layer.add"
+    delete:
+      operationId: "routes.layer.delete_mapping"
       tags:
         - "Layers"
-      summary: "Adds an empty Layer to the DB"
-      description: "Adds an empty Layer to the DB"
+      summary: "Deletes an attribute mapping from the selected Layer"
+      description: "Deletes an attribute mapping from the selected Layer"
       parameters:
-        - name: "name"
-          in: "path"
-          description: "Name of the new Layer"
-          required: true
-          type: "string"
         - name: "use_case"
           in: "path"
           description: "Name of the Use-Case the Layer belongs to"
           required: true
           type: "string"
-      responses:
-        '200':
-          description: "Successful Request"
-        '400':
-          description: "Layer already exists"
-    delete:
-      operationId: "routes.layer.delete_one"
-      tags:
-        - "Layers"
-      summary: "Delete one Layer from the DB"
-      description: "Delete one Layer from the DB"
-      parameters:
         - name: "name"
           in: "path"
-          description: "Name of the layer to delete"
-          required: true
-          type: "string"
-        - name: "use_case"
-          in: "path"
-          description: "Name of the Use-Case the layer belongs to"
+          description: "Name of the Layer (must exist)"
           required: true
           type: "string"
-      responses:
-        '200':
-          description: "Successful Request"
-        '404':
-          description: "Layer does not exist"
-  /layers:
-    get:
-      operationId: "routes.layer.all"
-      tags:
-        - "Layers"
-      summary: "Retrieve all Layers from the DB"
-      description: "Retrieve all Layers from the DB"
-      responses:
-        '200':
-          description: "Successful Request"
-    delete:
-      operationId: "routes.layer.delete_all_layers"
-      tags:
-        - "Layers"
-      summary: "Delete all Layers from the DB"
-      description: "Delete all Layers from the DB"
-      responses:
-        '200':
-          description: "Successful Request"
-    post:
-      operationId: "routes.layer.add_complete"
-      tags:
-        - "Layers"
-      summary: "Adds a complete Layer (including its properties) to the DB"
-      description: "Adds a complete Layer (including its properties) to the DB"
-      parameters:
         - in: body
           name: "Object"
           required: true
           schema:
-            $ref: '#/definitions/Layer'
+            $ref: '#/definitions/LayerMapping'
       responses:
         '200':
           description: "Successful Request"
+        '404':
+          description: "Layer does not exist"
         '400':
-          description: "Bad structure in request body or Layer already exists"
-  /debug:
-    post:
-      operationId: "debug.echo"
-      tags:
-        - "Echo"
-      summary: "Echo function for debugging purposes"
-      description: "Echoes the input back to the caller."
-      parameters:
-        - in: body
-          name: "Object"
-          required: true
-          schema:
-            type: object
-      responses:
-        '200':
-          description: "Successful echo of request data"
+          description: "Field in request is missing"
 
 definitions:
   LayerMapping:

src/participation-hub/business-logic-microservice/app/db/entities/table.py

+from typing import Dict
+
+class Table:
+    def __init__(self, name):
+        self.name = name
+    
+    def to_serializable_dict(self) -> Dict:
+        return {"name": self.name}
+    
+    @staticmethod
+    def from_serializable_dict(data: Dict):
+        return Table(data["name"])
\ No newline at end of file

src/participation-hub/business-logic-microservice/app/db/layer_repository.py

+# global imports (dont't worry, red is normal)
+import network_constants as netconst
+from database.MongoRepositoryBase import MongoRepositoryBase
+from db.entities.table import Table
+
+import pymongo
+import json
+from typing import List, Dict
+
+class TableRepository(MongoRepositoryBase):
+    '''This is a repository for MongoDb.'''
+
+    def __init__(self):
+        super().__init__(netconst.BUSINESS_LOGIC_DB_HOSTNAME,
+                         netconst.BUSINESS_LOGIC_DB_PORT,
+                         'rest-gateway-db')
+
+        self._table_collection = 'tables'
+
+    def add_one(self, table: Table):
+        super().insert_entry(self._table_collection, table.to_serializable_dict())
+    
+    
\ No newline at end of file

src/participation-hub/business-logic-microservice/app/db/repository.py

@@ -3,7 +3,6 @@ import network_constants as netconst
 from database.MongoRepositoryBase import MongoRepositoryBase
 from db.entities.layer_adapter import LayerAdapter
 from db.entities.use_case import UseCase
-from db.entities.schema import Schema
 
 import pymongo
 import json
@@ -19,72 +18,35 @@ class Repository(MongoRepositoryBase):
 
         self._adapter_collection = 'layer_adapters'
         self._use_case_collection = 'use_cases'
-        self._schema_collection = 'schemas'
     
-    def add_schema(self, schema: Schema):
-        self.put_use_case(schema.use_case)
-        super().insert_entry(self._schema_collection, schema.to_serializable_dict())
+    def all(self) -> List[Dict]:
+        result = super().get_entries(self._adapter_collection, projection={'_id': False})
 
-    def all_schemas(self) -> List[Schema]:
-        result = super().get_entries(self._schema_collection, projection={'_id': False})
-        return [Schema.from_serializable_dict(row) for row in list(result)]
+        return [LayerAdapter.from_serializable_dict(row) for row in list(result)]
     
-    def schema_for_use_case(self, use_case: str) -> List[Dict]:
-        result = super().get_entries(self._schema_collection, projection={'_id': False}, selection={"use_case": use_case})
+    def all_for_use_case(self, use_case: str) -> List[Dict]:
+        result = super().get_entries(self._adapter_collection, projection={'_id': False}, selection={"use_case": use_case})
 
-        result = list(result)
-        if len(result) > 1:
-            raise ValueError("No more than 1 Schema allowed per use-case!")
+        return [LayerAdapter.from_serializable_dict(row) for row in list(result)]
+
+    def one(self, name : str, use_case: str) -> LayerAdapter:
+        result = list(super().get_entries(self._adapter_collection, selection={"name": name, "use_case": use_case}))
 
         if len(result) == 1:
-            return Schema.from_serializable_dict(result[0])
+            return LayerAdapter.from_serializable_dict(result[0])
         
         return None
 
-    def delete_schema_with_use_case(self, use_case: str): 
-        collection = self._database[self._schema_collection]
-        collection.delete_one({"use_case": use_case})
-
-    def delete_all_schemas(self):
-        collection = self._database[self._schema_collection]
-        collection.delete_many({})
-
-    def update_schema(self, schema: Schema):
-        collection = self._database[self._schema_collection]
-        collection.update_one({"use_case": schema.use_case}, {"$set": schema.to_serializable_dict()})
-
-    def delete_all_use_cases_with_name(self, name: str):
-        collection = self._database[self._use_case_collection]
-        collection.delete_many({"name": name})
-
-    def delete_all_layers(self):
+    def delete_all(self):
         collection = self._database[self._adapter_collection]
         collection.delete_many({})
 
-    def delete_all_use_cases(self):
-        collection = self._database[self._use_case_collection]
-        collection.delete_many({})
-
-    def all_use_cases(self) -> List[UseCase]:
-        dicts = list(super().get_entries(self._use_case_collection, projection={'_id': False}))
-
-        return [UseCase.from_serializable_dict(d) for d in dicts]
-
-    def put_use_case(self, use_case_name: str):
-        use_cases = self.all_use_cases()
-
-        existing_use_cases = list(filter(lambda use_case: use_case.name == use_case_name, use_cases))
-
-        if len(existing_use_cases) == 0:
-            use_case = UseCase(use_case_name)
-            super().insert_entry(self._use_case_collection, use_case.to_serializable_dict())
-
     def add(self, adapter : LayerAdapter):
-        self.put_use_case(adapter.use_case)
         super().insert_entry(self._adapter_collection, adapter.to_serializable_dict())
     
-    def one_by_name_and_usecase(self, name : str, use_case: str) -> LayerAdapter:
-        return list(super().get_entries(self._adapter_collection, selection={"name": name, "use_case": use_case}))
+    def add_empty(self, name: str, use_case: str):
+        adapter = LayerAdapter(name, use_case, [], [])
+        super().insert_entry(self._adapter_collection, adapter.to_serializable_dict())
 
     def update_use_case(self, adapter : LayerAdapter, use_case: str):
         collection = self._database[self._adapter_collection]
@@ -97,13 +59,3 @@ class Repository(MongoRepositoryBase):
     def delete_all_with_name_and_use_case(self, name: str, use_case: str):
         collection = self._database[self._adapter_collection]
         collection.delete_many({"name": name, "use_case": use_case})
\ No newline at end of file
-
-    def all(self) -> List[Dict]:
-        result = super().get_entries(self._adapter_collection, projection={'_id': False})
-
-        return list(result)
-    
-    def all_for_use_case(self, use_case: str) -> List[Dict]:
-        result = super().get_entries(self._adapter_collection, projection={'_id': False}, selection={"use_case": use_case})
-
-        return list(result)
\ No newline at end of file

src/participation-hub/business-logic-microservice/app/db/schema_repository.py

+# global imports (dont't worry, red is normal)
+import network_constants as netconst
+from database.MongoRepositoryBase import MongoRepositoryBase
+from db.entities.schema import Schema
+
+import pymongo
+import json
+from typing import List, Dict
+
+class SchemaRepository(MongoRepositoryBase):
+    '''This is a repository for MongoDb.'''
+
+    def __init__(self):
+        super().__init__(netconst.BUSINESS_LOGIC_DB_HOSTNAME,
+                         netconst.BUSINESS_LOGIC_DB_PORT,
+                         'rest-gateway-db')
+
+        self._schema_collection = 'schemas'
+    
+    def all(self) -> List[Schema]:
+        result = super().get_entries(self._schema_collection, projection={'_id': False})
+        return [Schema.from_serializable_dict(row) for row in list(result)]
+
+    def add(self, schema: Schema):
+        self.put_use_case(schema.use_case)
+        super().insert_entry(self._schema_collection, schema.to_serializable_dict())
+
+    def get_for_use_case(self, use_case: str) -> Schema:
+        result = super().get_entries(self._schema_collection, projection={'_id': False}, selection={"use_case": use_case})
+
+        result = list(result)
+        if len(result) > 1:
+            raise ValueError("No more than 1 Schema allowed per use-case!")
+
+        if len(result) == 1:
+            return Schema.from_serializable_dict(result[0])
+        
+        return None
+    
+    def put(self, use_case: str):
+        schema = self.get_for_use_case(use_case)
+
+        if schema == None:
+            schema = Schema(use_case, mappings={})
+            self.add(schema)
+        
+        return schema
+    
+    def delete_for_use_case(self, use_case: str): 
+        collection = self._database[self._schema_collection]
+        collection.delete_one({"use_case": use_case})
+
+    def delete_all(self):
+        collection = self._database[self._schema_collection]
+        collection.delete_many({})
+
+    def update(self, schema: Schema):
+        collection = self._database[self._schema_collection]
+        collection.update_one({"use_case": schema.use_case}, {"$set": schema.to_serializable_dict()})

src/participation-hub/business-logic-microservice/app/db/use_case_repository.py

+# global imports (dont't worry, red is normal)
+import network_constants as netconst
+from database.MongoRepositoryBase import MongoRepositoryBase
+from db.entities.use_case import UseCase
+
+import pymongo
+import json
+from typing import List, Dict
+
+class UseCaseRepository(MongoRepositoryBase):
+    '''This is a repository for MongoDb.'''
+
+    def __init__(self):
+        super().__init__(netconst.BUSINESS_LOGIC_DB_HOSTNAME,
+                         netconst.BUSINESS_LOGIC_DB_PORT,
+                         'rest-gateway-db')
+
+        self._use_case_collection = 'use_cases'
+    
+    def all(self) -> List[UseCase]:
+        dicts = list(super().get_entries(self._use_case_collection, projection={'_id': False}))
+
+        return [UseCase.from_serializable_dict(d) for d in dicts]
+    
+    def delete_all(self):
+        collection = self._database[self._use_case_collection]
+        collection.delete_many({})
+    
+    def delete_all_with_name(self, name: str):
+        collection = self._database[self._use_case_collection]
+        collection.delete_many({"name": name})
+
+    def put(self, use_case_name: str):
+        use_cases = self.all_use_cases()
+
+        existing_use_cases = list(filter(lambda use_case: use_case.name == use_case_name, use_cases))
+
+        if len(existing_use_cases) == 0:
+            use_case = UseCase(use_case_name)
+            super().insert_entry(self._use_case_collection, use_case.to_serializable_dict())
+    

src/participation-hub/business-logic-microservice/app/routes/layer.py

 #global imports
 from db.entities.layer_adapter import LayerAdapter
+from db.repository import Repository
+from db.schema_repository import SchemaRepository
 from services.layer_adapter_service import LayerAdapterService
 
 import json
 from flask import Response, request
 
-
-def use_cases():
-    return [adapter.to_serializable_dict() for adapter in LayerAdapterService.all_use_cases()]
-
-def delete_uses_cases():
-    LayerAdapterService.delete_all_use_cases()
-    return Response(status=200)
+schema_repository = SchemaRepository()
+layer_repository = Repository()
 
 def all():
-    return LayerAdapterService.all()
-
-def all_schemas():
-    return [schema.to_serializable_dict() for schema in LayerAdapterService.all_schemas()]
-
-def schema_for_use_case(use_case:str):
-    schema = LayerAdapterService.schema_for_use_case(use_case)
-
-    if schema != None:
-        return Response(status=200, response=json.dumps(schema.to_serializable_dict()))
-    
-    return Response(status=404, response=f"Schema {use_case} does not exist")
-
-def add_mapping_to_schema(use_case:str):
-    data = request.json
-
-    if "internal" not in data or "external" not in data:
-        return Response(status=400, response=f"Field missing! Fields required: (internal, external)")
-    
-    schema = LayerAdapterService.schema_for_use_case(use_case)
-
-    if schema == None:
-        print("schema not there, creating it...")
-        schema = LayerAdapterService.put_schema(use_case)
-    
-    schema.add_mapping(data["internal"], data["external"])
-    LayerAdapterService.update_schema(schema)
-
-    return Response(status=200)
-
-def delete_schema_for_use_case(use_case:str):
-    schema = LayerAdapterService.schema_for_use_case(use_case)
-
-    if schema == None:
-        return Response(status=404, response=f"Schema {use_case} does not exist")
-    
-    LayerAdapterService.delete_schema(use_case)
+    return [layer.to_serializable_dict() for layer in layer_repository.all()]
 
-    return Response(status=200)
-
-
-##########
-# LAYERS #
-##########
 def get_all_for_use_case(use_case: str):
     '''
     get all layers assigned to the given use_case
     '''
-    return LayerAdapterService.all_for_use_case(use_case)
-
-def add(name: str, use_case: str):
-    '''
-    add an empty layer to the DB
-
-    @params:
-        name        - Required : unique identifier for the layer
-        use_case    - Required : String-identifier for the use-case
-    '''
-    if LayerAdapterService.one(name, use_case) != None:
-        return Response(status=400, response=f"Layer with name '{name}' already exists!")
-
-    LayerAdapterService.add(name, use_case)
-    return Response(status=200)
+    return [layer.to_serializable_dict() for layer in layer_repository.all_for_use_case(use_case)]
 
 def add_complete():
     '''
@@ -87,7 +28,7 @@ def add_complete():
     if "name" not in data or "properties" not in data or "cluster_properties" not in data or "use_case" not in data:
         return Response(status=400, response=f"Field missing! Fields required: (name, properties, cluster_properties)")
 
-    layer = LayerAdapterService.one(data["name"], data["use_case"])
+    layer = layer_repository.one(data["name"], data["use_case"])
 
     if layer != None:
         return Response(status=400, response=f'Layer with name "{data["name"]}" already exists!')
@@ -100,11 +41,10 @@ def add_complete():
         return Response(status=400)
     
     try:
-        LayerAdapterService.check_layer(layer_new)
+        LayerAdapterService.add_complete(layer_new)
     except ValueError as e:
         return Response(status = 400, response=f"{e}")
     
-    LayerAdapterService.add_complete(layer_new)
     return Response(status=200)
 
 def one(name: str, use_case: str):
@@ -115,99 +55,107 @@ def one(name: str, use_case: str):
         name        - Required : unique identifier for the layer
         use_case    - Required : String-identifier for the use-case
     '''
-    layer = LayerAdapterService.one(name, use_case)
+    layer = layer_repository.one(name, use_case)
 
     if layer == None:
         return Response(status=404, response=f"Layer with name '{name}' does not exist!")
 
     return Response(status=200, response=json.dumps(layer.to_serializable_dict()))
 
-def add_mapping_for_all(use_case: str):
+def add_empty(name: str, use_case: str):
     '''
-    add a new mapping to each layer of the use-case
+    add an empty layer to the DB
 
     @params:
+        name        - Required : unique identifier for the layer
         use_case    - Required : String-identifier for the use-case
     '''
-    data = request.json
+    if layer_repository.one(name, use_case) != None:
+        return Response(status=400, response=f"Layer with name '{name}' already exists!")
 
-    if "internal" not in data:
-        return Response(status=400, response=f"Field missing! Fields required: (internal)")
+    layer_repository.add_empty(name, use_case)
+    return Response(status=200)
 
-    # check if schema contains mapping
-    schema = LayerAdapterService.put_schema(use_case)
-    if data["internal"] not in schema.mappings:
-        return Response(status=400, response=f'{data["internal"]} is not existent in the schema!')
+def add_cluster_mapping(name: str, use_case: str):
+    '''
+    add a mapped property to the list of properties to cluster with
 
-    layers = LayerAdapterService.all_for_use_case(use_case)
-    layers = [LayerAdapter.from_serializable_dict(d) for d in layers]
+    @params:
+        name        - Required : unique identifier for the layer
+        use_case    - Required : String-identifier for the use-case
+    '''
+    layer = layer_repository.one(name, use_case)
 
-    for layer in layers:
-        layer.add_mapping(data["internal"])
+    if layer == None:
+        return Response(status=404, response=f"Layer with name '{name}' does not exist!")
 
-        try:
-            LayerAdapterService.check_layer(layer)
-        except ValueError as e:
-            return Response(status = 400, response=f"{e}")
+    data = request.json
 
-        LayerAdapterService.update(layer)
+    if "attribute" not in data:
+        return Response(status=400, response=f"Field missing! Fields required: (attribute)")
 
+    try:
+        layer.add_cluster_mapping(data["attribute"])
+        layer_repository.update(layer)
         return Response(status=200)
+    except:
+        return Response(status=400, response=f'{data["attribute"]} is no attribute in the layer!')
 
-def add_mapping(name: str, use_case: str):
+def delete_cluster_mapping(name: str, use_case: str):
     '''
-    add a new mapping to the layer identified by name
+    remove a mapped property from the list of properties to cluster with
 
     @params:
         name        - Required : unique identifier for the layer
         use_case    - Required : String-identifier for the use-case
     '''
-    layer = LayerAdapterService.one(name, use_case)
+    layer = layer_repository.one(name, use_case)
 
     if layer == None:
         return Response(status=404, response=f"Layer with name '{name}' does not exist!")
 
     data = request.json
 
-    if "internal" not in data:
-        return Response(status=400, response=f"Field missing! Fields required: (internal)")
-
-    # check if schema contains mapping
-    schema = LayerAdapterService.put_schema(use_case)
-    if data["internal"] not in schema.mappings:
-        return Response(status=400, response=f'{data["internal"]} is not existent in the schema!')
-
-    layer.add_mapping(data["internal"])
-    LayerAdapterService.update(layer)
+    if "attribute" not in data:
+        return Response(status=400, response=f"Field missing! Fields required: (attribute)")
 
+    try:
+        layer.delete_cluster_mapping(data["attribute"])
+        layer_repository.update(layer)
         return Response(status=200)
+    except ValueError as e:
+        print(e)
+        return Response(status=400, response=f'{data["attribute"]} is no attribute in the layer!')
 
-def update_use_case_for_all(use_case: str):
+def add_mapping_for_all(use_case: str):
     '''
-    update the use-case for each layer in the use-case
-    this changes the use-case of all layers, meaning the use-case used
-    for this request might not be usable after the request
+    add a new mapping to each layer of the use-case
 
     @params:
         use_case    - Required : String-identifier for the use-case
     '''
     data = request.json
 
-    if "use_case" not in data:
-        return Response(status=400, response=f"Field missing! Fields required: (use_case)")
+    if "internal" not in data:
+        return Response(status=400, response=f"Field missing! Fields required: (internal)")
+    
+    # check if schema contains mapping
+    schema = schema_repository.put(use_case)
+
+    if data["internal"] not in schema.mappings:
+        return Response(status=400, response=f'{data["internal"]} is not existent in the schema!')
 
-    layers = LayerAdapterService.all_for_use_case(use_case)
-    layers = [LayerAdapter.from_serializable_dict(d) for d in layers]
+    layers = layer_repository.all_for_use_case(use_case)
 
     for layer in layers:
-        layer.use_case = data["use_case"]
+        layer.add_mapping(data["internal"])
 
         try:
             LayerAdapterService.check_layer(layer)
         except ValueError as e:
             return Response(status = 400, response=f"{e}")
 
-        LayerAdapterService.update_use_case(layer, use_case)
+        layer_repository.update(layer)
 
     return Response(status=200)
 
@@ -223,15 +171,14 @@ def delete_mapping_for_all(use_case: str):
     if "internal" not in data:
         return Response(status=400, response=f"Field missing! Fields required: (internal)")
     
-    layers = LayerAdapterService.all_for_use_case(use_case)
-    layers = [LayerAdapter.from_serializable_dict(d) for d in layers]
+    layers = layer_repository.all_for_use_case(use_case)
 
     for layer in layers:
         try:
             layer.delete_mapping(data["internal"])
         except ValueError:
             continue
-        LayerAdapterService.update(layer)
+        layer_repository.update(layer)
 
     return Response(status=200)
 
@@ -243,7 +190,7 @@ def delete_mapping(name: str, use_case: str):
         name        - Required : unique identifier for the layer
         use_case    - Required : String-identifier for the use-case
     '''
-    layer = LayerAdapterService.one(name, use_case)
+    layer = layer_repository.one(name, use_case)
 
     if layer == None:
         return Response(status=404, response=f"Layer with name '{name}' does not exist!")
@@ -255,65 +202,39 @@ def delete_mapping(name: str, use_case: str):
 
     try:
         layer.delete_mapping(data["internal"])
-        LayerAdapterService.update(layer)
+        layer_repository.update(layer)
     except ValueError:
         return Response(status=400, response=f'{data["internal"]} is not a property of the layer!')
 
     return Response(status=200)
 
-
-def add_cluster_mapping(name: str, use_case: str):
+def add_mapping(name: str, use_case: str):
     '''
-    add a mapped property to the list of properties to cluster with
+    add a new mapping to the layer identified by name
 
     @params:
         name        - Required : unique identifier for the layer
         use_case    - Required : String-identifier for the use-case
     '''
-    layer = LayerAdapterService.one(name, use_case)
+    layer = layer_repository.one(name, use_case)
 
     if layer == None:
         return Response(status=404, response=f"Layer with name '{name}' does not exist!")
 
     data = request.json
 
-    if "attribute" not in data:
-        return Response(status=400, response=f"Field missing! Fields required: (attribute)")
-
-    try:
-        layer.add_cluster_mapping(data["attribute"])
-        LayerAdapterService.update(layer)
-        return Response(status=200)
-    except:
-        return Response(status=400, response=f'{data["attribute"]} is no attribute in the layer!')
-
-
-def delete_cluster_mapping(name: str, use_case: str):
-    '''
-    remove a mapped property from the list of properties to cluster with
-
-    @params:
-        name        - Required : unique identifier for the layer
-        use_case    - Required : String-identifier for the use-case
-    '''
-    layer = LayerAdapterService.one(name, use_case)
-
-    if layer == None:
-        return Response(status=404, response=f"Layer with name '{name}' does not exist!")
+    if "internal" not in data:
+        return Response(status=400, response=f"Field missing! Fields required: (internal)")
 
-    data = request.json
+    # check if schema contains mapping
+    schema = schema_repository.put(use_case)
+    if data["internal"] not in schema.mappings:
+        return Response(status=400, response=f'{data["internal"]} is not existent in the schema!')
 
-    if "attribute" not in data:
-        return Response(status=400, response=f"Field missing! Fields required: (attribute)")
+    layer.add_mapping(data["internal"])
+    layer_repository.update(layer)
 
-    try:
-        layer.delete_cluster_mapping(data["attribute"])
-        LayerAdapterService.update(layer)
     return Response(status=200)
-    except ValueError as e:
-        print(e)
-        return Response(status=400, response=f'{data["attribute"]} is no attribute in the layer!')
-
 
 def delete_one(name: str, use_case: str):
     '''
@@ -323,17 +244,17 @@ def delete_one(name: str, use_case: str):
         name        - Required : unique identifier for the layer
         use_case    - Required : String-identifier for the use-case
     '''
-    layer = LayerAdapterService.one(name, use_case)
+    layer = layer_repository.one(name, use_case)
 
     if layer == None:
         return Response(status=404, response=f"Layer with name '{name}' does not exist!")
 
-    LayerAdapterService.delete(layer)
+    layer_repository.delete_all_with_name_and_use_case(layer)
     return Response(status=200)
 
 def delete_all_layers():
     '''
     delete all layers from the DB
     '''
-    LayerAdapterService.delete_all_layers()
+    layer_repository.delete_all()
     return Response(status=200)
\ No newline at end of file

src/participation-hub/business-logic-microservice/app/routes/schema.py

+#global imports
+from db.entities.layer_adapter import LayerAdapter
+from db.schema_repository import SchemaRepository
+from services.layer_adapter_service import LayerAdapterService
+
+import json
+from flask import Response, request
+
+schema_repository = SchemaRepository()
+
+def all():
+    return [schema.to_serializable_dict() for schema in schema_repository.all()]
+
+def get_for_use_case(use_case:str):
+    schema = schema_repository.get_for_use_case(use_case)
+
+    if schema != None:
+        return Response(status=200, response=json.dumps(schema.to_serializable_dict()))
+    
+    return Response(status=404, response=f"Schema {use_case} does not exist")
+
+def delete_for_use_case(use_case:str):
+    schema = schema_repository.get_for_use_case(use_case)
+
+    if schema == None:
+        return Response(status=404, response=f"Schema {use_case} does not exist")
+    
+    schema_repository.delete_for_use_case(use_case)
+
+    return Response(status=200)
+
+def add_mapping(use_case:str):
+    data = request.json
+
+    if "internal" not in data or "external" not in data:
+        return Response(status=400, response=f"Field missing! Fields required: (internal, external)")
+    
+    schema = schema_repository.get_for_use_case(use_case)
+
+    if schema == None:
+        print("schema not there, creating it...")
+        schema = schema_repository.put(use_case)
+    
+    schema.add_mapping(data["internal"], data["external"])
+    schema_repository.update(schema)
+
+    return Response(status=200)
\ No newline at end of file

src/participation-hub/business-logic-microservice/app/routes/use_case.py

+from db.entities.layer_adapter import LayerAdapter
+from db.use_case_repository import UseCaseRepository
+from services.layer_adapter_service import LayerAdapterService
+
+import json
+from flask import Response, request
+
+use_case_repository = UseCaseRepository()
+
+def all():
+    return [adapter.to_serializable_dict() for adapter in use_case_repository.all()]
+
+def delete_all():
+    LayerAdapterService.delete_all()
+    return Response(status=200)
\ No newline at end of file

src/participation-hub/business-logic-microservice/app/services/layer_adapter_service.py

 #global imports
 from db.repository import Repository
+from db.schema_repository import SchemaRepository
+from db.use_case_repository import UseCaseRepository
 from db.entities.layer_adapter import LayerAdapter
 from db.entities.schema import Schema
 
 from typing import List
 
-
 class LayerAdapterService:
 
-    _repository = Repository()
-
-    @staticmethod
-    def all_schemas() -> List[Schema]:
-        return LayerAdapterService._repository.all_schemas()
-
-    @staticmethod
-    def schema_for_use_case(use_case: str):
-        LayerAdapterService._repository.put_use_case(use_case)
-        return LayerAdapterService._repository.schema_for_use_case(use_case)
-
-    @staticmethod
-    def put_schema(use_case: str):
-        schema = LayerAdapterService.schema_for_use_case(use_case)
-
-        if schema == None:
-            schema = Schema(use_case, mappings={})
-            LayerAdapterService._repository.add_schema(schema)
-        
-        return schema
+    _schema_repository = SchemaRepository()
+    _layer_repository = Repository()
+    _use_case_repository = UseCaseRepository()
     
     @staticmethod
     def check_layer(layer: LayerAdapter):
         '''
         checks if the given layer has correct mappings regarding the schema of the use_case
         '''
-        schema = LayerAdapterService.put_schema(layer.use_case)
+        schema = LayerAdapterService._schema_repository.put(layer.use_case)
         for p in layer.properties:
             if p not in schema.mappings:
                 raise ValueError(f'{p} is not existent in the schema!')
 
-    @staticmethod
-    def delete_schema(use_case:str):
-        LayerAdapterService._repository.delete_schema_with_use_case(use_case)
-
-    
-    @staticmethod
-    def update_schema(schema: Schema):
-        LayerAdapterService._repository.update_schema(schema)
-        
-    @staticmethod
-    def all_use_cases() -> List[str]:
-        return LayerAdapterService._repository.all_use_cases()
-    
-    @staticmethod
-    def delete_all_use_cases():
-        LayerAdapterService._repository.delete_all_use_cases()
-        LayerAdapterService._repository.delete_all_schemas()
-        LayerAdapterService._repository.delete_all_layers()
-    
-    @staticmethod
-    def delete_use_case(name:str):
-        LayerAdapterService._repository.delete_all_use_cases_with_name(name)
-
-    @staticmethod
-    def all() -> List[LayerAdapter]:
-        '''
-        Return all currently defined layers
-        '''
-        return LayerAdapterService._repository.all()
-    
-    @staticmethod
-    def all_for_use_case(use_case: str) -> List[LayerAdapter]:
-        '''
-        Return all currently defined layers that belong to the
-        given use-case
-        '''
-        return LayerAdapterService._repository.all_for_use_case(use_case)
-
-    @staticmethod
-    def update(layer: LayerAdapter):
-        '''
-        Overwrite the stored instance with the given one which is 
-        identified by the layer name
-
-        @params:
-            layer - Required : layer object holding the current data
-        '''
-        LayerAdapterService._repository.update(layer)
-
-    @staticmethod
-    def update_use_case(layer: LayerAdapter, use_case:str):
-        '''
-        Overwrite the stored instance with the given one which is 
-        identified by the layer name
-
-        @params:
-            layer - Required : layer object holding the current data
-        '''
-        LayerAdapterService._repository.update_use_case(layer, use_case)
-
-    @staticmethod
-    def add(name: str, use_case: str):
-        '''
-        Add a new layer to the DB. Attribute mapping and cluster
-        attributes will be empty per default
-
-        @params:
-            name        - Required : Unique name for a layer.
-            use_case    - Required : String-identifier for the use-case
-        '''
-        adapter_new = LayerAdapter(name, use_case, [], [])
-
-        LayerAdapterService._repository.add(adapter_new)
-
     @staticmethod
     def add_complete(layer: LayerAdapter):
         '''
-        Add a new layer to the DB. Attribute mappings and cluster
-        attributes of the given layer are used
+        Add a new layer to the DB. Attribute mappings and cluster attributes of the given layer
+        are used. Before inserting, the layer gets checked for consistency with the schema.
 
         @params:
             layer - Required : layer object holding correct data
         '''
-        LayerAdapterService._repository.add(layer)
-
-    @staticmethod
-    def delete(layer: LayerAdapter):
-        '''
-        delete all layers with the given name.
-
-        @params:
-            layer - Required : layer object to remove from the DB
-        '''
-        use_case = layer.use_case
-        LayerAdapterService._repository.delete_all_with_name_and_use_case(layer.name, use_case)
+        LayerAdapterService.check_layer(layer)
+        LayerAdapterService._layer_repository.add(layer)
     
     @staticmethod
-    def delete_all_layers():
-        LayerAdapterService._repository.delete_all_layers()
-
-    @staticmethod
-    def one(name: str, use_case: str) -> LayerAdapter:
-        '''
-        Retrieve a single layer from the DB. Returns None if no layer
-        was found under this name.
-
-         @params:
-            name        - Required : Unique name for a layer
-            use_case    - Required : String-identifier for the use-case
-        '''
-        result = LayerAdapterService._repository.one_by_name_and_usecase(name, use_case)
+    def delete_all_use_cases():
+        # TODO
+        LayerAdapterService._layer_repository.delete_all_use_cases()
+        LayerAdapterService._schema_repository.delete_all()
+        LayerAdapterService._use_case_repository.delete_all()
    
\ No newline at end of file
-        if len(result) == 1:
-            return LayerAdapter.from_serializable_dict(result[0])
-        else:
-            return None