Signal R for main code

 import asyncio

import azure.functions as func

import logging

import json

import functools

import multiples_sales_caliberation

import multiples_ebitda_caliberation

import multiples_sales_liquidity

import multiples_ebitda_liquidity

import gorden_growth

import dcf_exit_multiples_sales

import dcf_exit_multiples_ebitda

import extract_document_data

import asset_sensitivity_check

from response_handling import handle_error, handle_success

from fn_pwc_cit_rates_scaper_bronze import bp as cit_bronze_scraper

from fn_cit_rates_bronze_silver_transformation import bp as cit_bronze_silver_transformation

from fn_risk_premium_scraper_bronze import bp as risk_premium_scraper_bronze

from fn_risk_premium_bronze_gold_transformation import bp as risk_premium_bronze_gold_transformation

from connection import send_restapi_message,notify_and_handle_errors,get_engine,get_connection_details

from constants import STORED_PROCEDURES

from sqlalchemy import create_engine, text

app = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION)

app.register_functions(cit_bronze_scraper)

app.register_functions(cit_bronze_silver_transformation)

app.register_functions(risk_premium_scraper_bronze)

app.register_functions(risk_premium_bronze_gold_transformation)

#todo other functions should be mved to separate files in another PR

# Wrapper function with decorator

@app.route(route="fn_asset_valuation")

@notify_and_handle_errors

async def fn_asset_valuation(req: func.HttpRequest) -> func.HttpResponse:

    logging.info('Python HTTP trigger function processed a request.')

    # try:

    engine = get_engine()

    conn=get_connection_details()

    req_body = req.get_json()

    Asset_Valuation_Id = req_body.get('Asset_Valuation_Id', 'Unknown')

    Methodology_Id = int(req_body.get('Methodology_Id', 0))  # Convert to int safely

    switch = {

        1: lambda: multiples_sales_caliberation.multiples_sales_caliberation(Asset_Valuation_Id, Methodology_Id),

        2: lambda: multiples_sales_liquidity.multiples_sales_liquidity(Asset_Valuation_Id, Methodology_Id),

        3: lambda: multiples_ebitda_caliberation.multiples_ebitda_caliberation(Asset_Valuation_Id, Methodology_Id),

        4: lambda: multiples_ebitda_liquidity.multiples_ebitda_liquidity(Asset_Valuation_Id, Methodology_Id),

        5: lambda: (

            multiples_sales_caliberation.multiples_sales_caliberation(Asset_Valuation_Id, Methodology_Id),

            gorden_growth.gorden_growth(Asset_Valuation_Id, Methodology_Id)

        ),

        6: lambda: (

            multiples_sales_liquidity.multiples_sales_liquidity(Asset_Valuation_Id, Methodology_Id),

            gorden_growth.gorden_growth(Asset_Valuation_Id, Methodology_Id)

        ),

        7: lambda: (

            multiples_ebitda_caliberation.multiples_ebitda_caliberation(Asset_Valuation_Id, Methodology_Id),

            gorden_growth.gorden_growth(Asset_Valuation_Id, Methodology_Id)

        ),

        8: lambda: (

            multiples_ebitda_liquidity.multiples_ebitda_liquidity(Asset_Valuation_Id, Methodology_Id),

            gorden_growth.gorden_growth(Asset_Valuation_Id, Methodology_Id)

        ),

        9: lambda: (

            multiples_sales_caliberation.multiples_sales_caliberation(Asset_Valuation_Id, Methodology_Id),

            dcf_exit_multiples_sales.dcf_exit_multiples_sales(Asset_Valuation_Id, Methodology_Id)

        ),

        10: lambda: (

            multiples_sales_liquidity.multiples_sales_liquidity(Asset_Valuation_Id, Methodology_Id),

            dcf_exit_multiples_sales.dcf_exit_multiples_sales(Asset_Valuation_Id, Methodology_Id)

        ),

        11: lambda: (

            multiples_ebitda_caliberation.multiples_ebitda_caliberation(Asset_Valuation_Id, Methodology_Id),

            dcf_exit_multiples_ebitda.dcf_exit_multiples_ebitda(Asset_Valuation_Id, Methodology_Id)

        ),

        12: lambda: (

            multiples_ebitda_liquidity.multiples_ebitda_liquidity(Asset_Valuation_Id, Methodology_Id),

            dcf_exit_multiples_ebitda.dcf_exit_multiples_ebitda(Asset_Valuation_Id, Methodology_Id)

        )

    }

    proc_name = STORED_PROCEDURES['CLEAN_VALUATION']

    # Execute the MERGE statement

    with engine.begin() as connection:

        connection.execute(

                text(f"EXEC {proc_name} @Asset_Valuation_Id = :asset_id"),

                {"asset_id": Asset_Valuation_Id}

                            )

    result = await switch.get(Methodology_Id, lambda: {"error": "Invalid Methodology_Id"})()

    return result

       

   

@app.route(route="fn_extract_document_data")

@notify_and_handle_errors

async def fn_extract_document_data(req: func.HttpRequest) -> func.HttpResponse :

    req_body = req.get_json()

    Asset_Valuation_Id = req_body.get('Asset_Valuation_Id', 'Unknown')

    Asset_Fund_Year_Map_Id = req_body.get('Asset_Fund_Year_Map_Id', 'Unknown')

    Backtesting_Year_Id = req_body.get('Backtesting_Year_Id', 'Unknown')

    Document_Id = req_body.get('Document_Id', 'Unknown')

    Extraction_Method = req_body.get('Extraction_Method', 'Unknown')

    # Only business logic here

    result = await extract_document_data.fn_extract_document_data( Asset_Valuation_Id,Asset_Fund_Year_Map_Id,Backtesting_Year_Id,Document_Id,Extraction_Method)

    return result  # Decorator handles JSON/HttpResponse wrapping

@app.route(route="fn_sensitivity_check")

@notify_and_handle_errors

async def fn_sensitivity_check(req: func.HttpRequest) -> func.HttpResponse :

    req_body = req.get_json()

    Asset_Valuation_Id = req_body.get('Asset_Valuation_Id', 'Unknown')

    # Only business logic here

    result = await asset_sensitivity_check.asset_sensitivity_check( Asset_Valuation_Id)

    return result  # Decorator handles JSON/HttpResponse wrapping