fix: TT-365 Resolve comments

Author: dsgarcia8

V2/tests/api/azure/activity_azure_endpoints_test.py

@@ -85,18 +85,18 @@ def test__activity_azure_endpoint__creates_an_activity__when_activity_has_all_at
      create_temp_activities,
  ):
      activities_json, tmp_directory = create_temp_activities
-     activities._create_activity.JSON_PATH = tmp_directory
+     activities._create_activity._JSON_PATH = tmp_directory
 
-     activity_body = {'id': Faker().uuid4(), 'name': Faker().user_name(), 'description': Faker().sentence(),'deleted': Faker().uuid4() ,'status': 'active', 'tenant_id': Faker().uuid4()}
+     activity_body = {'id': None, 'name': Faker().user_name(), 'description': Faker().sentence(),'deleted': Faker().uuid4() ,'status': 'active', 'tenant_id': Faker().uuid4()}
      body = json.dumps(activity_body).encode("utf-8")
      req = func.HttpRequest(
          method='POST',
          body= body,
-         url='/api/activities/',
+         url=ACTIVITY_URL,
      )
 
-     response = activities._create_activity.create_activity(req)
+     response = activities.create_activity(req)
      activitiy_json_data = response.get_body()
-
-     assert response.status_code == 200
+     print(response)
+     assert response.status_code == 201
      assert activitiy_json_data ==  body

V2/time_entries/_application/_activities/_create_activity.py

@@ -5,81 +5,58 @@
 
 import azure.functions as func
 
-from time_entries._infrastructure import ActivitiesJsonDao
-from time_entries._domain import ActivityService, _use_cases, Activity
+from ... import _domain
+from ... import _infrastructure
 
 _JSON_PATH = (
     'time_entries/_infrastructure/_data_persistence/activities_data.json'
 )
 
 
 def create_activity(req: func.HttpRequest) -> func.HttpResponse:
+    activity_dao = _infrastructure.ActivitiesJsonDao(_JSON_PATH)
+    activity_service = _domain.ActivityService(activity_dao)
+    use_case = _domain._use_cases.CreateActivityUseCase(activity_service)
     logging.info(
         'Python HTTP trigger function processed a request to create an activity.'
     )
     activity_data = req.get_json()
-    # status_code = 200
-    # if _validate_activity(activity_data):
-    #     response = _create_activity(activity_data)
-    # else:
-    #     status_code = 404
-    #     response = b'Not possible to create activity, attributes are not correct '
-
+    print(activity_data)
     validation_errors = _validate_activity(activity_data)
     if validation_errors:
         return func.HttpResponse(
             body=validation_errors, status_code=400, mimetype="application/json"
         )
-    
-    activity_to_create = Activity(
-        id=None,
+    activity_to_create = _domain.Activity(
+        id= None,
         name=activity_data['name'],
         description=activity_data['description'],
-        status_code=activity_data['status_code'],
-        deleted=activity_data['delete'],
+        status=activity_data['status'],
+        deleted=activity_data['deleted'],
         tenant_id=activity_data['tenant_id']
     )
 
-    # created_activity = use_case.create_activity(activity_to_create)
-    created_activity = _create_activity(activity_to_create)
-    
-    if not created_activity:
+    created_activity = use_case.create_activity(activity_to_create.__dict__)
+    print("actividad mapeada",activity_to_create)
+    print("use case",created_activity)
+    if not create_activity:
         return func.HttpResponse(
             body={'error': 'activity could not be created'},
             status_code=500,
             mimetype="application/json",
         )
-    
     return func.HttpResponse(
         body=json.dumps(created_activity.__dict__),
         status_code=201,
         mimetype="application/json"
     )
 
-def _create_activity(activity_data: dict) -> str:
-    activity_use_case = _use_cases.CreateActivityUseCase(
-        _create_activity_service(_JSON_PATH)
-    )
-    activity = activity_use_case.create_activity(activity_data)
-    return json.dumps(activity.__dict__) if activity else b'Not Found'
 
 def _validate_activity(activity_data: dict) -> typing.List[str]:
-# def _validate_activity(activity_data: dict) -> bool:
-
-    activity_fields = [field.name for field in dataclasses.fields(Activity)]
-
-    # activity_keys = [field.name for field in dataclasses.fields(Activity)]
-    # new_activity_keys = list(activity_data.keys())
-    # return  all(map(lambda key: key in activity_keys, new_activity_keys)) and len(activity_keys) == len(new_activity_keys)
+    activity_fields = [field.name for field in dataclasses.fields(_domain.Activity)]
 
     missing_keys = [field for field in activity_fields if field not in activity_data]
     return [
         f'The {missing_key} key is missing in the input data'
         for missing_key in missing_keys
-    ]
-
-def _create_activity_service(path: str):
-    activity_json = ActivitiesJsonDao(path)
-    return ActivityService(activity_json)
-
-
+    ]

V2/time_entries/_infrastructure/_data_persistence/_activities_json_dao.py

@@ -92,6 +92,7 @@ def create_activity(self, activity_data: dict) -> Activity:
     def __get_activities_from_file(self) -> typing.List[dict]:
         try:
             file = open(self.json_data_file_path)
+            print("")
             activities = json.load(file)
             file.close()