O

Merge branch 'TT-201-validate-the-current-entry-and-last-entry' of github.com:ioet/time-tracker-backend into TT-201-validate-the-current-entry-and-last-entry

Author: VanessaIniguezG

tests/time_tracker_api/api_test.py

@@ -30,16 +30,57 @@ def test_remove_required_constraint():
     from flask_restplus import Namespace
 
     ns = Namespace('todos', description='Namespace for testing')
-    sample_model = ns.model('Todo', {
-        'id': fields.Integer(readonly=True, description='The task unique identifier'),
-        'task': fields.String(required=True, description='The task details'),
-        'done': fields.Boolean(required=False, description='Has it being done or not')
-    })
+    sample_model = ns.model(
+        'Todo',
+        {
+            'id': fields.Integer(
+                readonly=True, description='The task unique identifier'
+            ),
+            'task': fields.String(
+                required=True, description='The task details'
+            ),
+            'done': fields.Boolean(
+                required=False, description='Has it being done or not'
+            ),
+        },
+    )
 
     new_model = remove_required_constraint(sample_model)
 
     assert new_model is not sample_model
 
     for attrib in sample_model:
-        assert new_model[attrib].required is False, "No attribute should be required"
-        assert new_model[attrib] is not sample_model[attrib], "No attribute should be required"
+        assert (
+            new_model[attrib].required is False
+        ), "No attribute should be required"
+        assert (
+            new_model[attrib] is not sample_model[attrib]
+        ), "No attribute should be required"
+
+
+def test_add_update_last_entry_if_overlap():
+    from time_tracker_api.api import add_update_last_entry_if_overlap
+    from flask_restplus import fields
+    from flask_restplus import Namespace
+
+    ns = Namespace('todos', description='Namespace for testing')
+    sample_model = ns.model(
+        'Todo',
+        {
+            'id': fields.Integer(
+                readonly=True, description='The task unique identifier'
+            ),
+            'task': fields.String(
+                required=True, description='The task details'
+            ),
+        },
+    )
+
+    new_model = add_update_last_entry_if_overlap(sample_model)
+
+    assert new_model is not sample_model
+
+    update_last_entry_if_overlap = new_model.get(
+        'update_last_entry_if_overlap'
+    )
+    assert update_last_entry_if_overlap is not None

tests/time_tracker_api/time_entries/time_entries_model_test.py

@@ -310,3 +310,34 @@ def test_find_all_v2(
     time_entry = result[0]
     assert isinstance(time_entry, TimeEntryCosmosDBModel)
     assert time_entry.__dict__ == expected_item
+
+
+@patch(
+    'time_tracker_api.time_entries.time_entries_repository.TimeEntryCosmosDBRepository.find_partition_key_value'
+)
+def test_get_last_entry(
+    find_partition_key_value_mock,
+    event_context: EventContext,
+    time_entry_repository: TimeEntryCosmosDBRepository,
+):
+    expected_item = {
+        'id': 'id',
+        'start_date': '2021-03-22T10:00:00.000Z',
+        'end_date': "2021-03-22T11:00:00.000Z",
+        'description': 'do some testing',
+        'tenant_id': 'tenant_id',
+        'project_id': 'project_id',
+        'activity_id': 'activity_id',
+        'technologies': ['python'],
+    }
+    query_items_mock = Mock(return_value=[expected_item])
+    time_entry_repository.container = Mock()
+    time_entry_repository.container.query_items = query_items_mock
+
+    result = time_entry_repository.get_last_entry('id1', event_context)
+    find_partition_key_value_mock.assert_called_once()
+
+    assert len(result) == 1
+    time_entry = result.pop()
+    assert isinstance(time_entry, TimeEntryCosmosDBModel)
+    assert time_entry.__dict__ == expected_item

tests/utils/query_builder_test.py

@@ -1,5 +1,5 @@
 from unittest.mock import patch
-from utils.query_builder import CosmosDBQueryBuilder
+from utils.query_builder import CosmosDBQueryBuilder, Order
 from utils.repository import remove_white_spaces
 import pytest
 
@@ -41,7 +41,9 @@ def test_add_select_conditions_should_update_select_list(
     ],
 )
 def test_add_sql_in_condition_should_update_where_list(
-    attribute, ids_list, expected_where_condition_list,
+    attribute,
+    ids_list,
+    expected_where_condition_list,
 ):
     query_builder = CosmosDBQueryBuilder().add_sql_in_condition(
         attribute, ids_list
@@ -66,7 +68,9 @@ def test_add_sql_in_condition_should_update_where_list(
     ],
 )
 def test_add_sql_where_equal_condition_should_update_where_params_list(
-    data, expected_where_list, expected_params,
+    data,
+    expected_where_list,
+    expected_params,
 ):
     query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition(data)
 
@@ -91,7 +95,8 @@ def test_add_sql_where_equal_condition_with_None_should_not_update_lists():
     [(True, ['NOT IS_DEFINED(c.deleted)']), (False, [])],
 )
 def test_add_sql_visibility_condition(
-    visibility_bool, expected_where_list,
+    visibility_bool,
+    expected_where_list,
 ):
     query_builder = CosmosDBQueryBuilder().add_sql_visibility_condition(
         visibility_bool
@@ -102,7 +107,12 @@ def test_add_sql_visibility_condition(
 
 
 @pytest.mark.parametrize(
-    "limit_value,expected_limit", [(1, 1), (10, 10), (None, None),],
+    "limit_value,expected_limit",
+    [
+        (1, 1),
+        (10, 10),
+        (None, None),
+    ],
 )
 def test_add_sql_limit_condition(limit_value, expected_limit):
     query_builder = CosmosDBQueryBuilder().add_sql_limit_condition(limit_value)
@@ -111,10 +121,16 @@ def test_add_sql_limit_condition(limit_value, expected_limit):
 
 
 @pytest.mark.parametrize(
-    "offset_value,expected_offset", [(1, 1), (10, 10), (None, None),],
+    "offset_value,expected_offset",
+    [
+        (1, 1),
+        (10, 10),
+        (None, None),
+    ],
 )
 def test_add_sql_offset_condition(
-    offset_value, expected_offset,
+    offset_value,
+    expected_offset,
 ):
     query_builder = CosmosDBQueryBuilder().add_sql_offset_condition(
         offset_value
@@ -125,10 +141,15 @@ def test_add_sql_offset_condition(
 
 @pytest.mark.parametrize(
     "select_conditions,expected_condition",
-    [([], "*"), (["c.id"], "c.id"), (["c.id", "c.name"], "c.id,c.name"),],
+    [
+        ([], "*"),
+        (["c.id"], "c.id"),
+        (["c.id", "c.name"], "c.id,c.name"),
+    ],
 )
 def test__build_select_return_fields_in_select_list(
-    select_conditions, expected_condition,
+    select_conditions,
+    expected_condition,
 ):
     query_builder = CosmosDBQueryBuilder().add_select_conditions(
         select_conditions
@@ -148,7 +169,8 @@ def test__build_select_return_fields_in_select_list(
     ],
 )
 def test__build_where_should_return_concatenated_conditions(
-    fields, expected_condition,
+    fields,
+    expected_condition,
 ):
     query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition(
         fields
@@ -164,7 +186,9 @@ def test__build_where_should_return_concatenated_conditions(
     [(1, "OFFSET @offset", [{'name': '@offset', 'value': 1}]), (None, "", [])],
 )
 def test__build_offset(
-    offset, expected_condition, expected_params,
+    offset,
+    expected_condition,
+    expected_params,
 ):
     query_builder = CosmosDBQueryBuilder().add_sql_offset_condition(offset)
 
@@ -179,7 +203,9 @@ def test__build_offset(
     [(1, "LIMIT @limit", [{'name': '@limit', 'value': 1}]), (None, "", [])],
 )
 def test__build_limit(
-    limit, expected_condition, expected_params,
+    limit,
+    expected_condition,
+    expected_params,
 ):
     query_builder = CosmosDBQueryBuilder().add_sql_limit_condition(limit)
 
@@ -235,3 +261,23 @@ def test_build_with_empty_and_None_attributes_return_query_select_all():
     assert query == expected_query
     assert len(query_builder.get_parameters()) == 0
     assert len(query_builder.where_conditions) == 0
+
+
+def test_order_by_condition():
+    query_builder = CosmosDBQueryBuilder().add_sql_order_by_condition(
+        'start_date', Order.DESC
+    )
+
+    assert len(query_builder.order_by) == 2
+    assert query_builder.order_by == ('start_date', 'DESC')
+
+
+def test__build_orderBy():
+    query_builder = CosmosDBQueryBuilder().add_sql_order_by_condition(
+        'start_date', Order.DESC
+    )
+
+    orderBy_condition = query_builder._CosmosDBQueryBuilder__build_order_By()
+    expected_order_string = "ORDER BY c.start_date DESC"
+
+    assert expected_order_string == orderBy_condition

time_tracker_api/api.py

@@ -34,6 +34,19 @@ def remove_required_constraint(model: Model):
     return result
 
 
+def add_update_last_entry_if_overlap(time_entry_model: Model):
+    time_entry_flag = {
+        'update_last_entry_if_overlap': fields.Boolean(
+            title='Update last entry if overlap',
+            required=False,
+            description='Flag that indicates if the last time entry is updated',
+            example=True,
+        )
+    }
+    new_model = time_entry_model.clone('TimeEntryInput', time_entry_flag)
+    return new_model
+
+
 def create_attributes_filter(
     ns: namespace, model: Model, filter_attrib_names: list
 ) -> RequestParser:

time_tracker_api/time_entries/time_entries_dao.py

@@ -226,6 +226,9 @@ def create(self, data: dict):
     def update(self, id, data: dict, description=None):
         event_ctx = self.create_event_context("update", description)
 
+        if data.get('update_last_entry_if_overlap'):
+            self.repository.update_last_entry(data, event_ctx)
+
         time_entry = self.repository.find(id, event_ctx)
         self.check_whether_current_user_owns_item(time_entry)
 

time_tracker_api/time_entries/time_entries_namespace.py

@@ -15,6 +15,7 @@
     UUID,
     NullableString,
     remove_required_constraint,
+    add_update_last_entry_if_overlap,
 )
 from time_tracker_api.time_entries.time_entries_dao import create_dao
 
@@ -267,6 +268,11 @@ def get(self):
         return time_entries_dao.get_lastest_entries_by_project(conditions={})
 
 
+update_entry_input = add_update_last_entry_if_overlap(
+    remove_required_constraint(time_entry_input)
+)
+
+
 @ns.route('/<string:id>')
 @ns.response(HTTPStatus.NOT_FOUND, 'This time entry does not exist')
 @ns.response(HTTPStatus.UNPROCESSABLE_ENTITY, 'The id has an invalid format')
@@ -288,7 +294,7 @@ def get(self, id):
         '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.expect(update_entry_input)
     @ns.marshal_with(time_entry)
     def put(self, id):
         """Update a time entry"""

time_tracker_api/time_entries/time_entries_repository.py

@@ -27,6 +27,8 @@
 from time_tracker_api.time_entries.time_entries_query_builder import (
     TimeEntryQueryBuilder,
 )
+from utils.query_builder import CosmosDBQueryBuilder, Order
+from utils.time import str_to_datetime
 
 
 class TimeEntryCosmosDBRepository(CosmosDBRepository):
@@ -233,6 +235,52 @@ def find_all_v2(
         function_mapper = self.get_mapper_or_dict(mapper)
         return list(map(function_mapper, result))
 
+    def get_last_entry(
+        self,
+        owner_id: str,
+        event_context: EventContext,
+        visible_only=True,
+        mapper: Callable = None,
+    ):
+        query_builder = (
+            CosmosDBQueryBuilder()
+            .add_sql_where_equal_condition({'owner_id': owner_id})
+            .add_sql_order_by_condition('end_date', Order.DESC)
+            .add_sql_limit_condition(1)
+            .add_sql_offset_condition(1)
+            .build()
+        )
+
+        query_str = query_builder.get_query()
+        params = query_builder.get_parameters()
+
+        partition_key_value = self.find_partition_key_value(event_context)
+        result = self.container.query_items(
+            query=query_str,
+            parameters=params,
+            partition_key=partition_key_value,
+        )
+
+        function_mapper = self.get_mapper_or_dict(mapper)
+        return list(map(function_mapper, result))
+
+    def update_last_entry(self, data: dict, event_context: EventContext):
+        owner_id = data.get('owner_id')
+        last_entry = self.get_last_entry(owner_id, event_context)
+        last_entry = last_entry.pop()
+
+        end_date = str_to_datetime(last_entry.end_date)
+        start_date = data.get('start_date')
+        start_date = str_to_datetime(start_date)
+
+        if start_date < end_date:
+            update_date = {'end_date': data.get('start_date')}
+            return self.partial_update(
+                last_entry.id, update_date, event_context
+            )
+
+        return False
+
     def on_create(self, new_item_data: dict, event_context: EventContext):
         CosmosDBRepository.on_create(self, new_item_data, event_context)