feat: update equipment master data

src/equipment/model.py

@@ -34,7 +34,7 @@ class Equipment(Base, DefaultMixin, IdentityMixin):
     )
 
 
-class MasterRecords(Base, DefaultMixin, IdentityMixin):
+class EquipmentTransactionRecords(Base, DefaultMixin, IdentityMixin):
     __tablename__ = "lcc_equipment_tr_data"
 
     equipment = relationship(

src/equipment/router.py

@@ -1,7 +1,7 @@
 from typing import List, Optional
 from fastapi import APIRouter, HTTPException, status, Query
 
-from .model import Equipment, MasterRecords
+from .model import Equipment, EquipmentTransactionRecords
 from .schema import (
     EquipmentBase,
     EquipmentPagination,
@@ -10,9 +10,10 @@ from .schema import (
     EquipmentTop10EconomicLife,
     EquipmentUpdate,
 )
-from .service import (
+from src.equipment.service import (
     get_master_by_assetnum,
     get_by_id,
+    get_by_assetnum,
     get_all,
     create,
     get_top_10_replacement_priorities,
@@ -137,16 +138,16 @@ async def create_equipment(
     return StandardResponse(data=equipment, message="Data created successfully")
 
 
-@router.put("/{equipment_id}", response_model=StandardResponse[EquipmentUpdate])
+@router.put("/{assetnum}", response_model=StandardResponse[EquipmentUpdate])
 async def update_equipment(
     db_session: DbSession,
-    equipment_id: str,
+    assetnum: str,
     equipment_in: EquipmentUpdate,
     current_user: CurrentUser,
     token: Token,
 ):
-    equipment = await get_by_id(db_session=db_session, equipment_id=equipment_id)
+    equipment = await get_by_assetnum(db_session=db_session, assetnum=assetnum)
-
+    print(equipment, assetnum)
     if not equipment:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,

src/equipment/service.py

@@ -3,7 +3,7 @@ from sqlalchemy import Select, Delete, Float, func, cast, String
 from sqlalchemy.orm import selectinload
 
 from src.database.service import search_filter_sort_paginate
-from .model import Equipment, MasterRecords
+from .model import Equipment, EquipmentTransactionRecords
 from ..equipment_master.model import EquipmentMaster
 from .schema import EquipmentCreate, EquipmentUpdate, MasterBase
 from typing import Optional
@@ -19,7 +19,7 @@ import datetime
 
 async def get_master_by_assetnum(
     *, db_session: DbSession, assetnum: str
-) -> tuple[list[MasterRecords], float | None]:
+) -> tuple[list[EquipmentTransactionRecords], float | None]:
     """Returns master records with equipment data based on asset number."""
 
     # First query to get equipment record
@@ -34,32 +34,32 @@ async def get_master_by_assetnum(
 
     # Second query to get master records
     master_query = (
-        Select(MasterRecords)
+        Select(EquipmentTransactionRecords)
-        .join(MasterRecords.equipment)
+        .join(EquipmentTransactionRecords.equipment)
-        .options(selectinload(MasterRecords.equipment))
+        .options(selectinload(EquipmentTransactionRecords.equipment))
         .filter(Equipment.assetnum == assetnum)
-        .order_by(MasterRecords.tahun.asc())
+        .order_by(EquipmentTransactionRecords.tahun.asc())
     )
     master_result = await db_session.execute(master_query)
     records = master_result.scalars().all()
 
     # Get the last actual year
     last_actual_year_query = (
-        Select(func.max(MasterRecords.tahun))
+        Select(func.max(EquipmentTransactionRecords.tahun))
-        .join(MasterRecords.equipment)
+        .join(EquipmentTransactionRecords.equipment)
         .filter(Equipment.assetnum == assetnum)
-        .filter(MasterRecords.is_actual == 1)
+        .filter(EquipmentTransactionRecords.is_actual == 1)
     )
     last_actual_year_result = await db_session.execute(last_actual_year_query)
     last_actual_year = last_actual_year_result.scalar()
 
     # Third query specifically for minimum eac_eac
     min_query = (
-        Select(func.min(func.cast(MasterRecords.eac_eac, Float)), MasterRecords.seq)
+        Select(func.min(func.cast(EquipmentTransactionRecords.eac_eac, Float)), EquipmentTransactionRecords.seq)
-        .join(MasterRecords.equipment)
+        .join(EquipmentTransactionRecords.equipment)
         .filter(Equipment.assetnum == assetnum)
-        .group_by(MasterRecords.seq)
+        .group_by(EquipmentTransactionRecords.seq)
-        .order_by(func.min(func.cast(MasterRecords.eac_eac, Float)))
+        .order_by(func.min(func.cast(EquipmentTransactionRecords.eac_eac, Float)))
         .limit(1)
     )
     min_result = await db_session.execute(min_query)
@@ -79,6 +79,12 @@ async def get_master_by_assetnum(
     )
     # return result.scalars().all()
 
+async def get_by_assetnum(*, db_session: DbSession, assetnum: str) -> Optional[Equipment]:
+    """Returns a document based on the given document id."""
+    print("assetnum service:", assetnum)
+    query = Select(Equipment).filter(Equipment.assetnum == assetnum)
+    result = await db_session.execute(query)
+    return result.scalars().one_or_none()
 
 async def get_by_id(*, db_session: DbSession, equipment_id: str) -> Optional[Equipment]:
     """Returns a document based on the given document id."""
@@ -182,9 +188,9 @@ async def generate_transaction(
 ):
     # Delete all existing master records for this asset number and prediction data
     query = (
-        Delete(MasterRecords)
+        Delete(EquipmentTransactionRecords)
-        .where(MasterRecords.assetnum == data_in.assetnum)
+        .where(EquipmentTransactionRecords.assetnum == data_in.assetnum)
-        .where(MasterRecords.is_actual == 0)
+        .where(EquipmentTransactionRecords.is_actual == 0)
     )
     await db_session.execute(query)
     await db_session.commit()
@@ -300,7 +306,7 @@ async def create(*, db_session: DbSession, equipment_in: EquipmentCreate, token)
     equipment = Equipment(**equipment_in.model_dump())
     db_session.add(equipment)
     await db_session.commit()
-    await generate_transaction(db_session=db_session, data_in=equipment_in, token=token)
+    # await generate_transaction(db_session=db_session, data_in=equipment_in, token=token)
     return equipment
 
 
@@ -318,12 +324,12 @@ async def update(
     await db_session.commit()
 
     updated_data = vars(equipment)
-    equipment_create = EquipmentCreate(**updated_data)
+    # equipment_create = EquipmentCreate(**updated_data)
-    await generate_transaction(
+    # await generate_transaction(
-        db_session=db_session, data_in=equipment_create, token=token
+    #     db_session=db_session, data_in=equipment_create, token=token
-    )
+    # )
 
-    return equipment
+    return updated_data
 
 
 async def delete(*, db_session: DbSession, equipment_id: str):