src/privacy/routing/privacy_router.py

'''
MIT license https://opensource.org/licenses/MIT Copyright 2024 Infosys Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
'''

from io import BytesIO
from tempfile import NamedTemporaryFile
import threading
import time
import uuid

import requests
from privacy.util.code_detect.ner.pii_inference.netcustom import code_detect_ner
from privacy.util.code_detect.ner.CodePIINER import codeNer
# from privacy.dao.TelemetryFlagDb import TelemetryFlag
from fastapi import Depends, Query,Request,APIRouter, HTTPException, WebSocket,websockets,FastAPI,Cookie,Body
from typing import List, Union

from privacy.service.privacytelemetryservice import PrivacyTelemetryRequest
from privacy.service.Video_service import *

from fastapi.params import Form
from privacy.mappers.mappers import *
#from privacy.mappers.mappers import PIIEntity, PIIAnalyzeRequest, PIIAnonymizeResponse, PIIAnonymizeRequest,PIIAnalyzeResponse,PIIImageAnonymizeResponse,PIIImageAnalyzeResponse,PIIImageAnalyzeRequest


from privacy.service.Video_service import VideoService
# from privacy.service.logo_service import Logo 
from privacy.service.code_detect_service import *
from privacy.service.excel_service import Excel

from privacy.exception.exception import PrivacyException
from privacy.config.logger import CustomLogger

from fastapi import FastAPI, UploadFile,File
from fastapi.responses import FileResponse
from datetime import date
import concurrent.futures
from fastapi import Request
from fastapi.responses import StreamingResponse
from privacy.util.code_detect.ner.pii_inference.netcustom import *
# from privacy.util.face_detect.mask_detect_video import mask_video
import logging
# from privacy.code_generator.codegeneration import create_new_recognizer_file,modify_recognizer_registry,modify_init_py,run_wheel_creation_commands, copy_wheel_file,test
# from privacy.dao.privacy.PrivacyException import ExceptionDb
# from privacy.dao.privacy.TelemetryDb import TelemetryDb
from privacy.service.api_req import *
from privacy.service.__init__ import *
from privacy.service.textPrivacy import TextPrivacy,Shield
from privacy.service.imagePrivacy import ImagePrivacy
from privacy.service.dicomPrivacy import DICOMPrivacy
import cv2
import numpy as np
router = APIRouter()
# user_id=1234
log=CustomLogger()
app = FastAPI()

fileRouter=APIRouter()
# logger = UserLogger()

import tracemalloc
from transformers import AutoModelForTokenClassification, AutoTokenizer
#@router.post('/privacy/text/analyze', response_model= PIIAnalyzeResponse)
today = date.today()
from datetime import datetime
import asyncio
from dotenv import load_dotenv
load_dotenv()
# import gc
import os
from uuid import UUID, uuid4
# from fastapi_sessions.backends.implementations import InMemoryBackend
# from fastapi_sessions.frontends.implementations import SessionCookie, CookieParameters
# from request_id_store import request_ids
from privacy.config.logger import request_id_var
import traceback
from fastapi import APIRouter, HTTPException, Request, Depends
from pydantic import BaseModel
from fastapi.responses import JSONResponse
from privacy.util.auth.auth_client_id import get_auth_client_id
from privacy.util.auth.auth_jwt import get_auth_jwt
from privacy.util.auth.auth_none import get_auth_none

# from fastapi.se

# from fastapi_session import get_session
# returns current date and time
now = datetime.now()
# from memory_profiler import profile
# telFlagData = TelemetryFlag.findall({})[0]
# tel_Falg = telFlagData["TelemetryFlag"]
# telFlagData = TelemetryFlag.findall({"Module":"Privacy"})
# print("Teldata==",telFlagData)
# if(len(telFlagData) == 0):
    # telData = TelemetryFlag.create({"module":"Privacy"})
    # print("telData===",telData)
magMap = {"True": True, "False": False,"true": True, "false": False}
tel_Falg=os.getenv("TELE_FLAG")
tel_Falg=magMap[tel_Falg]
# tel_Falg = os.getenv("TELE_FLAG", "False")  # Default to "False" if TELE_FLAG is not set
# tel_Falg = magMap.get(tel_Falg, False)  # Use .get() to safely access the dictionary and default to False if the key doesn't exist
# print("===============",tel_Falg,type(tel_Falg))
privacytelemetryurl = os.getenv("PRIVACY_TELEMETRY_URL")
privacyerrorteleurl = os.getenv("PRIVACY_ERROR_URL")

# print("tel_falg===",tel_Falg)
# Load the model and tokenizer for CODEFILE API
local_model_directory = "privacy/util/code_detect/ner/pii_inference/nermodel"
model = AutoModelForTokenClassification.from_pretrained(local_model_directory)
tokenizer = AutoTokenizer.from_pretrained(local_model_directory, model_max_length=10000)



class NoAccountException(Exception):
    pass

class NoAdminConnException(Exception):
    pass



## FUNCTION FOR FAIL_SAFE TELEMETRY
def send_telemetry_request(privacy_telemetry_request):
    id = uuid.uuid4().hex
    request_id_var.set("telemetry")

    try:
        # print("==",privacy_telemetry_request)
        log.debug("teleReq="+str(privacy_telemetry_request))
        
        response = requests.post(privacytelemetryurl, json=privacy_telemetry_request)
        # print/("===,",response)
        response.raise_for_status()
        response_data = response.json()
        log.debug("tele data response: "+ str(response))
        # print(response_data)
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"send_telemetry_requestFunction","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        raise HTTPException(
            status_code=500,    
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
        
        
class Telemetry:
    def error_telemetry_request(errobj,id):
        request_id_var.set(id)

        try:
            # print("==",privacy_telemetry_request)
            log.debug("teleReq="+str(errobj))
            if(tel_Falg):

                response = requests.post(privacyerrorteleurl, json=errobj)
                # print("===,",response)
                response.raise_for_status()
                response_data = response.json()
                log.debug("tele error response: "+ str(response))
                # print(response_data)
        except Exception as e:
            log.error(str(e))
            # ExceptionDb.create({"UUID":request_id_var.get(),"function":"send_telemetry_requestFunction","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
            raise HTTPException(
                status_code=500,    
                detail="Please check with administration!!",
                headers={"X-Error": "Please check with administration!!"})
        


# Authentication 

auth_type = os.environ.get("AUTH_TYPE")

if auth_type == "azure":
    auth = get_auth_client_id()
elif auth_type == "jwt":
    auth = get_auth_jwt()

elif auth_type == 'none':
    auth = get_auth_none()
else:
    raise HTTPException(status_code=500, detail="Invalid authentication type configured")
    

router = APIRouter()


@router.post('/privacy/text/analyze', response_model= PIIAnalyzeResponse)
# @profile
def analyze(payload: PIIAnalyzeRequest,auth= Depends(auth)):

    # gc.collect()
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered into analyze routing method" )

    try:
        log.debug("request payload: "+ str(payload))
        startTime = time.time()
        log.debug("Entered into analyze function")
        tracemalloc.start()
        # raise Exception()
        response = TextPrivacy.analyze(payload)
        ApiCall.delAdminList()
        tracemalloc.stop()
        log.debug("Returned from analyze function")
        endTime = time.time()
        totalTime = endTime - startTime
          
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            # print("Inside Raise Exception")
            # return "Portfolio/Account Is Incorrect"
            raise NoAccountException
        # print("---",response.admin)
        if(response==404):
            raise NoAdminConnException
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},

        # )
    
        log.debug("response : "+ str(response))
        log.info("exit create from analyze routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("TelFlag==="+ str(tel_Falg))
        # TelemetryDb.create({"UUID":id,"tenant":"privacy","apiName":analyze.__name__,"portfolio":payload.portfolio,"accountName":payload.account,"exclusion_list":payload.exclusionList,"entityrecognised":"Text"})
        if(tel_Falg == True):
            responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
            requestList = payload.__dict__
            requestObj = {
                "portfolio_name": payload.portfolio if payload.portfolio is not None else "None",
                "account_name": payload.account if payload.account is not None else "None",
                "inputText": requestList["inputText"],
                "exclusion_list": requestList["exclusionList"].split(',') if requestList["exclusionList"] is not None else [],
            }
            # lotNumber = 0  # Initialize lotNumber with a default value
            # if payload.lotNumber is not None:
            #     lotNumber = payload.lotNumber
            
            telemetryPayload = {
                "uniqueid": id,
                "tenant": "privacy",
                "apiname": analyze.__name__,           
                "user": payload.user if payload.user is not None else "None",
                "date":now.isoformat(),
                "lotNumber": payload.lotNumber if payload.lotNumber is not None else "None",
                # "exclusionList": payload.exclusionList,
                "request": requestObj,
                "response": responseList
            }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            with concurrent.futures.ThreadPoolExecutor() as executor:
                executor.submit(send_telemetry_request, telemetryPayload)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        # responseprivacytelemetry = requests.post(privacytelemetryurl, json=privacy_telemetry_request.__dict__)
        # gc.collect()
        return response
    except PrivacyException as cie:
        log.debug("Exception for analyze")
        log.error(cie.__dict__)

        er=[{"UUID":request_id_var.get(),"function":"textAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        # 
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        # ExceptionDb.create({"UUID":id,"function":"textAnalyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
        # print(cie)
        # print(cie.__dict__)
        log.error(cie, exc_info=True)
        log.info("exit create from analyze routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # print(error_dict)
        er=[{"UUID":request_id_var.get(),"function":"textAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        # 
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
    
@router.post('/privacy/text/anonymize', response_model= PIIAnonymizeResponse)
def anonymize(payload: PIIAnonymizeRequest,auth= Depends(auth)):
    
    id = uuid.uuid4().hex
    request_id_var.set(id)
    
    log.info("Entered create into anonymize routing method")
    try:
        # log.info("Entered create usecase routing method" )
        log.debug("request payload: "+ str(payload))
        startTime = time.time()
        log.debug("Entered into anonymize function")
        response = TextPrivacy.anonymize(payload)
        ApiCall.delAdminList()
        log.debug("Returned from anonymize function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
        # log.info("after invoking create usecase service ")
        log.debug("response : "+ str(response))
        log.info("exit create from anonymize routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        # log.debug("Tel Flag==="+ str(tel_Falg))
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            requestList = payload.__dict__
            requestObj = {
               "portfolio_name": payload.portfolio if payload.portfolio is not None else "None",
                "account_name": payload.account if payload.account is not None else "None",
                "inputText": requestList["inputText"],
                "exclusion_list": requestList["exclusionList"].split(',') if requestList["exclusionList"] is not None else [],
            }
            responseObj = {
                "type": "None",
                "beginOffset": 0,
                "endOffset": 0,
                "score": 0,
                "responseText": response.anonymizedText
            }
            # lotNumber = 0  # Initialize lotNumber with a default value
            # if payload.lotNumber is not None:
            #     lotNumber = payload.lotNumber
            telemetryPayload = {
                "uniqueid": id,
                "tenant": "privacy",
                "apiname": anonymize.__name__,
                "user": payload.user if payload.user is not None else "None",
                "date":now.isoformat(),
                "lotNumber": payload.lotNumber if payload.lotNumber is not None else "None",
                # "exclusionList": payload.exclusionList,
                "request": requestObj,
                "response": [responseObj]
            }
            # TelemetryDb.create(telemetryPayload)
            
            
            # Trigger the API call asynchronously using a separate thread
           
            with concurrent.futures.ThreadPoolExecutor() as executor:
                executor.submit(send_telemetry_request, telemetryPayload)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
    except PrivacyException as cie:
        log.error("Exception for anonymize")
        log.error(cie.__dict__)
        er=[{"UUID":id,"function":"textAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        # 
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from anonymize routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        # 
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
            
@router.post('/privacy/text/encrpyt',response_model=PIIEncryptResponse)
def encrypt(payload: PIIAnonymizeRequest,auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    
    log.info("Entered create into encrypt routing method")
    try:
        log.debug("request payload: "+ str(payload))
        startTime = time.time()
        log.debug("Entered into encrypt function")
        response = TextPrivacy.encrypt(payload)
        log.debug("Returned from encrypt function")
        endTime = time.time()
        totalTime = endTime - startTime
        print("response=======",response)
        log.info("Total Time taken "+str(totalTime))
        
        if(response==None):
            raise NoAccountException
        
        # log.debug("response : "+ str(response))
        log.info("exit create from encrypt routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        # log.debug("Tel Flag==="+ str(tel_Falg))
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            requestList = payload.__dict__
            requestObj = {
               "portfolio_name": payload.portfolio if payload.portfolio is not None else "None",
                "account_name": payload.account if payload.account is not None else "None",
                "inputText": requestList["inputText"],
                "exclusion_list": requestList["exclusionList"].split(',') if requestList["exclusionList"] is not None else [],
            }
            responseObj = {
                "type": "None",
                "beginOffset": 0,
                "endOffset": 0,
                "score": 0,
                "responseText": response.text
            }
            # lotNumber = 0  # Initialize lotNumber with a default value
            # if payload.lotNumber is not None:
            #      lotNumber = payload.lotNumber
            telemetryPayload = {
                "uniqueid": id,
                "tenant": "privacy",
                "apiname": anonymize.__name__,
                "user": payload.user if payload.user is not None else "None",
                "date":now.isoformat(),
                "lotNumber": payload.lotNumber if payload.lotNumber is not None else "None",
                # "exclusionList": payload.exclusionList,
                "request": requestObj,
                "response": [responseObj]
            }
            # TelemetryDb.create(telemetryPayload)
            
            
            # Trigger the API call asynchronously using a separate thread
           
            with concurrent.futures.ThreadPoolExecutor() as executor:
                executor.submit(send_telemetry_request, telemetryPayload)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
       
    except PrivacyException as cie:
        log.error("Exception for encrypt")
        log.error(cie.__dict__)
        er=[{"UUID":id,"function":"textEncryptRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        # 
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from encrypt routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
        
@router.post('/privacy/text/decrpyt',response_model= PIIDecryptResponse)  
def decrypt(payload: PIIDecryptRequest,auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into decrypt routing method")
    try:
        log.debug("request payload: "+ str(payload))
        startTime = time.time()
        log.debug("Entered into decrypt function")
        response = TextPrivacy.decryption(payload)
        log.debug("Returned from decrypt function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        return response
    except PrivacyException as cie:
        log.error("Exception for decrypt")
        log.error(cie.__dict__)
        er=[{"UUID":id,"function":"textDecryptRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        # 
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from decrypt routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id]
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})

@router.post('/privacy/image/analyze', response_model= PIIImageAnalyzeResponse)
def image_analyze(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into image_analyze routing method")
    try:
       
        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
        log.debug("Requested payload" + str(payload))
        startTime = time.time()
        log.debug("Entered into image_analyze function")
        response = ImagePrivacy.image_analyze(payload)
        ApiCall.delAdminList()
        log.debug("Returned from image_analyze function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException        
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
        
        log.info("exit create from image_analyze routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("tel_Flag==="+str(tel_Falg))
        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
        # requestList = payload.__dict__
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": image_analyze.__name__,
            #     # "portfolio": portfolio,
            #     # "accountName": account,
            #     # "exclusion_list": exclusionList,
            #     "request": requestList,
            #     "response": responseList
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
        
    except PrivacyException as cie:
        log.error("Exception for image_analyze")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"imageAnalyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"imageAnalyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from image_analyze routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"imageAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})

@router.post('/privacy/image/anonymize')
def image_anonymize(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into image_anonymize routing method" )
    try:
        
        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
        log.debug("Payload:"+str(payload))
        startTime = time.time()
        log.debug("Entered into image_anonymize function")
        response = ImagePrivacy.image_anonymize(payload)
        ApiCall.delAdminList()
        log.debug("Returned from image_anonymize function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
        
        
        log.info("exit create from image_anonymize routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("tel_Flag==="+str(tel_Falg))
        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
        # requestList = payload.__dict__
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": image_anonymize.__name__,
            #     # "portfolio": portfolio,
            #     # "accountName": account,
            #     # "exclusion_list": exclusionList,
            #     "request": requestList,
            #     "response": responseList
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
        
    except PrivacyException as cie:
        log.error("Exception for image_anonymize")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"imageAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"imageAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create usecase routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"imageAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})

@router.post('/privacy/image/masking')
async def image_mask(media: UploadFile = File(...), template: UploadFile = File(...),auth= Depends(auth)):
    try:
        # log.info("before invoking create usecase service ")
        main_image_content = await media.read()
        nparr = np.fromstring(main_image_content, np.uint8)
        main_image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)

        template_image_content = await template.read()
        nparr = np.fromstring(template_image_content, np.uint8)
        template_image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
        if template_image.shape[0] > main_image.shape[0] or template_image.shape[1] > main_image.shape[1]:
            raise HTTPException(status_code=400, detail ="Mask image must be smaller or equal in size to the main image")
        response = await ImagePrivacy.image_masking(main_image,template_image)
        # log.info("after invoking image masking service")
        is_success, buffer = cv2.imencode(".png", response)

        # Create a StreamingResponse from the image buffer
        return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/png")
    except PrivacyException as cie:
        log.error(cie.__dict__)
        log.info("exit create usecase routing method")
        raise HTTPException(**cie.__dict__)
# @router.post('/privacy/pii/image/anonymize/zip')                                   #########@#@@#@#$@
# def image_anonymize(payload: UploadFile):
#     try:
#         log.info("Entered create usecase routing method" )
#         response = service.zipimage_anonymize(payload)
#         if(response==None):
#             raise HTTPException(
#             status_code=430,
#             detail="Portfolio/Account Is Incorrect",
#             headers={"X-Error": "There goes my error"},
#         )
#         log.info("after invoking create usecase service ")
        
#         log.info("exit create usecase routing method")
#         return response
        
#     except PrivacyException as cie:
#         log.error(cie.__dict__)
#         log.info("exit create usecase routing method")
#         raise HTTPException(**cie.__dict__)


# @router.post('/privacy/pii/image/anonymize/multiple')
# def image_anonymize(payload: List[UploadFile] = File(...)):
#     try:
#         log.info("Entered create usecase routing method" )
#         response=[]
#         for image in payload:
#             response.append(service.image_anonymize(image))
            
#         log.info("after invoking create usecase service ")
        
#         log.info("exit create usecase routing method")
#         return response
        
#     except PrivacyException as cie:
#         log.error(cie.__dict__)
#         log.info("exit create usecase routing method")
#         raise HTTPException(**cie.__dict__)

# @router.post('/privacy/pii/image/analyze/multiple')#,response_model=PIIMultipleImageAnalyzeResponse)
# def image_analyze(payload: List[UploadFile] = File(...)):
#     try:
#         log.info("Entered create usecase routing method" )
#         response=[]
#         for image in payload:
#             response.append(service.temp(image))
        
#         log.info("after invoking create usecase service ")
        
#         log.info("exit create usecase routing method")
#         return response
        
#     except PrivacyException as cie:
#         log.error(cie.__dict__)
#         log.info("exit create usecase routing method")
#         raise HTTPException(**cie.__dict__)


@router.post('/privacy/image/verify')
def image_verify(image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into image_verify routing method" )
    try:
        payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
        log.debug("request payload: "+str(payload))
        startTime = time.time()
        log.debug("Entered into image_verify function")
        response = ImagePrivacy.image_verify(payload)
        ApiCall.delAdminList()
        log.debug("Returned from image_verify function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException        
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
      
        
        log.info("exit create from image_verify routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("tel_Flag==="+ str(tel_Falg))
        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": image_verify.__name__,
            #     # "portfolio": portfolio,
            #     # "accountName": account,
            #     # "exclusion_list": exclusionList,
            #     "request": payload,
            #     "response": response
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
        
    except PrivacyException as cie:
        log.error("Exception for image_verify")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"imageVerifyRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"imageVerifyRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from image_verify routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageVerifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"imageVerifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
    
    
@router.post('/privacy/image/hashify')
def image_hashify(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into imageEncryption routing method" )
    try:
        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
        log.debug("request payload: "+str(payload))
        startTime = time.time()
        log.debug("Entered into imageEncryption function")
        response = ImagePrivacy.imageEncryption(payload)
        ApiCall.delAdminList()
        log.debug("Returned from imageEncryption function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException        
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
        log.info("exit create from into imageEncryption routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("tel_Flag==="+str(tel_Falg))
        # requestList = payload.__dict__
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": image_verify.__name__,
            #     # "portfolio": portfolio,
            #     # "accountName": account,
            #     # "exclusion_list": exclusionList,
            #     "request": requestList,
            #     "response": response
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
        
    except PrivacyException as cie:
        log.error("Exception for imageEncryption")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"imageHashifyRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"imageHashifyRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create usecase routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageHashifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"imageHashifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
    


@router.post('/privacy/privacyShield', response_model= PIIPrivacyShieldResponse)
def privacy_shield(payload: PIIPrivacyShieldRequest,auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into privacyShield routing method")
    try:
        # log.info("Entered create usecase routing method" )
        log.debug("request payload: "+ str(payload))
        startTime = time.time()
        log.debug("Entered into privacyShield function")
        response = Shield.privacyShield(payload)
        ApiCall.delAdminList()
        log.debug("Returned from privacyShield function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException        
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
        # log.info("after invoking create usecase service ")
        log.debug("response : "+ str(response))
        log.info("exit create from privacyShield routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("tel_Flag==="+str(tel_Falg))
        # responseList = response.privacyCheck
        # requestList = payload.__dict__
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": "privacyshield",
            #     # "portfolio": payload.portfolio,
            #     # "accountName": payload.account,
            #     # "exclusion_list": "None",
            #     "request": requestList,
            #     "response": responseList
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
    except PrivacyException as cie:
        log.error("Exception for privacyShield")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"privacyShield","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"privacyShield","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from privacyShield routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"privacyShield","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"privacyShield","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})

# from privacy.service.dicom_service import DICOM
# @router.get('/privacy/pii/dicom/anonymize')
# def image_anonymize():
#     try:
#         log.info("Entered create usecase routing method" )
#         # payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
#         # log.info(str(payload))
#         # response = service.image_anonymize(payload)
#         response=DICOM.dicomReader()
#         # print(response)
        
#         # if(response==None):
#         #     raise HTTPException(
#         #     status_code=430,
#         #     detail="Portfolio/Account Is Incorrect",
#         #     headers={"X-Error": "There goes my error"},
#         # )
#         log.info("after invoking create usecase service ")
        
#         log.info("exit create usecase routing method")
#         return response
        
#     except PrivacyException as cie:
#         log.error(cie.__dict__)
#         log.info("exit create usecase routing method")
#         raise HTTPException(**cie.__dict__)
 
   
@router.post('/privacy/dicom/anonymize')
def dicom_anonymize(payload: UploadFile = File(...),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into readDicom routing method" )
    try:
        # payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
        startTime = time.time()
        log.debug("Entered into readDicom function")
        response =DICOMPrivacy.readDicom(payload)
        log.debug("Returned from readDicom function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException  
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
     
        
        log.info("exit create from readDicom routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("tel_Flag==="+str(tel_Falg))
        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
        # requestList = payload.__dict__
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": "DICOMIMAGE",
            #     # "portfolio": "None",
            #     # "accountName": "None",
            #     # "exclusion_list": "None",
            #     "request": requestList,
            #     "response": responseList
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return response
        
    except PrivacyException as cie:
        log.error("Exception for readDicom")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"DICOMAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"DICOMAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from readDicom routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"DICOMAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"DICOMAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})

@fileRouter.post('/privacy-files/excel/anonymize')
def logo_anonymize(excel: UploadFile = File(...),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into excelanonymize routing method" )
    try:
        payload={"excel":excel}
        print("payload==",payload)
        # print("type==",excel.file.content_type)
        startTime = time.time()
        log.debug("Entered into excelanonymize function")
        response = Excel.excelanonymize(payload)
        log.debug("Returned from excelanonymize function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        if(response==404):
            raise NoAdminConnException  
        
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
       
        log.info("exit create from excelanonymize routing method")
        log.debug("response===="+str(response))
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        log.debug("tel_Flag==="+str(tel_Falg))
        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
        # requestList = payload.__dict__
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": "Excel_Anonymize",
            #     # "portfolio": "None",
            #     # "accountName": "None",
            #     # "exclusion_list": "None",
            #     "request": requestList,
            #     "response": responseList
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")
        return FileResponse(response,media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
        # return response
        
    except PrivacyException as cie:
        log.error("Exception for excelanonymize")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"excelAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"excelAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create usecase routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except NoAdminConnException:
        raise HTTPException(
            status_code=435,
            detail=" Accounts and Portfolio not available with the Subscription!!",
            headers={"X-Error": "Admin Connection is not established,"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"excelAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"excelAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})

## PAYLOAD CHANGED TO ACCEPT TEXT IN A STRUCTURED FORMAT AND GET RESPONSE FOR THE SAME
from starlette.responses import PlainTextResponse
@router.post('/privacy/code/anonymize',response_class=PlainTextResponse)
async def code_redaction(payload_text: str = Body(..., media_type="text/plain", description="The code to be anonymized"),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into textner routing method")
    try:
        log.debug("payload==" + str(payload_text))
        
        startTime = time.time()
        log.debug("Entered into textner function")
        response = codeNer.codeText(payload_text,model, tokenizer)
        log.debug("Returned from textner function")
        
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken " + str(totalTime))
        log.debug("response" + str(response))
        
        if response is None:
            raise NoAccountException
        
        log.info("exit create from textner routing method")
        # Return the response as plain text, maintaining the format
        return PlainTextResponse(content=response)
    except PrivacyException as cie:
        log.error("Exception for code anonymize")
        raise cie

from io import BytesIO

@router.post('/privacy/codefile/anonymize')
async def code_anonymize(code_file: UploadFile = File(...)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into filener routing method" )
    try:
        # Read the file content from the UploadFile object
        code_content = await code_file.read()
        print("code_content==",code_content)
        # Perform code redaction
        startTime = time.time()
        log.debug("Entered into filener function")
        redacted_content, output_code_file = codeNer.codeFile(code_content, code_file.filename,model, tokenizer)
        log.debug("Returned from filener function")
        if isinstance(redacted_content, str):
            redacted_content = redacted_content.encode('utf-8')
        print(redacted_content,"REDACTED CONTENT")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        headers = {
            "Content-Disposition": f"attachment; filename={output_code_file}",
            "Access-Control-Expose-Headers": "Content-Disposition"
        }

        # Delete the uploaded file
        await code_file.close()
        # filepath = os.path.join('', code_file.filename)
        output_code_file = os.path.splitext(code_file.filename)[0] + "_redacted" + os.path.splitext(code_file.filename)[1]
        os.remove(output_code_file)
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
        # requestList = payload.__dict__
        if(tel_Falg == True):
            log.debug("Inside Telemetry Flag")
            # telemetryPayload = {
            #     "uniqueid": id,
            #     "tenant": "privacy",
            #     "apiName": code_anonymize.__name__,
            #     # "portfolio": "None",
            #     # "accountName": "None",
            #     # "exclusion_list": "None",
            #     "request": requestList,
            #     "response": responseList
            # }
            # TelemetryDb.create(telemetryPayload)
            
            # Trigger the API call asynchronously using a separate thread
            # with concurrent.futures.ThreadPoolExecutor() as executor:
            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
            log.info("******TELEMETRY REQUEST COMPLETED********")

        # Return the redacted code content as a response with the correct filename
        return StreamingResponse(BytesIO(redacted_content), media_type="application/octet-stream", headers=headers)
    except PrivacyException as cie:
        log.error("Exception for filener")
        log.error(cie, exc_info=True)
        # ExceptionDb.create({"UUID":id,"function":"codeFileAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"codeFileAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise cie
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"codeFileAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"codeFileAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})




# # from privacy.service.test import Test
# @router.get('/privacy/pii/video/anonymizea')
# async def image_analyze():
#     try:
#         log.info("Entered create usecase routing method" )
#         # payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
#         # response =VideoAnalyzer.anonymize(payload)
#         # print(response)
#         # if(response==None):
#         #     raise HTTPException(
#         #     status_code=430,
#         #     detail="Portfolio/Account Is Incorrect",
#         #     headers={"X-Error": "There goes my error"},
#         # )
#         # log.info("after invoking create usecase service ")
#         # x=[]
#         x=Test.work()
#         # for i in x:
#         #     print(i)
#         # log.info("exit create usecase routing method")
#         return StreamingResponse(x,media_type="plain/text")
        
        
#     except PrivacyException as cie:
#         log.error(cie.__dict__)
#         log.info("exit create usecase routing method")
#         raise HTTPException(**cie.__dict__)
# app=FastAPI()
# cc=set()
# @app.websocket("/ws")
# async def check(websocket:WebSocket):
#     await websocket.accept()
#     cc.add(websocket)
#     try:
#         while True:
#             m="asdasdasdasdasd"
#             await websocket.send_text(m)
#             await asyncio.sleep(1)
#     except:
#         cc.remove(websocket)



from privacy.service.diffrentialPrivacy import DiffPrivacy
@router.post('/privacy/DifferentialPrivacy/file')
def diff_privacy_file(dataset: UploadFile = File(...),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into uploadFIle routing method" )
    try:
        # payload={"excel":excel}
        # print("payload==",payload)
        # print("type==",excel.file.content_type)
        startTime = time.time()
        log.debug("Entered into uploadFIle function")
        response = DiffPrivacy.uploadFIle(dataset)
        log.debug("Returned from uploadFIle function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
        # log.info("after invoking create usecase service ")
        
        log.info("exit create from uploadFIle routing method")
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        # print("tel_Flag===",tel_Falg)
        # if(tel_Falg == True):
        #     print("Inside Telemetry Flag")
        #     
        #     # Trigger the API call asynchronously using a separate thread
        #     with concurrent.futures.ThreadPoolExecutor() as executor:
            #    executor.submit(send_telemetry_request, privacy_telemetry_request)
        return response
    except PrivacyException as cie:
        log.error("Exception for uploadFIle")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"diffPrivacyFileRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyFileRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create from uploadFIle routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"diffPrivacyFileRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyFileRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
    
from privacy.service.diffrentialPrivacy import DiffPrivacy
@router.post('/privacy/DifferentialPrivacy/anonymize')
def diff_privacy_anonymize(suppression:Optional[str]=Form(""),noiselist:Optional[str]=Form(""),binarylist:Optional[str]=Form(""),rangeList:Optional[str]=Form(""),auth= Depends(auth)):
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into diffPrivacy routing method" )
    try:
        # log.info("Entered create usecase routing method" )
        # payload={"excel":excel}
        # print("payload==",payload)
        payload={"suppression":suppression,"noiselist":noiselist,"binarylist":binarylist,"rangelist":rangeList}
        # print("type==",excel.file.content_type)
        startTime = time.time()
        log.debug("Entered into diffPrivacy function")
        response = DiffPrivacy.diffPrivacy(payload)
        log.debug("Returned from diffPrivacy function")
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        #     raise HTTPException(
        #     status_code=430,
        #     detail="Portfolio/Account Is Incorrect",
        #     headers={"X-Error": "There goes my error"},
        # )
        # log.info("after invoking create usecase service ")
        
        log.info("exit create from diffPrivacy routing method")
        log.debug("res===="+str(response))
        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
        # tel_Falg = telFlagData["TelemetryFlag"]
        # print("tel_Flag===",tel_Falg)
        # if(tel_Falg == True):
        #     print("Inside Telemetry Flag")
        #     
        #     # Trigger the API call asynchronously using a separate thread
        #     with concurrent.futures.ThreadPoolExecutor() as executor:
            #    executor.submit(send_telemetry_request, privacy_telemetry_request)
        # return response
        headers = {"Content-Disposition": f"attachment; filename=x.csv"}
        return StreamingResponse(response, media_type="text/csv", headers=headers)
    except PrivacyException as cie:
        log.error("Exception for diffPrivacy")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"diffPrivacyAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        log.error(cie, exc_info=True)
        log.info("exit create usecase routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except Exception as e:
        log.error(str(e))
        # er={"UUID":request_id_var.get(),"function":"diffPrivacyAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
        logobj = {"uniqueid":id,"error":er}
        
        if len(er)!=0:
            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
            thread.start()
            
            if request_id_var.get() in error_dict:
                del error_dict[id] 
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})
   
@fileRouter.post('/privacy-files/video/anonymize')
async def videoPrivacy(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),video: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
    # payload = {"video": video, "easyocr": ocr}
    id = uuid.uuid4().hex
    request_id_var.set(id)
    log.info("Entered create into image_anonymize routing method" )
    try:
        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"video":video,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
        startTime = time.time()
        response = await VideoService.videoPrivacy(payload)
        endTime = time.time()
        totalTime = endTime - startTime
        log.info("Total Time taken "+str(totalTime))
        if(response==None):
            raise NoAccountException
        
        
        log.info("exit create from image_anonymize routing method")
        return response
        
    except PrivacyException as cie:
        log.error("Exception for video_privacy")
        log.error(cie.__dict__)
        # ExceptionDb.create({"UUID":id,"function":"videoPrivacyRouter","msg":cie.__dict__,"description":cie.__dict__})
       
        log.error(cie, exc_info=True)
        log.info("exit create usecase routing method")
        raise HTTPException(**cie.__dict__)
    except NoAccountException:
        raise HTTPException(
            status_code=430,
            detail="Portfolio/Account Is Incorrect",
            headers={"X-Error": "There goes my error"},
        )
    except Exception as e:
        log.error(str(e))
        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"videoPrivacyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
        raise HTTPException(
            status_code=500,
            detail="Please check with administration!!",
            headers={"X-Error": "Please check with administration!!"})