feat:added profile service

src/auth/router.py

@@ -11,7 +11,8 @@ from src.auth.service import (
     login_user,
 )
 from src.auth.utils import get_current_user
-from src.core.models import Users
+from src.core.models import Users, Roles, UserTeamsRole
+from sqlmodel import select
 from src.core.config import settings
 from fastapi.responses import RedirectResponse
 from .schemas import SignUpRequest, LoginRequest, BaseResponse, SendVerificationRequest
@@ -63,6 +64,21 @@ async def login(
     payload: LoginRequest, session: AsyncSession = Depends(get_async_session)
 ):
     response = await login_user(session, payload.email, payload.password)
+
+    user_id = response["user"]["id"]
+
+    # 🔥 Fetch User Role
+    result = await session.exec(
+        select(Roles)
+        .join(UserTeamsRole, UserTeamsRole.role_id == Roles.id)
+        .where(UserTeamsRole.user_id == uuid.UUID(user_id))
+    )
+
+    role_obj = result.first()
+    role_name = role_obj.name if role_obj else "Member"
+
+    response["user"]["role"] = (role_name or "member").lower()
+
     return {"code": 200, "data": response}
 
 
@@ -104,6 +120,13 @@ async def get_home(
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
 
+    role_join = await session.exec(
+        select(Roles.name)
+        .join(UserTeamsRole, UserTeamsRole.role_id == Roles.id)
+        .where(UserTeamsRole.user_id == uuid.UUID(user_id))
+    )
+    user_role = role_join.first() or "Member"
+
     # Example payload — replace with your real app data
     return {
         "code": 200,
@@ -115,7 +138,8 @@ async def get_home(
                 "email": user.email_id,
                 "is_verified": user.is_verified,
                 "dob": user.dob.isoformat() if user.dob else None,
-                "profile_picture": user.profile_picture
+                "profile_picture": user.profile_picture,
+                "role": user_role.lower(),
             },
             "home_data": {
                 "announcements": ["Welcome!", "New protocol released"],

src/profile/router.py

@@ -1,3 +1,4 @@
+from src.profile.schemas import LeaveDetailResponse
 from src.core.database import get_async_session
 from src.auth.utils import get_current_user
 from src.profile.models import Leave, LeaveType, LeaveStatus
@@ -76,8 +77,6 @@ async def mentor_decision_route(
             detail="Comment is required when rejecting leave",
         )
 
-
-
     try:
         leave = await mentor_decide_leave(session, mentor_uuid, leave_uuid, body)
     except PermissionError as e:
@@ -212,33 +211,42 @@ async def list_notifications(
     return {"code": 200, "data": notifications}
 
 
-@router.get("/leave/{leave_id}")
+@router.get("/leave/{leave_id}", response_model=LeaveDetailResponse)
 async def get_leave_details(
     leave_id: str,
     session: AsyncSession = Depends(get_async_session),
     user_id: str = Depends(get_current_user),
 ):
-    leave = await session.get(Leave, leave_id)
+    # Join Leave + Users table to get user_name
+    stmt = (
+        select(Leave, Users.user_name)
+        .join(Users, Users.id == Leave.user_id)
+        .where(Leave.id == uuid.UUID(leave_id))
+    )
 
-    if not leave:
+    row = (await session.exec(stmt)).first()
+
+    if not row:
         raise HTTPException(status_code=404, detail="Leave not found")
 
-    # Convert to JSON response
+    leave, user_name = row
+
     return {
         "code": 200,
         "data": {
             "id": str(leave.id),
             "user_id": str(leave.user_id),
+            "user_name": user_name,
             "mentor_id": str(leave.mentor_id),
             "lead_id": str(leave.lead_id),
             "leave_type": leave.leave_type,
-            "from_date": str(leave.from_date),
-            "to_date": str(leave.to_date),
+            "from_date": leave.from_date.isoformat(),
+            "to_date": leave.to_date.isoformat(),
             "days": leave.days,
             "reason": leave.reason,
             "status": leave.status,
             "reject_reason": leave.reject_reason,
-            "updated_at": leave.updated_at.isoformat(),
+            "updated_at": leave.updated_at.isoformat() if leave.updated_at else None,
         },
     }
 
@@ -248,32 +256,122 @@ async def mentor_pending_leaves(
     session: AsyncSession = Depends(get_async_session),
     mentor_id: str = Depends(get_current_user),
 ):
-    stmt = select(Leave).where(
-        Leave.mentor_id == mentor_id,
-        Leave.status == LeaveStatus.PENDING,
+    print("🔥 mentor pending called for:", mentor_id)
+
+    stmt = (
+        select(Leave, Users.user_name)
+        .join(Users, Users.id == Leave.user_id)
+        .where(
+            Leave.mentor_id == uuid.UUID(mentor_id),
+            Leave.status == LeaveStatus.PENDING,
+        )
     )
 
     rows = (await session.exec(stmt)).all()
 
-    return {
-        "code": 200,
-        "data": [
+    result = []
+
+    for leave, user_name in rows:
+        result.append(
             LeaveResponse(
-                id=str(r.id),
-                leave_type=r.leave_type,
-                from_date=r.from_date,
-                to_date=r.to_date,
-                days=r.days,
-                reason=r.reason,
-                status=r.status,
-                mentor_id=str(r.mentor_id),
-                lead_id=str(r.lead_id),
+                id=str(leave.id),
+                leave_type=leave.leave_type,
+                from_date=leave.from_date.isoformat(),
+                to_date=leave.to_date.isoformat(),
+                days=leave.days,
+                reason=leave.reason,
+                status=(
+                    leave.status.value
+                    if hasattr(leave.status, "value")
+                    else leave.status
+                ),
+                mentor_id=str(leave.mentor_id),
+                lead_id=str(leave.lead_id),
+                user_name=user_name,
+                updated_at=(
+                    leave.updated_at.isoformat()
+                    if hasattr(leave, "updated_at") and leave.updated_at
+                    else None
+                ),
             )
-            for r in rows
-        ],
+        )
+
+    return {
+        "code": 200,
+        "data": result,
     }
 
 
+@router.get("/my-leaves")
+async def my_leave_history(
+    session: AsyncSession = Depends(get_async_session),
+    user_id: str = Depends(get_current_user),
+):
+    stmt = (
+        select(Leave, Users.user_name, Users.email_id)
+        .join(Users, Users.id == Leave.mentor_id, isouter=True)
+        .where(Leave.user_id == uuid.UUID(user_id))
+        .order_by(desc(Leave.updated_at))
+    )
+
+    rows = (await session.exec(stmt)).all()
+
+    result = []
+    for leave, mentor_name, mentor_email in rows:
+        result.append(
+            {
+                "id": str(leave.id),
+                "leave_type": leave.leave_type,
+                "from_date": leave.from_date.isoformat(),
+                "to_date": leave.to_date.isoformat(),
+                "days": leave.days,
+                "reason": leave.reason,
+                "status": leave.status,
+                "mentor_name": mentor_name,
+                "updated_at": (
+                    leave.updated_at.isoformat() if leave.updated_at else None
+                ),
+            }
+        )
+
+    return {"code": 200, "data": result}
+
+
+@router.get("/mentor/team-leaves")
+async def team_leave_history(
+    session: AsyncSession = Depends(get_async_session),
+    mentor_id: str = Depends(get_current_user),
+):
+    stmt = (
+        select(Leave, Users.user_name)
+        .join(Users, Users.id == Leave.user_id)
+        .where(Leave.mentor_id == uuid.UUID(mentor_id))
+        .order_by(desc(Leave.updated_at))
+    )
+
+    rows = (await session.exec(stmt)).all()
+
+    result = []
+    for leave, username in rows:
+        result.append(
+            {
+                "id": str(leave.id),
+                "user_name": username,
+                "leave_type": leave.leave_type,
+                "from_date": leave.from_date.isoformat(),
+                "to_date": leave.to_date.isoformat(),
+                "days": leave.days,
+                "reason": leave.reason,
+                "status": leave.status,
+                "updated_at": (
+                    leave.updated_at.isoformat() if leave.updated_at else None
+                ),
+            }
+        )
+
+    return {"code": 200, "data": result}
+
+
 @router.get("/contacts", response_model=BaseResponse)
 async def get_leave_contacts(
     current_user=Depends(get_current_user),

src/profile/schemas.py

@@ -31,6 +31,27 @@ class ApproveRejectRequest(BaseModel):
     comment: Optional[str] = None  # optional for approve, required for reject
 
 
+class LeaveDetail(BaseModel):
+    id: str
+    user_id: str
+    user_name: str  # 👈 NEW FIELD
+    mentor_id: Optional[str]
+    lead_id: Optional[str]
+    leave_type: str
+    from_date: str
+    to_date: str
+    days: int
+    reason: str
+    status: str
+    reject_reason: Optional[str]
+    updated_at: Optional[str]
+
+
+class LeaveDetailResponse(BaseModel):
+    code: int
+    data: LeaveDetail
+
+
 class LeaveResponse(BaseModel):
     id: str
     leave_type: LeaveType
@@ -41,6 +62,8 @@ class LeaveResponse(BaseModel):
     status: LeaveStatus
     mentor_id: str
     lead_id: str
+    user_name: Optional[str] = None
+    updated_at: Optional[str] = None
 
 
 class DeviceTokenIn(BaseModel):