+ {/* DB freshness status */}
+ {sirutaValid && dbLayersSummary.length > 0 && (
+
+
+
+
+
+ {dbTotalFeatures.toLocaleString("ro-RO")}
+ {" "}
+ entit\u0103\u021bi \u00een DB din{" "}
+
+ {dbLayersSummary.length}
+ {" "}
+ layere
+
+ {(() => {
+ const freshCount = dbLayersSummary.filter(
+ (l) => l.isFresh,
+ ).length;
+ const staleCount = dbLayersSummary.length - freshCount;
+ const oldestSync = dbLayersSummary.reduce(
+ (oldest, l) => {
+ if (!l.lastSynced) return oldest;
+ if (!oldest || l.lastSynced < oldest) return l.lastSynced;
+ return oldest;
+ },
+ null as Date | null,
+ );
+ return (
+ <>
+ {staleCount === 0 ? (
+
+
+ ) : (
+
+
+ )}
+ {oldestSync && (
+
+ Ultima sincronizare: {relativeTime(oldestSync)}
+
+ )}
+
+ );
+ })()}
+
+
+
+ )}
+
+ {/* Hero buttons */}
+ {sirutaValid && session.connected ? (
+
+
void handleExportBundle("base")}
+ >
+ {exporting && exportProgress?.phase !== "Detalii parcele" ? (
+
+
+ Descarc\u0103 Terenuri \u0219i Cl\u0103diri
+
+
+ Sync + GPKG (din cache dac\u0103 e proasp\u0103t)
+
+
+
+
void handleExportBundle("magic")}
+ >
+ {exporting && exportProgress?.phase === "Detalii parcele" ? (
+
+
Magic
+
+ Sync + \u00eembog\u0103\u021bire (CF, proprietari, adres\u0103) + GPKG + CSV
+
+
+
+ ) : (
+
+
+ {!session.connected ? (
+ <>
+ Conecteaz\u0103-te la eTerra pentru a activa exportul.
+
+ ) : (
+ <>
+ Selecteaz\u0103 un UAT pentru a activa exportul.
+
+ )}
+
+
+ )}
+
+ {/* No-geometry option — shown after auto-scan completes */}
+ {sirutaValid &&
+ session.connected &&
+ (() => {
+ const scanDone = noGeomScan !== null && noGeomScanSiruta === siruta;
+ const estimatedNoGeom = scanDone
+ ? Math.max(
+ 0,
+ noGeomScan.totalImmovables - noGeomScan.remoteGisCount,
+ )
+ : 0;
+ const hasNoGeomParcels = scanDone && estimatedNoGeom > 0;
+ const scanning = noGeomScanning;
+
+ // Still scanning
+ if (scanning)
+ return (
+
+
+
+
+
+ Po\u021bi folosi butoanele de mai jos f\u0103r\u0103 s\u0103 a\u0219tep\u021bi scanarea.
+
+
+
+ );
+
+ // Scan timed out
+ if (scanDone && noGeomScan.scannedAt === "timeout")
+ return (
+
+
+
+
+
+ Po\u021bi lansa sincronizarea fundal f\u0103r\u0103 rezultate de scanare.
+ Include no-geom nu va fi disponibil.
+
+ void handleNoGeomScan()}
+ >
+
+
+
+ );
+
+ // Helper: local DB status line
+ const staleEnrichment =
+ scanDone &&
+ noGeomScan.localDbEnriched > 0 &&
+ noGeomScan.localDbEnrichedComplete < noGeomScan.localDbEnriched;
+ const staleCount = scanDone
+ ? noGeomScan.localDbEnriched - noGeomScan.localDbEnrichedComplete
+ : 0;
+
+ const localDbLine = scanDone && noGeomScan.localDbTotal > 0 && (
+
+
+
+ Baza de date local\u0103:{" "}
+
+ {noGeomScan.localDbWithGeom.toLocaleString("ro-RO")}
+ {" "}
+ cu geometrie
+ {noGeomScan.localDbNoGeom > 0 && (
+ <>
+ {" + "}
+
+ {noGeomScan.localDbNoGeom.toLocaleString("ro-RO")}
+ {" "}
+ f\u0103r\u0103 geometrie
+
+ )}
+ {noGeomScan.localDbEnriched > 0 && (
+ <>
+ {" \u00b7 "}
+
+ {noGeomScan.localDbEnriched.toLocaleString("ro-RO")}
+ {" "}
+ \u00eembog\u0103\u021bite
+ {staleEnrichment && (
+
+ {" "}
+ ({staleCount.toLocaleString("ro-RO")} incomplete)
+
+ )}
+
+ )}
+ {noGeomScan.localSyncFresh && (
+
+ (proasp\u0103t)
+
+ )}
+
+
+ {staleEnrichment && (
+
+
+
+ {staleCount.toLocaleString("ro-RO")} parcele au \u00eembog\u0103\u021bire
+ veche (lips\u0103 PROPRIETARI_VECHI). Vor fi re-\u00eembog\u0103\u021bite la
+ urm\u0103torul export Magic.
+
+
+ )}
+
+ );
+
+ // Helper: workflow preview (what Magic will do)
+ const workflowPreview = scanDone && (
+
+
+ La ap\u0103sarea Magic, pa\u0219ii vor fi:
+
+
+
+ {"Sync GIS \u2014 "}
+ 0
+ ? "text-emerald-600 dark:text-emerald-400"
+ : "text-foreground",
+ )}
+ >
+ {noGeomScan.localSyncFresh &&
+ noGeomScan.localDbWithGeom > 0
+ ? "skip (date proaspete \u00een DB)"
+ : `descarc\u0103 ${noGeomScan.remoteGisCount.toLocaleString("ro-RO")} terenuri` +
+ (noGeomScan.remoteCladiriCount > 0
+ ? ` + ${noGeomScan.remoteCladiriCount.toLocaleString("ro-RO")} cl\u0103diri`
+ : "")}
+
+
+ {includeNoGeom && (
+
+ Import parcele f\u0103r\u0103 geometrie \u2014{" "}
+
+ {(() => {
+ const usefulNoGeom =
+ noGeomScan.qualityBreakdown.useful;
+ const newNoGeom = Math.max(
+ 0,
+ usefulNoGeom - noGeomScan.localDbNoGeom,
+ );
+ const filtered = noGeomScan.qualityBreakdown.empty;
+ return newNoGeom > 0
+ ? `~${newNoGeom.toLocaleString("ro-RO")} noi de importat` +
+ (filtered > 0
+ ? ` (${filtered.toLocaleString("ro-RO")} filtrate)`
+ : "")
+ : "deja importate";
+ })()}
+
+
+ )}
+
+ \u00cembog\u0103\u021bire CF, proprietari, adrese \u2014{" "}
+
+ {(() => {
+ // What will be in DB after sync + optional no-geom import:
+ // If DB is empty: sync will add remoteGisCount geo features
+ // If DB is fresh: keep localDbTotal
+ const geoAfterSync =
+ noGeomScan.localSyncFresh &&
+ noGeomScan.localDbWithGeom > 0
+ ? noGeomScan.localDbWithGeom
+ : noGeomScan.remoteGisCount;
+ const noGeomAfterImport = includeNoGeom
+ ? Math.max(
+ noGeomScan.localDbNoGeom,
+ noGeomScan.qualityBreakdown.useful,
+ )
+ : noGeomScan.localDbNoGeom;
+ const totalAfter = geoAfterSync + noGeomAfterImport;
+ const remaining =
+ totalAfter - noGeomScan.localDbEnrichedComplete;
+ return remaining > 0
+ ? `~${remaining.toLocaleString("ro-RO")} de procesat (~${Math.ceil((remaining * 0.25) / 60)} min)`
+ : "deja \u00eembog\u0103\u021bite";
+ })()}
+
+
+ Generare GPKG + CSV
+ Comprimare ZIP + desc\u0103rcare
+
+
+ );
+
+ // No-geometry parcels found
+ if (hasNoGeomParcels)
+ return (
+
+
+
+
+
+
+ Layer GIS:{" "}
+
+ {noGeomScan.remoteGisCount.toLocaleString("ro-RO")}
+ {" "}
+ terenuri
+ {noGeomScan.remoteCladiriCount > 0 && (
+ <>
+ {" + "}
+
+ {noGeomScan.remoteCladiriCount.toLocaleString(
+ "ro-RO",
+ )}
+ {" "}
+ cl\u0103diri
+
+ )}
+ {" \u00b7 "}
+ Lista imobile:{" "}
+
+ {noGeomScan.totalImmovables.toLocaleString("ro-RO")}
+
+ {" (estimat "}
+
+ ~
+ {Math.max(
+ 0,
+ noGeomScan.totalImmovables -
+ noGeomScan.remoteGisCount,
+ ).toLocaleString("ro-RO")}
+
+ {" f\u0103r\u0103 geometrie)"}
+
+
+ Cele f\u0103r\u0103 geometrie exist\u0103 \u00een baza de date eTerra dar
+ nu au contur desenat \u00een layerul GIS.
+
+ {localDbLine}
+
+
void handleNoGeomScan()}
+ title="Re-scanare"
+ >
+
+
+
+ Include \u0219i parcelele f\u0103r\u0103 geometrie la export
+
+
+ {/* Quality breakdown of no-geom items */}
+ {scanDone && noGeomScan.noGeomCount > 0 && (
+
+
+ Calitate date (din{" "}
+ {noGeomScan.noGeomCount.toLocaleString("ro-RO")} f\u0103r\u0103
+ geometrie):
+
+
+
+ Cu nr. cadastral eTerra:{" "}
+
+ {noGeomScan.qualityBreakdown.withCadRef.toLocaleString(
+ "ro-RO",
+ )}
+
+
+
+ Cu nr. CF/LB:{" "}
+
+ {noGeomScan.qualityBreakdown.withPaperLb.toLocaleString(
+ "ro-RO",
+ )}
+
+
+
+ Cu nr. cad. pe h\u00e2rtie:{" "}
+
+ {noGeomScan.qualityBreakdown.withPaperCad.toLocaleString(
+ "ro-RO",
+ )}
+
+
+
+ Cu suprafa\u021b\u0103:{" "}
+
+ {noGeomScan.qualityBreakdown.withArea.toLocaleString(
+ "ro-RO",
+ )}
+
+
+
+ Active (status=1):{" "}
+
+ {noGeomScan.qualityBreakdown.withActiveStatus.toLocaleString(
+ "ro-RO",
+ )}
+
+
+
+ Cu carte funciar\u0103:{" "}
+
+ {noGeomScan.qualityBreakdown.withLandbook.toLocaleString(
+ "ro-RO",
+ )}
+
+
+
+
+
+ Utilizabile:{" "}
+
+ {noGeomScan.qualityBreakdown.useful.toLocaleString(
+ "ro-RO",
+ )}
+
+
+ {noGeomScan.qualityBreakdown.empty > 0 && (
+
+ Filtrate (f\u0103r\u0103 CF/inactive/f\u0103r\u0103 date):{" "}
+
+ {noGeomScan.qualityBreakdown.empty.toLocaleString(
+ "ro-RO",
+ )}
+
+
+ )}
+
+
+ {noGeomScan.qualityBreakdown.empty > 0
+ ? `Din ${noGeomScan.noGeomCount.toLocaleString("ro-RO")} f\u0103r\u0103 geometrie, ~${noGeomScan.qualityBreakdown.useful.toLocaleString("ro-RO")} vor fi importate (imobile electronice cu CF). ${noGeomScan.qualityBreakdown.empty.toLocaleString("ro-RO")} vor fi filtrate (f\u0103r\u0103 carte funciar\u0103, inactive sau f\u0103r\u0103 date).`
+ : "Vor fi importate \u00een DB \u0219i incluse \u00een CSV + Magic GPKG (coloana HAS_GEOMETRY=0/1)."}{" "}
+ \u00cen GPKG de baz\u0103 apar doar cele cu geometrie.
+
+ )}
+ {workflowPreview}
+
+
+ );
+
+ // Scan done, all parcels have geometry (or totalImmovables=0 => workspace issue)
+ if (scanDone && !hasNoGeomParcels)
+ return (
+
+
+
+ {noGeomScan.totalImmovables > 0 ? (
+ <>
+
+ Toate cele{" "}
+ {noGeomScan.totalImmovables.toLocaleString("ro-RO")}{" "}
+ imobile din eTerra au geometrie \u2014 nimic de importat
+ suplimentar.
+ {noGeomScan.localDbTotal > 0 && (
+
+ ({noGeomScan.localDbTotal.toLocaleString("ro-RO")}{" "}
+ \u00een DB local
+ {noGeomScan.localDbEnriched > 0 &&
+ `, ${noGeomScan.localDbEnriched.toLocaleString("ro-RO")} \u00eembog\u0103\u021bite`}
+ {noGeomScan.localDbEnriched > 0 &&
+ noGeomScan.localDbEnrichedComplete <
+ noGeomScan.localDbEnriched && (
+
+ {` (${(noGeomScan.localDbEnriched - noGeomScan.localDbEnrichedComplete).toLocaleString("ro-RO")} incomplete)`}
+
+ )}
+ {noGeomScan.localSyncFresh && ", proasp\u0103t"})
+
+ )}
+
+ ) : (
+ <>
+
+ Nu s-au g\u0103sit imobile \u00een lista eTerra pentru acest
+ UAT. Verific\u0103 sesiunea eTerra.
+
+ )}
+
+
+ );
+
+ return null;
+ })()}
+
+ {/* ── Background sync + Download from DB ──────────────── */}
+ {sirutaValid && (
+
+
+ {/* Row 1: Section label */}
+
+
+ Procesare fundal & desc\u0103rcare din DB
+
+
+ \u2014 porne\u0219te sincronizarea, \u00eenchide pagina, descarc\u0103 mai t\u00e2rziu
+
+
+
+ {/* Include no-geom toggle (works independently of scan) */}
+ {session.connected && (
+
+
+ Include \u0219i parcelele f\u0103r\u0103 geometrie
+
+ {noGeomScanning && (
+
+ (scanare \u00een curs\u2026)
+
+ )}
+
+ )}
+
+ {/* Row 2: Background sync buttons */}
+ {session.connected && (
+
+
void handleSyncBackground("base")}
+ >
+ {bgJobId &&
+ bgProgress?.status === "running" &&
+ !bgPhaseTrail.some((p) => p.includes("\u00cembog\u0103\u021bire")) ? (
+
+
+ Sync fundal \u2014 Baz\u0103
+
+
+ Terenuri + cl\u0103diri \u2192 salveaz\u0103 \u00een DB
+
+
+
void handleSyncBackground("magic")}
+ >
+ {bgJobId &&
+ bgProgress?.status === "running" &&
+ bgPhaseTrail.some((p) => p.includes("\u00cembog\u0103\u021bire")) ? (
+
+
+ Sync fundal \u2014 Magic
+
+
+ Sync + \u00eembog\u0103\u021bire \u2192 salveaz\u0103 \u00een DB
+
+
+
+
void handleDownloadFromDb("base")}
+ >
+ {downloadingFromDb ? (
+
+
+ Descarc\u0103 din DB \u2014 Baz\u0103
+
+
+ GPKG terenuri + cl\u0103diri (instant, f\u0103r\u0103 eTerra)
+
+
+
void handleDownloadFromDb("magic")}
+ >
+ {downloadingFromDb ? (
+
+
+ Descarc\u0103 din DB \u2014 Magic
+
+
+ GPKG + CSV + raport calitate (instant)
+
+
+
+ Conecteaz\u0103-te la eTerra pentru a porni sincronizarea fundal,
+ sau sincronizeaz\u0103 mai \u00eent\u00e2i date \u00een baza local\u0103.
+
+ )}
+
+
+ )}
+
+ {/* Background sync progress */}
+ {bgJobId && bgProgress && bgProgress.status !== "unknown" && (
+
+
+ {/* Label */}
+
+
+ Sincronizare fundal
+
+ {bgProgress.status === "running" && (
+
+ (po\u021bi \u00eenchide pagina)
+
+ )}
+
+
+ {/* Phase trail */}
+
+ {bgPhaseTrail.map((p, i) => (
+
+ {i > 0 && \u2192 }
+
+ {p}
+
+
+ ))}
+
+
+ {/* Progress info */}
+
+ {bgProgress.status === "running" && (
+
+ )}
+ {bgProgress.status === "done" && (
+
+ )}
+ {bgProgress.status === "error" && (
+
+ )}
+
+
{bgProgress.phase}
+ {bgProgress.note && (
+
+ {bgProgress.note}
+
+ )}
+ {bgProgress.message && (
+
+ {bgProgress.message}
+
+ )}
+
+
+ {bgProgress.total && bgProgress.total > 0
+ ? Math.round(
+ (bgProgress.downloaded / bgProgress.total) * 100,
+ )
+ : 0}
+ %
+
+
+
0 ? Math.round((bgProgress.downloaded / bgProgress.total) * 100) : 0)}%`,
+ }}
+ />
+
+
+ {/* Done — show download from DB button */}
+ {bgProgress.status === "done" && (
+
+ void handleDownloadFromDb("magic")}
+ >
+ {downloadingFromDb ? (
+
+ {
+ setBgJobId(null);
+ setBgProgress(null);
+ setBgPhaseTrail([]);
+ }}
+ >
+ \u00cenchide
+
+
+ )}
+
+
+ )}
+
+ {/* Progress bar for bundle export */}
+ {exportProgress &&
+ exportProgress.status !== "unknown" &&
+ exportJobId && (
+
+
+ {/* Phase trail */}
+
+ {phaseTrail.map((p, i) => (
+
+ {i > 0 && \u2192 }
+
+ {p}
+
+
+ ))}
+
+
+ {/* Progress info */}
+
+ {exportProgress.status === "running" && (
+
+ )}
+ {exportProgress.status === "done" && (
+
+ )}
+ {exportProgress.status === "error" && (
+
+ )}
+
+
+ {exportProgress.phase}
+ {exportProgress.phaseCurrent != null &&
+ exportProgress.phaseTotal
+ ? ` \u2014 ${exportProgress.phaseCurrent} / ${exportProgress.phaseTotal}`
+ : ""}
+
+ {exportProgress.note && (
+
+ {exportProgress.note}
+
+ )}
+ {exportProgress.message && (
+
+ {exportProgress.message}
+
+ )}
+
+
+ {progressPct}%
+
+
+
+ )}
+
;
+ syncRuns: SyncRunInfo[];
+ syncingSiruta: string;
+ onSyncRefresh: () => void;
+ exporting: boolean;
+};
+
+/* ------------------------------------------------------------------ */
+/* Component */
+/* ------------------------------------------------------------------ */
+
+export function LayersTab({
+ siruta,
+ sirutaValid,
+ session,
+ syncLocalCounts,
+ syncRuns,
+ syncingSiruta,
+ onSyncRefresh,
+ exporting,
+}: LayersTabProps) {
+ /* ── Local state ──────────────────────────────────────────────── */
+ const [expandedCategories, setExpandedCategories] = useState<
+ Record
+ >({});
+ const [downloadingLayer, setDownloadingLayer] = useState(null);
+ const [layerCounts, setLayerCounts] = useState<
+ Record
+ >({});
+ const [countingLayers, setCountingLayers] = useState(false);
+ const [layerCountSiruta, setLayerCountSiruta] = useState("");
+ const [layerHistory, setLayerHistory] = useState<
+ {
+ layerId: string;
+ label: string;
+ count: number;
+ time: string;
+ siruta: string;
+ }[]
+ >([]);
+ const [syncingLayer, setSyncingLayer] = useState(null);
+ const [syncProgress, setSyncProgress] = useState("");
+ const [syncQueue, setSyncQueue] = useState([]);
+ const syncQueueRef = useRef([]);
+ const [exportingLocal, setExportingLocal] = useState(false);
+ const [postgisRunning, setPostgisRunning] = useState(false);
+ const [postgisResult, setPostgisResult] = useState<{
+ success: boolean;
+ message?: string;
+ details?: Record;
+ error?: string;
+ } | null>(null);
+ const [exportProgress, setExportProgress] = useState(
+ null,
+ );
+ const [phaseTrail, setPhaseTrail] = useState([]);
+
+ const pollingRef = useRef | null>(null);
+
+ /* ── Derived ──────────────────────────────────────────────────── */
+
+ const layersByCategory = useMemo(() => {
+ const grouped: Record = {};
+ for (const layer of LAYER_CATALOG) {
+ if (!grouped[layer.category]) grouped[layer.category] = [];
+ grouped[layer.category]!.push(layer);
+ }
+ return grouped;
+ }, []);
+
+ const progressPct =
+ exportProgress?.total && exportProgress.total > 0
+ ? Math.round((exportProgress.downloaded / exportProgress.total) * 100)
+ : 0;
+
+ /* ── Layer history: load from localStorage on mount ───────────── */
+
+ useEffect(() => {
+ try {
+ const raw = localStorage.getItem("parcel-sync:layer-history");
+ if (raw) {
+ const parsed = JSON.parse(raw) as typeof layerHistory;
+ const today = new Date().toISOString().slice(0, 10);
+ const todayEntries = parsed.filter(
+ (e) => e.time.slice(0, 10) === today,
+ );
+ setLayerHistory(todayEntries);
+ }
+ } catch {
+ // ignore
+ }
+ }, []);
+
+ /* ── Cleanup polling on unmount ───────────────────────────────── */
+
+ useEffect(() => {
+ return () => {
+ if (pollingRef.current) clearInterval(pollingRef.current);
+ };
+ }, []);
+
+ /* ── startPolling ─────────────────────────────────────────────── */
+
+ const startPolling = useCallback((jid: string) => {
+ if (pollingRef.current) clearInterval(pollingRef.current);
+ pollingRef.current = setInterval(async () => {
+ try {
+ const res = await fetch(
+ `/api/eterra/progress?jobId=${encodeURIComponent(jid)}`,
+ );
+ const data = (await res.json()) as ExportProgress;
+ setExportProgress(data);
+ if (data.phase) {
+ setPhaseTrail((prev) => {
+ if (prev[prev.length - 1] === data.phase) return prev;
+ return [...prev, data.phase!];
+ });
+ }
+ if (data.status === "done" || data.status === "error") {
+ if (pollingRef.current) {
+ clearInterval(pollingRef.current);
+ pollingRef.current = null;
+ }
+ }
+ } catch {
+ /* ignore polling errors */
+ }
+ }, 1000);
+ }, []);
+
+ /* ── fetchLayerCounts ─────────────────────────────────────────── */
+
+ const fetchLayerCounts = useCallback(async () => {
+ if (!siruta || countingLayers) return;
+ setCountingLayers(true);
+ try {
+ const res = await fetch("/api/eterra/layers/summary", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ siruta }),
+ });
+ const data = (await res.json()) as {
+ counts?: Record;
+ error?: string;
+ };
+ if (data.counts) {
+ setLayerCounts(data.counts);
+ setLayerCountSiruta(siruta);
+
+ // Save non-zero counts to history
+ const now = new Date().toISOString();
+ const today = now.slice(0, 10);
+ const newEntries: typeof layerHistory = [];
+ for (const [layerId, info] of Object.entries(data.counts)) {
+ if (info.count > 0) {
+ const layer = LAYER_CATALOG.find((l) => l.id === layerId);
+ newEntries.push({
+ layerId,
+ label: layer?.label ?? layerId,
+ count: info.count,
+ time: now,
+ siruta,
+ });
+ }
+ }
+ setLayerHistory((prev) => {
+ // Keep today's entries only, add new batch
+ const kept = prev.filter(
+ (e) => e.time.slice(0, 10) === today && e.siruta !== siruta,
+ );
+ const merged = [...kept, ...newEntries];
+ try {
+ localStorage.setItem(
+ "parcel-sync:layer-history",
+ JSON.stringify(merged),
+ );
+ } catch {
+ // quota
+ }
+ return merged;
+ });
+ }
+ } catch {
+ // silent
+ }
+ setCountingLayers(false);
+ }, [siruta, countingLayers]);
+
+ /* ── handleSyncLayer ──────────────────────────────────────────── */
+
+ const handleSyncLayer = useCallback(
+ async (layerId: string) => {
+ if (!siruta || syncingLayer) return;
+ setSyncingLayer(layerId);
+ setSyncProgress("Sincronizare pornit\u0103\u2026");
+ try {
+ const res = await fetch("/api/eterra/sync", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ siruta,
+ layerId,
+ jobId: crypto.randomUUID(),
+ }),
+ });
+ const data = (await res.json()) as {
+ status?: string;
+ newFeatures?: number;
+ removedFeatures?: number;
+ totalLocal?: number;
+ error?: string;
+ };
+ if (data.error) {
+ setSyncProgress(`Eroare: ${data.error}`);
+ } else {
+ setSyncProgress(
+ `Finalizat \u2014 ${data.newFeatures ?? 0} noi, ${data.removedFeatures ?? 0} \u0219terse, ${data.totalLocal ?? 0} total local`,
+ );
+ // Refresh sync status
+ onSyncRefresh();
+ }
+ } catch {
+ setSyncProgress("Eroare re\u021bea");
+ }
+ // Clear progress after 8s
+ setTimeout(() => {
+ setSyncingLayer(null);
+ setSyncProgress("");
+ }, 8_000);
+ },
+ [siruta, syncingLayer, onSyncRefresh],
+ );
+
+ /* ── handleExportLocal ────────────────────────────────────────── */
+
+ const handleExportLocal = useCallback(
+ async (layerIds?: string[]) => {
+ if (!siruta || exportingLocal) return;
+ setExportingLocal(true);
+ try {
+ const res = await fetch("/api/eterra/export-local", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ siruta,
+ ...(layerIds ? { layerIds } : { allLayers: true }),
+ }),
+ });
+ if (!res.ok) {
+ const err = (await res.json().catch(() => ({}))) as {
+ error?: string;
+ };
+ throw new Error(err.error ?? `HTTP ${res.status}`);
+ }
+ const blob = await res.blob();
+ const cd = res.headers.get("Content-Disposition") ?? "";
+ const match = /filename="?([^"]+)"?/.exec(cd);
+ const filename =
+ match?.[1] ??
+ `eterra_local_${siruta}.${layerIds?.length === 1 ? "gpkg" : "zip"}`;
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement("a");
+ a.href = url;
+ a.download = filename;
+ document.body.appendChild(a);
+ a.click();
+ a.remove();
+ URL.revokeObjectURL(url);
+ } catch (error) {
+ const msg = error instanceof Error ? error.message : "Eroare export";
+ setSyncProgress(msg);
+ setTimeout(() => setSyncProgress(""), 5_000);
+ }
+ setExportingLocal(false);
+ },
+ [siruta, exportingLocal],
+ );
+
+ /* ── handleSyncMultiple ───────────────────────────────────────── */
+
+ const handleSyncMultiple = useCallback(
+ async (layerIds: string[]) => {
+ if (!siruta || syncingLayer || syncQueue.length > 0) return;
+ syncQueueRef.current = [...layerIds];
+ setSyncQueue([...layerIds]);
+
+ for (const layerId of layerIds) {
+ setSyncingLayer(layerId);
+ setSyncProgress(
+ `Sincronizare ${LAYER_CATALOG.find((l) => l.id === layerId)?.label ?? layerId}\u2026`,
+ );
+ try {
+ const res = await fetch("/api/eterra/sync", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ siruta,
+ layerId,
+ jobId: crypto.randomUUID(),
+ }),
+ });
+ const data = (await res.json()) as {
+ error?: string;
+ newFeatures?: number;
+ removedFeatures?: number;
+ totalLocal?: number;
+ };
+ if (data.error) {
+ setSyncProgress(`Eroare: ${data.error}`);
+ }
+ } catch {
+ setSyncProgress("Eroare re\u021bea");
+ }
+ // Remove from queue
+ syncQueueRef.current = syncQueueRef.current.filter(
+ (id) => id !== layerId,
+ );
+ setSyncQueue([...syncQueueRef.current]);
+ }
+ // Done — refresh status
+ onSyncRefresh();
+ setSyncingLayer(null);
+ setSyncProgress("");
+ setSyncQueue([]);
+ syncQueueRef.current = [];
+ },
+ [siruta, syncingLayer, syncQueue.length, onSyncRefresh],
+ );
+
+ /* ── handleSetupPostgis ───────────────────────────────────────── */
+
+ const handleSetupPostgis = useCallback(async () => {
+ if (postgisRunning) return;
+ setPostgisRunning(true);
+ setPostgisResult(null);
+ try {
+ const res = await fetch("/api/eterra/setup-postgis", { method: "POST" });
+ const json = await res.json();
+ setPostgisResult(json as typeof postgisResult);
+ } catch (error) {
+ const msg = error instanceof Error ? error.message : "Eroare setup";
+ setPostgisResult({ success: false, error: msg });
+ }
+ setPostgisRunning(false);
+ }, [postgisRunning, postgisResult]);
+
+ /* ── handleExportLayer ────────────────────────────────────────── */
+
+ const handleExportLayer = useCallback(
+ async (layerId: string) => {
+ if (!siruta || downloadingLayer) return;
+ setDownloadingLayer(layerId);
+ const jobId = crypto.randomUUID();
+ setExportProgress(null);
+ setPhaseTrail([]);
+
+ startPolling(jobId);
+
+ try {
+ const res = await fetch("/api/eterra/export-layer-gpkg", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ siruta,
+ layerId,
+ jobId,
+ }),
+ });
+
+ if (!res.ok) {
+ const err = (await res.json().catch(() => ({}))) as {
+ error?: string;
+ };
+ throw new Error(err.error ?? `HTTP ${res.status}`);
+ }
+
+ const blob = await res.blob();
+ const cd = res.headers.get("Content-Disposition") ?? "";
+ const match = /filename="?([^"]+)"?/.exec(cd);
+ const filename =
+ match?.[1] ?? `eterra_uat_${siruta}_${layerId}.gpkg`;
+
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement("a");
+ a.href = url;
+ a.download = filename;
+ document.body.appendChild(a);
+ a.click();
+ a.remove();
+ URL.revokeObjectURL(url);
+
+ // Mark progress as done after successful download
+ setExportProgress((prev) =>
+ prev
+ ? {
+ ...prev,
+ status: "done",
+ phase: "Finalizat",
+ downloaded: prev.total ?? 100,
+ total: prev.total ?? 100,
+ message: `Desc\u0103rcare complet\u0103 \u2014 ${filename}`,
+ note: undefined,
+ }
+ : null,
+ );
+ } catch (error) {
+ const msg = error instanceof Error ? error.message : "Eroare export";
+ setExportProgress((prev) =>
+ prev
+ ? { ...prev, status: "error", message: msg }
+ : {
+ jobId,
+ downloaded: 0,
+ status: "error",
+ message: msg,
+ },
+ );
+ }
+
+ if (pollingRef.current) {
+ clearInterval(pollingRef.current);
+ pollingRef.current = null;
+ }
+ setDownloadingLayer(null);
+ // Refresh sync status — layer was synced to DB
+ onSyncRefresh();
+ },
+ [siruta, downloadingLayer, startPolling, onSyncRefresh],
+ );
+
+ /* ── Suppress unused warnings for sync multiple (used externally) */
+ void handleSyncMultiple;
+ void phaseTrail;
+ void syncQueue;
+
+ /* ── JSX ──────────────────────────────────────────────────────── */
+
+ if (!sirutaValid || !session.connected) {
+ return (
+
+
+
+ {!session.connected
+ ? "Conecteaz\u0103-te la eTerra \u0219i selecteaz\u0103 un UAT."
+ : "Selecteaz\u0103 un UAT pentru a vedea catalogul de layere."}
+
+
+
+ );
+ }
+
+ return (
+
+ {/* Action bar */}
+
+
+ {layerCountSiruta === siruta &&
+ Object.keys(layerCounts).length > 0
+ ? `Num\u0103r features pentru SIRUTA ${siruta}`
+ : "Apas\u0103 pentru a num\u0103ra features-urile din fiecare layer."}
+
+
+ {/* Export from local DB */}
+ {syncingSiruta === siruta &&
+ Object.values(syncLocalCounts).some((c) => c > 0) && (
+ void handleExportLocal()}
+ className="border-violet-300 text-violet-700 dark:border-violet-700 dark:text-violet-300"
+ >
+ {exportingLocal ? (
+
+ )}
+ void fetchLayerCounts()}
+ >
+ {countingLayers ? (
+
+
+
+
+ {/* Sync progress message */}
+ {syncProgress && (
+
+ {syncingLayer ? (
+ {syncProgress}
+
+ )}
+
+ {(Object.keys(LAYER_CATEGORY_LABELS) as LayerCategory[]).map((cat) => {
+ const layers = layersByCategory[cat];
+ if (!layers?.length) return null;
+ const isExpanded = expandedCategories[cat] ?? false;
+
+ // Sum counts for category badge
+ const catTotal =
+ layerCountSiruta === siruta
+ ? layers.reduce(
+ (sum, l) => sum + (layerCounts[l.id]?.count ?? 0),
+ 0,
+ )
+ : null;
+
+ // Sum local counts for category
+ const catLocal =
+ syncingSiruta === siruta
+ ? layers.reduce(
+ (sum, l) => sum + (syncLocalCounts[l.id] ?? 0),
+ 0,
+ )
+ : null;
+
+ return (
+
+
+ setExpandedCategories((prev) => ({
+ ...prev,
+ [cat]: !prev[cat],
+ }))
+ }
+ >
+
+
+ {LAYER_CATEGORY_LABELS[cat]}
+
+
+ {layers.length}
+
+ {catTotal != null && catTotal > 0 && (
+
+ {catTotal.toLocaleString("ro-RO")} remote
+
+ )}
+ {catLocal != null && catLocal > 0 && (
+
+ {catLocal.toLocaleString("ro-RO")} local
+
+ )}
+
+ {isExpanded ? (
+
+
+ {isExpanded && (
+
+ {layers.map((layer) => {
+ const isDownloading = downloadingLayer === layer.id;
+ const isSyncing = syncingLayer === layer.id;
+ const lc =
+ layerCountSiruta === siruta
+ ? layerCounts[layer.id]
+ : undefined;
+ const localCount =
+ syncingSiruta === siruta
+ ? (syncLocalCounts[layer.id] ?? 0)
+ : 0;
+
+ // Find last sync run for this layer
+ const lastRun = syncRuns.find(
+ (r) =>
+ r.layerId === layer.id && r.status === "done",
+ );
+
+ return (
+
+
+
+
+
+ {layer.label}
+
+ {lc != null && !lc.error && (
+
+ {lc.count.toLocaleString("ro-RO")}
+
+ )}
+ {lc?.error && (
+
+ eroare
+
+ )}
+ {localCount > 0 && (
+
+
+ )}
+
+
+
+ {layer.id}
+
+ {lastRun && (
+
+ sync{" "}
+ {new Date(
+ lastRun.completedAt ??
+ lastRun.startedAt,
+ ).toLocaleDateString("ro-RO", {
+ day: "2-digit",
+ month: "2-digit",
+ hour: "2-digit",
+ minute: "2-digit",
+ })}
+
+ )}
+
+
+
+ {/* Sync to DB */}
+
+ void handleSyncLayer(layer.id)
+ }
+ className="border-violet-200 dark:border-violet-800"
+ title="Sincronizeaz\u0103 \u00een baza de date"
+ >
+ {isSyncing ? (
+
+ Sync
+
+
+ {/* GPKG (sync-first: syncs to DB if needed, then exports from DB) */}
+
+ void handleExportLayer(layer.id)
+ }
+ title={
+ localCount > 0
+ ? "Descarc\u0103 GPKG (din cache dac\u0103 e proasp\u0103t)"
+ : "Sincronizeaz\u0103 + descarc\u0103 GPKG"
+ }
+ >
+ {isDownloading ? (
+
+ GPKG
+
+
+
+
+
+ )}
+
+ );
+ })}
+
+ {/* Drumul de azi — today's layer count history */}
+ {layerHistory.length > 0 && (
+
+
+
+ Drumul de azi
+
+ {layerHistory.length}
+
+
+
+
+ {/* Group by siruta */}
+ {(() => {
+ const grouped = new Map
();
+ for (const e of layerHistory) {
+ if (!grouped.has(e.siruta)) grouped.set(e.siruta, []);
+ grouped.get(e.siruta)!.push(e);
+ }
+ return Array.from(grouped.entries()).map(
+ ([sir, entries]) => (
+
+
+ SIRUTA {sir}{" "}
+
+ \u2014{" "}
+ {new Date(entries[0]!.time).toLocaleTimeString(
+ "ro-RO",
+ { hour: "2-digit", minute: "2-digit" },
+ )}
+
+
+
+ {entries
+ .sort((a, b) => b.count - a.count)
+ .map((e) => (
+
+ {e.label}
+
+ {e.count.toLocaleString("ro-RO")}
+
+
+ ))}
+
+
+
+ )}
+
+ {/* PostGIS / QGIS setup */}
+
+
+
+
+
+ Conectare QGIS
+
+
+ {!postgisResult?.success && (
+
+
+
+ void handleSetupPostgis()}
+ className="border-violet-300 text-violet-700 dark:border-violet-700 dark:text-violet-300"
+ >
+ {postgisRunning ? (
+
+
+
+
+ Operatie sigura, reversibila
+
+
+ Creeaza coloane native PostGIS + view-uri read-only
+ pentru QGIS. Nu modifica datele existente. Ruleaza o
+ singura data (~30s).
+
+
+
+
+ )}
+
+
+ {postgisResult ? (
+ postgisResult.success ? (
+
+
+
+ QGIS compatibil \u2014 gata de conectare
+
+
+
+
+ Cum te conectezi din QGIS:
+
+
+
+ QGIS \u2192 Layer \u2192 Add Layer \u2192 Add PostGIS Layers
+
+ New connection:
+
+
+
+ Host: 10.10.10.166
+
+
+ Port: 5432
+
+
+ Database: architools_db
+
+
+ Username: architools_user
+
+
+
+ View-uri disponibile (read-only):
+
+
+ gis_terenuri, gis_cladiri, gis_documentatii,
+ gis_administrativ
+
+
+ SRID: 3844 (Stereo70)
+
+ {postgisResult.details && (
+
+ {String(
+ (
+ postgisResult.details as {
+ totalFeaturesWithGeom?: number;
+ }
+ ).totalFeaturesWithGeom ?? 0,
+ )}{" "}
+ features cu geometrie nativa
+
+ )}
+
+
+
+
+
+ PostGIS nu este instalat pe server
+
+
+ Contacteaza administratorul pentru instalare:
+
+
+ apt install postgresql-16-postgis-3
+
+
+
+
+ Permite conectarea din QGIS direct la baza de date pentru
+ vizualizare si analiza spatiala a parcelelor, cladirilor
+ si limitelor UAT.
+
+
+ Apasa butonul pentru a activa \u2014 creeaza view-uri read-only
+ (nu modifica datele, nu afecteaza performanta aplicatiei).
+
+
+
+
+ {/* Progress bar for layer download */}
+ {downloadingLayer && exportProgress && (
+
+
+
+
+
+
+ {exportProgress.phase}
+ {exportProgress.phaseCurrent != null &&
+ exportProgress.phaseTotal
+ ? ` \u2014 ${exportProgress.phaseCurrent} / ${exportProgress.phaseTotal}`
+ : ""}
+
+
+
+ {progressPct}%
+
+
+
+ )}
+
): void;
+ addLayer(layer: Record, before?: string): void;
+ setFilter(id: string, filter: unknown[] | null): void;
+ setLayoutProperty(id: string, prop: string, value: unknown): void;
+ fitBounds(bounds: [number, number, number, number], opts?: Record): void;
+ isStyleLoaded(): boolean;
+};
+
+function asMap(handle: MapViewerHandle | null): MapLike | null {
+ const m = handle?.getMap();
+ return m ? (m as unknown as MapLike) : null;
+}
+
+/* ------------------------------------------------------------------ */
+/* Component */
+/* ------------------------------------------------------------------ */
+
+export function MapTab({ siruta, sirutaValid }: MapTabProps) {
+ const mapHandleRef = useRef(null);
+ const [basemap, setBasemap] = useState("liberty");
+ const [clickedFeature, setClickedFeature] =
+ useState(null);
+ const [selectionMode, setSelectionMode] = useState("off");
+ const [selectedFeatures, setSelectedFeatures] = useState(
+ [],
+ );
+ const [boundsLoading, setBoundsLoading] = useState(false);
+ const [flyTarget, setFlyTarget] = useState<
+ { center: [number, number]; zoom?: number } | undefined
+ >();
+ const [mapReady, setMapReady] = useState(false);
+ const [viewsReady, setViewsReady] = useState(null);
+ const appliedSirutaRef = useRef("");
+
+ /* Layer visibility: show terenuri + cladiri, hide admin */
+ const [layerVisibility] = useState({
+ terenuri: true,
+ cladiri: true,
+ administrativ: false,
+ });
+
+ /* ── Check if enrichment views exist, create if not ────────── */
+ useEffect(() => {
+ fetch("/api/geoportal/setup-enrichment-views")
+ .then((r) => r.json())
+ .then((data: { ready?: boolean }) => {
+ if (data.ready) {
+ setViewsReady(true);
+ } else {
+ // Auto-create views
+ fetch("/api/geoportal/setup-enrichment-views", { method: "POST" })
+ .then((r) => r.json())
+ .then((res: { status?: string }) => {
+ setViewsReady(res.status === "ok");
+ })
+ .catch(() => setViewsReady(false));
+ }
+ })
+ .catch(() => setViewsReady(false));
+ }, []);
+
+ /* ── Detect when map is ready ──────────────────────────────── */
+ useEffect(() => {
+ if (!sirutaValid) return;
+ const check = setInterval(() => {
+ const map = asMap(mapHandleRef.current);
+ if (map && map.isStyleLoaded()) {
+ setMapReady(true);
+ clearInterval(check);
+ }
+ }, 200);
+ return () => clearInterval(check);
+ }, [sirutaValid]);
+
+ /* ── Apply siruta filter on base map layers ────────────────── */
+ useEffect(() => {
+ if (!mapReady || !sirutaValid || !siruta) return;
+ if (appliedSirutaRef.current === siruta) return;
+
+ const map = asMap(mapHandleRef.current);
+ if (!map) return;
+
+ appliedSirutaRef.current = siruta;
+ const filter = ["==", ["get", "siruta"], siruta];
+
+ for (const layerId of BASE_LAYERS) {
+ try {
+ if (!map.getLayer(layerId)) continue;
+ map.setFilter(layerId, filter);
+ } catch {
+ /* layer may not exist */
+ }
+ }
+ }, [mapReady, siruta, sirutaValid]);
+
+ /* ── Add enrichment overlay source + layers ────────────────── */
+ useEffect(() => {
+ if (!mapReady || !viewsReady || !sirutaValid || !siruta) return;
+
+ const map = asMap(mapHandleRef.current);
+ if (!map) return;
+
+ const martinBase = typeof window !== "undefined"
+ ? `${window.location.origin}/tiles`
+ : "/tiles";
+
+ // Add gis_terenuri_status source (only once)
+ if (!map.getSource("gis_terenuri_status")) {
+ map.addSource("gis_terenuri_status", {
+ type: "vector",
+ tiles: [`${martinBase}/gis_terenuri_status/{z}/{x}/{y}`],
+ minzoom: 10,
+ maxzoom: 18,
+ });
+
+ // Data-driven fill: color by enrichment status
+ map.addLayer(
+ {
+ id: "l-ps-terenuri-fill",
+ type: "fill",
+ source: "gis_terenuri_status",
+ "source-layer": "gis_terenuri_status",
+ minzoom: 13,
+ filter: ["==", ["get", "siruta"], siruta],
+ paint: {
+ "fill-color": [
+ "case",
+ // Enriched parcels: darker green
+ ["==", ["get", "has_enrichment"], 1],
+ "#15803d",
+ // No enrichment: lighter green
+ "#86efac",
+ ],
+ "fill-opacity": 0.25,
+ },
+ },
+ "l-terenuri-line", // insert before line layer
+ );
+
+ // Data-driven outline
+ map.addLayer(
+ {
+ id: "l-ps-terenuri-line",
+ type: "line",
+ source: "gis_terenuri_status",
+ "source-layer": "gis_terenuri_status",
+ minzoom: 13,
+ filter: ["==", ["get", "siruta"], siruta],
+ paint: {
+ "line-color": [
+ "case",
+ // Has building without legal docs: red
+ [
+ "all",
+ ["==", ["get", "has_building"], 1],
+ ["==", ["get", "build_legal"], 0],
+ ],
+ "#ef4444",
+ // Has building with legal: blue
+ ["==", ["get", "has_building"], 1],
+ "#3b82f6",
+ // Default: green
+ "#15803d",
+ ],
+ "line-width": [
+ "case",
+ ["==", ["get", "has_building"], 1],
+ 1.8,
+ 0.8,
+ ],
+ },
+ },
+ "l-cladiri-fill",
+ );
+ } else {
+ // Source already exists — just update filters for new siruta
+ const sirutaFilter = ["==", ["get", "siruta"], siruta];
+ try {
+ if (map.getLayer("l-ps-terenuri-fill"))
+ map.setFilter("l-ps-terenuri-fill", sirutaFilter);
+ if (map.getLayer("l-ps-terenuri-line"))
+ map.setFilter("l-ps-terenuri-line", sirutaFilter);
+ } catch {
+ /* noop */
+ }
+ }
+
+ // Hide the base terenuri-fill (we replaced it with enrichment-aware version)
+ try {
+ if (map.getLayer("l-terenuri-fill"))
+ map.setLayoutProperty("l-terenuri-fill", "visibility", "none");
+ } catch {
+ /* noop */
+ }
+ }, [mapReady, viewsReady, siruta, sirutaValid]);
+
+ /* ── Fetch UAT bounds and zoom ─────────────────────────────── */
+ const prevBoundsSirutaRef = useRef("");
+ useEffect(() => {
+ if (!sirutaValid || !siruta) return;
+ if (prevBoundsSirutaRef.current === siruta) return;
+ prevBoundsSirutaRef.current = siruta;
+
+ setBoundsLoading(true);
+ fetch(`/api/geoportal/uat-bounds?siruta=${siruta}`)
+ .then((r) => (r.ok ? r.json() : null))
+ .then(
+ (data: {
+ bounds?: [[number, number], [number, number]];
+ } | null) => {
+ if (data?.bounds) {
+ const [[minLng, minLat], [maxLng, maxLat]] = data.bounds;
+ const centerLng = (minLng + maxLng) / 2;
+ const centerLat = (minLat + maxLat) / 2;
+ setFlyTarget({ center: [centerLng, centerLat], zoom: 13 });
+
+ // Fit bounds if map is already ready
+ const map = asMap(mapHandleRef.current);
+ if (map) {
+ map.fitBounds([minLng, minLat, maxLng, maxLat], {
+ padding: 40,
+ duration: 1500,
+ });
+ }
+ }
+ },
+ )
+ .catch(() => {})
+ .finally(() => setBoundsLoading(false));
+ }, [siruta, sirutaValid]);
+
+ /* ── Feature click handler ─────────────────────────────────── */
+ const handleFeatureClick = useCallback(
+ (feature: ClickedFeature | null) => {
+ if (!feature || !feature.properties) {
+ setClickedFeature(null);
+ return;
+ }
+ setClickedFeature(feature);
+ },
+ [],
+ );
+
+ /* ── Selection mode handler ────────────────────────────────── */
+ const handleSelectionModeChange = useCallback((mode: SelectionMode) => {
+ if (mode === "off") {
+ mapHandleRef.current?.clearSelection();
+ setSelectedFeatures([]);
+ }
+ setSelectionMode(mode);
+ }, []);
+
+ /* ── Render ─────────────────────────────────────────────────── */
+
+ if (!sirutaValid) {
+ return (
+
+
+ Selecteaz\u0103 un UAT din lista de mai sus
+
+
+ );
+ }
+
+ return (
+
+ {boundsLoading && (
+
+
+ )}
+
+
+
+ {/* Top-right: basemap switcher + feature panel */}
+
+ setClickedFeature(null)}
+ />
+ )}
+
+
+ {/* Bottom-left: selection toolbar */}
+
+ {
+ mapHandleRef.current?.clearSelection();
+ setSelectedFeatures([]);
+ }}
+ />
+
+
+ {/* Bottom-right: legend */}
+
+
+
+
+
+
+
+
+
+
+
([]);
+ const [searchList, setSearchList] = useState([]);
+ const [featuresSearch, setFeaturesSearch] = useState("");
+ const [loadingFeatures, setLoadingFeatures] = useState(false);
+ const [searchError, setSearchError] = useState("");
+
+ /* ── Owner search ──────────────────────────────────────────── */
+ const [ownerSearch, setOwnerSearch] = useState("");
+ const [ownerResults, setOwnerResults] = useState([]);
+ const [ownerLoading, setOwnerLoading] = useState(false);
+ const [ownerError, setOwnerError] = useState("");
+ const [ownerNote, setOwnerNote] = useState("");
+
+ /* ── CF extract statuses ──────────────────────────────────── */
+ const [cfStatusMap, setCfStatusMap] = useState>({});
+ const [cfLatestIds, setCfLatestIds] = useState>({});
+ const [cfExpiryDates, setCfExpiryDates] = useState>(
+ {},
+ );
+ const [cfStatusLoading, setCfStatusLoading] = useState(false);
+ const [listCfOrdering, setListCfOrdering] = useState(false);
+ const [listCfOrderResult, setListCfOrderResult] = useState("");
+ const [listCfDownloading, setListCfDownloading] = useState(false);
+
+ /* ── Search handlers ──────────────────────────────────────── */
+
+ const handleSearch = useCallback(async () => {
+ if (!siruta || !/^\d+$/.test(siruta)) return;
+ if (!featuresSearch.trim()) {
+ setSearchResults([]);
+ setSearchError("");
+ return;
+ }
+ setLoadingFeatures(true);
+ setSearchError("");
+ try {
+ const res = await fetch("/api/eterra/search", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ siruta,
+ search: featuresSearch.trim(),
+ ...(workspacePk ? { workspacePk } : {}),
+ }),
+ });
+ const data = (await res.json()) as {
+ results?: ParcelDetail[];
+ total?: number;
+ error?: string;
+ };
+ if (data.error) {
+ setSearchResults([]);
+ setSearchError(data.error);
+ } else {
+ setSearchResults(data.results ?? []);
+ setSearchError("");
+ }
+ } catch {
+ setSearchError("Eroare de re\u021bea.");
+ }
+ setLoadingFeatures(false);
+ }, [siruta, featuresSearch, workspacePk]);
+
+ const handleSearchKeyDown = useCallback(
+ (e: React.KeyboardEvent) => {
+ if (e.key === "Enter") {
+ e.preventDefault();
+ void handleSearch();
+ }
+ },
+ [handleSearch],
+ );
+
+ /* ── Owner search ──────────────────────────────────────────── */
+
+ const handleOwnerSearch = useCallback(async () => {
+ if (!siruta || !/^\d+$/.test(siruta)) return;
+ if (!ownerSearch.trim() || ownerSearch.trim().length < 2) {
+ setOwnerError("Minim 2 caractere.");
+ return;
+ }
+ setOwnerLoading(true);
+ setOwnerError("");
+ setOwnerNote("");
+ try {
+ const res = await fetch("/api/eterra/search-owner", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ siruta,
+ ownerName: ownerSearch.trim(),
+ ...(workspacePk ? { workspacePk } : {}),
+ }),
+ });
+ const data = (await res.json()) as {
+ results?: OwnerSearchResult[];
+ total?: number;
+ dbSearched?: boolean;
+ eterraSearched?: boolean;
+ eterraNote?: string;
+ error?: string;
+ };
+ if (data.error) {
+ setOwnerResults([]);
+ setOwnerError(data.error);
+ } else {
+ setOwnerResults(data.results ?? []);
+ const notes: string[] = [];
+ if (data.dbSearched) notes.push("DB local");
+ if (data.eterraSearched) notes.push("eTerra API");
+ if (data.eterraNote) notes.push(data.eterraNote);
+ setOwnerNote(
+ notes.length > 0
+ ? `Surse: ${notes.join(" + ")}${data.total ? ` \u00b7 ${data.total} rezultate` : ""}`
+ : "",
+ );
+ }
+ } catch {
+ setOwnerError("Eroare de re\u021bea.");
+ }
+ setOwnerLoading(false);
+ }, [siruta, ownerSearch, workspacePk]);
+
+ const handleOwnerKeyDown = useCallback(
+ (e: React.KeyboardEvent) => {
+ if (e.key === "Enter") {
+ e.preventDefault();
+ void handleOwnerSearch();
+ }
+ },
+ [handleOwnerSearch],
+ );
+
+ const ownerResultToParcelDetail = useCallback(
+ (r: OwnerSearchResult): ParcelDetail => ({
+ nrCad: r.nrCad,
+ nrCF: r.nrCF,
+ nrCFVechi: "",
+ nrTopo: "",
+ intravilan: r.intravilan,
+ categorieFolosinta: r.categorieFolosinta,
+ adresa: r.adresa,
+ proprietari: r.proprietari || r.proprietariVechi,
+ proprietariActuali: r.proprietari,
+ proprietariVechi: r.proprietariVechi,
+ suprafata: typeof r.suprafata === "number" ? r.suprafata : null,
+ solicitant: "",
+ immovablePk: r.immovablePk,
+ }),
+ [],
+ );
+
+ /* ── List management ───────────────────────────────────────── */
+
+ const addToList = useCallback((item: ParcelDetail) => {
+ setSearchList((prev) => {
+ if (
+ prev.some(
+ (p) => p.nrCad === item.nrCad && p.immovablePk === item.immovablePk,
+ )
+ )
+ return prev;
+ return [...prev, item];
+ });
+ }, []);
+
+ const removeFromList = useCallback((nrCad: string) => {
+ setSearchList((prev) => prev.filter((p) => p.nrCad !== nrCad));
+ }, []);
+
+ const csvEscape = useCallback((val: string | number | null | undefined) => {
+ const s = val != null ? String(val) : "";
+ return `"${s.replace(/"/g, '""')}"`;
+ }, []);
+
+ const downloadCSV = useCallback(() => {
+ const items = searchList.length > 0 ? searchList : searchResults;
+ if (items.length === 0) return;
+ const headers = [
+ "NR_CAD",
+ "NR_CF",
+ "NR_CF_VECHI",
+ "NR_TOPO",
+ "SUPRAFATA",
+ "INTRAVILAN",
+ "CATEGORIE_FOLOSINTA",
+ "ADRESA",
+ "PROPRIETARI_ACTUALI",
+ "PROPRIETARI_VECHI",
+ "SOLICITANT",
+ ];
+ const rows = items.map((p) => [
+ csvEscape(p.nrCad),
+ csvEscape(p.nrCF),
+ csvEscape(p.nrCFVechi),
+ csvEscape(p.nrTopo),
+ csvEscape(p.suprafata),
+ csvEscape(p.intravilan),
+ csvEscape(p.categorieFolosinta),
+ csvEscape(p.adresa),
+ csvEscape(p.proprietariActuali ?? p.proprietari),
+ csvEscape(p.proprietariVechi),
+ csvEscape(p.solicitant),
+ ]);
+ const csv = [headers.join(","), ...rows.map((r) => r.join(","))].join("\n");
+ const blob = new Blob(["\uFEFF" + csv], {
+ type: "text/csv;charset=utf-8",
+ });
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement("a");
+ a.href = url;
+ a.download = `parcele_${siruta}_${Date.now()}.csv`;
+ a.click();
+ URL.revokeObjectURL(url);
+ }, [searchList, searchResults, siruta, csvEscape]);
+
+ /* ── CF extract status fetching ────────────────────────────── */
+
+ const fetchCfStatuses = useCallback(async (cadastralNumbers: string[]) => {
+ if (cadastralNumbers.length === 0) return;
+ setCfStatusLoading(true);
+ try {
+ const nrs = cadastralNumbers.join(",");
+ const res = await fetch(
+ `/api/ancpi/orders?nrCadastral=${encodeURIComponent(nrs)}&limit=1`,
+ );
+ const data = (await res.json()) as {
+ statusMap?: Record;
+ latestById?: Record<
+ string,
+ { id: string; expiresAt: string | null }
+ >;
+ };
+ if (data.statusMap) {
+ setCfStatusMap((prev) => ({ ...prev, ...data.statusMap }));
+ }
+ if (data.latestById) {
+ const idMap: Record = {};
+ const expiryMap: Record = {};
+ for (const [nr, rec] of Object.entries(data.latestById)) {
+ if (rec && typeof rec === "object" && "id" in rec) {
+ idMap[nr] = (rec as { id: string }).id;
+ const expires = (rec as { expiresAt: string | null }).expiresAt;
+ if (expires) {
+ expiryMap[nr] = expires;
+ }
+ }
+ }
+ setCfLatestIds((prev) => ({ ...prev, ...idMap }));
+ setCfExpiryDates((prev) => ({ ...prev, ...expiryMap }));
+ }
+ } catch {
+ /* silent */
+ } finally {
+ setCfStatusLoading(false);
+ }
+ }, []);
+
+ const refreshCfStatuses = useCallback(() => {
+ const allNrs = new Set();
+ for (const r of searchResults) {
+ if (r.nrCad) allNrs.add(r.nrCad);
+ }
+ for (const p of searchList) {
+ if (p.nrCad) allNrs.add(p.nrCad);
+ }
+ if (allNrs.size > 0) {
+ void fetchCfStatuses(Array.from(allNrs));
+ }
+ }, [searchResults, searchList, fetchCfStatuses]);
+
+ // Auto-fetch CF statuses when search results change
+ useEffect(() => {
+ const nrs = searchResults.map((r) => r.nrCad).filter(Boolean);
+ if (nrs.length > 0) void fetchCfStatuses(nrs);
+ }, [searchResults, fetchCfStatuses]);
+
+ // Auto-fetch CF statuses when list changes
+ useEffect(() => {
+ const nrs = searchList.map((p) => p.nrCad).filter(Boolean);
+ if (nrs.length > 0) void fetchCfStatuses(nrs);
+ }, [searchList, fetchCfStatuses]);
+
+ /* ── List CF ordering + ZIP download ──────────────────────── */
+
+ const handleListCfOrder = useCallback(async () => {
+ if (!siruta || searchList.length === 0 || listCfOrdering) return;
+ const toOrder: typeof searchList = [];
+ const toReorder: typeof searchList = [];
+ const alreadyValid: typeof searchList = [];
+ for (const p of searchList) {
+ const status = cfStatusMap[p.nrCad];
+ if (status === "valid") {
+ alreadyValid.push(p);
+ } else if (status === "expired") {
+ toReorder.push(p);
+ } else {
+ if (status !== "processing") toOrder.push(p);
+ }
+ }
+ const newCount = toOrder.length;
+ const updateCount = toReorder.length;
+ const existingCount = alreadyValid.length;
+ if (newCount === 0 && updateCount === 0) {
+ setListCfOrderResult(
+ `Toate cele ${existingCount} extrase sunt valide.`,
+ );
+ return;
+ }
+ const msg = [
+ newCount > 0 ? `${newCount} extrase noi` : null,
+ updateCount > 0 ? `${updateCount} actualizari` : null,
+ existingCount > 0 ? `${existingCount} existente (skip)` : null,
+ ]
+ .filter(Boolean)
+ .join(", ");
+ if (!window.confirm(`Comanda extrase CF:\n${msg}\n\nContinui?`)) return;
+ setListCfOrdering(true);
+ setListCfOrderResult("");
+ try {
+ const allToProcess = [...toOrder, ...toReorder];
+ const parcels = allToProcess.map((p) => ({
+ nrCadastral: p.nrCad,
+ siruta,
+ judetIndex: 0,
+ judetName: selectedUat?.county ?? "",
+ uatId: 0,
+ uatName: selectedUat?.name ?? "",
+ }));
+ const res = await fetch("/api/ancpi/order", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ parcels }),
+ });
+ const data = (await res.json()) as {
+ orders?: unknown[];
+ error?: string;
+ };
+ if (!res.ok || data.error) {
+ setListCfOrderResult(
+ `Eroare: ${data.error ?? "Eroare la comanda"}`,
+ );
+ } else {
+ const count = data.orders?.length ?? allToProcess.length;
+ setListCfOrderResult(
+ `${count} extras${count > 1 ? "e" : ""} CF trimis${count > 1 ? "e" : ""} la procesare.`,
+ );
+ const pollInterval = setInterval(() => {
+ void refreshCfStatuses();
+ }, 10_000);
+ setTimeout(() => clearInterval(pollInterval), 5 * 60 * 1000);
+ }
+ } catch {
+ setListCfOrderResult("Eroare retea.");
+ } finally {
+ setListCfOrdering(false);
+ }
+ }, [
+ siruta,
+ searchList,
+ listCfOrdering,
+ cfStatusMap,
+ selectedUat,
+ refreshCfStatuses,
+ ]);
+
+ const handleListCfDownloadZip = useCallback(async () => {
+ if (searchList.length === 0 || listCfDownloading) return;
+ const ids: string[] = [];
+ for (const p of searchList) {
+ const status = cfStatusMap[p.nrCad];
+ const extractId = cfLatestIds[p.nrCad];
+ if (status === "valid" && extractId) ids.push(extractId);
+ }
+ if (ids.length === 0) {
+ setListCfOrderResult("Niciun extras CF valid in lista.");
+ return;
+ }
+ setListCfDownloading(true);
+ try {
+ const res = await fetch(`/api/ancpi/download-zip?ids=${ids.join(",")}`);
+ if (!res.ok) throw new Error("Eroare descarcare ZIP");
+ const blob = await res.blob();
+ const cd = res.headers.get("Content-Disposition") ?? "";
+ const match = /filename="?([^"]+)"?/.exec(cd);
+ const filename = match?.[1]
+ ? decodeURIComponent(match[1])
+ : "Extrase_CF_lista.zip";
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement("a");
+ a.href = url;
+ a.download = filename;
+ document.body.appendChild(a);
+ a.click();
+ a.remove();
+ URL.revokeObjectURL(url);
+ } catch {
+ setListCfOrderResult("Eroare la descarcarea ZIP.");
+ } finally {
+ setListCfDownloading(false);
+ }
+ }, [searchList, cfStatusMap, cfLatestIds, listCfDownloading]);
+
+ /* ── CF status badge helper ────────────────────────────────── */
+
+ const CfStatusBadge = useCallback(
+ ({
+ nrCad,
+ immovablePk,
+ }: {
+ nrCad: string;
+ immovablePk?: number | string | null;
+ }) => {
+ if (!immovablePk || !sirutaValid) return null;
+ const cfStatus = cfStatusMap[nrCad];
+ const extractId = cfLatestIds[nrCad];
+ const cfExpiry = cfExpiryDates[nrCad];
+
+ if (cfStatus === "valid") {
+ return (
+
+
+
+
+
+ Extras CF
+
+
+
+ {cfExpiry
+ ? `Valid pana la ${formatShortDate(cfExpiry)}`
+ : "Extras CF valid"}
+
+
+ {extractId && (
+
+
+
+
+
+
+
+ Descarca extras CF
+
+ )}
+
+ );
+ }
+ if (cfStatus === "expired") {
+ return (
+
+
+
+
+
+ Expirat
+
+
+
+ {cfExpiry
+ ? `Expirat pe ${formatShortDate(cfExpiry)}`
+ : "Extras CF expirat"}
+
+
+
+
+ );
+ }
+ if (cfStatus === "processing") {
+ return (
+
+
+
+
+ Se proceseaza...
+
+
+ Comanda in curs de procesare
+
+
+ );
+ }
+ // "none" or unknown
+ return (
+
+
+ Selecteaz\u0103 un UAT mai sus pentru a c\u0103uta parcele.
+
+
+ );
+ }
+
+ return (
+ <>
+ {/* Search input — mode toggle + input */}
+
+
+ {/* Mode toggle */}
+
+ setSearchMode("cadastral")}
+ className={cn(
+ "px-3 py-1 text-xs rounded font-medium transition-colors",
+ searchMode === "cadastral"
+ ? "bg-background shadow text-foreground"
+ : "text-muted-foreground hover:text-foreground",
+ )}
+ >
+
+ setSearchMode("owner")}
+ className={cn(
+ "px-3 py-1 text-xs rounded font-medium transition-colors",
+ searchMode === "owner"
+ ? "bg-background shadow text-foreground"
+ : "text-muted-foreground hover:text-foreground",
+ )}
+ >
+
+
+
+ {/* Cadastral search input */}
+ {searchMode === "cadastral" && (
+
+
+
+ Numere cadastrale (separate prin virgul\u0103 sau Enter)
+
+
+
+ {!session.connected && (
+
+ Necesit\u0103 conexiune eTerra. Folose\u0219te modul Proprietar
+ pentru a c\u0103uta offline \u00een DB.
+
+ )}
+
+
void handleSearch()}
+ disabled={
+ loadingFeatures ||
+ !featuresSearch.trim() ||
+ !session.connected
+ }
+ >
+ {loadingFeatures ? (
+
+
+
+
+ Nume proprietar (caut\u0103 \u00een DB local + eTerra)
+
+
+
+
+
void handleOwnerSearch()}
+ disabled={ownerLoading || ownerSearch.trim().length < 2}
+ >
+ {ownerLoading ? (
+
+
{searchError}
+ )}
+ {searchMode === "owner" && ownerError && (
+ {ownerError}
+ )}
+ {searchMode === "owner" && ownerNote && (
+ {ownerNote}
+ )}
+
+
+
+ {/* ─── Cadastral search results ────────────── */}
+ {searchMode === "cadastral" && (
+ <>
+ {loadingFeatures && searchResults.length === 0 && (
+
+
+ Se caut\u0103 \u00een eTerra...
+
+ Prima c\u0103utare pe un UAT nou poate dura ~10-30s (se
+ \u00eencarc\u0103 lista de jude\u021be).
+
+
+
+ )}
+
+ {searchResults.length > 0 && (
+ <>
+ {/* Action bar */}
+
+
+ {searchResults.length} rezultat
+ {searchResults.length > 1 ? "e" : ""}
+ {searchList.length > 0 && (
+
+ · {searchList.length} \u00een list\u0103
+
+ )}
+
+
+ {searchResults.length > 0 && (
+
{
+ for (const r of searchResults) addToList(r);
+ }}
+ >
+
+ )}
+
+
+
+
+ {searchResults.map((p, idx) => (
+
+
+
+
+
+ Nr. Cad. {p.nrCad}
+
+ {!p.immovablePk && (
+
+ Parcela nu a fost g\u0103sit\u0103 \u00een eTerra.
+
+ )}
+
+
+
addToList(p)}
+ disabled={!p.immovablePk}
+ >
+
+
{
+ const text = [
+ `Nr. Cad: ${p.nrCad}`,
+ `Nr. CF: ${p.nrCF || "\u2014"}`,
+ p.nrCFVechi
+ ? `CF vechi: ${p.nrCFVechi}`
+ : null,
+ p.nrTopo
+ ? `Nr. Topo: ${p.nrTopo}`
+ : null,
+ p.suprafata != null
+ ? `Suprafata: ${p.suprafata.toLocaleString("ro-RO")} mp`
+ : null,
+ `Intravilan: ${p.intravilan || "\u2014"}`,
+ p.categorieFolosinta
+ ? `Categorie: ${p.categorieFolosinta}`
+ : null,
+ p.adresa ? `Adresa: ${p.adresa}` : null,
+ p.proprietariActuali
+ ? `Proprietari actuali: ${p.proprietariActuali}`
+ : null,
+ p.proprietariVechi
+ ? `Proprietari vechi: ${p.proprietariVechi}`
+ : null,
+ !p.proprietariActuali &&
+ !p.proprietariVechi &&
+ p.proprietari
+ ? `Proprietari: ${p.proprietari}`
+ : null,
+ p.solicitant
+ ? `Solicitant: ${p.solicitant}`
+ : null,
+ ]
+ .filter(Boolean)
+ .join("\n");
+ void navigator.clipboard.writeText(text);
+ }}
+ >
+
+
+
+
+
+
+ Nr. CF
+
+
+ {p.nrCF || "\u2014"}
+
+
+ {p.nrCFVechi && (
+
+
+ CF vechi
+
+ {p.nrCFVechi}
+
+ )}
+
+
+ Nr. Topo
+
+ {p.nrTopo || "\u2014"}
+
+
+
+ Suprafa\u021b\u0103
+
+
+ {p.suprafata != null
+ ? formatArea(p.suprafata)
+ : "\u2014"}
+
+
+
+
+ Intravilan
+
+
+ {p.intravilan || "\u2014"}
+
+
+ {p.categorieFolosinta && (
+
+
+ Categorii folosin\u021b\u0103
+
+
+ {p.categorieFolosinta}
+
+
+ )}
+ {p.adresa && (
+
+
+ Adres\u0103
+
+ {p.adresa}
+
+ )}
+ {(p.proprietariActuali || p.proprietariVechi) && (
+
+ {p.proprietariActuali && (
+
+
+ Proprietari actuali
+
+
+ {p.proprietariActuali}
+
+
+ )}
+ {p.proprietariVechi && (
+
+
+ Proprietari anteriori
+
+
+ {p.proprietariVechi}
+
+
+ )}
+ {!p.proprietariActuali &&
+ !p.proprietariVechi &&
+ p.proprietari && (
+
+
+ Proprietari
+
+ {p.proprietari}
+
+ )}
+
+ )}
+ {p.solicitant && (
+
+
+ Solicitant
+
+ {p.solicitant}
+
+ )}
+
+
+ ))}
+
+
+ Introdu un num\u0103r cadastral \u0219i apas\u0103 Caut\u0103.
+
+ Po\u021bi c\u0103uta mai multe parcele simultan, separate prin
+ virgul\u0103.
+
+
+
+ )}
+
+ )}
+
+ {/* ─── Owner search results ────────────────── */}
+ {searchMode === "owner" && (
+ <>
+ {ownerLoading && ownerResults.length === 0 && (
+
+
+ Se caut\u0103 proprietar...
+
+ Caut\u0103 mai \u00eent\u00e2i \u00een DB local (date \u00eembog\u0103\u021bite), apoi pe
+ eTerra.
+
+
+
+ )}
+
+ {ownerResults.length > 0 && (
+ <>
+
+
+ {ownerResults.length} rezultat
+ {ownerResults.length > 1 ? "e" : ""} pentru "
+ {ownerSearch}"
+
+
+
{
+ for (const r of ownerResults)
+ addToList(ownerResultToParcelDetail(r));
+ }}
+ >
+
+
+
+
+
+ {ownerResults.map((r, idx) => (
+
+
+
+
+
+ Nr. Cad. {r.nrCad}
+
+
+ {r.source === "db"
+ ? "din baza de date"
+ : "eTerra online"}
+
+
+
+
+ addToList(ownerResultToParcelDetail(r))
+ }
+ >
+
+
{
+ const text = [
+ `Nr. Cad: ${r.nrCad}`,
+ r.nrCF ? `Nr. CF: ${r.nrCF}` : null,
+ r.proprietari
+ ? `Proprietari: ${r.proprietari}`
+ : null,
+ r.proprietariVechi
+ ? `Proprietari vechi: ${r.proprietariVechi}`
+ : null,
+ r.adresa ? `Adresa: ${r.adresa}` : null,
+ r.suprafata
+ ? `Suprafata: ${r.suprafata} mp`
+ : null,
+ ]
+ .filter(Boolean)
+ .join("\n");
+ void navigator.clipboard.writeText(text);
+ }}
+ >
+
+
+
+
+ {r.nrCF && (
+
+
+ Nr. CF
+
+ {r.nrCF}
+
+ )}
+ {r.suprafata && (
+
+
+ Suprafa\u021b\u0103
+
+
+ {typeof r.suprafata === "number"
+ ? formatArea(r.suprafata)
+ : `${r.suprafata} mp`}
+
+
+ )}
+ {r.intravilan && (
+
+
+ Intravilan
+
+
+ {r.intravilan}
+
+
+ )}
+ {r.categorieFolosinta && (
+
+
+ Categorii folosin\u021b\u0103
+
+
+ {r.categorieFolosinta}
+
+
+ )}
+ {r.adresa && (
+
+
+ Adres\u0103
+
+ {r.adresa}
+
+ )}
+ {r.proprietari && (
+
+
+ Proprietari actuali
+
+
+ {r.proprietari}
+
+
+ )}
+ {r.proprietariVechi && (
+
+
+ Proprietari anteriori
+
+
+ {r.proprietariVechi}
+
+
+ )}
+
+
+ ))}
+
+
+ Introdu numele proprietarului \u0219i apas\u0103 Caut\u0103.
+
+ Caut\u0103 \u00een datele \u00eembog\u0103\u021bite (DB local) \u0219i pe eTerra.
+
+
+
+ )}
+
+ )}
+
+ {/* Saved list */}
+ {searchList.length > 0 && (
+
+
+
+
+ Lista mea ({searchList.length} parcele)
+
+
+
{
+ setSearchList([]);
+ setListCfOrderResult("");
+ }}
+ >
+
+
+
+ {/* Download all valid CF extracts as ZIP */}
+ {searchList.some(
+ (p) => cfStatusMap[p.nrCad] === "valid",
+ ) &&
+ (() => {
+ const validCount = searchList.filter(
+ (p) => cfStatusMap[p.nrCad] === "valid",
+ ).length;
+ return (
+
+
+
+
+ void handleListCfDownloadZip()
+ }
+ >
+ {listCfDownloading ? (
+
+
+ {`Descarca ZIP cu ${validCount} extrase valide din lista`}
+
+
+ );
+ })()}
+ {/* Order CF extracts for list */}
+ {epayStatus.connected &&
+ (() => {
+ const newCount = searchList.filter((p) => {
+ const s = cfStatusMap[p.nrCad];
+ return (
+ s !== "valid" &&
+ s !== "expired" &&
+ s !== "processing"
+ );
+ }).length;
+ const updateCount = searchList.filter(
+ (p) => cfStatusMap[p.nrCad] === "expired",
+ ).length;
+ const totalCredits = newCount + updateCount;
+ const validCount = searchList.filter(
+ (p) => cfStatusMap[p.nrCad] === "valid",
+ ).length;
+ return (
+
+
+
+ void handleListCfOrder()}
+ >
+ {listCfOrdering ? (
+
+
+
+ {`Comanda ${newCount} extrase noi + ${updateCount} actualizari = ${totalCredits} credite. ${validCount} existente valide raman.`}
+
+
+
+ );
+ })()}
+
+
+ {listCfOrderResult}
+
+ )}
+
+
+
+
+
+
+ #
+
+
+ Nr. Cad
+
+
+ Nr. CF
+
+
+ Suprafata
+
+
+ Proprietari
+
+
+ Extras CF
+
+
+
+
+ {searchList.map((p, idx) => {
+ const cfStatus = cfStatusMap[p.nrCad];
+ const cfExpiry = cfExpiryDates[p.nrCad];
+ return (
+
+
+ {idx + 1}
+
+
+ {p.nrCad}
+
+
+ {p.nrCF || "\u2014"}
+
+
+ {p.suprafata != null
+ ? formatArea(p.suprafata)
+ : "\u2014"}
+
+
+ {p.proprietari || "\u2014"}
+
+
+
+
+
+ {cfStatus === "valid" ? (
+
+ Valid
+
+ ) : cfStatus === "expired" ? (
+
+ Expirat
+
+ ) : cfStatus === "processing" ? (
+
+ Procesare
+
+ ) : (
+
+ Lipsa
+
+ )}
+
+
+ {cfStatus === "valid"
+ ? cfExpiry
+ ? `Extras CF valid pana la ${formatShortDate(cfExpiry)}`
+ : "Extras CF valid"
+ : cfStatus === "expired"
+ ? cfExpiry
+ ? `Extras CF expirat pe ${formatShortDate(cfExpiry)}. Va fi actualizat automat la 'Scoate Extrase CF'.`
+ : "Extras CF expirat. Va fi actualizat automat la 'Scoate Extrase CF'."
+ : cfStatus === "processing"
+ ? "Comanda in curs de procesare"
+ : "Nu exista extras CF. Apasa 'Scoate Extrase CF' pentru a comanda."}
+
+
+
+
+
+ removeFromList(p.nrCad)}
+ >
+
+
+
+ );
+ })}
+
+
+
+
+ )}
+
+ );
+}