dev-2.2

grisera/__init__.py

@@ -6,6 +6,10 @@
 from .activity_execution.activity_execution_router import ActivityExecutionRouter, router as activity_execution_router
 from .activity_execution.activity_execution_service import ActivityExecutionService
 
+from .additional_parameter.additional_parameter_model import *
+from .additional_parameter.additional_parameter_router import AdditionalParameterRouter, router as additional_parameter_router
+from .additional_parameter.additional_parameter_service import AdditionalParameterService
+
 from .appearance.appearance_model import *
 from .appearance.appearance_router import AppearanceRouter, router as appearance_router
 from .appearance.appearance_service import AppearanceService
@@ -26,6 +30,10 @@
 from .experiment.experiment_router import ExperimentRouter, router as experiment_router
 from .experiment.experiment_service import ExperimentService
 
+from .file.file_model import *
+from .file.file_router import FileRouter, router as file_router
+from .file.file_service import FileService
+
 from .helpers.hateoas import prepare_links, get_links
 from .helpers.helpers import create_stub_from_response
 
@@ -46,6 +54,7 @@
 from .modality.modality_service import ModalityService
 
 from .models.base_model_out import BaseModelOut
+from .models.importable_model import ImportableModel
 from .models.not_found_model import NotFoundByIdModel
 from .models.relation_information_model import RelationInformation
 

grisera/activity/activity_model.py

@@ -4,6 +4,7 @@
 from pydantic import BaseModel
 
 from grisera.models.base_model_out import BaseModelOut
+from grisera.models.importable_model import ImportableModel
 from grisera.property.property_model import PropertyIn
 
 
@@ -23,7 +24,7 @@ class Activity(str, Enum):
     group = "group"
 
 
-class ActivityPropertyIn(BaseModel):
+class ActivityPropertyIn(ImportableModel):
     """
         Model of activity execution to acquire from client
 

grisera/activity_execution/activity_execution_model.py

@@ -3,10 +3,11 @@
 from pydantic import BaseModel
 
 from grisera.models.base_model_out import BaseModelOut
+from grisera.models.importable_model import ImportableModel
 from grisera.property.property_model import PropertyIn
 
 
-class ActivityExecutionPropertyIn(BaseModel):
+class ActivityExecutionPropertyIn(ImportableModel):
     """
     Model of activity execution to acquire from client
 

grisera/additional_parameter/additional_parameter_model.py

@@ -0,0 +1,71 @@
+from enum import Enum
+from typing import Optional, Union, List
+
+from pydantic import BaseModel
+
+from grisera.models.base_model_out import BaseModelOut
+
+
+class ParameterType(str, Enum):
+    """
+    Types of additional parameters
+
+    Attributes:
+        participant (str): Parameter for participants
+        activity (str): Parameter for activities
+        participant_state (str): Parameter for participant states
+        activity_execution (str): Parameter for activity executions
+    """
+
+    participant = "participant"
+    activity = "activity"
+    participant_state = "participantState"
+    activity_execution = "activityExecution"
+
+
+class AdditionalParameterIn(BaseModel):
+    """
+    Model of additional parameter to acquire from client
+
+    Attributes:
+        name (str): Name of the parameter
+        key (Optional[str]): Key identifier for the parameter
+        type (ParameterType): Type of parameter (participant, activity, etc.)
+        options (Optional[List[str]]): Available options for the parameter
+    """
+
+    name: str
+    key: Optional[str]
+    type: ParameterType
+    options: Optional[List[str]] = []
+
+
+class BasicAdditionalParameterOut(AdditionalParameterIn):
+    """
+    Basic model of additional parameter to send to client as a result of request
+
+    Attributes:
+        id (Optional[int | str]): Id of parameter returned from api
+        dataset_id (Optional[int | str]): Id of dataset this parameter belongs to
+    """
+
+    id: Optional[Union[int, str]]
+    dataset_id: Optional[Union[int, str]]
+
+
+class AdditionalParameterOut(BasicAdditionalParameterOut, BaseModelOut):
+    """
+    Model of additional parameter with relationships to send to client as a result of request
+    """
+    pass
+
+
+class AdditionalParametersOut(BaseModelOut):
+    """
+    Model of additional parameters to send to client as a result of request
+
+    Attributes:
+        parameters (List[BasicAdditionalParameterOut]): Parameters from database
+    """
+
+    parameters: List[BasicAdditionalParameterOut] = []

grisera/additional_parameter/additional_parameter_router.py

@@ -0,0 +1,126 @@
+from typing import Union
+
+from fastapi import Response, Depends
+from fastapi_utils.cbv import cbv
+from fastapi_utils.inferring_router import InferringRouter
+
+from grisera.additional_parameter.additional_parameter_model import (
+    AdditionalParameterIn,
+    AdditionalParameterOut,
+    AdditionalParametersOut,
+)
+from grisera.helpers.hateoas import get_links
+from grisera.helpers.helpers import check_dataset_permission
+from grisera.models.not_found_model import NotFoundByIdModel
+from grisera.services.service import service
+from grisera.services.service_factory import ServiceFactory
+
+router = InferringRouter(dependencies=[Depends(check_dataset_permission)])
+
+
+@cbv(router)
+class AdditionalParameterRouter:
+    """
+    Class for routing additional parameter based requests
+
+    Attributes:
+        additional_parameter_service (AdditionalParameterService): Service instance for additional parameters
+    """
+
+    def __init__(self, service_factory: ServiceFactory = Depends(service.get_service_factory)):
+        self.additional_parameter_service = service_factory.get_additional_parameter_service()
+
+    @router.post("/parameters", tags=["parameters"], response_model=AdditionalParameterOut)
+    async def create_parameter(self, parameter: AdditionalParameterIn, response: Response, dataset_id: Union[int, str]):
+        """
+        Create additional parameter in database
+        """
+
+        create_response = self.additional_parameter_service.save_additional_parameter(parameter, dataset_id)
+        if create_response.errors is not None:
+            response.status_code = 422
+
+        # add links from hateoas
+        create_response.links = get_links(router)
+
+        return create_response
+
+    @router.get("/parameters", tags=["parameters"], response_model=AdditionalParametersOut)
+    async def get_parameters(self, response: Response, dataset_id: Union[int, str]):
+        """
+        Get additional parameters from database
+        """
+
+        get_response = self.additional_parameter_service.get_additional_parameters(dataset_id)
+
+        # add links from hateoas
+        get_response.links = get_links(router)
+
+        return get_response
+
+    @router.get(
+        "/parameters/{parameter_id}",
+        tags=["parameters"],
+        response_model=Union[AdditionalParameterOut, NotFoundByIdModel],
+    )
+    async def get_parameter(
+            self, parameter_id: Union[str, int], response: Response, dataset_id: Union[int, str]
+    ):
+        """
+        Get additional parameter from database
+        """
+
+        get_response = self.additional_parameter_service.get_additional_parameter(parameter_id, dataset_id)
+        if get_response.errors is not None:
+            response.status_code = 404
+
+        # add links from hateoas
+        get_response.links = get_links(router)
+
+        return get_response
+
+    @router.delete(
+        "/parameters/{parameter_id}",
+        tags=["parameters"],
+        response_model=Union[AdditionalParameterOut, NotFoundByIdModel],
+    )
+    async def delete_parameter(
+            self, parameter_id: Union[int, str], response: Response, dataset_id: Union[int, str]
+    ):
+        """
+        Delete additional parameter from database
+        """
+        delete_response = self.additional_parameter_service.delete_additional_parameter(parameter_id, dataset_id)
+        if delete_response.errors is not None:
+            response.status_code = 404
+
+        # add links from hateoas
+        delete_response.links = get_links(router)
+
+        return delete_response
+
+    @router.put(
+        "/parameters/{parameter_id}",
+        tags=["parameters"],
+        response_model=Union[AdditionalParameterOut, NotFoundByIdModel],
+    )
+    async def update_parameter(
+            self,
+            parameter_id: Union[int, str],
+            parameter: AdditionalParameterIn,
+            response: Response,
+            dataset_id: Union[int, str]
+    ):
+        """
+        Update additional parameter model in database
+        """
+        update_response = self.additional_parameter_service.update_additional_parameter(
+            parameter_id, parameter, dataset_id
+        )
+        if update_response.errors is not None:
+            response.status_code = 404
+
+        # add links from hateoas
+        update_response.links = get_links(router)
+
+        return update_response

grisera/additional_parameter/additional_parameter_service.py

@@ -0,0 +1,87 @@
+from typing import Union
+
+from grisera.additional_parameter.additional_parameter_model import AdditionalParameterIn
+
+
+class AdditionalParameterService:
+    """
+    Abstract class to handle logic of additional parameters requests
+
+    """
+
+    def save_additional_parameter(self, parameter: AdditionalParameterIn, dataset_id: Union[int, str]):
+        """
+        Send request to database to create new additional parameter
+
+        Args:
+            parameter (AdditionalParameterIn): Additional parameter to be added
+            dataset_id (int | str): name of dataset
+
+        Returns:
+            Result of request as additional parameter object
+        """
+        raise Exception("save_additional_parameter not implemented yet")
+
+    def get_additional_parameters(self, dataset_id: Union[int, str]):
+        """
+        Send request to database to get additional parameters
+
+        Args:
+            dataset_id (int | str): name of dataset
+
+        Returns:
+            Result of request as list of additional parameters objects
+        """
+        raise Exception("get_additional_parameters not implemented yet")
+
+    def get_additional_parameter(self, parameter_id: Union[int, str], dataset_id: Union[int, str]):
+        """
+        Send request to database to get given additional parameter
+
+        Args:
+            parameter_id (int | str): identity of additional parameter
+            dataset_id (int | str): name of dataset
+
+        Returns:
+            Result of request as additional parameter object
+        """
+        raise Exception("get_additional_parameter not implemented yet")
+
+    def delete_additional_parameter(self, parameter_id: Union[int, str], dataset_id: Union[int, str]):
+        """
+        Send request to database to delete given additional parameter
+
+        Args:
+            parameter_id (int | str): identity of additional parameter
+            dataset_id (int | str): name of dataset
+
+        Returns:
+            Result of request as additional parameter object
+        """
+        raise Exception("delete_additional_parameter not implemented yet")
+
+    def update_additional_parameter(self, parameter_id: Union[int, str], parameter: AdditionalParameterIn, dataset_id: Union[int, str]):
+        """
+        Send request to database to update given additional parameter
+
+        Args:
+            parameter_id (int | str): identity of additional parameter
+            parameter (AdditionalParameterIn): Properties to update
+            dataset_id (int | str): name of dataset
+
+        Returns:
+            Result of request as additional parameter object
+        """
+        raise Exception("update_additional_parameter not implemented yet")
+
+    def get_additional_parameters_by_dataset(self, dataset_id: Union[int, str]):
+        """
+        Send request to database to get additional parameters for given dataset
+
+        Args:
+            dataset_id (int | str): name of dataset
+
+        Returns:
+            Result of request as list of additional parameters objects
+        """
+        raise Exception("get_additional_parameters_by_dataset not implemented yet")

grisera/appearance/appearance_model.py

@@ -20,11 +20,13 @@ class AppearanceOcclusionIn(BaseModel):
         glasses (bool): Does appearance contain glasses
         beard (FacialHair): Length of beard
         moustache (FacialHair): Length of moustache
+        external_id (Optional[str]): External ID from source system
     """
 
     beard: FacialHair
     moustache: FacialHair
     glasses: bool
+    external_id: Optional[str]
 
 
 class BasicAppearanceOcclusionOut(AppearanceOcclusionIn):
@@ -58,12 +60,14 @@ class AppearanceSomatotypeIn(BaseModel):
         ectomorph (float): Range of ectomorph appearance measure
         endomorph (float): Range of endomorph appearance measure
         mesomorph (float): Range of mesomorph appearance measure
+        external_id (Optional[str]): External ID from source system
 
     """
 
     ectomorph: float
     endomorph: float
     mesomorph: float
+    external_id: Optional[str]
 
 
 class BasicAppearanceSomatotypeOut(AppearanceSomatotypeIn):