feat: add filter per month and year

Author: Angeluz-07

commons/data_access_layer/cosmos_db.py

@@ -2,7 +2,7 @@
 import logging
 import uuid
 from datetime import datetime
-from typing import Callable
+from typing import Callable, List
 
 import azure.cosmos.cosmos_client as cosmos_client
 import azure.cosmos.exceptions as exceptions
@@ -116,6 +116,17 @@ def create_sql_where_conditions(conditions: dict, container_name='c') -> str:
         else:
             return ""
 
+    @staticmethod
+    def create_sql_custom_conditions(custom_conditions: List[str]) -> str:
+        if len(custom_conditions) > 0:
+            return """
+            AND {custom_conditions_clause}
+            """.format(
+                custom_conditions_clause=" AND ".join(custom_conditions)
+            )
+        else:
+            return ''
+
     @staticmethod
     def generate_condition_values(conditions: dict) -> dict:
         result = []
@@ -154,8 +165,8 @@ def find(self, id: str, partition_key_value, 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, partition_key_value: str, conditions: dict = {}, max_count=None, offset=0,
-                 visible_only=True, mapper: Callable = None):
+    def find_all(self, partition_key_value: str, conditions: dict = {}, custom_conditions: List[str] = [],
+                 custom_params: dict = {}, max_count=None, offset=0, visible_only=True, mapper: Callable = None):
         # TODO Use the tenant_id param and change container alias
         max_count = self.get_page_size_or(max_count)
         params = [
@@ -164,13 +175,15 @@ def find_all(self, partition_key_value: str, conditions: dict = {}, max_count=No
             {"name": "@max_count", "value": max_count},
         ]
         params.extend(self.generate_condition_values(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} {order_clause}
+            {conditions_clause} {visibility_condition} {custom_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_conditions_clause=self.create_sql_custom_conditions(custom_conditions),
                        order_clause=self.create_sql_order_clause()),
                                             parameters=params,
                                             partition_key=partition_key_value,

time_tracker_api/time_entries/time_entries_model.py

@@ -1,6 +1,7 @@
 import abc
 from dataclasses import dataclass, field
-from typing import List, Callable
+from typing import List, Callable, Tuple
+from datetime import datetime
 
 from azure.cosmos import PartitionKey
 from flask_restplus._http import HTTPStatus
@@ -74,6 +75,35 @@ def create_sql_ignore_id_condition(id: str):
         else:
             return "AND c.id!=@ignore_id"
 
+    @staticmethod
+    def create_sql_date_range_filter(custom_args: dict) -> str:
+        if 'start_date' and 'end_date' in custom_args:
+            return """
+            ((c.start_date BETWEEN @start_date AND @end_date) OR
+             (c.end_date BETWEEN @start_date AND @end_date))
+            """
+        else:
+            return ''
+
+    def find_all(self, partition_key_value: str, conditions: dict, custom_args: dict):
+        custom_conditions = []
+        custom_conditions.append(
+            self.create_sql_date_range_filter(custom_args)
+        )
+
+        custom_params = [
+            {"name": "@start_date", "value": custom_args.get('start_date')},
+            {"name": "@end_date", "value": custom_args.get('end_date')},
+        ]
+
+        return CosmosDBRepository.find_all(
+            self,
+            partition_key_value=partition_key_value,
+            conditions=conditions,
+            custom_conditions=custom_conditions,
+            custom_params=custom_params
+        )
+
     def on_create(self, new_item_data: dict):
         CosmosDBRepository.on_create(self, new_item_data)
 
@@ -157,6 +187,32 @@ def validate_data(self, data):
                               description="There is another time entry in that date range")
 
 
+def get_last_day_of_month(year: int, month: int) -> int:
+    from calendar import monthrange
+    return monthrange(year=year, month=month)[1]
+
+
+def get_current_year() -> int:
+    return datetime.now().year
+
+
+def get_current_month() -> int:
+    return datetime.now().month
+
+
+def get_date_range_of_month(
+    year: int,
+    month: int
+) -> Tuple[datetime, datetime]:
+    first_day_of_month = 1
+    start_date = datetime(year=year, month=month, day=first_day_of_month)
+
+    # TODO : fix bound as this would exclude the last day
+    last_day_of_month = get_last_day_of_month(year=year, month=month)
+    end_date = datetime(year=year, month=month, day=last_day_of_month)
+    return start_date, end_date
+
+
 class TimeEntriesCosmosDBDao(TimeEntriesDao, CosmosDBDao):
     def __init__(self, repository):
         CosmosDBDao.__init__(self, repository)
@@ -170,8 +226,29 @@ def check_whether_current_user_owns_item(cls, data: dict):
 
     def get_all(self, conditions: dict = {}) -> list:
         conditions.update({"owner_id": self.current_user_id()})
+
+        if 'month' and 'year' in conditions:
+            month = int(conditions.get("month"))
+            year = int(conditions.get("year"))
+            conditions.pop('month')
+            conditions.pop('year')
+        elif 'month' in conditions:
+            month = int(conditions.get("month"))
+            year = get_current_year()
+            conditions.pop('month')
+        else:
+            month = get_current_month()
+            year = get_current_year()
+
+        start_date, end_date = get_date_range_of_month(year, month)
+
+        custom_args = {
+            'start_date': start_date.isoformat(),
+            'end_date': end_date.isoformat()
+        }
         return self.repository.find_all(partition_key_value=self.partition_key_value,
-                                        conditions=conditions)
+                                        conditions=conditions,
+                                        custom_args=custom_args)
 
     def get(self, id):
         return self.repository.find(id,

time_tracker_api/time_entries/time_entries_namespace.py

@@ -108,10 +108,20 @@
     "uri",
 ])
 
+# custom attributes filter
+attributes_filter.add_argument('month', required=False,
+                                    store_missing=False,
+                                    help="(Filter) month to filter",
+                                    location='args')
+attributes_filter.add_argument('year', required=False,
+                                    store_missing=False,
+                                    help="(Filter) year to filter",
+                                    location='args')
 
 @ns.route('')
 class TimeEntries(Resource):
     @ns.doc('list_time_entries')
+    @ns.expect(attributes_filter)
     @ns.marshal_list_with(time_entry)
     def get(self):
         """List all time entries"""