Trends Dashboard

.env

@@ -4,7 +4,8 @@ PORT = 80
 
 # POSTGRES DETAILS
 POSTGRES_URI = postgresql://admin:UtAdm#Post265399@20.221.119.96:5335/project_101__ilens_assistant
-POSTGRES_MASTER_TBL = public.trends_master_tbl_
+POSTGRES_MASTER_TBL = public.trends_master_tbl
+POSTGRES_DATA_TBL = public.trends_form_tbl
 
 # LOG DETAILS
 LOG_BASE_PATH=logs/

scripts/configurations/__init__.py

@@ -27,6 +27,7 @@ class PostgresDetails(BaseSettings):
 
     uri: str
     master_tbl: str
+    data_tbl: str
 
     class Config:
         env_prefix = "POSTGRES_"

scripts/constants/__init__.py

@@ -24,7 +24,7 @@ class MainConstants:
 
     META_TAG_JSON = {
         "name": "PepsiCO: Trends Dashboard",
-        "description": "Service for pushing data into the Postgres table",
+        "description": "Service for pushing each_data into the Postgres table",
     }
     DESCRIPTION_KEY = "Trends Dashboard"
     TOKEN_KEY = "token"
@@ -36,7 +36,7 @@ class Constants:
     """
     EXCEPTION_RAISER = "Exception ->{}"
     TRENDS_HANDLING_ENDPOINT = "Trends Handler Endpoints"
-    DATA = "data"
+    DATA = "each_data"
     LINE = "line"
     DEPARTMENT = "department"
     FORM = "form"
@@ -44,21 +44,32 @@ class Constants:
     VALUES = "values"
     FILTER_NAME = "filter_name"
 
-    MAPPING_JSON = {
-        0: "function",
-        1: "form",
-        2: "l1",
-        3: "l2",
-        4: "l3",
-        5: "l4",
-        6: "l5",
-        7: "l6",
-        8: "l7",
-        9: "l8",
-        10: "l9",
-        11: "l10",
-
-    }
+    HEADER_CONTENT = [
+        {
+            "key": "date",
+            "label": "Date"
+        },
+        {
+            "key": "parameter",
+            "label": "Parameter"
+        },
+        {
+            "key": "value",
+            "label": "Value"
+        },
+        {
+            "key": "mean",
+            "label": "Mean"
+        },
+        {
+            "key": "upper_limit",
+            "label": "Upper Limit"
+        },
+        {
+            "key": "lower_limit",
+            "label": "Lower Limit"
+        }
+    ]
 
 
 class LoggerConstants:

scripts/core/db/postgres/psql_query.py

@@ -80,13 +80,35 @@ def get_filter_query(
     return query, clause
 
 
-def get_parameters(where_clause):
+def get_parameters(table, where_clause):
     return f"""
     SELECT 
-        DISTINCT PARAMETER
+        DISTINCT PARAMETER, PARAMETER_TYPE, MAPPING_ID
     FROM
-        PUBLIC.TRENDS_MASTER_TBL_
+        {table}
     {where_clause}
     ORDER BY
-        PARAMETER
+        PARAMETER, PARAMETER_TYPE
+    """
+
+
+def get_form_data(metadata_tbl, data_tbl, mapping_id, start_date, end_date):
+    return f"""
+    SELECT 
+        FT.TIME_STAMP,
+        MT.PARAMETER,
+        FT.VALUE,
+        MT.UPPER_VALUE,
+        MT.LOWER_LIMIT
+    FROM 
+        {data_tbl} FT
+    JOIN 
+        {metadata_tbl} MT 
+    ON 
+        FT.MAPPING_ID = MT.MAPPING_ID
+    WHERE 
+        FT.MAPPING_ID = '{mapping_id}'
+    AND 
+        FT.TIME_STAMP 
+            BETWEEN '{start_date}' AND '{end_date}'
     """

scripts/core/handler/trends_handler.py

-import copy
-from datetime import datetime
+"""
+Project: Trends Dashboard Handler
+
+Description:
+    This module contains a class responsible for creating tables and performing
+    calculations for PepsiCo metrics.
+    It provides methods to retrieve metadata and data for the Trends dashboard.
+
+Author: [H115-301: Suryakant Soni]
+
+"""
 
 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_departments, get_parameters, get_filter_query
+    get_departments, get_parameters, get_filter_query, get_form_data
 )
 from scripts.core.schemas.postgres import TableObject
 from scripts.core.logging.application_logging import logger
-from scripts.core.exception.app_exceptions import GeneralException
 from scripts.core.schemas.postgres.postgres_tables import \
     TrendsMasterTable, TrendsFormTable
 
 
 class TrendsDashboardHandler:
     """
-        Class responsible for creating tables and performing calculations for
-        PepsiCo metrics.
+    Class responsible for creating tables and performing calculations for
+    PepsiCo metrics.
     """
 
     def get_trends_metadata(self, request_data):
         """
-        get_trends_metadata
+        Retrieve metadata for trends dashboard.
+
+        Parameters:
+            request_data : Object containing request parameters.
+
+        Returns:
+            dict: Metadata for trends dashboard.
         """
+        logger.info("Getting Metadata")
         final_metadata_json = dict()
         clause = None
 
         logger.info("Database initialization")
         db_init = database_init()
 
-        # Creating table object
+        logger.info("Initiating table object")
         trends_master_tbl_obj = TableObject(
             db=db_init, table_name=TrendsMasterTable
         )
 
+        logger.info(f"Current level: {request_data.current_level}")
+
         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(
@@ -51,7 +68,7 @@ class TrendsDashboardHandler:
                 table=TrendsMasterTable
             )
 
-        # Getting response from the Trends Master Table
+        logger.info("Getting response from the Trends Master Table")
         response_data = trends_master_tbl_obj.execute_query(
             query=filter_query
         )
@@ -65,7 +82,9 @@ class TrendsDashboardHandler:
             )
 
         if parameter_flag:
-            filter_query = get_parameters(where_clause=clause)
+            filter_query = get_parameters(table=postgres_details.master_tbl,
+                                          where_clause=clause)
+
             # Getting response from the Trends Master Table
             response_data = trends_master_tbl_obj.execute_query(
                 query=filter_query
@@ -76,36 +95,141 @@ class TrendsDashboardHandler:
                     final_metadata_json=final_metadata_json,
                     parameter_flag=parameter_flag
                 )
-
         return final_metadata_json
 
     def get_trends_data(self, request_data):
         """
-        Docstring
+        Retrieve data for trends dashboard.
+
+        Parameters:
+            request_data : Object containing request parameters.
+
+        Returns:
+            dict: Data for trends dashboard.
         """
-        return True
+        logger.info("Getting data from form table")
+        final_data_json = dict()
+
+        logger.info("Database initialization")
+        db_init = database_init()
+
+        # Creating table object
+        trends_data_tbl_obj = TableObject(
+            db=db_init, table_name=TrendsFormTable
+        )
+
+        if request_data.start_date and request_data.end_date \
+                and request_data.mapping_id:
+            data_query = get_form_data(
+                metadata_tbl=postgres_details.master_tbl,
+                data_tbl=postgres_details.data_tbl,
+                mapping_id=request_data.mapping_id,
+                start_date=request_data.start_date,
+                end_date=request_data.end_date
+            )
+            # Getting response from the Trends Master Table
+            response_data = trends_data_tbl_obj.execute_query(
+                query=data_query
+            )
+            if response_data:
+                logger.info("Calculate mean value")
+                total_value = sum(entry['value'] for entry in response_data)
+                mean_value = round((total_value / len(response_data)), 2)
+
+                logger.info("Creating the required JSON format")
+                final_data_json = {
+                    "header_content": Constants.HEADER_CONTENT,
+                    "body_content": [
+                        {
+                            "date": entry['time_stamp'].strftime("%m-%d-%Y %H:%M:%S"),
+                            "parameter": entry['parameter'],
+                            "value": entry['value'],
+                            "mean": mean_value,
+                            "upper_limit": entry['upper_value'],
+                            "lower_limit": entry['lower_limit']
+                        }
+                        for entry in response_data
+                    ],
+                    "upper_limit": response_data[0]['upper_value'],
+                    "lower_limit": response_data[0]['lower_limit'],
+                    "mean": mean_value
+                }
+            else:
+                logger.info("No data in database")
+                final_data_json = {
+                    "header_content": Constants.HEADER_CONTENT,
+                    "body_content": [],
+                    "upper_limit": 0,
+                    "lower_limit": 0,
+                    "mean": 0
+                }
+
+        return final_data_json
 
     def get_response_data(self, response_data, final_metadata_json, parameter_flag):
+        """
+        Process response data.
+
+        Parameters:
+            response_data (list): List of response data.
+            final_metadata_json (dict): Final metadata JSON.
+            parameter_flag (bool): Flag indicating parameter presence.
+
+        Returns:
+            tuple: Tuple containing updated metadata JSON and 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]:
+
+        if parameter_flag:
+            logger.info("Getting parameter data from metadata table")
+            filter_data = {}
+
+            # Iterate through the response_data list
+            for each_data in response_data:
+                parameter_name = each_data['parameter']
+                parameter_type = each_data['parameter_type']
+
+                # If the parameter doesn't exist in filter_data, add it
+                if parameter_name not in filter_data:
+                    filter_data[parameter_name] = {
+                        "key": parameter_name,
+                        "label": parameter_name,
+                        "mapping_id": each_data["mapping_id"],
+                        "type": []
+                    }
+
+                # Add the parameter_type to the type list if it doesn't exist
+                if parameter_type not in [t["key"] for t in
+                                          filter_data[parameter_name]["type"]]:
+                    filter_data[parameter_name]["type"].append({
+                        "key": parameter_type,
+                        "label": parameter_type
+                    })
+            final_metadata_json.update({
+                "filter_name": "parameter",
+                "values": list(filter_data.values())
+            })
+        else:
+            logger.info("Getting filter values from metadata table")
+            for each_data in response_data:
+                if not parameter_flag and 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 not parameter_flag and len(each_data) == 1:
+                    filter_name = list(each_data.keys())[0]
                     values.append({
-                        "key": filter_name[1][1],
-                        "label": filter_name[1][1]
+                        "key": each_data[filter_name],
+                        "label": each_data[filter_name]
                     })
-                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
+                    final_metadata_json["filter_name"] = filter_name
+                    final_metadata_json["values"] = values
         return final_metadata_json, parameter_flag

scripts/core/schemas/api/__init__.py

 from .trends_schema import (
     DashboardFilterInput,
     DashboardFilterOutput,
+    DashboardFormInput,
+    DashboardFormOutput
 )
 
 trends_request = DashboardFilterInput
 trends_response = DashboardFilterOutput
+trends_form_request = DashboardFormInput
+trends_form_response = DashboardFormOutput

scripts/core/schemas/api/trends_schema.py

 from __future__ import annotations
-import json
-from datetime import datetime
-from typing import Optional, Any
+from typing import Optional
 from pydantic import BaseModel
 
 
@@ -20,15 +18,14 @@ class DashboardFilterOutput(BaseModel):
 
 
 class DashboardFormInput(BaseModel):
-    start_date: Optional[str] = None
-    end_date: Optional[str] = None
-    mapping_id: Optional[str] = None
-    department: Optional[str] = None
-    function: Optional[str] = None
-    form: Optional[str] = None
-    parameter: Optional[str] = None
+    start_date: Optional[str]
+    end_date: Optional[str]
+    mapping_id: Optional[str]
 
 
 class DashboardFormOutput(BaseModel):
-    filter_name: str
-    values: list
+    header_content: list
+    body_content: list
+    upper_limit: float
+    lower_limit: float
+    mean: float

scripts/core/schemas/postgres/postgres_tables.py

@@ -5,7 +5,7 @@ Base = declarative_base()
 
 
 class TrendsMasterTable(Base):
-    __tablename__ = "trends_master_tbl_"
+    __tablename__ = "trends_master_tbl"
 
     id = Column(Integer, primary_key=True, autoincrement=True)
     mapping_id = Column(VARCHAR, nullable=True)
@@ -14,20 +14,16 @@ class TrendsMasterTable(Base):
     form = Column(VARCHAR, nullable=True)
     filter = Column(JSON, nullable=True)
     parameter = Column(VARCHAR, nullable=True)
+    parameter_type = Column(VARCHAR, nullable=True)
     trend_captured = Column(BOOLEAN, nullable=True)
     lower_limit = Column(FLOAT, nullable=True)
     upper_value = Column(FLOAT, nullable=True)
 
-    # index_name = Index("trends_master_tbl_", mapping_id, department,
-    #                    function, form, filter, parameter)
-
 
 class TrendsFormTable(Base):
-    __tablename__ = "trends_form_tbl_"
+    __tablename__ = "trends_form_tbl"
 
     id = Column(Integer, primary_key=True, autoincrement=True)
     mapping_id = Column(VARCHAR, nullable=True)
     time_stamp = Column(TIMESTAMP)
-    value = Column(VARCHAR, nullable=True)
-
-    # index_name = Index("trends_form_tbl_", mapping_id, time_stamp)
+    value = Column(FLOAT, nullable=True)

scripts/core/service/trends_service.py

@@ -17,7 +17,8 @@ from fastapi.responses import JSONResponse
 from scripts.constants import Constants, APIConstants
 from scripts.core.logging.application_logging import logger
 from scripts.core.schemas.api import (
-    trends_request, trends_response
+    trends_request, trends_response,
+    trends_form_request, trends_form_response
 )
 from scripts.core.handler.trends_handler import TrendsDashboardHandler
 
@@ -66,15 +67,15 @@ async def dashboard_metadata(
 
 
 @downday_router.post(APIConstants.DASHBOARD_DATA_ENDPOINT,
-                     response_model=trends_response)
+                     response_model=trends_form_response)
 async def dashboard_data(
-        request_data: trends_request
+        request_data: trends_form_request
 ):
     """
     Initiate postgres db and create tables
 
     Args:
-        request_data (DashboardFilterInput): Request body containing the
+        request_data (DashboardFormInput): Request body containing the
         necessary form parameters.
 
     Returns:

scripts/core/utilities/common_utility.py

@@ -19,7 +19,7 @@
 #         - headers (dict): The headers to be included in the GET request.
 #
 #         Returns:
-#         - dict or None: The JSON response data if successful, or None if there is an
+#         - dict or None: The JSON response each_data if successful, or None if there is an
 #           error.
 #         """
 #         response_data = None
@@ -29,7 +29,7 @@
 #                 params=params,
 #                 headers=headers).json()
 #         except GeneralException as err:
-#             logger.error(f"Exception in GET API data: {err}")
+#             logger.error(f"Exception in GET API each_data: {err}")
 #         return response_data
 #
 #     def request_post(self, url, headers):
@@ -41,7 +41,7 @@
 #         - headers (dict): The JSON payload to be included in the POST request.
 #
 #         Returns:
-#         - dict or None: The JSON response data if successful, or None if there is an
+#         - dict or None: The JSON response each_data if successful, or None if there is an
 #           error.
 #         """
 #         response_data = None
@@ -50,5 +50,5 @@
 #                 url=url,
 #                 json=headers).json()
 #         except GeneralException as err:
-#             logger.error(f"Exception in POST API data: {err}")
+#             logger.error(f"Exception in POST API each_data: {err}")
 #         return response_data