fix: async apis

apis/endpoints/admin.py

@@ -13,55 +13,55 @@ router = APIRouter()
 
 
 @router.put("/clinic/status")
-def update_clinic_status(req:Request, data: ClinicStatusUpdate):
+async def update_clinic_status(req:Request, data: ClinicStatusUpdate):
-    ClinicServices().update_clinic_status(req.state.user, data.clinic_id, data.status, data.documentStatus, data.rejection_reason)
+    await ClinicServices().update_clinic_status(req.state.user, data.clinic_id, data.status, data.documentStatus, data.rejection_reason)
     return ApiResponse(data="OK", message="Clinic status updated successfully")
 
 @router.post("/user")
-def create_user(req:Request, user_data: CreateSuperAdmin):
+async def create_user(req:Request, user_data: CreateSuperAdmin):
-    AuthService().create_super_admin(req.state.user, user_data)
+    await AuthService().create_super_admin(req.state.user, user_data)
     return ApiResponse(data="OK", message="User created successfully")
 
 @router.put("/user/{user_id}")
-def update_user(req:Request, user_id: int, user_data: UpdateSuperAdmin):
+async def update_user(req:Request, user_id: int, user_data: UpdateSuperAdmin):
-    AuthService().update_super_admin(req.state.user, user_id, user_data)
+    await AuthService().update_super_admin(req.state.user, user_id, user_data)
     return ApiResponse(data="OK", message="User updated successfully")
 
 @router.delete("/user/{user_id}")
-def delete_user(req:Request, user_id: int):
+async def delete_user(req:Request, user_id: int):
-    AuthService().delete_super_admin(req.state.user, user_id)
+    await AuthService().delete_super_admin(req.state.user, user_id)
     return ApiResponse(data="OK", message="User deleted successfully")
 
 
 @router.get("/")
-def get_users(req:Request, limit:int = DEFAULT_LIMIT, page:int = DEFAULT_PAGE, search:str = ""):
+async def get_users(req:Request, limit:int = DEFAULT_LIMIT, page:int = DEFAULT_PAGE, search:str = ""):
     if page < 1:
         page = 1
     offset = (page - 1) * limit
-    users = AuthService().get_admins(req.state.user, limit, offset, search)
+    users = await AuthService().get_admins(req.state.user, limit, offset, search)
     return ApiResponse(data=users, message="Users retrieved successfully")
 
 @router.post("/master-data")
-def create_master_data(appointment_type: MasterAppointmentTypeBase):
+async def create_master_data(appointment_type: MasterAppointmentTypeBase):
-    MasterAppointmentServices().create_master_appointment_type(appointment_type)
+    await MasterAppointmentServices().create_master_appointment_type(appointment_type)
     return ApiResponse(data="OK", message="Master data created successfully")
 
 
 @router.delete("/master-data/{master_appointment_type_id}")
-def delete_master_data(master_appointment_type_id: int):
+async def delete_master_data(master_appointment_type_id: int):
-    MasterAppointmentServices().delete_master_appointment_type(master_appointment_type_id)
+    await MasterAppointmentServices().delete_master_appointment_type(master_appointment_type_id)
     return ApiResponse(data="OK", message="Master data deleted successfully")
 
 
 @router.put("/master-data/{master_appointment_type_id}")
-def update_master_data(master_appointment_type_id: int, appointment_type: MasterAppointmentTypeBase):
+async def update_master_data(master_appointment_type_id: int, appointment_type: MasterAppointmentTypeBase):
-    MasterAppointmentServices().update_master_appointment_type(master_appointment_type_id, appointment_type)
+    await MasterAppointmentServices().update_master_appointment_type(master_appointment_type_id, appointment_type)
     return ApiResponse(data="OK", message="Master data updated successfully")
 
 
 @router.get("/master-data")
-def get_master_data():
+async def get_master_data():
-    appointment_types = MasterAppointmentServices().get_master_appointment_types()
+    appointment_types = await MasterAppointmentServices().get_master_appointment_types()
     return ApiResponse(data=appointment_types, message="Master data retrieved successfully")
 
 
@@ -77,7 +77,7 @@ async def get_clinic_offers(
         page = 1
     offset = (page - 1) * limit
     
-    clinic_offers = ClinicServices().get_clinic_offers(req.state.user, limit, offset, search)
+    clinic_offers = await ClinicServices().get_clinic_offers(req.state.user, limit, offset, search)
     return ApiResponse(data=clinic_offers, message="Clinic offers retrieved successfully")
 
 
@@ -86,7 +86,7 @@ async def create_clinic_offer(
     req:Request,
     clinic_offer: ClinicOffersBase
 ):
-    ClinicServices().create_clinic_offer(req.state.user, clinic_offer)
+    await ClinicServices().create_clinic_offer(req.state.user, clinic_offer)
     return ApiResponse(data="OK", message="Clinic offer created successfully")
 
 @router.put("/clinic/offer/{clinic_offer_id}")
@@ -95,7 +95,7 @@ async def update_clinic_offer(
     clinic_offer_id: int,
     clinic_offer: ClinicOffersBase
 ):
-    ClinicServices().update_clinic_offer(req.state.user, clinic_offer_id, clinic_offer)
+    await ClinicServices().update_clinic_offer(req.state.user, clinic_offer_id, clinic_offer)
     return ApiResponse(data="OK", message="Clinic offer updated successfully")
 
 @router.delete("/clinic/offer/{clinic_offer_id}")
@@ -103,6 +103,6 @@ async def delete_clinic_offer(
     req:Request,
     clinic_offer_id: int
 ):
-    ClinicServices().delete_clinic_offer(req.state.user, clinic_offer_id)
+    await ClinicServices().delete_clinic_offer(req.state.user, clinic_offer_id)
     return ApiResponse(data="OK", message="Clinic offer deleted successfully")
     

apis/endpoints/auth.py

@@ -4,13 +4,12 @@ from schemas.CreateSchemas import UserCreate
 from schemas.ApiResponse import ApiResponse
 from schemas.BaseSchemas import AuthBase, AuthOTP, ResetPasswordBase
 from services.clinicServices import ClinicServices
-from http import HTTPStatus
 
 router = APIRouter()
 
 @router.post("/login")
-def login(data: AuthBase):
+async def login(data: AuthBase):
-    token = AuthService().login(data)
+    token = await AuthService().login(data)
     return ApiResponse(
         data=token,
         message="Login successful"
@@ -18,16 +17,16 @@ def login(data: AuthBase):
 
 
 @router.post("/register")
-def register(user_data: UserCreate, background_tasks: BackgroundTasks):
+async def register(user_data: UserCreate, background_tasks: BackgroundTasks):
-    token = AuthService().register(user_data, background_tasks)
+    token = await AuthService().register(user_data, background_tasks)
     return ApiResponse(
         data=token,
         message="User registered successfully"
     )
 
 @router.get("/clinic/latest-id")
-def get_latest_clinic_id():
+async def get_latest_clinic_id():
-    clinic_id = ClinicServices().get_latest_clinic_id()
+    clinic_id = await ClinicServices().get_latest_clinic_id()
     return ApiResponse(
         data=clinic_id,
         message="Latest clinic ID retrieved successfully"
@@ -35,24 +34,27 @@ def get_latest_clinic_id():
 
 
 @router.post('/admin/forget-password')
-def forget_password(email: str):
+async def forget_password(email: str):
-    AuthService().forget_password(email)
+    await AuthService().forget_password(email)
     return ApiResponse(data="OK", message="Password reset email sent successfully")
 
 @router.post('/admin/reset-password')
-def reset_password(data: ResetPasswordBase):
+async def reset_password(data: ResetPasswordBase):
-    AuthService().reset_password(data.token, data.password)
+    await AuthService().reset_password(data.token, data.password)
     return ApiResponse(data="OK", message="Password reset successfully")
 
 
 @router.post("/send-otp")
-def send_otp(email: str):
+async def send_otp(email: str):
-    AuthService().send_otp(email)
+    await AuthService().send_otp(email)
-    return HTTPStatus.OK
+    return ApiResponse(
+        data="OK",
+        message="OTP sent successfully"
+    )
 
 @router.post("/verify-otp")
-def verify_otp(data: AuthOTP):
+async def verify_otp(data: AuthOTP):
-    AuthService().verify_otp(data)
+    await AuthService().verify_otp(data)
     return ApiResponse(
         data="OK",
         message="OTP verified successfully"

apis/endpoints/call_transcripts.py

@@ -7,15 +7,15 @@ router = APIRouter()
 
 
 @router.get("/")
-def get_call_transcripts(limit:int = DEFAULT_LIMIT, page:int = DEFAULT_PAGE):
+async def get_call_transcripts(limit:int = DEFAULT_LIMIT, page:int = DEFAULT_PAGE):
     if page == 0:
         page = 1
     offset = (page - 1) * limit
-    response = CallTranscriptServices().get_call_transcripts(limit, offset)
+    response = await CallTranscriptServices().get_call_transcripts(limit, offset)
     return ApiResponse(data=response, message="Call transcripts retrieved successfully")
 
 @router.post("/bulk-download")
-def bulk_download_call_transcripts(key_ids: list[int], background_tasks: BackgroundTasks):
+async def bulk_download_call_transcripts(key_ids: list[int], background_tasks: BackgroundTasks):
     service = CallTranscriptServices()
-    response = service.bulk_download_call_transcripts(key_ids, background_tasks)
+    response = await service.bulk_download_call_transcripts(key_ids, background_tasks)
     return response

apis/endpoints/clinicDoctor.py

@@ -7,21 +7,21 @@ from services.clinicDoctorsServices import ClinicDoctorsServices
 router = APIRouter()
 
 @router.get("/")
-def get_clinic_doctors():
+async def get_clinic_doctors():
-    clinic_doctors = ClinicDoctorsServices().get_clinic_doctors()
+    clinic_doctors = await ClinicDoctorsServices().get_clinic_doctors()
     return ApiResponse(data=clinic_doctors, message="Clinic doctors retrieved successfully")
 
 @router.post("/")
-def create_clinic_doctor(clinic_doctor: ClinicDoctorCreate):
+async def create_clinic_doctor(clinic_doctor: ClinicDoctorCreate):
-    clinic_doctor = ClinicDoctorsServices().create_clinic_doctor(clinic_doctor)
+    clinic_doctor = await ClinicDoctorsServices().create_clinic_doctor(clinic_doctor)
     return ApiResponse(data=clinic_doctor, message="Clinic doctor created successfully")
 
 @router.put("/{clinic_doctor_id}")
-def update_clinic_doctor(clinic_doctor_id: int, clinic_doctor: ClinicDoctorUpdate):
+async def update_clinic_doctor(clinic_doctor_id: int, clinic_doctor: ClinicDoctorUpdate):
-    clinic_doctor = ClinicDoctorsServices().update_clinic_doctor(clinic_doctor_id, clinic_doctor)
+    clinic_doctor = await ClinicDoctorsServices().update_clinic_doctor(clinic_doctor_id, clinic_doctor)
     return ApiResponse(data=clinic_doctor, message="Clinic doctor updated successfully")
 
 @router.delete("/{clinic_doctor_id}")
-def delete_clinic_doctor(clinic_doctor_id: int):
+async def delete_clinic_doctor(clinic_doctor_id: int):
-    ClinicDoctorsServices().delete_clinic_doctor(clinic_doctor_id)
+    await ClinicDoctorsServices().delete_clinic_doctor(clinic_doctor_id)
     return ApiResponse(data="OK", message="Clinic doctor deleted successfully")

apis/endpoints/clinics.py

@@ -28,17 +28,17 @@ async def get_clinics(
     if page < 1:
         page = 1
     offset = (page - 1) * limit
-    clinics = ClinicServices().get_clinics(req.state.user, limit, offset, filter_type, search)
+    clinics = await ClinicServices().get_clinics(req.state.user, limit, offset, filter_type, search)
     return ApiResponse(data=clinics, message="Clinics retrieved successfully" )
 
 @router.get("/verified-files/{clinic_id}")
 async def get_verified_files(clinic_id: int):
-    clinic = ClinicServices().get_clinic_by_id(clinic_id)
+    clinic = await ClinicServices().get_clinic_by_id(clinic_id)
     return ApiResponse(data=clinic, message="Clinic retrieved successfully")
 
 @router.get("/{clinic_id}")
 async def get_clinic(clinic_id: int):
-    clinic = ClinicServices().get_clinic_by_id(clinic_id)
+    clinic = await ClinicServices().get_clinic_by_id(clinic_id)
     return ApiResponse(data=clinic, message="Clinic retrieved successfully")
 
 @router.put("/{clinic_id}")
@@ -46,10 +46,10 @@ async def update_clinic(
     req:Request,
     clinic_id: int, clinic: ClinicUpdate
 ):
-    clinic = ClinicServices().update_clinic(req.state.user, clinic_id, clinic)
+    clinic = await ClinicServices().update_clinic(req.state.user, clinic_id, clinic)
     return ApiResponse(data=clinic, message="Clinic updated successfully")
 
 @router.delete("/{clinic_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_clinic(clinic_id: int):
-    ClinicServices().delete_clinic(clinic_id)
+    await ClinicServices().delete_clinic(clinic_id)
     return ApiResponse(data="OK", message="Clinic deleted successfully")

apis/endpoints/dashboard.py

@@ -8,17 +8,17 @@ router = APIRouter()
 
 @router.get("/")
 async def get_clinic_doctor_status_count(req:Request):
-    counts = DashboardService().get_dashboard_counts(isSuperAdmin=req.state.user["userType"] == UserType.SUPER_ADMIN)
+    counts = await DashboardService().get_dashboard_counts(isSuperAdmin=req.state.user["userType"] == UserType.SUPER_ADMIN)
     return ApiResponse(data=counts, message="Counts fetched successfully")
 
 @router.post("/signup-pricing-master")
 async def update_signup_pricing_master(req:Request, signup_pricing_master:SignupPricingMasterCreate):
     user = req.state.user
-    response = DashboardService().update_signup_pricing_master(user, signup_pricing_master)
+    response = await DashboardService().update_signup_pricing_master(user, signup_pricing_master)
     return ApiResponse(data=response, message="Signup pricing master updated successfully")
 
 
 @router.get("/signup-pricing-master")
 async def get_signup_pricing_master():
-    pricing = DashboardService().get_signup_pricing_master()
+    pricing = await DashboardService().get_signup_pricing_master()
     return ApiResponse(data=pricing, message="Signup pricing master fetched successfully")

apis/endpoints/s3.py

@@ -8,10 +8,7 @@ from schemas.CreateSchemas import S3Create
 router = APIRouter()
 
 @router.post("/")
-def upload_file(data:S3Create):
+async def upload_file(data:S3Create):
-    try:
+
-        resp = upload_file_service(data.folder, data.file_name)
+    resp = await upload_file_service(data.folder, data.file_name)
-        return ApiResponse(data=resp, message="File uploaded successfully")
+    return ApiResponse(data=resp, message="File uploaded successfully")
-    except Exception as e:
-        logger.error(f"Error uploading file: {str(e)}")
-        raise e

apis/endpoints/users.py

@@ -9,12 +9,12 @@ from utils.constants import DEFAULT_LIMIT, DEFAULT_PAGE
 router = APIRouter()
 
 @router.get("/")
-def get_users(limit:int = DEFAULT_LIMIT, page:int = DEFAULT_PAGE, search:str = ""):
+async def get_users(limit:int = DEFAULT_LIMIT, page:int = DEFAULT_PAGE, search:str = ""):
     if page == 0:
         page = 1
     offset = (page - 1) * limit
 
-    user =  UserServices().get_users(limit, offset, search)
+    user =  await UserServices().get_users(limit, offset, search)
     
     return ApiResponse(
         data=user,
@@ -22,10 +22,10 @@ def get_users(limit:int = DEFAULT_LIMIT, page:int = DEFAULT_PAGE, search:str = "
     )
 
 @router.get("/me")
-def get_user(request: Request):
+async def get_user(request: Request):
     try:
         user_id = request.state.user["id"]
-        user = UserServices().get_user(user_id)
+        user = await UserServices().get_user(user_id)
         return ApiResponse(
             data=user,
             message="User fetched successfully"
@@ -35,34 +35,34 @@ def get_user(request: Request):
         raise e
 
 @router.get("/{user_id}")
-def get_user(request: Request, user_id: int):
+async def get_user(request: Request, user_id: int):
-    user =  UserServices().get_user(user_id)
+    user =  await UserServices().get_user(user_id)
     return ApiResponse(
         data=user,
         message="User fetched successfully"
     )
 
 @router.delete("/")
-def delete_user(request: Request):
+async def delete_user(request: Request):
     user_id = request.state.user["id"]
-    UserServices().delete_user(user_id)
+    await UserServices().delete_user(user_id)
     return ApiResponse(
         data="OK",
         message="User deleted successfully"
     )
 
 @router.put("/")
-def update_user(request: Request, user_data: UserUpdate):
+async def update_user(request: Request, user_data: UserUpdate):
     user_id = request.state.user["id"]
-    user = UserServices().update_user(user_id, user_data)
+    user = await UserServices().update_user(user_id, user_data)
     return ApiResponse(
         data=user,
         message="User updated successfully"
     )
 
 @router.put("/{user_id}")
-def update_user(request: Request, user_id: int, user_data: UserUpdate):
+async def update_user(request: Request, user_id: int, user_data: UserUpdate):
-    user = UserServices().update_user(user_id, user_data)
+    user = await UserServices().update_user(user_id, user_data)
     return ApiResponse(
         data=user,
         message="User updated successfully"

middleware/auth_dependency.py

@@ -18,7 +18,7 @@ async def auth_required(request: Request ,credentials: HTTPAuthorizationCredenti
         raise HTTPException(status_code=401, detail="Invalid authentication token")
 
     # Get user from database
-    user = UserServices().get_user(payload["id"]) 
+    user = await UserServices().get_user(payload["id"]) 
 
     # set user to request state
     request.state.user = user

services/authService.py

@@ -36,10 +36,10 @@ class AuthService:
         self.email_service = EmailService()
         self.url = os.getenv("FRONTEND_URL")
 
-    def login(self, data: AuthBase) -> str:
+    async def login(self, data: AuthBase) -> str:
 
         # get user
-        user = self.user_service.get_user_by_email(data.email)
+        user = await self.user_service.get_user_by_email(data.email)
 
         # verify password
         if not verify_password(data.password, user.password):
@@ -53,8 +53,8 @@ class AuthService:
         token = create_jwt_token(user_dict)
         return token
         
-    def register(self, user_data: UserCreate, background_tasks=None):
+    async def register(self, user_data: UserCreate, background_tasks=None):
-        response =  self.user_service.create_user(user_data, background_tasks)
+        response =  await self.user_service.create_user(user_data, background_tasks)
         user = {
             "id": response.id,
             "username": response.username,
@@ -93,7 +93,7 @@ class AuthService:
 
         return "OK"
 
-    def send_otp(self, email:str):
+    async def send_otp(self, email:str):
         otp = generateOTP()
         self.email_service.send_otp_email(email, otp)
 
@@ -105,7 +105,7 @@ class AuthService:
 
         return
 
-    def verify_otp(self, data: AuthOTP):
+    async def verify_otp(self, data: AuthOTP):
         db_otp = self.db.query(OTP).filter(OTP.email == data.email, OTP.otp == data.otp).first()
         if not db_otp:
             raise ValidationException("Invalid OTP")
@@ -121,7 +121,7 @@ class AuthService:
         return
 
     
-    def get_admins(self, user, limit:int, offset:int, search:str):
+    async def get_admins(self, user, limit:int, offset:int, search:str):
         try:
             if user["userType"] != UserType.SUPER_ADMIN:
                 raise UnauthorizedException("User is not authorized to perform this action")
@@ -150,7 +150,7 @@ class AuthService:
         except Exception as e:
             raise e
 
-    def create_super_admin(self, user, data: CreateSuperAdmin):
+    async def create_super_admin(self, user, data: CreateSuperAdmin):
 
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("User is not authorized to perform this action")
@@ -191,7 +191,7 @@ class AuthService:
         return
 
     
-    def update_super_admin(self, user, user_id: int, data: UpdateSuperAdmin):
+    async def update_super_admin(self, user, user_id: int, data: UpdateSuperAdmin):
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("User is not authorized to perform this action")
 
@@ -207,7 +207,7 @@ class AuthService:
 
         return
 
-    def delete_super_admin(self, user, user_id: int):
+    async def delete_super_admin(self, user, user_id: int):
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("User is not authorized to perform this action")
 
@@ -221,7 +221,7 @@ class AuthService:
         return
 
     
-    def forget_password(self, email: str):
+    async def forget_password(self, email: str):
         user = self.db.query(Users).filter(Users.email == email.lower()).first()
 
         if not user:
@@ -240,7 +240,7 @@ class AuthService:
 
         return
         
-    def reset_password(self, token: str, password: str):
+    async def reset_password(self, token: str, password: str):
         reset_password = self.db.query(ResetPasswordTokens).filter(ResetPasswordTokens.token == token).first()
 
         if not reset_password:

services/callTranscripts.py

@@ -18,7 +18,7 @@ class CallTranscriptServices:
     def __init__(self):
         self.db:Session = next(get_db())
     
-    def get_call_transcripts(self, limit:int, offset:int):
+    async def get_call_transcripts(self, limit:int, offset:int):
         call_transcripts = self.db.query(CallTranscripts).limit(limit).offset(offset).all()
 
         total = self.db.query(CallTranscripts).count()
@@ -84,7 +84,7 @@ class CallTranscriptServices:
         except Exception as e:
             print(f"Error during cleanup: {e}")
 
-    def bulk_download_call_transcripts(self, key_ids: list[int], background_tasks: BackgroundTasks):
+    async def bulk_download_call_transcripts(self, key_ids: list[int], background_tasks: BackgroundTasks):
 
         transcript_ids = self.db.query(CallTranscripts).filter(CallTranscripts.id.in_(key_ids)).all()
 

services/clinicDoctorsServices.py

@@ -7,13 +7,15 @@ from sqlalchemy.orm import Session
 from services.clinicServices import ClinicServices
 from exceptions import ResourceNotFoundException
 from interface.common_response import CommonResponse
+from sqlalchemy import func
+from enums.enums import ClinicDoctorStatus
 
 class ClinicDoctorsServices:
     def __init__(self):
         self.db: Session = next(get_db())
         self.clinic_services = ClinicServices()
 
-    def create_clinic_doctor(self, clinic_doctor: ClinicDoctorCreate) -> ClinicDoctorResponse:
+    async def create_clinic_doctor(self, clinic_doctor: ClinicDoctorCreate) -> ClinicDoctorResponse:
 
         # check if clinic exists
         self.clinic_services.get_clinic_by_id(clinic_doctor.clinic_id)
@@ -24,7 +26,7 @@ class ClinicDoctorsServices:
         self.db.refresh(clinic_doctor)
         return ClinicDoctorResponse(**clinic_doctor.__dict__.copy())
 
-    def update_clinic_doctor(self, clinic_doctor_id: int, clinic_doctor_data: ClinicDoctorUpdate) -> ClinicDoctorResponse:
+    async def update_clinic_doctor(self, clinic_doctor_id: int, clinic_doctor_data: ClinicDoctorUpdate) -> ClinicDoctorResponse:
         # check if clinic doctor exists
         clinic_doctor = self.db.query(ClinicDoctors).filter(ClinicDoctors.id == clinic_doctor_id).first()
         if clinic_doctor is None:
@@ -44,15 +46,12 @@ class ClinicDoctorsServices:
         self.db.refresh(clinic_doctor)
         return ClinicDoctorResponse(**clinic_doctor.__dict__.copy())
 
-    def delete_clinic_doctor(self, clinic_doctor_id: int):
+    async def delete_clinic_doctor(self, clinic_doctor_id: int):
         clinic_doctor = self.db.query(ClinicDoctors).filter(ClinicDoctors.id == clinic_doctor_id).first()
         self.db.delete(clinic_doctor)
         self.db.commit()
 
-    def get_doctor_status_count(self):
+    async def get_doctor_status_count(self):
-        # Use SQLAlchemy's func.count to get the count for each status
-        from sqlalchemy import func
-        from enums.enums import ClinicDoctorStatus
         
         # Query to count doctors by status
         status_counts = self.db.query(
@@ -69,7 +68,7 @@ class ClinicDoctorsServices:
             
         return result
         
-    def get_clinic_doctors(self):
+    async def get_clinic_doctors(self):
         clinic_doctors = self.db.query(ClinicDoctors).all()
 
         total = self.db.query(ClinicDoctors).count()

services/clinicServices.py

@@ -11,7 +11,7 @@ from sqlalchemy import or_,not_
 from sqlalchemy import text
 
 from services.s3Service import get_file_key, get_signed_url
-from models import ClinicFileVerifications, ClinicOffers, Clinics
+from models import ClinicFileVerifications, ClinicOffers, Clinics, Users
 from schemas.BaseSchemas import ClinicFileVerificationBase, ClinicOffersBase
 from services.emailService import EmailService
 
@@ -20,12 +20,12 @@ class ClinicServices:
         self.db: Session = next(get_db())
         self.email_service = EmailService()
 
-    def get_clinics(self, user, limit:int, offset:int, filter_type: Union[Literal["UNREGISTERED"], Literal["REGISTERED"]] = "UNREGISTERED", search:str = ""):
+    async def get_clinics(self, user, limit:int, offset:int, filter_type: Union[Literal["UNREGISTERED"], Literal["REGISTERED"]] = "UNREGISTERED", search:str = ""):
 
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("You are not authorized to get clinics")
 
-        clinics_query =  self.db.query(Clinics)
+        clinics_query =  self.db.query(Clinics).order_by(Clinics.update_time.desc())
 
         if filter_type == "UNREGISTERED":
             clinics_query = clinics_query.filter(not_(Clinics.status == ClinicStatus.ACTIVE),not_(Clinics.status == ClinicStatus.INACTIVE))
@@ -43,7 +43,7 @@ class ClinicServices:
                 )
             )
 
-        clinics = clinics_query.limit(limit).offset(offset).all()
+        clinics = clinics_query.offset(offset).limit(limit).all()
                 
         count_query = text("""
             SELECT 
@@ -62,7 +62,7 @@ class ClinicServices:
         clinic_response = [Clinic(**clinic.__dict__.copy()) for clinic in clinics]
 
         for clinic in clinic_response:
-            clinic.logo = get_signed_url(clinic.logo) if clinic.logo else None
+            clinic.logo = await get_signed_url(clinic.logo) if clinic.logo else None
 
         clinic_response_with_total = {
             "clinics": clinic_response,
@@ -74,45 +74,42 @@ class ClinicServices:
 
         return response
 
-    def get_latest_clinic_id(self) -> int:
+    async def get_latest_clinic_id(self) -> int:
         clinic = self.db.query(Clinics).order_by(Clinics.id.desc()).first()
         return clinic.id if clinic else 0
 
 
-    def get_clinic_by_id(self, clinic_id: int):
+    async def get_clinic_by_id(self, clinic_id: int):
-        try:
+        clinic = self.db.query(Clinics).options(joinedload(Clinics.creator)).filter(Clinics.id == clinic_id).first()
-            clinic = self.db.query(Clinics).options(joinedload(Clinics.creator)).filter(Clinics.id == clinic_id).first()
 
-            if clinic is None:
+        if clinic is None:
-                raise ResourceNotFoundException("Clinic not found")
+            raise ResourceNotFoundException("Clinic not found")
 
-            clinic_response = Clinic(**clinic.__dict__.copy())
+        clinic_response = Clinic(**clinic.__dict__.copy())
         
-            clinic_response.logo = get_signed_url(clinic_response.logo) if clinic_response.logo else None
+        clinic_response.logo = await get_signed_url(clinic_response.logo) if clinic_response.logo else None
-            clinic_response.abn_doc = get_signed_url(clinic_response.abn_doc) if clinic_response.abn_doc else None
+        clinic_response.abn_doc = await get_signed_url(clinic_response.abn_doc) if clinic_response.abn_doc else None
-            clinic_response.contract_doc = get_signed_url(clinic_response.contract_doc) if clinic_response.contract_doc else None
+        clinic_response.contract_doc = await get_signed_url(clinic_response.contract_doc) if clinic_response.contract_doc else None
 
-            clinicFiles = None
+        clinicFiles = None
-            if(clinic.status != ClinicStatus.ACTIVE):
+        if(clinic.status != ClinicStatus.ACTIVE):
-                clinicFiles = self.db.query(ClinicFileVerifications).filter(ClinicFileVerifications.clinic_id == clinic_id).first()
+            clinicFiles = self.db.query(ClinicFileVerifications).filter(ClinicFileVerifications.clinic_id == clinic_id).first()
 
-            clinic_resp = {
+        clinic_resp = {
-                "clinic": clinic_response,
+            "clinic": clinic_response,
-                "creator": {
+            "creator": {
-                    "name": clinic.creator.username,
+                "name": clinic.creator.username,
-                    "email": clinic.creator.email,
+                "email": clinic.creator.email,
-                    "phone": clinic.creator.mobile,
+                "phone": clinic.creator.mobile,
-                    "designation": clinic.creator.clinicRole
+                "designation": clinic.creator.clinicRole
-                },
+            },
-                "clinic_files": self.get_clinic_files(clinic_id),
+            "clinic_files": await self.get_clinic_files(clinic_id),
-                "fileStatus": {"reason":clinicFiles.rejection_reason if clinicFiles else None},
+            "fileStatus": {"reason":clinicFiles.rejection_reason if clinicFiles else None},
-            }
+        }
 
-            return clinic_resp
+        return clinic_resp
-        except Exception as e:
-            raise Exception(e)
 
-    def get_clinic_files(self, clinic_id: int):
+    async def get_clinic_files(self, clinic_id: int):
         clinic_files = self.db.query(ClinicFileVerifications).filter(ClinicFileVerifications.clinic_id == clinic_id).first()
 
         if clinic_files is None:
@@ -122,7 +119,7 @@ class ClinicServices:
 
         return response
 
-    def update_clinic(self, user, clinic_id: int, clinic_data: ClinicUpdate):
+    async def update_clinic(self, user, clinic_id: int, clinic_data: ClinicUpdate):
         clinic = self.db.query(Clinics).filter(Clinics.id == clinic_id).first()
 
         if clinic is None:
@@ -149,7 +146,7 @@ class ClinicServices:
 
         return clinic_response
 
-    def delete_clinic(self, clinic_id: int):
+    async def delete_clinic(self, clinic_id: int):
         clinic = self.db.query(Clinics).filter(Clinics.id == clinic_id).first()
 
         if clinic is None:
@@ -157,7 +154,7 @@ class ClinicServices:
 
         clinic.soft_delete(self.db)
 
-    def get_clinic_count(self):
+    async def get_clinic_count(self):
         from sqlalchemy import func
         
         # Get total count
@@ -199,7 +196,7 @@ class ClinicServices:
         return counts
         
     
-    def update_clinic_status(self, user, clinic_id: int, status: ClinicStatus, documentStatus: Optional[dict] = None, rejection_reason: Optional[str] = None):
+    async def update_clinic_status(self, user, clinic_id: int, status: ClinicStatus, documentStatus: Optional[dict] = None, rejection_reason: Optional[str] = None):
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("You are not authorized to update clinic status")
 
@@ -258,11 +255,18 @@ class ClinicServices:
 
         # handle inactive status
         if clinic.status == ClinicStatus.INACTIVE:
+            # get clinic creator
+            # clinic_creator = self.db.query(Users).options(joinedload(Users.created_clinics)).filter(Clinics.id == clinic.id).first()
+
+            # # block clinic creator
+            # clinic_creator.isBlocked = True
+            # self.db.add(clinic_creator)
+            # self.db.commit()
             pass
 
         return 
         
-    def get_clinic_offers(self, user, limit:int, offset:int, search:str = ""):
+    async def get_clinic_offers(self, user, limit:int, offset:int, search:str = ""):
 
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("You are not authorized to get clinic offers")
@@ -283,7 +287,7 @@ class ClinicServices:
 
         return response
 
-    def create_clinic_offer(self, user, clinic_offer_data: ClinicOffersBase):
+    async def create_clinic_offer(self, user, clinic_offer_data: ClinicOffersBase):
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("You are not authorized to create clinic offer")
 
@@ -299,7 +303,7 @@ class ClinicServices:
 
         return
 
-    def update_clinic_offer(self, user, clinic_offer_id: int, clinic_offer_data: ClinicOffersBase):
+    async def update_clinic_offer(self, user, clinic_offer_id: int, clinic_offer_data: ClinicOffersBase):
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("You are not authorized to update clinic offer")
 
@@ -316,7 +320,7 @@ class ClinicServices:
 
         return
 
-    def delete_clinic_offer(self, user, clinic_offer_id: int):
+    async def delete_clinic_offer(self, user, clinic_offer_id: int):
         if user["userType"] != UserType.SUPER_ADMIN:
             raise UnauthorizedException("You are not authorized to delete clinic offer")
 

services/dashboardService.py

@@ -14,15 +14,15 @@ class DashboardService:
         self.clinicDoctorsServices = ClinicDoctorsServices()
         self.clinicServices = ClinicServices()
 
-    def get_dashboard_counts(self, isSuperAdmin: bool):
+    async def get_dashboard_counts(self, isSuperAdmin: bool):
         if isSuperAdmin:
-            clinicCounts = self.clinicServices.get_clinic_count()
+            clinicCounts = await self.clinicServices.get_clinic_count()
             return clinicCounts
         else:
-            clinicDoctorsCount = self.clinicDoctorsServices.get_doctor_status_count()
+            clinicDoctorsCount = await self.clinicDoctorsServices.get_doctor_status_count()
             return clinicDoctorsCount
 
-    def update_signup_pricing_master(
+    async def update_signup_pricing_master(
         self, user, pricing_data: SignupPricingMasterBase
     ):
         if user["userType"] != UserType.SUPER_ADMIN:
@@ -62,7 +62,7 @@ class DashboardService:
             return response
 
 
-    def get_signup_pricing_master(self):
+    async def get_signup_pricing_master(self):
         signup_pricing_master = self.db.query(SignupPricingMaster).first()
         if signup_pricing_master is None:
             raise ResourceNotFoundException("Signup pricing master not found")

services/masterAppointmentServices.py

@@ -12,7 +12,7 @@ class MasterAppointmentServices:
         self.db: Session = next(get_db())
     
 
-    def get_master_appointment_types(self):
+    async def get_master_appointment_types(self):
         appointment_types = self.db.query(MasterAppointmentTypes).all()
         total= self.db.query(MasterAppointmentTypes).count()
         response = CommonResponse(data=[MasterAppointmentTypeResponse(**appointment_type.__dict__.copy()) for appointment_type in appointment_types], total=total)
@@ -22,7 +22,7 @@ class MasterAppointmentServices:
         existing_appointment_type = self.db.query(MasterAppointmentTypes).filter(MasterAppointmentTypes.type == appointment_type.type.lower()).first()
         return existing_appointment_type
 
-    def create_master_appointment_type(self, appointment_type: MasterAppointmentTypeBase):
+    async def create_master_appointment_type(self, appointment_type: MasterAppointmentTypeBase):
 
         # get existing appointment type
         existing_appointment_type = self.is_appointment_type_exists(appointment_type)
@@ -37,7 +37,7 @@ class MasterAppointmentServices:
         self.db.commit()
         return
 
-    def delete_master_appointment_type(self, appointment_type_id: int):
+    async def delete_master_appointment_type(self, appointment_type_id: int):
         appointment_type = self.db.query(MasterAppointmentTypes).filter(MasterAppointmentTypes.id == appointment_type_id).first()
 
         if appointment_type is None:
@@ -47,7 +47,7 @@ class MasterAppointmentServices:
         self.db.commit()
         return
 
-    def update_master_appointment_type(self, appointment_type_id: int, appointment_type: MasterAppointmentTypeBase):
+    async def update_master_appointment_type(self, appointment_type_id: int, appointment_type: MasterAppointmentTypeBase):
         appointment_type_db = self.db.query(MasterAppointmentTypes).filter(MasterAppointmentTypes.id == appointment_type_id).first()
 
         if appointment_type_db is None:

services/s3Service.py

@@ -40,7 +40,7 @@ class S3Service:
 def get_s3_service():
     return S3Service()
 
-def upload_file(
+async def upload_file(
     folder: S3FolderNameEnum,
     file_name: str,
 ) -> Dict[str, str]:
@@ -93,7 +93,7 @@ def upload_file(
         print(f"Error generating pre-signed URL: {e}")
         raise BusinessValidationException(str(e))
 
-def get_signed_url(key: str) -> str:
+async def get_signed_url(key: str) -> str:
     """
     Generate a pre-signed URL for retrieving a file from S3.
     

services/userServices.py

@@ -24,7 +24,7 @@ class UserServices:
         self.db: Session = next(get_db())
         self.email_service = EmailService()
 
-    def create_user(self, user_data: UserCreate, background_tasks=None):
+    async def create_user(self, user_data: UserCreate, background_tasks=None):
         # Start a transaction
         try:
             user = user_data.user
@@ -114,9 +114,6 @@ class UserServices:
             # Add clinic files to database
             self.db.add(clinic_files)
 
-            # Now commit both user and clinic in a single transaction
-            self.db.commit()
-
             # Send mail to admin in a non-blocking way using background tasks
             if background_tasks:
                 background_tasks.add_task(self._send_emails_to_admins, clinic.email)
@@ -130,8 +127,10 @@ class UserServices:
             
             # Use the centralized exception handler
             DBExceptionHandler.handle_exception(e, context="creating user")
+        finally:
+            self.db.commit()
 
-    def get_user(self, user_id) -> UserResponse:
+    async def get_user(self, user_id) -> UserResponse:
         try:
             # Query the user by ID and explicitly load the created clinics relationship
             user = self.db.query(Users).options(joinedload(Users.created_clinics)).filter(Users.id == user_id).first()
@@ -165,7 +164,7 @@ class UserServices:
             from twillio.exceptions.db_exceptions import DBExceptionHandler
             DBExceptionHandler.handle_exception(e, context="getting user")
 
-    def get_users(self, limit:int, offset:int, search:str):
+    async def get_users(self, limit:int, offset:int, search:str):
         query = self.db.query(Users)
         if search:
             query = query.filter(
@@ -185,23 +184,20 @@ class UserServices:
 
         return response
 
-    def get_user_by_email(self, email: str) -> UserResponse:
+    async def get_user_by_email(self, email: str) -> UserResponse:
-        try:
+        user = self.db.query(Users).filter(Users.email == email.lower()).first()
-            user = self.db.query(Users).filter(Users.email == email.lower()).first()
 
-            if not user:
+        if not user:
-                logger.error("User not found")
+            logger.error("User not found")
-                raise ResourceNotFoundException("User not found")
+            raise ResourceNotFoundException("User not found")
 
-            user_dict = user.__dict__.copy()
+        user_dict = user.__dict__.copy()
 
-            user_response = UserResponse(**user_dict)
+        user_response = UserResponse(**user_dict)
 
-            return user_response
+        return user_response
-        except Exception as e:
-            raise e
 
-    def update_user(self, admin_id:int|None, user_id: int, user_data: UserUpdate) -> UserResponse:
+    async def update_user(self, admin_id:int|None, user_id: int, user_data: UserUpdate) -> UserResponse:
         # Check admin authorization if admin_id is provided
         if admin_id:
             admin = self.db.query(Users).filter(Users.id == admin_id).first()
@@ -232,7 +228,7 @@ class UserServices:
         # Return properly serialized response
         return UserResponse.model_validate(user)
 
-    def delete_user(self, user_id: int):
+    async def delete_user(self, user_id: int):
         user = self.db.query(Users).filter(Users.id == user_id).first()
 
         if not user:
@@ -244,13 +240,13 @@ class UserServices:
         
         return True
     
-    def get_super_admins(self):
+    async def get_super_admins(self):
         return self.db.query(Users).filter(Users.userType == UserType.SUPER_ADMIN).all()
         
-    def _send_emails_to_admins(self, clinic_name):
+    async def _send_emails_to_admins(self, clinic_name):
         """Helper method to send emails to all super admins"""
         try:
-            admins = self.get_super_admins()
+            admins = await self.get_super_admins()
             for admin in admins:
                 self.email_service.send_new_clinic_email(
                     to_address=admin.email,