feat: add FastAPI admin dashboard with sync orchestration and test suite

Replace Flask admin with FastAPI app (api/app/) featuring:
- Dashboard with stat cards, sync control, and history
- Mappings CRUD for ARTICOLE_TERTI with CSV import/export
- Article autocomplete from NOM_ARTICOLE
- SKU pre-validation before import
- Sync orchestration: read JSONs -> validate -> import -> log to SQLite
- APScheduler for periodic sync from UI
- File logging to logs/sync_comenzi_YYYYMMDD_HHMMSS.log
- Oracle pool None guard (503 vs 500 on unavailable)

Test suite:
- test_app_basic.py: 30 tests (imports + routes) without Oracle
- test_integration.py: 9 integration tests with Oracle

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

api/app/services/sync_service.py

@@ -0,0 +1,165 @@
+import asyncio
+import logging
+import uuid
+from datetime import datetime
+
+from . import order_reader, validation_service, import_service, sqlite_service
+
+logger = logging.getLogger(__name__)
+
+# Sync state
+_sync_lock = asyncio.Lock()
+_current_sync = None  # dict with run_id, status, progress info
+
+
+async def get_sync_status():
+    """Get current sync status."""
+    if _current_sync:
+        return {**_current_sync}
+    return {"status": "idle"}
+
+
+async def run_sync(id_pol: int = None, id_sectie: int = None) -> dict:
+    """Run a full sync cycle. Returns summary dict."""
+    global _current_sync
+
+    if _sync_lock.locked():
+        return {"error": "Sync already running"}
+
+    async with _sync_lock:
+        run_id = datetime.now().strftime("%Y%m%d_%H%M%S") + "_" + uuid.uuid4().hex[:6]
+        _current_sync = {
+            "run_id": run_id,
+            "status": "running",
+            "started_at": datetime.now().isoformat(),
+            "progress": "Reading JSON files..."
+        }
+
+        try:
+            # Step 1: Read orders
+            orders, json_count = order_reader.read_json_orders()
+            await sqlite_service.create_sync_run(run_id, json_count)
+
+            if not orders:
+                await sqlite_service.update_sync_run(run_id, "completed", 0, 0, 0, 0)
+                _current_sync = None
+                return {
+                    "run_id": run_id,
+                    "status": "completed",
+                    "message": "No orders found",
+                    "json_files": json_count
+                }
+
+            _current_sync["progress"] = f"Validating {len(orders)} orders..."
+
+            # Step 2: Validate SKUs (blocking Oracle call -> run in thread)
+            all_skus = order_reader.get_all_skus(orders)
+            validation = await asyncio.to_thread(validation_service.validate_skus, all_skus)
+            importable, skipped = validation_service.classify_orders(orders, validation)
+
+            # Track missing SKUs
+            for sku in validation["missing"]:
+                product_name = ""
+                for order in orders:
+                    for item in order.items:
+                        if item.sku == sku:
+                            product_name = item.name
+                            break
+                    if product_name:
+                        break
+                await sqlite_service.track_missing_sku(sku, product_name)
+
+            # Step 3: Record skipped orders
+            for order, missing_skus in skipped:
+                customer = order.billing.company_name or \
+                    f"{order.billing.firstname} {order.billing.lastname}"
+                await sqlite_service.add_import_order(
+                    sync_run_id=run_id,
+                    order_number=order.number,
+                    order_date=order.date,
+                    customer_name=customer,
+                    status="SKIPPED",
+                    missing_skus=missing_skus,
+                    items_count=len(order.items)
+                )
+
+            # Step 4: Import valid orders
+            imported_count = 0
+            error_count = 0
+
+            for i, order in enumerate(importable):
+                _current_sync["progress"] = f"Importing {i+1}/{len(importable)}: #{order.number}"
+
+                result = await asyncio.to_thread(
+                    import_service.import_single_order,
+                    order, id_pol=id_pol, id_sectie=id_sectie
+                )
+                customer = order.billing.company_name or \
+                    f"{order.billing.firstname} {order.billing.lastname}"
+
+                if result["success"]:
+                    imported_count += 1
+                    await sqlite_service.add_import_order(
+                        sync_run_id=run_id,
+                        order_number=order.number,
+                        order_date=order.date,
+                        customer_name=customer,
+                        status="IMPORTED",
+                        id_comanda=result["id_comanda"],
+                        id_partener=result["id_partener"],
+                        items_count=len(order.items)
+                    )
+                else:
+                    error_count += 1
+                    await sqlite_service.add_import_order(
+                        sync_run_id=run_id,
+                        order_number=order.number,
+                        order_date=order.date,
+                        customer_name=customer,
+                        status="ERROR",
+                        id_partener=result.get("id_partener"),
+                        error_message=result["error"],
+                        items_count=len(order.items)
+                    )
+
+                # Safety: stop if too many errors
+                if error_count > 10:
+                    logger.warning("Too many errors, stopping sync")
+                    break
+
+            # Step 5: Update sync run
+            status = "completed" if error_count <= 10 else "failed"
+            await sqlite_service.update_sync_run(
+                run_id, status, len(orders), imported_count, len(skipped), error_count
+            )
+
+            summary = {
+                "run_id": run_id,
+                "status": status,
+                "json_files": json_count,
+                "total_orders": len(orders),
+                "imported": imported_count,
+                "skipped": len(skipped),
+                "errors": error_count,
+                "missing_skus": len(validation["missing"])
+            }
+
+            logger.info(
+                f"Sync {run_id} completed: {imported_count} imported, "
+                f"{len(skipped)} skipped, {error_count} errors"
+            )
+            return summary
+
+        except Exception as e:
+            logger.error(f"Sync {run_id} failed: {e}")
+            await sqlite_service.update_sync_run(run_id, "failed", 0, 0, 0, 1)
+            return {"run_id": run_id, "status": "failed", "error": str(e)}
+        finally:
+            _current_sync = None
+
+
+def stop_sync():
+    """Signal sync to stop. Currently sync runs to completion."""
+    # For now, sync runs are not cancellable mid-flight.
+    # Future: use an asyncio.Event for cooperative cancellation.
+    pass