Trends Dashboard

scripts/core/db/postgres/psql_query.py

 from scripts.constants import Constants
-from scripts.configurations import postgres_details
-from sqlalchemy import select, and_, cast, Text
+from sqlalchemy import select
 
 
-def get_unique_departments(table):
+def get_departments(table):
     return select(
-        table.department.label(Constants.DATA)
+        table.department
     ).distinct()
 
 
@@ -15,8 +14,9 @@ def get_filter_query(
         table=None
 ):
     query = None
+    clause = None
 
-    if current_level and current_level == 0:
+    if current_level == 0:
         query = f"""
         SELECT 
             DISTINCT FUNCTION
@@ -28,7 +28,7 @@ def get_filter_query(
             FUNCTION
         """
 
-    elif current_level and current_level == 1:
+    elif current_level == 1:
         query = f"""
         SELECT 
             DISTINCT FORM
@@ -41,19 +41,24 @@ def get_filter_query(
             FORM
         """
 
-    elif current_level and current_level >= 2:
+    elif current_level >= 2:
         current_level -= 1
 
         where_clause = ""
         if current_level >= 2:
-            where_clause = f"""
-            AND FILTER ->> 'l{current_level - 1}-value' = '{filter_value}'
-            """
+            query_parts = []
+            for index, data in filter_value.items():
+                key, value = list(data.items())[0]
+                query_parts.append(
+                    f"AND FILTER ->> 'l{int(index) + 1}-name' = '{key}'")
+                query_parts.append(
+                    f"AND FILTER ->> 'l{int(index) + 1}-value' = '{value}'")
+            where_clause = "\n".join(query_parts)
 
         query = f"""
         SELECT 
-            DISTINCT (FILTER - >> 'l{current_level}-name') AS L{current_level}_NAME,
-            (FILTER - >> 'l{current_level}-value') AS L{current_level}_VALUE
+            DISTINCT (FILTER ->> 'l{current_level}-name') AS L{current_level}_NAME,
+            (FILTER ->> 'l{current_level}-value') AS L{current_level}_VALUE
         FROM
             {table}
         WHERE  
@@ -64,35 +69,24 @@ def get_filter_query(
         ORDER BY
             L{current_level}_NAME
         """
+        clause = f"""
+        WHERE  
+            DEPARTMENT='{department}' 
+            AND FUNCTION='{function}'
+            AND FORM='{form}'
+            {where_clause}
+        """
 
-    return query
-
-
-def get_unique_function(table, department):
-    return select(
-        table.function.label(Constants.DATA)
-    ).distinct().where(
-        table.department == department
-    )
-
-
-def get_unique_form(table, department, function):
-    return select(
-        table.form.label(Constants.DATA)
-    ).distinct().where(
-        and_(
-            table.department == department,
-            table.function == function
-        ))
+    return query, clause
 
 
-def get_unique_filters(table, department, function, form):
-    return select(
-        cast(table.filter, Text).label(Constants.DATA)
-    ).distinct().where(
-        and_(
-            table.department == department,
-            table.function == function,
-            table.form == form
-        )
-    )
+def get_parameters(where_clause):
+    return f"""
+    SELECT 
+        DISTINCT PARAMETER
+    FROM
+        PUBLIC.TRENDS_MASTER_TBL_
+    {where_clause}
+    ORDER BY
+        PARAMETER
+    """

scripts/core/handler/trends_handler.py

@@ -5,8 +5,7 @@ from scripts.configurations import postgres_details
 from scripts.constants import Constants
 from scripts.core.db.postgres import database_init
 from scripts.core.db.postgres.psql_query import (
-    get_unique_departments, get_unique_function,
-    get_unique_form, get_unique_filters, get_filter_query
+    get_departments, get_parameters, get_filter_query
 )
 from scripts.core.schemas.postgres import TableObject
 from scripts.core.logging.application_logging import logger
@@ -21,80 +20,12 @@ class TrendsDashboardHandler:
         PepsiCo metrics.
     """
 
-    def get_trends_metadata_old(self, request_data):
-        """
-        get_trends_metadata
-        """
-        filter_flag = False
-
-        final_metadata_json = dict(
-            values=[]
-        )
-
-        logger.info("Database initialization")
-        db_init = database_init()
-
-        # Creating table object
-        trends_master_tbl_obj = TableObject(
-            db=db_init, table_name=TrendsMasterTable
-        )
-
-        if request_data.department and request_data.function and request_data.form:
-            filter_flag = True
-            filter_name = Constants.LINE
-            filter_query = get_unique_filters(
-                table=TrendsMasterTable,
-                department=request_data.department,
-                function=request_data.function,
-                form=request_data.form
-            )
-
-        elif request_data.department and request_data.function:
-            filter_name = Constants.FORM
-            filter_query = get_unique_form(
-                table=TrendsMasterTable,
-                department=request_data.department,
-                function=request_data.function
-            )
-
-        elif request_data.department:
-            filter_name = Constants.FUNCTION
-            filter_query = get_unique_function(
-                table=TrendsMasterTable,
-                department=request_data.department
-            )
-
-        else:
-            filter_name = Constants.DEPARTMENT
-            filter_query = get_unique_departments(
-                table=TrendsMasterTable
-            )
-
-        # Getting response from the Trends Master Table
-        response_data = trends_master_tbl_obj.execute_query(
-            query=filter_query
-        )
-
-        if response_data and not filter_flag:
-            final_metadata_json[Constants.FILTER_NAME] = filter_name
-            for each_metadata in response_data:
-                final_metadata_json[Constants.VALUES].append(
-                    dict(
-                        key=each_metadata[Constants.DATA],
-                        label=each_metadata[Constants.DATA],
-                    )
-                )
-
-        return final_metadata_json
-
     def get_trends_metadata(self, request_data):
         """
         get_trends_metadata
         """
-        final_metadata_json = dict(
-            values=[]
-        )
-        print(request_data)
+        final_metadata_json = dict()
+        clause = None
 
         logger.info("Database initialization")
         db_init = database_init()
@@ -104,17 +35,19 @@ class TrendsDashboardHandler:
             db=db_init, table_name=TrendsMasterTable
         )
 
-        if request_data.current_level:
-            filter_query = get_filter_query(
+        if request_data.current_level or request_data.current_level == 0:
+            final_metadata_json["current_level"] = request_data.current_level + 1
+            filter_query, clause = get_filter_query(
                 current_level=request_data.current_level,
                 department=request_data.department,
                 function=request_data.function,
                 form=request_data.form,
-                filter_value=None,
+                filter_value=request_data.filter,
                 table=postgres_details.master_tbl
             )
         else:
-            filter_query = get_unique_departments(
+            final_metadata_json["current_level"] = 0
+            filter_query = get_departments(
                 table=TrendsMasterTable
             )
 
@@ -122,14 +55,28 @@ class TrendsDashboardHandler:
         response_data = trends_master_tbl_obj.execute_query(
             query=filter_query
         )
+        parameter_flag = False
 
         if response_data:
-            for each_metadata in response_data:
+            final_metadata_json, parameter_flag = self.get_response_data(
+                response_data=response_data,
+                final_metadata_json=final_metadata_json,
+                parameter_flag=parameter_flag
+            )
 
-                # Create a JSON for UI
-                print(each_metadata)
+        if parameter_flag:
+            filter_query = get_parameters(where_clause=clause)
+            # Getting response from the Trends Master Table
+            response_data = trends_master_tbl_obj.execute_query(
+                query=filter_query
+            )
+            if response_data:
+                final_metadata_json, parameter_flag = self.get_response_data(
+                    response_data=response_data,
+                    final_metadata_json=final_metadata_json,
+                    parameter_flag=parameter_flag
+                )
 
-        final_metadata_json[Constants.FILTER_NAME] = "filter_name"
         return final_metadata_json
 
     def get_trends_data(self, request_data):
@@ -137,3 +84,28 @@ class TrendsDashboardHandler:
         Docstring
         """
         return True
+
+    def get_response_data(self, response_data, final_metadata_json, parameter_flag):
+        values = []
+        for each_data in response_data:
+            if len(each_data) > 1:
+                filter_name = list(each_data.items())
+                if filter_name[1][1]:
+                    values.append({
+                        "key": filter_name[1][1],
+                        "label": filter_name[1][1]
+                    })
+                else:
+                    parameter_flag = True
+                    break
+                final_metadata_json["filter_name"] = filter_name[0][1]
+                final_metadata_json["values"] = values
+            elif len(each_data) == 1:
+                filter_name = list(each_data.keys())[0]
+                values.append({
+                    "key": each_data[filter_name],
+                    "label": each_data[filter_name]
+                })
+                final_metadata_json["filter_name"] = filter_name
+                final_metadata_json["values"] = values
+        return final_metadata_json, parameter_flag

scripts/core/schemas/api/trends_schema.py

@@ -9,12 +9,14 @@ class DashboardFilterInput(BaseModel):
     department: Optional[str] = None
     function: Optional[str] = None
     form: Optional[str] = None
-    current_level: Optional[str] = None
+    current_level: Optional[int] = None
+    filter: Optional[dict] = None
 
 
 class DashboardFilterOutput(BaseModel):
     filter_name: str
     values: list
+    current_level: int
 
 
 class DashboardFormInput(BaseModel):

scripts/core/service/trends_service.py

@@ -56,7 +56,6 @@ async def dashboard_metadata(
     """
     try:
         trends_obj = TrendsDashboardHandler()
-        print(request_data)
         return trends_obj.get_trends_metadata(request_data=request_data)
     except Exception as err:
         logger.exception(