feat: added leave and userdevice models

alembic/versions/e95f62f91348_added_leave_and_userdevice_table.py

@@ -0,0 +1,33 @@
+"""added: leave and userdevice table
+
+Revision ID: e95f62f91348
+Revises: a3c79664f866
+Create Date: 2025-11-22 15:42:12.098237
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = 'e95f62f91348'
+down_revision: Union[str, Sequence[str], None] = 'a3c79664f866'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('users', 'device_tokens')
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('users', sa.Column('device_tokens', postgresql.ARRAY(sa.VARCHAR()), autoincrement=False, nullable=True))
+    # ### end Alembic commands ###

src/core/models.py

@@ -4,7 +4,6 @@ import uuid
 from datetime import date, datetime
 from enum import Enum
 from typing import List, Optional
-from src.profile.models import Leaves
 
 
 from sqlalchemy import CheckConstraint, UniqueConstraint

src/main.py

@@ -1,4 +1,4 @@
-from src.profile.router import router as profile
+# from src.profile.router import router as profile
 from fastapi import FastAPI
 
 
@@ -7,17 +7,17 @@ from src.chatbot.router import router as chatbot
 from src.core.database import init_db
 from src.home.router import router as home_router
 
-from src.profile.router import router as profile
+# from src.profile.router import router as profile
 
 app = FastAPI(title="Yuvabe App API")
 
 app.include_router(home_router, prefix="/home", tags=["Home"])
 
-# init_db()
+init_db()
 
 app.include_router(auth_router)
 
-app.include_router(profile)
+# app.include_router(profile)
 
 app.include_router(chatbot)
 

src/profile/models.py

@@ -1,39 +1,45 @@
+from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy import Column, String
 import uuid
 from datetime import date, datetime
-from typing import Optional
-from sqlmodel import SQLModel, Field
 from enum import Enum
+from typing import List, Optional
 
+from sqlmodel import Field, Relationship, SQLModel
 
-class LeaveStatus(str, Enum):
-    PENDING = "PENDING"
-    APPROVED = "APPROVED"
-    REJECTED = "REJECTED"
-
+class LeaveType(str, Enum):
+    SICK = "Sick"
+    CASUAL = "Casual"
+    EMERGENCY = "Emergency"
 
-class Leaves(SQLModel, table=True):
-    __tablename__ = "leaves"
+class LeaveStatus(str, Enum):
+    APPROVED = "Approved"
+    REJECTED = "Rejected"
+    PENDING = "Pending"
 
+class Leave(SQLModel, table=True):
+    __tablename__ = "leave"
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
-
-    # Foreign keys (users table)
     user_id: uuid.UUID = Field(foreign_key="users.id", nullable=False)
     mentor_id: uuid.UUID = Field(foreign_key="users.id", nullable=False)
     lead_id: uuid.UUID = Field(foreign_key="users.id", nullable=False)
-
-    leave_type: str = Field(nullable=False)
+    leave_type: LeaveType = Field(default=LeaveType.SICK)
     from_date: date = Field(nullable=False)
     to_date: date = Field(nullable=False)
-    days: int = Field(nullable=False)
-    reason: Optional[str] = None
-
+    days: Optional[int] = 1
+    reason: str = Field(nullable=True)
     status: LeaveStatus = Field(default=LeaveStatus.PENDING)
-
-    approved_by: Optional[uuid.UUID] = Field(foreign_key="users.id", default=None)
-    approved_at: Optional[datetime] = None
+    is_delivered: bool = Field(default= False)
+    requested_at: date = Field(default_factory=date.today)
+    updated_at: date = Field(default_factory=date.today)
     reject_reason: Optional[str] = None
 
-    comment: Optional[str] = None
-
-    created_at: datetime = Field(default_factory=datetime.now)
-    updated_at: datetime = Field(default_factory=datetime.now)
+class UserDevices(SQLModel, table=True):
+    __tablename__ = "user_devices"
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    user_id: uuid.UUID = Field(foreign_key="users.id", nullable=False)
+    device_token: str
+    last_seen: datetime = Field(default_factory=datetime.now)
+    device_model: str
+    platform: str
+    updated_at: datetime = Field(default_factory=datetime.now)

src/profile/router.py

@@ -1,282 +1,282 @@
-from src.profile.service import send_email_service
-from src.profile.schemas import SendMailRequest
-from src.profile.utils import build_auth_url
-from src.profile.utils import exchange_code_for_tokens
-from src.profile.service import USER_TOKEN_STORE
-from src.profile.utils import send_email
-from src.profile.service import list_user_assets
-from fastapi.routing import APIRouter
-from src.core.database import get_async_session
-from src.auth.utils import get_current_user
-from src.auth.schemas import BaseResponse
-from sqlalchemy.ext.asyncio.session import AsyncSession
-from fastapi.params import Depends
-from .schemas import UpdateProfileRequest
-from src.profile.service import update_user_profile
-from sqlmodel import select
-from src.core.models import Users, Teams, Roles, UserTeamsRole
-from fastapi import APIRouter, Query, HTTPException ,BackgroundTasks
-from fastapi.responses import RedirectResponse, JSONResponse
-import httpx
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlmodel.ext.asyncio.session import AsyncSession
-from src.auth.utils import get_current_user  # adjust path
-from src.profile.schemas import (
-    ApplyLeaveRequest,
-    ApproveRejectRequest,
-    LeaveResponse,
-    BalanceResponse,
-    DeviceTokenIn,
-)
-from src.profile import service
-from typing import List
-
-
-router = APIRouter(prefix="/profile", tags=["Profile"])
-
-
-@router.post("/apply", response_model=LeaveResponse)
-async def apply_leave_endpoint(
-    payload: ApplyLeaveRequest,
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    user_id = current_user
-    leave = await service.apply_leave(session, user_id, payload)
-    return leave
-
-
-@router.get("/pending", response_model=List[LeaveResponse])
-async def pending_leaves(
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    user_id = current_user
-    leaves = await service.get_pending_leaves_for_approver(session, user_id)
-    return leaves
-
-
-@router.get("/my", response_model=List[LeaveResponse])
-async def my_leaves(
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    leaves = await service.get_my_leaves(session, current_user)
-    return leaves
-
-
-@router.get("/team", response_model=List[LeaveResponse])
-async def team_leaves(
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    leaves = await service.get_team_leaves(session, current_user)
-    return leaves
-
-
-@router.post("/{leave_id}/approve", response_model=LeaveResponse)
-async def approve_leave_endpoint(
-    leave_id: str,
-    payload: ApproveRejectRequest,
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    leave = await service.approve_leave(
-        session, current_user, leave_id, comment=payload.comment
-    )
-    return leave
-
-
-@router.post("/{leave_id}/reject", response_model=LeaveResponse)
-async def reject_leave_endpoint(
-    leave_id: str,
-    payload: ApproveRejectRequest,
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    leave = await service.reject_leave(
-        session,
-        current_user,
-        leave_id,
-        reject_reason=payload.reject_reason,
-        comment=payload.comment,
-    )
-    return leave
-
-
-@router.get("/balance", response_model=List[BalanceResponse])
-async def get_balance(
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    return await service.get_leave_balance(session, current_user)
-
-
-@router.post("/device-token")
-async def save_device_token(
-    payload: DeviceTokenIn,
-    session: AsyncSession = Depends(get_async_session),
-    current_user=Depends(get_current_user),
-):
-    tokens = await service.add_device_token(session, current_user, payload.device_token)
-    return {"status": "ok", "tokens": tokens}
-
-
-
-
-@router.get("/login")
-def google_login(state: str | None = Query(None)):
-    return RedirectResponse(build_auth_url(state))
-
-
-@router.get("/callback")
-async def google_callback(code: str | None = None, state: str | None = None):
-    if not code:
-        raise HTTPException(400, "Missing code")
-
-    token_data = await exchange_code_for_tokens(code)
-    access_token = token_data["access_token"]
-    refresh_token = token_data.get("refresh_token")
-
-    # Get user info
-    async with httpx.AsyncClient() as client:
-        r = await client.get(
-            "https://www.googleapis.com/oauth2/v3/userinfo",
-            headers={"Authorization": f"Bearer {access_token}"},
-        )
-    userinfo = r.json()
-
-    google_user_id = userinfo["sub"]
-    user_email = userinfo["email"]
-
-    USER_TOKEN_STORE[google_user_id] = {
-        "access_token": access_token,
-        "refresh_token": refresh_token,
-        "email": user_email,
-    }
-
-    return JSONResponse(
-        {
-            "status": "ok",
-            "user_id": google_user_id,
-            "email": user_email,
-            "state": state,
-        }
-    )
-
-
-@router.post("/send-mail")
-async def send_mail(req: SendMailRequest):
-    return await send_email_service(req)
-
-
-@router.get("/", response_model=BaseResponse)
-async def get_assets(
-    user_id: str = Depends(get_current_user),
-    session: AsyncSession = Depends(get_async_session),
-):
-    assets = await list_user_assets(session, user_id)
-
-    data = {
-        "assets": [
-            {
-                "id": a.id,
-                "name": a.name,
-                "type": a.type,
-                "status": a.status,
-            }
-            for a in assets
-        ]
-    }
-
-    return {"code": 200, "data": data}
-
-
-@router.put("/update-profile", response_model=BaseResponse)
-async def update_profile(
-    payload: UpdateProfileRequest,
-    user_id: str = Depends(get_current_user),
-    session: AsyncSession = Depends(get_async_session),
-):
-    result = await update_user_profile(session, user_id, payload)
-    return {"code": 200, "data": result}
-
-
-@router.get("/contacts", response_model=BaseResponse)
-async def get_leave_contacts(
-    current_user=Depends(get_current_user),
-    session: AsyncSession = Depends(get_async_session),
-):
-    # get_current_user returns a STRING user_id
-    user_id = current_user
-
-    if not user_id:
-        raise HTTPException(status_code=400, detail="Invalid user token")
-
-    # 1) Get user's team
-    stmt = select(UserTeamsRole).where(UserTeamsRole.user_id == user_id)
-    ut = (await session.exec(stmt)).first()
-
-    if not ut:
-        raise HTTPException(status_code=404, detail="User-Team mapping not found")
-
-    # 2) Get Team Lead role
-    lead_role = (
-        await session.exec(select(Roles).where(Roles.name == "Team Lead"))
-    ).first()
-
-    if not lead_role:
-        raise HTTPException(status_code=500, detail="Team Lead role not found")
-
-    # 3) Find Team Lead user in same team
-    lead_user = (
-        await session.exec(
-            select(Users)
-            .join(UserTeamsRole)
-            .where(UserTeamsRole.team_id == ut.team_id)
-            .where(UserTeamsRole.role_id == lead_role.id)
-        )
-    ).all()
-
-    if not lead_user:
-        raise HTTPException(status_code=404, detail="Team lead not found")
-
-    to_email = ", ".join([u.email_id for u in lead_user])
-
-    # 4) HR CC emails
-    hr_team = (await session.exec(select(Teams).where(Teams.name == "HR Team"))).first()
-
-    cc = []
-    if hr_team:
-        hr_users = (
-            await session.exec(
-                select(Users)
-                .join(UserTeamsRole)
-                .where(UserTeamsRole.team_id == hr_team.id)
-            )
-        ).all()
-
-        cc = [str(row.email_id) for row in hr_users]
-
-    return BaseResponse(code=200, message="success", data={"to": to_email, "cc": cc})
-
-
-@router.post("/send", response_model=BaseResponse)
-async def send_leave_email(
-    payload: dict,
-    background: BackgroundTasks,
-    current_user=Depends(get_current_user),
-):
-    from_email = payload.get("from_email")
-    to_email = payload.get("to")
-    cc = payload.get("cc", [])
-    subject = payload.get("subject")
-    body = payload.get("body")
-
-    if not subject or not body:
-        raise HTTPException(status_code=400, detail="Subject and body required")
-
-    # send in background so API returns fast
-    background.add_task(send_email, to_email, subject, body, cc, from_email)
-
-    return BaseResponse(code=200, message="Leave request sent", data=None)
+# from src.profile.service import send_email_service
+# from src.profile.schemas import SendMailRequest
+# from src.profile.utils import build_auth_url
+# from src.profile.utils import exchange_code_for_tokens
+# from src.profile.service import USER_TOKEN_STORE
+# from src.profile.utils import send_email
+# from src.profile.service import list_user_assets
+# from fastapi.routing import APIRouter
+# from src.core.database import get_async_session
+# from src.auth.utils import get_current_user
+# from src.auth.schemas import BaseResponse
+# from sqlalchemy.ext.asyncio.session import AsyncSession
+# from fastapi.params import Depends
+# from .schemas import UpdateProfileRequest
+# from src.profile.service import update_user_profile
+# from sqlmodel import select
+# from src.core.models import Users, Teams, Roles, UserTeamsRole
+# from fastapi import APIRouter, Query, HTTPException ,BackgroundTasks
+# from fastapi.responses import RedirectResponse, JSONResponse
+# import httpx
+# from fastapi import APIRouter, Depends, HTTPException, status
+# from sqlmodel.ext.asyncio.session import AsyncSession
+# from src.auth.utils import get_current_user  # adjust path
+# from src.profile.schemas import (
+#     ApplyLeaveRequest,
+#     ApproveRejectRequest,
+#     LeaveResponse,
+#     BalanceResponse,
+#     DeviceTokenIn,
+# )
+# from src.profile import service
+# from typing import List
+
+
+# router = APIRouter(prefix="/profile", tags=["Profile"])
+
+
+# @router.post("/apply", response_model=LeaveResponse)
+# async def apply_leave_endpoint(
+#     payload: ApplyLeaveRequest,
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     user_id = current_user
+#     leave = await service.apply_leave(session, user_id, payload)
+#     return leave
+
+
+# @router.get("/pending", response_model=List[LeaveResponse])
+# async def pending_leaves(
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     user_id = current_user
+#     leaves = await service.get_pending_leaves_for_approver(session, user_id)
+#     return leaves
+
+
+# @router.get("/my", response_model=List[LeaveResponse])
+# async def my_leaves(
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     leaves = await service.get_my_leaves(session, current_user)
+#     return leaves
+
+
+# @router.get("/team", response_model=List[LeaveResponse])
+# async def team_leaves(
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     leaves = await service.get_team_leaves(session, current_user)
+#     return leaves
+
+
+# @router.post("/{leave_id}/approve", response_model=LeaveResponse)
+# async def approve_leave_endpoint(
+#     leave_id: str,
+#     payload: ApproveRejectRequest,
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     leave = await service.approve_leave(
+#         session, current_user, leave_id, comment=payload.comment
+#     )
+#     return leave
+
+
+# @router.post("/{leave_id}/reject", response_model=LeaveResponse)
+# async def reject_leave_endpoint(
+#     leave_id: str,
+#     payload: ApproveRejectRequest,
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     leave = await service.reject_leave(
+#         session,
+#         current_user,
+#         leave_id,
+#         reject_reason=payload.reject_reason,
+#         comment=payload.comment,
+#     )
+#     return leave
+
+
+# @router.get("/balance", response_model=List[BalanceResponse])
+# async def get_balance(
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     return await service.get_leave_balance(session, current_user)
+
+
+# @router.post("/device-token")
+# async def save_device_token(
+#     payload: DeviceTokenIn,
+#     session: AsyncSession = Depends(get_async_session),
+#     current_user=Depends(get_current_user),
+# ):
+#     tokens = await service.add_device_token(session, current_user, payload.device_token)
+#     return {"status": "ok", "tokens": tokens}
+
+
+
+
+# @router.get("/login")
+# def google_login(state: str | None = Query(None)):
+#     return RedirectResponse(build_auth_url(state))
+
+
+# @router.get("/callback")
+# async def google_callback(code: str | None = None, state: str | None = None):
+#     if not code:
+#         raise HTTPException(400, "Missing code")
+
+#     token_data = await exchange_code_for_tokens(code)
+#     access_token = token_data["access_token"]
+#     refresh_token = token_data.get("refresh_token")
+
+#     # Get user info
+#     async with httpx.AsyncClient() as client:
+#         r = await client.get(
+#             "https://www.googleapis.com/oauth2/v3/userinfo",
+#             headers={"Authorization": f"Bearer {access_token}"},
+#         )
+#     userinfo = r.json()
+
+#     google_user_id = userinfo["sub"]
+#     user_email = userinfo["email"]
+
+#     USER_TOKEN_STORE[google_user_id] = {
+#         "access_token": access_token,
+#         "refresh_token": refresh_token,
+#         "email": user_email,
+#     }
+
+#     return JSONResponse(
+#         {
+#             "status": "ok",
+#             "user_id": google_user_id,
+#             "email": user_email,
+#             "state": state,
+#         }
+#     )
+
+
+# @router.post("/send-mail")
+# async def send_mail(req: SendMailRequest):
+#     return await send_email_service(req)
+
+
+# @router.get("/", response_model=BaseResponse)
+# async def get_assets(
+#     user_id: str = Depends(get_current_user),
+#     session: AsyncSession = Depends(get_async_session),
+# ):
+#     assets = await list_user_assets(session, user_id)
+
+#     data = {
+#         "assets": [
+#             {
+#                 "id": a.id,
+#                 "name": a.name,
+#                 "type": a.type,
+#                 "status": a.status,
+#             }
+#             for a in assets
+#         ]
+#     }
+
+#     return {"code": 200, "data": data}
+
+
+# @router.put("/update-profile", response_model=BaseResponse)
+# async def update_profile(
+#     payload: UpdateProfileRequest,
+#     user_id: str = Depends(get_current_user),
+#     session: AsyncSession = Depends(get_async_session),
+# ):
+#     result = await update_user_profile(session, user_id, payload)
+#     return {"code": 200, "data": result}
+
+
+# @router.get("/contacts", response_model=BaseResponse)
+# async def get_leave_contacts(
+#     current_user=Depends(get_current_user),
+#     session: AsyncSession = Depends(get_async_session),
+# ):
+#     # get_current_user returns a STRING user_id
+#     user_id = current_user
+
+#     if not user_id:
+#         raise HTTPException(status_code=400, detail="Invalid user token")
+
+#     # 1) Get user's team
+#     stmt = select(UserTeamsRole).where(UserTeamsRole.user_id == user_id)
+#     ut = (await session.exec(stmt)).first()
+
+#     if not ut:
+#         raise HTTPException(status_code=404, detail="User-Team mapping not found")
+
+#     # 2) Get Team Lead role
+#     lead_role = (
+#         await session.exec(select(Roles).where(Roles.name == "Team Lead"))
+#     ).first()
+
+#     if not lead_role:
+#         raise HTTPException(status_code=500, detail="Team Lead role not found")
+
+#     # 3) Find Team Lead user in same team
+#     lead_user = (
+#         await session.exec(
+#             select(Users)
+#             .join(UserTeamsRole)
+#             .where(UserTeamsRole.team_id == ut.team_id)
+#             .where(UserTeamsRole.role_id == lead_role.id)
+#         )
+#     ).all()
+
+#     if not lead_user:
+#         raise HTTPException(status_code=404, detail="Team lead not found")
+
+#     to_email = ", ".join([u.email_id for u in lead_user])
+
+#     # 4) HR CC emails
+#     hr_team = (await session.exec(select(Teams).where(Teams.name == "HR Team"))).first()
+
+#     cc = []
+#     if hr_team:
+#         hr_users = (
+#             await session.exec(
+#                 select(Users)
+#                 .join(UserTeamsRole)
+#                 .where(UserTeamsRole.team_id == hr_team.id)
+#             )
+#         ).all()
+
+#         cc = [str(row.email_id) for row in hr_users]
+
+#     return BaseResponse(code=200, message="success", data={"to": to_email, "cc": cc})
+
+
+# @router.post("/send", response_model=BaseResponse)
+# async def send_leave_email(
+#     payload: dict,
+#     background: BackgroundTasks,
+#     current_user=Depends(get_current_user),
+# ):
+#     from_email = payload.get("from_email")
+#     to_email = payload.get("to")
+#     cc = payload.get("cc", [])
+#     subject = payload.get("subject")
+#     body = payload.get("body")
+
+#     if not subject or not body:
+#         raise HTTPException(status_code=400, detail="Subject and body required")
+
+#     # send in background so API returns fast
+#     background.add_task(send_email, to_email, subject, body, cc, from_email)
+
+#     return BaseResponse(code=200, message="Leave request sent", data=None)

src/profile/service.py

@@ -1,384 +1,383 @@
-from src.profile.utils import build_raw_message, refresh_access_token
-from src.profile.schemas import SendMailRequest
-from src.core.models import Assets, Users
-from datetime import datetime
-import uuid
-from fastapi import HTTPException
-from passlib.context import CryptContext
-from src.core.models import Users
-import uuid
-from typing import List
-from sqlmodel import select
-from sqlmodel.ext.asyncio.session import AsyncSession
-import httpx
-from src.core.config import settings
-from typing import List, Optional
-from sqlmodel import select
-from sqlmodel.ext.asyncio.session import AsyncSession
-from fastapi import HTTPException
-from datetime import datetime
-from src.profile.models import Leaves
-from src.profile.schemas import ApplyLeaveRequest, ApproveRejectRequest
-from src.profile.utils import calculate_days, find_mentor_and_lead
-from src.profile.utils import get_tokens_for_user, send_push_to_tokens
-from src.core.config import settings
-
-
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-# src/profile/service.py
-
-# Leave limits (you can move to config)
-SICK_LIMIT = getattr(settings, "SICK_LEAVE_LIMIT", 10)
-CASUAL_LIMIT = getattr(settings, "CASUAL_LEAVE_LIMIT", 10)
-
-
-async def apply_leave(session: AsyncSession, user_id, payload: ApplyLeaveRequest):
-    # compute days
-    days = calculate_days(payload.from_date, payload.to_date)
-    if days <= 0:
-        raise HTTPException(status_code=400, detail="Invalid date range")
-
-    # find mentor and lead
-    mentor, lead = await find_mentor_and_lead(session, user_id)
-    if not mentor or not lead:
-        raise HTTPException(status_code=400, detail="Mentor or Lead not found for user")
-
-    # check remaining balance
-    limit = SICK_LIMIT if payload.leave_type.lower() == "sick" else CASUAL_LIMIT
-    # sum used days for this leave_type
-    q = select(Leaves).where(
-        Leaves.user_id == user_id,
-        Leaves.leave_type.ilike(payload.leave_type),
-        Leaves.status == "APPROVED",
-    )
-    rows = (await session.exec(q)).all()
-    used = sum(r.days for r in rows) if rows else 0
-    remaining = limit - used
-    if days > remaining:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Insufficient {payload.leave_type} balance. Remaining {remaining}",
-        )
-
-    leave = Leaves(
-        user_id=user_id,
-        mentor_id=mentor.id,
-        lead_id=lead.id,
-        leave_type=payload.leave_type,
-        from_date=payload.from_date,
-        to_date=payload.to_date,
-        days=days,
-        reason=payload.reason,
-        status="PENDING",
-    )
-    session.add(leave)
-    await session.commit()
-    await session.refresh(leave)
-
-    # push notifications to mentor & lead
-    title = "New Leave Request"
-    body = f"{user_id} applied {payload.leave_type} leave ({days} days)."
-    mentor_tokens = await get_tokens_for_user(session, mentor.id)
-    lead_tokens = await get_tokens_for_user(session, lead.id)
-    await send_push_to_tokens(
-        mentor_tokens,
-        title,
-        body,
-        data={"leave_id": str(leave.id), "action": "leave_request"},
-    )
-    await send_push_to_tokens(
-        lead_tokens,
-        title,
-        body,
-        data={"leave_id": str(leave.id), "action": "leave_request"},
-    )
-
-    return leave
-
-
-async def get_pending_leaves_for_approver(
-    session: AsyncSession, approver_user_id
-) -> List[Leaves]:
-    # returns pending leaves where mentor_id == approver OR lead_id == approver
-    stmt = select(Leaves).where(
-        (Leaves.mentor_id == approver_user_id) | (Leaves.lead_id == approver_user_id),
-        Leaves.status == "PENDING",
-    )
-    return (await session.exec(stmt)).all()
-
-
-async def get_my_leaves(session: AsyncSession, user_id) -> List[Leaves]:
-    stmt = (
-        select(Leaves)
-        .where(Leaves.user_id == user_id)
-        .order_by(Leaves.created_at.desc())
-    )
-    return (await session.exec(stmt)).all()
-
-
-async def get_team_leaves(session: AsyncSession, lead_user_id) -> List[Leaves]:
-    # lead can view leaves where lead_id == lead_user_id
-    stmt = (
-        select(Leaves)
-        .where(Leaves.lead_id == lead_user_id)
-        .order_by(Leaves.created_at.desc())
-    )
-    return (await session.exec(stmt)).all()
-
-
-async def approve_leave(
-    session: AsyncSession, approver_id, leave_id: str, comment: Optional[str] = None
-):
-    # transaction-safe update
-    async with session.begin():
-        stmt = select(Leaves).where(Leaves.id == leave_id).with_for_update()
-        leave = (await session.exec(stmt)).one_or_none()
-        if not leave:
-            raise HTTPException(404, "Leave not found")
-        if leave.status != "PENDING":
-            raise HTTPException(400, "Leave is not pending")
-
-        # optional: verify approver is mentor or lead for this leave
-        if str(approver_id) not in (str(leave.mentor_id), str(leave.lead_id)):
-            # you might want to check roles more thoroughly
-            raise HTTPException(403, "Not authorized to approve this leave")
-
-        # check balance again before approving
-        # compute limit and used
-        limit = SICK_LIMIT if leave.leave_type.lower() == "sick" else CASUAL_LIMIT
-        q = select(Leaves).where(
-            Leaves.user_id == leave.user_id,
-            Leaves.leave_type.ilike(leave.leave_type),
-            Leaves.status == "APPROVED",
-        )
-        approved_rows = (await session.exec(q)).all()
-        used = sum(r.days for r in approved_rows) if approved_rows else 0
-        if used + leave.days > limit:
-            raise HTTPException(400, "Insufficient balance at approval time")
-
-        # update
-        leave.status = "APPROVED"
-        leave.approved_by = approver_id
-        leave.approved_at = datetime.utcnow()
-        if comment:
-            leave.comment = comment
-
-        session.add(leave)
-    # commit done by context manager
-
-    # send push notification to member and lead
-    title = "Leave Approved"
-    body = f"Your leave ({leave.leave_type}) has been approved."
-    member_tokens = await get_tokens_for_user(session, leave.user_id)
-    lead_tokens = await get_tokens_for_user(session, leave.lead_id)
-    await send_push_to_tokens(
-        member_tokens,
-        title,
-        body,
-        data={"leave_id": str(leave.id), "action": "leave_approved"},
-    )
-    await send_push_to_tokens(
-        lead_tokens,
-        title,
-        body,
-        data={"leave_id": str(leave.id), "action": "leave_approved"},
-    )
-
-    return leave
-
-
-async def reject_leave(
-    session: AsyncSession,
-    approver_id,
-    leave_id: str,
-    reject_reason: Optional[str] = None,
-    comment: Optional[str] = None,
-):
-    async with session.begin():
-        stmt = select(Leaves).where(Leaves.id == leave_id).with_for_update()
-        leave = (await session.exec(stmt)).one_or_none()
-        if not leave:
-            raise HTTPException(404, "Leave not found")
-        if leave.status != "PENDING":
-            raise HTTPException(400, "Leave is not pending")
-
-        if str(approver_id) not in (str(leave.mentor_id), str(leave.lead_id)):
-            raise HTTPException(403, "Not authorized to reject this leave")
-
-        leave.status = "REJECTED"
-        leave.approved_by = approver_id
-        leave.approved_at = datetime.utcnow()
-        leave.reject_reason = reject_reason
-        if comment:
-            leave.comment = comment
-        session.add(leave)
-
-    # push to member + lead
-    title = "Leave Rejected"
-    body = f"Your leave ({leave.leave_type}) has been rejected. Reason: {leave.reject_reason or 'N/A'}"
-    member_tokens = await get_tokens_for_user(session, leave.user_id)
-    lead_tokens = await get_tokens_for_user(session, leave.lead_id)
-    await send_push_to_tokens(
-        member_tokens,
-        title,
-        body,
-        data={"leave_id": str(leave.id), "action": "leave_rejected"},
-    )
-    await send_push_to_tokens(
-        lead_tokens,
-        title,
-        body,
-        data={"leave_id": str(leave.id), "action": "leave_rejected"},
-    )
-
-    return leave
-
-
-async def add_device_token(session: AsyncSession, user_id, device_token: str):
-    """
-    Add FCM token to Users.device_tokens ARRAY.
-    Avoid duplicates.
-    """
-
-    # 1) Fetch user
-    user = await session.get(Users, user_id)
-    if not user:
-        raise HTTPException(404, "User not found")
-
-    # 2) If token not present -> add it
-    if device_token not in user.device_tokens:
-        user.device_tokens.append(device_token)
-        session.add(user)
-        await session.commit()
-        await session.refresh(user)
-
-    return user.device_tokens
-
-
-async def get_leave_balance(session: AsyncSession, user_id) -> List[dict]:
-    # compute used for each leave_type and return
-    # using constants SICK_LIMIT and CASUAL_LIMIT
-    stmt = select(Leaves).where(Leaves.user_id == user_id, Leaves.status == "APPROVED")
-    rows = (await session.exec(stmt)).all()
-    used_sick = sum(r.days for r in rows if r.leave_type.lower() == "sick")
-    used_casual = sum(r.days for r in rows if r.leave_type.lower() == "casual")
-    return [
-        {
-            "leave_type": "Sick",
-            "limit": SICK_LIMIT,
-            "used": used_sick,
-            "remaining": max(0, SICK_LIMIT - used_sick),
-        },
-        {
-            "leave_type": "Casual",
-            "limit": CASUAL_LIMIT,
-            "used": used_casual,
-            "remaining": max(0, CASUAL_LIMIT - used_casual),
-        },
-    ]
-
-
-# In production, replace with DB storage
-USER_TOKEN_STORE = {}  # {google_user_id: {tokens}}
-
-
-async def send_email_service(req: SendMailRequest):
-    record = USER_TOKEN_STORE.get(req.user_id)
-    if not record:
-        raise HTTPException(404, "User not logged in with Google OAuth")
-
-    access_token = record["access_token"]
-    refresh_token = record.get("refresh_token")
-
-    if not access_token and refresh_token:
-        new_tokens = await refresh_access_token(refresh_token)
-        access_token = new_tokens["access_token"]
-        record["access_token"] = access_token
-
-    if not access_token:
-        raise HTTPException(400, "Re-auth required")
-
-    raw = build_raw_message(
-        to_email=req.to,
-        subject=req.subject,
-        body=req.body,
-        from_name=req.from_name,
-        from_email=record["email"],
-    )
-
-    url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
-    payload = {"raw": raw}
-
-    async with httpx.AsyncClient() as client:
-        r = await client.post(
-            url, json=payload, headers={"Authorization": f"Bearer {access_token}"}
-        )
-
-    if r.status_code >= 400:
-        raise HTTPException(500, f"Gmail error: {r.text}")
-
-    return r.json()
-
-
-async def update_user_profile(session, user_id: str, data):
-    user = await session.get(Users, uuid.UUID(user_id))
-
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-
-    # --- Update Name ---
-    if data.name:
-        user.user_name = data.name
-
-    # --- Update Email ---
-    if data.email:
-        user.email_id = data.email
-
-    # --- Update DOB ---
-    if data.dob:
-        try:
-            # Convert DD.MM.YYYY → Python date
-            parsed_date = datetime.strptime(data.dob, "%d.%m.%Y").date()
-            user.dob = parsed_date
-        except:
-            raise HTTPException(
-                status_code=400, detail="DOB must be in DD.MM.YYYY format"
-            )
-
-    # --- Update Address ---
-    if data.address:
-        user.address = data.address
-
-    # --- Change Password ---
-    if data.new_password:
-        if not data.current_password:
-            raise HTTPException(status_code=400, detail="Current password required")
-
-        # Verify old password
-        if not pwd_context.verify(data.current_password, user.password):
-            raise HTTPException(status_code=400, detail="Incorrect current password")
-
-        # Set new password
-        user.password = pwd_context.hash(data.new_password)
-
-    # Commit changes
-    await session.commit()
-    await session.refresh(user)
-
-    return {
-        "message": "Profile updated successfully",
-        "user": {
-            "id": str(user.id),
-            "name": user.user_name,
-            "email": user.email_id,
-            "dob": user.dob.isoformat() if user.dob else None,
-            "address": user.address,
-            "is_verified": user.is_verified,
-        },
-    }
+# from src.profile.utils import build_raw_message, refresh_access_token
+# from src.profile.schemas import SendMailRequest
+# from src.core.models import Assets, Users
+# from datetime import datetime
+# import uuid
+# from fastapi import HTTPException
+# from passlib.context import CryptContext
+# from src.core.models import Users
+# import uuid
+# from typing import List
+# from sqlmodel import select
+# from sqlmodel.ext.asyncio.session import AsyncSession
+# import httpx
+# from src.core.config import settings
+# from typing import List, Optional
+# from sqlmodel import select
+# from sqlmodel.ext.asyncio.session import AsyncSession
+# from fastapi import HTTPException
+# from datetime import datetime
+# from src.profile.schemas import ApplyLeaveRequest, ApproveRejectRequest
+# from src.profile.utils import calculate_days, find_mentor_and_lead
+# from src.profile.utils import get_tokens_for_user, send_push_to_tokens
+# from src.core.config import settings
+
+
+# pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# # src/profile/service.py
+
+# # Leave limits (you can move to config)
+# SICK_LIMIT = getattr(settings, "SICK_LEAVE_LIMIT", 10)
+# CASUAL_LIMIT = getattr(settings, "CASUAL_LEAVE_LIMIT", 10)
+
+
+# async def apply_leave(session: AsyncSession, user_id, payload: ApplyLeaveRequest):
+#     # compute days
+#     days = calculate_days(payload.from_date, payload.to_date)
+#     if days <= 0:
+#         raise HTTPException(status_code=400, detail="Invalid date range")
+
+#     # find mentor and lead
+#     mentor, lead = await find_mentor_and_lead(session, user_id)
+#     if not mentor or not lead:
+#         raise HTTPException(status_code=400, detail="Mentor or Lead not found for user")
+
+#     # check remaining balance
+#     limit = SICK_LIMIT if payload.leave_type.lower() == "sick" else CASUAL_LIMIT
+#     # sum used days for this leave_type
+#     q = select(Leaves).where(
+#         Leaves.user_id == user_id,
+#         Leaves.leave_type.ilike(payload.leave_type),
+#         Leaves.status == "APPROVED",
+#     )
+#     rows = (await session.exec(q)).all()
+#     used = sum(r.days for r in rows) if rows else 0
+#     remaining = limit - used
+#     if days > remaining:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"Insufficient {payload.leave_type} balance. Remaining {remaining}",
+#         )
+
+#     leave = Leaves(
+#         user_id=user_id,
+#         mentor_id=mentor.id,
+#         lead_id=lead.id,
+#         leave_type=payload.leave_type,
+#         from_date=payload.from_date,
+#         to_date=payload.to_date,
+#         days=days,
+#         reason=payload.reason,
+#         status="PENDING",
+#     )
+#     session.add(leave)
+#     await session.commit()
+#     await session.refresh(leave)
+
+#     # push notifications to mentor & lead
+#     title = "New Leave Request"
+#     body = f"{user_id} applied {payload.leave_type} leave ({days} days)."
+#     mentor_tokens = await get_tokens_for_user(session, mentor.id)
+#     lead_tokens = await get_tokens_for_user(session, lead.id)
+#     await send_push_to_tokens(
+#         mentor_tokens,
+#         title,
+#         body,
+#         data={"leave_id": str(leave.id), "action": "leave_request"},
+#     )
+#     await send_push_to_tokens(
+#         lead_tokens,
+#         title,
+#         body,
+#         data={"leave_id": str(leave.id), "action": "leave_request"},
+#     )
+
+#     return leave
+
+
+# async def get_pending_leaves_for_approver(
+#     session: AsyncSession, approver_user_id
+# ) -> List[Leaves]:
+#     # returns pending leaves where mentor_id == approver OR lead_id == approver
+#     stmt = select(Leaves).where(
+#         (Leaves.mentor_id == approver_user_id) | (Leaves.lead_id == approver_user_id),
+#         Leaves.status == "PENDING",
+#     )
+#     return (await session.exec(stmt)).all()
+
+
+# async def get_my_leaves(session: AsyncSession, user_id) -> List[Leaves]:
+#     stmt = (
+#         select(Leaves)
+#         .where(Leaves.user_id == user_id)
+#         .order_by(Leaves.created_at.desc())
+#     )
+#     return (await session.exec(stmt)).all()
+
+
+# async def get_team_leaves(session: AsyncSession, lead_user_id) -> List[Leaves]:
+#     # lead can view leaves where lead_id == lead_user_id
+#     stmt = (
+#         select(Leaves)
+#         .where(Leaves.lead_id == lead_user_id)
+#         .order_by(Leaves.created_at.desc())
+#     )
+#     return (await session.exec(stmt)).all()
+
+
+# async def approve_leave(
+#     session: AsyncSession, approver_id, leave_id: str, comment: Optional[str] = None
+# ):
+#     # transaction-safe update
+#     async with session.begin():
+#         stmt = select(Leaves).where(Leaves.id == leave_id).with_for_update()
+#         leave = (await session.exec(stmt)).one_or_none()
+#         if not leave:
+#             raise HTTPException(404, "Leave not found")
+#         if leave.status != "PENDING":
+#             raise HTTPException(400, "Leave is not pending")
+
+#         # optional: verify approver is mentor or lead for this leave
+#         if str(approver_id) not in (str(leave.mentor_id), str(leave.lead_id)):
+#             # you might want to check roles more thoroughly
+#             raise HTTPException(403, "Not authorized to approve this leave")
+
+#         # check balance again before approving
+#         # compute limit and used
+#         limit = SICK_LIMIT if leave.leave_type.lower() == "sick" else CASUAL_LIMIT
+#         q = select(Leaves).where(
+#             Leaves.user_id == leave.user_id,
+#             Leaves.leave_type.ilike(leave.leave_type),
+#             Leaves.status == "APPROVED",
+#         )
+#         approved_rows = (await session.exec(q)).all()
+#         used = sum(r.days for r in approved_rows) if approved_rows else 0
+#         if used + leave.days > limit:
+#             raise HTTPException(400, "Insufficient balance at approval time")
+
+#         # update
+#         leave.status = "APPROVED"
+#         leave.approved_by = approver_id
+#         leave.approved_at = datetime.utcnow()
+#         if comment:
+#             leave.comment = comment
+
+#         session.add(leave)
+#     # commit done by context manager
+
+#     # send push notification to member and lead
+#     title = "Leave Approved"
+#     body = f"Your leave ({leave.leave_type}) has been approved."
+#     member_tokens = await get_tokens_for_user(session, leave.user_id)
+#     lead_tokens = await get_tokens_for_user(session, leave.lead_id)
+#     await send_push_to_tokens(
+#         member_tokens,
+#         title,
+#         body,
+#         data={"leave_id": str(leave.id), "action": "leave_approved"},
+#     )
+#     await send_push_to_tokens(
+#         lead_tokens,
+#         title,
+#         body,
+#         data={"leave_id": str(leave.id), "action": "leave_approved"},
+#     )
+
+#     return leave
+
+
+# async def reject_leave(
+#     session: AsyncSession,
+#     approver_id,
+#     leave_id: str,
+#     reject_reason: Optional[str] = None,
+#     comment: Optional[str] = None,
+# ):
+#     async with session.begin():
+#         stmt = select(Leaves).where(Leaves.id == leave_id).with_for_update()
+#         leave = (await session.exec(stmt)).one_or_none()
+#         if not leave:
+#             raise HTTPException(404, "Leave not found")
+#         if leave.status != "PENDING":
+#             raise HTTPException(400, "Leave is not pending")
+
+#         if str(approver_id) not in (str(leave.mentor_id), str(leave.lead_id)):
+#             raise HTTPException(403, "Not authorized to reject this leave")
+
+#         leave.status = "REJECTED"
+#         leave.approved_by = approver_id
+#         leave.approved_at = datetime.utcnow()
+#         leave.reject_reason = reject_reason
+#         if comment:
+#             leave.comment = comment
+#         session.add(leave)
+
+#     # push to member + lead
+#     title = "Leave Rejected"
+#     body = f"Your leave ({leave.leave_type}) has been rejected. Reason: {leave.reject_reason or 'N/A'}"
+#     member_tokens = await get_tokens_for_user(session, leave.user_id)
+#     lead_tokens = await get_tokens_for_user(session, leave.lead_id)
+#     await send_push_to_tokens(
+#         member_tokens,
+#         title,
+#         body,
+#         data={"leave_id": str(leave.id), "action": "leave_rejected"},
+#     )
+#     await send_push_to_tokens(
+#         lead_tokens,
+#         title,
+#         body,
+#         data={"leave_id": str(leave.id), "action": "leave_rejected"},
+#     )
+
+#     return leave
+
+
+# async def add_device_token(session: AsyncSession, user_id, device_token: str):
+#     """
+#     Add FCM token to Users.device_tokens ARRAY.
+#     Avoid duplicates.
+#     """
+
+#     # 1) Fetch user
+#     user = await session.get(Users, user_id)
+#     if not user:
+#         raise HTTPException(404, "User not found")
+
+#     # 2) If token not present -> add it
+#     if device_token not in user.device_tokens:
+#         user.device_tokens.append(device_token)
+#         session.add(user)
+#         await session.commit()
+#         await session.refresh(user)
+
+#     return user.device_tokens
+
+
+# async def get_leave_balance(session: AsyncSession, user_id) -> List[dict]:
+#     # compute used for each leave_type and return
+#     # using constants SICK_LIMIT and CASUAL_LIMIT
+#     stmt = select(Leaves).where(Leaves.user_id == user_id, Leaves.status == "APPROVED")
+#     rows = (await session.exec(stmt)).all()
+#     used_sick = sum(r.days for r in rows if r.leave_type.lower() == "sick")
+#     used_casual = sum(r.days for r in rows if r.leave_type.lower() == "casual")
+#     return [
+#         {
+#             "leave_type": "Sick",
+#             "limit": SICK_LIMIT,
+#             "used": used_sick,
+#             "remaining": max(0, SICK_LIMIT - used_sick),
+#         },
+#         {
+#             "leave_type": "Casual",
+#             "limit": CASUAL_LIMIT,
+#             "used": used_casual,
+#             "remaining": max(0, CASUAL_LIMIT - used_casual),
+#         },
+#     ]
+
+
+# # In production, replace with DB storage
+# USER_TOKEN_STORE = {}  # {google_user_id: {tokens}}
+
+
+# async def send_email_service(req: SendMailRequest):
+#     record = USER_TOKEN_STORE.get(req.user_id)
+#     if not record:
+#         raise HTTPException(404, "User not logged in with Google OAuth")
+
+#     access_token = record["access_token"]
+#     refresh_token = record.get("refresh_token")
+
+#     if not access_token and refresh_token:
+#         new_tokens = await refresh_access_token(refresh_token)
+#         access_token = new_tokens["access_token"]
+#         record["access_token"] = access_token
+
+#     if not access_token:
+#         raise HTTPException(400, "Re-auth required")
+
+#     raw = build_raw_message(
+#         to_email=req.to,
+#         subject=req.subject,
+#         body=req.body,
+#         from_name=req.from_name,
+#         from_email=record["email"],
+#     )
+
+#     url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
+#     payload = {"raw": raw}
+
+#     async with httpx.AsyncClient() as client:
+#         r = await client.post(
+#             url, json=payload, headers={"Authorization": f"Bearer {access_token}"}
+#         )
+
+#     if r.status_code >= 400:
+#         raise HTTPException(500, f"Gmail error: {r.text}")
+
+#     return r.json()
+
+
+# async def update_user_profile(session, user_id: str, data):
+#     user = await session.get(Users, uuid.UUID(user_id))
+
+#     if not user:
+#         raise HTTPException(status_code=404, detail="User not found")
+
+#     # --- Update Name ---
+#     if data.name:
+#         user.user_name = data.name
+
+#     # --- Update Email ---
+#     if data.email:
+#         user.email_id = data.email
+
+#     # --- Update DOB ---
+#     if data.dob:
+#         try:
+#             # Convert DD.MM.YYYY → Python date
+#             parsed_date = datetime.strptime(data.dob, "%d.%m.%Y").date()
+#             user.dob = parsed_date
+#         except:
+#             raise HTTPException(
+#                 status_code=400, detail="DOB must be in DD.MM.YYYY format"
+#             )
+
+#     # --- Update Address ---
+#     if data.address:
+#         user.address = data.address
+
+#     # --- Change Password ---
+#     if data.new_password:
+#         if not data.current_password:
+#             raise HTTPException(status_code=400, detail="Current password required")
+
+#         # Verify old password
+#         if not pwd_context.verify(data.current_password, user.password):
+#             raise HTTPException(status_code=400, detail="Incorrect current password")
+
+#         # Set new password
+#         user.password = pwd_context.hash(data.new_password)
+
+#     # Commit changes
+#     await session.commit()
+#     await session.refresh(user)
+
+#     return {
+#         "message": "Profile updated successfully",
+#         "user": {
+#             "id": str(user.id),
+#             "name": user.user_name,
+#             "email": user.email_id,
+#             "dob": user.dob.isoformat() if user.dob else None,
+#             "address": user.address,
+#             "is_verified": user.is_verified,
+#         },
+#     }
 
-
-async def list_user_assets(session: AsyncSession, user_id: str) -> List[Assets]:
-    q = await session.exec(select(Assets).where(Assets.user_id == uuid.UUID(user_id)))
-    return q.all()
+
+# async def list_user_assets(session: AsyncSession, user_id: str) -> List[Assets]:
+#     q = await session.exec(select(Assets).where(Assets.user_id == uuid.UUID(user_id)))
+#     return q.all()