From 9f85ae4221cb1b303d889ea98fd314dc26e452e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andrew=20Beveridge=20=E2=98=84=EF=B8=8F?= Date: Wed, 4 Mar 2026 14:18:10 -0500 Subject: [PATCH] feat: credit notifications and refund on job deletion (#474) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary - **Backend**: Refund credits when jobs are deleted (if not already complete/failed/cancelled) - **Frontend**: Show toast notifications for credit changes — "Credit used" on job creation, "Credit refunded" on eligible job deletion - Refreshes user data from backend after credit-changing operations so header counter stays accurate ## Changes | File | What | |------|------| | `backend/services/job_manager.py` | Refund credit on job deletion (non-complete jobs) | | `frontend/components/job/JobSubmission.tsx` | "Credit used — X remaining" toast after job creation | | `frontend/components/job/JobActions.tsx` | "Credit refunded — X remaining" toast after eligible deletion | | `frontend/components/__tests__/JobActions.test.tsx` | Updated test mock for auth module | ## Test plan - [x] All 178 Playwright + Jest tests pass - [ ] Create a job → see "Credit used" toast with correct remaining count - [ ] Delete a pending/processing job → see "Credit refunded" toast - [ ] Delete a completed job → see "Job deleted" toast (no refund mention) - [ ] Header credit counter updates immediately after both operations 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.6 --- .../credit-refund-on-delete-cancel.plan.md | 111 ++++++++++ backend/models/job.py | 3 + backend/services/job_manager.py | 91 +++++--- backend/tests/test_credit_enforcement.py | 209 +++++++++++++++++- .../components/__tests__/JobActions.test.tsx | 12 +- frontend/components/job/JobActions.tsx | 23 +- frontend/components/job/JobSubmission.tsx | 16 +- pyproject.toml | 2 +- 8 files changed, 430 insertions(+), 37 deletions(-) create mode 100644 .claude/plans/credit-refund-on-delete-cancel.plan.md diff --git a/.claude/plans/credit-refund-on-delete-cancel.plan.md b/.claude/plans/credit-refund-on-delete-cancel.plan.md new file mode 100644 index 00000000..d6689675 --- /dev/null +++ b/.claude/plans/credit-refund-on-delete-cancel.plan.md @@ -0,0 +1,111 @@ +# Plan: Credit Refund on Job Deletion and Cancellation + +**Created:** 2026-03-04 +**Branch:** feat/sess-20260304-1308-investigate-user-credits +**Status:** Implemented + +## Overview + +When a user deletes or cancels a job, their credit is not refunded. This was discovered when user john2011@sky.com deleted a job 16 seconds after creation (accidental duplicate) and lost the credit. Job *failures* already auto-refund via `mark_job_failed()` → `refund_credit()`, but deletions and cancellations do not. + +## Requirements + +- [x] Job failures already refund credits (existing behavior, no change needed) +- [ ] Job cancellation refunds 1 credit +- [ ] Job deletion refunds 1 credit (if not already completed) +- [ ] No refund for completed jobs (user got their video) +- [ ] No refund for admin-owned jobs (consistent with failure refund logic) +- [ ] Idempotency: prevent double-refund if a job is cancelled then deleted, or fails then deleted +- [ ] Credit transaction records the reason clearly ("job_cancelled", "job_deleted") +- [ ] Refund failure must not block the cancel/delete operation + +## Technical Approach + +### Key Insight: Idempotency via Job Field + +The current `refund_credit()` has no guard against double-refund for the same job. Since a job can transition through cancelled → deleted, or failed → deleted, we need a way to track that a refund was already issued. + +**Approach**: Add a `credit_refunded` boolean field to the Job model. Check it before refunding. This is simpler and more reliable than scanning the user's transaction history. + +### What Should and Shouldn't Be Refunded + +| Job Status at Time of Action | Delete | Cancel | Notes | +|------------------------------|--------|--------|-------| +| PENDING through pre-COMPLETE | Refund | Refund | Job didn't deliver value | +| COMPLETE / PREP_COMPLETE | No refund | N/A (can't cancel terminal) | User got their output | +| FAILED | No refund (already refunded) | N/A (can't cancel terminal) | Already refunded by fail_job | +| CANCELLED | No refund (already refunded) | N/A (already cancelled) | Already refunded by cancel | + +For deletion: we need to read the job status *before* deleting it to decide whether to refund. The delete endpoint already fetches the job for ownership check, so this is straightforward. + +### Refund Helper + +Extract the refund logic (currently in `mark_job_failed`) into a reusable private method `_refund_credit_for_job()` that: +1. Checks `job.credit_refunded` — skip if already refunded +2. Checks `job.user_email` — skip if no user +3. Checks if admin — skip if admin job +4. Calls `user_service.refund_credit()` with appropriate reason +5. Sets `credit_refunded = True` on the job (for cancel; for delete the job is about to be removed but we set it anyway for the brief window) +6. Wraps everything in try/except so failures don't block the parent operation + +## Implementation Steps + +1. [ ] **Add `credit_refunded` field to Job model** (`backend/models/job.py`) + - Add `credit_refunded: bool = False` to the Job model + - No migration needed — Firestore is schemaless, defaults to False for existing docs + +2. [ ] **Extract refund helper in JobManager** (`backend/services/job_manager.py`) + - Create `_refund_credit_for_job(self, job_id: str, job: Job, reason: str) -> bool` + - Move the refund logic from `mark_job_failed` (lines 821-839) into this helper + - Add `credit_refunded` check at the top + - Update `mark_job_failed` to call the helper with `reason="job_failed"` + +3. [ ] **Add refund to `cancel_job()`** (`backend/services/job_manager.py`) + - After setting status to CANCELLED, call `_refund_credit_for_job(job_id, job, reason="job_cancelled")` + - The job object is already fetched at line 1017 + +4. [ ] **Add refund to `delete_job()`** (`backend/services/job_manager.py`) + - Need to fetch the job (already done when `delete_files=True`, but not always) + - Before deletion, check if job status is NOT in `[COMPLETE, PREP_COMPLETE, FAILED, CANCELLED]` + - If eligible, call `_refund_credit_for_job(job_id, job, reason="job_deleted")` + - For FAILED/CANCELLED: skip because refund was already issued during that transition + - For COMPLETE/PREP_COMPLETE: skip because user received their output + +5. [ ] **Update `mark_job_failed` to set `credit_refunded`** + - The helper handles this, but also update the Firestore doc + +6. [ ] **Add unit tests** (`backend/tests/test_credit_enforcement.py`) + - Test: cancel_job refunds credit for non-admin user + - Test: cancel_job skips refund for admin jobs + - Test: delete_job refunds credit for non-complete, non-terminal jobs + - Test: delete_job does NOT refund for completed jobs + - Test: delete_job does NOT double-refund for already-failed jobs + - Test: delete_job does NOT double-refund for already-cancelled jobs + - Test: refund failure doesn't block cancel/delete + - Test: credit_refunded flag prevents double refund + +7. [ ] **Backfill: Refund john2011@sky.com** (manual one-time) + - Grant 1 credit for the deleted job 40dcca89 via admin API or direct Firestore update + +## Files to Create/Modify + +| File | Action | Description | +|------|--------|-------------| +| `backend/models/job.py` | Modify | Add `credit_refunded: bool = False` field | +| `backend/services/job_manager.py` | Modify | Extract `_refund_credit_for_job()` helper, add refund to `cancel_job()` and `delete_job()` | +| `backend/tests/test_credit_enforcement.py` | Modify | Add tests for cancel/delete refund scenarios | + +## Testing Strategy + +- **Unit tests**: Extend `test_credit_enforcement.py` with new test classes `TestCreditRefundOnJobCancellation` and `TestCreditRefundOnJobDeletion`, following the exact pattern of existing `TestCreditRefundOnJobFailure` +- **Manual verification**: After deploy, cancel and delete test jobs and verify credit balance updates + +## Open Questions + +- [ ] Should we notify the user (email/in-app) when a credit is refunded? (Suggest: no, keep it simple for now — the credit just appears back in their balance) + +## Rollback Plan + +- The `credit_refunded` field is additive (defaults to False for old jobs) +- If issues arise, revert the PR — old behavior (no refund on cancel/delete) is restored +- Any refunds already issued are just bonus credits to users, no harm done diff --git a/backend/models/job.py b/backend/models/job.py index 9332c357..cd65186b 100644 --- a/backend/models/job.py +++ b/backend/models/job.py @@ -307,6 +307,9 @@ class Job(BaseModel): outputs_deleted_at: Optional[datetime] = None # Timestamp when outputs were deleted by admin outputs_deleted_by: Optional[str] = None # Admin email who deleted outputs + # Credit refund tracking (prevents double-refund on cancel→delete or fail→delete) + credit_refunded: bool = False + # Processing state track_output_dir: Optional[str] = None # Local output directory (temp) audio_hash: Optional[str] = None # Hash for deduplication diff --git a/backend/services/job_manager.py b/backend/services/job_manager.py index cbc23a6b..ee4edd19 100644 --- a/backend/services/job_manager.py +++ b/backend/services/job_manager.py @@ -355,14 +355,20 @@ class JobManager: def delete_job(self, job_id: str, delete_files: bool = True) -> None: """Delete a job, its files, and its logs subcollection.""" - if delete_files: - job = self.get_job(job_id) - if job and job.output_files: - for gcs_path in job.output_files.values(): - try: - self.storage.delete_file(gcs_path) - except Exception as e: - logger.error(f"Error deleting file {gcs_path}: {e}") + job = self.get_job(job_id) + + # Refund credit if job never completed (and wasn't already refunded via fail/cancel) + if job: + no_refund_statuses = [JobStatus.COMPLETE, JobStatus.PREP_COMPLETE, JobStatus.FAILED, JobStatus.CANCELLED] + if job.status not in no_refund_statuses: + self._refund_credit_for_job(job_id, job, reason="job_deleted") + + if delete_files and job and job.output_files: + for gcs_path in job.output_files.values(): + try: + self.storage.delete_file(gcs_path) + except Exception as e: + logger.error(f"Error deleting file {gcs_path}: {e}") # Delete logs subcollection first (must be done before deleting parent doc) try: @@ -790,6 +796,46 @@ class JobManager: logger.error(f"Job {job_id}: Failed to delete state_data keys {keys}: {e}") return [] + def _refund_credit_for_job(self, job_id: str, job: Job, reason: str) -> bool: + """ + Refund one credit for a job if eligible. + + Skips refund if: already refunded, no user email, or admin-owned job. + Never raises — refund failure must not block the calling operation. + + Returns: + True if credit was refunded, False otherwise. + """ + try: + if job.credit_refunded: + logger.info(f"Credit already refunded for job {job_id}, skipping") + return False + + if not job.user_email: + return False + + from backend.services.auth_service import is_admin_email + from backend.services.user_service import get_user_service + + if is_admin_email(job.user_email): + return False + + user_service = get_user_service() + refund_ok, new_balance, refund_msg = user_service.refund_credit( + job.user_email, job_id, reason=reason + ) + if refund_ok: + # Mark job as refunded to prevent double-refund + self.update_job(job_id, {'credit_refunded': True}) + logger.info(f"Refunded credit for {reason} job {job_id} to {_mask_email(job.user_email)} (balance: {new_balance})") + return True + else: + logger.warning(f"Credit refund failed for job {job_id}: {refund_msg}") + return False + except Exception as e: + logger.warning(f"Error refunding credit for job {job_id}: {e}") + return False + def fail_job(self, job_id: str, error_message: str, error_details: Optional[Dict[str, Any]] = None) -> bool: """ Mark a job as failed with error information. @@ -818,25 +864,10 @@ class JobManager: logger.error(f"Job {job_id} failed: {error_message}") - # Auto-refund credit on failure (skip for admin-owned jobs) - try: - job = self.get_job(job_id) - if job and job.user_email: - from backend.services.auth_service import is_admin_email - from backend.services.user_service import get_user_service - - if not is_admin_email(job.user_email): - user_service = get_user_service() - refund_ok, new_balance, refund_msg = user_service.refund_credit( - job.user_email, job_id, reason="job_failed" - ) - if refund_ok: - logger.info(f"Refunded credit for failed job {job_id} to {_mask_email(job.user_email)} (balance: {new_balance})") - else: - logger.warning(f"Credit refund failed for job {job_id}: {refund_msg}") - except Exception as refund_err: - # Don't fail the fail_job call if refund fails - logger.warning(f"Error refunding credit for job {job_id}: {refund_err}") + # Auto-refund credit on failure + job = self.get_job(job_id) + if job: + self._refund_credit_for_job(job_id, job, reason="job_failed") return True except Exception as e: @@ -1032,8 +1063,12 @@ class JobManager: ) logger.info(f"Job {job_id} cancelled") + + # Refund credit for cancelled job + self._refund_credit_for_job(job_id, job, reason="job_cancelled") + return True - + def mark_job_failed( self, job_id: str, diff --git a/backend/tests/test_credit_enforcement.py b/backend/tests/test_credit_enforcement.py index 2041cd8c..2ff3ea28 100644 --- a/backend/tests/test_credit_enforcement.py +++ b/backend/tests/test_credit_enforcement.py @@ -1,10 +1,11 @@ """ -Tests for credit enforcement in job creation and failure flows. +Tests for credit enforcement in job creation, failure, cancellation, and deletion flows. Verifies that: - Job creation requires credits (unless admin) - Credits are deducted on job creation -- Credits are refunded on job failure +- Credits are refunded on job failure, cancellation, and deletion +- No double-refund when a job is cancelled/failed then deleted - New users get 2 welcome credits """ import pytest @@ -154,6 +155,7 @@ class TestCreditRefundOnJobFailure: """Credit is refunded when a non-admin job fails.""" mock_job = Mock(spec=Job) mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False mock_firestore_service.get_job.return_value = mock_job mock_user_service.refund_credit.return_value = (True, 1, "Refunded") @@ -171,6 +173,7 @@ class TestCreditRefundOnJobFailure: """Credit refund is skipped for admin-owned jobs.""" mock_job = Mock(spec=Job) mock_job.user_email = "admin@nomadkaraoke.com" + mock_job.credit_refunded = False mock_firestore_service.get_job.return_value = mock_job with patch('backend.services.auth_service.is_admin_email', return_value=True): @@ -185,6 +188,7 @@ class TestCreditRefundOnJobFailure: """If refund fails, the job is still marked as failed.""" mock_job = Mock(spec=Job) mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False mock_firestore_service.get_job.return_value = mock_job mock_user_service.refund_credit.side_effect = Exception("Firestore error") @@ -199,6 +203,7 @@ class TestCreditRefundOnJobFailure: """No refund attempted when job has no user_email.""" mock_job = Mock(spec=Job) mock_job.user_email = None + mock_job.credit_refunded = False mock_firestore_service.get_job.return_value = mock_job result = job_manager.fail_job("job123", "Processing error") @@ -206,6 +211,206 @@ class TestCreditRefundOnJobFailure: assert result is True mock_user_service.refund_credit.assert_not_called() + def test_no_double_refund_when_already_refunded( + self, job_manager, mock_firestore_service, mock_user_service + ): + """No refund if credit_refunded is already True.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = True + mock_firestore_service.get_job.return_value = mock_job + + with patch('backend.services.auth_service.is_admin_email', return_value=False): + result = job_manager.fail_job("job123", "Processing error") + + assert result is True + mock_user_service.refund_credit.assert_not_called() + + +class TestCreditRefundOnJobCancellation: + """Test credit refund when jobs are cancelled.""" + + def test_credit_refunded_on_cancellation( + self, job_manager, mock_firestore_service, mock_user_service + ): + """Credit is refunded when a non-admin job is cancelled.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.PENDING + mock_firestore_service.get_job.return_value = mock_job + mock_user_service.refund_credit.return_value = (True, 1, "Refunded") + + with patch('backend.services.auth_service.is_admin_email', return_value=False): + result = job_manager.cancel_job("job123", reason="User cancelled") + + assert result is True + mock_user_service.refund_credit.assert_called_once_with( + "user@test.com", "job123", reason="job_cancelled" + ) + + def test_cancel_skips_refund_for_admin_jobs( + self, job_manager, mock_firestore_service, mock_user_service + ): + """Credit refund is skipped when admin cancels their own job.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "admin@nomadkaraoke.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.PENDING + mock_firestore_service.get_job.return_value = mock_job + + with patch('backend.services.auth_service.is_admin_email', return_value=True): + result = job_manager.cancel_job("job123") + + assert result is True + mock_user_service.refund_credit.assert_not_called() + + def test_cancel_refund_failure_does_not_block_cancellation( + self, job_manager, mock_firestore_service, mock_user_service + ): + """If refund fails, the job is still cancelled.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.PENDING + mock_firestore_service.get_job.return_value = mock_job + mock_user_service.refund_credit.side_effect = Exception("Firestore error") + + with patch('backend.services.auth_service.is_admin_email', return_value=False): + result = job_manager.cancel_job("job123") + + assert result is True + + def test_cannot_cancel_terminal_job( + self, job_manager, mock_firestore_service, mock_user_service + ): + """Cannot cancel a job in a terminal state.""" + mock_job = Mock(spec=Job) + mock_job.status = JobStatus.COMPLETE + mock_firestore_service.get_job.return_value = mock_job + + result = job_manager.cancel_job("job123") + + assert result is False + mock_user_service.refund_credit.assert_not_called() + + +class TestCreditRefundOnJobDeletion: + """Test credit refund when jobs are deleted.""" + + def test_credit_refunded_on_delete_pending_job( + self, job_manager, mock_firestore_service, mock_user_service + ): + """Credit is refunded when a pending job is deleted.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.PENDING + mock_job.output_files = {} + mock_firestore_service.get_job.return_value = mock_job + mock_user_service.refund_credit.return_value = (True, 1, "Refunded") + + with patch('backend.services.auth_service.is_admin_email', return_value=False): + job_manager.delete_job("job123") + + mock_user_service.refund_credit.assert_called_once_with( + "user@test.com", "job123", reason="job_deleted" + ) + + def test_no_refund_on_delete_completed_job( + self, job_manager, mock_firestore_service, mock_user_service + ): + """No refund when deleting a completed job (user got their video).""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.COMPLETE + mock_job.output_files = {} + mock_firestore_service.get_job.return_value = mock_job + + job_manager.delete_job("job123") + + mock_user_service.refund_credit.assert_not_called() + + def test_no_refund_on_delete_prep_complete_job( + self, job_manager, mock_firestore_service, mock_user_service + ): + """No refund when deleting a prep-complete job.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.PREP_COMPLETE + mock_job.output_files = {} + mock_firestore_service.get_job.return_value = mock_job + + job_manager.delete_job("job123") + + mock_user_service.refund_credit.assert_not_called() + + def test_no_double_refund_on_delete_failed_job( + self, job_manager, mock_firestore_service, mock_user_service + ): + """No refund when deleting a failed job (already refunded on failure).""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = True + mock_job.status = JobStatus.FAILED + mock_job.output_files = {} + mock_firestore_service.get_job.return_value = mock_job + + job_manager.delete_job("job123") + + mock_user_service.refund_credit.assert_not_called() + + def test_no_double_refund_on_delete_cancelled_job( + self, job_manager, mock_firestore_service, mock_user_service + ): + """No refund when deleting a cancelled job (already refunded on cancel).""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = True + mock_job.status = JobStatus.CANCELLED + mock_job.output_files = {} + mock_firestore_service.get_job.return_value = mock_job + + job_manager.delete_job("job123") + + mock_user_service.refund_credit.assert_not_called() + + def test_delete_refund_failure_does_not_block_deletion( + self, job_manager, mock_firestore_service, mock_user_service + ): + """If refund fails, the job is still deleted.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "user@test.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.PENDING + mock_job.output_files = {} + mock_firestore_service.get_job.return_value = mock_job + mock_user_service.refund_credit.side_effect = Exception("Firestore error") + + with patch('backend.services.auth_service.is_admin_email', return_value=False): + job_manager.delete_job("job123") + + # Job should still be deleted despite refund failure + mock_firestore_service.delete_job.assert_called_once_with("job123") + + def test_delete_skips_refund_for_admin_jobs( + self, job_manager, mock_firestore_service, mock_user_service + ): + """No refund when admin deletes their own job.""" + mock_job = Mock(spec=Job) + mock_job.user_email = "admin@nomadkaraoke.com" + mock_job.credit_refunded = False + mock_job.status = JobStatus.PENDING + mock_job.output_files = {} + mock_firestore_service.get_job.return_value = mock_job + + with patch('backend.services.auth_service.is_admin_email', return_value=True): + job_manager.delete_job("job123") + + mock_user_service.refund_credit.assert_not_called() + class TestCreditAndRateLimitOrdering: """Test interaction between rate limit and credit checks.""" diff --git a/frontend/components/__tests__/JobActions.test.tsx b/frontend/components/__tests__/JobActions.test.tsx index 06f90d3a..ecffe29d 100644 --- a/frontend/components/__tests__/JobActions.test.tsx +++ b/frontend/components/__tests__/JobActions.test.tsx @@ -11,7 +11,17 @@ jest.mock('@/lib/api', () => ({ api: { retryJob: jest.fn(), deleteJob: jest.fn(), - } + }, + getAccessToken: jest.fn(), +})) + +// Mock the auth module +jest.mock('@/lib/auth', () => ({ + useAuth: Object.assign(jest.fn(() => ({ + fetchUser: jest.fn(), + })), { + getState: jest.fn(() => ({ user: { credits: 5 } })), + }), })) describe('JobActions', () => { diff --git a/frontend/components/job/JobActions.tsx b/frontend/components/job/JobActions.tsx index 46344d03..35bb2fe6 100644 --- a/frontend/components/job/JobActions.tsx +++ b/frontend/components/job/JobActions.tsx @@ -2,6 +2,7 @@ import { useState } from "react" import { Job, api } from "@/lib/api" +import { useAuth } from "@/lib/auth" import { Button } from "@/components/ui/button" import { useToast } from "@/hooks/use-toast" import { @@ -17,6 +18,7 @@ export function JobActions({ job, onRefresh }: JobActionsProps) { const [isRetrying, setIsRetrying] = useState(false) const [isDeleting, setIsDeleting] = useState(false) const { toast } = useToast() + const { fetchUser } = useAuth() const canRetry = job.status === "failed" const canDelete = !["complete", "failed", "prep_complete"].includes(job.status) @@ -52,13 +54,26 @@ export function JobActions({ job, onRefresh }: JobActionsProps) { async function handleDelete() { if (!confirm("Are you sure you want to permanently cancel and delete this job? This cannot be undone.")) return + // Statuses where the backend does NOT refund credits + const noRefundStatuses = ["complete", "prep_complete", "failed", "cancelled"] + const willRefund = !noRefundStatuses.includes(job.status) + setIsDeleting(true) try { await api.deleteJob(job.job_id) - toast({ - title: "Job deleted", - description: "The job has been permanently deleted.", - }) + if (willRefund) { + await fetchUser() + const remaining = useAuth.getState().user?.credits ?? 0 + toast({ + title: "Credit refunded", + description: `1 credit returned to your account. ${remaining} remaining.`, + }) + } else { + toast({ + title: "Job deleted", + description: "The job has been permanently deleted.", + }) + } onRefresh() } catch (error: any) { console.error("Failed to delete job:", error) diff --git a/frontend/components/job/JobSubmission.tsx b/frontend/components/job/JobSubmission.tsx index 57ee1827..4f4cc078 100644 --- a/frontend/components/job/JobSubmission.tsx +++ b/frontend/components/job/JobSubmission.tsx @@ -13,14 +13,16 @@ import { Label } from "@/components/ui/label" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Upload, Youtube, Music, Loader2, ChevronDown, ChevronRight, AlertTriangle } from "lucide-react" import { BuyCreditsDialog } from "@/components/credits/BuyCreditsDialog" +import { useToast } from "@/hooks/use-toast" interface JobSubmissionProps { onJobCreated: () => void } export function JobSubmission({ onJobCreated }: JobSubmissionProps) { - const { user } = useAuth() + const { user, fetchUser } = useAuth() const { features, isDefault, tenant } = useTenant() + const { toast } = useToast() const isAdmin = user?.role === "admin" // Determine which tabs are available based on tenant features @@ -78,6 +80,15 @@ export function JobSubmission({ onJobCreated }: JobSubmissionProps) { // Credit enforcement const noCredits = !isAdmin && user?.credits === 0 + async function showCreditDeductedToast() { + await fetchUser() + const remaining = useAuth.getState().user?.credits ?? 0 + toast({ + title: "Credit used", + description: `1 credit deducted. ${remaining} remaining.`, + }) + } + // --- Autocomplete helpers --- const fetchArtistSuggestions = useCallback(async (query: string): Promise => { @@ -171,6 +182,7 @@ export function JobSubmission({ onJobCreated }: JobSubmissionProps) { setUploadArtist("") setUploadTitle("") onJobCreated() + showCreditDeductedToast() } catch (err) { if (err instanceof ApiError && err.status === 402) { setIsCreditError(true) @@ -213,6 +225,7 @@ export function JobSubmission({ onJobCreated }: JobSubmissionProps) { setYoutubeArtist("") setYoutubeTitle("") onJobCreated() + showCreditDeductedToast() } catch (err) { if (err instanceof ApiError && err.status === 402) { setIsCreditError(true) @@ -250,6 +263,7 @@ export function JobSubmission({ onJobCreated }: JobSubmissionProps) { setDisplayArtist("") setDisplayTitle("") onJobCreated() + showCreditDeductedToast() } catch (err) { if (err instanceof ApiError && err.status === 402) { setIsCreditError(true) diff --git a/pyproject.toml b/pyproject.toml index 69cb3e97..c1c6bd80 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "karaoke-gen" -version = "0.126.2" +version = "0.128.0" description = "Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens." authors = ["Andrew Beveridge "] license = "MIT"