Merge branch 'main' of https://github.com/Madiwka4/csci361-vms-backend

app/apis/base.py

@@ -7,6 +7,8 @@ from apis.v1 import (
     route_auth,
     route_task,
     route_maintenancejob,
+    route_fuelingtask,
+    route_auction,
 )
 
 api_router = APIRouter()
@@ -17,3 +19,5 @@ api_router.include_router(route_task.router, prefix="/task", tags=["task"])
 api_router.include_router(
     route_maintenancejob.router, prefix="/maintenancejob", tags=["maintenancejob"]
 )
+api_router.include_router(route_fuelingtask.router, prefix="/fuel", tags=["fueltasks"])
+api_router.include_router(route_auction.router, prefix="/auction", tags=["auctions"])

app/apis/v1/route_auction.py

@@ -0,0 +1,94 @@
+from fastapi import Depends, APIRouter, HTTPException, status
+from sqlalchemy.orm import Session
+from db.session import get_db
+from schemas.auction import ShowAuction, CreateAuction
+from typing import List
+from db.repository.auction import (
+    get_all_auctions,
+    get_auction_by_id,
+    create_new_auction,
+    edit_auction_by_id,
+    delete_auction_by_id,
+)
+from db.models.user import User
+from apis.v1.route_auth import get_current_user
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[ShowAuction], status_code=status.HTTP_200_OK)
+def getAllAuctions(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    auctions = get_all_auctions(db)
+    return auctions
+
+
+@router.get("/{id}", response_model=ShowAuction, status_code=status.HTTP_200_OK)
+def getAuction(
+    id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    auction = get_auction_by_id(id, db)
+    return auction
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+def create_auction(
+    auction: CreateAuction,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    auction_res = create_new_auction(auction=auction, createId=current_user.Id, db=db)
+    if auction_res == "novehicle":
+        raise HTTPException(
+            status_code=404, detail="Vehicle with this ID does not exist"
+        )
+    elif auction_res == "vehicleunavailable":
+        raise HTTPException(
+            status_code=404, detail="Vehicle with this ID is currently not up for sale"
+        )
+    return auction_res
+
+
+@router.patch("/{auc_id}", status_code=status.HTTP_200_OK)
+def editAuction(
+    auc_id: int,
+    auction: CreateAuction,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    auction_res = edit_auction_by_id(id=auc_id, auction=auction, db=db)
+    if auction_res == "noauction":
+        raise HTTPException(
+            status_code=404, detail="Auction with this ID does not exist"
+        )
+    return auction_res
+
+
+@router.delete("/{auc_id}", status_code=status.HTTP_200_OK)
+def deleteAuction(
+    auc_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    auction_res = delete_auction_by_id(id=auc_id, db=db)
+    if auction_res == "noauction":
+        raise HTTPException(
+            status_code=404, detail="Auction with this ID does not exist"
+        )
+    return auction_res

app/apis/v1/route_fuelingtask.py

@@ -0,0 +1,75 @@
+from fastapi import Depends, APIRouter, HTTPException, status
+from sqlalchemy.orm import Session
+from db.session import get_db
+from db.repository.fuelingtask import (
+    create_fueling_task,
+    delete_fueling_task,
+    get_fueling_task_by_id
+)
+from schemas.fuelingtask import CreateFuelingTask, OutputFuelingTask
+from db.models.user import User
+from apis.v1.route_auth import get_current_user
+
+router = APIRouter()
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+def create_fuelingtask(
+    fuelingtask: CreateFuelingTask,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "FuelingPerson" and current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+
+    fuelingtask_res = create_fueling_task(
+        fueling_task=fuelingtask, current_user=current_user.Id, db=db
+    )
+
+    if fuelingtask_res == "nodriver":
+        raise HTTPException(
+            status_code=404, detail="Driver ID not found"
+        )
+
+    if fuelingtask_res == "novehicle":
+        raise HTTPException(
+            status_code=404, detail="Vehicle ID not found"
+        )
+    return fuelingtask_res
+
+
+
+@router.get("/{fueling_task_id}", response_model=OutputFuelingTask, status_code=status.HTTP_200_OK)
+def get_fuelingtask(
+    fueling_task_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "FuelingPerson" and current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    
+    fuelingtask = get_fueling_task_by_id(fueling_task_id, db)
+    if fuelingtask == "notfound":
+        raise HTTPException(
+            status_code=404, detail="fuck off"
+        )
+    return fuelingtask
+
+@router.delete("/{fueling_task_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_fuelingtask(
+    fueling_task_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "FuelingPerson" and current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+
+    if not delete_fueling_task(fueling_task_id, db):
+        raise HTTPException(
+            status_code=404, detail="Fueling task not found"
+        )

app/apis/v1/route_maintenancejob.py

@@ -6,9 +6,10 @@ from db.repository.maintenancejob import (
     create_car_part,
     get_all_maintenance_jobs,
     get_maintenance_job,
-    change_maintenance_status
+    change_maintenance_status,
 )
-from schemas.maintenancejob import CreateMaintenanceJob
+from typing import List
+from schemas.maintenancejob import CreateMaintenanceJob, OutputMaintenanceJob
 from schemas.carpart import CreateCarPart
 from db.models.user import User
 from apis.v1.route_auth import get_current_user
@@ -48,7 +49,9 @@ def create_carpart(
     return car_part_res
 
 
-@router.get("/", status_code=status.HTTP_200_OK)
+@router.get(
+    "/", response_model=List[OutputMaintenanceJob], status_code=status.HTTP_200_OK
+)
 def get_all_maintenancejobs(
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
@@ -62,7 +65,11 @@ def get_all_maintenancejobs(
     return maintenancejobs
 
 
-@router.get("/{maintenance_job_id}", status_code=status.HTTP_200_OK)
+@router.get(
+    "/{maintenance_job_id}",
+    response_model=OutputMaintenanceJob,
+    status_code=status.HTTP_200_OK,
+)
 def get_maintenancejob(
     maintenance_job_id: int,
     db: Session = Depends(get_db),
@@ -74,8 +81,10 @@ def get_maintenancejob(
         )
 
     maintenancejob = get_maintenance_job(maintenance_job_id, db)
+    print(maintenancejob)
     return maintenancejob
 
+
 @router.patch("/{maintenance_job_id}", status_code=status.HTTP_200_OK)
 def change_status(
     maintenance_job_id: int,
@@ -89,7 +98,5 @@ def change_status(
         )
     result = change_maintenance_status(maintenance_job_id, status, db)
     if result is None:
-        raise HTTPException(
-            status_code=404, detail="Maintenance job not found"
-        )
-    return result 
+        raise HTTPException(status_code=404, detail="Maintenance job not found")
+    return result

app/apis/v1/route_task.py

@@ -9,11 +9,14 @@ from db.repository.drivetask import (
     get_all_tasks,
     get_task_by_id,
     get_tasks_by_driver,
-    edit_task
+    edit_task,
+    get_active_route_by_driver,
+    get_my_routes,
 )
-from schemas.drivetask import CreateTask
+from schemas.drivetask import CreateTask, ShowTask
 from db.models.user import User
 from apis.v1.route_auth import get_current_user
+from typing import List
 
 router = APIRouter()
 
@@ -68,13 +71,14 @@ def changeStatus(
         )
 
 
-@router.get("/", status_code=status.HTTP_200_OK)
+@router.get("/", response_model=List[ShowTask], status_code=status.HTTP_200_OK)
 def getAllTasks(
+    status: str = "Any",
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
     if current_user.Role == "Admin":
-        tasks = get_all_tasks(db)
+        tasks = get_all_tasks(status, db)
         return tasks
     else:
         raise HTTPException(
@@ -82,7 +86,7 @@ def getAllTasks(
         )
 
 
-@router.get("/{task_id}", status_code=status.HTTP_200_OK)
+@router.get("/{task_id}", response_model=ShowTask, status_code=status.HTTP_200_OK)
 def getTaskById(
     task_id: int,
     db: Session = Depends(get_db),
@@ -120,6 +124,7 @@ def getTasksByDriver(
         )
     return tasks
 
+
 @router.put("/{task_id}", status_code=status.HTTP_200_OK)
 def updateTask(
     task_id: int,
@@ -133,7 +138,48 @@ def updateTask(
         )
     task = edit_task(task_id, task, db)
     if task == "notaskfound":
+        raise HTTPException(status_code=404, detail=f"Task with id {task_id} not found")
+    return task
+
+
+@router.get("/active/{driver_id}", status_code=status.HTTP_200_OK)
+def getActiveRoute(
+    driver_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "Admin" and current_user.Id != driver_id:
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    route = get_active_route_by_driver(driver_id, db)
+    if route == "notdriver":
+        raise HTTPException(
+            status_code=404, detail=f"Driver with id {driver_id} not found"
+        )
+    if route == "noroute":
+        raise HTTPException(
+            status_code=404, detail=f"Driver with id {driver_id} has no active route"
+        )
+    return route
+
+
+@router.get("/myroutes", status_code=status.HTTP_200_OK)
+def getMyRoutes(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "Driver":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    routes = get_my_routes(current_user.Id, db)
+    if routes == "notdriver":
+        raise HTTPException(
+            status_code=404, detail=f"Driver with id {current_user.Id} not found"
+        )
+    if not routes:
         raise HTTPException(
-            status_code=404, detail=f"Task with id {task_id} not found"
+            status_code=404, detail=f"Driver with id {current_user.Id} has no routes"
         )
-    return task
+    return routes

app/apis/v1/route_user.py

@@ -7,7 +7,14 @@ from apis.v1.route_auth import get_current_user
 from db.models.user import User
 from schemas.user import UserCreate, ShowUser, ShowDriver, DriverCreate
 from db.session import get_db
-from db.repository.user import create_new_user, list_users, get_user_by_id, replace_user_data, create_new_driver
+from db.repository.user import (
+    create_new_user,
+    list_users,
+    get_user_by_id,
+    replace_user_data,
+    create_new_driver,
+    delete_user_data,
+)
 
 
 router = APIRouter()
@@ -19,24 +26,30 @@ def create_user(
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
-    if (current_user.Role != "Admin"):
-        raise HTTPException(status_code=403, detail="You are not authorized to perform this action")
+    if current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
     # if current_user.Role != "Admin":
     #     raise HTTPException(status_code=403, detail="You are not authorized to perform this action")
     user = create_new_user(user=user, db=db)
     return user
 
+
 @router.post("/driver", response_model=ShowDriver, status_code=status.HTTP_201_CREATED)
 def create_driver(
     driver: DriverCreate,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
-    if (current_user.Role != "Admin"):
-        raise HTTPException(status_code=403, detail="You are not authorized to perform this action")
+    if current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
     driver = create_new_driver(driver=driver, db=db)
     return driver
 
+
 @router.get("/", response_model=List[ShowUser], status_code=status.HTTP_200_OK)
 def get_all_users(db: Session = Depends(get_db), role: str = None):
     if role is None:
@@ -45,6 +58,7 @@ def get_all_users(db: Session = Depends(get_db), role: str = None):
     users = list_users(db=db, role=role)
     return users
 
+
 @router.put("/{user_id}", response_model=ShowUser, status_code=status.HTTP_202_ACCEPTED)
 def update_user(
     user_id: int,
@@ -53,7 +67,9 @@ def update_user(
     current_user: User = Depends(get_current_user),
 ):
     if current_user.Role != "Admin":
-        raise HTTPException(status_code=403, detail="You are not authorized to perform this action")
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
     user = replace_user_data(user_id=user_id, user=user, db=db)
     return user
 
@@ -75,11 +91,30 @@ def get_user(user_id: int, db: Session = Depends(get_db)):
     return user
 
 
-@router.get("/driver/{driver_id}", response_model=ShowDriver, status_code=status.HTTP_200_OK)
+@router.get(
+    "/driver/{driver_id}", response_model=ShowDriver, status_code=status.HTTP_200_OK
+)
 def get_driver(driver_id: int, db: Session = Depends(get_db)):
-    driver = get_user_by_id(user_id=driver_id, role = "Driver", db=db)
-    res = driver.__dict__
-    res["AssignedVehicle"] = driver.vehicle
+    driver = get_user_by_id(user_id=driver_id, role="Driver", db=db)
     if not driver:
         raise HTTPException(status_code=404, detail="Driver not found")
-    return driver
+    res = driver.__dict__
+    res["AssignedVehicle"] = driver.vehicle
+
+    return driver
+
+
+@router.delete("/{user_id}", status_code=status.HTTP_200_OK)
+def delete_user(
+    user_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    result = delete_user_data(id=user_id, db=db)
+    if result == "userNotFound":
+        raise HTTPException(status_code=404, detail="User not found")
+    return result

app/apis/v1/route_vehicle.py

@@ -87,6 +87,24 @@ async def assign_driver(
     return vehicle
 
 
+@router.patch("/{vehicle_id}/driver", status_code=status.HTTP_200_OK)
+async def unassign_driver(
+    vehicle_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if current_user.Role != "Admin":
+        raise HTTPException(
+            status_code=403, detail="You are not authorized to perform this action"
+        )
+    vehicle = assign_vehicle_driver(vehicle_id=vehicle_id, driver_id=None, db=db)
+    if vehicle == "novehicle":
+        raise HTTPException(
+            status_code=404, detail=f"Vehicle with id {vehicle_id} not found"
+        )
+    return {"msg": "Driver unassigned successfully"}
+
+
 @router.get("/", response_model=List[OutputVehicle], status_code=status.HTTP_200_OK)
 async def get_all_vehicles(db: Session = Depends(get_db)):
     vehicles = list_vehicles(db=db)

app/db/base.py

@@ -6,3 +6,4 @@ from db.models.carpart import CarPart
 from db.models.maintenancejob import MaintenanceJob
 from db.models.drivetask import DriveTask
 from db.models.auction import Auction
+from db.models.fuelingtask import FuelingTask

app/db/models/auction.py

@@ -1,11 +1,11 @@
-from sqlalchemy import Column, Integer, String, ForeignKey, DateTime 
+from sqlalchemy import Column, Integer, String, ForeignKey, DateTime
 from sqlalchemy.orm import relationship
 from db.base import Base
 
 
 class Auction(Base):
     Id = Column(Integer, primary_key=True, index=True)
-    
+
     initialPrice = Column(Integer, nullable=False)
     minimalBet = Column(Integer, nullable=False)
     carID = Column(Integer, ForeignKey("vehicle.Id"), nullable=False)
@@ -14,4 +14,3 @@ class Auction(Base):
     CreatedBy = relationship("User", back_populates="auctions")
     dateStart = Column(DateTime, nullable=False)
     dateEnd = Column(DateTime, nullable=False)
-    

app/db/models/drivetask.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, String, ForeignKey, ARRAY
+from sqlalchemy import Column, Integer, String, ForeignKey, ARRAY, DateTime
 from db.base import Base
 from sqlalchemy.orm import relationship
 
@@ -11,3 +11,4 @@ class DriveTask(Base):
     Status = Column(String, nullable=False)
     StartLocation = Column(ARRAY(String), nullable=False)
     EndLocation = Column(ARRAY(String), nullable=False)
+    StartDateTime = Column(DateTime, nullable=False)

app/db/models/fuelingtask.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, DateTime
+from sqlalchemy.orm import relationship
+from db.base import Base
+
+
+class FuelingTask(Base):
+    Id = Column(Integer, primary_key=True, index=True)
+    VehicleId = Column(ForeignKey("vehicle.Id"), nullable=False)
+    DriverId = Column(ForeignKey("user.Id"), nullable=False)
+    CreatedById = Column(ForeignKey("user.Id"), nullable=False)
+    Date = Column(DateTime, nullable=False)
+    Description = Column(String, nullable=True)
+    Cost = Column(Integer, nullable=False)
+    FuelRefilled = Column(Integer, nullable=False)
+    GasStationName = Column(String, nullable=False)
+    ImageBefore = Column(String, nullable=False)
+    ImageAfter = Column(String, nullable=False)
+    CreatedBy = relationship(
+        "User", back_populates="fuelingTasks", foreign_keys="FuelingTask.CreatedById"
+    )

app/db/models/user.py

@@ -27,5 +27,5 @@ class User(Base):
     #MaintenancePerson-specific relationships
     maintenanceJobs = relationship("MaintenanceJob", back_populates="CreatedBy")
     #FuelingPerson-specific relationships
-    #fuelingJobs = relationship("FuelingJob", back_populates="CreatedBy")
+    fuelingTasks = relationship("FuelingTask", back_populates="CreatedBy", foreign_keys="FuelingTask.CreatedById")
 

app/db/repository/auction.py

@@ -0,0 +1,61 @@
+from sqlalchemy.orm import Session
+from schemas.auction import CreateAuction
+from db.models.auction import Auction
+from db.repository.user import get_user_by_id
+from db.repository.vehicle import get_vehicle_by_id
+
+
+def get_all_auctions(db: Session):
+    auctions = db.query(Auction).all()
+    for auction in auctions:
+        auction.car = auction.vehicle
+    return auctions
+
+
+def get_auction_by_id(id: int, db: Session):
+    auction = db.query(Auction).filter(Auction.Id == id).first()
+    auction.car = auction.vehicle
+    return auction
+
+
+def create_new_auction(auction: CreateAuction, createId: int, db: Session):
+    vehicle = get_vehicle_by_id(auction.carId, db)
+    if vehicle is None:
+        return "novehicle"
+    auction_object = Auction(
+        initialPrice=auction.initialPrice,
+        minimalBet=auction.minimalBet,
+        carID=auction.carId,
+        creatorId=createId,
+        dateStart=auction.dateStart,
+        dateEnd=auction.dateEnd,
+    )
+    db.add(auction_object)
+    db.commit()
+    db.refresh(auction_object)
+    return auction_object
+
+
+def delete_auction_by_id(id: int, db: Session):
+    auction = db.query(Auction).filter(Auction.Id == id).first()
+    if not auction:
+        return "noauction"
+    db.delete(auction)
+    db.commit()
+    return auction
+
+
+def edit_auction_by_id(id: int, auction: CreateAuction, db: Session):
+    auction_db = db.query(Auction).filter(Auction.Id == id)
+    auction_object = auction_db.first()
+    if not auction_object:
+        return "noauction"
+    auction_object.initialPrice = auction.initialPrice
+    auction_object.minimalBet = auction.minimalBet
+    auction_object.carID = auction.carId
+    auction_object.dateStart = auction.dateStart
+    auction_object.dateEnd = auction.dateEnd
+    db.add(auction_object)
+    db.commit()
+    db.refresh(auction_object)
+    return auction_object

app/db/repository/drivetask.py

@@ -6,7 +6,7 @@ from db.repository.user import get_user_by_id
 
 
 def create_new_task(task: CreateTask, db: Session):
-    driver = get_user_by_id(task.DriverId, db)
+    driver = get_user_by_id(task.DriverId, "Driver", db)
     if driver is None:
         return "notdriver"
     elif driver.Role != "Driver":
@@ -28,6 +28,12 @@ def change_task_status(task_id: int, status: str, db: Session):
     task = db.query(DriveTask).filter(DriveTask.Id == task_id).first()
     if not task:
         return "notaskfound"
+    if status == "In Progress":
+        # see if there are any other tasks in progress by this driver, if yes, cancel
+        tasks = db.query(DriveTask).filter(DriveTask.DriverId == task.DriverId).all()
+        for task in tasks:
+            if task.Status == "In Progress":
+                return "driverhasothertask"
     task.Status = status
     db.commit()
     db.refresh(task)
@@ -38,14 +44,14 @@ def get_task_driver(task_id: int, db: Session):
     task = db.query(DriveTask).filter(DriveTask.Id == task_id).first()
     if not task:
         return "notaskfound"
-    driver = get_user_by_id(task.DriverId, db)
+    driver = get_user_by_id(task.DriverId, "Any", db)
     if not driver:
         return "notdriver"
     return driver
 
 
 def get_tasks_by_driver(driver_id: int, db: Session):
-    driver = get_user_by_id(driver_id, db)
+    driver = get_user_by_id(driver_id, "Any", db)
     if not driver:
         return "notdriver"
     if driver.Role != "Driver":
@@ -56,15 +62,24 @@ def get_tasks_by_driver(driver_id: int, db: Session):
 
 def get_task_by_id(task_id: int, db: Session):
     task = db.query(DriveTask).filter(DriveTask.Id == task_id).first()
+    task.Driver = task.CreatedBy.__dict__
+    task.Driver["AssignedVehicle"] = task.CreatedBy.vehicle
     if not task:
         return "notaskfound"
     return task
 
 
-def get_all_tasks(db: Session):
-    tasks = db.query(DriveTask).all()
+def get_all_tasks(status: str, db: Session):
+    if status != "Any":
+        tasks = db.query(DriveTask).filter(DriveTask.Status == status).all()
+    else:
+        tasks = db.query(DriveTask).all()
+    for task in tasks:
+        task.Driver = task.CreatedBy.__dict__
+        task.Driver["AssignedVehicle"] = task.CreatedBy.vehicle
     return tasks
 
+
 def edit_task(task_id: int, task: CreateTask, db: Session):
     tasks = db.query(DriveTask).filter(DriveTask.Id == task_id).first()
     if not tasks:
@@ -75,3 +90,22 @@ def edit_task(task_id: int, task: CreateTask, db: Session):
     db.commit()
     db.refresh(tasks)
     return tasks
+
+
+def get_active_route_by_driver(driver_id: int, db: Session):
+    driver = get_user_by_id(driver_id, "Driver", db)
+    if not driver:
+        return "notdriver"
+    tasks = db.query(DriveTask).filter(DriveTask.DriverId == driver_id).all()
+    for task in tasks:
+        if task.Status == "In Progress":
+            return task
+    return "noroute"
+
+
+def get_my_routes(driver_id: int, db: Session):
+    driver = get_user_by_id(driver_id, "Driver", db)
+    if not driver:
+        return "notdriver"
+    tasks = db.query(DriveTask).filter(DriveTask.DriverId == driver_id).all()
+    return tasks

app/db/repository/fuelingtask.py

@@ -0,0 +1,54 @@
+from sqlalchemy.orm import Session
+
+
+from schemas.fuelingtask import CreateFuelingTask
+from db.models.fuelingtask import FuelingTask
+from db.repository.user import get_car_driver, get_user_by_id
+from db.repository.vehicle import get_vehicle_by_id
+
+def create_fueling_task(fueling_task: CreateFuelingTask, current_user: int, db: Session):
+    
+    if not get_vehicle_by_id(fueling_task.VehicleId, db=db):
+        return "novehicle"
+    
+    driver = get_car_driver(fueling_task.VehicleId, db=db)
+    
+    if not driver:
+        return "nodriver"
+
+    fueling_task_object = FuelingTask(
+        DriverId=driver.Id,
+        VehicleId=fueling_task.VehicleId,
+        CreatedById=current_user,
+        Description=fueling_task.Description,
+        Date=fueling_task.Date,
+        Cost=fueling_task.Cost,
+        FuelRefilled=fueling_task.FuelRefilled,
+        GasStationName=fueling_task.GasStationName,
+        ImageBefore=fueling_task.ImageBefore,
+        ImageAfter=fueling_task.ImageAfter,
+    )
+    db.add(fueling_task_object)
+    db.commit()
+    db.refresh(fueling_task_object)
+    return fueling_task_object
+
+
+def delete_fueling_task(fueling_task_id: int, db: Session):
+    fueling_task = db.query(FuelingTask).filter(FuelingTask.Id == fueling_task_id).first()
+    if fueling_task:
+        db.delete(fueling_task)
+        db.commit()
+        return True
+    return False
+
+def get_fueling_task_by_id(fuel_task_id: int, db: Session):
+    fuel_task = db.query(FuelingTask).filter(FuelingTask.Id == fuel_task_id).first()
+    if not fuel_task:
+        return "notfound"
+    res = fuel_task.__dict__ 
+    driver = get_user_by_id(fuel_task.DriverId, role="Driver", db=db)
+    driver_obj = driver.__dict__
+    res["Driver"] = driver_obj
+    res["Driver"]["AssignedVehicle"] = driver.vehicle
+    return fuel_task

app/db/repository/maintenancejob.py

@@ -39,7 +39,7 @@ def create_car_part(car_part: CreateCarPart, db: Session):
 def calculate_total_cost(car_parts: CarPart):
     total_cost = 0
     for part in car_parts:
-        total_cost += part["Cost"]
+        total_cost += part.Cost
     return total_cost
 
 
@@ -48,8 +48,9 @@ def get_all_maintenance_jobs(db: Session):
     result = []
     for job in maintenancejobs:
         job_dict = job.__dict__
-        job_dict["CarParts"] = [part.__dict__ for part in job.CarParts]
+        job_dict["CarPartsList"] = [part.__dict__ for part in job.CarParts]
         job_dict["TotalCost"] = calculate_total_cost(job.CarParts)
+        job_dict["AssignedTo"] = job.CreatedBy.__dict__
         result.append(job_dict)
     return maintenancejobs
 
@@ -58,9 +59,15 @@ def get_maintenance_job(maintenancejob_id: int, db: Session):
     maintenancejob = (
         db.query(MaintenanceJob).filter(MaintenanceJob.Id == maintenancejob_id).first()
     )
-    result = maintenancejob.__dict__
-    result["CarParts"] = [part.__dict__ for part in maintenancejob.CarParts]
-    return result
+    maintenancejob.CarPartsList = [part.__dict__ for part in maintenancejob.CarParts]
+    # print(type(result.CarPartsList))
+    maintenancejob.TotalCost = calculate_total_cost(maintenancejob.CarParts)
+    # print(result.TotalCost)
+    maintenancejob.AssignedTo = maintenancejob.CreatedBy.__dict__
+    print(maintenancejob.AssignedTo)
+    print("DB Access complete")
+    return maintenancejob
+
 
 def change_maintenance_status(maintenancejob_id: int, status: str, db: Session):
     maintenancejob = (
@@ -71,4 +78,4 @@ def change_maintenance_status(maintenancejob_id: int, status: str, db: Session):
     maintenancejob.Status = status
     db.commit()
     db.refresh(maintenancejob)
-    return maintenancejob
+    return maintenancejob

app/db/repository/user.py

@@ -4,6 +4,7 @@ from sqlalchemy.orm import Session
 from schemas.user import UserCreate, DriverCreate
 from db.models.user import User
 from core.hashing import Hasher
+from db.models.drivetask import DriveTask
 
 
 def create_new_user(user: UserCreate, db: Session):
@@ -22,6 +23,8 @@ def create_new_user(user: UserCreate, db: Session):
     db.commit()
     db.refresh(user_object)
     return user_object
+
+
 def create_new_driver(driver: DriverCreate, db: Session):
     driver_object = User(
         Email=driver.Email,
@@ -33,16 +36,19 @@ def create_new_driver(driver: DriverCreate, db: Session):
         ContactNumber=driver.ContactNumber,
         Role="Driver",
         HashedPassword=Hasher.get_password_hash(driver.Password),
-        DrivingLicenseNumber=driver.DrivingLicenseNumber
+        DrivingLicenseNumber=driver.DrivingLicenseNumber,
     )
     db.add(driver_object)
     db.commit()
     db.refresh(driver_object)
     return driver_object
 
+
 def get_user_by_id(user_id: int, role: str, db: Session):
     user = db.query(User).filter(User.Id == user_id).first()
-    if user.Role != role:
+    if not user:
+        return False
+    if user.Role != role and role != "Any":
         return False
     return user
 
@@ -77,6 +83,7 @@ def list_users(db: Session, role: str = "Any"):
     users = db.query(User).filter((User.Role == role) | (role == "Any")).all()
     return users
 
+
 def replace_user_data(user_id: int, user_data: UserCreate, db: Session):
     user = db.query(User).filter(User.Id == user_id).first()
     if not user:
@@ -92,4 +99,16 @@ def replace_user_data(user_id: int, user_data: UserCreate, db: Session):
     user.HashedPassword = Hasher.get_password_hash(user_data.Password)
     db.commit()
     db.refresh(user)
-    return user
+    return user
+
+
+def delete_user_data(id: int, db: Session):
+    user = db.query(User).filter(User.Id == id).first()
+    if not user:
+        return "userNotFound"
+    drivetasks = db.query(DriveTask).filter(DriveTask.DriverId == id).all()
+    for task in drivetasks:  # delete all tasks assigned to this user
+        db.delete(task)
+    db.delete(user)
+    db.commit()
+    return "userDeleted"

app/db/repository/vehicle.py

@@ -7,10 +7,7 @@ from db.repository.user import get_car_driver
 
 def create_new_vehicle(vehicle: CreateVehicle, db: Session):
     vehicle_object = Vehicle(
-        **vehicle.model_dump(),
-        Fuel=0,
-        Status="Inactive",
-        CurrentLocation=[]
+        **vehicle.model_dump(), Fuel=0, Status="Inactive", CurrentLocation=[]
     )
     db.add(vehicle_object)
     db.commit()
@@ -32,16 +29,30 @@ def update_vehicle_geoloc(vehicle_id: int, location: VehicleLocation, db: Sessio
 
 
 def assign_vehicle_driver(vehicle_id: int, driver_id: int, db: Session):
-    driver = (
-        db.query(User).filter((User.Id == driver_id) & (User.Role == "Driver")).first()
-    )
-    print(driver)
-    vehicle = db.query(Vehicle).filter(Vehicle.Id == vehicle_id).first()
-    if not vehicle:
-        return "novehicle"
-    if not driver:
-        return "nodriver"
-    driver.AssignedVehicle = vehicle_id
+    if driver_id != None:
+        driver = (
+            db.query(User)
+            .filter((User.Id == driver_id) & (User.Role == "Driver"))
+            .first()
+        )
+        print(driver)
+        vehicle = db.query(Vehicle).filter(Vehicle.Id == vehicle_id).first()
+        if not vehicle:
+            return "novehicle"
+        if not driver:
+            return "nodriver"
+        driver.AssignedVehicle = vehicle_id
+    else:
+        vehicle = db.query(Vehicle).filter(Vehicle.Id == vehicle_id).first()
+        if not vehicle:
+            return "novehicle"
+        if vehicle.Status == "Active":
+            return "alreadyassigned"
+        driver = get_car_driver(vehicle_id, db)
+        if driver:
+            driver.AssignedVehicle = None
+        else:
+            return "nodriver"
     db.add(driver)
     db.commit()
     return vehicle
@@ -53,7 +64,7 @@ def list_vehicles(db: Session):
     for vehicle in vehicles:
         driver = get_car_driver(vehicle.Id, db)
         if driver:
-            vehicle.AssignedDriver = driver.Id
+            vehicle.AssignedDriver = driver.__dict__
         else:
             vehicle.AssignedDriver = None
     return vehicles
@@ -65,7 +76,7 @@ def get_vehicle_by_id(vehicle_id: int, db: Session):
         return None
     driver = get_car_driver(vehicle.Id, db)
     if driver:
-        vehicle.AssignedDriver = driver.Id
+        vehicle.AssignedDriver = driver.__dict__
     else:
         vehicle.AssignedDriver = None
     return vehicle

app/python

@@ -0,0 +1 @@
+/usr/local/bin/python3.10/usr/local/bin/python

app/schemas/auction.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+from schemas.vehicle import OutputVehicle
+
+
+class CreateAuction(BaseModel):
+    initialPrice: int = Field(...)
+    minimalBet: int = Field(...)
+    carId: int = Field(...)
+    dateStart: datetime
+    dateEnd: datetime
+
+
+class ShowAuction(BaseModel):
+    Id: int
+    initialPrice: int
+    minimalBet: int
+    car: OutputVehicle
+    dateStart: datetime
+    dateEnd: datetime
+
+    class Config:
+        orm_mode = True

app/schemas/carpart.py

@@ -8,3 +8,12 @@ class CreateCarPart(BaseModel):
     Condition: str = Field(...)
     ImageURL: str = Field(...)
     Cost: int = Field(...)
+
+
+class ShowCarPart(BaseModel):
+    ParentId: int = Field(...)
+    Name: str = Field(...)
+    Number: str = Field(...)
+    Condition: str = Field(...)
+    ImageURL: str = Field(...)
+    Cost: int = Field(...)

app/schemas/drivetask.py

@@ -1,4 +1,7 @@
 from pydantic import BaseModel, Field
+from datetime import datetime
+from schemas.user import ShowDriver
+from typing import Optional
 
 
 class CreateTask(BaseModel):
@@ -10,11 +13,12 @@ class CreateTask(BaseModel):
 
 class ShowTask(BaseModel):
     Id: int
-    DriverId: int
+    Driver: Optional[ShowDriver]
     Description: str
     Status: str
     StartLocation: tuple[str, str]
     EndLocation: tuple[str, str]
+    StartDateTime: Optional[datetime]
 
     class Config:
         orm_mode = True

app/schemas/fuelingtask.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+from schemas.user import ShowDriver
+
+class CreateFuelingTask(BaseModel):
+    VehicleId: int = Field(...)
+    Description: str = Field(...)
+    Date: datetime = Field(...)
+    Cost: int = Field(...)
+    FuelRefilled: int = Field(...)
+    GasStationName: str = Field(...)
+    ImageBefore: str = Field(...)
+    ImageAfter: str = Field(...)
+
+class OutputFuelingTask(BaseModel):
+    VehicleId: int = Field(...)
+    Description: str = Field(...)
+    Date: datetime = Field(...)
+    Cost: int = Field(...)
+    FuelRefilled: int = Field(...)
+    GasStationName: str = Field(...)
+    ImageBefore: str = Field(...)
+    ImageAfter: str = Field(...)
+    Driver: ShowDriver | None

app/schemas/maintenancejob.py

@@ -1,7 +1,19 @@
 from pydantic import BaseModel, Field
 from datetime import datetime
+from typing import List, Optional
+from schemas.carpart import ShowCarPart
+from schemas.user import ShowUser
 
 
 class CreateMaintenanceJob(BaseModel):
     Description: str = Field(...)
     Date: datetime = Field(...)
+
+
+class OutputMaintenanceJob(BaseModel):
+    Id: int
+    Description: str
+    Date: datetime
+    CarPartsList: Optional[List[ShowCarPart]]
+    TotalCost: int
+    AssignedTo: ShowUser

app/schemas/user.py

@@ -1,7 +1,7 @@
 # Purpose: User schema for pydantic (validation, inside-api usage)
 
 from pydantic import BaseModel, EmailStr, Field
-from schemas.vehicle import OutputVehicle
+
 
 class UserCreate(BaseModel):
     Email: EmailStr
@@ -14,9 +14,10 @@ class UserCreate(BaseModel):
     Address: str = Field(...)
     Email: EmailStr = Field(...)
 
+
 class DriverCreate(UserCreate):
     DrivingLicenseNumber: str = Field(...)
-    
+
 
 class ShowUser(BaseModel):
     Id: int
@@ -29,11 +30,18 @@ class ShowUser(BaseModel):
     Email: EmailStr
     Role: str
 
-
     class Config:
         orm_mode = True
         validate_assignment = True
 
+
+class ShowDriverNoVehicle(ShowUser):
+    DrivingLicenseNumber: str | None
+
+
+from schemas.vehicle import OutputVehicle
+
+
 class ShowDriver(ShowUser):
     DrivingLicenseNumber: str | None
-    AssignedVehicle: OutputVehicle |  None
+    AssignedVehicle: OutputVehicle | None

app/schemas/vehicle.py

@@ -1,5 +1,6 @@
 from typing import Optional
 from pydantic import BaseModel
+from schemas.user import ShowDriverNoVehicle
 
 
 class CreateVehicle(BaseModel):
@@ -21,7 +22,7 @@ class OutputVehicle(BaseModel):
     Fuel: Optional[int] = 0
     Type: str
     DriverHistory: Optional[list[int]] = None
-    AssignedDriver: Optional[int] = None
+    AssignedDriver: Optional[ShowDriverNoVehicle] = None
     Capacity: int
     Status: str