api

API-Fast/src/controllers/borrow_controller.py

@@ -5,33 +5,43 @@ from datetime import datetime
 from fastapi import HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
-
+from ..models.project_equipment import ProjectEquipment
+from ..models.project_member import ProjectMember
 from ..models.borrow_transaction import BorrowTransaction
 from ..models.project_equipment import ProjectEquipment
-from ..models.equipment import Equipment
+from ..models.equipments import Equipment
 from ..models.member import Member  # ถ้าต้องเช็คว่ามี member นี้จริงไหม
 from ..schemas.borrow_schema import BorrowCreate, BorrowUpdate
 
 # CREATE
-# - ตรวจสอบ member_id มีจริงไหม (ถ้าต้องการ)
-# - ตรวจสอบ project_equipment (pe_id) มีจริง + พอไหม
+# - ตรวจสอบ memberId มีจริงไหม (ถ้าต้องการ)
+# - ตรวจสอบ project_equipment (peId) มีจริง + พอไหม
 # - ลดจำนวนใน project_equipment
 # - สร้าง record borrow_transaction
 async def create_borrow_transaction(db: AsyncSession, borrow_in: BorrowCreate):
-    # (ถ้าต้องการตรวจสอบว่ามี member_id นี้ไหม)
-    # result_member = await db.execute(select(Member).where(Member.memberId == borrow_in.member_id))
-    # member_db = result_member.scalar_one_or_none()
-    # if not member_db:
-    #     raise HTTPException(status_code=404, detail="Member not found")
-
-    # 1) หา project_equipments จาก pe_id
+    # 1) หา projectEquipment จาก peId
     result_pe = await db.execute(
-        select(ProjectEquipment).where(ProjectEquipment.pe_id == borrow_in.pe_id)
+        select(ProjectEquipment).where(ProjectEquipment.peId == borrow_in.peId)
     )
     projectEquipment = result_pe.scalar_one_or_none()
     if not projectEquipment:
         raise HTTPException(status_code=404, detail="ProjectEquipment not found")
 
+    # 1.1) ตรวจสอบว่า memberId อยู่ใน projectId นี้หรือไม่
+    # (projectEquipment.projectId) + (borrow_in.memberId)
+    check_pm = await db.execute(
+        select(ProjectMember).where(
+            ProjectMember.memberId == borrow_in.memberId,
+            ProjectMember.projectId == projectEquipment.projectId
+        )
+    )
+    pm_record = check_pm.scalar_one_or_none()
+    if not pm_record:
+        raise HTTPException(
+            status_code=403,
+            detail="Member is not in this project, cannot borrow."
+        )
+
     # 2) ตรวจสอบจำนวน
     if projectEquipment.quantity_in_project < borrow_in.quantity_borrowed:
         raise HTTPException(status_code=400, detail="Not enough equipment in project")
@@ -42,8 +52,8 @@ async def create_borrow_transaction(db: AsyncSession, borrow_in: BorrowCreate):
 
     # 4) สร้าง BorrowTransaction
     new_borrow = BorrowTransaction(
-        member_id=borrow_in.member_id,
-        pe_id=borrow_in.pe_id,
+        memberId=borrow_in.memberId,
+        peId=borrow_in.peId,
         quantity_borrowed=borrow_in.quantity_borrowed,
         status=borrow_in.status or "borrowed"
     )
@@ -53,46 +63,44 @@ async def create_borrow_transaction(db: AsyncSession, borrow_in: BorrowCreate):
     await db.refresh(new_borrow)
     return new_borrow
 
-# UPDATE
-# - ถ้าเปลี่ยน status เป็น "returned" => เช็ค equipment.is_returnable => บวกจำนวนคืน
-async def update_borrow_transaction(db: AsyncSession, borrow_id: UUID, borrow_up: BorrowUpdate):
-    # 1) หา borrowTransaction เดิม
+# UPDATE (คืนอุปกรณ์, เปลี่ยนสถานะ)
+async def update_borrow_transaction(db: AsyncSession, borrowId: UUID, borrow_up: BorrowUpdate):
+    # 1) หา borrow เดิม
     result_bt = await db.execute(
-        select(BorrowTransaction).where(BorrowTransaction.borrow_id == borrow_id)
+        select(BorrowTransaction).where(BorrowTransaction.borrowId == borrowId)
     )
     borrowTx = result_bt.scalar_one_or_none()
     if not borrowTx:
         raise HTTPException(status_code=404, detail="BorrowTransaction not found")
 
+    # ถ้า user ส่ง status มา
     if borrow_up.status:
-        # 2) ถ้าเปลี่ยนเป็น 'returned'
         if borrow_up.status == "returned":
-            # หา projectEquipment
+            # 2.1) หา ProjectEquipment
             result_pe = await db.execute(
-                select(ProjectEquipment).where(ProjectEquipment.pe_id == borrowTx.pe_id)
+                select(ProjectEquipment).where(ProjectEquipment.peId == borrowTx.peId)
             )
             projectEquipment = result_pe.scalar_one_or_none()
             if not projectEquipment:
                 raise HTTPException(status_code=404, detail="ProjectEquipment not found")
 
-            # หา equipment
+            # 2.2) หา Equipment
             result_eq = await db.execute(
-                select(Equipment).where(Equipment.equipment_id == projectEquipment.equipment_id)
+                select(Equipment).where(Equipment.equipmentId == projectEquipment.equipmentId)
             )
             equipment = result_eq.scalar_one_or_none()
             if not equipment:
                 raise HTTPException(status_code=404, detail="Equipment not found")
 
-            # ถ้า is_returnable => บวกจำนวน
+            # ถ้าเป็นอุปกรณ์ต้องคืน => บวกจำนวนคืน
             if equipment.is_returnable:
                 projectEquipment.quantity_in_project += borrowTx.quantity_borrowed
                 db.add(projectEquipment)
 
             borrowTx.status = "returned"
             borrowTx.returned_date = datetime.utcnow()
-
         else:
-            # เปลี่ยนเป็นสถานะอื่น
+            # อัปเดตเป็นสถานะอื่น
             borrowTx.status = borrow_up.status
 
     db.add(borrowTx)
@@ -106,15 +114,15 @@ async def get_all_borrow_transactions(db: AsyncSession):
     return result.scalars().all()
 
 # GET BY ID
-async def get_borrow_transaction_by_id(db: AsyncSession, borrow_id: UUID):
+async def get_borrow_transaction_by_id(db: AsyncSession, borrowId: UUID):
     result = await db.execute(
-        select(BorrowTransaction).where(BorrowTransaction.borrow_id == borrow_id)
+        select(BorrowTransaction).where(BorrowTransaction.borrowId == borrowId)
     )
     return result.scalar_one_or_none()
 
 # DELETE
-async def delete_borrow_transaction(db: AsyncSession, borrow_id: UUID):
-    borrowTx = await db.get(BorrowTransaction, borrow_id)
+async def delete_borrow_transaction(db: AsyncSession, borrowId: UUID):
+    borrowTx = await db.get(BorrowTransaction, borrowId)
     if not borrowTx:
         raise HTTPException(status_code=404, detail="BorrowTransaction not found")
 

API-Fast/src/controllers/project_controller.py

@@ -35,21 +35,21 @@ async def get_all_projects(db: AsyncSession):
 # READ ONE
 async def get_project_by_id(
     db: AsyncSession,
-    project_id: UUID
+    projectId: UUID
 ):
     result = await db.execute(
-        select(Project).where(Project.project_id == project_id)
+        select(Project).where(Project.projectId == projectId)
     )
     return result.scalar_one_or_none()
 
 # UPDATE
 async def update_project(
     db: AsyncSession,
-    project_id: UUID,
+    projectId: UUID,
     project_in: ProjectUpdate
 ):
     result = await db.execute(
-        select(Project).where(Project.project_id == project_id)
+        select(Project).where(Project.projectId == projectId)
     )
     project_db = result.scalar_one_or_none()
 
@@ -72,8 +72,8 @@ async def update_project(
     return project_db
 
 # DELETE
-async def delete_project(db: AsyncSession, project_id: UUID):
-    project_db = await db.get(Project, project_id)
+async def delete_project(db: AsyncSession, projectId: UUID):
+    project_db = await db.get(Project, projectId)
     if not project_db:
         raise HTTPException(
             status_code=404, detail="Project not found"

API-Fast/src/controllers/project_equipment_controller.py

@@ -17,8 +17,8 @@ async def create_project_equipment(
     pe_in: ProjectEquipmentCreate
 ):
     new_pe = ProjectEquipment(
-        project_id=pe_in.project_id,
-        equipment_id=pe_in.equipment_id,
+        projectId=pe_in.projectId,
+        equipmentId=pe_in.equipmentId,
         quantity_in_project=pe_in.quantity_in_project
     )
     db.add(new_pe)
@@ -34,22 +34,22 @@ async def get_all_project_equipments(db: AsyncSession):
 # READ ONE
 async def get_project_equipment_by_id(
     db: AsyncSession,
-    pe_id: UUID
+    peId: UUID
 ):
     result = await db.execute(
-        select(ProjectEquipment).where(ProjectEquipment.pe_id == pe_id)
+        select(ProjectEquipment).where(ProjectEquipment.peId == peId)
     )
     return result.scalar_one_or_none()
 
 # UPDATE
 async def update_project_equipment(
     db: AsyncSession,
-    pe_id: UUID,
+    peId: UUID,
     pe_in: ProjectEquipmentUpdate
 ):
-    # หา record ตาม pe_id
+    # หา record ตาม peId
     result = await db.execute(
-        select(ProjectEquipment).where(ProjectEquipment.pe_id == pe_id)
+        select(ProjectEquipment).where(ProjectEquipment.peId == peId)
     )
     pe_db = result.scalar_one_or_none()
     if not pe_db:
@@ -58,10 +58,10 @@ async def update_project_equipment(
         )
 
     # อัปเดตฟิลด์
-    if pe_in.project_id is not None:
-        pe_db.project_id = pe_in.project_id
-    if pe_in.equipment_id is not None:
-        pe_db.equipment_id = pe_in.equipment_id
+    if pe_in.projectId is not None:
+        pe_db.projectId = pe_in.projectId
+    if pe_in.equipmentId is not None:
+        pe_db.equipmentId = pe_in.equipmentId
     if pe_in.quantity_in_project is not None:
         pe_db.quantity_in_project = pe_in.quantity_in_project
 
@@ -72,9 +72,9 @@ async def update_project_equipment(
 # DELETE
 async def delete_project_equipment(
     db: AsyncSession,
-    pe_id: UUID
+    peId: UUID
 ):
-    pe_db = await db.get(ProjectEquipment, pe_id)
+    pe_db = await db.get(ProjectEquipment, peId)
     if not pe_db:
         raise HTTPException(
             status_code=404, detail="ProjectEquipment not found"

API-Fast/src/controllers/project_member_controller.py

@@ -17,8 +17,8 @@ async def create_project_member(
     pm_in: ProjectMemberCreate
 ):
     new_pm = ProjectMember(
-        user_id=pm_in.user_id,
-        project_id=pm_in.project_id,
+        memberId=pm_in.memberId,
+        projectId=pm_in.projectId,
         role_in_project=pm_in.role_in_project
     )
     db.add(new_pm)
@@ -32,28 +32,28 @@ async def get_all_project_members(db: AsyncSession):
     return result.scalars().all()
 
 # READ ONE
-async def get_project_member_by_id(db: AsyncSession, pm_id: UUID):
-    result = await db.execute(select(ProjectMember).where(ProjectMember.pm_id == pm_id))
+async def get_project_member_by_id(db: AsyncSession, pmId: UUID):
+    result = await db.execute(select(ProjectMember).where(ProjectMember.pmId == pmId))
     return result.scalar_one_or_none()
 
 # UPDATE
 async def update_project_member(
     db: AsyncSession,
-    pm_id: UUID,
+    pmId: UUID,
     pm_in: ProjectMemberUpdate
 ):
-    # ค้นหาจาก pm_id
-    result = await db.execute(select(ProjectMember).where(ProjectMember.pm_id == pm_id))
+    # ค้นหาจาก pmId
+    result = await db.execute(select(ProjectMember).where(ProjectMember.pmId == pmId))
     pm_db = result.scalar_one_or_none()
 
     if not pm_db:
         raise HTTPException(status_code=404, detail="ProjectMember not found")
 
     # อัปเดตฟิลด์
-    if pm_in.user_id is not None:
-        pm_db.user_id = pm_in.user_id
-    if pm_in.project_id is not None:
-        pm_db.project_id = pm_in.project_id
+    if pm_in.memberId is not None:
+        pm_db.memberId = pm_in.memberId
+    if pm_in.projectId is not None:
+        pm_db.projectId = pm_in.projectId
     if pm_in.role_in_project is not None:
         pm_db.role_in_project = pm_in.role_in_project
 
@@ -62,8 +62,8 @@ async def update_project_member(
     return pm_db
 
 # DELETE
-async def delete_project_member(db: AsyncSession, pm_id: UUID):
-    pm_db = await db.get(ProjectMember, pm_id)
+async def delete_project_member(db: AsyncSession, pmId: UUID):
+    pm_db = await db.get(ProjectMember, pmId)
     if not pm_db:
         raise HTTPException(status_code=404, detail="ProjectMember not found")
 

API-Fast/src/models/borrow_transaction.py

@@ -9,13 +9,13 @@ from ..config.database import Base
 class BorrowTransaction(Base):
     __tablename__ = "borrow_transactions"
 
-    borrow_id = Column(
+    borrowId = Column(
         UUID(as_uuid=True),
         primary_key=True,
         default=uuid.uuid4
     )
-    pe_id = Column(UUID(as_uuid=True), nullable=False)   # FK -> project_equipments.pe_id
-    member_id = Column(UUID(as_uuid=True), nullable=False) # FK -> member.memberId (ตาม Model Member)
+    peId = Column(UUID(as_uuid=True), nullable=False)   # FK -> project_equipments.peId
+    memberId = Column(UUID(as_uuid=True), nullable=False) # FK -> member.memberId (ตาม Model Member)
     quantity_borrowed = Column(Integer, nullable=False, default=1)
     status = Column(String(50), nullable=False, default="borrowed")
     returned_date = Column(DateTime, nullable=True)

API-Fast/src/models/project.py

@@ -8,7 +8,7 @@ from ..config.database import Base
 class Project(Base):
     __tablename__ = 'projects'  # ชื่อตารางใน DB
 
-    project_id = Column(
+    projectId = Column(
         UUID(as_uuid=True),
         primary_key=True,
         default=uuid.uuid4

API-Fast/src/models/project_equipment.py

@@ -7,11 +7,11 @@ from ..config.database import Base
 class ProjectEquipment(Base):
     __tablename__ = "project_equipments"
 
-    pe_id = Column(
+    peId = Column(
         UUID(as_uuid=True),
         primary_key=True,
         default=uuid.uuid4
     )
-    project_id = Column(UUID(as_uuid=True), nullable=False)
-    equipment_id = Column(UUID(as_uuid=True), nullable=False)
+    projectId = Column(UUID(as_uuid=True), nullable=False)
+    equipmentId = Column(UUID(as_uuid=True), nullable=False)
     quantity_in_project = Column(Integer, nullable=False, default=0)

API-Fast/src/models/project_member.py

@@ -8,7 +8,7 @@ from ..config.database import Base
 class ProjectMember(Base):
     __tablename__ = 'project_members'
 
-    pm_id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    user_id = Column(UUID(as_uuid=True), nullable=False)
-    project_id = Column(UUID(as_uuid=True), nullable=False)
+    pmId = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    memberId = Column(UUID(as_uuid=True), nullable=False)
+    projectId = Column(UUID(as_uuid=True), nullable=False)
     role_in_project = Column(String(100), nullable=True)

API-Fast/src/routes/borrow_routes.py

@@ -31,13 +31,13 @@ async def create_borrow_endpoint(
     return new_borrow
 
 # UPDATE (เช่น คืนอุปกรณ์)
-@router.put("/{borrow_id}", response_model=BorrowResponse)
+@router.put("/{borrowId}", response_model=BorrowResponse)
 async def update_borrow_endpoint(
-    borrow_id: UUID,
+    borrowId: UUID,
     borrow_up: BorrowUpdate,
     db: AsyncSession = Depends(get_db)
 ):
-    updated_borrow = await update_borrow_transaction(db, borrow_id, borrow_up)
+    updated_borrow = await update_borrow_transaction(db, borrowId, borrow_up)
     return updated_borrow
 
 # GET ALL
@@ -46,20 +46,20 @@ async def get_all_borrows_endpoint(db: AsyncSession = Depends(get_db)):
     return await get_all_borrow_transactions(db)
 
 # GET BY ID
-@router.get("/{borrow_id}", response_model=BorrowResponse)
+@router.get("/{borrowId}", response_model=BorrowResponse)
 async def get_borrow_by_id_endpoint(
-    borrow_id: UUID,
+    borrowId: UUID,
     db: AsyncSession = Depends(get_db)
 ):
-    tx = await get_borrow_transaction_by_id(db, borrow_id)
+    tx = await get_borrow_transaction_by_id(db, borrowId)
     if not tx:
         raise HTTPException(status_code=404, detail="BorrowTransaction not found")
     return tx
 
 # DELETE
-@router.delete("/{borrow_id}")
+@router.delete("/{borrowId}")
 async def delete_borrow_endpoint(
-    borrow_id: UUID,
+    borrowId: UUID,
     db: AsyncSession = Depends(get_db)
 ):
-    return await delete_borrow_transaction(db, borrow_id)
+    return await delete_borrow_transaction(db, borrowId)

API-Fast/src/routes/project_equipment_routes.py

@@ -37,30 +37,30 @@ async def read_all_pe_endpoint(db: AsyncSession = Depends(get_db)):
     return pes
 
 # READ ONE
-@router.get("/{pe_id}", response_model=ProjectEquipmentResponse)
+@router.get("/{peId}", response_model=ProjectEquipmentResponse)
 async def read_pe_by_id_endpoint(
-    pe_id: UUID,
+    peId: UUID,
     db: AsyncSession = Depends(get_db)
 ):
-    pe_db = await get_project_equipment_by_id(db, pe_id)
+    pe_db = await get_project_equipment_by_id(db, peId)
     if not pe_db:
         raise HTTPException(status_code=404, detail="ProjectEquipment not found")
     return pe_db
 
 # UPDATE
-@router.put("/{pe_id}", response_model=ProjectEquipmentResponse)
+@router.put("/{peId}", response_model=ProjectEquipmentResponse)
 async def update_pe_endpoint(
-    pe_id: UUID,
+    peId: UUID,
     pe_in: ProjectEquipmentUpdate,
     db: AsyncSession = Depends(get_db)
 ):
-    updated_pe = await update_project_equipment(db, pe_id, pe_in)
+    updated_pe = await update_project_equipment(db, peId, pe_in)
     return updated_pe
 
 # DELETE
-@router.delete("/{pe_id}")
+@router.delete("/{peId}")
 async def delete_pe_endpoint(
-    pe_id: UUID,
+    peId: UUID,
     db: AsyncSession = Depends(get_db)
 ):
-    return await delete_project_equipment(db, pe_id)
+    return await delete_project_equipment(db, peId)

API-Fast/src/routes/project_member_routes.py

@@ -37,30 +37,30 @@ async def read_all_pms(db: AsyncSession = Depends(get_db)):
     return pms
 
 # READ ONE
-@router.get("/{pm_id}", response_model=ProjectMemberResponse)
+@router.get("/{pmId}", response_model=ProjectMemberResponse)
 async def read_pm_by_id(
-    pm_id: UUID,
+    pmId: UUID,
     db: AsyncSession = Depends(get_db)
 ):
-    pm_db = await get_project_member_by_id(db, pm_id)
+    pm_db = await get_project_member_by_id(db, pmId)
     if not pm_db:
         raise HTTPException(status_code=404, detail="ProjectMember not found")
     return pm_db
 
 # UPDATE
-@router.put("/{pm_id}", response_model=ProjectMemberResponse)
+@router.put("/{pmId}", response_model=ProjectMemberResponse)
 async def update_pm_endpoint(
-    pm_id: UUID,
+    pmId: UUID,
     pm_in: ProjectMemberUpdate,
     db: AsyncSession = Depends(get_db)
 ):
-    updated_pm = await update_project_member(db, pm_id, pm_in)
+    updated_pm = await update_project_member(db, pmId, pm_in)
     return updated_pm
 
 # DELETE
-@router.delete("/{pm_id}")
+@router.delete("/{pmId}")
 async def delete_pm_endpoint(
-    pm_id: UUID,
+    pmId: UUID,
     db: AsyncSession = Depends(get_db)
 ):
-    return await delete_project_member(db, pm_id)
+    return await delete_project_member(db, pmId)

API-Fast/src/schemas/borrow_schema.py

-# myproject/schemas/borrow_schema.py
 from pydantic import BaseModel
 from uuid import UUID
 from typing import Optional
 from datetime import datetime
 
-# CREATE Borrow (ตอน user กดยืม)
 class BorrowCreate(BaseModel):
-    member_id: UUID
-    pe_id: UUID
+    memberId: UUID
+    peId: UUID
     quantity_borrowed: int
     status: Optional[str] = "borrowed"
 
-# UPDATE Borrow (เปลี่ยนสถานะเป็น returned, canceled ฯลฯ)
 class BorrowUpdate(BaseModel):
     status: Optional[str] = None
 
-# RESPONSE
 class BorrowResponse(BaseModel):
-    borrow_id: UUID
-    pe_id: UUID
-    member_id: UUID
+    borrowId: UUID
+    peId: UUID
+    memberId: UUID
     quantity_borrowed: int
     status: str
     returned_date: Optional[datetime] = None

API-Fast/src/schemas/project_equipment_schema.py

@@ -4,20 +4,20 @@ from typing import Optional
 from uuid import UUID
 
 class ProjectEquipmentBase(BaseModel):
-    project_id: UUID
-    equipment_id: UUID
+    projectId: UUID
+    equipmentId: UUID
     quantity_in_project: int = 0
 
 class ProjectEquipmentCreate(ProjectEquipmentBase):
     pass
 
 class ProjectEquipmentUpdate(BaseModel):
-    project_id: Optional[UUID] = None
-    equipment_id: Optional[UUID] = None
+    projectId: Optional[UUID] = None
+    equipmentId: Optional[UUID] = None
     quantity_in_project: Optional[int] = None
 
 class ProjectEquipmentResponse(ProjectEquipmentBase):
-    pe_id: UUID
+    peId: UUID
 
     class Config:
         orm_mode = True

API-Fast/src/schemas/project_member_schema.py

@@ -5,20 +5,20 @@ from typing import Optional
 from uuid import UUID
 
 class ProjectMemberBase(BaseModel):
-    user_id: UUID
-    project_id: UUID
+    memberId: UUID
+    projectId: UUID
     role_in_project: Optional[str] = None
 
 class ProjectMemberCreate(ProjectMemberBase):
     pass
 
 class ProjectMemberUpdate(BaseModel):
-    user_id: Optional[UUID] = None
-    project_id: Optional[UUID] = None
+    memberId: Optional[UUID] = None
+    projectId: Optional[UUID] = None
     role_in_project: Optional[str] = None
 
 class ProjectMemberResponse(ProjectMemberBase):
-    pm_id: UUID
+    pmId: UUID
 
     class Config:
         orm_mode = True

API-Fast/src/schemas/project_schema.py

@@ -21,7 +21,7 @@ class ProjectUpdate(BaseModel):
     end_date: Optional[date] = None
 
 class ProjectResponse(ProjectBase):
-    project_id: UUID
+    projectId: UUID
 
     class Config:
         orm_mode = True