feat:added cancel service

src/notifications/router.py

@@ -1,3 +1,4 @@
+from src.profile.models import Leave
 from requests.api import delete
 from src.notifications.schemas import RegisterDeviceRequest
 from src.notifications.service import register_device
@@ -5,6 +6,9 @@ from fastapi import APIRouter, Depends
 from src.auth.utils import get_current_user
 from src.core.database import get_async_session
 from sqlalchemy.ext.asyncio import AsyncSession
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import text
+import uuid
 
 router = APIRouter(prefix="/notifications", tags=["Notifications"])
 
@@ -19,3 +23,42 @@ async def register_device_route(
     return {"message": "Device registered", "device": str(device.id)}
 
 
+@router.post("/{notif_id}/mark-read")
+async def mark_notification_read(
+    notif_id: str,
+    session: AsyncSession = Depends(get_async_session),
+    user_id: str = Depends(get_current_user),
+):
+    notif = await session.get(Leave, uuid.UUID(notif_id))
+
+    if not notif:
+        raise HTTPException(404, "Notification not found")
+
+    # Only owner or mentor should mark
+    if str(notif.user_id) != user_id and str(notif.mentor_id) != user_id:
+        raise HTTPException(403, "Unauthorized")
+
+    notif.is_read = True
+    await session.commit()
+
+    return {"message": "Marked as read"}
+
+
+@router.post("/mark-all-read")
+async def mark_all_read(
+    session: AsyncSession = Depends(get_async_session),
+    user_id: str = Depends(get_current_user),
+):
+    await session.execute(
+        text(
+            """
+            UPDATE leave
+            SET is_read = TRUE
+            WHERE user_id = :uid OR mentor_id = :uid
+        """
+        ),
+        {"uid": user_id},
+    )
+    await session.commit()
+
+    return {"message": "All notifications cleared"}

src/profile/models.py

@@ -7,17 +7,20 @@ from typing import List, Optional
 
 from sqlmodel import Field, Relationship, SQLModel
 
+
 class LeaveType(str, Enum):
     SICK = "Sick"
     CASUAL = "Casual"
     EMERGENCY = "Emergency"
 
+
 class LeaveStatus(str, Enum):
     APPROVED = "Approved"
     REJECTED = "Rejected"
     CANCELLED = "Cancelled"
     PENDING = "Pending"
 
+
 class Leave(SQLModel, table=True):
     __tablename__ = "leave"
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
@@ -30,12 +33,13 @@ class Leave(SQLModel, table=True):
     days: Optional[int] = 1
     reason: str = Field(nullable=True)
     status: LeaveStatus = Field(default=LeaveStatus.PENDING)
-    is_delivered: bool = Field(default= False)
+    is_delivered: bool = Field(default=False)
     is_read: 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
 
+
 class UserDevices(SQLModel, table=True):
     __tablename__ = "user_devices"
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
@@ -44,4 +48,4 @@ class UserDevices(SQLModel, table=True):
     last_seen: datetime = Field(default_factory=datetime.now)
     device_model: str
     platform: str
-    updated_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)

src/profile/router.py

@@ -1,6 +1,8 @@
 from src.profile.schemas import LeaveDetailResponse
 from src.core.database import get_async_session
 from src.auth.utils import get_current_user
+from src.notifications.service import get_user_device_tokens
+from src.notifications.fcm import send_fcm
 from src.profile.models import Leave, LeaveType, LeaveStatus
 from src.auth.schemas import BaseResponse
 from sqlalchemy import desc
@@ -21,8 +23,8 @@ from src.profile.schemas import (
     CreateLeaveRequest,
     LeaveResponse,
     ApproveRejectRequest,
-    LeaveStatus,
 )
+from datetime import datetime
 from src.profile.service import create_leave, mentor_decide_leave
 
 
@@ -158,7 +160,6 @@ async def list_notifications(
     session: AsyncSession = Depends(get_async_session),
     user_id: str = Depends(get_current_user),
 ):
-    from src.profile.models import Leave
 
     stmt = (
         select(Leave)
@@ -205,6 +206,7 @@ async def list_notifications(
                 "to_date": str(leave.to_date),
                 "reject_reason": leave.reject_reason,
                 "reason": leave.reason,
+                "is_read": leave.is_read,
             }
         )
 
@@ -484,3 +486,69 @@ async def get_profile_details(
             "mentor_email": ", ".join(mentor_emails),
         },
     )
+
+
+@router.post("/leave/{leave_id}/cancel")
+async def cancel_leave(
+    leave_id: str,
+    session: AsyncSession = Depends(get_async_session),
+    user_id: str = Depends(get_current_user),
+):
+    leave = await session.get(Leave, uuid.UUID(leave_id))
+
+    if not leave:
+        raise HTTPException(status_code=404, detail="Leave not found")
+
+    # User must own this leave
+    if str(leave.user_id) != user_id:
+        raise HTTPException(status_code=403, detail="Not your leave")
+
+    # Only approved leaves can be cancelled
+    if leave.status not in [LeaveStatus.APPROVED, LeaveStatus.PENDING]:
+        raise HTTPException(
+            status_code=400,
+            detail="Only pending or approved leaves can be cancelled",
+        )
+
+    # Check if leave date is future
+    from datetime import date
+
+    if leave.from_date <= date.today():
+        raise HTTPException(
+            status_code=400,
+            detail="Past or current day leaves cannot be cancelled",
+        )
+
+    # Update leave status
+    leave.status = LeaveStatus.CANCELLED
+    leave.updated_at = datetime.utcnow()
+    await session.commit()
+
+    user = await session.get(Users, leave.user_id)
+
+    # Notify mentor
+    mentor_tokens = await get_user_device_tokens(session, leave.mentor_id)
+    await send_fcm(
+        mentor_tokens,
+        "Leave Cancelled",
+        f"{user.user_name} cancelled their approved leave.",
+        {"type": "leave_cancel", "leave_id": str(leave.id)},
+    )
+
+    # Notify Team Lead
+    lead_tokens = await get_user_device_tokens(session, leave.lead_id)
+    await send_fcm(
+        lead_tokens,
+        "Leave Cancelled",
+        f"User {user.user_name} cancelled their approved leave.",
+        {"type": "leave_cancel", "leave_id": str(leave.id)},
+    )
+
+    return {
+        "code": 200,
+        "message": "Leave cancelled successfully",
+        "data": {
+            "id": str(leave.id),
+            "status": leave.status,
+        },
+    }

src/profile/schemas.py

@@ -1,3 +1,4 @@
+from sqlalchemy.event.api import CANCEL
 from pydantic import BaseModel, EmailStr, Field
 from typing import Optional, List
 import uuid
@@ -16,6 +17,7 @@ class LeaveStatus(str, Enum):
     APPROVED = "Approved"
     REJECTED = "Rejected"
     PENDING = "Pending"
+    CANCELLED = "Cancelled"
 
 
 class CreateLeaveRequest(BaseModel):