Tt 180 create method get activities by id list in activitydao

tests/conftest.py

@@ -14,6 +14,9 @@
 from time_tracker_api.time_entries.time_entries_repository import (
     TimeEntryCosmosDBRepository,
 )
+from time_tracker_api.activities.activities_model import (
+    ActivityCosmosDBRepository,
+)
 
 fake = Faker()
 Faker.seed()
@@ -84,11 +87,7 @@ def cosmos_db_model():
     return {
         'id': 'test',
         'partition_key': PartitionKey(path='/tenant_id'),
-        'unique_key_policy': {
-            'uniqueKeys': [
-                {'paths': ['/email']},
-            ]
-        },
+        'unique_key_policy': {'uniqueKeys': [{'paths': ['/email']},]},
     }
 
 
@@ -222,6 +221,24 @@ def running_time_entry(
     )
 
 
+@pytest.fixture(scope="module")
+def activity_repository(app: Flask) -> ActivityCosmosDBRepository:
+    with app.app_context():
+        from commons.data_access_layer.cosmos_db import init_app, cosmos_helper
+
+        if cosmos_helper is None:
+            init_app(app)
+
+    return ActivityCosmosDBRepository()
+
+
+@pytest.fixture
+def activities_dao():
+    from time_tracker_api.activities.activities_model import create_dao
+
+    return create_dao()
+
+
 @pytest.fixture(scope="session")
 def valid_jwt(app: Flask, tenant_id: str, owner_id: str) -> str:
     with app.app_context():

tests/time_tracker_api/activities/activities_model_test.py

@@ -0,0 +1,98 @@
+from unittest.mock import Mock, patch
+import pytest
+
+from commons.data_access_layer.database import EventContext
+from time_tracker_api.activities.activities_model import (
+    ActivityCosmosDBRepository,
+    ActivityCosmosDBModel,
+)
+
+
+@pytest.mark.parametrize(
+    "id_list", [123, (1, 2), "id_list", {"id_list": []},],
+)
+def test_validate_list(
+    id_list, activity_repository: ActivityCosmosDBRepository
+):
+    try:
+        activity_repository.validate_list(id_list)
+    except Exception as e:
+        assert type(e) is AssertionError
+
+
+@patch(
+    'time_tracker_api.activities.activities_model.ActivityCosmosDBRepository.validate_list'
+)
+@pytest.mark.parametrize(
+    "id_list,expected_result",
+    [
+        (["id1"], "('id1')"),
+        (["id1", "id2"], "('id1', 'id2')"),
+        (["id1", "id2", "id3", "id4"], "('id1', 'id2', 'id3', 'id4')"),
+    ],
+)
+def test_convert_list_to_tuple_string(
+    validate_list_mock,
+    activity_repository: ActivityCosmosDBRepository,
+    id_list,
+    expected_result,
+):
+    result = activity_repository.convert_list_to_tuple_string(id_list)
+
+    validate_list_mock.assert_called_once()
+    assert expected_result == result
+
+
+@pytest.mark.parametrize(
+    "id_list,expected_result",
+    [
+        (["id1"], "c.id IN ('id1')"),
+        (["id1", "id2"], "c.id IN ('id1', 'id2')"),
+        (["id1", "id2", "id3", "id4"], "c.id IN ('id1', 'id2', 'id3', 'id4')"),
+    ],
+)
+def test_create_sql_in_condition(
+    activity_repository: ActivityCosmosDBRepository, id_list, expected_result,
+):
+    result = activity_repository.create_sql_in_condition(id_list)
+    assert expected_result == result
+
+
+@patch(
+    'time_tracker_api.activities.activities_model.ActivityCosmosDBRepository.create_sql_condition_for_visibility'
+)
+@patch(
+    'time_tracker_api.activities.activities_model.ActivityCosmosDBRepository.create_sql_in_condition'
+)
+@patch(
+    'time_tracker_api.activities.activities_model.ActivityCosmosDBRepository.find_partition_key_value'
+)
+def test_find_all_with_id_in_list(
+    find_partition_key_value_mock,
+    create_sql_in_condition_mock,
+    create_sql_condition_for_visibility_mock,
+    event_context: EventContext,
+    activity_repository: ActivityCosmosDBRepository,
+):
+    expected_item = {
+        'id': 'id1',
+        'name': 'testing',
+        'description': 'do some testing',
+        'tenant_id': 'tenantid1',
+    }
+
+    query_items_mock = Mock(return_value=[expected_item])
+    activity_repository.container = Mock()
+    activity_repository.container.query_items = query_items_mock
+
+    result = activity_repository.find_all_with_id_in_list(event_context, [])
+
+    create_sql_condition_for_visibility_mock.assert_called_once()
+    create_sql_in_condition_mock.assert_called_once()
+    find_partition_key_value_mock.assert_called_once()
+    query_items_mock.assert_called_once()
+
+    assert len(result) == 1
+    activity = result[0]
+    assert isinstance(activity, ActivityCosmosDBModel)
+    assert activity.__dict__ == expected_item

time_tracker_api/activities/activities_model.py

@@ -2,8 +2,14 @@
 
 from azure.cosmos import PartitionKey
 
-from commons.data_access_layer.cosmos_db import CosmosDBModel, CosmosDBDao, CosmosDBRepository
+from commons.data_access_layer.cosmos_db import (
+    CosmosDBModel,
+    CosmosDBDao,
+    CosmosDBRepository,
+)
 from time_tracker_api.database import CRUDDao, APICosmosDBDao
+from typing import List, Callable
+from commons.data_access_layer.database import EventContext
 
 
 class ActivityDao(CRUDDao):
@@ -13,11 +19,7 @@ class ActivityDao(CRUDDao):
 container_definition = {
     'id': 'activity',
     'partition_key': PartitionKey(path='/tenant_id'),
-    'unique_key_policy': {
-        'uniqueKeys': [
-            {'paths': ['/name', '/deleted']},
-        ]
-    }
+    'unique_key_policy': {'uniqueKeys': [{'paths': ['/name', '/deleted']},]},
 }
 
 
@@ -39,12 +41,72 @@ def __str___(self):
         return "the activity \"%s\"" % self.name  # pragma: no cover
 
 
-def create_dao() -> ActivityDao:
-    repository = CosmosDBRepository.from_definition(container_definition,
-                                                    mapper=ActivityCosmosDBModel)
+class ActivityCosmosDBRepository(CosmosDBRepository):
+    def __init__(self):
+        CosmosDBRepository.__init__(
+            self,
+            container_id=container_definition['id'],
+            partition_key_attribute='tenant_id',
+            mapper=ActivityCosmosDBModel,
+        )
+
+    def create_sql_in_condition(self, id_list):
+        id_values = self.convert_list_to_tuple_string(id_list)
+
+        return "c.id IN {value_condition}".format(value_condition=id_values)
+
+    def convert_list_to_tuple_string(self, id_list):
+        self.validate_list(id_list)
+        id_value = (
+            f"('{id_list[0]}')" if len(id_list) == 1 else str(tuple(id_list))
+        )
+        return id_value
+
+    def validate_list(self, id_list):
+        assert isinstance(id_list, list)
+        assert len(id_list) > 0
+
+    def find_all_with_id_in_list(
+        self,
+        event_context: EventContext,
+        id_list: List[str],
+        visible_only=True,
+        mapper: Callable = None,
+    ):
+        visibility = self.create_sql_condition_for_visibility(visible_only)
+        query_str = """
+            SELECT * FROM c
+            WHERE {condition}
+            {visibility_condition}
+            """.format(
+            condition=self.create_sql_in_condition(id_list),
+            visibility_condition=visibility,
+        )
+
+        tenant_id_value = self.find_partition_key_value(event_context)
+        result = self.container.query_items(
+            query=query_str, partition_key=tenant_id_value,
+        )
 
-    class ActivityCosmosDBDao(APICosmosDBDao, ActivityDao):
-        def __init__(self):
-            CosmosDBDao.__init__(self, repository)
+        function_mapper = self.get_mapper_or_dict(mapper)
+        return list(map(function_mapper, result))
+
+
+class ActivityCosmosDBDao(APICosmosDBDao, ActivityDao):
+    def __init__(self, repository):
+        CosmosDBDao.__init__(self, repository)
+
+    def get_all_with_id_in_list(
+        self, id_list,
+    ):
+        event_ctx = self.create_event_context("read-many")
+        activities_list = self.repository.find_all_with_id_in_list(
+            event_ctx, id_list,
+        )
+        return activities_list
+
+
+def create_dao() -> ActivityDao:
+    repository = ActivityCosmosDBRepository()
 
-    return ActivityCosmosDBDao()
+    return ActivityCosmosDBDao(repository)