Refactoring code for modular approach

2025-09-09 22:07:21 +02:00
parent b865235f8a
commit 8fbe64687a
9 changed files with 1517 additions and 520 deletions
--- a/app/api/v1/marketplace.py
+++ b/app/api/v1/marketplace.py
@@ -7,8 +7,8 @@ from app.api.deps import get_current_user
 from app.tasks.background_tasks import process_marketplace_import
 from middleware.decorators import rate_limit
 from models.api_models import MarketplaceImportJobResponse, MarketplaceImportRequest
-from models.database_models import User, MarketplaceImportJob, Shop
-from datetime import datetime
+from models.database_models import User
+from marketplace_service import marketplace_service
 import logging

 router = APIRouter()
@@ -25,50 +25,39 @@ async def import_products_from_marketplace(
        current_user: User = Depends(get_current_user)
 ):
    """Import products from marketplace CSV with background processing (Protected)"""
+    try:
+        logger.info(
+            f"Starting marketplace import: {request.marketplace} -> {request.shop_code} by user {current_user.username}")

-    logger.info(
-        f"Starting marketplace import: {request.marketplace} -> {request.shop_code} by user {current_user.username}")
+        # Create import job through service
+        import_job = marketplace_service.create_import_job(db, request, current_user)

-    # Verify shop exists and user has access
-    shop = db.query(Shop).filter(Shop.shop_code == request.shop_code).first()
-    if not shop:
-        raise HTTPException(status_code=404, detail="Shop not found")
+        # Process in background
+        background_tasks.add_task(
+            process_marketplace_import,
+            import_job.id,
+            request.url,
+            request.marketplace,
+            request.shop_code,
+            request.batch_size or 1000
+        )

-    # Check permissions: admin can import for any shop, others only for their own
-    if current_user.role != "admin" and shop.owner_id != current_user.id:
-        raise HTTPException(status_code=403, detail="Access denied to this shop")
+        return MarketplaceImportJobResponse(
+            job_id=import_job.id,
+            status="pending",
+            marketplace=request.marketplace,
+            shop_code=request.shop_code,
+            message=f"Marketplace import started from {request.marketplace}. Check status with "
+                    f"/marketplace-import-status/{import_job.id}"
+        )

-    # Create marketplace import job record
-    import_job = MarketplaceImportJob(
-        status="pending",
-        source_url=request.url,
-        marketplace=request.marketplace,
-        shop_code=request.shop_code,
-        user_id=current_user.id,
-        created_at=datetime.utcnow()
-    )
-    db.add(import_job)
-    db.commit()
-    db.refresh(import_job)
-
-    # Process in background
-    background_tasks.add_task(
-        process_marketplace_import,
-        import_job.id,
-        request.url,
-        request.marketplace,
-        request.shop_code,
-        request.batch_size or 1000
-    )
-
-    return MarketplaceImportJobResponse(
-        job_id=import_job.id,
-        status="pending",
-        marketplace=request.marketplace,
-        shop_code=request.shop_code,
-        message=f"Marketplace import started from {request.marketplace}. Check status with "
-                f"/marketplace-import-status/{import_job.id}"
-    )
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error starting marketplace import: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")


@router.get("/marketplace-import-status/{job_id}", response_model=MarketplaceImportJobResponse)
@@ -78,28 +67,17 @@ def get_marketplace_import_status(
        current_user: User = Depends(get_current_user)
 ):
    """Get status of marketplace import job (Protected)"""
-    job = db.query(MarketplaceImportJob).filter(MarketplaceImportJob.id == job_id).first()
-    if not job:
-        raise HTTPException(status_code=404, detail="Marketplace import job not found")
+    try:
+        job = marketplace_service.get_import_job_by_id(db, job_id, current_user)
+        return marketplace_service.convert_to_response_model(job)

-    # Users can only see their own jobs, admins can see all
-    if current_user.role != "admin" and job.user_id != current_user.id:
-        raise HTTPException(status_code=403, detail="Access denied to this import job")
-
-    return MarketplaceImportJobResponse(
-        job_id=job.id,
-        status=job.status,
-        marketplace=job.marketplace,
-        shop_name=job.shop_name,
-        imported=job.imported_count or 0,
-        updated=job.updated_count or 0,
-        total_processed=job.total_processed or 0,
-        error_count=job.error_count or 0,
-        error_message=job.error_message,
-        created_at=job.created_at,
-        started_at=job.started_at,
-        completed_at=job.completed_at
-    )
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error getting import job status {job_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")


@router.get("/marketplace-import-jobs", response_model=List[MarketplaceImportJobResponse])
@@ -112,35 +90,73 @@ def get_marketplace_import_jobs(
        current_user: User = Depends(get_current_user)
 ):
    """Get marketplace import jobs with filtering (Protected)"""
+    try:
+        jobs = marketplace_service.get_import_jobs(
+            db=db,
+            user=current_user,
+            marketplace=marketplace,
+            shop_name=shop_name,
+            skip=skip,
+            limit=limit
+        )

-    query = db.query(MarketplaceImportJob)
+        return [marketplace_service.convert_to_response_model(job) for job in jobs]

-    # Users can only see their own jobs, admins can see all
-    if current_user.role != "admin":
-        query = query.filter(MarketplaceImportJob.user_id == current_user.id)
+    except Exception as e:
+        logger.error(f"Error getting import jobs: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")

-    # Apply filters
-    if marketplace:
-        query = query.filter(MarketplaceImportJob.marketplace.ilike(f"%{marketplace}%"))
-    if shop_name:
-        query = query.filter(MarketplaceImportJob.shop_name.ilike(f"%{shop_name}%"))

-    # Order by creation date (newest first) and apply pagination
-    jobs = query.order_by(MarketplaceImportJob.created_at.desc()).offset(skip).limit(limit).all()
+@router.get("/marketplace-import-stats")
+def get_marketplace_import_stats(
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
+):
+    """Get statistics about marketplace import jobs (Protected)"""
+    try:
+        stats = marketplace_service.get_job_stats(db, current_user)
+        return stats

-    return [
-        MarketplaceImportJobResponse(
-            job_id=job.id,
-            status=job.status,
-            marketplace=job.marketplace,
-            shop_name=job.shop_name,
-            imported=job.imported_count or 0,
-            updated=job.updated_count or 0,
-            total_processed=job.total_processed or 0,
-            error_count=job.error_count or 0,
-            error_message=job.error_message,
-            created_at=job.created_at,
-            started_at=job.started_at,
-            completed_at=job.completed_at
-        ) for job in jobs
-    ]
+    except Exception as e:
+        logger.error(f"Error getting import stats: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
+@router.put("/marketplace-import-jobs/{job_id}/cancel", response_model=MarketplaceImportJobResponse)
+def cancel_marketplace_import_job(
+        job_id: int,
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
+):
+    """Cancel a pending or running marketplace import job (Protected)"""
+    try:
+        job = marketplace_service.cancel_import_job(db, job_id, current_user)
+        return marketplace_service.convert_to_response_model(job)
+
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error cancelling import job {job_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
+@router.delete("/marketplace-import-jobs/{job_id}")
+def delete_marketplace_import_job(
+        job_id: int,
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
+):
+    """Delete a completed marketplace import job (Protected)"""
+    try:
+        marketplace_service.delete_import_job(db, job_id, current_user)
+        return {"message": "Marketplace import job deleted successfully"}
+
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error deleting import job {job_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")