add master endpoint and fix add equip scope endpoint

.env

@@ -1,6 +1,6 @@
 ENV=development
 LOG_LEVEL=ERROR
-PORT=3010
+PORT=3020
 HOST=0.0.0.0
 
 DATABASE_HOSTNAME=192.168.1.82

src/scope_equipment/router.py

@@ -1,11 +1,11 @@
 
-from typing import List
+from typing import List, Optional
 from fastapi import APIRouter, HTTPException, status
 from fastapi.params import Query
 
 from .model import ScopeEquipment
-from .schema import ScopeEquipmentCreate, ScopeEquipmentPagination, ScopeEquipmentRead, ScopeEquipmentUpdate
-from .service import get, get_all, create, update, delete, get_by_scope_name, get_exculed_scope_name
+from .schema import ScopeEquipmentCreate, ScopeEquipmentPagination, ScopeEquipmentRead, ScopeEquipmentUpdate, MasterEquipmentPagination
+from .service import get, get_all, create, update, delete, get_by_scope_name, get_exculed_scope_name, get_all_master_equipment
 
 from src.database.service import CommonParameters, search_filter_sort_paginate
 from src.database.core import DbSession
@@ -16,12 +16,11 @@ router = APIRouter()
 
 
 @router.get("", response_model=StandardResponse[ScopeEquipmentPagination])
-async def get_scope_equipments(common: CommonParameters, scope_name:str = Query(None), exclude: bool = Query(False)):
+async def get_scope_equipments(common: CommonParameters, scope_name: str = Query(None), exclude: bool = Query(False)):
     """Get all scope pagination."""
     # return
     data = await get_all(db_session=common["db_session"], common=common, scope_name=scope_name, exclude=exclude)
 
-
     return StandardResponse(
         data=data,
         message="Data retrieved successfully",
@@ -36,6 +35,13 @@ async def get_scope_name(db_session: DbSession, scope_name: str, exclude: bool =
     return StandardResponse(data=await get_by_scope_name(db_session=db_session, scope_name=scope_name), message="Data retrieved successfully")
 
 
+@router.get("/master", response_model=StandardResponse[MasterEquipmentPagination])
+async def get_master_equipment(db_session: DbSession,  common: CommonParameters, exclude: Optional[str] = Query(None)):
+    results = await get_all_master_equipment(db_session=db_session, common=common, exclude=exclude)
+
+    return StandardResponse(data=results, message="Data retrieved successfully")
+
+
 @router.get("/{scope_equipment_id}", response_model=StandardResponse[ScopeEquipmentRead])
 async def get_scope_equipment(db_session: DbSession, scope_equipment_id: str):
     scope = await get(db_session=db_session, scope_equipment_id=scope_equipment_id)

src/scope_equipment/schema.py

@@ -7,16 +7,19 @@ from pydantic import Field, computed_field, field_validator, validator
 from src.models import DefultBase, Pagination
 from src.scope.schema import ScopeRead
 
+
 class MasterEquipmentBase(DefultBase):
     name: Optional[str] = Field(None, title="Name")
     location_tag: Optional[str] = Field(None, title="Location Tag")
-    
+
+
 class ScopeEquipmentBase(DefultBase):
     scope_id: Optional[UUID] = Field(None, title="Scope ID")
 
 
-class ScopeEquipmentCreate(ScopeEquipmentBase):
-    assetnum: str
+class ScopeEquipmentCreate(DefultBase):
+    assetnums: List[str]
+    scope_name: str
 
 
 class ScopeEquipmentUpdate(ScopeEquipmentBase):
@@ -30,7 +33,16 @@ class ScopeEquipmentRead(ScopeEquipmentBase):
     master_equipment: MasterEquipmentBase
     total_cost: float
 
-    
 
 class ScopeEquipmentPagination(Pagination):
     items: List[ScopeEquipmentRead] = []
+
+
+class MasterEquipmentRead(DefultBase):
+    assetnum: Optional[str] = Field(None, title="Asset Number")
+    location_tag: str
+    name: str
+
+
+class MasterEquipmentPagination(Pagination):
+    items: List[MasterEquipmentRead] = []

src/scope_equipment/service.py

@@ -1,9 +1,10 @@
 
 
-from sqlalchemy import Select, Delete, desc, func
+from fastapi import HTTPException, status
+from sqlalchemy import Select, Delete, desc, func, not_, insert
 
 from src.workorder.model import MasterWorkOrder
-from .model import ScopeEquipment
+from .model import ScopeEquipment, MasterEquipment
 from src.scope.service import get_by_scope_name as get_scope_by_name_service
 from .schema import ScopeEquipmentCreate, ScopeEquipmentUpdate
 from typing import Optional, Union
@@ -27,7 +28,6 @@ async def get_all(*, db_session: DbSession, common, scope_name: str = None, excl
     query = Select(ScopeEquipment).options(selectinload(
         ScopeEquipment.scope), selectinload(ScopeEquipment.master_equipment))
 
-
     query = query.order_by(desc(ScopeEquipment.created_at))
 
     if scope_name:
@@ -41,10 +41,35 @@ async def get_all(*, db_session: DbSession, common, scope_name: str = None, excl
 
 async def create(*, db_session: DbSession, scope_equipment_in: ScopeEquipmentCreate):
     """Creates a new document."""
-    scope_equipment = ScopeEquipment(**scope_equipment_in.model_dump())
-    db_session.add(scope_equipment)
+    # scope_equipment = ScopeEquipment(**scope_equipment_in.model_dump())
+    assetnums = scope_equipment_in.assetnums
+    scope = get_scope_by_name_service(
+        db_session=db_session, scope_name=scope_equipment_in.scope_name)
+
+    if not scope:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="A scope with this name does not exist.",
+        )
+        
+    results = []
+
+    for assetnum in assetnums:
+        stmt = insert(ScopeEquipment).values(
+            assetnum=assetnum,
+            scope_id=scope.id
+        ).on_conflict_do_update(
+            index_elements=["assetnum"],
+            set_={
+                "scope_id": scope.id
+            }
+        )
+        
+        db_session.execute(stmt)
+        results.append(assetnum)
+
     await db_session.commit()
-    return scope_equipment
+    return results
 
 
 async def update(*, db_session: DbSession, scope_equipment: ScopeEquipment, scope_equipment_in: ScopeEquipmentUpdate):
@@ -96,3 +121,14 @@ async def get_exculed_scope_name(*, db_session: DbSession, scope_name: Union[str
 
     result = await db_session.execute(query)
     return result.scalars().all()
+
+
+async def get_all_master_equipment(*, db_session: DbSession, exclude: Optional[str] = None, common: CommonParameters):
+    query = Select(MasterEquipment).filter(MasterEquipment.assetnum != None)
+
+    if exclude:
+        query = query.filter(
+            not_(MasterEquipment.location_tag.op("~")(f"{exclude.capitalize()}$")))
+
+    results = await search_filter_sort_paginate(model=query, **common)
+    return results