app.py

from fastapi import FastAPI ,File, UploadFile,Form
from pydantic import BaseModel
from typing import List,Optional
from component.mongoconnection import provideClient
from component.checkaccountexists import checkAccount
from component.filechecker import checkFile
from component.getproblems import GetProblems
from component.getdeep import GetDeepDive
from component.getbreakdown import GetBreakdown



from component.legal_points_agent import LegalKeyPoints
from component.legal_deepdive_agent import LegalDeepDive
from component.legal_breakdown_agent import LegalBreakdown


from component.medical_points_agent import MedicalKeyPoints
from component.medical_deepdive_agent import MedicalDeepDive
from component.medical_breakdown_agent import MedicalBreakdown



from component.research_deepdive_agent import ResearchDeepDive
from component.research_points_agent import ResearchKeyPoints
from component.research_breakdown_agent import ResearchBreakdown


from fastapi.middleware.cors import CORSMiddleware
from PyPDF2 import PdfReader
import io
import time

origins=[
    "http://localhost:3000"
]


app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)



mclient=provideClient()

db=mclient["askmydoc_db"]
coll=db["askmydoc_col"]

class Item(BaseModel):
    owner:str

class Item2(BaseModel):
    owner: str
    filetype:str

class QAI(BaseModel):
    owner:str
    files:List[str]
    question:str
    msg_type:str

class QA2(BaseModel):
    owner:str
    files:List[str]

class QA3(BaseModel):
     owner:str
     msg_type:str


class QA4(BaseModel):
    owner:str
    msg_type:str
    files:List[str]
     

@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.post("/setupaccount")
def create_item(data: Item):
    print(data.owner)
    payload={

          "owner":data.owner,
          "app_id":"askmydoc_v1",
          "files":[],
          "keypoints":[],
          "deepdive":[],
          "breakdown":[]

    }
    inserted=coll.insert_one(payload)
    if inserted.inserted_id:
        return {"status":True}
    else:

        return {"status":False}

@app.post("/checkaccount")
def checkaccount(data:Item):
    status=checkAccount(data.owner)
    print(data)
    if status==True:
        return {'status':True}
    else:
        return {"status":False}
    

@app.post("/checkfile")
def checkfileexistence(data:Item2):
    filechecksresponse=checkFile(data.owner,data.filetype)
    return filechecksresponse



@app.post("/checkproblems")
def checkProblems(data:QA4):
     problems=GetProblems(data.owner,data.msg_type,data.files)
     return problems    


@app.post("/checkdive")
def checkProblems(data:QA4):
     DIVE=GetDeepDive(data.owner,data.msg_type,data.files)
     return DIVE

3
@app.post("/checkbreakdown")
def checkProblems(data:QA4):
     DIVE=GetBreakdown(data.owner,data.msg_type,files=data.files)
     return DIVE



@app.post("/upload-files")
async def upload_files(
    files: List[UploadFile] = File(...),
    owner: Optional[str] = Form(None),
    filetype:Optional[str]=Form(None)
    ):


    MAX_FILE_SIZE = 5 * 1024 * 1024 
    results = []
    if len(files) > 2:
        return {"error":"maximum 2 files allowed"}
    try:
        for file in files:
            contents = await file.read()
            if len(contents) > MAX_FILE_SIZE:
                return {
                    "error": f"File '{file.filename}' exceeds 5MB limit",
                    "max_size": "5MB"
            }
            file_info = {
                "filename": file.filename,
                "content_type": file.content_type,
                "size": len(contents),
                "filetype":filetype
            }
            if file.content_type == "text/plain":
                # Decode text files - now we can safely return full content
                text_content = contents.decode("utf-8")
                file_info["content"] = text_content  # Full content since we have size limit
            elif file.content_type == "application/pdf":
            # Extract text from PDF
                try:
                    pdf_file = io.BytesIO(contents)
                    pdf_reader = PdfReader(pdf_file)
                    text_content = ""
                    for page in pdf_reader.pages:
                        text_content += page.extract_text() + "\n"
                        file_info["content"] = text_content
                        file_info["pages"] = len(pdf_reader.pages)
                except Exception as e:
                        file_info["error"] = f"Failed to read PDF: {str(e)}"

    
        results.append(file_info)
        coll.update_one(
                {"owner": owner},
                {"$push": {"files": {"$each": results}}}
        )
       

        return {"status":True}
    except Exception as e:
        return {"status":False}




    
@app.post("/legalproblems")
def LegalProblems(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:
         
        checkifalreadypresent=GetProblems(data.owner,"legal",data.files)

        
        if len(checkifalreadypresent["problems"]) !=0:
             return checkifalreadypresent["problems"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                problems=LegalKeyPoints(content=content)
                payload={"type":"legal","problems":problems,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"keypoints": payload}}
                )

                return {"problems":problems}
    else:            

                return {"problems":None}
    


@app.post("/legaldeepdive")
def LegalDDive(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetDeepDive(data.owner,"legal",data.files)

        
        if len(checkifalreadypresent["dive"]) !=0:
             return checkifalreadypresent["dive"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                dive=LegalDeepDive(content=content)
                payload={"type":"legal","dive":dive,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"deepdive": payload}}
                )
                return {"deepdive":dive}
    else:            

                return {"deepdive":None}






@app.post("/legalbreakdown")
def LegalB(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:

        checkifalreadypresent=GetBreakdown(data.owner,"legal",data.files)


        if len(checkifalreadypresent["breakdown"])!=0:
             return checkifalreadypresent["breakdown"]

        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                breakdown=LegalBreakdown(content=content)
                payload={"type":"legal","breakdown":breakdown,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"breakdown": payload}}
                )

                return {"problems":breakdown}
    else:            

                return {"problems":None}






@app.post("/medicalproblems")
def MedicalProblems(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetProblems(data.owner,"medical",data.files)

        
        if len(checkifalreadypresent["problems"]) !=0:
             return checkifalreadypresent["problems"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                problems=MedicalKeyPoints(content=content)
                payload={"type":"medical","problems":problems,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"keypoints": payload}}
                )

                return {"problems":problems}
    else:            

                return {"problems":None}




@app.post("/medicaldeepdive")
def MedicalDDive(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetDeepDive(data.owner,"medical",data.files)

        
        if len(checkifalreadypresent["dive"]) !=0:
             return checkifalreadypresent["dive"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                dive=MedicalDeepDive(content=content)
                payload={"type":"medical","dive":dive,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"deepdive": payload}}
                )

                return {"deepdive":dive}
    else:            

                return {"deepdive":None}




@app.post("/medicalbreakdown")
def MedicalB(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:

        checkifalreadypresent=GetBreakdown(data.owner,"medical",data.files)

        
        if len(checkifalreadypresent["breakdown"]) !=0:
             return checkifalreadypresent["breakdown"]



        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                breakdown=MedicalBreakdown(content=content)
                payload={"type":"medical","breakdown":breakdown,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"breakdown": payload}}
                )

                return {"problems":breakdown}
    else:            

                return {"problems":None}





@app.post("/researchproblems")
def ResearchProblems(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetProblems(data.owner,"research",data.files)

        
        if len(checkifalreadypresent["problems"])!=0:
             return checkifalreadypresent["problems"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                problems=ResearchKeyPoints(content=content)
                payload={"type":"research","problems":problems,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"keypoints": payload}}
                )

                return {"problems":problems}
    else:            

                return {"problems":None}




@app.post("/researchbreakdown")
def ResearchB(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:


        checkifalreadypresent=GetBreakdown(data.owner,"research",data.files)

        
        if len(checkifalreadypresent["breakdown"]) !=0:
             return checkifalreadypresent["breakdown"]

        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                breakdown=ResearchBreakdown(content=content)
                payload={"type":"research","breakdown":breakdown,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"breakdown": payload}}
                )

                return {"problems":breakdown}
    else:            

                return {"problems":None}

'''

'''
@app.post("/researchdeepdive")
def ResearchDDive(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:



        checkifalreadypresent=GetDeepDive(data.owner,"research",data.files)

        
        if len(checkifalreadypresent["dive"]) !=0:
             return checkifalreadypresent["dive"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                dive=ResearchDeepDive(content=content)
                payload={"type":"research","dive":dive,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"deepdive": payload}}
                )

                return {"deepdive":dive}
    else:            

                return {"deepdive":None}