Update backend with high-quality catalog and fixes

app/api/admin.py

@@ -6,8 +6,9 @@ from datetime import datetime, timedelta
 from app.db.base import get_db
 from app.models.user import User, UserRole
 from app.models.order import Order, OrderStatus, PaymentDetail
-from app.models.product import Product
+from app.models.product import Product, ProductImage, ProductAudit
 from app.api.auth import get_current_user
+import json
 
 router = APIRouter(prefix="/admin", tags=["Administration"])
 
@@ -300,3 +301,196 @@ def get_order_payment_details(
         "statusCode": 200
     }
 
+@router.get("/products/deleted")
+def get_deleted_products(
+    current_user_id: int = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """List all soft-deleted products pending administrative review."""
+    check_admin(current_user_id, db)
+    
+    deleted_products = db.query(Product).filter(Product.deleted_at.isnot(None)).all()
+    
+    results = [{
+        "id": p.id,
+        "name_en": p.name_en,
+        "name_ar": p.name_ar,
+        "price": p.price,
+        "deleted_at": p.deleted_at.isoformat() if p.deleted_at else None,
+        "deletion_reason": p.deletion_reason,
+        "quality_score": p.quality_score,
+        "image_url": p.images[0].image_url if p.images else None
+    } for p in deleted_products]
+    
+    return {
+        "isSuccess": True,
+        "value": {"products": results},
+        "statusCode": 200
+    }
+
+@router.post("/products/{product_id}/restore")
+def restore_product(
+    product_id: int,
+    current_user_id: int = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Restore a soft-deleted product and log the action."""
+    admin = check_admin(current_user_id, db)
+    product = db.query(Product).filter(Product.id == product_id).first()
+    
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found")
+        
+    if not product.deleted_at:
+        return {"isSuccess": False, "message": "Product is not deleted", "statusCode": 400}
+        
+    # Log the restore action
+    audit = ProductAudit(
+        product_id=product.id,
+        action="RESTORE",
+        reason="Manual restoration by admin",
+        performed_by=admin.id,
+        created_at=datetime.utcnow()
+    )
+    db.add(audit)
+    
+    product.deleted_at = None
+    product.deletion_reason = None
+    product.deleted_by = None
+    product.is_active = True
+    
+    db.commit()
+    
+    return {
+        "isSuccess": True,
+        "value": {"message": f"Product {product.id} restored successfully"},
+        "statusCode": 200
+    }
+
+@router.delete("/products/{product_id}/final")
+def permanently_delete_product(
+    product_id: int,
+    current_user_id: int = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Permanently delete a product from the database after review."""
+    check_admin(current_user_id, db)
+    product = db.query(Product).filter(Product.id == product_id).first()
+    
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found")
+        
+    db.delete(product)
+    db.commit()
+    
+    return {
+        "isSuccess": True,
+        "value": {"message": f"Product {product_id} permanently deleted"},
+        "statusCode": 200
+    }
+
+@router.get("/products/{product_id}/audit")
+def get_product_audit_logs(
+    product_id: int,
+    current_user_id: int = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Get all audit logs for a specific product."""
+    check_admin(current_user_id, db)
+    
+    logs = db.query(ProductAudit).filter(ProductAudit.product_id == product_id).order_by(ProductAudit.created_at.desc()).all()
+    
+    results = [{
+        "id": l.id,
+        "action": l.action,
+        "reason": l.reason,
+        "created_at": l.created_at.isoformat(),
+        "snapshot": l.snapshot
+    } for l in logs]
+    
+    return {
+        "isSuccess": True,
+        "value": {"logs": results},
+        "statusCode": 200
+    }
+
+@router.post("/products/bulk-restore")
+def bulk_restore_products(
+    product_ids: list[int],
+    current_user_id: int = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Restore multiple soft-deleted products."""
+    admin = check_admin(current_user_id, db)
+    
+    products = db.query(Product).filter(Product.id.in_(product_ids)).all()
+    products_to_restore = [p for p in products if p.deleted_at]
+    
+    for product in products_to_restore:
+        product.deleted_at = None
+        product.deletion_reason = None
+        product.deleted_by = None
+        product.is_active = True
+        
+        audit = ProductAudit(
+            product_id=product.id,
+            action="RESTORE",
+            reason="Bulk restoration by admin",
+            performed_by=admin.id,
+            created_at=datetime.utcnow()
+        )
+        db.add(audit)
+            
+    db.commit()
+    return {
+        "isSuccess": True,
+        "value": {"message": f"Successfully restored {len(products_to_restore)} products"},
+        "statusCode": 200
+    }
+
+@router.post("/products/bulk-hard-delete")
+def bulk_hard_delete_products(
+    product_ids: list[int],
+    current_user_id: int = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Permanently delete multiple products."""
+    check_admin(current_user_id, db)
+    
+    # We can delete them all in one go or loop if we want to log (hard delete has no audit after delete)
+    db.query(Product).filter(Product.id.in_(product_ids)).delete(synchronize_session=False)
+    db.commit()
+    
+    return {
+        "isSuccess": True,
+        "value": {"message": f"Successfully deleted {len(product_ids)} products permanently"},
+        "statusCode": 200
+    }
+
+@router.get("/quality/summary")
+def get_quality_summary(
+    current_user_id: int = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Get a summary of product quality issues."""
+    check_admin(current_user_id, db)
+    
+    total_products = db.query(func.count(Product.id)).scalar()
+    deleted_products = db.query(func.count(Product.id)).filter(Product.deleted_at.isnot(None)).scalar()
+    active_products = db.query(func.count(Product.id)).filter(Product.deleted_at.is_ (None)).scalar()
+    
+    # Average quality score of active products
+    avg_score_val = db.query(func.avg(Product.quality_score)).filter(Product.deleted_at.is_(None)).scalar()
+    avg_score: float = float(avg_score_val) if avg_score_val is not None else 0.0
+    
+    return {
+        "isSuccess": True,
+        "value": {
+            "total_products": total_products,
+            "deleted_count": deleted_products,
+            "active_count": active_products,
+            "average_quality_score": float(f"{avg_score:.2f}")
+        },
+        "statusCode": 200
+    }
+

app/api/products.py

@@ -329,127 +329,4 @@ async def list_deleted_products(
     )
 
 
-from typing import List
-
-
-@router.post("/admin/bulk-delete", response_model=AuthResponse)
-async def bulk_soft_delete_products(
-    product_ids: List[int],
-    reason: str = "Bulk deletion by admin",
-    db: Session = Depends(get_db),
-    user_id: int = Depends(get_current_user),
-):
-    """Soft delete multiple products at once."""
-    deleted_count = 0
-    
-    for product_id in product_ids:
-        product = db.query(Product).filter(Product.id == product_id).first()
-        if product and product.deleted_at is None:
-            product.deleted_at = datetime.now(timezone.utc)
-            product.deleted_by = user_id
-            product.deletion_reason = reason
-            deleted_count += 1
-    
-    db.commit()
-    
-    return AuthResponse(
-        isSuccess=True,
-        value={"deleted_count": deleted_count, "requested_count": len(product_ids)},
-        statusCode=200,
-    )
-
-
-@router.post("/admin/bulk-restore", response_model=AuthResponse)
-async def bulk_restore_products(
-    product_ids: List[int],
-    db: Session = Depends(get_db),
-    user_id: int = Depends(get_current_user),
-):
-    """Restore multiple soft-deleted products."""
-    restored_count = 0
-    
-    for product_id in product_ids:
-        product = db.query(Product).filter(Product.id == product_id).first()
-        if product and product.deleted_at is not None:
-            product.deleted_at = None
-            product.deleted_by = None
-            product.deletion_reason = None
-            restored_count += 1
-    
-    db.commit()
-    
-    return AuthResponse(
-        isSuccess=True,
-        value={"restored_count": restored_count, "requested_count": len(product_ids)},
-        statusCode=200,
-    )
-
-
-@router.post("/admin/bulk-hard-delete", response_model=AuthResponse)
-async def bulk_hard_delete_products(
-    product_ids: List[int],
-    db: Session = Depends(get_db),
-    user_id: int = Depends(get_current_user),
-):
-    """Permanently delete multiple products (hard delete)."""
-    deleted_count = 0
-    
-    for product_id in product_ids:
-        product = db.query(Product).filter(Product.id == product_id).first()
-        if product:
-            db.delete(product)
-            deleted_count += 1
-    
-    db.commit()
-    
-    return AuthResponse(
-        isSuccess=True,
-        value={"deleted_count": deleted_count, "requested_count": len(product_ids)},
-        statusCode=200,
-    )
-
-
-@router.get("/admin/quality/summary", response_model=AuthResponse)
-async def get_quality_summary(
-    db: Session = Depends(get_db),
-    user_id: int = Depends(get_current_user),
-):
-    """Get quality statistics summary."""
-    from sqlalchemy import func
-    
-    try:
-        total_products = db.query(Product).filter(Product.deleted_at == None).count()
-        total_deleted = db.query(Product).filter(Product.deleted_at != None).count()
-        
-        avg_quality = db.query(func.avg(Product.quality_score)).filter(
-            Product.deleted_at == None
-        ).scalar() or 0
-        
-        low_quality = db.query(Product).filter(
-            Product.deleted_at == None,
-            Product.quality_score < 70
-        ).count()
-        
-        no_images = 0
-        products = db.query(Product).filter(Product.deleted_at == None).all()
-        for p in products:
-            if not p.images or len(p.images) == 0:
-                no_images += 1
-        
-        return AuthResponse(
-            isSuccess=True,
-            value={
-                "total_active": total_products,
-                "total_deleted": total_deleted,
-                "avg_quality_score": round(float(avg_quality), 1),
-                "low_quality_products": low_quality,
-                "products_without_images": no_images,
-            },
-            statusCode=200,
-        )
-    except Exception as e:
-        return AuthResponse(
-            isSuccess=False,
-            value={"error": str(e)},
-            statusCode=500,
-        )
+# End of products.py

app/models/product.py

@@ -39,6 +39,22 @@ class Product(Base):
 
     category = relationship("Category", back_populates="products")
     images = relationship("ProductImage", back_populates="product", cascade="all, delete-orphan")
+    audit_logs = relationship("ProductAudit", back_populates="product", cascade="all, delete-orphan")
+
+
+class ProductAudit(Base):
+    __tablename__ = "product_audit_logs"
+    __table_args__ = {'extend_existing': True}
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    product_id = Column(Integer, ForeignKey("products.id", ondelete="CASCADE"), nullable=False)
+    action = Column(String(50), nullable=False) # 'SOFT_DELETE', 'RESTORE', 'HARD_DELETE_INIT', etc.
+    reason = Column(String(500), nullable=True)
+    performed_by = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    snapshot = Column(JSON, nullable=True) # Full data backup before action
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), nullable=False)
+
+    product = relationship("Product", back_populates="audit_logs")
 
 
 class ProductImage(Base):

seed_orchestrator.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+import os
+import sys
+import asyncio
+import logging
+
+# Set up paths - we assume this script runs from the backend directory
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Set logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+async def main():
+    try:
+        from app.db.base import SessionLocal, engine, Base
+        from app.api.seed import seed_database
+        # Models are imported within seed_database and checker
+    except ImportError as e:
+        logger.error(f"Import failed: {e}")
+        return
+
+    # Seed database logic will handle clearing tables if clear=True is passed
+    # Ensure tables exist
+    logger.info("Initializing database tables...")
+    Base.metadata.create_all(bind=engine)
+
+    db = SessionLocal()
+    try:
+        logger.info("Step 1: Seeding database with 1000 models...")
+        result = await seed_database(clear=True, db=db)
+        logger.info(f"Seed Result: {result.value.get('message')} - {result.value.get('inserted_new')} inserted")
+
+        logger.info("Step 2: Running dynamic quality audit on DB...")
+        # Import checker with correct path
+        sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "scripts"))
+        from product_quality_checker import ProductQualityChecker
+        
+        checker = ProductQualityChecker(db)
+        report = checker.run_quality_check()
+        
+        logger.info(f"Audit Complete: {report.total_valid} valid, {report.total_invalid} soft-deleted")
+        
+        # Save final report
+        with open("final_audit_report.json", "w", encoding="utf-8") as f:
+            import json
+            json.dump(report.to_dict(), f, indent=2, ensure_ascii=False)
+            
+    except Exception as e:
+        logger.exception(f"Orchestration failed: {e}")
+    finally:
+        db.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())