from __future__ import annotations from fastapi import APIRouter, Depends, HTTPException, Response, status from sqlalchemy.orm import Session from app.api.v1.schemas import ( BuildCampaignRequest, CampaignCreateRequest, CampaignUpdateRequest, CampaignCreateResponse, CampaignCreateMinimalRequest, CampaignJobsResponse, CampaignListResponse, CampaignResponse, CampaignVersionDetailResponse, CampaignVersionResponse, CampaignVersionSetStepRequest, CampaignVersionUpdateRequest, CampaignPartialValidationRequest, CampaignPartialValidationResponse, ValidateCampaignRequest, ReportEmailRequest, ReportEmailResponse, ) from app.auth.dependencies import ApiPrincipal, require_scope from app.audit.logging import audit_from_principal from app.db.models import Campaign, CampaignJob, CampaignVersion from app.db.session import get_session from app.mailer.reports.campaigns import CampaignReportError, generate_campaign_report, generate_jobs_csv from app.mailer.reports.emailing import CampaignReportEmailError, send_campaign_report_email from app.mailer.persistence.campaigns import ( CampaignPersistenceError, build_campaign_version, create_campaign_version_from_json, validate_campaign_version, ) from app.mailer.persistence.versions import ( LockedCampaignVersionError, create_minimal_campaign, fork_campaign_version_for_edit, is_version_final_locked, is_user_locked_version, get_campaign_version_for_tenant, publish_campaign_version, unlock_validated_campaign_version, update_campaign_version, validate_campaign_partial, ) router = APIRouter(prefix="/campaigns", tags=["campaigns"]) def _get_campaign_for_tenant(session: Session, campaign_id: str, tenant_id: str) -> Campaign: campaign = session.get(Campaign, campaign_id) if not campaign or campaign.tenant_id != tenant_id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Campaign not found") return campaign def _get_version_for_tenant(session: Session, version_id: str, tenant_id: str) -> CampaignVersion: version = session.get(CampaignVersion, version_id) if not version: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Campaign version not found") campaign = session.get(Campaign, version.campaign_id) if not campaign or campaign.tenant_id != tenant_id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Campaign version not found") return version @router.post("", response_model=CampaignCreateResponse) def create_campaign( payload: CampaignCreateRequest, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): try: campaign, version = create_campaign_version_from_json( session, tenant_id=principal.tenant_id, user_id=principal.user.id, raw_json=payload.config, source_filename=payload.source_filename, source_base_path=payload.source_base_path, ) audit_from_principal( session, principal, action="campaign.created", object_type="campaign", object_id=campaign.id, details={"version_id": version.id, "external_id": campaign.external_id}, commit=True, ) except Exception as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc return CampaignCreateResponse(campaign=CampaignResponse.model_validate(campaign), version=CampaignVersionResponse.model_validate(version)) @router.post("/new", response_model=CampaignCreateResponse) def create_minimal_campaign_endpoint( payload: CampaignCreateMinimalRequest, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): """Create a minimal editable campaign/version for the WebUI wizard. This is intentionally different from importing a complete campaign JSON. It returns a normal Campaign + CampaignVersion whose version is a working copy and can be autosaved while incomplete. """ try: campaign, version = create_minimal_campaign( session, tenant_id=principal.tenant_id, user_id=principal.user.id, external_id=payload.external_id, name=payload.name, description=payload.description, current_flow=payload.current_flow, current_step=payload.current_step, ) audit_from_principal( session, principal, action="campaign.created_minimal", object_type="campaign", object_id=campaign.id, details={"version_id": version.id, "external_id": campaign.external_id}, commit=True, ) return CampaignCreateResponse(campaign=CampaignResponse.model_validate(campaign), version=CampaignVersionResponse.model_validate(version)) except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.get("", response_model=CampaignListResponse) def list_campaigns( session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): campaigns = ( session.query(Campaign) .filter(Campaign.tenant_id == principal.tenant_id) .order_by(Campaign.updated_at.desc()) .all() ) return CampaignListResponse(campaigns=[CampaignResponse.model_validate(item) for item in campaigns]) @router.get("/{campaign_id}", response_model=CampaignResponse) def get_campaign( campaign_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): return CampaignResponse.model_validate(_get_campaign_for_tenant(session, campaign_id, principal.tenant_id)) @router.put("/{campaign_id}", response_model=CampaignResponse) def update_campaign_metadata_endpoint( campaign_id: str, payload: CampaignUpdateRequest, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): campaign = _get_campaign_for_tenant(session, campaign_id, principal.tenant_id) if payload.external_id is not None: value = payload.external_id.strip() if not value: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Campaign ID cannot be empty") duplicate = ( session.query(Campaign) .filter(Campaign.tenant_id == principal.tenant_id, Campaign.external_id == value, Campaign.id != campaign.id) .one_or_none() ) if duplicate: raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Campaign ID already exists for this tenant") campaign.external_id = value if payload.name is not None: value = payload.name.strip() if not value: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Campaign name cannot be empty") campaign.name = value if payload.status is not None: campaign.status = payload.status if payload.description is not None: campaign.description = payload.description session.add(campaign) session.commit() session.refresh(campaign) audit_from_principal( session, principal, action="campaign.metadata_updated", object_type="campaign", object_id=campaign.id, details={"external_id": campaign.external_id, "name": campaign.name}, commit=True, ) return CampaignResponse.model_validate(campaign) @router.get("/{campaign_id}/versions", response_model=list[CampaignVersionResponse]) def list_versions( campaign_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): campaign = _get_campaign_for_tenant(session, campaign_id, principal.tenant_id) versions = ( session.query(CampaignVersion) .filter(CampaignVersion.campaign_id == campaign.id) .order_by(CampaignVersion.version_number.desc()) .all() ) return [CampaignVersionResponse.model_validate(item) for item in versions] @router.get("/{campaign_id}/versions/{version_id}", response_model=CampaignVersionDetailResponse) def get_version_detail( campaign_id: str, version_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): try: version = get_campaign_version_for_tenant( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id ) return CampaignVersionDetailResponse.model_validate(version) except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.post("/{campaign_id}/versions/{version_id}/fork", response_model=CampaignCreateResponse) def fork_version_for_edit( campaign_id: str, version_id: str, payload: CampaignVersionUpdateRequest | None = None, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): """Create a new editable campaign version from a locked/validated/sent version. Versions that were validated, built, queued or sent are immutable audit snapshots. This endpoint makes an explicit editable copy and makes that new copy the campaign's current version. """ payload = payload or CampaignVersionUpdateRequest() try: version = fork_campaign_version_for_edit( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id, raw_json=payload.campaign_json, current_flow=payload.current_flow or "manual", current_step=payload.current_step, editor_state=payload.editor_state, source_filename=payload.source_filename, source_base_path=payload.source_base_path, autosave=True, ) campaign = _get_campaign_for_tenant(session, campaign_id, principal.tenant_id) audit_from_principal( session, principal, action="campaign.version_forked_for_edit", object_type="campaign_version", object_id=version.id, details={"campaign_id": campaign_id, "source_version_id": version_id, "version_number": version.version_number}, commit=True, ) return CampaignCreateResponse( campaign=CampaignResponse.model_validate(campaign), version=CampaignVersionResponse.model_validate(version), ) except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.post("/{campaign_id}/versions/{version_id}/unlock-validation", response_model=CampaignVersionDetailResponse) def unlock_version_validation( campaign_id: str, version_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): """Unlock a successfully validated version before delivery starts. Unlocking invalidates validation/build state and removes generated jobs for that version. Sent/final versions cannot be unlocked and must be copied. """ try: version = unlock_validated_campaign_version( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id, ) audit_from_principal( session, principal, action="campaign.version_validation_unlocked", object_type="campaign_version", object_id=version.id, details={"campaign_id": campaign_id}, commit=True, ) return CampaignVersionDetailResponse.model_validate(version) except LockedCampaignVersionError as exc: raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.put("/{campaign_id}/versions/{version_id}", response_model=CampaignVersionDetailResponse) def update_version_detail( campaign_id: str, version_id: str, payload: CampaignVersionUpdateRequest, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): try: version = update_campaign_version( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id, raw_json=payload.campaign_json, current_flow=payload.current_flow, current_step=payload.current_step, workflow_state=payload.workflow_state, is_complete=payload.is_complete, editor_state=payload.editor_state, source_filename=payload.source_filename, source_base_path=payload.source_base_path, autosave=False, ) audit_from_principal( session, principal, action="campaign.version_updated", object_type="campaign_version", object_id=version.id, details={"campaign_id": campaign_id, "current_flow": version.current_flow, "current_step": version.current_step}, commit=True, ) return CampaignVersionDetailResponse.model_validate(version) except LockedCampaignVersionError as exc: raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc except Exception as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/{campaign_id}/versions/{version_id}/autosave", response_model=CampaignVersionDetailResponse) def autosave_version( campaign_id: str, version_id: str, payload: CampaignVersionUpdateRequest, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): try: version = update_campaign_version( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id, raw_json=payload.campaign_json, current_flow=payload.current_flow, current_step=payload.current_step, workflow_state=payload.workflow_state, is_complete=payload.is_complete, editor_state=payload.editor_state, source_filename=payload.source_filename, source_base_path=payload.source_base_path, autosave=True, ) audit_from_principal( session, principal, action="campaign.version_autosaved", object_type="campaign_version", object_id=version.id, details={"campaign_id": campaign_id, "current_flow": version.current_flow, "current_step": version.current_step}, commit=True, ) return CampaignVersionDetailResponse.model_validate(version) except LockedCampaignVersionError as exc: raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc except Exception as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/{campaign_id}/versions/{version_id}/set-step", response_model=CampaignVersionDetailResponse) def set_version_step( campaign_id: str, version_id: str, payload: CampaignVersionSetStepRequest, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): try: version = update_campaign_version( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id, current_flow=payload.current_flow, current_step=payload.current_step, autosave=True, ) return CampaignVersionDetailResponse.model_validate(version) except LockedCampaignVersionError as exc: raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.post("/{campaign_id}/versions/{version_id}/validate-partial", response_model=CampaignPartialValidationResponse) def validate_version_partial( campaign_id: str, version_id: str, payload: CampaignPartialValidationRequest | None = None, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:validate")), ): try: version = get_campaign_version_for_tenant( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id ) campaign_json = payload.campaign_json if payload and payload.campaign_json is not None else version.raw_json result = validate_campaign_partial(campaign_json, section=payload.section if payload else None) audit_from_principal( session, principal, action="campaign.version_partially_validated", object_type="campaign_version", object_id=version.id, details={"campaign_id": campaign_id, "section": result.get("section"), "ok": result.get("ok")}, commit=True, ) return CampaignPartialValidationResponse(**result) except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.post("/{campaign_id}/versions/{version_id}/publish", response_model=CampaignVersionDetailResponse) def publish_version( campaign_id: str, version_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:write")), ): try: version = publish_campaign_version(session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id) audit_from_principal( session, principal, action="campaign.version_published", object_type="campaign_version", object_id=version.id, details={"campaign_id": campaign_id}, commit=True, ) return CampaignVersionDetailResponse.model_validate(version) except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.post("/versions/{version_id}/validate") def validate_version( version_id: str, payload: ValidateCampaignRequest | None = None, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:validate")), ): try: version = _get_version_for_tenant(session, version_id, principal.tenant_id) if is_user_locked_version(version) or is_version_final_locked(version): raise HTTPException( status_code=status.HTTP_409_CONFLICT, detail="This version is audit-safe/final and cannot be validated again. Create an editable copy instead.", ) result = validate_campaign_version( session, tenant_id=principal.tenant_id, version_id=version_id, check_files=payload.check_files if payload else False, user_id=principal.user.id, ) audit_from_principal( session, principal, action="campaign.validated", object_type="campaign_version", object_id=version_id, details={"check_files": payload.check_files if payload else False, "ok": result.get("ok")}, commit=True, ) return result except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc except Exception as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/versions/{version_id}/build") def build_version( version_id: str, payload: BuildCampaignRequest | None = None, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:build")), ): try: result = build_campaign_version( session, tenant_id=principal.tenant_id, version_id=version_id, write_eml=payload.write_eml if payload else True, ) audit_from_principal( session, principal, action="campaign.messages_built", object_type="campaign_version", object_id=version_id, details={"write_eml": payload.write_eml if payload else True, "built_count": result.get("built_count")}, commit=True, ) return result except CampaignPersistenceError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc except Exception as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.get("/{campaign_id}/jobs", response_model=CampaignJobsResponse) def list_jobs( campaign_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): campaign = _get_campaign_for_tenant(session, campaign_id, principal.tenant_id) jobs = ( session.query(CampaignJob) .filter(CampaignJob.campaign_id == campaign.id) .order_by(CampaignJob.entry_index.asc()) .all() ) return CampaignJobsResponse( jobs=[ { "id": job.id, "entry_index": job.entry_index, "entry_id": job.entry_id, "recipient_email": job.recipient_email, "subject": job.subject, "build_status": job.build_status, "validation_status": job.validation_status, "queue_status": job.queue_status, "send_status": job.send_status, "imap_status": job.imap_status, "eml_local_path": job.eml_local_path, "eml_size_bytes": job.eml_size_bytes, "attempt_count": job.attempt_count, "last_error": job.last_error, "queued_at": job.queued_at, "sent_at": job.sent_at, "issues": job.issues_snapshot, "attachments": job.resolved_attachments, } for job in jobs ] ) @router.get("/{campaign_id}/summary") def campaign_summary( campaign_id: str, include_jobs: bool = False, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): """Return dashboard-friendly campaign status counters and summaries.""" try: return generate_campaign_report( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, include_jobs=include_jobs, ) except CampaignReportError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.get("/{campaign_id}/report") def campaign_report( campaign_id: str, include_jobs: bool = True, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): """Return the full JSON report for one campaign.""" try: return generate_campaign_report( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, include_jobs=include_jobs, ) except CampaignReportError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc @router.get("/{campaign_id}/report/jobs.csv") def campaign_jobs_csv( campaign_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:read")), ): """Export per-job campaign status as CSV.""" try: csv_text = generate_jobs_csv(session, tenant_id=principal.tenant_id, campaign_id=campaign_id) except CampaignReportError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc return Response( content=csv_text, media_type="text/csv; charset=utf-8", headers={"Content-Disposition": f'attachment; filename="campaign-{campaign_id}-jobs.csv"'}, ) @router.post("/{campaign_id}/report/email", response_model=ReportEmailResponse) def email_campaign_report( campaign_id: str, payload: ReportEmailRequest, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("reports:send")), ): """Generate a campaign report and send it to one or more email addresses.""" try: result = send_campaign_report_email( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, to=payload.to, include_jobs=payload.include_jobs, attach_jobs_csv=payload.attach_jobs_csv, attach_report_json=payload.attach_report_json, dry_run=payload.dry_run, ) audit_from_principal( session, principal, action="report.email_sent" if not payload.dry_run else "report.email_dry_run", object_type="campaign", object_id=campaign_id, details=result.as_dict(), commit=True, ) return ReportEmailResponse(result=result.as_dict()) except CampaignReportError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc except (CampaignReportEmailError, Exception) as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc # Queue / delivery control ------------------------------------------------- from app.api.v1.schemas import ( AppendSentRequest, CampaignActionResponse, QueueCampaignRequest, QueueCampaignResponse, SendCampaignNowRequest, SendCampaignNowResponse, ) from app.mailer.sending.jobs import ( QueueingError, cancel_campaign_jobs, enqueue_pending_imap_appends, pause_campaign_jobs, queue_campaign_jobs, resume_campaign_jobs, send_campaign_now, ) @router.post("/{campaign_id}/queue", response_model=QueueCampaignResponse) def queue_campaign( campaign_id: str, payload: QueueCampaignRequest | None = None, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:queue")), ): payload = payload or QueueCampaignRequest() try: result = queue_campaign_jobs( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=payload.version_id, include_warnings=payload.include_warnings, enqueue_celery=payload.enqueue_celery, dry_run=payload.dry_run, ) audit_from_principal( session, principal, action="campaign.queued" if not payload.dry_run else "campaign.queue_dry_run", object_type="campaign", object_id=campaign_id, details=result.as_dict(), commit=True, ) return QueueCampaignResponse(**result.as_dict()) except QueueingError as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/{campaign_id}/send-now", response_model=SendCampaignNowResponse) def send_campaign_now_endpoint( campaign_id: str, payload: SendCampaignNowRequest | None = None, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:send")), ): """Validate/build/queue and synchronously send a small campaign version. This endpoint is intentionally conservative and suitable for a first small test campaign. Larger campaigns should use the queue/Celery flow. """ payload = payload or SendCampaignNowRequest() try: campaign = _get_campaign_for_tenant(session, campaign_id, principal.tenant_id) version_id = payload.version_id or campaign.current_version_id if not version_id: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Campaign has no current version") version = _get_version_for_tenant(session, version_id, principal.tenant_id) validation_result: dict[str, object] | None = version.validation_summary if isinstance(version.validation_summary, dict) else None build_result: dict[str, object] | None = None if is_user_locked_version(version): raise HTTPException( status_code=status.HTTP_409_CONFLICT, detail="User-locked audit-safe versions cannot be dry-run or sent. Create an editable copy and validate it instead.", ) if not version.locked_at or not validation_result or validation_result.get("ok") is not True: raise HTTPException( status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Campaign version must be validated and locked before dry-run or sending.", ) if not version.build_summary: raise HTTPException( status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Campaign version must be built before dry-run or sending.", ) result = send_campaign_now( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, version_id=version_id, include_warnings=payload.include_warnings, dry_run=payload.dry_run, use_rate_limit=payload.use_rate_limit, enqueue_imap_task=payload.enqueue_imap_task, ).as_dict() result["validation"] = validation_result result["build"] = build_result audit_from_principal( session, principal, action="campaign.sent_now" if not payload.dry_run else "campaign.send_now_dry_run", object_type="campaign", object_id=campaign_id, details=result, commit=True, ) return SendCampaignNowResponse(result=result) except HTTPException: raise except (CampaignPersistenceError, QueueingError) as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc except Exception as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/{campaign_id}/pause", response_model=CampaignActionResponse) def pause_campaign( campaign_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:queue")), ): try: result = pause_campaign_jobs(session, tenant_id=principal.tenant_id, campaign_id=campaign_id) audit_from_principal(session, principal, action="campaign.paused", object_type="campaign", object_id=campaign_id, details=result, commit=True) return CampaignActionResponse(result=result) except QueueingError as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/{campaign_id}/resume", response_model=CampaignActionResponse) def resume_campaign( campaign_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:queue")), ): try: result = resume_campaign_jobs(session, tenant_id=principal.tenant_id, campaign_id=campaign_id) audit_from_principal(session, principal, action="campaign.resumed", object_type="campaign", object_id=campaign_id, details=result, commit=True) return CampaignActionResponse(result=result) except QueueingError as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/{campaign_id}/cancel", response_model=CampaignActionResponse) def cancel_campaign( campaign_id: str, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:queue")), ): try: result = cancel_campaign_jobs(session, tenant_id=principal.tenant_id, campaign_id=campaign_id) audit_from_principal(session, principal, action="campaign.cancelled", object_type="campaign", object_id=campaign_id, details=result, commit=True) return CampaignActionResponse(result=result) except QueueingError as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc @router.post("/{campaign_id}/append-sent", response_model=CampaignActionResponse) def append_sent( campaign_id: str, payload: AppendSentRequest | None = None, session: Session = Depends(get_session), principal: ApiPrincipal = Depends(require_scope("campaign:send")), ): payload = payload or AppendSentRequest() try: result = enqueue_pending_imap_appends( session, tenant_id=principal.tenant_id, campaign_id=campaign_id, enqueue_celery=payload.enqueue_celery, dry_run=payload.dry_run, ) audit_from_principal( session, principal, action="campaign.append_sent_enqueued" if not payload.dry_run else "campaign.append_sent_dry_run", object_type="campaign", object_id=campaign_id, details=result, commit=True, ) return CampaignActionResponse(result=result) except QueueingError as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc