Refactor device validation and update tests

- Replaced `UserDeviceService` with `UserDeviceEventsHistoryCRUD` for device validation.
- Added a new method `get_device` in `UserDeviceEventsHistoryCRUD`.
- Updated logic to validate devices based on event history.
- Modified test cases to align with the new device validation approach.
- Removed unused imports and code related to the old device service.

src/apps/answers/api.py

@@ -52,6 +52,7 @@
 from apps.applets.errors import InvalidVersionError, NotValidAppletHistory
 from apps.applets.service import AppletHistoryService, AppletService
 from apps.authentication.deps import get_current_user
+from apps.schedule.crud.user_device_events_history import UserDeviceEventsHistoryCRUD
 from apps.schedule.service.schedule_history import ScheduleHistoryService
 from apps.shared.deps import get_client_ip, get_i18n
 from apps.shared.domain import Response, ResponseMulti
@@ -61,7 +62,6 @@
 from apps.subjects.services import SubjectsService
 from apps.users import UsersCRUD
 from apps.users.domain import User
-from apps.users.services.user_device import UserDeviceService
 from apps.workspaces.domain.constants import Role
 from apps.workspaces.service.check_access import CheckAccessService
 from apps.workspaces.service.workspace import WorkspaceService
@@ -86,11 +86,6 @@ async def create_answer(
         except NotValidAppletHistory:
             raise InvalidVersionError()
 
-        if device_id:
-            device = await UserDeviceService(session, user.id).get_by_device_id(device_id)
-            if device is None or device.user_id != user.id:
-                raise NotFoundError("Invalid device_id provided")
-
         if schema.event_history_id:
             event = await ScheduleHistoryService(session).get_by_id(schema.event_history_id)
             if (
@@ -101,11 +96,21 @@ async def create_answer(
             ):
                 raise NotFoundError("Invalid event_history_id provided")
 
+        device = None
+        if device_id and schema.event_history_id:
+            event_id = uuid.UUID(schema.event_history_id.split("_")[0])
+            event_version = schema.event_history_id.split("_")[1]
+            device = await UserDeviceEventsHistoryCRUD(session).get_device(
+                device_id=device_id, user_id=user.id, event_id=event_id, event_version=event_version
+            )
+            if device is None:
+                raise NotFoundError("Invalid device_id provided")
+
         service = AnswerService(session, user.id, answer_session)
         if tz_offset is not None and schema.answer.tz_offset is None:
             schema.answer.tz_offset = tz_offset // 60  # value in minutes
         async with atomic(answer_session):
-            answer = await service.create_answer(schema, device_id)
+            answer = await service.create_answer(schema, device.device_id if device else None)
         await service.create_report_from_answer(answer)
 
 

src/apps/answers/tests/test_answers.py

@@ -36,7 +36,6 @@
 from apps.users import User
 from apps.users.cruds.user import UsersCRUD
 from apps.users.domain import AppInfoOS, UserCreate, UserDeviceCreate
-from apps.users.router import router as user_router
 from apps.users.tests.fixtures.users import _get_or_create_user
 from apps.workspaces.crud.user_applet_access import UserAppletAccessCRUD
 from apps.workspaces.db.schemas import UserAppletAccessSchema
@@ -837,9 +836,16 @@ async def test_create_answer__with_device_id_and_event_history_id(
     ):
         client.login(tom)
 
-        response = await client.post(
-            user_router.url_path_for("user_save_device"), data=device_create_data.dict(include={"device_id"})
+        response = await client.get(
+            url="/users/me/respondent/current_events",
+            headers={
+                "Device-Id": device_create_data.device_id,
+                "OS-Name": device_create_data.os.name,
+                "OS-Version": device_create_data.os.version,
+                "App-Version": device_create_data.app_version,
+            },
         )
+
         assert response.status_code == http.HTTPStatus.OK
 
         data = answer_create.copy(deep=True)
@@ -862,10 +868,13 @@ async def test_create_answer_with_wrong_event_history_id(
         assert response.json()["result"][0]["message"] == "Invalid event_history_id provided"
 
     async def test_create_answer_with_wrong_device_id(
-        self, client: TestClient, tom: User, answer_create: AppletAnswerCreate
+        self, client: TestClient, tom: User, answer_create: AppletAnswerCreate, applet_default_events
     ):
         client.login(tom)
         data = answer_create.copy(deep=True)
+        event = next((event for event in applet_default_events if event.activity_id == answer_create.activity_id), None)
+        assert event
+        data.event_history_id = f"{event.id}_{event.version}"
         response = await client.post(self.answer_url, data=data, headers={"Device-Id": "wrong_device_id"})
 
         assert response.status_code == http.HTTPStatus.NOT_FOUND

src/apps/schedule/crud/user_device_events_history.py

@@ -17,6 +17,22 @@ def __init__(self, session):
         super().__init__(session)
         self.schema_class = UserDeviceEventsHistorySchema
 
+    async def get_device(
+        self,
+        device_id: str,
+        user_id: uuid.UUID,
+        event_id: uuid.UUID,
+        event_version: str,
+    ) -> UserDeviceEventsHistorySchema:
+        query: Query = select(UserDeviceEventsHistorySchema)
+        query = query.where(UserDeviceEventsHistorySchema.device_id == device_id)
+        query = query.where(UserDeviceEventsHistorySchema.user_id == user_id)
+        query = query.where(UserDeviceEventsHistorySchema.event_id == event_id)
+        query = query.where(UserDeviceEventsHistorySchema.event_version == event_version)
+
+        result = await self._execute(query)
+        return result.scalars().first()
+
     async def record_event_versions(
         self,
         user_id: uuid.UUID,