Create endpoint for checking LORIS integration - retrieve server configuration (M2-7429)

src/apps/answers/domain/answers.py

@@ -175,8 +175,7 @@ class SubmissionDate(PublicModel):
     end_datetime: datetime.datetime
 
 
-class ReviewFlow(ReviewItem[SubmissionDate]):
-    ...
+class ReviewFlow(ReviewItem[SubmissionDate]): ...
 
 
 class PublicReviewFlow(ReviewFlow):

src/apps/integrations/api/integrations.py

@@ -1,9 +1,9 @@
+import uuid
+
 from fastapi import Body, Depends
 
 from apps.authentication.deps import get_current_user
 from apps.integrations.domain import Integration, IntegrationFilter
-from apps.integrations.loris.domain.loris_integrations import IntegrationsCreate
-from apps.integrations.loris.domain.loris_projects import LorisProjects
 from apps.integrations.service import IntegrationService
 from apps.shared.domain import ResponseMulti
 from apps.shared.query_params import QueryParams, parse_query_params
@@ -12,7 +12,7 @@
 from infrastructure.database import atomic
 from infrastructure.database.deps import get_session
 
-__all__ = ["enable_integration", "disable_integration", "create_integration"]
+__all__ = ["enable_integration", "disable_integration", "create_integration", "retrieve_integration"]
 
 
 async def enable_integration(
@@ -35,11 +35,23 @@ async def disable_integration(
 
 
 async def create_integration(
+    session=Depends(get_session),
+    user: User = Depends(get_current_user),
+    integrationsCreate: Integration = Body(...),
+) -> Integration:
+    await CheckAccessService(session, user.id).check_integrations_access(
+        integrationsCreate.applet_id
+    )
+    async with atomic(session):
+        return await IntegrationService(session, user).create_integration(integrationsCreate)
+
+
+async def retrieve_integration(
     type: str,
+    applet_id: uuid.UUID,
     session=Depends(get_session),
     user: User = Depends(get_current_user),
-    params: IntegrationsCreate = Body(...),
-) -> LorisProjects:
-    await CheckAccessService(session, user.id).check_integrations_create_access(params.applet_id, type)
+) -> Integration:
+    await CheckAccessService(session, user.id).check_integrations_access(applet_id)
     async with atomic(session):
-        return await IntegrationService(session, user).create_integration(type, params)
+        return await IntegrationService(session, user).retrieve_integration(applet_id, type)

src/apps/integrations/crud/integrations.py

@@ -1,3 +1,5 @@
+from sqlalchemy import select
+from sqlalchemy.engine import Result
 from sqlalchemy.exc import IntegrityError
 
 from apps.integrations.db.schemas import IntegrationsSchema
@@ -20,3 +22,11 @@ async def create(self, schema: IntegrationsSchema) -> IntegrationsSchema:
                 type=schema.type, applet_id=schema.applet_id
             )
         return new_integrations
+
+    async def retrieve(self, schema: IntegrationsSchema) -> IntegrationsSchema:
+        query = select(IntegrationsSchema)
+        query = query.where(IntegrationsSchema.applet_id == schema.applet_id)
+        query = query.where(IntegrationsSchema.type == schema.type)
+        query = query.limit(1)
+        result: Result = await self._execute(query)
+        return result.scalars().first()

src/apps/integrations/domain.py

@@ -1,14 +1,60 @@
+import json
+import uuid
 from enum import Enum
 
-from apps.shared.domain import InternalModel
+from apps.integrations.db.schemas import IntegrationsSchema
+from apps.integrations.loris.domain.loris_integrations import LorisIntegration, LorisIntegrationPublic
+from apps.shared.domain import InternalModel, PublicModel
 
 
 class AvailableIntegrations(str, Enum):
     LORIS = "LORIS"
+    FUTURE = "FUTURE"
+
+
+class FutureIntegration(InternalModel):
+    endpoint: str
+    api_key: str
+
+    @classmethod
+    def from_schema(cls, schema: IntegrationsSchema):
+        new_future_integration_dict = json.loads(schema.configuration.replace("'", '"'))
+        new_future_integration = cls(
+            endpoint=new_future_integration_dict["endpoint"],
+            api_key=new_future_integration_dict["api_key"],
+        )
+        return new_future_integration
+
+    def __repr__(self):
+        return "FutureIntegration()"
+
+
+class FutureIntegrationPublic(PublicModel):
+    endpoint: str
+
+    @classmethod
+    def from_schema(cls, schema: IntegrationsSchema):
+        new_future_integration_dict = json.loads(schema.configuration.replace("'", '"'))
+        new_future_integration = cls(
+            endpoint=new_future_integration_dict["endpoint"],
+        )
+        return new_future_integration
+
+    def __repr__(self):
+        return "FutureIntegrationPublic()"
 
 
 class Integration(InternalModel):
     integration_type: AvailableIntegrations
+    applet_id: uuid.UUID
+    configuration: FutureIntegrationPublic | LorisIntegrationPublic | FutureIntegration | LorisIntegration
+
+    @classmethod
+    def from_schema(cls, schema: IntegrationsSchema):
+        new_integration = cls(
+            applet_id=schema.applet_id, integration_type=schema.type, configuration=schema.configuration
+        )
+        return new_integration
 
 
 class IntegrationFilter(InternalModel):

src/apps/integrations/errors.py

@@ -11,5 +11,16 @@ class IntegrationsConfigurationsTypeAlreadyAssignedToAppletError(ValidationError
     message = _("Provided Integration Type `{type}` has previously been tied to applet `{applet_id}`.")
 
 
+class UnexpectedPropertiesForIntegration(ValidationError):
+    message = _(
+        """Provided configurations `{provided_keys}` for Integration Type `{type}` were not expected.
+ Expected keys are: `{expected_keys}`"""
+    )
+
+
 class UnsupportedIntegrationError(ValidationError):
     message = _("The specified integration type `{type}` is not supported")
+
+
+class UnavailableIntegrationError(ValidationError):
+    message = _("The specified integration type `{type}` does not exist for applet `{applet_id}`")

src/apps/integrations/loris/api/applets.py

@@ -7,16 +7,13 @@
 from apps.answers.deps.preprocess_arbitrary import get_answer_session
 from apps.authentication.deps import get_current_user
 from apps.integrations.loris.domain.domain import PublicListOfVisits, UploadableAnswersResponse, VisitsForUsers
+from apps.integrations.loris.domain.loris_projects import LorisProjects
 from apps.integrations.loris.service.loris import LorisIntegrationService
 from apps.users.domain import User
 from apps.workspaces.service.check_access import CheckAccessService
 from infrastructure.database.deps import get_session
 
-__all__ = [
-    "start_transmit_process",
-    "visits_list",
-    "users_info_with_visits",
-]
+__all__ = ["start_transmit_process", "visits_list", "users_info_with_visits", "get_loris_projects"]
 
 
 async def integration(applet_id: uuid.UUID, session, user, users_and_visits):
@@ -59,3 +56,15 @@ async def users_info_with_visits(
     # TODO move to worker
     info, count = await loris_service.get_uploadable_answers()
     return UploadableAnswersResponse(result=info, count=count)
+
+
+async def get_loris_projects(
+    hostname: str,
+    username: str,
+    password: str,
+    user: User = Depends(get_current_user),
+    session=Depends(get_session),
+) -> LorisProjects:
+    return await LorisIntegrationService(
+        uuid.UUID("00000000-0000-0000-0000-000000000000"), session=session, user=user
+    ).get_loris_projects(hostname, username, password)

src/apps/integrations/loris/domain/loris_integrations.py

@@ -1,29 +1,44 @@
-import uuid
+import json
 
 from apps.integrations.db.schemas import IntegrationsSchema
-from apps.integrations.domain import AvailableIntegrations
-from apps.shared.domain import InternalModel
+from apps.shared.domain import InternalModel, PublicModel
 
 
-class IntegrationMeta(InternalModel):
+class LorisIntegration(InternalModel):
     hostname: str
     username: str
-    password: str
-    project: str | None
-
-
-class Integrations(InternalModel):
-    applet_id: uuid.UUID
-    type: AvailableIntegrations
-    configuration: IntegrationMeta
+    password: str | None
+    project: str
 
     @classmethod
     def from_schema(cls, schema: IntegrationsSchema):
-        return cls(applet_id=schema.applet_id, type=schema.type, configuration=schema.configuration)
+        new_loris_integration_dict = json.loads(schema.configuration.replace("'", '"'))
+        new_loris_integration = cls(
+            hostname=new_loris_integration_dict["hostname"],
+            username=new_loris_integration_dict["username"],
+            password=new_loris_integration_dict["password"],
+            project=new_loris_integration_dict["project"],
+        )
+        return new_loris_integration
+
+    def __repr__(self):
+        return "LorisIntegration()"
 
 
-class IntegrationsCreate(InternalModel):
-    applet_id: uuid.UUID
+class LorisIntegrationPublic(PublicModel):
     hostname: str
     username: str
-    password: str
+    project: str
+
+    @classmethod
+    def from_schema(cls, schema: IntegrationsSchema):
+        new_loris_integration_dict = json.loads(schema.configuration.replace("'", '"'))
+        new_loris_integration = cls(
+            hostname=new_loris_integration_dict["hostname"],
+            username=new_loris_integration_dict["username"],
+            project=new_loris_integration_dict["project"],
+        )
+        return new_loris_integration
+
+    def __repr__(self):
+        return "LorisIntegrationPublic()"

src/apps/integrations/loris/router.py

@@ -1,14 +1,15 @@
 from fastapi.routing import APIRouter
 from starlette import status
 
-from apps.integrations.loris.api import start_transmit_process, users_info_with_visits, visits_list
+from apps.integrations.loris.api import get_loris_projects, start_transmit_process, users_info_with_visits, visits_list
 from apps.integrations.loris.api.consent import (
     consent_create,
     consent_get_by_id,
     consent_get_by_user_id,
     consent_update,
 )
 from apps.integrations.loris.domain.domain import PublicConsent, PublicListOfVisits, UploadableAnswersResponse
+from apps.integrations.loris.domain.loris_projects import LorisProjects
 from apps.shared.domain import Response
 from apps.shared.domain.response import (
     AUTHENTICATION_ERROR_RESPONSES,
@@ -105,3 +106,14 @@
         **AUTHENTICATION_ERROR_RESPONSES,
     },
 )(users_info_with_visits)
+
+
+router.get(
+    "/projects",
+    status_code=status.HTTP_200_OK,
+    responses={
+        status.HTTP_200_OK: {"model": LorisProjects},
+        **DEFAULT_OPENAPI_RESPONSE,
+        **AUTHENTICATION_ERROR_RESPONSES,
+    },
+)(get_loris_projects)

src/apps/integrations/loris/service/loris.py

@@ -19,6 +19,8 @@
 from apps.answers.errors import ReportServerError
 from apps.answers.service import ReportServerService
 from apps.applets.crud.applets_history import AppletHistoriesCRUD
+from apps.integrations.crud.integrations import IntegrationsCRUD, IntegrationsSchema
+from apps.integrations.domain import AvailableIntegrations
 from apps.integrations.loris.crud.user_relationship import MlLorisUserRelationshipCRUD
 from apps.integrations.loris.db.schemas import MlLorisUserRelationshipSchema
 from apps.integrations.loris.domain.domain import (
@@ -29,7 +31,10 @@
     UploadableAnswersData,
     UserVisits,
 )
+from apps.integrations.loris.domain.loris_integrations import LorisIntegration, LorisIntegrationPublic
+from apps.integrations.loris.domain.loris_projects import LorisProjects
 from apps.integrations.loris.errors import LorisServerError
+from apps.integrations.loris.service.loris_client import LorisClient
 from apps.subjects.crud import SubjectsCrud
 from apps.users.domain import User
 from apps.workspaces.crud.user_applet_access import UserAppletAccessCRUD
@@ -55,6 +60,7 @@ def __init__(self, applet_id: uuid.UUID, session, user: User, answer_session=Non
         self.applet_id = applet_id
         self.session = session
         self.user = user
+        self.type = AvailableIntegrations.LORIS
         self._answer_session = answer_session
 
     @property
@@ -271,7 +277,7 @@ async def _prepare_answers(self, users_answers: dict, activities: dict):
                         answers_for_loris_by_respondent[user].update(answers_for_loris)
         return answers_for_loris_by_respondent
 
-    async def _ml_answer_to_loris(
+    async def _ml_answer_to_loris(  # noqa: C901
         self, answer_id: str, activity_id: str, version: str, items: list, data: list
     ) -> dict:
         loris_answers: dict = {}
@@ -853,3 +859,23 @@ async def _create_integration_alerts(self, applet_id: uuid.UUID, message: str):
             except Exception as e:
                 sentry_sdk.capture_exception(e)
                 break
+
+    async def create_loris_integration(self, hostname, username, project) -> LorisIntegration:
+        integration_schema = await IntegrationsCRUD(self.session).create(
+            IntegrationsSchema(
+                applet_id=self.applet_id,
+                type=self.type,
+                configuration={
+                    "hostname": hostname,
+                    "username": username,
+                    "project": project,
+                },
+            )
+        )
+        return LorisIntegrationPublic.from_schema(integration_schema)
+
+    async def get_loris_projects(self, hostname, username, password) -> LorisProjects:
+        token = await LorisClient.login_to_loris(hostname, username, password)
+        projects_raw = await LorisClient.list_projects(hostname, token)
+        projects = list(projects_raw["Projects"].keys())
+        return LorisProjects(projects=projects)