api

API-Fast/src/controllers/borrow_controller.py

+# myproject/controllers/borrow_controller.py
+
+from fastapi import HTTPException
+from uuid import UUID
+from datetime import datetime
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from ..models.borrow_transaction import BorrowTransaction
+from ..models.project_equipment import ProjectEquipment
+from ..models.equipment import Equipment
+from ..schemas.borrow_schema import (
+    BorrowCreate,
+    BorrowUpdate
+)
+
+# CREATE
+# 1) ตรวจสอบ ProjectEquipment (pe_id) มีไหม
+# 2) ตรวจสอบ quantity_in_project >= quantity_borrowed
+# 3) ลดจำนวน => update
+# 4) สร้าง BorrowTransaction (status=borrowed)
+async def create_borrow(db: AsyncSession, borrow_in: BorrowCreate):
+    # 1) หา projectEquipment จาก pe_id
+    result_pe = await db.execute(
+        select(ProjectEquipment).where(ProjectEquipment.pe_id == borrow_in.pe_id)
+    )
+    projectEquipment = result_pe.scalar_one_or_none()
+    if not projectEquipment:
+        raise HTTPException(status_code=404, detail="ProjectEquipment not found")
+
+    # 2) ตรวจสอบจำนวน
+    if projectEquipment.quantity_in_project < borrow_in.quantity_borrowed:
+        raise HTTPException(status_code=400, detail="Not enough equipment in project")
+
+    # 3) ลดจำนวน
+    projectEquipment.quantity_in_project -= borrow_in.quantity_borrowed
+    db.add(projectEquipment)
+
+    # 4) สร้าง BorrowTransaction
+    new_borrow = BorrowTransaction(
+        pe_id=borrow_in.pe_id,
+        quantity_borrowed=borrow_in.quantity_borrowed,
+        status=borrow_in.status or "borrowed"
+    )
+    db.add(new_borrow)
+
+    await db.commit()
+    await db.refresh(new_borrow)
+
+    return new_borrow
+
+# UPDATE
+# เช่น เปลี่ยน status -> 'returned' => ถ้า is_returnable => +quantity_in_project คืน
+async def update_borrow(db: AsyncSession, borrow_id: UUID, borrow_up: BorrowUpdate):
+    # 1) หา borrow
+    result_borrow = await db.execute(
+        select(BorrowTransaction).where(BorrowTransaction.borrow_id == borrow_id)
+    )
+    borrowTx = result_borrow.scalar_one_or_none()
+    if not borrowTx:
+        raise HTTPException(status_code=404, detail="BorrowTransaction not found")
+
+    # ถ้าส่ง status มา
+    if borrow_up.status:
+        # 2) ถ้าเปลี่ยนเป็น returned
+        if borrow_up.status == "returned":
+            # หา ProjectEquipment
+            result_pe = await db.execute(
+                select(ProjectEquipment).where(ProjectEquipment.pe_id == borrowTx.pe_id)
+            )
+            projectEquipment = result_pe.scalar_one_or_none()
+            if not projectEquipment:
+                raise HTTPException(status_code=404, detail="ProjectEquipment not found")
+
+            # หา Equipment
+            result_eq = await db.execute(
+                select(Equipment).where(Equipment.equipment_id == projectEquipment.equipment_id)
+            )
+            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, returned_date = now
+            borrowTx.status = "returned"
+            borrowTx.returned_date = datetime.utcnow()
+        else:
+            # กรณีอัปเดตเป็น status อื่น
+            borrowTx.status = borrow_up.status
+
+    db.add(borrowTx)
+    await db.commit()
+    await db.refresh(borrowTx)
+
+    return borrowTx
+
+# GET ALL
+async def get_all_borrows(db: AsyncSession):
+    result = await db.execute(select(BorrowTransaction))
+    return result.scalars().all()
+
+# GET ONE
+async def get_borrow_by_id(db: AsyncSession, borrow_id: UUID):
+    result = await db.execute(
+        select(BorrowTransaction).where(BorrowTransaction.borrow_id == borrow_id)
+    )
+    return result.scalar_one_or_none()
+
+# DELETE
+async def delete_borrow(db: AsyncSession, borrow_id: UUID):
+    borrowTx = await db.get(BorrowTransaction, borrow_id)
+    if not borrowTx:
+        raise HTTPException(status_code=404, detail="BorrowTransaction not found")
+
+    await db.delete(borrowTx)
+    await db.commit()
+    return {"message": "BorrowTransaction deleted"}

API-Fast/src/controllers/project_equipment_controller.py

+# myproject/controllers/project_equipment_controller.py
+
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from uuid import UUID
+
+from ..models.project_equipment import ProjectEquipment
+from ..schemas.project_equipment_schema import (
+    ProjectEquipmentCreate,
+    ProjectEquipmentUpdate
+)
+
+# CREATE
+async def create_project_equipment(
+    db: AsyncSession,
+    pe_in: ProjectEquipmentCreate
+):
+    new_pe = ProjectEquipment(
+        project_id=pe_in.project_id,
+        equipment_id=pe_in.equipment_id,
+        quantity_in_project=pe_in.quantity_in_project
+    )
+    db.add(new_pe)
+    await db.commit()
+    await db.refresh(new_pe)
+    return new_pe
+
+# READ ALL
+async def get_all_project_equipments(db: AsyncSession):
+    result = await db.execute(select(ProjectEquipment))
+    return result.scalars().all()
+
+# READ ONE
+async def get_project_equipment_by_id(
+    db: AsyncSession,
+    pe_id: UUID
+):
+    result = await db.execute(
+        select(ProjectEquipment).where(ProjectEquipment.pe_id == pe_id)
+    )
+    return result.scalar_one_or_none()
+
+# UPDATE
+async def update_project_equipment(
+    db: AsyncSession,
+    pe_id: UUID,
+    pe_in: ProjectEquipmentUpdate
+):
+    # หา record ตาม pe_id
+    result = await db.execute(
+        select(ProjectEquipment).where(ProjectEquipment.pe_id == pe_id)
+    )
+    pe_db = result.scalar_one_or_none()
+    if not pe_db:
+        raise HTTPException(
+            status_code=404, detail="ProjectEquipment not found"
+        )
+
+    # อัปเดตฟิลด์
+    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.quantity_in_project is not None:
+        pe_db.quantity_in_project = pe_in.quantity_in_project
+
+    await db.commit()
+    await db.refresh(pe_db)
+    return pe_db
+
+# DELETE
+async def delete_project_equipment(
+    db: AsyncSession,
+    pe_id: UUID
+):
+    pe_db = await db.get(ProjectEquipment, pe_id)
+    if not pe_db:
+        raise HTTPException(
+            status_code=404, detail="ProjectEquipment not found"
+        )
+    await db.delete(pe_db)
+    await db.commit()
+    return {"message": "ProjectEquipment deleted successfully"}

API-Fast/src/controllers/project_member_controller.py

+# myproject/controllers/project_member_controller.py
+
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from uuid import UUID
+
+from ..models.project_member import ProjectMember
+from ..schemas.project_member_schema import (
+    ProjectMemberCreate,
+    ProjectMemberUpdate
+)
+
+# CREATE
+async def create_project_member(
+    db: AsyncSession,
+    pm_in: ProjectMemberCreate
+):
+    new_pm = ProjectMember(
+        user_id=pm_in.user_id,
+        project_id=pm_in.project_id,
+        role_in_project=pm_in.role_in_project
+    )
+    db.add(new_pm)
+    await db.commit()
+    await db.refresh(new_pm)
+    return new_pm
+
+# READ ALL
+async def get_all_project_members(db: AsyncSession):
+    result = await db.execute(select(ProjectMember))
+    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))
+    return result.scalar_one_or_none()
+
+# UPDATE
+async def update_project_member(
+    db: AsyncSession,
+    pm_id: UUID,
+    pm_in: ProjectMemberUpdate
+):
+    # ค้นหาจาก pm_id
+    result = await db.execute(select(ProjectMember).where(ProjectMember.pm_id == pm_id))
+    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.role_in_project is not None:
+        pm_db.role_in_project = pm_in.role_in_project
+
+    await db.commit()
+    await db.refresh(pm_db)
+    return pm_db
+
+# DELETE
+async def delete_project_member(db: AsyncSession, pm_id: UUID):
+    pm_db = await db.get(ProjectMember, pm_id)
+    if not pm_db:
+        raise HTTPException(status_code=404, detail="ProjectMember not found")
+
+    await db.delete(pm_db)
+    await db.commit()
+
+    return {"message": "ProjectMember deleted successfully"}

API-Fast/src/main.py

@@ -7,6 +7,9 @@ import logging
 from .routes import member_routes,auth_routes,file_upload_router
 from .routes.equipment_routes import router as equipment_router
 from .routes.project_routes import router as project_router
+from .routes.project_member_routes import router as pm_router
+from .routes.project_equipment_routes import router as pe_router
+from .routes.borrow_routes import router as borrow_router
 
 from fastapi.middleware.cors import CORSMiddleware
 logging.basicConfig(level=logging.DEBUG)
@@ -38,6 +41,9 @@ app.include_router(auth_routes.router, prefix="/auth", tags=["Authentication"])
 app.include_router(member_routes.router, prefix="/members", tags=["Members"])
 app.include_router(equipment_router, prefix="/equipments", tags=["Equipments"])
 app.include_router(project_router, prefix="/projects", tags=["Projects"])
+app.include_router(pm_router, prefix="/project-members", tags=["ProjectMembers"])
+app.include_router(pe_router, prefix="/project-equipments", tags=["ProjectEquipments"])
+app.include_router(borrow_router, prefix="/borrow-transactions", tags=["BorrowTransactions"])
 app.include_router(file_upload_router.router, prefix="/api", tags=["File Upload"])
 @app.get("/")
 async def root():

API-Fast/src/models/borrow_transaction.py

+# myproject/models/borrow_transaction.py
+import uuid
+from datetime import datetime
+from sqlalchemy import Column, Integer, String, DateTime
+from sqlalchemy.dialects.postgresql import UUID
+from ..config.database import Base
+
+class BorrowTransaction(Base):
+    __tablename__ = "borrow_transactions"
+
+    borrow_id = Column(
+        UUID(as_uuid=True),
+        primary_key=True,
+        default=uuid.uuid4
+    )
+    pe_id = Column(UUID(as_uuid=True), nullable=False)  # FK to project_equipments.pe_id
+    quantity_borrowed = Column(Integer, nullable=False, default=1)
+    status = Column(String(50), nullable=False, default="borrowed")
+    returned_date = Column(DateTime, nullable=True)
+    created_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    # updated_at ถ้าต้องการก็เพิ่มได้

API-Fast/src/models/equipments.py

 # myproject/models/equipment.py
 
 import uuid
-from sqlalchemy import Column, String, Integer
+from sqlalchemy import Column, String, Integer ,Boolean
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.sql import func
 from datetime import datetime
@@ -18,9 +18,7 @@ class Equipment(Base):
     )
     equipmentName = Column(String(255), nullable=False)
     description = Column(String, nullable=True)
-    quantityTotal = Column(Integer, nullable=False, default=0)
-    location = Column(String(255), nullable=True)
-
+    is_returnable = Column(Boolean, nullable=False, default=True)
     # ถ้าต้องการวันเวลาสร้าง/แก้ไข สามารถเพิ่มได้
     # createdAt = Column(DateTime, nullable=False, server_default=func.now())
     # updatedAt = Column(DateTime, nullable=False, server_default=func.now(), onupdate=func.now())

API-Fast/src/models/project_equipment.py

+# myproject/models/project_equipment.py
+import uuid
+from sqlalchemy import Column, Integer
+from sqlalchemy.dialects.postgresql import UUID
+from ..config.database import Base
+
+class ProjectEquipment(Base):
+    __tablename__ = "project_equipments"
+
+    pe_id = 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)
+    quantity_in_project = Column(Integer, nullable=False, default=0)

API-Fast/src/models/project_member.py

+# myproject/models/project_member.py
+
+import uuid
+from sqlalchemy import Column, String, Text, ForeignKey
+from sqlalchemy.dialects.postgresql import UUID
+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)
+    role_in_project = Column(String(100), nullable=True)

API-Fast/src/routes/borrow_routes.py

+# myproject/routes/borrow_routes.py
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import List
+from uuid import UUID
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..config.database import get_db
+from ..controllers.borrow_controller import (
+    create_borrow,
+    update_borrow,
+    get_all_borrows,
+    get_borrow_by_id,
+    delete_borrow
+)
+from ..schemas.borrow_schema import (
+    BorrowCreate,
+    BorrowUpdate,
+    BorrowResponse
+)
+
+router = APIRouter()
+
+# CREATE
+@router.post("/", response_model=BorrowResponse, status_code=status.HTTP_201_CREATED)
+async def create_borrow_transaction_endpoint(
+    borrow_in: BorrowCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    new_borrow = await create_borrow(db, borrow_in)
+    return new_borrow
+
+# UPDATE
+@router.put("/{borrow_id}", response_model=BorrowResponse)
+async def update_borrow_transaction_endpoint(
+    borrow_id: UUID,
+    borrow_up: BorrowUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    updated_borrow = await update_borrow(db, borrow_id, borrow_up)
+    return updated_borrow
+
+# GET ALL
+@router.get("/", response_model=List[BorrowResponse])
+async def get_all_borrows_endpoint(db: AsyncSession = Depends(get_db)):
+    return await get_all_borrows(db)
+
+# GET ONE
+@router.get("/{borrow_id}", response_model=BorrowResponse)
+async def get_borrow_by_id_endpoint(
+    borrow_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
+    tx = await get_borrow_by_id(db, borrow_id)
+    if not tx:
+        raise HTTPException(status_code=404, detail="BorrowTransaction not found")
+    return tx
+
+# DELETE
+@router.delete("/{borrow_id}")
+async def delete_borrow_transaction_endpoint(
+    borrow_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
+    return await delete_borrow(db, borrow_id)

API-Fast/src/routes/project_equipment_routes.py

+# myproject/routes/project_equipment_routes.py
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List
+from uuid import UUID
+
+from ..config.database import get_db
+from ..controllers.project_equipment_controller import (
+    create_project_equipment,
+    get_all_project_equipments,
+    get_project_equipment_by_id,
+    update_project_equipment,
+    delete_project_equipment
+)
+from ..schemas.project_equipment_schema import (
+    ProjectEquipmentCreate,
+    ProjectEquipmentUpdate,
+    ProjectEquipmentResponse
+)
+
+router = APIRouter()
+
+# CREATE
+@router.post("/", response_model=ProjectEquipmentResponse, status_code=status.HTTP_201_CREATED)
+async def create_pe_endpoint(
+    pe_in: ProjectEquipmentCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    new_pe = await create_project_equipment(db, pe_in)
+    return new_pe
+
+# READ ALL
+@router.get("/", response_model=List[ProjectEquipmentResponse])
+async def read_all_pe_endpoint(db: AsyncSession = Depends(get_db)):
+    pes = await get_all_project_equipments(db)
+    return pes
+
+# READ ONE
+@router.get("/{pe_id}", response_model=ProjectEquipmentResponse)
+async def read_pe_by_id_endpoint(
+    pe_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
+    pe_db = await get_project_equipment_by_id(db, pe_id)
+    if not pe_db:
+        raise HTTPException(status_code=404, detail="ProjectEquipment not found")
+    return pe_db
+
+# UPDATE
+@router.put("/{pe_id}", response_model=ProjectEquipmentResponse)
+async def update_pe_endpoint(
+    pe_id: UUID,
+    pe_in: ProjectEquipmentUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    updated_pe = await update_project_equipment(db, pe_id, pe_in)
+    return updated_pe
+
+# DELETE
+@router.delete("/{pe_id}")
+async def delete_pe_endpoint(
+    pe_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
+    return await delete_project_equipment(db, pe_id)

API-Fast/src/routes/project_member_routes.py

+# myproject/routes/project_member_routes.py
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import List
+from uuid import UUID
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..config.database import get_db
+from ..controllers.project_member_controller import (
+    create_project_member,
+    get_all_project_members,
+    get_project_member_by_id,
+    update_project_member,
+    delete_project_member
+)
+from ..schemas.project_member_schema import (
+    ProjectMemberCreate,
+    ProjectMemberUpdate,
+    ProjectMemberResponse
+)
+
+router = APIRouter()
+
+# CREATE
+@router.post("/", response_model=ProjectMemberResponse, status_code=status.HTTP_201_CREATED)
+async def create_pm_endpoint(
+    pm_in: ProjectMemberCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    new_pm = await create_project_member(db, pm_in)
+    return new_pm
+
+# READ ALL
+@router.get("/", response_model=List[ProjectMemberResponse])
+async def read_all_pms(db: AsyncSession = Depends(get_db)):
+    pms = await get_all_project_members(db)
+    return pms
+
+# READ ONE
+@router.get("/{pm_id}", response_model=ProjectMemberResponse)
+async def read_pm_by_id(
+    pm_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
+    pm_db = await get_project_member_by_id(db, pm_id)
+    if not pm_db:
+        raise HTTPException(status_code=404, detail="ProjectMember not found")
+    return pm_db
+
+# UPDATE
+@router.put("/{pm_id}", response_model=ProjectMemberResponse)
+async def update_pm_endpoint(
+    pm_id: UUID,
+    pm_in: ProjectMemberUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    updated_pm = await update_project_member(db, pm_id, pm_in)
+    return updated_pm
+
+# DELETE
+@router.delete("/{pm_id}")
+async def delete_pm_endpoint(
+    pm_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
+    return await delete_project_member(db, pm_id)

API-Fast/src/schemas/borrow_schema.py

+# myproject/schemas/borrow_schema.py
+
+from pydantic import BaseModel
+from typing import Optional
+from uuid import UUID
+from datetime import datetime
+
+# สำหรับสร้าง BorrowTransaction
+class BorrowCreate(BaseModel):
+    pe_id: UUID
+    quantity_borrowed: int
+    status: Optional[str] = "borrowed"
+
+# สำหรับอัปเดต BorrowTransaction (เปลี่ยน status ฯลฯ)
+class BorrowUpdate(BaseModel):
+    status: Optional[str] = None
+
+# สำหรับแสดงผลลัพธ์ (Response)
+class BorrowResponse(BaseModel):
+    borrow_id: UUID
+    pe_id: UUID
+    quantity_borrowed: int
+    status: str
+    returned_date: Optional[datetime] = None
+
+    class Config:
+        orm_mode = True

API-Fast/src/schemas/project_equipment_schema.py

+# myproject/schemas/project_equipment_schema.py
+from pydantic import BaseModel
+from typing import Optional
+from uuid import UUID
+
+class ProjectEquipmentBase(BaseModel):
+    project_id: UUID
+    equipment_id: UUID
+    quantity_in_project: int = 0
+
+class ProjectEquipmentCreate(ProjectEquipmentBase):
+    pass
+
+class ProjectEquipmentUpdate(BaseModel):
+    project_id: Optional[UUID] = None
+    equipment_id: Optional[UUID] = None
+    quantity_in_project: Optional[int] = None
+
+class ProjectEquipmentResponse(ProjectEquipmentBase):
+    pe_id: UUID
+
+    class Config:
+        orm_mode = True

API-Fast/src/schemas/project_member_schema.py

+# myproject/schemas/project_member_schema.py
+
+from pydantic import BaseModel
+from typing import Optional
+from uuid import UUID
+
+class ProjectMemberBase(BaseModel):
+    user_id: UUID
+    project_id: UUID
+    role_in_project: Optional[str] = None
+
+class ProjectMemberCreate(ProjectMemberBase):
+    pass
+
+class ProjectMemberUpdate(BaseModel):
+    user_id: Optional[UUID] = None
+    project_id: Optional[UUID] = None
+    role_in_project: Optional[str] = None
+
+class ProjectMemberResponse(ProjectMemberBase):
+    pm_id: UUID
+
+    class Config:
+        orm_mode = True