Close #58 Create time entry model for Cosmos DB

Author: EliuX

README.md

@@ -9,6 +9,7 @@ This is the mono-repository for the backend services and their common codebase
 ## Getting started
 Follow the following instructions to get the project ready to use ASAP.
 
+
 ### Requirements
 Be sure you have installed in your system
 
@@ -93,6 +94,18 @@ To troubleshoot issues regarding this part please check out:
 a link to the swagger.json with the definition of the api.
 
 
+### Important notes
+Due to the used technology and particularities on the implementation of this API, it is important that you respect the
+following notes regarding to the manipulation of the data from and towards the API:
+
+- The [recommended](https://docs.microsoft.com/en-us/azure/cosmos-db/working-with-dates#storing-datetimes) format for 
+DateTime strings in Azure Cosmos DB is `YYYY-MM-DDThh:mm:ss.fffffffZ` which follows the ISO 8601 **UTC standard**.
+- You may want to delete permanently the time entries, because they may interfere with the constraints of its container. 
+For instance, if a user starts a new time entry the `end_date` will be `null`. If they remove that active time entry 
+without closing it and starts all over again this new time entry will also have `end_date` with `null`. In scenarios 
+like this one the user will get from the server a Conflict error (409). Therefore, it was enable the  possibility to 
+remove a time entry permanently by specifying `delete_permanently` to `true` as a url parameter (query string).
+
 ## Development
 
 ### Test

commons/data_access_layer/cosmos_db.py

@@ -1,15 +1,17 @@
 import dataclasses
 import logging
 import uuid
+from datetime import datetime
 from typing import Callable
 
 import azure.cosmos.cosmos_client as cosmos_client
 import azure.cosmos.exceptions as exceptions
 from azure.cosmos import ContainerProxy, PartitionKey
 from flask import Flask
+from werkzeug.exceptions import HTTPException
 
 from commons.data_access_layer.database import CRUDDao
-from time_tracker_api.security import current_user_tenant_id
+from time_tracker_api.security import current_user_tenant_id, current_user_id
 
 
 class CosmosDBFacade:
@@ -75,12 +77,14 @@ class CosmosDBRepository:
     def __init__(self, container_id: str,
                  partition_key_attribute: str,
                  mapper: Callable = None,
+                 order_fields: list = [],
                  custom_cosmos_helper: CosmosDBFacade = None):
         global cosmos_helper
         self.cosmos_helper = custom_cosmos_helper or cosmos_helper
         if self.cosmos_helper is None:  # pragma: no cover
             raise ValueError("The cosmos_db module has not been initialized!")
         self.mapper = mapper
+        self.order_fields = order_fields
         self.container: ContainerProxy = self.cosmos_helper.db.get_container_client(container_id)
         self.partition_key_attribute: str = partition_key_attribute
 
@@ -93,7 +97,23 @@ def from_definition(cls, container_definition: dict,
                    mapper=mapper,
                    custom_cosmos_helper=custom_cosmos_helper)
 
+    @staticmethod
+    def create_sql_condition_for_visibility(visible_only: bool, container_name='c') -> str:
+        if visible_only:
+            # We are considering that `deleted == null` is not a choice
+            return 'NOT IS_DEFINED(%s.deleted)' % container_name
+        return 'true'
+
+    @staticmethod
+    def check_visibility(item, throw_not_found_if_deleted):
+        if throw_not_found_if_deleted and item.get('deleted') is not None:
+            raise exceptions.CosmosResourceNotFoundError(message='Deleted item',
+                                                         status_code=404)
+
+        return item
+
     def create(self, data: dict, mapper: Callable = None):
+        self.on_create(data)
         function_mapper = self.get_mapper_or_dict(mapper)
         return function_mapper(self.container.create_item(body=data))
 
@@ -108,10 +128,12 @@ def find_all(self, partition_key_value: str, max_count=None, offset=0,
         max_count = self.get_page_size_or(max_count)
         result = self.container.query_items(
             query="""
-            SELECT * FROM c WHERE c.{partition_key_attribute}=@partition_key_value AND {visibility_condition}
+            SELECT * FROM c WHERE c.{partition_key_attribute}=@partition_key_value 
+            AND {visibility_condition}  {order_clause}
             OFFSET @offset LIMIT @max_count
             """.format(partition_key_attribute=self.partition_key_attribute,
-                       visibility_condition=self.create_sql_condition_for_visibility(visible_only)),
+                       visibility_condition=self.create_sql_condition_for_visibility(visible_only),
+                       order_clause=self.create_sql_order_clause()),
             parameters=[
                 {"name": "@partition_key_value", "value": partition_key_value},
                 {"name": "@offset", "value": offset},
@@ -130,6 +152,7 @@ def partial_update(self, id: str, changes: dict, partition_key_value: str,
         return self.update(id, item_data, mapper=mapper)
 
     def update(self, id: str, item_data: dict, mapper: Callable = None):
+        self.on_update(item_data)
         function_mapper = self.get_mapper_or_dict(mapper)
         return function_mapper(self.container.replace_item(id, body=item_data))
 
@@ -141,19 +164,6 @@ def delete(self, id: str, partition_key_value: str, mapper: Callable = None):
     def delete_permanently(self, id: str, partition_key_value: str) -> None:
         self.container.delete_item(id, partition_key_value)
 
-    def check_visibility(self, item, throw_not_found_if_deleted):
-        if throw_not_found_if_deleted and item.get('deleted') is not None:
-            raise exceptions.CosmosResourceNotFoundError(message='Deleted item',
-                                                         status_code=404)
-
-        return item
-
-    def create_sql_condition_for_visibility(self, visible_only: bool, container_name='c') -> str:
-        if visible_only:
-            # We are considering that `deleted == null` is not a choice
-            return 'NOT IS_DEFINED(%s.deleted)' % container_name
-        return 'true'
-
     def get_mapper_or_dict(self, alternative_mapper: Callable) -> Callable:
         return alternative_mapper or self.mapper or dict
 
@@ -162,11 +172,28 @@ def get_page_size_or(self, custom_page_size: int) -> int:
         # or any other repository for the settings
         return custom_page_size or 100
 
+    def on_create(self, new_item_data: dict):
+        if new_item_data.get('id') is None:
+            new_item_data['id'] = str(uuid.uuid4())
+
+    def on_update(self, update_item_data: dict):
+        pass
+
+    def create_sql_order_clause(self):
+        if len(self.order_fields) > 0:
+            return "ORDER BY c.{}".format(", c.".join(self.order_fields))
+        else:
+            return ""
+
 
 class CosmosDBDao(CRUDDao):
     def __init__(self, repository: CosmosDBRepository):
         self.repository = repository
 
+    @property
+    def partition_key_value(self):
+        return current_user_tenant_id()
+
     def get_all(self) -> list:
         tenant_id: str = self.partition_key_value
         return self.repository.find_all(partition_key_value=tenant_id)
@@ -176,8 +203,8 @@ def get(self, id):
         return self.repository.find(id, partition_key_value=tenant_id)
 
     def create(self, data: dict):
-        data['id'] = str(uuid.uuid4())
-        data['tenant_id'] = self.partition_key_value
+        data[self.repository.partition_key_attribute] = self.partition_key_value
+        data['owner_id'] = current_user_id()
         return self.repository.create(data)
 
     def update(self, id, data: dict):
@@ -189,9 +216,22 @@ def delete(self, id):
         tenant_id: str = current_user_tenant_id()
         self.repository.delete(id, partition_key_value=tenant_id)
 
-    @property
-    def partition_key_value(self):
-        return current_user_tenant_id()
+
+class CustomError(HTTPException):
+    def __init__(self, status_code: int, description: str = None):
+        self.code = status_code
+        self.description = description
+
+
+def current_datetime():
+    return datetime.utcnow()
+
+
+def datetime_str(value: datetime):
+    if value is not None:
+        return value.isoformat()
+    else:
+        return None
 
 
 def init_app(app: Flask) -> None:

requirements/azure_cosmos.txt

@@ -11,4 +11,7 @@ idna==2.8
 six==1.13.0
 urllib3==1.25.7
 virtualenv==16.7.9
-virtualenv-clone==0.5.3
+virtualenv-clone==0.5.3
+
+# Dataclasses
+dataclasses==0.6

tests/conftest.py

@@ -5,6 +5,8 @@
 
 from commons.data_access_layer.cosmos_db import CosmosDBRepository
 from time_tracker_api import create_app
+from time_tracker_api.security import current_user_tenant_id, current_user_id
+from time_tracker_api.time_entries.time_entries_model import TimeEntryCosmosDBRepository
 
 fake = Faker()
 Faker.seed()
@@ -92,11 +94,16 @@ def cosmos_db_repository(app: Flask, cosmos_db_model) -> CosmosDBRepository:
 
 @pytest.fixture(scope="session")
 def tenant_id() -> str:
-    return fake.uuid4()
+    return current_user_tenant_id()
+
+
+@pytest.fixture(scope="session")
+def another_tenant_id(tenant_id) -> str:
+    return str(tenant_id) + "2"
 
 
 @pytest.fixture(scope="session")
-def another_tenant_id() -> str:
+def owner_id() -> str:
     return fake.uuid4()
 
 
@@ -109,3 +116,8 @@ def sample_item(cosmos_db_repository: CosmosDBRepository, tenant_id: str) -> dic
                             tenant_id=tenant_id)
 
     return cosmos_db_repository.create(sample_item_data)
+
+
+@pytest.yield_fixture(scope="module")
+def time_entry_repository(cosmos_db_repository: CosmosDBRepository) -> TimeEntryCosmosDBRepository:
+    return TimeEntryCosmosDBRepository()

tests/time_tracker_api/smoke_test.py

@@ -4,7 +4,11 @@
 from flask_restplus._http import HTTPStatus
 from pytest_mock import MockFixture
 
-unexpected_errors_to_be_handled = [CosmosHttpResponseError, CosmosResourceNotFoundError, CosmosResourceExistsError]
+from commons.data_access_layer.cosmos_db import CustomError
+
+unexpected_errors_to_be_handled = [CustomError(HTTPStatus.BAD_REQUEST, "Anything"),
+                                   CosmosHttpResponseError, CosmosResourceNotFoundError,
+                                   CosmosResourceExistsError, AttributeError]
 
 
 def test_app_exists(app):

tests/time_tracker_api/time_entries/time_entries_model_test.py

@@ -0,0 +1,53 @@
+from datetime import datetime, timedelta
+
+import pytest
+from faker import Faker
+
+from commons.data_access_layer.cosmos_db import current_datetime, datetime_str
+from time_tracker_api.time_entries.time_entries_model import TimeEntryCosmosDBRepository, TimeEntryCosmosDBModel
+
+fake = Faker()
+
+now = current_datetime()
+yesterday = current_datetime() - timedelta(days=1)
+two_days_ago = current_datetime() - timedelta(days=2)
+
+
+def create_time_entry(start_date: datetime,
+                      end_date: datetime,
+                      owner_id: str,
+                      tenant_id: str,
+                      time_entry_repository: TimeEntryCosmosDBRepository) -> TimeEntryCosmosDBModel:
+    data = {
+        "project_id": fake.uuid4(),
+        "activity_id": fake.uuid4(),
+        "description": fake.paragraph(nb_sentences=2),
+        "start_date": datetime_str(start_date),
+        "end_date": datetime_str(end_date),
+        "owner_id": owner_id,
+        "tenant_id": tenant_id
+    }
+
+    created_item = time_entry_repository.create(data, mapper=TimeEntryCosmosDBModel)
+    return created_item
+
+
+@pytest.mark.parametrize(
+    'start_date,end_date', [(two_days_ago, yesterday), (now, None)]
+)
+def test_find_interception_with_date_range_should_find(start_date: datetime,
+                                                       end_date: datetime,
+                                                       owner_id: str,
+                                                       tenant_id: str,
+                                                       time_entry_repository: TimeEntryCosmosDBRepository):
+    existing_item = create_time_entry(start_date, end_date, owner_id, tenant_id, time_entry_repository)
+
+    result = time_entry_repository.find_interception_with_date_range(datetime_str(yesterday), datetime_str(now),
+                                                                     owner_id=owner_id,
+                                                                     partition_key_value=tenant_id)
+
+    time_entry_repository.delete_permanently(existing_item.id, partition_key_value=existing_item.tenant_id)
+
+    assert result is not None
+    assert len(result) >= 0
+    assert any([existing_item.id == item.id for item in result])