feat: credit notifications and refund on job deletion (#474)

<!-- @coderabbitai ignore -->

## 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 <noreply@anthropic.com>
This commit is contained in:
Andrew Beveridge ☄️andClaude Opus 4.6 authored and GitHub committed 2026-03-04 14:18:10 -05:00
1 parent 7eecbe8382
commit 9f85ae4221
8 files changed
+430 -37

No files matched your search

@@ -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
+3
View File
@@ -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
+63 -28
View File
@@ -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,
+207 -2
View File
@@ -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."""
@@ -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', () => {
+19 -4
View File
@@ -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)
+15 -1
View File
@@ -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<AutocompleteSuggestion[]> => {
@@ -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)
+1 -1
View File
@@ -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 <andrew@beveridge.uk>"]
license = "MIT"