feat(reference): add delete operations for various reference data entities

app/controllers/reference.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, Query, status, HTTPException
+from fastapi import APIRouter, Depends, Query, status, HTTPException, Response
 from sqlalchemy.orm import Session
 from app.db.session import get_db
 from app.services.reference_service import ReferenceDataService
@@ -697,4 +697,186 @@ def update_priority(
     result = service.update_priority(priority_id, data)
     if not result:
         raise HTTPException(status_code=404, detail="Priority not found")
-    return result
+    return result
+
+@router.delete("/states/{state_id}", status_code=204)
+def delete_state(
+    state_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a state"""
+    service = ReferenceDataService(db)
+    success = service.delete_state(state_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="State not found")
+    return Response(status_code=204)
+
+@router.delete("/countries/{country_id}", status_code=204)
+def delete_country(
+    country_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a country"""
+    service = ReferenceDataService(db)
+    success = service.delete_country(country_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Country not found")
+    return Response(status_code=204)
+
+@router.delete("/company-types/{company_type_id}", status_code=204)
+def delete_company_type(
+    company_type_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a company type"""
+    service = ReferenceDataService(db)
+    success = service.delete_company_type(company_type_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Company type not found")
+    return Response(status_code=204)
+
+@router.delete("/lead-sources/{lead_generated_from_id}", status_code=204)
+def delete_lead_source(
+    lead_generated_from_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a lead source"""
+    service = ReferenceDataService(db)
+    success = service.delete_lead_source(lead_generated_from_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Lead source not found")
+    return Response(status_code=204)
+
+@router.delete("/payment-terms/{payment_term_id}", status_code=204)
+def delete_payment_term(
+    payment_term_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a payment term"""
+    service = ReferenceDataService(db)
+    success = service.delete_payment_term(payment_term_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Payment term not found")
+    return Response(status_code=204)
+
+@router.delete("/purchase-prices/{purchase_price_id}", status_code=204)
+def delete_purchase_price(
+    purchase_price_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a purchase price"""
+    service = ReferenceDataService(db)
+    success = service.delete_purchase_price(purchase_price_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Purchase price not found")
+    return Response(status_code=204)
+
+@router.delete("/rental-prices/{rental_price_id}", status_code=204)
+def delete_rental_price(
+    rental_price_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a rental price"""
+    service = ReferenceDataService(db)
+    success = service.delete_rental_price(rental_price_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Rental price not found")
+    return Response(status_code=204)
+
+@router.delete("/barrier-sizes/{barrier_size_id}", status_code=204)
+def delete_barrier_size(
+    barrier_size_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a barrier size"""
+    service = ReferenceDataService(db)
+    success = service.delete_barrier_size(barrier_size_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Barrier size not found")
+    return Response(status_code=204)
+
+@router.delete("/product-applications/{application_id}", status_code=204)
+def delete_product_application(
+    application_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a product application"""
+    service = ReferenceDataService(db)
+    success = service.delete_product_application(application_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Product application not found")
+    return Response(status_code=204)
+
+@router.delete("/fobs/{fob_id}", status_code=204)
+def delete_fob(
+    fob_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a FOB"""
+    service = ReferenceDataService(db)
+    success = service.delete_fob(fob_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="FOB not found")
+    return Response(status_code=204)
+
+@router.delete("/est-ship-dates/{est_ship_date_id}", status_code=204)
+def delete_est_ship_date(
+    est_ship_date_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete an estimated ship date"""
+    service = ReferenceDataService(db)
+    success = service.delete_est_ship_date(est_ship_date_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Estimated ship date not found")
+    return Response(status_code=204)
+
+@router.delete("/est-freights/{est_freight_id}", status_code=204)
+def delete_est_freight(
+    est_freight_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete an estimated freight"""
+    service = ReferenceDataService(db)
+    success = service.delete_est_freight(est_freight_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Estimated freight not found")
+    return Response(status_code=204)
+
+@router.delete("/status-info/{status_info_id}", status_code=204)
+def delete_status_info(
+    status_info_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a status info"""
+    service = ReferenceDataService(db)
+    success = service.delete_status_info(status_info_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Status info not found")
+    return Response(status_code=204)
+
+@router.delete("/priorities/{priority_id}", status_code=204)
+def delete_priority(
+    priority_id: int,
+    db: Session = Depends(get_db),
+    current_user: CurrentUser = Depends(get_current_user_optional)
+):
+    """Delete a priority"""
+    service = ReferenceDataService(db)
+    success = service.delete_priority(priority_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Priority not found")
+    return Response(status_code=204)

app/db/repositories/reference_repo.py

@@ -748,6 +748,132 @@ class ReferenceDataRepository:
         self.db.refresh(priority)
         return {column.name: getattr(priority, column.name) for column in priority.__table__.columns}
 
+    def delete_state(self, state_id: int) -> bool:
+        """Delete a state"""
+        state = self.db.query(State).filter(State.state_id == state_id).first()
+        if not state:
+            return False
+        self.db.delete(state)
+        self.db.commit()
+        return True
+
+    def delete_country(self, country_id: int) -> bool:
+        """Delete a country"""
+        country = self.db.query(Country).filter(Country.country_id == country_id).first()
+        if not country:
+            return False
+        self.db.delete(country)
+        self.db.commit()
+        return True
+
+    def delete_company_type(self, company_type_id: int) -> bool:
+        """Delete a company type"""
+        company_type = self.db.query(CompanyType).filter(CompanyType.company_type_id == company_type_id).first()
+        if not company_type:
+            return False
+        self.db.delete(company_type)
+        self.db.commit()
+        return True
+
+    def delete_lead_source(self, lead_generated_from_id: int) -> bool:
+        """Delete a lead source"""
+        lead_source = self.db.query(LeadGeneratedFrom).filter(LeadGeneratedFrom.lead_generated_from_id == lead_generated_from_id).first()
+        if not lead_source:
+            return False
+        self.db.delete(lead_source)
+        self.db.commit()
+        return True
+
+    def delete_payment_term(self, payment_term_id: int) -> bool:
+        """Delete a payment term"""
+        payment_term = self.db.query(PaymentTerm).filter(PaymentTerm.payment_term_id == payment_term_id).first()
+        if not payment_term:
+            return False
+        self.db.delete(payment_term)
+        self.db.commit()
+        return True
+
+    def delete_purchase_price(self, purchase_price_id: int) -> bool:
+        """Delete a purchase price"""
+        purchase_price = self.db.query(PurchasePrice).filter(PurchasePrice.purchase_price_id == purchase_price_id).first()
+        if not purchase_price:
+            return False
+        self.db.delete(purchase_price)
+        self.db.commit()
+        return True
+
+    def delete_rental_price(self, rental_price_id: int) -> bool:
+        """Delete a rental price"""
+        rental_price = self.db.query(RentalPrice).filter(RentalPrice.rental_price_id == rental_price_id).first()
+        if not rental_price:
+            return False
+        self.db.delete(rental_price)
+        self.db.commit()
+        return True
+
+    def delete_barrier_size(self, barrier_size_id: int) -> bool:
+        """Delete a barrier size"""
+        barrier_size = self.db.query(BarrierSize).filter(BarrierSize.barrier_size_id == barrier_size_id).first()
+        if not barrier_size:
+            return False
+        self.db.delete(barrier_size)
+        self.db.commit()
+        return True
+
+    def delete_product_application(self, application_id: int) -> bool:
+        """Delete a product application"""
+        product_application = self.db.query(ProductApplication).filter(ProductApplication.application_id == application_id).first()
+        if not product_application:
+            return False
+        self.db.delete(product_application)
+        self.db.commit()
+        return True
+
+    def delete_fob(self, fob_id: int) -> bool:
+        """Delete a FOB"""
+        fob = self.db.query(FOB).filter(FOB.fob_id == fob_id).first()
+        if not fob:
+            return False
+        self.db.delete(fob)
+        self.db.commit()
+        return True
+
+    def delete_est_ship_date(self, est_ship_date_id: int) -> bool:
+        """Delete an estimated ship date"""
+        est_ship_date = self.db.query(EstShipDate).filter(EstShipDate.est_ship_date_id == est_ship_date_id).first()
+        if not est_ship_date:
+            return False
+        self.db.delete(est_ship_date)
+        self.db.commit()
+        return True
+
+    def delete_est_freight(self, est_freight_id: int) -> bool:
+        """Delete an estimated freight"""
+        est_freight = self.db.query(EstFreight).filter(EstFreight.est_freight_id == est_freight_id).first()
+        if not est_freight:
+            return False
+        self.db.delete(est_freight)
+        self.db.commit()
+        return True
+
+    def delete_status_info(self, status_info_id: int) -> bool:
+        """Delete a status info"""
+        status_info = self.db.query(StatusInfo).filter(StatusInfo.status_info_id == status_info_id).first()
+        if not status_info:
+            return False
+        self.db.delete(status_info)
+        self.db.commit()
+        return True
+
+    def delete_priority(self, priority_id: int) -> bool:
+        """Delete a priority"""
+        priority = self.db.query(Priority).filter(Priority.priority_id == priority_id).first()
+        if not priority:
+            return False
+        self.db.delete(priority)
+        self.db.commit()
+        return True
+
     def clear_cache(self):
         """Clear the internal cache to force fresh data on next request"""
         self._cache.clear()

app/services/reference_service.py

@@ -288,6 +288,62 @@ class ReferenceDataService:
             return PriorityOut(**result)
         return None
 
+    def delete_state(self, state_id: int) -> bool:
+        """Delete a state"""
+        return self.repo.delete_state(state_id)
+
+    def delete_country(self, country_id: int) -> bool:
+        """Delete a country"""
+        return self.repo.delete_country(country_id)
+
+    def delete_company_type(self, company_type_id: int) -> bool:
+        """Delete a company type"""
+        return self.repo.delete_company_type(company_type_id)
+
+    def delete_lead_source(self, lead_generated_from_id: int) -> bool:
+        """Delete a lead source"""
+        return self.repo.delete_lead_source(lead_generated_from_id)
+
+    def delete_payment_term(self, payment_term_id: int) -> bool:
+        """Delete a payment term"""
+        return self.repo.delete_payment_term(payment_term_id)
+
+    def delete_purchase_price(self, purchase_price_id: int) -> bool:
+        """Delete a purchase price"""
+        return self.repo.delete_purchase_price(purchase_price_id)
+
+    def delete_rental_price(self, rental_price_id: int) -> bool:
+        """Delete a rental price"""
+        return self.repo.delete_rental_price(rental_price_id)
+
+    def delete_barrier_size(self, barrier_size_id: int) -> bool:
+        """Delete a barrier size"""
+        return self.repo.delete_barrier_size(barrier_size_id)
+
+    def delete_product_application(self, application_id: int) -> bool:
+        """Delete a product application"""
+        return self.repo.delete_product_application(application_id)
+
+    def delete_fob(self, fob_id: int) -> bool:
+        """Delete a FOB"""
+        return self.repo.delete_fob(fob_id)
+
+    def delete_est_ship_date(self, est_ship_date_id: int) -> bool:
+        """Delete an estimated ship date"""
+        return self.repo.delete_est_ship_date(est_ship_date_id)
+
+    def delete_est_freight(self, est_freight_id: int) -> bool:
+        """Delete an estimated freight"""
+        return self.repo.delete_est_freight(est_freight_id)
+
+    def delete_status_info(self, status_info_id: int) -> bool:
+        """Delete a status info"""
+        return self.repo.delete_status_info(status_info_id)
+
+    def delete_priority(self, priority_id: int) -> bool:
+        """Delete a priority"""
+        return self.repo.delete_priority(priority_id)
+
     def get_fobs(self, active_only: bool = True):
         """Get all FOBs as Pydantic models"""
         fobs_data = self.repo.get_fobs(active_only)