feat: Add JWT auth and nomenclature sync to data-entry-app

Integrate shared JWT authentication into data-entry-app:
- Add Oracle pool initialization for auth service
- Add AuthenticationMiddleware to protect API routes
- Update all receipt endpoints to use CurrentUser from JWT
- Add shared auth router (/api/auth/login, /api/auth/refresh)

Add nomenclature synchronization feature:
- Create SQLite models for synced suppliers, local suppliers, and cash registers
- Add nomenclature router with sync triggers and CRUD endpoints
- Add sync service for Oracle → SQLite nomenclature data
- Update nomenclature_service to use synced SQLite data with fallbacks

Create shared frontend components:
- Add shared/frontend/ with LoginView.vue, auth store factory, login.css
- Integrate shared login and auth into data-entry-app frontend
- Add axios-based API service with token refresh interceptor

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

data-entry-app/backend/app/services/nomenclature_service.py

@@ -3,6 +3,9 @@
 from typing import List, Optional
 from decimal import Decimal
 
+from sqlmodel import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
 from app.schemas.receipt import (
     PartnerOption,
     AccountOption,
@@ -10,6 +13,7 @@ from app.schemas.receipt import (
     ExpenseTypeOption,
 )
 from app.services.expense_types import EXPENSE_TYPES
+from app.db.models.nomenclature import SyncedSupplier, LocalSupplier, SyncedCashRegister
 
 
 class NomenclatureService:
@@ -21,15 +25,55 @@ class NomenclatureService:
     """
 
     @staticmethod
-    async def get_partners(company_id: int, search: Optional[str] = None) -> List[PartnerOption]:
+    async def get_partners(
+        company_id: int,
+        search: Optional[str] = None,
+        session: Optional[AsyncSession] = None
+    ) -> List[PartnerOption]:
         """
         Get partners (suppliers/customers) for a company.
 
-        Phase 1: Returns empty list or mock data.
-        Phase 2: Will fetch from Oracle NOM_PARTENERI.
+        Phase 1: Returns mock data.
+        Phase 2: Returns synced data from SQLite (from Oracle sync).
+        Phase 3: Will fetch live from Oracle.
         """
-        # TODO: Implement Oracle fetch in Phase 2
-        # For now, return some mock data for testing
+        # If session is provided, try to get from synced SQLite data
+        if session:
+            # Try to get from SQLite synced data
+            stmt = select(SyncedSupplier).where(SyncedSupplier.company_id == company_id)
+            if search:
+                stmt = stmt.where(
+                    (SyncedSupplier.name.ilike(f"%{search}%")) |
+                    (SyncedSupplier.fiscal_code.ilike(f"%{search}%"))
+                )
+            stmt = stmt.limit(50)  # Limit results
+
+            result = await session.execute(stmt)
+            suppliers = result.scalars().all()
+
+            if suppliers:
+                # Also get local suppliers
+                local_stmt = select(LocalSupplier).where(LocalSupplier.company_id == company_id)
+                if search:
+                    local_stmt = local_stmt.where(
+                        (LocalSupplier.name.ilike(f"%{search}%")) |
+                        (LocalSupplier.fiscal_code.ilike(f"%{search}%"))
+                    )
+                local_stmt = local_stmt.limit(50)
+
+                local_result = await session.execute(local_stmt)
+                local_suppliers = local_result.scalars().all()
+
+                # Combine both
+                partners = []
+                for s in suppliers:
+                    partners.append(PartnerOption(id=s.id, name=s.name, code=s.fiscal_code))
+                for l in local_suppliers:
+                    partners.append(PartnerOption(id=l.id, name=f"{l.name} (local)", code=l.fiscal_code))
+
+                return partners
+
+        # Fallback to mock data for Phase 1
         mock_partners = [
             PartnerOption(id=1, name="OMV Petrom", code="RO123456"),
             PartnerOption(id=2, name="Dedeman", code="RO789012"),
@@ -83,14 +127,30 @@ class NomenclatureService:
         return accounts
 
     @staticmethod
-    async def get_cash_registers(company_id: int) -> List[CashRegisterOption]:
+    async def get_cash_registers(
+        company_id: int,
+        session: Optional[AsyncSession] = None
+    ) -> List[CashRegisterOption]:
         """
         Get cash registers and bank accounts for a company.
 
         Phase 1: Returns default options.
-        Phase 2: Will fetch from Oracle NOM_CASE / NOM_BANCI.
+        Phase 2: Returns synced data from SQLite (from Oracle sync).
+        Phase 3: Will fetch live from Oracle NOM_CASE / NOM_BANCI.
         """
-        # Default cash registers
+        # If session is provided, try to get from synced SQLite data
+        if session:
+            stmt = select(SyncedCashRegister).where(SyncedCashRegister.company_id == company_id)
+            result = await session.execute(stmt)
+            registers = result.scalars().all()
+
+            if registers:
+                return [
+                    CashRegisterOption(id=r.id, name=r.name, account_code=r.account_code)
+                    for r in registers
+                ]
+
+        # Fallback to default cash registers for Phase 1
         return [
             CashRegisterOption(id=1, name="Casa principala", account_code="5311"),
             CashRegisterOption(id=2, name="Cont BCR", account_code="5121"),