Merge pull request #38 from yuvabe-ai-labs/feat/journaling

alembic/versions/217db60578fa_added_journal_table.py

@@ -0,0 +1,44 @@
+"""added journal table
+
+Revision ID: 217db60578fa
+Revises: d9b4df655a55
+Create Date: 2025-12-05 14:19:31.722971
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '217db60578fa'
+down_revision: Union[str, Sequence[str], None] = 'd9b4df655a55'
+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.create_table('journal_entries',
+    sa.Column('id', sa.Uuid(), nullable=False),
+    sa.Column('user_id', sa.UUID(), nullable=False),
+    sa.Column('title', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+    sa.Column('content', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+    sa.Column('journal_date', sa.Date(), nullable=False),
+    sa.Column('created_at', sa.DateTime(), nullable=False),
+    sa.Column('updated_at', sa.DateTime(), nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('user_id', 'journal_date', name='unique_user_date_journal')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('journal_entries')
+    # ### end Alembic commands ###

alembic/versions/d9b4df655a55_updated_emotion_tag.py

@@ -0,0 +1,45 @@
+"""updated emotion tag
+
+Revision ID: d9b4df655a55
+Revises: fec3872d7eba
+Create Date: 2025-12-04 14:34:22.373838
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'd9b4df655a55'
+down_revision: Union[str, Sequence[str], None] = 'fec3872d7eba'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    emotion_enum = sa.Enum(
+        'JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED',
+        name='emotion_enum'
+    )
+    emotion_enum.create(op.get_bind(), checkfirst=True)
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('emotion_logs', sa.Column('morning_emotion', sa.Enum('JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED', name='emotion_enum'), nullable=True))
+    op.add_column('emotion_logs', sa.Column('evening_emotion', sa.Enum('JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED', name='emotion_enum'), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('emotion_logs', 'evening_emotion')
+    op.drop_column('emotion_logs', 'morning_emotion')
+    emotion_enum = sa.Enum(
+        'JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED',
+        name='emotion_enum'
+    )
+    emotion_enum.drop(op.get_bind(), checkfirst=True)
+    # ### end Alembic commands ###

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/auth/utils.py

@@ -156,7 +156,7 @@ async def verify_verification_token(token: str) -> str:
 bearer_scheme = HTTPBearer()
 
 
-def get_current_user(
+def  get_current_user(
     credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
 ):
     """Decode JWT token and extract current user ID"""
@@ -169,7 +169,7 @@ def get_current_user(
         if user_id is None:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid token: missing user id",
+                detail="Invalid token: Missing user id",
             )
         return user_id
 

src/core/__init__.py

@@ -4,4 +4,6 @@ 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
+from src.journaling import models as journaling_models

src/core/models.py

@@ -9,6 +9,7 @@ from typing import List, Optional
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy import CheckConstraint, UniqueConstraint, ForeignKey
 from sqlmodel import Field, Relationship, SQLModel
+from sqlalchemy import Enum as SQLEnum
 
 
 class AssetStatus(str, Enum):
@@ -17,6 +18,14 @@ class AssetStatus(str, Enum):
     ON_REQUEST = "On Request"
     IN_SERVICE = "In Service"
 
+class Emotion(str, Enum):
+    JOYFUL = "joyful"
+    HAPPY = "happy"
+    CALM = "calm"
+    NEUTRAL = "neutral"
+    ANXIOUS = "anxious"
+    SAD = "sad"
+    FRUSTRATED = "frustrated"
 
 class Users(SQLModel, table=True):
     __tablename__ = "users"
@@ -30,9 +39,11 @@ 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")
+    journal_entries: List["JournalEntry"] = Relationship(back_populates="user")
 
 
 class Teams(SQLModel, table=True):
@@ -51,31 +62,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)
@@ -86,18 +102,24 @@ class Assets(SQLModel, table=True):
 
 class EmotionLogs(SQLModel, table=True):
     __tablename__ = "emotion_logs"
-    __table_args__ = (
-        UniqueConstraint("user_id", "log_date"),
-        CheckConstraint("morning_emotion BETWEEN 1 AND 7 or morning_emotion IS NULL"),
-        CheckConstraint("evening_emotion BETWEEN 1 AND 7 or evening_emotion IS NULL"),
-    )
+    __table_args__ = (UniqueConstraint("user_id", "log_date"),)
+
     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)
-    evening_emotion: Optional[int] = Field(default=None, ge=1, le=7)
+
+    morning_emotion: Optional[Emotion] = Field(
+    sa_column=Column(SQLEnum(Emotion, name="emotion_enum", native_enum=True), nullable=True)
+)
+    evening_emotion: Optional[Emotion] = Field(
+    sa_column=Column(SQLEnum(Emotion, name="emotion_enum", native_enum=True), nullable=True)
+)
+
     log_date: date = Field(default_factory=date.today)
+

src/home/schemas.py

@@ -1,22 +1,19 @@
-# pylint: disable=no-name-in-module
-# pylint: disable=no-self-argument
 from datetime import date
-from typing import List, Optional, Union
-
+from typing import List, Optional
 from pydantic import BaseModel
-
+from src.core.models import Emotion
 
 class EmotionLogCreate(BaseModel):
     user_id: str
-    morning_emotion: Optional[int] = None
-    evening_emotion: Optional[int] = None
+    morning_emotion: Optional[Emotion] = None
+    evening_emotion: Optional[Emotion] = None
     log_date: date
 
 
 class EmotionLogResponse(BaseModel):
     log_date: date
-    morning_emotion: Optional[int]
-    evening_emotion: Optional[int]
+    morning_emotion: Optional[Emotion]
+    evening_emotion: Optional[Emotion]
 
 
 class HomeResponseData(BaseModel):
@@ -25,6 +22,7 @@ class HomeResponseData(BaseModel):
     philosophy_text: str
     recent_emotions: List[EmotionLogResponse]
 
+
 class BroadcastNotificationRequest(BaseModel):
     title: str
     body: str

src/home/service.py

@@ -46,6 +46,7 @@ async def get_home_data(user_id: str, session: AsyncSession) -> HomeResponseData
 async def add_or_update_emotion(
     data: EmotionLogCreate, session: AsyncSession
 ) -> EmotionLogResponse:
+
     user_exists = await session.exec(select(Users).where(Users.id == data.user_id))
     if not user_exists.first():
         raise ValueError("User not found. Cannot add emotion log.")

src/journaling/models.py

@@ -0,0 +1,32 @@
+import uuid
+from datetime import date, datetime
+from typing import Optional
+
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy import Column, ForeignKey, UniqueConstraint
+from sqlmodel import SQLModel, Field, Relationship
+
+
+class JournalEntry(SQLModel, table=True):
+    __tablename__ = "journal_entries"
+    __table_args__ = (
+        UniqueConstraint("user_id", "journal_date", name="unique_user_date_journal"),
+    )
+    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,
+        )
+    )
+    title: str = Field(nullable=False)
+    content: str = Field(nullable=False)
+    journal_date: date = Field(nullable=False)
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column_kwargs={"onupdate": datetime.now},
+        nullable=False,
+    )
+    user: Optional["Users"] = Relationship(back_populates="journal_entries")

src/journaling/router.py

@@ -0,0 +1,92 @@
+import uuid
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from src.core.database import get_async_session
+from src.core.schemas import BaseResponse
+from src.auth.utils import get_current_user
+
+from src.journaling.schemas import (
+    JournalCreate,
+    JournalUpdate,
+    JournalResponse,
+)
+from src.journaling.service import (
+    create_or_update_journal,
+    get_all_journals,
+    get_journal,
+    update_journal,
+    delete_journal,
+)
+
+router = APIRouter(prefix="/journal", tags=["Journal"])
+
+
+@router.post("/", response_model=BaseResponse[JournalResponse], status_code=200)
+async def create_or_update(
+    data: JournalCreate,
+    user_id: uuid.UUID = Depends(get_current_user),
+    session: AsyncSession = Depends(get_async_session),
+):
+    data.user_id = user_id
+
+    try:
+        record = await create_or_update_journal(data, session)
+        return BaseResponse(status_code=200, data=record)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.get("/", response_model=BaseResponse[list[JournalResponse]], status_code=200)
+async def list_user_journals(
+    user_id: uuid.UUID = Depends(get_current_user),
+    session: AsyncSession = Depends(get_async_session),
+):
+    records = await get_all_journals(user_id, session)
+    return BaseResponse(status_code=200, data=records)
+
+
+@router.get("/entry/{journal_id}", response_model=BaseResponse[JournalResponse], status_code=200)
+async def fetch_single(
+    journal_id: uuid.UUID,
+    user_id: uuid.UUID = Depends(get_current_user),
+    session: AsyncSession = Depends(get_async_session),
+):
+    try:
+        record = await get_journal(journal_id, user_id, session)
+        return BaseResponse(status_code=200, data=record)
+    except ValueError as e:
+        if str(e) == "Not authorized":
+            raise HTTPException(status_code=403, detail=str(e))
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.put("/entry/{journal_id}", response_model=BaseResponse[JournalResponse], status_code=200)
+async def update_entry(
+    journal_id: uuid.UUID,
+    data: JournalUpdate,
+    user_id: uuid.UUID = Depends(get_current_user),
+    session: AsyncSession = Depends(get_async_session),
+):
+    try:
+        record = await update_journal(journal_id, data, user_id, session)
+        return BaseResponse(status_code=200, data=record)
+    except ValueError as e:
+        if str(e) == "Not authorized":
+            raise HTTPException(status_code=403, detail=str(e))
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.delete("/entry/{journal_id}", response_model=BaseResponse[str], status_code=200)
+async def delete_entry(
+    journal_id: uuid.UUID,
+    user_id: uuid.UUID = Depends(get_current_user),
+    session: AsyncSession = Depends(get_async_session),
+):
+    try:
+        await delete_journal(journal_id, user_id, session)
+        return BaseResponse(status_code=200, data="Deleted")
+    except ValueError as e:
+        if str(e) == "Not authorized":
+            raise HTTPException(status_code=403, detail=str(e))
+        raise HTTPException(status_code=404, detail=str(e))

src/journaling/schemas.py

@@ -0,0 +1,31 @@
+import uuid
+from datetime import date, datetime
+from typing import Optional
+
+from sqlmodel import SQLModel
+
+
+class JournalBase(SQLModel):
+    title: str
+    content: str
+    journal_date: date
+
+
+class JournalCreate(JournalBase):
+    user_id: Optional[uuid.UUID] = None 
+
+
+class JournalUpdate(SQLModel):
+    title: Optional[str] = None
+    content: Optional[str] = None
+    journal_date: Optional[date] = None
+
+
+class JournalResponse(SQLModel):
+    id: uuid.UUID
+    user_id: uuid.UUID
+    title: str
+    content: str
+    journal_date: date
+    created_at: datetime
+    updated_at: datetime

src/journaling/service.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+import uuid
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from src.core.models import Users
+from src.journaling.models import JournalEntry
+from src.journaling.schemas import JournalCreate, JournalUpdate
+
+
+async def create_or_update_journal(data: JournalCreate, session: AsyncSession):
+    user = await session.exec(select(Users).where(Users.id == data.user_id))
+    if not user.first():
+        raise ValueError("User not found")
+
+    query = select(JournalEntry).where(
+        JournalEntry.user_id == data.user_id,
+        JournalEntry.journal_date == data.journal_date
+    )
+    existing = (await session.exec(query)).first()
+
+    if existing:
+        existing.title = data.title
+        existing.content = data.content
+        existing.updated_at = datetime.utcnow()
+        record = existing
+    else:
+        record = JournalEntry(
+            user_id=data.user_id,
+            title=data.title,
+            content=data.content,
+            journal_date=data.journal_date,
+        )
+        session.add(record)
+
+    await session.commit()
+    await session.refresh(record)
+    return record
+
+
+async def get_all_journals(user_id: uuid.UUID, session: AsyncSession):
+    stmt = (
+        select(JournalEntry)
+        .where(JournalEntry.user_id == user_id)
+        .order_by(JournalEntry.journal_date.desc())
+    )
+    result = await session.exec(stmt)
+    return result.all()
+
+
+async def get_journal(journal_id: uuid.UUID, user_id: uuid.UUID, session: AsyncSession):
+    stmt = select(JournalEntry).where(JournalEntry.id == journal_id)
+    result = await session.exec(stmt)
+    record = result.first()
+
+    if not record:
+        raise ValueError("Journal entry not found")
+    if str(record.user_id) != user_id:
+        raise ValueError("Not authorized")
+
+    return record
+
+
+async def update_journal(
+    journal_id: uuid.UUID,
+    data: JournalUpdate,
+    user_id: uuid.UUID,
+    session: AsyncSession,
+):
+    record = await get_journal(journal_id, user_id, session)
+
+    if data.title is not None:
+        record.title = data.title
+
+    if data.content is not None:
+        record.content = data.content
+
+    if data.journal_date is not None:
+        record.journal_date = data.journal_date
+
+    record.updated_at = datetime.utcnow()
+
+    await session.commit()
+    await session.refresh(record)
+    return record
+
+
+async def delete_journal(journal_id: uuid.UUID, user_id: uuid.UUID, session: AsyncSession):
+    record = await get_journal(journal_id, user_id, session)
+    await session.delete(record)
+    await session.commit()

src/main.py

@@ -7,7 +7,9 @@ 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 src.journaling.router import router as journal
 from fastapi.staticfiles import StaticFiles
 
 
@@ -33,6 +35,10 @@ app.include_router(wellbeing)
 
 app.include_router(notifications_router)
 
+app.include_router(payslip_router)
+
+app.include_router(journal)
+
 
 @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")