fix(migration): support full MediaGroup/MediaAsset cascade delete, disk cleanup, unlinking, and rollback

This commit is contained in:
adithiyan 2026-10-30 13:58:31 +05:30
parent 3d7c2dec0a
commit 211666347e

View file

@ -10,6 +10,7 @@ from typing import List, Dict, Any, Optional
from fastapi import APIRouter, UploadFile, File, Form, Depends, HTTPException, status
from pydantic import BaseModel
from fastapi.responses import Response, StreamingResponse
from sqlalchemy import or_, text
from sqlalchemy.orm import Session
from app.core.database.db_session import get_db, SessionLocal
import openpyxl
@ -489,37 +490,204 @@ def list_migration_jobs(db: Session = Depends(get_db)):
return {"status": "success", "batches": res, "jobs": res}
class BulkDeleteMediaRequest(BaseModel):
ids: list[str]
ids: Optional[list[str]] = None
group_ids: Optional[list[str]] = None
def target_ids(self) -> list[str]:
combined = []
if self.ids:
combined.extend(self.ids)
if self.group_ids:
combined.extend(self.group_ids)
return list(dict.fromkeys(str(x).strip() for x in combined if x and str(x).strip()))
@router.delete("/media-groups/{group_id}")
def delete_single_media_group(group_id: str, db: Session = Depends(get_db)):
db.query(MigrationMediaItem).filter(MigrationMediaItem.id == group_id).delete()
"""
Deletes a MediaGroup along with its MediaAssets, linked variant/product images, and disk files.
Accepts MediaGroup id, media_key, or staging MigrationMediaItem id.
"""
# 1. Search for MediaGroup by id or media_key
mg = db.query(MediaGroup).filter(or_(MediaGroup.id == group_id, MediaGroup.media_key == group_id)).first()
# 2. If not found, check if group_id is a MigrationMediaItem id
if not mg:
item = db.query(MigrationMediaItem).filter(MigrationMediaItem.id == group_id).first()
if item and item.media_key:
mg = db.query(MediaGroup).filter(MediaGroup.media_key == item.media_key).first()
try:
db.delete(item)
except Exception:
pass
if mg:
media_key = mg.media_key
# Delete physical files and collect URLs to unlink
asset_urls = []
for asset in (mg.media_assets or []):
if asset.storage_path and os.path.exists(asset.storage_path):
try:
os.remove(asset.storage_path)
except Exception:
pass
if asset.cdn_url:
asset_urls.append(asset.cdn_url)
# Unlink from VariantImage and ProductImage
if asset_urls:
db.query(VariantImage).filter(VariantImage.image_url.in_(asset_urls)).delete(synchronize_session=False)
db.query(ProductImage).filter(ProductImage.image_url.in_(asset_urls)).delete(synchronize_session=False)
# Delete any staging media items matching this key
if media_key:
db.query(MigrationMediaItem).filter(
or_(MigrationMediaItem.media_key == media_key, MigrationMediaItem.id == group_id)
).delete(synchronize_session=False)
# Delete media group (cascades to MediaAsset)
db.delete(mg)
db.commit()
return {"status": "success", "message": f"Media item {media_key} deleted successfully."}
# Fallback: check if staging items exist
deleted_items = db.query(MigrationMediaItem).filter(
or_(MigrationMediaItem.id == group_id, MigrationMediaItem.media_key == group_id)
).delete(synchronize_session=False)
db.commit()
if deleted_items > 0:
return {"status": "success", "message": f"Media item {group_id} deleted."}
return {"status": "success", "message": f"Media item {group_id} removed."}
@router.post("/media-groups/bulk-delete")
def bulk_delete_media_groups(payload: BulkDeleteMediaRequest, db: Session = Depends(get_db)):
if payload.ids:
db.query(MigrationMediaItem).filter(MigrationMediaItem.id.in_(payload.ids)).delete(synchronize_session=False)
"""
Bulk deletes multiple MediaGroup records, their MediaAssets, linked variant/product images, and disk files.
Supports both payload.ids and payload.group_ids.
"""
target_ids = payload.target_ids()
if not target_ids:
return {"status": "success", "message": "No media keys specified for deletion.", "deleted_groups_count": 0}
# Find all MediaGroups matching IDs or media_keys
groups = db.query(MediaGroup).filter(
or_(MediaGroup.id.in_(target_ids), MediaGroup.media_key.in_(target_ids))
).all()
media_keys = [g.media_key for g in groups if g.media_key]
# Also check if any target_ids are MigrationMediaItem IDs
staging_items = db.query(MigrationMediaItem).filter(MigrationMediaItem.id.in_(target_ids)).all()
staging_keys = [i.media_key for i in staging_items if i.media_key]
if staging_keys:
more_groups = db.query(MediaGroup).filter(MediaGroup.media_key.in_(staging_keys)).all()
for mg in more_groups:
if mg not in groups:
groups.append(mg)
if mg.media_key:
media_keys.append(mg.media_key)
# Clean up physical files and collect asset URLs
all_cdn_urls = []
for g in groups:
for asset in (g.media_assets or []):
if asset.storage_path and os.path.exists(asset.storage_path):
try:
os.remove(asset.storage_path)
except Exception:
pass
if asset.cdn_url:
all_cdn_urls.append(asset.cdn_url)
db.delete(g)
# Unlink images from variants and products
if all_cdn_urls:
db.query(VariantImage).filter(VariantImage.image_url.in_(all_cdn_urls)).delete(synchronize_session=False)
db.query(ProductImage).filter(ProductImage.image_url.in_(all_cdn_urls)).delete(synchronize_session=False)
# Clean up staging items
all_clean_keys = list(set(target_ids + media_keys + staging_keys))
db.query(MigrationMediaItem).filter(
or_(MigrationMediaItem.id.in_(all_clean_keys), MigrationMediaItem.media_key.in_(all_clean_keys))
).delete(synchronize_session=False)
db.commit()
return {"status": "success", "message": f"Deleted {len(payload.ids)} media items."}
count = len(groups)
return {"status": "success", "message": f"Deleted {count} media key(s).", "deleted_groups_count": count}
@router.post("/rollback/{batch_id}")
def rollback_migration_batch(batch_id: str, db: Session = Depends(get_db)):
"""
Reverts inserted and updated records for a migration batch using migration_snapshots.
"""
batch = db.query(MigrationBatch).filter(MigrationBatch.id == batch_id).first()
if not batch:
raise HTTPException(status_code=404, detail="Migration batch not found")
snapshots = db.query(MigrationSnapshot).filter(
MigrationSnapshot.batch_id == batch_id
).order_by(MigrationSnapshot.created_at.desc()).all()
reverted_inserts = 0
reverted_updates = 0
for snap in snapshots:
if snap.entity_table == "product_variants":
variant = db.query(ProductVariant).filter(ProductVariant.variant_id == snap.entity_id).first()
if not variant:
continue
if snap.action_taken == "INSERTED":
# Delete variant attributes & images
db.query(VariantAttribute).filter(VariantAttribute.variant_id == variant.variant_id).delete(synchronize_session=False)
db.query(VariantImage).filter(VariantImage.variant_id == variant.variant_id).delete(synchronize_session=False)
prod_id = variant.product_id
db.delete(variant)
reverted_inserts += 1
# Clean up empty parent product
if prod_id:
remaining = db.query(ProductVariant).filter(ProductVariant.product_id == prod_id).count()
if remaining <= 1:
prod = db.query(Product).filter(Product.product_id == prod_id).first()
if prod:
db.query(ProductImage).filter(ProductImage.product_id == prod_id).delete(synchronize_session=False)
db.delete(prod)
elif snap.action_taken == "UPDATED" and snap.previous_state:
prev = snap.previous_state
if "price" in prev:
variant.price = prev["price"]
if "cost_price" in prev:
variant.cost_price = prev["cost_price"]
if "sku" in prev:
variant.sku = prev["sku"]
reverted_updates += 1
batch.status = BatchStatusEnum.ROLLED_BACK
db.commit()
return {
"status": "success",
"message": f"Rollback complete: {reverted_inserts} inserted variants removed, {reverted_updates} updated variants restored."
}
@router.post("/purge-all")
@router.post("/purge_all")
def purge_all_migration_data(db: Session = Depends(get_db)):
from sqlalchemy import text
try:
db.execute(text("DELETE FROM migration_snapshots"))
db.execute(text("DELETE FROM migration_errors"))
db.execute(text("DELETE FROM migration_job_checkpoints"))
db.execute(text("DELETE FROM migration_media_items"))
db.execute(text("DELETE FROM media_library"))
db.execute(text("DELETE FROM media_groups"))
db.execute(text("DELETE FROM migration_jobs"))
db.execute(text("DELETE FROM migration_batches"))
db.commit()
except Exception as e:
db.rollback()
print(f"Purge warning: {e}")
return {"status": "success", "message": "All migration history and media groups purged."}
return {"status": "success", "message": "All migration history, jobs, and media groups purged."}
@router.get("/jobs/{job_id}/status")
def get_job_telemetry(job_id: str, db: Session = Depends(get_db)):