feat: journaling endpoints

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 ###

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

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

src/core/models.py

@@ -43,6 +43,7 @@ class Users(SQLModel, table=True):
     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):

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

@@ -9,6 +9,7 @@ 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
 
 
@@ -36,6 +37,8 @@ app.include_router(notifications_router)
 
 app.include_router(payslip_router)
 
+app.include_router(journal)
+
 
 @app.get("/")
 def root():