add schedules api

src/api.py

@@ -13,6 +13,7 @@ from src.overhaul.router import router as overhaul_router
 from src.calculation_time_constrains.router import router as calculation_time_constrains_router
 from src.overhaul_history.router import router as overhaul_history_router
 from src.scope_equipment_activity.router import router as scope_equipment_activity_router
+from src.overhaul_schedule.router import router as ovehaul_schedule_router
 
 
 class ErrorMessage(BaseModel):
@@ -60,7 +61,11 @@ authenticated_api_router.include_router(
 )
 
 authenticated_api_router.include_router(
-    scope_equipment_activity_router, prefix="/equipment-activities", tags=["overhaul_history"]
+    scope_equipment_activity_router, prefix="/equipment-activities", tags=["overhaul_activities"]
+)
+
+authenticated_api_router.include_router(
+    ovehaul_schedule_router, prefix="/overhaul-schedules", tags=["overhaul_schedules"]
 )
 
 # calculation

src/overhaul/router.py

@@ -6,15 +6,15 @@ from src.overhaul.service import get_overhaul_critical_parts, get_overhaul_overv
 from .schema import OverhaulRead, OverhaulSchedules, OverhaulCriticalParts, OverhaulSystemComponents
 
 from src.models import StandardResponse
-
+from src.database.core import DbSession
 router = APIRouter()
 
 
 @router.get("", response_model=StandardResponse[OverhaulRead])
-async def get_overhaul():
+async def get_overhaul(db_session: DbSession):
     """Get all scope pagination."""
     overview = get_overhaul_overview()
-    schedules = get_overhaul_schedules()
+    schedules = await get_overhaul_schedules()
     criticalParts = get_overhaul_critical_parts()
     systemComponents = get_overhaul_system_components()
 

src/overhaul/service.py

@@ -5,6 +5,7 @@ from typing import Optional
 
 from src.database.core import DbSession
 from src.auth.service import CurrentUser
+from src.overhaul_schedule.service import get_all as get_all_schedules
 
 
 def get_overhaul_overview():
@@ -32,21 +33,10 @@ def get_overhaul_critical_parts():
     ]
 
 
-def get_overhaul_schedules():
+async def get_overhaul_schedules(*, db_session: DbSession):
     """Get all overhaul schedules."""
-    return [
-        {
-            "date": "2025-01-12",
-            "Overhaul": "B",
-            "status": "upcoming"
-        },
-        {
-            "date": "2025-02-15",
-            "Overhaul": "A",
-            "status": "upcoming"
-        },
-
-    ]
+    schedules = await get_all_schedules(db_session=db_session)
+    return schedules
 
 
 def get_overhaul_system_components():

src/overhaul_schedule/model.py

@@ -0,0 +1,16 @@
+
+from sqlalchemy import UUID, Column, DateTime, Float, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+from src.database.core import Base
+from src.models import DefaultMixin
+
+
+class OverhaulSchedule(Base, DefaultMixin):
+    __tablename__ = "oh_tr_overhaul_schedule"
+
+    scope_id = Column(UUID(as_uuid=True), ForeignKey(
+        "oh_scope.id"), nullable=True)
+    start_date = Column(DateTime(timezone=True))
+    end_date = Column(DateTime(timezone=True))
+
+    scope = relationship("Scope", backref="overhaul_schedules", lazy="raise")

src/overhaul_schedule/router.py

@@ -0,0 +1,37 @@
+
+from typing import List
+from fastapi import APIRouter, HTTPException, status
+
+from src.maximo.service import MaximoService
+
+from .schema import OverhaulScheduleCreate, OverhaulScheduleRead
+from .service import get, get_all, create
+
+from src.database.service import CommonParameters, search_filter_sort_paginate
+from src.database.core import DbSession
+from src.auth.service import CurrentUser
+from src.models import StandardResponse
+
+router = APIRouter()
+
+
+@router.get("", response_model=StandardResponse[List[OverhaulScheduleRead]])
+async def get_schedules(db_session: DbSession):
+    """Get all scope pagination."""
+    schedules = await get_all(db_session=db_session)
+    # return
+    return StandardResponse(
+        data=schedules,
+        message="Data retrieved successfully",
+    )
+
+
+
+@router.post("", response_model=StandardResponse[OverhaulScheduleRead])
+async def create_schedule(db_session: DbSession, overhaul_schedule_in: OverhaulScheduleCreate):
+
+    schedule = await create(db_session=db_session, overhaul_schedule_in=overhaul_schedule_in)
+    
+    # raise Exception(schedule.scope)
+
+    return StandardResponse(data=schedule, message="Data created successfully")

src/overhaul_schedule/schema.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+from typing import List, Optional, Union
+from uuid import UUID
+
+
+from pydantic import Field
+from src.models import DefultBase, Pagination
+from src.scope.schema import ScopeRead
+
+
+class OverhaulScheduleBase(DefultBase):
+    pass
+
+
+class OverhaulScheduleCreate(OverhaulScheduleBase):
+    scope_id: Union[UUID, str]
+    start_date: datetime
+    end_date: Optional[datetime] = Field(None)
+
+
+class OverhaulScheduleUpdate(OverhaulScheduleBase):
+    pass
+
+
+class OverhaulScheduleRead(OverhaulScheduleBase):
+    id: UUID
+    scope: Optional[ScopeRead] = Field(None)
+    start_date: datetime
+    end_date: Optional[datetime]
+
+
+class OverhaulSchedulePagination(Pagination):
+    items: List[OverhaulScheduleRead] = []

src/overhaul_schedule/service.py

@@ -0,0 +1,68 @@
+
+
+from fastapi import HTTPException
+from sqlalchemy import Select, Delete, and_
+from sqlalchemy.orm import selectinload
+
+from .model import OverhaulSchedule
+from .schema import OverhaulScheduleCreate, OverhaulScheduleUpdate
+from typing import Optional
+
+from src.database.core import DbSession
+from src.scope.service import get_by_scope_name
+
+
+async def get(*, db_session: DbSession, overhaul_history_id: str) -> Optional[OverhaulSchedule]:
+    """Returns a document based on the given document id."""
+    result = await db_session.get(OverhaulSchedule, overhaul_history_id)
+    return result.scalars().one_or_none()
+
+
+async def get_all(*, db_session: DbSession):
+    """Returns all documents."""
+    query = Select(OverhaulSchedule).options(
+        selectinload(OverhaulSchedule.scope))
+    result = await db_session.execute(query)
+    return result.scalars().all()
+
+
+async def create(*, db_session: DbSession, overhaul_schedule_in: OverhaulScheduleCreate):
+    """Creates a new document."""
+    scope = await get_by_scope_name(db_session=db_session, scope_name=overhaul_schedule_in.scope_id)
+
+    if not scope:
+        raise HTTPException(
+            status_code=404,
+            detail="Not Found"
+        )
+    overhaul_schedule_in.scope_id = scope.id
+
+    overhaul_schedule = OverhaulSchedule(**overhaul_schedule_in.model_dump())
+
+    db_session.add(overhaul_schedule)
+    await db_session.commit()
+    results = Select(OverhaulSchedule).options(selectinload(OverhaulSchedule.scope)).filter(OverhaulSchedule.id == overhaul_schedule.id)
+    return await db_session.scalar(results)
+
+
+async def update(*, db_session: DbSession, overhaul_schedule: OverhaulSchedule, overhaul_schedule_in: OverhaulScheduleUpdate):
+    """Updates a document."""
+    data = overhaul_schedule_in.model_dump()
+
+    update_data = overhaul_schedule_in.model_dump(exclude_defaults=True)
+
+    for field in data:
+        if field in update_data:
+            setattr(overhaul_schedule, field, update_data[field])
+
+    await db_session.commit()
+
+    return overhaul_schedule
+
+
+async def delete(*, db_session: DbSession, overhaul_schedule_id: str):
+    """Deletes a document."""
+    query = Delete(OverhaulSchedule).where(
+        overhaul_schedule_id == overhaul_schedule_id)
+    await db_session.execute(query)
+    await db_session.commit()

src/utils.py

@@ -58,7 +58,7 @@ def parse_date_string(date_str: str) -> Optional[datetime]:
             # Parse the date and set it to start of day in UTC
             dt = datetime.strptime(date_str, fmt)
             dt = dt.replace(
-                hour=0, minute=0, second=0, microsecond=0, tzinfo=timezone.utc
+                hour=0, minute=0, second=0, microsecond=0, tzinfo=timezone.tzname("Asia/Jakarta")
             )
             return dt
         except ValueError: