Ignorierte Slots
diff --git a/src/components/NavigationTabs.js b/src/components/NavigationTabs.js
index e603e58..1a753dd 100644
--- a/src/components/NavigationTabs.js
+++ b/src/components/NavigationTabs.js
@@ -4,23 +4,26 @@ const NavigationTabs = ({ isAdmin, onProtectedNavigate }) => {
const location = useLocation();
const navigate = useNavigate();
- if (!isAdmin) {
- return null;
- }
-
const tabs = [
{ to: '/', label: 'Konfiguration' },
- { to: '/admin', label: 'Admin' }
+ { to: '/store-watch', label: 'Betriebs-Monitoring' }
];
+ if (isAdmin) {
+ tabs.push({ to: '/admin', label: 'Admin' });
+ }
const handleClick = (event, to) => {
event.preventDefault();
if (to === location.pathname) {
return;
}
- onProtectedNavigate(`zur Seite "${tabs.find((tab) => tab.to === to)?.label || ''}" zu wechseln`, () =>
- navigate(to)
- );
+ const label = tabs.find((tab) => tab.to === to)?.label || '';
+ const proceed = () => navigate(to);
+ if (onProtectedNavigate) {
+ onProtectedNavigate(`zur Seite "${label}" zu wechseln`, proceed);
+ return;
+ }
+ proceed();
};
return (
diff --git a/src/components/StoreWatchPage.js b/src/components/StoreWatchPage.js
new file mode 100644
index 0000000..690ca08
--- /dev/null
+++ b/src/components/StoreWatchPage.js
@@ -0,0 +1,414 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+const StoreWatchPage = ({ authorizedFetch }) => {
+ const [regions, setRegions] = useState([]);
+ const [selectedRegionId, setSelectedRegionId] = useState('');
+ const [storesByRegion, setStoresByRegion] = useState({});
+ const [watchList, setWatchList] = useState([]);
+ const [regionLoading, setRegionLoading] = useState(false);
+ const [storesLoading, setStoresLoading] = useState(false);
+ const [subscriptionsLoading, setSubscriptionsLoading] = useState(false);
+ const [status, setStatus] = useState('');
+ const [error, setError] = useState('');
+ const [dirty, setDirty] = useState(false);
+ const [saving, setSaving] = useState(false);
+
+ const watchedIds = useMemo(
+ () => new Set(watchList.map((entry) => String(entry.storeId))),
+ [watchList]
+ );
+
+ const selectedRegion = useMemo(
+ () => regions.find((region) => String(region.id) === String(selectedRegionId)) || null,
+ [regions, selectedRegionId]
+ );
+
+ const currentStores = useMemo(() => {
+ const regionEntry = storesByRegion[String(selectedRegionId)];
+ if (!regionEntry || !Array.isArray(regionEntry.stores)) {
+ return [];
+ }
+ return regionEntry.stores;
+ }, [storesByRegion, selectedRegionId]);
+
+ const eligibleStores = useMemo(
+ () => currentStores.filter((store) => Number(store.cooperationStatus) === 5),
+ [currentStores]
+ );
+
+ const loadRegions = useCallback(async () => {
+ if (!authorizedFetch) {
+ return;
+ }
+ setRegionLoading(true);
+ setError('');
+ try {
+ const response = await authorizedFetch('/api/store-watch/regions');
+ if (!response.ok) {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ const data = await response.json();
+ const normalized = Array.isArray(data.regions) ? data.regions : [];
+ setRegions(normalized);
+ if (!selectedRegionId && normalized.length > 0) {
+ setSelectedRegionId(String(normalized[0].id));
+ }
+ } catch (err) {
+ setError(`Regionen konnten nicht geladen werden: ${err.message}`);
+ } finally {
+ setRegionLoading(false);
+ }
+ }, [authorizedFetch, selectedRegionId]);
+
+ const loadSubscriptions = useCallback(async () => {
+ if (!authorizedFetch) {
+ return;
+ }
+ setSubscriptionsLoading(true);
+ setError('');
+ try {
+ const response = await authorizedFetch('/api/store-watch/subscriptions');
+ if (!response.ok) {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ const data = await response.json();
+ const normalized = Array.isArray(data.stores) ? data.stores : [];
+ setWatchList(normalized);
+ setDirty(false);
+ } catch (err) {
+ setError(`Überwachte Betriebe konnten nicht geladen werden: ${err.message}`);
+ } finally {
+ setSubscriptionsLoading(false);
+ }
+ }, [authorizedFetch]);
+
+ const fetchStoresForRegion = useCallback(
+ async (regionId, { force } = {}) => {
+ if (!authorizedFetch || !regionId) {
+ return;
+ }
+ if (!force && storesByRegion[String(regionId)]) {
+ return;
+ }
+ setStoresLoading(true);
+ setError('');
+ try {
+ const endpoint = force
+ ? `/api/store-watch/regions/${regionId}/stores?force=1`
+ : `/api/store-watch/regions/${regionId}/stores`;
+ const response = await authorizedFetch(endpoint);
+ if (!response.ok) {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ const data = await response.json();
+ setStoresByRegion((prev) => ({
+ ...prev,
+ [String(regionId)]: {
+ total: Number(data.total) || 0,
+ stores: Array.isArray(data.stores) ? data.stores : [],
+ fetchedAt: Date.now()
+ }
+ }));
+ } catch (err) {
+ setError(`Betriebe konnten nicht geladen werden: ${err.message}`);
+ } finally {
+ setStoresLoading(false);
+ }
+ },
+ [authorizedFetch, storesByRegion]
+ );
+
+ useEffect(() => {
+ loadRegions();
+ loadSubscriptions();
+ }, [loadRegions, loadSubscriptions]);
+
+ useEffect(() => {
+ if (selectedRegionId) {
+ fetchStoresForRegion(selectedRegionId);
+ }
+ }, [selectedRegionId, fetchStoresForRegion]);
+
+ const handleToggleStore = useCallback(
+ (store, checked) => {
+ setWatchList((prev) => {
+ const storeId = String(store.id || store.storeId);
+ const existing = prev.find((entry) => entry.storeId === storeId);
+ if (checked) {
+ if (existing) {
+ return prev;
+ }
+ setDirty(true);
+ const regionName =
+ store.region?.name || selectedRegion?.name || existing?.regionName || '';
+ return [
+ ...prev,
+ {
+ storeId,
+ storeName: store.name || store.storeName || `Store ${storeId}`,
+ regionId: String(store.region?.id || selectedRegionId || existing?.regionId || ''),
+ regionName,
+ lastTeamSearchStatus: existing?.lastTeamSearchStatus ?? null
+ }
+ ];
+ }
+ if (!existing) {
+ return prev;
+ }
+ setDirty(true);
+ return prev.filter((entry) => entry.storeId !== storeId);
+ });
+ },
+ [selectedRegion, selectedRegionId]
+ );
+
+ const handleRemoveWatch = useCallback((storeId) => {
+ setWatchList((prev) => {
+ const next = prev.filter((entry) => entry.storeId !== storeId);
+ if (next.length !== prev.length) {
+ setDirty(true);
+ }
+ return next;
+ });
+ }, []);
+
+ const handleSave = useCallback(async () => {
+ if (!authorizedFetch || saving || !dirty) {
+ return;
+ }
+ setSaving(true);
+ setStatus('');
+ setError('');
+ try {
+ const response = await authorizedFetch('/api/store-watch/subscriptions', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ stores: watchList })
+ });
+ if (!response.ok) {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ const data = await response.json();
+ setWatchList(Array.isArray(data.stores) ? data.stores : []);
+ setDirty(false);
+ setStatus('Überwachung gespeichert.');
+ setTimeout(() => setStatus(''), 4000);
+ } catch (err) {
+ setError(`Speichern fehlgeschlagen: ${err.message}`);
+ } finally {
+ setSaving(false);
+ }
+ }, [authorizedFetch, dirty, saving, watchList]);
+
+ const handleReset = useCallback(() => {
+ loadSubscriptions();
+ }, [loadSubscriptions]);
+
+ if (!authorizedFetch) {
+ return (
+
+ );
+ }
+
+ return (
+
+
+
Betriebs-Monitoring
+
+ Wähle Betriebe aus, die bei offenem Team-Status automatisch gemeldet werden sollen.
+
+
+
+ {(error || status) && (
+
+ {error && (
+
{error}
+ )}
+ {status && (
+
+ {status}
+
+ )}
+
+ )}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Es werden nur Regionen angezeigt, in denen du Mitglied mit Klassifikation 1 bist.
+
+
+
+
+
+
Betriebe in der Region
+ {storesByRegion[String(selectedRegionId)]?.fetchedAt && (
+
+ Aktualisiert:{' '}
+ {new Date(storesByRegion[String(selectedRegionId)].fetchedAt).toLocaleTimeString('de-DE')}
+
+ )}
+
+ {storesLoading &&
Lade Betriebe...
}
+ {!storesLoading && (!selectedRegionId || eligibleStores.length === 0) && (
+
+ {selectedRegionId
+ ? 'Keine geeigneten Betriebe (Status "aktiv") in dieser Region.'
+ : 'Bitte zuerst eine Region auswählen.'}
+
+ )}
+ {!storesLoading && eligibleStores.length > 0 && (
+
+
+
+
+ | Betrieb |
+ Ort |
+ Kooperation |
+ Überwachen |
+
+
+
+ {eligibleStores.map((store) => {
+ const checked = watchedIds.has(String(store.id));
+ return (
+
+ |
+ {store.name}
+ #{store.id}
+ |
+
+ {store.city || 'unbekannt'}
+ {store.street || ''}
+ |
+
+ Seit {store.createdAt ? new Date(store.createdAt).toLocaleDateString('de-DE') : 'n/a'}
+ |
+
+ handleToggleStore(store, event.target.checked)}
+ />
+ |
+
+ );
+ })}
+
+
+
+ )}
+
+
+
+
+
+ Überwachte Betriebe ({watchList.length})
+
+
+
+
+
+
+ {subscriptionsLoading &&
Lade aktuelle Auswahl...
}
+ {!subscriptionsLoading && watchList.length === 0 && (
+
Noch keine Betriebe ausgewählt.
+ )}
+ {watchList.length > 0 && (
+
+ {watchList.map((entry) => (
+
+
+
+
{entry.storeName}
+
+ #{entry.storeId} — {entry.regionName || 'Region unbekannt'}
+
+
+
+
+
+ Letzter Status:{' '}
+ {entry.lastTeamSearchStatus === 1
+ ? 'Suchend'
+ : entry.lastTeamSearchStatus === 0
+ ? 'Nicht suchend'
+ : 'Unbekannt'}
+
+
+ ))}
+
+ )}
+
+
+ {dirty && (
+
+ Es gibt ungespeicherte Änderungen. Bitte "Speichern" klicken.
+
+ )}
+
+ );
+};
+
+export default StoreWatchPage;
diff --git a/src/utils/adminSettings.js b/src/utils/adminSettings.js
index 3f93399..0eba3fe 100644
--- a/src/utils/adminSettings.js
+++ b/src/utils/adminSettings.js
@@ -9,6 +9,9 @@ export const normalizeAdminSettings = (raw) => {
initialDelayMinSeconds: raw.initialDelayMinSeconds ?? '',
initialDelayMaxSeconds: raw.initialDelayMaxSeconds ?? '',
storePickupCheckDelayMs: raw.storePickupCheckDelayMs ?? '',
+ storeWatchCron: raw.storeWatchCron || '',
+ storeWatchInitialDelayMinSeconds: raw.storeWatchInitialDelayMinSeconds ?? '',
+ storeWatchInitialDelayMaxSeconds: raw.storeWatchInitialDelayMaxSeconds ?? '',
ignoredSlots: Array.isArray(raw.ignoredSlots)
? raw.ignoredSlots.map((slot) => ({
storeId: slot?.storeId ? String(slot.storeId) : '',
@@ -50,6 +53,9 @@ export const serializeAdminSettings = (adminSettings) => {
initialDelayMinSeconds: toNumberOrUndefined(adminSettings.initialDelayMinSeconds),
initialDelayMaxSeconds: toNumberOrUndefined(adminSettings.initialDelayMaxSeconds),
storePickupCheckDelayMs: toNumberOrUndefined(adminSettings.storePickupCheckDelayMs),
+ storeWatchCron: adminSettings.storeWatchCron,
+ storeWatchInitialDelayMinSeconds: toNumberOrUndefined(adminSettings.storeWatchInitialDelayMinSeconds),
+ storeWatchInitialDelayMaxSeconds: toNumberOrUndefined(adminSettings.storeWatchInitialDelayMaxSeconds),
ignoredSlots: (adminSettings.ignoredSlots || []).map((slot) => ({
storeId: slot.storeId || '',
description: slot.description || ''