HR-ATS-Portal/backend/inbox/app.py

from fastapi import APIRouter,Depends, Query
from fastapi.responses import JSONResponse
from fastapi import HTTPException
from db_setup import get_session
from inbox.enums import Candidate_application_Status
from sqlalchemy.ext.asyncio import AsyncSession
from inbox.views import Email
from users.permissions import PermissionTag, require_permission
from dotenv import load_dotenv
load_dotenv()

router = APIRouter()

@router.get("/email/fetch")
async def fetch_email(
    top:int=Query(100),
    skip:int=Query(0,ge=0),
    test_on: bool = Query(True),
    token: str | None = Query(None),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session,token=token)
        if not service.token:
            raise HTTPException(status_code=401,detail="Unauthorized")
        data=await service.service_email(top,skip)
        value=data.get("value")
        items_lst=[]
        for item in value:
            message_id=item.get("id")
            service_per_email=await service.get_email_by_id(message_id,test_on)
            items_lst.append({"message_id":message_id,"email_contents":service_per_email})

        if service.pending_match_ids:
            await service.enqueue_matching(list(service.pending_match_ids),force=False)

        account_setup=[]
        if test_on:
            return JSONResponse(content={"data":items_lst,"status_code":200})
        if service.pending_confirmation_emails:
            account_setup=await service.send_account_setup(list(service.pending_confirmation_emails))

        return JSONResponse(content={"data":items_lst,"account_setup":account_setup,"status_code":200})
    
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/inbox/fetch")
async def fetch_inbox(
    record_id: str | None = Query(None),
    search: str | None = Query(None),
    top: int | None = Query(None),
    skip: int = Query(0, ge=0),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        if record_id:
            item=await service.get_inbox_message_by_id(record_id)
            return JSONResponse(content={"data":item,"total":1,"status_code":200})

        items=await service.get_inbox_messages(top,skip,search)
        total=await service.count_inbox_messages(search)
        return JSONResponse(content={"data":items,"total":total,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.post("/inbox/{record_id}/match")
async def rematch_inbox(
    record_id: str,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        queued_id=await service.queue_rematch(record_id)
        task_ids=await service.enqueue_matching([queued_id], force=True)
        return JSONResponse(content={"data":{"queued":True,"task_ids":task_ids},"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.post("/inbox/{record_id}/read")
async def mark_inbox_read(
    record_id: str,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.mark_read(record_id)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/inbox/{record_id}/read-status")
async def get_inbox_read_status(
    record_id: str,
    token: str | None = Query(None),
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session,token=token)
        data=await service.refresh_read_status(record_id)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))

@router.get("/inbox/all-applications")
async def get_all_applications(
    record_id: str | None = Query(None),
    application_status: Candidate_application_Status = Query(default=Candidate_application_Status.CLOSED),
    isread: bool = Query(default=True),
    search: str | None = Query(None),
    top: int | None = Query(None),
    skip: int = Query(0, ge=0),
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_VIEW)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        
        if application_status == Candidate_application_Status.PROCESS or application_status==Candidate_application_Status.REJECTED:
            items=await service.get_all_applications(top, skip, search, application_status=application_status)
            total=await service.count_inbox_messages(search, application_status=application_status)
            return JSONResponse(content={"data":items,"total":total,"status_code":200})
        if isread==False:
            items=await service.get_all_applications(top, skip, search, isread=False)
            total=await service.count_inbox_messages(search, isread=False)
            return JSONResponse(content={"data":items,"total":total,"status_code":200})
        if record_id:
            item=await service.get_application_by_id(record_id)
            return JSONResponse(content={"data":item,"total":1,"status_code":200})

        items=await service.get_all_applications(top,skip,search)
        total=await service.count_inbox_messages(search)
        return JSONResponse(content={"data":items,"total":total,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))