feat(data-entry): Bulk Receipt Upload cu Mobile UX Android Nativ

## Funcționalități Principale

### Bulk Upload & Processing
- Drag & drop pentru upload bonuri multiple oriunde pe pagină
- Batch processing cu job queue și worker pool
- Real-time updates via SSE (Server-Sent Events) cu fallback polling
- Duplicate detection via SHA-256 file hash
- Auto-retry pentru job-uri failed
- Cancel individual jobs sau batch complet

### Mobile UX - Android Native Style
- Top bar fixă cu hamburger, titlu centrat, acțiuni (search/filter)
- Bottom navigation cu 4 tab-uri (Bonuri, Upload, Rapoarte, Setări)
- FAB (Floating Action Button) cu hide/show on scroll
- Filter chips orizontal scrollabile
- Selecție multiplă prin long-press (500ms)
- Select All + Bulk Delete cu confirmare
- Layout Android pentru Create/Edit/View bon (Gmail compose style)

### Bug Fixes
- Refresh individual via SSE în loc de refresh total pagină
- Bonurile cu eroare OCR rămân vizibile pentru editare manuală
- Afișare nume fișier original pentru toate bonurile
- Upload stabil pe mobil (fix race condition File API)
- Păstrare ordine bonuri la refresh (nu se reordonează)

### Backend
- SSE endpoint pentru status updates real-time
- Bulk delete endpoint cu partial success
- Auto-cleanup bonuri failed după 7 zile
- Batch model cu tracking complet

### Testing
- E2E tests cu Playwright
- Unit tests pentru bulk upload, auto-create, cleanup

## Commits Squashed: 43 user stories (US-001 → US-043)
## Branch: ralph/bulk-receipt-upload
## Timp dezvoltare: ~3 zile (Ralph autonomous)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

backend/modules/data_entry/db/crud/receipt.py

@@ -147,13 +147,33 @@ class ReceiptCRUD:
                 )
             )
 
+        # Bulk upload filters (US-012)
+        # US-005: Support comma-separated values for processing_status filter (e.g., "pending,processing")
+        if filters.processing_status:
+            statuses = [s.strip() for s in filters.processing_status.split(",")]
+            if len(statuses) == 1:
+                query = query.where(Receipt.processing_status == statuses[0])
+            else:
+                query = query.where(Receipt.processing_status.in_(statuses))
+
+        if filters.batch_id:
+            query = query.where(Receipt.batch_id == filters.batch_id)
+
         # Count total
         count_query = select(func.count()).select_from(query.subquery())
         total_result = await session.execute(count_query)
         total = total_result.scalar() or 0
 
-        # Apply pagination and ordering
-        query = query.order_by(Receipt.created_at.desc())
+        # Apply ordering based on sort_by parameter (US-012)
+        if filters.sort_by == "processing_started_at":
+            query = query.order_by(Receipt.processing_started_at.desc())
+        elif filters.sort_by == "processing_started_at_asc":
+            query = query.order_by(Receipt.processing_started_at.asc())
+        else:
+            # Default ordering
+            query = query.order_by(Receipt.created_at.desc())
+
+        # Apply pagination
         offset = (filters.page - 1) * filters.page_size
         query = query.offset(offset).limit(filters.page_size)
 
@@ -163,6 +183,61 @@ class ReceiptCRUD:
 
         return list(receipts), total
 
+    @staticmethod
+    async def get_processing_stats(
+        session: AsyncSession,
+        company_id: Optional[int] = None,
+        batch_id: Optional[str] = None,
+    ) -> dict:
+        """Get processing status counts for bulk uploaded receipts (US-012)."""
+        # Build base query for counting by processing_status
+        base_conditions = []
+
+        if company_id:
+            base_conditions.append(Receipt.company_id == company_id)
+
+        if batch_id:
+            base_conditions.append(Receipt.batch_id == batch_id)
+
+        # Only count receipts that have a processing_status (bulk uploads)
+        base_conditions.append(Receipt.processing_status.isnot(None))
+
+        query = select(
+            Receipt.processing_status,
+            func.count(Receipt.id).label("count")
+        )
+
+        for condition in base_conditions:
+            query = query.where(condition)
+
+        query = query.group_by(Receipt.processing_status)
+
+        result = await session.execute(query)
+        rows = result.all()
+
+        # Initialize stats
+        stats = {
+            "pending_count": 0,
+            "processing_count": 0,
+            "completed_count": 0,
+            "failed_count": 0,
+        }
+
+        # Map results
+        for row in rows:
+            status = row.processing_status
+            count = row.count
+            if status == "pending":
+                stats["pending_count"] = count
+            elif status == "processing":
+                stats["processing_count"] = count
+            elif status == "completed":
+                stats["completed_count"] = count
+            elif status == "failed":
+                stats["failed_count"] = count
+
+        return stats
+
     @staticmethod
     async def get_pending_review(
         session: AsyncSession,

backend/modules/data_entry/db/models/__init__.py

@@ -1,8 +1,9 @@
 # Database models
-from .receipt import Receipt, ReceiptAttachment, ReceiptStatus, ReceiptType, ReceiptDirection
+from .receipt import Receipt, ReceiptAttachment, ReceiptStatus, ReceiptType, ReceiptDirection, ProcessingStatus
 from .accounting_entry import AccountingEntry, EntryType
 from .nomenclature import SyncedSupplier, LocalSupplier, SyncedCashRegister
 from .ocr_settings import UserOCRPreference, OCRJobMetrics, OCRMetricsSummary, OCREngine
+from .batch import BatchUpload, BatchJob, BatchStatus
 
 __all__ = [
     "Receipt",
@@ -10,6 +11,7 @@ __all__ = [
     "ReceiptStatus",
     "ReceiptType",
     "ReceiptDirection",
+    "ProcessingStatus",
     "AccountingEntry",
     "EntryType",
     "SyncedSupplier",
@@ -20,4 +22,8 @@ __all__ = [
     "OCRJobMetrics",
     "OCRMetricsSummary",
     "OCREngine",
+    # Batch Upload
+    "BatchUpload",
+    "BatchJob",
+    "BatchStatus",
 ]

backend/modules/data_entry/db/models/batch.py

@@ -0,0 +1,64 @@
+"""BatchUpload and BatchJob SQLModel models for bulk receipt processing."""
+
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from sqlmodel import SQLModel, Field
+
+
+class BatchStatus(str, Enum):
+    """Status of a batch upload."""
+    PENDING = "pending"          # Batch created, jobs queued
+    PROCESSING = "processing"    # At least one job is processing
+    COMPLETED = "completed"      # All jobs completed (success or failed)
+    FAILED = "failed"            # Batch-level failure (e.g., all jobs failed)
+
+
+class BatchUpload(SQLModel, table=True):
+    """
+    Batch upload record for grouping multiple OCR jobs.
+
+    Tracks overall progress and status of a bulk upload operation.
+    """
+
+    __tablename__ = "batch_uploads"
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+
+    # User info
+    user_id: str = Field(max_length=100, index=True)  # Username who created the batch
+    company_id: int = Field(index=True)  # Company ID for receipt creation
+
+    # Timestamps
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+    # Status tracking
+    status: BatchStatus = Field(default=BatchStatus.PENDING)
+    total_files: int = Field(default=0)
+
+
+class BatchJob(SQLModel, table=True):
+    """
+    Junction table linking batch_uploads to ocr_jobs.
+
+    Each record represents one file in a batch, linking to its OCR job.
+    Also stores the receipt_id once the job completes and auto-creates a receipt.
+    """
+
+    __tablename__ = "batch_jobs"
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+
+    # Foreign keys
+    batch_id: int = Field(foreign_key="batch_uploads.id", index=True)
+    job_id: str = Field(max_length=36, index=True)  # UUID from ocr_jobs table
+
+    # Original filename for display
+    filename: str = Field(max_length=255)
+
+    # Receipt reference (set after auto-create)
+    receipt_id: Optional[int] = Field(default=None, foreign_key="receipts.id")
+
+    # Timestamps
+    created_at: datetime = Field(default_factory=datetime.utcnow)

backend/modules/data_entry/db/models/receipt.py

@@ -36,6 +36,14 @@ class PaymentMode(str, Enum):
     AVANS_DECONTARE = "avans_decontare"  # Decont angajat (542)
 
 
+class ProcessingStatus(str, Enum):
+    """Processing status for bulk uploaded receipts."""
+    PENDING = "pending"          # Waiting in queue
+    PROCESSING = "processing"    # Currently being processed by OCR
+    COMPLETED = "completed"      # Successfully processed
+    FAILED = "failed"            # Processing failed with error
+
+
 if TYPE_CHECKING:
     from .accounting_entry import AccountingEntry
 
@@ -96,6 +104,14 @@ class Receipt(SQLModel, table=True):
     oracle_act_id: Optional[int] = Field(default=None)
     oracle_error: Optional[str] = Field(default=None, max_length=500)
 
+    # Bulk upload batch tracking
+    batch_id: Optional[str] = Field(default=None, max_length=50, index=True)
+    processing_status: Optional[str] = Field(default=None, max_length=20, index=True)  # ProcessingStatus enum value
+    processing_error: Optional[str] = Field(default=None)  # Full error message text
+    file_hash: Optional[str] = Field(default=None, max_length=64, index=True)  # SHA-256 hash for duplicate detection
+    processing_started_at: Optional[datetime] = Field(default=None)
+    processing_completed_at: Optional[datetime] = Field(default=None)
+
     # Relationships
     attachments: List["ReceiptAttachment"] = Relationship(
         back_populates="receipt",