feat:added payslip table

alembic/versions/fec3872d7eba_add_payslip_table.py

@@ -0,0 +1,41 @@
+"""add:payslip table
+
+Revision ID: fec3872d7eba
+Revises: f6a1d6fc82d0
+Create Date: 2025-12-04 10:58:25.795533
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'fec3872d7eba'
+down_revision: Union[str, Sequence[str], None] = 'f6a1d6fc82d0'
+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_constraint(op.f('comments_post_id_fkey'), 'comments', type_='foreignkey')
+    op.drop_constraint(op.f('comments_user_id_fkey'), 'comments', type_='foreignkey')
+    op.create_foreign_key(None, 'comments', 'posts', ['post_id'], ['id'], ondelete='CASCADE')
+    op.create_foreign_key(None, 'comments', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.add_column('users', sa.Column('join_date', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('users', 'join_date')
+    op.drop_constraint(None, 'comments', type_='foreignkey')
+    op.drop_constraint(None, 'comments', type_='foreignkey')
+    op.create_foreign_key(op.f('comments_user_id_fkey'), 'comments', 'users', ['user_id'], ['id'])
+    op.create_foreign_key(op.f('comments_post_id_fkey'), 'comments', 'posts', ['post_id'], ['id'])
+    # ### end Alembic commands ###

src/core/__init__.py

@@ -4,4 +4,5 @@ from src.core import models as core_models
 from src.feed import models as feed_models
 from src.home import models as home_models
 from src.profile import models as profile_models
-from src.wellbeing import models as wellbeing_models
+from src.wellbeing import models as wellbeing_models
+from src.payslip import models as payslip_models

src/core/models.py

@@ -30,6 +30,7 @@ class Users(SQLModel, table=True):
     dob: Optional[date] = None
     address: Optional[str] = None
     profile_picture: Optional[str] = None
+    join_date: Optional[str] = None
     created_at: datetime = Field(default_factory=datetime.now)
     asset: List["Assets"] = Relationship(back_populates="user")
     water_logs: List["WaterLogs"] = Relationship(back_populates="user")
@@ -51,31 +52,36 @@ class UserTeamsRole(SQLModel, table=True):
     __tablename__ = "user_teams_role"
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
     user_id: uuid.UUID = Field(
-        sa_column=Column(UUID(as_uuid=True),
+        sa_column=Column(
+            UUID(as_uuid=True),
             ForeignKey("users.id", ondelete="CASCADE"),
-            nullable=False
+            nullable=False,
         )
     )
     team_id: uuid.UUID = Field(
-        sa_column=Column(UUID(as_uuid=True),
+        sa_column=Column(
+            UUID(as_uuid=True),
             ForeignKey("teams.id", ondelete="CASCADE"),
-            nullable=False
+            nullable=False,
         )
     )
     role_id: uuid.UUID = Field(
-        sa_column=Column(UUID(as_uuid=True),
+        sa_column=Column(
+            UUID(as_uuid=True),
             ForeignKey("roles.id", ondelete="CASCADE"),
-            nullable=False
+            nullable=False,
         )
     )
 
+
 class Assets(SQLModel, table=True):
     __tablename__ = "assets"
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
     user_id: uuid.UUID = Field(
-        sa_column=Column(UUID(as_uuid=True),
+        sa_column=Column(
+            UUID(as_uuid=True),
             ForeignKey("users.id", ondelete="CASCADE"),
-            nullable=False
+            nullable=False,
         )
     )
     name: str = Field(nullable=False)
@@ -93,9 +99,10 @@ class EmotionLogs(SQLModel, table=True):
     )
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
     user_id: uuid.UUID = Field(
-        sa_column=Column(UUID(as_uuid=True),
+        sa_column=Column(
+            UUID(as_uuid=True),
             ForeignKey("users.id", ondelete="CASCADE"),
-            nullable=False
+            nullable=False,
         )
     )
     morning_emotion: Optional[int] = Field(default=None, ge=1, le=7)

src/main.py

@@ -7,6 +7,7 @@ from src.chatbot.router import router as chatbot_router
 from src.core.database import init_db
 from src.home.router import router as home_router
 from src.notifications.router import router as notifications_router
+from src.payslip.router import router as payslip_router
 from src.profile.router import router as profile
 from fastapi.staticfiles import StaticFiles
 
@@ -33,6 +34,8 @@ app.include_router(wellbeing)
 
 app.include_router(notifications_router)
 
+app.include_router(payslip_router)
+
 
 @app.get("/")
 def root():

src/payslip/googleservice.py

@@ -0,0 +1,80 @@
+import base64
+import json
+import requests
+from typing import Tuple
+from fastapi import HTTPException
+
+from src.core.config import settings
+
+
+def exchange_code_for_tokens(code: str):
+    """
+    Exchange Google 'code' for access_token + refresh_token
+    """
+    data = {
+        "code": code,
+        "client_id": settings.GOOGLE_CLIENT_ID,
+        "client_secret": settings.GOOGLE_CLIENT_SECRET,
+        "redirect_uri": settings.GOOGLE_REDIRECT_URI,
+        "grant_type": "authorization_code",
+    }
+
+    res = requests.post(settings.TOKEN_URL, data=data)
+    if res.status_code != 200:
+        raise HTTPException(500, f"Google token exchange error: {res.text}")
+
+    return res.json()
+
+
+def refresh_google_access_token(refresh_token: str) -> str:
+    """
+    Input → refresh_token  
+    Output → new access_token
+    """
+    data = {
+        "refresh_token": refresh_token,
+        "client_id": settings.GOOGLE_CLIENT_ID,
+        "client_secret": settings.GOOGLE_CLIENT_SECRET,
+        "grant_type": "refresh_token",
+    }
+
+    res = requests.post(settings.TOKEN_URL, data=data)
+    if res.status_code != 200:
+        raise HTTPException(500, f"Failed to refresh access token: {res.text}")
+
+    return res.json()["access_token"]
+
+
+def build_email(from_email: str, to_email: str, subject: str, body: str) -> str:
+    """
+    Gmail API expects Base64URL-encoded email.
+    """
+    message = (
+        f"From: {from_email}\r\n"
+        f"To: {to_email}\r\n"
+        f"Subject: {subject}\r\n"
+        "\r\n"
+        f"{body}"
+    )
+
+    message_bytes = message.encode("utf-8")
+    encoded = base64.urlsafe_b64encode(message_bytes).decode("utf-8")
+    return encoded
+
+
+def send_gmail(access_token: str, raw_message: str) -> str:
+    url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
+
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "Content-Type": "application/json",
+    }
+
+    payload = {"raw": raw_message}
+
+    res = requests.post(url, headers=headers, data=json.dumps(payload))
+
+    if res.status_code not in (200, 202):
+        raise HTTPException(500, f"Gmail API error: {res.text}")
+
+    return res.json().get("id")  # message_id

src/payslip/grouter.py

@@ -0,0 +1,70 @@
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import HTMLResponse
+from urllib.parse import urlencode
+import uuid
+
+from src.core.config import settings
+from sqlalchemy.ext.asyncio import AsyncSession
+from src.core.database import get_async_session
+from src.core.models import Users
+from src.payslip.models import PayslipRequest
+from src.payslip.googleservice import exchange_code_for_tokens
+
+
+router = APIRouter(prefix="/google", tags=["Google OAuth"])
+
+
+@router.get("/connect-url")
+def get_connect_url(user_id: uuid.UUID):
+    """
+    App calls this → backend returns Google OAuth URL
+    """
+    params = {
+        "client_id": settings.GOOGLE_CLIENT_ID,
+        "redirect_uri": settings.GOOGLE_REDIRECT_URI,
+        "response_type": "code",
+        "scope": settings.GMAIL_SEND_SCOPE,
+        "access_type": "offline",
+        "prompt": "consent",
+        "state": str(user_id),
+    }
+
+    url = f"{settings.AUTH_BASE}?{urlencode(params)}"
+    return {"auth_url": url}
+
+
+@router.get("/callback", response_class=HTMLResponse)
+def google_callback(
+    code: str,
+    state: str,
+    session: AsyncSession = Depends(get_async_session),
+):
+    """
+    Google redirects here after user logs in.
+    We store the refresh token in payslip table.
+    """
+    user_id = uuid.UUID(state)
+    user = session.get(Users, user_id)
+
+    if not user:
+        raise HTTPException(404, "User not found")
+
+    token_data = exchange_code_for_tokens(code)
+
+    refresh_token = token_data.get("refresh_token")
+    if not refresh_token:
+        raise HTTPException(400, "No refresh token received. Try again.")
+
+    # Save refresh token using a dummy payslip entry
+    entry = PayslipRequest(
+        user_id=user_id,
+        refresh_token=refresh_token,
+        status="Pending",
+    )
+    session.add(entry)
+    session.commit()
+
+    return """
+    <h2>Gmail Connected Successfully!</h2>
+    <p>You can close this window.</p>
+    """

src/payslip/models.py

@@ -0,0 +1,36 @@
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy import Column
+from sqlmodel import SQLModel, Field, ForeignKey
+
+
+class PayslipStatus(str, Enum):
+    PENDING = "Pending"
+    SENT = "Sent"
+    FAILED = "Failed"
+
+
+class PayslipRequest(SQLModel, table=True):
+    __tablename__ = "payslip_requests"
+
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+
+    user_id: uuid.UUID = Field(
+        sa_column=Column(
+            UUID(as_uuid=True),
+            ForeignKey("users.id", ondelete="CASCADE"),
+            nullable=False,
+        )
+    )
+
+    requested_at: datetime = Field(default_factory=datetime.now)
+
+    status: PayslipStatus = Field(default=PayslipStatus.PENDING)
+
+    refresh_token: Optional[str] = None
+
+    error_message: Optional[str] = None

src/payslip/router.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter, Depends
+from src.payslip.schemas import PayslipRequestSchema
+from src.payslip.service import process_payslip_request
+from src.auth.utils import get_current_user
+from sqlalchemy.ext.asyncio import AsyncSession
+from src.core.database import get_async_session
+from src.core.models import Users
+
+router = APIRouter(prefix="/payslips", tags=["Payslips"])
+
+
+@router.post("/request")
+def request_payslip(
+    payload: PayslipRequestSchema,
+    session: AsyncSession = Depends(get_async_session),
+    user: Users = Depends(get_current_user),
+):
+    entry = process_payslip_request(session, user, payload)
+    return {
+        "status": entry.status,
+        "requested_at": entry.requested_at,
+    }

src/payslip/schemas.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+from typing import Optional, Literal
+
+
+class PayslipRequestSchema(BaseModel):
+    mode: Literal["3_months", "6_months", "manual"]
+    start_month: Optional[str] = Field(default=None, description="YYYY-MM")
+    end_month: Optional[str] = Field(default=None, description="YYYY-MM")

src/payslip/service.py

@@ -0,0 +1,89 @@
+from sqlmodel import Session, select
+from fastapi import HTTPException
+from src.payslip.models import PayslipRequest, PayslipStatus
+from src.core.models import Users, Roles, UserTeamsRole
+
+from src.payslip.utils import calculate_period, validate_join_date
+from src.payslip.googleservice import (
+    refresh_google_access_token,
+    build_email,
+    send_gmail,
+)
+
+
+def get_latest_refresh_token(session: Session, user_id):
+    stmt = (
+        select(PayslipRequest)
+        .where(
+            PayslipRequest.user_id == user_id,
+            PayslipRequest.refresh_token.is_not(None),
+        )
+        .order_by(PayslipRequest.requested_at.desc())
+    )
+    entry = session.exec(stmt).first()
+    return entry.refresh_token if entry else None
+
+
+def get_hr_email(session: Session) -> str:
+    role = session.exec(select(Roles).where(Roles.name == "HR Manager")).first()
+    if not role:
+        raise HTTPException(500, "HR Manager role missing")
+
+    mapping = session.exec(
+        select(UserTeamsRole).where(UserTeamsRole.role_id == role.id)
+    ).first()
+
+    if not mapping:
+        raise HTTPException(500, "No HR assigned")
+
+    hr_user = session.get(Users, mapping.user_id)
+    return hr_user.email_id
+
+
+def process_payslip_request(session: Session, user: Users, payload):
+    # 1. Compute period
+    period_start, period_end = calculate_period(
+        payload.mode, payload.start_month, payload.end_month
+    )
+
+    # 2. Validate join date
+    validate_join_date(user.join_date, period_start)
+
+    # 3. Find refresh_token
+    refresh_token = get_latest_refresh_token(session, user.id)
+
+    if not refresh_token:
+        raise HTTPException(
+            400, "Please connect your Gmail before requesting a payslip."
+        )
+
+    # 4. Get access token
+    access_token = refresh_google_access_token(refresh_token)
+
+    # 5. Find HR email
+    hr_email = get_hr_email(session)
+
+    # 6. Build message
+    subject = "Payslip Request"
+    body = (
+        f"Payslip request from {user.email_id}\n"
+        f"Period: {period_start} → {period_end}"
+    )
+    raw = build_email(user.email_id, hr_email, subject, body)
+
+    # 7. Send email
+    message_id = send_gmail(access_token, raw)
+
+    # 8. Create new DB record
+    entry = PayslipRequest(
+        user_id=user.id,
+        status=PayslipStatus.SENT,
+        refresh_token=refresh_token,
+        error_message=None,
+    )
+
+    session.add(entry)
+    session.commit()
+    session.refresh(entry)
+
+    return entry

src/payslip/utils.py

@@ -0,0 +1,57 @@
+from datetime import date, datetime
+from fastapi import HTTPException
+
+
+def parse_month(month_str: str) -> date:
+    """Convert YYYY-MM to a date object representing first day of the month."""
+    try:
+        d = datetime.strptime(month_str, "%Y-%m")
+        return date(d.year, d.month, 1)
+    except:
+        raise HTTPException(status_code=400, detail="Invalid month format. Use YYYY-MM")
+
+
+def calculate_period(mode: str, start: str | None, end: str | None):
+    today = date.today()
+    current_month = date(today.year, today.month, 1)
+
+    if mode == "3_months":
+        months = 3
+    elif mode == "6_months":
+        months = 6
+    else:  # manual mode
+        if not start or not end:
+            raise HTTPException(400, "start_month and end_month required")
+        start_date = parse_month(start)
+        end_date = parse_month(end)
+
+        if end_date > current_month:
+            raise HTTPException(400, "Cannot request future payslips")
+        if start_date > end_date:
+            raise HTTPException(400, "start_month cannot be after end_month")
+
+        return start_date, end_date
+
+    # Auto period
+    end_date = current_month
+    year = end_date.year
+    mon = end_date.month - (months - 1)
+
+    while mon <= 0:
+        mon += 12
+        year -= 1
+
+    start_date = date(year, mon, 1)
+    return start_date, end_date
+
+
+def validate_join_date(join_date_str: str, period_start: date):
+    """User cannot request payslips earlier than join date"""
+    try:
+        join = datetime.strptime(join_date_str, "%Y-%m-%d").date()
+        join_month = join.replace(day=1)
+    except:
+        raise HTTPException(500, "Invalid join_date format in DB")
+
+    if period_start < join_month:
+        raise HTTPException(400, "You cannot request payslips before your joining date")