From e1ed69331d5cde9a97475b1c0daebce4fdff7418 Mon Sep 17 00:00:00 2001
From: roberto <alexandro.ramr777@gmail.com>
Date: Tue, 5 May 2020 17:52:40 -0500
Subject: [PATCH 1/2] fix(time-entries): add owner_id in data when create
 time-entry

---
 .../time_entries/time_entries_model.py        | 199 ++++++++++++------
 1 file changed, 136 insertions(+), 63 deletions(-)

diff --git a/time_tracker_api/time_entries/time_entries_model.py b/time_tracker_api/time_entries/time_entries_model.py
index 10cd7989..31044f55 100644
--- a/time_tracker_api/time_entries/time_entries_model.py
+++ b/time_tracker_api/time_entries/time_entries_model.py
@@ -5,8 +5,16 @@
 from azure.cosmos import PartitionKey
 from flask_restplus._http import HTTPStatus
 
-from commons.data_access_layer.cosmos_db import CosmosDBDao, CosmosDBRepository, CustomError, current_datetime_str, \
-    CosmosDBModel, get_date_range_of_month, get_current_year, get_current_month
+from commons.data_access_layer.cosmos_db import (
+    CosmosDBDao,
+    CosmosDBRepository,
+    CustomError,
+    current_datetime_str,
+    CosmosDBModel,
+    get_date_range_of_month,
+    get_current_year,
+    get_current_month,
+)
 from commons.data_access_layer.database import EventContext
 from time_tracker_api.database import CRUDDao, APICosmosDBDao
 from time_tracker_api.security import current_user_id
@@ -34,10 +42,8 @@ def restart(self, id: str):
     'id': 'time_entry',
     'partition_key': PartitionKey(path='/tenant_id'),
     'unique_key_policy': {
-        'uniqueKeys': [
-            {'paths': ['/owner_id', '/end_date', '/deleted']},
-        ]
-    }
+        'uniqueKeys': [{'paths': ['/owner_id', '/end_date', '/deleted']}]
+    },
 }
 
 
@@ -66,15 +72,20 @@ def __repr__(self):
         return '<Time Entry %r>' % self.start_date  # pragma: no cover
 
     def __str___(self):
-        return "Time Entry started in \"%s\"" % self.start_date  # pragma: no cover
+        return (
+            "Time Entry started in \"%s\"" % self.start_date
+        )  # pragma: no cover
 
 
 class TimeEntryCosmosDBRepository(CosmosDBRepository):
     def __init__(self):
-        CosmosDBRepository.__init__(self, container_id=container_definition['id'],
-                                    partition_key_attribute='tenant_id',
-                                    order_fields=['start_date DESC'],
-                                    mapper=TimeEntryCosmosDBModel)
+        CosmosDBRepository.__init__(
+            self,
+            container_id=container_definition['id'],
+            partition_key_attribute='tenant_id',
+            order_fields=['start_date DESC'],
+            mapper=TimeEntryCosmosDBModel,
+        )
 
     @staticmethod
     def create_sql_ignore_id_condition(id: str):
@@ -93,7 +104,9 @@ def create_sql_date_range_filter(date_range: dict) -> str:
         else:
             return ''
 
-    def find_all(self, event_context: EventContext, conditions: dict, date_range: dict):
+    def find_all(
+        self, event_context: EventContext, conditions: dict, date_range: dict
+    ):
         custom_sql_conditions = []
         custom_sql_conditions.append(
             self.create_sql_date_range_filter(date_range)
@@ -106,9 +119,9 @@ def find_all(self, event_context: EventContext, conditions: dict, date_range: di
             event_context=event_context,
             conditions=conditions,
             custom_sql_conditions=custom_sql_conditions,
-            custom_params=custom_params
+            custom_params=custom_params,
         )
- 
+
     def on_create(self, new_item_data: dict, event_context: EventContext):
         CosmosDBRepository.on_create(self, new_item_data, event_context)
 
@@ -122,8 +135,16 @@ def on_update(self, updated_item_data: dict, event_context: EventContext):
         self.validate_data(updated_item_data, event_context)
         self.replace_empty_value_per_none(updated_item_data)
 
-    def find_interception_with_date_range(self, start_date, end_date, owner_id, tenant_id,
-                                          ignore_id=None, visible_only=True, mapper: Callable = None):
+    def find_interception_with_date_range(
+        self,
+        start_date,
+        end_date,
+        owner_id,
+        tenant_id,
+        ignore_id=None,
+        visible_only=True,
+        mapper: Callable = None,
+    ):
         conditions = {
             "owner_id": owner_id,
             "tenant_id": tenant_id,
@@ -136,37 +157,54 @@ def find_interception_with_date_range(self, start_date, end_date, owner_id, tena
         params.extend(self.generate_params(conditions))
         result = self.container.query_items(
             query="""
-            SELECT * FROM c WHERE ((c.start_date BETWEEN @start_date AND @end_date) 
-              OR (c.end_date BETWEEN @start_date AND @end_date))
-             {conditions_clause} {ignore_id_condition} {visibility_condition} {order_clause}
-            """.format(ignore_id_condition=self.create_sql_ignore_id_condition(ignore_id),
-                       visibility_condition=self.create_sql_condition_for_visibility(visible_only),
-                       conditions_clause=self.create_sql_where_conditions(conditions),
-                       order_clause=self.create_sql_order_clause()),
+            SELECT * FROM c
+            WHERE ((c.start_date BETWEEN @start_date AND @end_date)
+                  OR (c.end_date BETWEEN @start_date AND @end_date))
+            {conditions_clause}
+            {ignore_id_condition}
+            {visibility_condition}
+            {order_clause}
+            """.format(
+                ignore_id_condition=self.create_sql_ignore_id_condition(
+                    ignore_id
+                ),
+                visibility_condition=self.create_sql_condition_for_visibility(
+                    visible_only
+                ),
+                conditions_clause=self.create_sql_where_conditions(conditions),
+                order_clause=self.create_sql_order_clause(),
+            ),
             parameters=params,
-            partition_key=tenant_id)
+            partition_key=tenant_id,
+        )
 
         function_mapper = self.get_mapper_or_dict(mapper)
         return list(map(function_mapper, result))
 
-    def find_running(self, tenant_id: str, owner_id: str, mapper: Callable = None):
+    def find_running(
+        self, tenant_id: str, owner_id: str, mapper: Callable = None
+    ):
         conditions = {
             "owner_id": owner_id,
             "tenant_id": tenant_id,
         }
         result = self.container.query_items(
             query="""
-                  SELECT * from c
-                  WHERE (NOT IS_DEFINED(c.end_date) OR c.end_date = null) 
-                  {conditions_clause} {visibility_condition}
-                  OFFSET 0 LIMIT 1
+            SELECT * from c
+            WHERE (NOT IS_DEFINED(c.end_date) OR c.end_date = null)
+            {conditions_clause}
+            {visibility_condition}
+            OFFSET 0 LIMIT 1
             """.format(
-                visibility_condition=self.create_sql_condition_for_visibility(True),
+                visibility_condition=self.create_sql_condition_for_visibility(
+                    True
+                ),
                 conditions_clause=self.create_sql_where_conditions(conditions),
             ),
             parameters=self.generate_params(conditions),
             partition_key=tenant_id,
-            max_item_count=1)
+            max_item_count=1,
+        )
 
         function_mapper = self.get_mapper_or_dict(mapper)
         return function_mapper(next(result))
@@ -176,20 +214,28 @@ def validate_data(self, data, event_context: EventContext):
 
         if data.get('end_date') is not None:
             if data['end_date'] <= start_date:
-                raise CustomError(HTTPStatus.BAD_REQUEST,
-                                  description="You must end the time entry after it started")
+                raise CustomError(
+                    HTTPStatus.BAD_REQUEST,
+                    description="You must end the time entry after it started",
+                )
             if data['end_date'] >= current_datetime_str():
-                raise CustomError(HTTPStatus.BAD_REQUEST,
-                                  description="You cannot end a time entry in the future")
-
-        collision = self.find_interception_with_date_range(start_date=start_date,
-                                                           end_date=data.get('end_date'),
-                                                           owner_id=event_context.user_id,
-                                                           tenant_id=event_context.tenant_id,
-                                                           ignore_id=data.get('id'))
+                raise CustomError(
+                    HTTPStatus.BAD_REQUEST,
+                    description="You cannot end a time entry in the future",
+                )
+
+        collision = self.find_interception_with_date_range(
+            start_date=start_date,
+            end_date=data.get('end_date'),
+            owner_id=event_context.user_id,
+            tenant_id=event_context.tenant_id,
+            ignore_id=data.get('id'),
+        )
         if len(collision) > 0:
-            raise CustomError(HTTPStatus.UNPROCESSABLE_ENTITY,
-                              description="There is another time entry in that date range")
+            raise CustomError(
+                HTTPStatus.UNPROCESSABLE_ENTITY,
+                description="There is another time entry in that date range",
+            )
 
 
 class TimeEntriesCosmosDBDao(APICosmosDBDao, TimeEntriesDao):
@@ -198,66 +244,93 @@ def __init__(self, repository):
 
     @classmethod
     def check_whether_current_user_owns_item(cls, data: dict):
-        if data.get('owner_id') is not None \
-                and data.get('owner_id') != cls.current_user_id():
-            raise CustomError(HTTPStatus.FORBIDDEN,
-                              "The current user is not the owner of this time entry")
+        if (
+            data.get('owner_id') is not None
+            and data.get('owner_id') != cls.current_user_id()
+        ):
+            raise CustomError(
+                HTTPStatus.FORBIDDEN,
+                "The current user is not the owner of this time entry",
+            )
 
     @classmethod
     def checks_owner_and_is_not_stopped(cls, data: dict):
         cls.check_whether_current_user_owns_item(data)
 
         if data.get('end_date') is not None:
-            raise CustomError(HTTPStatus.UNPROCESSABLE_ENTITY, "The specified time entry is already stopped")
+            raise CustomError(
+                HTTPStatus.UNPROCESSABLE_ENTITY,
+                "The specified time entry is already stopped",
+            )
 
     @classmethod
     def checks_owner_and_is_not_started(cls, data: dict):
         cls.check_whether_current_user_owns_item(data)
 
         if data.get('end_date') is None:
-            raise CustomError(HTTPStatus.UNPROCESSABLE_ENTITY, "The specified time entry is already running")
+            raise CustomError(
+                HTTPStatus.UNPROCESSABLE_ENTITY,
+                "The specified time entry is already running",
+            )
 
     def get_all(self, conditions: dict = {}) -> list:
         event_ctx = self.create_event_context("read-many")
         conditions.update({"owner_id": event_ctx.user_id})
 
         date_range = self.handle_date_filter_args(args=conditions)
-        return self.repository.find_all(event_ctx,
-                                        conditions=conditions,
-                                        date_range=date_range)
+        return self.repository.find_all(
+            event_ctx, conditions=conditions, date_range=date_range
+        )
 
     def get(self, id):
         event_ctx = self.create_event_context("read")
-        return self.repository.find(id, event_ctx, peeker=self.check_whether_current_user_owns_item)
+        return self.repository.find(
+            id, event_ctx, peeker=self.check_whether_current_user_owns_item
+        )
 
     def create(self, data: dict):
         event_ctx = self.create_event_context("create")
+        data['owner_id'] = event_ctx.user_id
         return self.repository.create(data, event_ctx)
 
     def update(self, id, data: dict, description=None):
         event_ctx = self.create_event_context("update", description)
-        return self.repository.partial_update(id, data, event_ctx,
-                                              peeker=self.check_whether_current_user_owns_item)
+        return self.repository.partial_update(
+            id,
+            data,
+            event_ctx,
+            peeker=self.check_whether_current_user_owns_item,
+        )
 
     def stop(self, id):
         event_ctx = self.create_event_context("update", "Stop time entry")
-        return self.repository.partial_update(id, {
-            'end_date': current_datetime_str()
-        }, event_ctx, peeker=self.checks_owner_and_is_not_stopped)
+        return self.repository.partial_update(
+            id,
+            {'end_date': current_datetime_str()},
+            event_ctx,
+            peeker=self.checks_owner_and_is_not_stopped,
+        )
 
     def restart(self, id):
         event_ctx = self.create_event_context("update", "Restart time entry")
-        return self.repository.partial_update(id, {
-            'end_date': None
-        }, event_ctx, peeker=self.checks_owner_and_is_not_started)
+        return self.repository.partial_update(
+            id,
+            {'end_date': None},
+            event_ctx,
+            peeker=self.checks_owner_and_is_not_started,
+        )
 
     def delete(self, id):
         event_ctx = self.create_event_context("delete")
-        self.repository.delete(id, event_ctx, peeker=self.check_whether_current_user_owns_item)
+        self.repository.delete(
+            id, event_ctx, peeker=self.check_whether_current_user_owns_item
+        )
 
     def find_running(self):
         event_ctx = self.create_event_context("find_running")
-        return self.repository.find_running(event_ctx.tenant_id, event_ctx.user_id)
+        return self.repository.find_running(
+            event_ctx.tenant_id, event_ctx.user_id
+        )
 
     @staticmethod
     def handle_date_filter_args(args: dict) -> dict:

From c8ce76a8de8abc64042cf2f0c8fe603a08f6f48e Mon Sep 17 00:00:00 2001
From: roberto <alexandro.ramr777@gmail.com>
Date: Tue, 5 May 2020 17:57:00 -0500
Subject: [PATCH 2/2] style: format time-entries namespace and cosmosdb.py with
 'black' library

---
 commons/data_access_layer/cosmos_db.py        | 241 ++++++++++++------
 time_tracker_api/config.py                    |  10 +-
 .../time_entries/time_entries_namespace.py    | 223 +++++++++-------
 3 files changed, 306 insertions(+), 168 deletions(-)

diff --git a/commons/data_access_layer/cosmos_db.py b/commons/data_access_layer/cosmos_db.py
index 8ca6d8fc..8082bd9a 100644
--- a/commons/data_access_layer/cosmos_db.py
+++ b/commons/data_access_layer/cosmos_db.py
@@ -26,24 +26,35 @@ def __init__(self, client, db_id: str, logger=None):  # pragma: no cover
     def from_flask_config(cls, app: Flask):
         db_uri = app.config.get('COSMOS_DATABASE_URI')
         if db_uri is None:
-            app.logger.warn("COSMOS_DATABASE_URI was not found. Looking for alternative variables.")
+            app.logger.warn(
+                "COSMOS_DATABASE_URI was not found. Looking for alternative variables."
+            )
             account_uri = app.config.get('DATABASE_ACCOUNT_URI')
             if account_uri is None:
-                raise EnvironmentError("DATABASE_ACCOUNT_URI is not defined in the environment")
+                raise EnvironmentError(
+                    "DATABASE_ACCOUNT_URI is not defined in the environment"
+                )
 
             master_key = app.config.get('DATABASE_MASTER_KEY')
             if master_key is None:
-                raise EnvironmentError("DATABASE_MASTER_KEY is not defined in the environment")
-
-            client = cosmos_client.CosmosClient(account_uri, {'masterKey': master_key},
-                                                user_agent="TimeTrackerAPI",
-                                                user_agent_overwrite=True)
+                raise EnvironmentError(
+                    "DATABASE_MASTER_KEY is not defined in the environment"
+                )
+
+            client = cosmos_client.CosmosClient(
+                account_uri,
+                {'masterKey': master_key},
+                user_agent="TimeTrackerAPI",
+                user_agent_overwrite=True,
+            )
         else:
             client = cosmos_client.CosmosClient.from_connection_string(db_uri)
 
         db_id = app.config.get('DATABASE_NAME')
         if db_id is None:
-            raise EnvironmentError("DATABASE_NAME is not defined in the environment")
+            raise EnvironmentError(
+                "DATABASE_NAME is not defined in the environment"
+            )
 
         return cls(client, db_id, logger=app.logger)
 
@@ -60,7 +71,7 @@ def delete_container(self, container_id: str):
 cosmos_helper: CosmosDBFacade = None
 
 
-class CosmosDBModel():
+class CosmosDBModel:
     def __init__(self, data):
         names = set([f.name for f in dataclasses.fields(self)])
         for k, v in data.items():
@@ -73,45 +84,63 @@ def partition_key_attribute(pk: PartitionKey) -> str:
 
 
 class CosmosDBRepository:
-    def __init__(self, container_id: str,
-                 partition_key_attribute: str,
-                 mapper: Callable = None,
-                 order_fields: list = [],
-                 custom_cosmos_helper: CosmosDBFacade = None):
+    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
+        self.container: ContainerProxy = self.cosmos_helper.db.get_container_client(
+            container_id
+        )
+        self.partition_key_attribute = partition_key_attribute
 
     @classmethod
-    def from_definition(cls, container_definition: dict,
-                        mapper: Callable = None,
-                        custom_cosmos_helper: CosmosDBFacade = None):
-        pk_attrib = partition_key_attribute(container_definition['partition_key'])
-        return cls(container_definition['id'], pk_attrib,
-                   mapper=mapper,
-                   custom_cosmos_helper=custom_cosmos_helper)
+    def from_definition(
+        cls,
+        container_definition: dict,
+        mapper: Callable = None,
+        custom_cosmos_helper: CosmosDBFacade = None,
+    ):
+        pk_attrib = partition_key_attribute(
+            container_definition['partition_key']
+        )
+        return cls(
+            container_definition['id'],
+            pk_attrib,
+            mapper=mapper,
+            custom_cosmos_helper=custom_cosmos_helper,
+        )
 
     @staticmethod
-    def create_sql_condition_for_visibility(visible_only: bool, container_name='c') -> str:
+    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 'AND NOT IS_DEFINED(%s.deleted)' % container_name
         return ''
 
     @staticmethod
-    def create_sql_where_conditions(conditions: dict, container_name='c') -> str:
+    def create_sql_where_conditions(
+        conditions: dict, container_name='c'
+    ) -> str:
         where_conditions = []
         for k in conditions.keys():
             where_conditions.append(f'{container_name}.{k} = @{k}')
 
         if len(where_conditions) > 0:
             return "AND {where_conditions_clause}".format(
-                where_conditions_clause=" AND ".join(where_conditions))
+                where_conditions_clause=" AND ".join(where_conditions)
+            )
         else:
             return ""
 
@@ -119,7 +148,10 @@ def create_sql_where_conditions(conditions: dict, container_name='c') -> str:
     def create_custom_sql_conditions(custom_sql_conditions: List[str]) -> str:
         if len(custom_sql_conditions) > 0:
             return "AND {custom_sql_conditions_clause}".format(
-                custom_sql_conditions_clause=" AND ".join(custom_sql_conditions))
+                custom_sql_conditions_clause=" AND ".join(
+                    custom_sql_conditions
+                )
+            )
         else:
             return ''
 
@@ -127,18 +159,16 @@ def create_custom_sql_conditions(custom_sql_conditions: List[str]) -> str:
     def generate_params(conditions: dict) -> dict:
         result = []
         for k, v in conditions.items():
-            result.append({
-                "name": "@%s" % k,
-                "value": v
-            })
+            result.append({"name": "@%s" % k, "value": v})
 
         return result
 
     @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)
+            raise exceptions.CosmosResourceNotFoundError(
+                message='Deleted item', status_code=404
+            )
         return item
 
     @staticmethod
@@ -158,14 +188,32 @@ def attach_context(data: dict, event_context: EventContext):
             "session_id": event_context.session_id,
         }
 
-    def create(self, data: dict, event_context: EventContext, mapper: Callable = None):
+    def create(
+        self, data: dict, event_context: EventContext, mapper: Callable = None
+    ):
         self.on_create(data, event_context)
         function_mapper = self.get_mapper_or_dict(mapper)
         self.attach_context(data, event_context)
         return function_mapper(self.container.create_item(body=data))
 
-    def find(self, id: str, event_context: EventContext, peeker: 'function' = None,
-             visible_only=True, mapper: Callable = None):
+    def on_create(self, new_item_data: dict, event_context: EventContext):
+        if new_item_data.get('id') is None:
+            new_item_data['id'] = generate_uuid4()
+
+        new_item_data[
+            self.partition_key_attribute
+        ] = self.find_partition_key_value(event_context)
+
+        self.replace_empty_value_per_none(new_item_data)
+
+    def find(
+        self,
+        id: str,
+        event_context: EventContext,
+        peeker: 'function' = None,
+        visible_only=True,
+        mapper: Callable = None,
+    ):
         partition_key_value = self.find_partition_key_value(event_context)
         found_item = self.container.read_item(id, partition_key_value)
         if peeker:
@@ -174,8 +222,17 @@ def find(self, id: str, event_context: EventContext, peeker: 'function' = None,
         function_mapper = self.get_mapper_or_dict(mapper)
         return function_mapper(self.check_visibility(found_item, visible_only))
 
-    def find_all(self, event_context: EventContext, conditions: dict = {}, custom_sql_conditions: List[str] = [],
-                 custom_params: dict = {}, max_count=None, offset=0, visible_only=True, mapper: Callable = None):
+    def find_all(
+        self,
+        event_context: EventContext,
+        conditions: dict = {},
+        custom_sql_conditions: List[str] = [],
+        custom_params: dict = {},
+        max_count=None,
+        offset=0,
+        visible_only=True,
+        mapper: Callable = None,
+    ):
         partition_key_value = self.find_partition_key_value(event_context)
         max_count = self.get_page_size_or(max_count)
         params = [
@@ -185,40 +242,80 @@ def find_all(self, event_context: EventContext, conditions: dict = {}, custom_sq
         ]
         params.extend(self.generate_params(conditions))
         params.extend(custom_params)
-        result = self.container.query_items(query="""
-            SELECT * FROM c WHERE c.{partition_key_attribute}=@partition_key_value
-            {conditions_clause} {visibility_condition} {custom_sql_conditions_clause} {order_clause}
+        result = self.container.query_items(
+            query="""
+            SELECT * FROM c
+            WHERE c.{partition_key_attribute}=@partition_key_value
+            {conditions_clause}
+            {visibility_condition}
+            {custom_sql_conditions_clause}
+            {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),
-                       conditions_clause=self.create_sql_where_conditions(conditions),
-                       custom_sql_conditions_clause=self.create_custom_sql_conditions(custom_sql_conditions),
-                       order_clause=self.create_sql_order_clause()),
-                                            parameters=params,
-                                            partition_key=partition_key_value,
-                                            max_item_count=max_count)
+            """.format(
+                partition_key_attribute=self.partition_key_attribute,
+                visibility_condition=self.create_sql_condition_for_visibility(
+                    visible_only
+                ),
+                conditions_clause=self.create_sql_where_conditions(conditions),
+                custom_sql_conditions_clause=self.create_custom_sql_conditions(
+                    custom_sql_conditions
+                ),
+                order_clause=self.create_sql_order_clause(),
+            ),
+            parameters=params,
+            partition_key=partition_key_value,
+            max_item_count=max_count,
+        )
 
         function_mapper = self.get_mapper_or_dict(mapper)
         return list(map(function_mapper, result))
 
-    def partial_update(self, id: str, changes: dict, event_context: EventContext,
-                       peeker: 'function' = None, visible_only=True, mapper: Callable = None):
-        item_data = self.find(id, event_context, peeker=peeker, visible_only=visible_only, mapper=dict)
+    def partial_update(
+        self,
+        id: str,
+        changes: dict,
+        event_context: EventContext,
+        peeker: 'function' = None,
+        visible_only=True,
+        mapper: Callable = None,
+    ):
+        item_data = self.find(
+            id,
+            event_context,
+            peeker=peeker,
+            visible_only=visible_only,
+            mapper=dict,
+        )
         item_data.update(changes)
         return self.update(id, item_data, event_context, mapper=mapper)
 
-    def update(self, id: str, item_data: dict, event_context: EventContext,
-               mapper: Callable = None):
+    def update(
+        self,
+        id: str,
+        item_data: dict,
+        event_context: EventContext,
+        mapper: Callable = None,
+    ):
         self.on_update(item_data, event_context)
         function_mapper = self.get_mapper_or_dict(mapper)
         self.attach_context(item_data, event_context)
         return function_mapper(self.container.replace_item(id, body=item_data))
 
-    def delete(self, id: str, event_context: EventContext,
-               peeker: 'function' = None, mapper: Callable = None):
-        return self.partial_update(id, {
-            'deleted': generate_uuid4()
-        }, event_context, peeker=peeker, visible_only=True, mapper=mapper)
+    def delete(
+        self,
+        id: str,
+        event_context: EventContext,
+        peeker: 'function' = None,
+        mapper: Callable = None,
+    ):
+        return self.partial_update(
+            id,
+            {'deleted': generate_uuid4()},
+            event_context,
+            peeker=peeker,
+            visible_only=True,
+            mapper=mapper,
+        )
 
     def delete_permanently(self, id: str, event_context: EventContext) -> None:
         partition_key_value = self.find_partition_key_value(event_context)
@@ -235,14 +332,6 @@ 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, event_context: EventContext):
-        if new_item_data.get('id') is None:
-            new_item_data['id'] = generate_uuid4()
-
-        new_item_data[self.partition_key_attribute] = self.find_partition_key_value(event_context)
-
-        self.replace_empty_value_per_none(new_item_data)
-
     def on_update(self, update_item_data: dict, event_context: EventContext):
         pass
 
@@ -276,9 +365,12 @@ def delete(self, id):
         event_ctx = self.create_event_context("delete")
         self.repository.delete(id, event_ctx)
 
-    def create_event_context(self, action: str = None, description: str = None):
-        return EventContext(self.repository.container.id, action,
-                            description=description)
+    def create_event_context(
+        self, action: str = None, description: str = None
+    ):
+        return EventContext(
+            self.repository.container.id, action, description=description
+        )
 
 
 class CustomError(HTTPException):
@@ -324,10 +416,7 @@ def get_current_month() -> int:
     return datetime.now().month
 
 
-def get_date_range_of_month(
-    year: int,
-    month: int
-) -> Dict[str, str]:
+def get_date_range_of_month(year: int, month: int) -> Dict[str, str]:
     first_day_of_month = 1
     start_date = datetime(year=year, month=month, day=first_day_of_month)
 
@@ -339,10 +428,10 @@ def get_date_range_of_month(
         hour=23,
         minute=59,
         second=59,
-        microsecond=999999
+        microsecond=999999,
     )
 
     return {
         'start_date': datetime_str(start_date),
-        'end_date': datetime_str(end_date)
+        'end_date': datetime_str(end_date),
     }
diff --git a/time_tracker_api/config.py b/time_tracker_api/config.py
index e31d9ab2..49a6afdf 100644
--- a/time_tracker_api/config.py
+++ b/time_tracker_api/config.py
@@ -12,6 +12,7 @@ class Config:
     RESTPLUS_VALIDATE = True
     DEBUG = True
     CORS_ORIGINS = "*"
+    ERROR_404_HELP = False
 
 
 class DevelopmentConfig(Config):
@@ -49,8 +50,13 @@ class ProductionConfig(Config):
 
 
 class AzureConfig(CosmosDB):
-    SQL_DATABASE_URI = os.environ.get('SQL_DATABASE_URI', os.environ.get('SQLCONNSTR_DATABASE_URI'))
-    COSMOS_DATABASE_URI = os.environ.get('COSMOS_DATABASE_URI', os.environ.get('CUSTOMCONNSTR_COSMOS_DATABASE_URI'))
+    SQL_DATABASE_URI = os.environ.get(
+        'SQL_DATABASE_URI', os.environ.get('SQLCONNSTR_DATABASE_URI')
+    )
+    COSMOS_DATABASE_URI = os.environ.get(
+        'COSMOS_DATABASE_URI',
+        os.environ.get('CUSTOMCONNSTR_COSMOS_DATABASE_URI'),
+    )
     SQLALCHEMY_DATABASE_URI = SQL_DATABASE_URI
 
 
diff --git a/time_tracker_api/time_entries/time_entries_namespace.py b/time_tracker_api/time_entries/time_entries_namespace.py
index e94ecd25..05c8e94a 100644
--- a/time_tracker_api/time_entries/time_entries_namespace.py
+++ b/time_tracker_api/time_entries/time_entries_namespace.py
@@ -4,78 +4,102 @@
 from flask_restplus import fields, Resource
 from flask_restplus._http import HTTPStatus
 
-from commons.data_access_layer.cosmos_db import current_datetime, datetime_str, current_datetime_str
+from commons.data_access_layer.cosmos_db import (
+    current_datetime,
+    datetime_str,
+    current_datetime_str,
+)
 from commons.data_access_layer.database import COMMENTS_MAX_LENGTH
-from time_tracker_api.api import common_fields, create_attributes_filter, api, UUID, NullableString, \
-    remove_required_constraint
+from time_tracker_api.api import (
+    common_fields,
+    create_attributes_filter,
+    api,
+    UUID,
+    NullableString,
+    remove_required_constraint,
+)
 from time_tracker_api.time_entries.time_entries_model import create_dao
 
 faker = Faker()
 
-ns = api.namespace('time-entries', description='Namespace of the API for time entries')
+ns = api.namespace(
+    'time-entries', description='Namespace of the API for time entries'
+)
 
 # TimeEntry Model
-time_entry_input = ns.model('TimeEntryInput', {
-    'project_id': UUID(
-        title='Project',
-        required=True,
-        description='The id of the selected project',
-        example=faker.uuid4(),
-    ),
-    'start_date': fields.DateTime(
-        dt_format='iso8601',
-        title='Start date',
-        required=False,
-        description='When the user started doing this activity',
-        example=datetime_str(current_datetime() - timedelta(days=1)),
-    ),
-    'activity_id': UUID(
-        title='Activity',
-        required=False,
-        description='The id of the selected activity',
-        example=faker.uuid4(),
-    ),
-    'description': NullableString(
-        title='Comments',
-        required=False,
-        description='Comments about the time entry',
-        example=faker.paragraph(nb_sentences=2),
-        max_length=COMMENTS_MAX_LENGTH,
-    ),
-    'end_date': fields.DateTime(
-        dt_format='iso8601',
-        title='End date',
-        required=False,
-        description='When the user ended doing this activity',
-        example=current_datetime_str(),
-    ),
-    'uri': NullableString(
-        title='Uniform Resource identifier',
-        description='Either identifier or locator of a resource in the Internet that helps to understand'
-                    ' what this time entry was about. For example, A Jira ticket, a Github issue, a Google document.',
-        required=False,
-        example=faker.random_element([
-            'https://github.com/ioet/time-tracker-backend/issues/51',
-            '#54',
-            'TT-54'
-        ]),
-    ),
-    'technologies': fields.List(
-        fields.String(
-            title='Technologies',
-            description='List of the canonical names of the used technologies',
+time_entry_input = ns.model(
+    'TimeEntryInput',
+    {
+        'project_id': UUID(
+            title='Project',
+            required=True,
+            description='The id of the selected project',
+            example=faker.uuid4(),
         ),
-        required=False,
-        max_items=10,
-        unique=True,
-        example=faker.words(
-            3,
-            ['cosmos_db', 'azure', 'python', 'docker', 'sql',
-             'javascript', 'typescript'],
-            unique=True
-        )
-    ),
-})
+        'start_date': fields.DateTime(
+            dt_format='iso8601',
+            title='Start date',
+            required=False,
+            description='When the user started doing this activity',
+            example=datetime_str(current_datetime() - timedelta(days=1)),
+        ),
+        'activity_id': UUID(
+            title='Activity',
+            required=False,
+            description='The id of the selected activity',
+            example=faker.uuid4(),
+        ),
+        'description': NullableString(
+            title='Comments',
+            required=False,
+            description='Comments about the time entry',
+            example=faker.paragraph(nb_sentences=2),
+            max_length=COMMENTS_MAX_LENGTH,
+        ),
+        'end_date': fields.DateTime(
+            dt_format='iso8601',
+            title='End date',
+            required=False,
+            description='When the user ended doing this activity',
+            example=current_datetime_str(),
+        ),
+        'uri': NullableString(
+            title='Uniform Resource identifier',
+            description='Either identifier or locator of a resource in the Internet that helps to understand'
+            ' what this time entry was about. For example, A Jira ticket, a Github issue, a Google document.',
+            required=False,
+            example=faker.random_element(
+                [
+                    'https://github.com/ioet/time-tracker-backend/issues/51',
+                    '#54',
+                    'TT-54',
+                ]
+            ),
+        ),
+        'technologies': fields.List(
+            fields.String(
+                title='Technologies',
+                description='List of the canonical names of the used technologies',
+            ),
+            required=False,
+            max_items=10,
+            unique=True,
+            example=faker.words(
+                3,
+                [
+                    'cosmos_db',
+                    'azure',
+                    'python',
+                    'docker',
+                    'sql',
+                    'javascript',
+                    'typescript',
+                ],
+                unique=True,
+            ),
+        ),
+    },
+)
 
 time_entry_response_fields = {
     'running': fields.Boolean(
@@ -95,28 +119,31 @@
 time_entry_response_fields.update(common_fields)
 
 time_entry = ns.inherit(
-    'TimeEntry',
-    time_entry_input,
-    time_entry_response_fields,
+    'TimeEntry', time_entry_input, time_entry_response_fields,
 )
 
 time_entries_dao = create_dao()
 
-attributes_filter = create_attributes_filter(ns, time_entry, [
-    "project_id",
-    "activity_id",
-    "uri",
-])
+attributes_filter = create_attributes_filter(
+    ns, time_entry, ["project_id", "activity_id", "uri"]
+)
 
 # custom attributes filter
-attributes_filter.add_argument('month', required=False,
-                                    store_missing=False,
-                                    help="(Filter) Month to filter by",
-                                    location='args')
-attributes_filter.add_argument('year', required=False,
-                                    store_missing=False,
-                                    help="(Filter) Year to filter by",
-                                    location='args')
+attributes_filter.add_argument(
+    'month',
+    required=False,
+    store_missing=False,
+    help="(Filter) Month to filter by",
+    location='args',
+)
+attributes_filter.add_argument(
+    'year',
+    required=False,
+    store_missing=False,
+    help="(Filter) Year to filter by",
+    location='args',
+)
+
 
 @ns.route('')
 class TimeEntries(Resource):
@@ -132,10 +159,15 @@ def get(self):
     @ns.expect(time_entry_input)
     @ns.marshal_with(time_entry, code=HTTPStatus.CREATED)
     @ns.response(HTTPStatus.CONFLICT, 'There is already an active time entry')
-    @ns.response(HTTPStatus.BAD_REQUEST, 'Invalid format or structure '
-                                         'of the attributes of the time entry')
-    @ns.response(HTTPStatus.UNPROCESSABLE_ENTITY, 'This new time entry intercepts another one. '
-                                                  'Please check your start and end date.')
+    @ns.response(
+        HTTPStatus.BAD_REQUEST,
+        'Invalid format or structure of the attributes of the time entry',
+    )
+    @ns.response(
+        HTTPStatus.UNPROCESSABLE_ENTITY,
+        'This new time entry intercepts another one. '
+        'Please check your start and end date.',
+    )
     def post(self):
         """Create a time entry"""
         return time_entries_dao.create(ns.payload), HTTPStatus.CREATED
@@ -153,10 +185,15 @@ def get(self, id):
         return time_entries_dao.get(id)
 
     @ns.doc('put_time_entry')
-    @ns.response(HTTPStatus.BAD_REQUEST, 'Invalid format or structure '
-                                         'of the attributes of the time entry')
-    @ns.response(HTTPStatus.CONFLICT, 'A time entry already exists with this new data or there'
-                                      ' is a bad reference for the project or activity')
+    @ns.response(
+        HTTPStatus.BAD_REQUEST,
+        'Invalid format or structure of the attributes of the time entry',
+    )
+    @ns.response(
+        HTTPStatus.CONFLICT,
+        'A time entry already exists with this new data or there'
+        ' is a bad reference for the project or activity',
+    )
     @ns.expect(remove_required_constraint(time_entry_input))
     @ns.marshal_with(time_entry)
     def put(self, id):
@@ -173,7 +210,10 @@ def delete(self, id):
 
 @ns.route('/<string:id>/stop')
 @ns.response(HTTPStatus.NOT_FOUND, 'Running time entry not found')
-@ns.response(HTTPStatus.UNPROCESSABLE_ENTITY, 'The specified time entry is already stopped')
+@ns.response(
+    HTTPStatus.UNPROCESSABLE_ENTITY,
+    'The specified time entry is already stopped',
+)
 @ns.param('id', 'The unique identifier of a running time entry')
 class StopTimeEntry(Resource):
     @ns.doc('stop_time_entry')
@@ -185,7 +225,10 @@ def post(self, id):
 
 @ns.route('/<string:id>/restart')
 @ns.response(HTTPStatus.NOT_FOUND, 'Stopped time entry not found')
-@ns.response(HTTPStatus.UNPROCESSABLE_ENTITY, 'The specified time entry is already running')
+@ns.response(
+    HTTPStatus.UNPROCESSABLE_ENTITY,
+    'The specified time entry is already running',
+)
 @ns.param('id', 'The unique identifier of a stopped time entry')
 class RestartTimeEntry(Resource):
     @ns.doc('restart_time_entry')