feat: TT-417 created CRUD project

test: TT-417 add test of projects

test: TT-417 add test with customer id

refactor: TT-417 created enums and use

test: TT-417 add missing tests

test: TT-417 add missing tests and resolve comments

refactor: TT-417 add HTTPStatus from http

reactor: TT-407 rebase with master - DELETE

Author: mandres2015

V2/serverless.yml

@@ -107,6 +107,15 @@ functions:
           route: time-entries/{id}
           authLevel: anonymous
 
+  get_latest_time_entry:
+    handler: time_tracker/time_entries/interface.get_latest_entries
+     - http: true
+        x-azure-settings:
+          methods:
+            - GET
+          route: time-entries/latest
+          authLevel: anonymous
+
   update_time_entry:
     handler: time_tracker/time_entries/interface.update_time_entry
     events:
@@ -177,3 +186,4 @@ functions:
           route: projects/
 
           authLevel: anonymous
+         

V2/tests/api/azure/time_entry_azure_endpoints_test.py

@@ -139,6 +139,45 @@ def test__get_time_entries_azure_endpoint__returns_a_status_code_400__when_time_
     assert response.get_body() == b'Invalid Format ID'
 
 
+def test__get_latest_entries_azure_endpoint__returns_a_list_of_latest_time_entries__when_an_owner_id_match(
+    test_db, time_entry_factory, insert_time_entry, insert_activity, activity_factory,
+):
+    inserted_activity = insert_activity(activity_factory(), test_db).__dict__
+    time_entry_body = time_entry_factory(activity_id=inserted_activity["id"], technologies="[jira,sql]")
+    inserted_time_entry = insert_time_entry(time_entry_body, test_db).__dict__
+
+    req = func.HttpRequest(
+        method='GET',
+        body=None,
+        url=TIME_ENTRY_URL+"latest/",
+        params={"owner_id": inserted_time_entry["owner_id"]},
+    )
+
+    response = azure_time_entries._get_latest_entries.get_latest_entries(req)
+    time_entry_json_data = json.loads(response.get_body().decode("utf-8"))
+
+    assert response.status_code == 200
+    assert time_entry_json_data == [inserted_time_entry]
+
+
+def test__get_latest_entries_azure_endpoint__returns_no_time_entries_found__when_recieve_an_invalid_owner_id(
+    test_db, insert_activity, activity_factory,
+):
+    insert_activity(activity_factory(), test_db)
+
+    req = func.HttpRequest(
+        method='GET',
+        body=None,
+        url=TIME_ENTRY_URL+"latest/",
+        params={"owner_id": Faker().pyint()},
+    )
+
+    response = azure_time_entries._get_latest_entries.get_latest_entries(req)
+
+    assert response.status_code == 404
+    assert response.get_body() == b'No time entries found'
+
+
 def test__update_time_entry_azure_endpoint__returns_an_time_entry__when_found_an_time_entry_to_update(
     test_db, time_entry_factory, insert_time_entry, activity_factory, insert_activity
 ):

V2/tests/integration/daos/time_entries_dao_test.py

@@ -73,6 +73,32 @@ def test_delete__returns_none__when_no_time_entry_matching_its_id_is_found(
     assert result is None
 
 
+def test_get_latest_entries__returns_a_list_of_latest_time_entries__when_an_owner_id_match(
+    create_fake_dao, time_entry_factory, insert_activity, activity_factory, test_db
+):
+    dao = create_fake_dao(test_db)
+    inserted_activity = insert_activity(activity_factory(), dao.db)
+    time_entry_to_insert = time_entry_factory(
+        activity_id=inserted_activity.id,
+        technologies="[jira,sql]")
+    inserted_time_entry = dao.create(time_entry_to_insert)
+
+    result = dao.get_latest_entries(int(inserted_time_entry.owner_id))
+
+    assert result == [inserted_time_entry.__dict__]
+
+
+def test_get_latest_entries__returns_none__when_an_owner_id_is_not_found(
+    create_fake_dao, test_db, insert_activity, activity_factory
+):
+    dao = create_fake_dao(test_db)
+    insert_activity(activity_factory(), dao.db)
+
+    result = dao.get_latest_entries(Faker().pyint())
+
+    assert result is None
+
+
 def test_update__returns_an_time_entry_dto__when_found_one_time_entry_to_update(
     test_db, create_fake_dao, time_entry_factory, insert_activity, activity_factory
 ):

V2/tests/unit/services/time_entry_service_test.py

@@ -31,6 +31,21 @@ def test__delete_time_entry__uses_the_time_entry_dao__to_delete_time_entry_selec
     assert expected_time_entry == deleted_time_entry
 
 
+def test__get_latest_entries__uses_the_time_entry_dao__to_get_last_entries(
+    mocker,
+):
+    expected_latest_time_entries = mocker.Mock()
+    time_entry_dao = mocker.Mock(
+        get_latest_entries=mocker.Mock(return_value=expected_latest_time_entries)
+    )
+
+    time_entry_service = TimeEntryService(time_entry_dao)
+    latest_time_entries = time_entry_service.get_latest_entries(Faker().pyint(), Faker().pyint())
+
+    assert expected_latest_time_entries == latest_time_entries
+    assert time_entry_dao.get_latest_entries.called
+
+
 def test__update_time_entry__uses_the_time_entry_dao__to_update_one_time_entry(
     mocker,
 ):

V2/tests/unit/use_cases/time_entries_use_case_test.py

@@ -34,6 +34,19 @@ def test__delete_time_entry_function__uses_the_time_entry_service__to_delete_tim
     assert expected_time_entry == deleted_time_entry
 
 
+def test__get_latest_entries_function__uses_the_time_entry_service__to_get_last_entries(
+    mocker: MockFixture,
+):
+    expected_latest_time_entries = mocker.Mock()
+    time_entry_service = mocker.Mock(get_latest_entries=mocker.Mock(return_value=expected_latest_time_entries))
+
+    time_entry_use_case = _use_cases.GetLastestTimeEntryUseCase(time_entry_service)
+    latest_time_entries = time_entry_use_case.get_latest_entries(Faker().pyint(), Faker().pyint())
+
+    assert time_entry_service.get_latest_entries.called
+    assert expected_latest_time_entries == latest_time_entries
+
+
 def test__update_time_entries_function__uses_the_time_entry_service__to_update_an_time_entry(
     mocker: MockFixture,
 ):

V2/time_tracker/time_entries/_application/_time_entries/__init__.py

@@ -1,6 +1,7 @@
 # flake8: noqa
 from ._create_time_entry import create_time_entry
 from ._delete_time_entry import delete_time_entry
+from ._get_latest_entries import get_latest_entries
 from ._update_time_entry import update_time_entry
 from ._get_time_entries import get_time_entries
 from ._get_latest_entries import get_latest_entries

V2/time_tracker/time_entries/_domain/__init__.py

@@ -5,6 +5,7 @@
 from ._use_cases import (
     CreateTimeEntryUseCase,
     DeleteTimeEntryUseCase,
+    GetLastestTimeEntryUseCase,
     UpdateTimeEntryUseCase,
     GetTimeEntriesUseCase,
     GetTimeEntryUseCase,

V2/time_tracker/time_entries/_domain/_services/_time_entry.py

@@ -1,6 +1,7 @@
 import typing
 
 from time_tracker.time_entries._domain import TimeEntry, TimeEntriesDao
+import typing
 
 
 class TimeEntryService:
@@ -13,6 +14,9 @@ def create(self, time_entry_data: TimeEntry) -> TimeEntry:
     def delete(self, id: int) -> TimeEntry:
         return self.time_entry_dao.delete(id)
 
+    def get_latest_entries(self, owner_id: int, limit: int) -> typing.List[TimeEntry]:
+        return self.time_entry_dao.get_latest_entries(owner_id, limit)
+
     def update(self, time_entry_id: int, new_time_entry: dict) -> TimeEntry:
         return self.time_entry_dao.update(time_entry_id, new_time_entry)
 

V2/time_tracker/time_entries/_domain/_use_cases/__init__.py

@@ -1,6 +1,7 @@
 # flake8: noqa
 from ._create_time_entry_use_case import CreateTimeEntryUseCase
 from ._delete_time_entry_use_case import DeleteTimeEntryUseCase
+from ._get_latest_entries_use_case import GetLastestTimeEntryUseCase
 from ._update_time_entry_use_case import UpdateTimeEntryUseCase
 from ._get_time_entry_use_case import GetTimeEntriesUseCase
 from ._get_time_entry_by_id_use_case import GetTimeEntryUseCase

V2/time_tracker/time_entries/_infrastructure/_data_persistence/_time_entries_sql_dao.py

@@ -84,6 +84,20 @@ def delete(self, time_entry_id: int) -> domain.TimeEntry:
         time_entry = self.db.get_session().execute(query_deleted_time_entry).one_or_none()
         return self.__create_time_entry_dto(dict(time_entry)) if time_entry else None
 
+    def get_latest_entries(self, owner_id: int, limit: int = 20) -> typing.List[domain.TimeEntry]:
+        query = (
+            self.time_entry.select()
+            .where(sqlalchemy.and_(
+                self.time_entry.c.owner_id == owner_id,
+                self.time_entry.c.deleted.is_(False)
+            ))
+            .order_by(self.time_entry.c.start_date.desc())
+            .limit(limit)
+        )
+        time_entries_data = self.db.get_session().execute(query)
+        list_time_entries = [dict(entry) for entry in time_entries_data]
+        return list_time_entries if len(list_time_entries) > 0 else None
+
     def __create_time_entry_dto(self, time_entry: dict) -> domain.TimeEntry:
         time_entry.update({
             "start_date": str(time_entry.get("start_date")),