Files
Sternsinger/CMBNet/static/js/views/dispatcher.js
T

2183 lines
70 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* Dispatcher-View
*
* Initialisierung:
* 1. Straßen und Gruppen per AJAX laden
* 2. Zugriffstoken holen und WebSocket mit Code 0 authentifizieren
* 3. Karte, Polylines, Marker und Kontrollansicht aufbauen
*/
const tenant = window.CMBNET_TENANT || window.location.pathname.split('/')[1];
const apiBase = `/${tenant}/api`;
const wsUrl = `${window.location.protocol === 'https:' ? 'wss' : 'ws'}://${window.location.host}/${tenant}/ws`;
const storageKey = `cmbnet:${tenant}:map`;
const themeStorageKey = 'cmbnet:theme';
const currentAccountId = Number(window.CMBNET_ACCOUNT_ID) || null;
const DEFAULT_SETTINGS = {
opacity: 0.7,
weight: 20, // Meter
baseLayer: 'osm',
center: null,
zoom: null
};
const STREET_STATES = ['unbearbeitet', 'zugewiesen', 'erledigt'];
const GROUP_STATES = ['offen', 'unterwegs', 'online', 'pausierend', 'fertig'];
const GROUP_MARKER_MAX_AGE_SECONDS = 30 * 60;
const STREET_COLORS = {
unbearbeitet: '#1f6feb',
zugewiesen: '#d62828',
erledigt: '#2e9e4f'
};
const dispatcherState = {
settings: {...DEFAULT_SETTINGS},
streets: [],
streetById: new Map(),
groups: [],
groupById: new Map(),
polylinesByStreetId: new Map(),
markersByGroupId: new Map(),
browserLatLng: null,
ws: null,
authenticated: false,
reconnectTimer: null,
crosshairGroupId: null,
currentStreetId: null,
streetsDialogGroupId: null,
aliasGroupId: null,
chatGroupId: null,
chatByGroup: new Map(),
chatKeysByGroup: new Map(),
streetSearchResults: [],
streetSearchActiveIndex: -1,
streetSearchRequestId: 0,
houseNumberMarker: null,
unloading: false
};
let map;
let osmLayer;
let aerialLayer;
let currentBaseLayer;
document.addEventListener('DOMContentLoaded', initDispatcher);
async function initDispatcher() {
loadStoredSettings();
initMap();
bindStaticUi();
updateClock();
setInterval(updateClock, 1000);
try {
const [streets, groups] = await Promise.all([
fetchJson(`${apiBase}/init/streets`),
fetchJson(`${apiBase}/init/groups`)
]);
dispatcherState.streets = Array.isArray(streets) ? streets : [];
dispatcherState.groups = Array.isArray(groups) ? groups : [];
indexData();
buildPolylines();
buildGroupAccordion();
applySettingsToUi();
placeKnownGroupMarkers();
} catch (error) {
console.error('Initialdaten konnten nicht geladen werden:', error);
showAccordionError('Die Straßen und Gruppen konnten nicht geladen werden.');
}
ensureInitialView();
updateAllPolylineStyles();
placeUnknownGroupMarkers();
setConnectionStatus('Verbinde …', '');
connectWebSocket();
window.addEventListener('beforeunload', () => {
dispatcherState.unloading = true;
if (dispatcherState.reconnectTimer) clearTimeout(dispatcherState.reconnectTimer);
if (dispatcherState.ws) dispatcherState.ws.close();
});
}
/* ------------------------------------------------------------------ */
/* Initialdaten und LocalStorage */
/* ------------------------------------------------------------------ */
async function fetchJson(url, options = {}) {
const response = await fetch(url, {credentials: 'same-origin', ...options});
if (!response.ok) {
throw new Error(`${url}: HTTP ${response.status}`);
}
return response.json();
}
function loadStoredSettings() {
let saved = {};
try {
const raw = localStorage.getItem(storageKey);
if (raw) saved = JSON.parse(raw);
} catch (error) {
console.warn('Gespeicherte Karteneinstellungen konnten nicht gelesen werden.', error);
}
const center = Array.isArray(saved.center) && saved.center.length === 2
? saved.center.map(Number)
: null;
const validCenter = center
&& center.every(Number.isFinite)
&& Math.abs(center[0]) <= 90
&& Math.abs(center[1]) <= 180
? center
: null;
dispatcherState.settings = {
opacity: clampNumber(saved.opacity, 0, 1, DEFAULT_SETTINGS.opacity),
weight: clampNumber(saved.weight, 1, 100, DEFAULT_SETTINGS.weight),
baseLayer: saved.baseLayer === 'aerial' ? 'aerial' : 'osm',
center: validCenter,
zoom: Number.isFinite(Number(saved.zoom)) && Number(saved.zoom) > 0
? Number(saved.zoom)
: null
};
}
function saveStoredSettings() {
if (map) {
const center = map.getCenter();
dispatcherState.settings.center = [center.lat, center.lng];
dispatcherState.settings.zoom = map.getZoom();
}
try {
localStorage.setItem(storageKey, JSON.stringify(dispatcherState.settings));
} catch (error) {
console.warn('Karteneinstellungen konnten nicht gespeichert werden.', error);
}
}
function clampNumber(value, min, max, fallback) {
const number = Number(value);
if (!Number.isFinite(number)) return fallback;
return Math.min(max, Math.max(min, number));
}
function initTheme() {
applyTheme(document.documentElement.dataset.theme, false);
document.getElementById('darkModeToggle').addEventListener('change', event => {
applyTheme(event.target.checked ? 'dark' : 'light', true);
});
window.addEventListener('storage', event => {
if (event.key === themeStorageKey) applyTheme(event.newValue, false);
});
}
function applyTheme(theme, persist) {
const normalized = theme === 'dark' ? 'dark' : 'light';
document.documentElement.dataset.theme = normalized;
const toggle = document.getElementById('darkModeToggle');
if (toggle) toggle.checked = normalized === 'dark';
if (!persist) return;
try {
localStorage.setItem(themeStorageKey, normalized);
} catch (error) {
console.warn('Theme-Einstellung konnte nicht gespeichert werden.', error);
}
}
function indexData() {
dispatcherState.streetById.clear();
dispatcherState.streets.forEach(street => {
dispatcherState.streetById.set(Number(street.id), street);
});
dispatcherState.groupById.clear();
dispatcherState.groups.forEach(group => {
group.id = Number(group.id);
group.last_pos_ts = parseTimestamp(group.last_pos_at);
dispatcherState.groupById.set(group.id, group);
});
dispatcherState.groups.sort((a, b) => a.id - b.id);
}
/* ------------------------------------------------------------------ */
/* Karte */
/* ------------------------------------------------------------------ */
function initMap() {
map = L.map('map', {
zoomControl: true,
preferCanvas: true,
minZoom: 2
});
map.setView([51.0, 10.0], 6);
osmLayer = L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
maxZoom: 19,
attribution: '&copy; OpenStreetMap-Mitwirkende'
});
aerialLayer = L.tileLayer(
'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
{
maxZoom: 19,
attribution: 'Tiles &copy; Esri'
}
);
setBaseLayer(dispatcherState.settings.baseLayer, false);
map.on('moveend zoomend', saveStoredSettings);
map.on('zoomend', updateAllPolylineStyles);
map.on('click', handleMapClick);
window.addEventListener('resize', () => map.invalidateSize());
setTimeout(() => map.invalidateSize(), 0);
}
function setBaseLayer(name, persist = true) {
if (currentBaseLayer) {
map.removeLayer(currentBaseLayer);
}
currentBaseLayer = name === 'aerial' ? aerialLayer : osmLayer;
currentBaseLayer.addTo(map);
dispatcherState.settings.baseLayer = name === 'aerial' ? 'aerial' : 'osm';
const mapContainer = map.getContainer();
mapContainer.classList.toggle(
'is-aerial-base',
dispatcherState.settings.baseLayer === 'aerial'
);
const select = document.getElementById('baseLayerSelect');
if (select) select.value = dispatcherState.settings.baseLayer;
if (persist) saveStoredSettings();
}
function ensureInitialView() {
if (dispatcherState.settings.center && dispatcherState.settings.zoom !== null) {
map.setView(dispatcherState.settings.center, dispatcherState.settings.zoom);
return;
}
const bounds = collectAllStreetBounds();
if (bounds.isValid()) {
map.fitBounds(bounds, {padding: [24, 24], maxZoom: 16});
}
}
function collectAllStreetBounds() {
const bounds = L.latLngBounds([]);
dispatcherState.streets.forEach(street => {
const streetBounds = bboxToBounds(street.bbox);
if (streetBounds) bounds.extend(streetBounds);
});
if (!bounds.isValid()) {
dispatcherState.polylinesByStreetId.forEach(lines => {
lines.forEach(line => {
line.getLatLngs().forEach(latlng => bounds.extend(latlng));
});
});
}
return bounds;
}
/**
* Unterstützt das im Projekt verwendete Format [[nwLon, nwLat], [seLon, seLat]]
* sowie flache GeoJSON-Bounding-Boxen [west, south, east, north].
*/
function bboxToBounds(bbox) {
if (!bbox) return null;
if (Array.isArray(bbox) && bbox.length === 2
&& Array.isArray(bbox[0]) && Array.isArray(bbox[1])
&& bbox[0].length >= 2 && bbox[1].length >= 2) {
const lon1 = Number(bbox[0][0]);
const lat1 = Number(bbox[0][1]);
const lon2 = Number(bbox[1][0]);
const lat2 = Number(bbox[1][1]);
if ([lon1, lat1, lon2, lat2].every(Number.isFinite)) {
return L.latLngBounds([lat1, lon1], [lat2, lon2]);
}
}
if (Array.isArray(bbox) && bbox.length === 4 && bbox.every(Number.isFinite)) {
const [west, south, east, north] = bbox.map(Number);
return L.latLngBounds([south, west], [north, east]);
}
if (bbox && typeof bbox === 'object' && !Array.isArray(bbox)) {
const south = Number(bbox.south ?? bbox.minLat);
const west = Number(bbox.west ?? bbox.minLon);
const north = Number(bbox.north ?? bbox.maxLat);
const east = Number(bbox.east ?? bbox.maxLon);
if ([south, west, north, east].every(Number.isFinite)) {
return L.latLngBounds([south, west], [north, east]);
}
}
return null;
}
function fitAllStreetBounds() {
const bounds = collectAllStreetBounds();
if (bounds.isValid()) {
map.fitBounds(bounds, {padding: [24, 24], maxZoom: 16});
} else {
map.setView([51.0, 10.0], 6);
}
}
/* ------------------------------------------------------------------ */
/* Polylines */
/* ------------------------------------------------------------------ */
function getStreetFragments() {
// Unterstützt sowohl window-Zuweisungen (window.Strasse2Polylines /
// window.STRASSE2POLYLINES) als auch globale const/let-Deklarationen im
// externen str2pl.js-Fragment.
if (typeof Strasse2Polylines !== 'undefined') return Strasse2Polylines;
if (typeof STRASSE2POLYLINES !== 'undefined') return STRASSE2POLYLINES;
return window.Strasse2Polylines || window.STRASSE2POLYLINES || {};
}
function tooltipElement(text) {
// Leaflet interpretiert String-Inhalte als HTML. Gruppennamen und
// Straßennamen stammen aus der Datenbank und werden deshalb als
// Textknoten übergeben.
const element = document.createElement('span');
element.textContent = String(text);
return element;
}
function buildPolylines() {
const fragments = getStreetFragments();
const regionBounds = dispatcherState.streets
.map(street => bboxToBounds(street.bbox))
.find(bounds => bounds && bounds.isValid()) || null;
const fallbackCenter = regionBounds
? regionBounds.getCenter()
: (dispatcherState.settings.center
? L.latLng(dispatcherState.settings.center)
: map.getCenter());
dispatcherState.streets.forEach(street => {
const segments = findStreetSegments(fragments, street.name);
if (!Array.isArray(segments)) return;
const streetBounds = bboxToBounds(street.bbox) || regionBounds;
const lines = [];
segments.forEach(segment => {
if (!Array.isArray(segment)) return;
const latlngs = segment
.map(point => normalizeStreetPoint(point, streetBounds, fallbackCenter))
.filter(Boolean);
if (latlngs.length < 2) return;
const line = L.polyline(latlngs, polylineStyle(street.state));
line.bindTooltip(tooltipElement(`${street.name} (${street.state})`), {sticky: true});
line.on('click', () => {
if (dispatcherState.crosshairGroupId) return;
openStreetModal(street.id);
});
line.addTo(map);
lines.push(line);
});
if (lines.length) {
dispatcherState.polylinesByStreetId.set(Number(street.id), lines);
}
});
}
function findStreetSegments(fragments, name) {
if (!name) return null;
if (fragments[name]) return fragments[name];
const lower = String(name).toLowerCase();
const matchingKey = Object.keys(fragments).find(key => key.toLowerCase() === lower);
return matchingKey ? fragments[matchingKey] : null;
}
function normalizeStreetPoint(point, bounds, fallbackCenter) {
if (!Array.isArray(point) || point.length < 2) return null;
const first = Number(point[0]);
const second = Number(point[1]);
if (!Number.isFinite(first) || !Number.isFinite(second)) return null;
// Die Spezifikation erwartet [Longitude, Latitude]. Das mitgelieferte
// Godesberg-Fragment enthält historisch bedingt [Latitude, Longitude].
// Beide Varianten werden akzeptiert und anhand der Straßen-Bounding-Box
// (bzw. des Kartenmittelpunkts) eindeutig zugeordnet.
const candidates = [
[second, first], // [lon, lat]
[first, second] // [lat, lon]
].filter(([lat, lon]) => (
Number.isFinite(lat) && Number.isFinite(lon)
&& lat >= -90 && lat <= 90
&& lon >= -180 && lon <= 180
));
if (!candidates.length) return null;
if (candidates.length === 1) return candidates[0];
let pool = candidates;
if (bounds && bounds.isValid()) {
const inside = candidates.filter(([lat, lon]) => bounds.contains([lat, lon]));
if (inside.length) pool = inside;
}
const center = bounds && bounds.isValid() ? bounds.getCenter() : fallbackCenter;
if (!center) return pool[0];
let best = pool[0];
let bestDistance = squaredCoordinateDistance(best, center);
for (let i = 1; i < pool.length; i += 1) {
const distance = squaredCoordinateDistance(pool[i], center);
if (distance < bestDistance) {
best = pool[i];
bestDistance = distance;
}
}
return best;
}
function squaredCoordinateDistance(latlng, center) {
const dLat = latlng[0] - center.lat;
const dLng = latlng[1] - center.lng;
return dLat * dLat + dLng * dLng;
}
/**
* Rechnet eine reale Länge an der Position `latlng` in Pixel beim aktuellen
* Zoom der Karte um. Grundlage ist die Längenausdehnung eines Grads am
* angegebenen Breitengrad.
*/
function getPixelsForMeters(mapInstance, latlng, meters) {
const value = Number(meters);
if (!Number.isFinite(value) || value <= 0) return 1;
if (!mapInstance || !latlng) return value;
const metersPerDegreeLng = 111320 * Math.cos(latlng.lat * Math.PI / 180);
if (!Number.isFinite(metersPerDegreeLng) || metersPerDegreeLng <= 0) {
return value;
}
const lngDelta = value / metersPerDegreeLng;
const zoom = mapInstance.getZoom();
const p1 = mapInstance.project(latlng, zoom);
const p2 = mapInstance.project(L.latLng(latlng.lat, latlng.lng + lngDelta), zoom);
return p1.distanceTo(p2);
}
function currentPolylineWeight() {
if (!map) return dispatcherState.settings.weight;
return getPixelsForMeters(map, map.getCenter(), dispatcherState.settings.weight);
}
function polylineStyle(state) {
return {
color: STREET_COLORS[state] || STREET_COLORS.unbearbeitet,
opacity: dispatcherState.settings.opacity,
weight: currentPolylineWeight(),
lineCap: 'round',
lineJoin: 'round'
};
}
function recolorStreet(street) {
const lines = dispatcherState.polylinesByStreetId.get(Number(street.id));
if (!lines) return;
const color = STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet;
lines.forEach(line => {
line.setStyle({
color,
opacity: dispatcherState.settings.opacity,
weight: currentPolylineWeight()
});
line.setTooltipContent(tooltipElement(`${street.name} (${street.state})`));
});
}
function updateAllPolylineStyles() {
const weight = currentPolylineWeight();
dispatcherState.polylinesByStreetId.forEach(lines => {
lines.forEach(line => {
line.setStyle({
opacity: dispatcherState.settings.opacity,
weight
});
});
});
}
/* ------------------------------------------------------------------ */
/* Gruppen, Marker und Accordion */
/* ------------------------------------------------------------------ */
function groupDisplayName(group) {
return group.aliasname && String(group.aliasname).trim()
? String(group.aliasname)
: String(group.id);
}
function groupColor(group) {
const id = Number(group.id) || 0;
const hue = Math.round((id * 137.508) % 360);
return `hsl(${hue}, 72%, 45%)`;
}
function hasPosition(group) {
return group.last_lat !== null && group.last_lat !== undefined
&& group.last_lon !== null && group.last_lon !== undefined
&& Number.isFinite(Number(group.last_lat))
&& Number.isFinite(Number(group.last_lon));
}
function createGroupMarker(group, latlng) {
const color = groupColor(group);
const marker = L.marker(latlng, {
title: groupDisplayName(group),
riseOnHover: true,
icon: L.divIcon({
className: 'group-marker-icon',
html: `<span style="--marker-color:${color}"></span>`,
iconSize: [22, 22],
iconAnchor: [11, 11]
})
});
marker.bindTooltip(tooltipElement(groupDisplayName(group)), {direction: 'top', offset: [0, -12]});
marker.addTo(map);
dispatcherState.markersByGroupId.set(Number(group.id), marker);
updateGroupMarkerOpacity(group);
return marker;
}
function markerOpacityForAge(ageSeconds) {
if (ageSeconds === null || ageSeconds === undefined || !Number.isFinite(ageSeconds)) {
return 1;
}
if (ageSeconds >= GROUP_MARKER_MAX_AGE_SECONDS) return 0;
return Math.max(0, Math.min(
1,
1 - Math.max(0, ageSeconds) / GROUP_MARKER_MAX_AGE_SECONDS
));
}
function updateGroupMarkerOpacity(group, now = Date.now()) {
const marker = dispatcherState.markersByGroupId.get(Number(group.id));
if (!marker) return;
const ageSeconds = group.last_pos_ts
? Math.max(0, (now - group.last_pos_ts) / 1000)
: null;
const opacity = markerOpacityForAge(ageSeconds);
marker.setOpacity(opacity);
const element = marker.getElement();
if (element) element.classList.toggle('is-marker-hidden', opacity <= 0);
if (opacity <= 0) marker.closeTooltip();
}
function placeKnownGroupMarkers() {
dispatcherState.groups.forEach(group => {
if (!hasPosition(group)) return;
createGroupMarker(group, [Number(group.last_lat), Number(group.last_lon)]);
});
}
async function placeUnknownGroupMarkers() {
if (!dispatcherState.groups.some(group => !hasPosition(group))) return;
dispatcherState.browserLatLng = await getBrowserLatLng();
dispatcherState.groups.forEach(group => {
if (hasPosition(group)) return;
const existing = dispatcherState.markersByGroupId.get(Number(group.id));
if (existing) {
existing.setLatLng(dispatcherState.browserLatLng);
} else {
createGroupMarker(group, dispatcherState.browserLatLng);
}
});
}
function getBrowserLatLng() {
return new Promise(resolve => {
if (!navigator.geolocation) {
resolve(map.getCenter());
return;
}
navigator.geolocation.getCurrentPosition(
position => resolve(L.latLng(
position.coords.latitude,
position.coords.longitude
)),
() => resolve(map.getCenter()),
{timeout: 8000, maximumAge: 60000}
);
});
}
function updateMarkerPosition(group) {
if (!hasPosition(group)) return;
const latlng = [Number(group.last_lat), Number(group.last_lon)];
const existing = dispatcherState.markersByGroupId.get(Number(group.id));
if (existing) {
existing.setLatLng(latlng);
existing.setTooltipContent(tooltipElement(groupDisplayName(group)));
} else {
createGroupMarker(group, latlng);
}
updateGroupMarkerOpacity(group);
}
function buildGroupAccordion() {
const container = document.getElementById('groupAccordion');
container.innerHTML = '';
if (!dispatcherState.groups.length) {
const empty = document.createElement('p');
empty.className = 'group-empty';
empty.textContent = 'Keine Gruppen vorhanden.';
container.appendChild(empty);
return;
}
dispatcherState.groups.forEach(group => {
container.appendChild(createGroupElement(group));
});
refreshGroupControls();
}
function createGroupElement(group) {
const details = document.createElement('details');
details.className = 'group-item';
details.dataset.groupId = group.id;
const summary = document.createElement('summary');
const dot = document.createElement('span');
dot.className = 'group-dot';
dot.style.background = groupColor(group);
const name = document.createElement('span');
name.className = 'group-name';
name.textContent = groupDisplayName(group);
const stateBadge = document.createElement('span');
stateBadge.className = 'group-state';
stateBadge.textContent = group.state || 'offen';
summary.append(dot, name, stateBadge);
details.appendChild(summary);
const content = document.createElement('div');
content.className = 'group-details';
const positionRow = document.createElement('div');
positionRow.className = 'group-position-row';
const locateButton = document.createElement('button');
locateButton.type = 'button';
locateButton.className = 'icon-button group-locate';
locateButton.textContent = '📍';
locateButton.title = 'Karte auf Gruppenposition zentrieren';
locateButton.setAttribute('aria-label', 'Karte auf Gruppenposition zentrieren');
locateButton.addEventListener('click', () => locateGroup(group.id));
const progress = document.createElement('progress');
progress.className = 'group-progress';
progress.max = 100;
progress.value = 0;
positionRow.append(locateButton, progress);
const meta = document.createElement('div');
meta.className = 'group-position-meta';
meta.textContent = 'Position unbekannt';
const actions = document.createElement('div');
actions.className = 'group-actions';
const crosshairButton = document.createElement('button');
crosshairButton.type = 'button';
crosshairButton.className = 'icon-button group-crosshair';
crosshairButton.dataset.groupId = group.id;
crosshairButton.textContent = '⌖';
crosshairButton.title = 'Position auf der Karte setzen';
crosshairButton.setAttribute('aria-label', 'Position auf der Karte setzen');
crosshairButton.addEventListener('click', () => toggleCrosshair(group.id));
const streetsButton = document.createElement('button');
streetsButton.type = 'button';
streetsButton.className = 'icon-button group-streets';
streetsButton.dataset.groupId = group.id;
streetsButton.textContent = '☑';
streetsButton.title = 'Straßen dieser Gruppe anzeigen';
streetsButton.setAttribute('aria-label', 'Straßen dieser Gruppe anzeigen');
streetsButton.addEventListener('click', () => openGroupStreetsModal(group.id));
const aliasButton = document.createElement('button');
aliasButton.type = 'button';
aliasButton.className = 'icon-button group-alias';
aliasButton.dataset.groupId = group.id;
aliasButton.textContent = '✎';
aliasButton.title = 'Aliasnamen ändern';
aliasButton.setAttribute('aria-label', 'Aliasnamen ändern');
aliasButton.addEventListener('click', () => openGroupAliasModal(group.id));
const stateSelect = document.createElement('select');
stateSelect.className = 'group-state-select';
stateSelect.dataset.groupId = group.id;
stateSelect.title = 'Status der Gruppe ändern';
stateSelect.setAttribute('aria-label', `Status von ${groupDisplayName(group)} ändern`);
GROUP_STATES.forEach(state => {
const option = document.createElement('option');
option.value = state;
option.textContent = state;
option.selected = state === (group.state || 'offen');
stateSelect.appendChild(option);
});
stateSelect.addEventListener('change', () => changeGroupState(group.id, stateSelect));
actions.append(crosshairButton, streetsButton, aliasButton, stateSelect);
const messageInput = document.createElement('input');
messageInput.type = 'text';
messageInput.className = 'group-message';
messageInput.readOnly = true;
messageInput.placeholder = 'Noch keine Gruppennachricht';
messageInput.title = 'Chatverlauf öffnen';
messageInput.addEventListener('click', () => openChat(group.id));
content.append(positionRow, meta, actions, messageInput);
details.appendChild(content);
return details;
}
function refreshGroupControls(now = Date.now()) {
dispatcherState.groups.forEach(group => {
updateGroupMarkerOpacity(group, now);
const item = document.querySelector(`.group-item[data-group-id="${group.id}"]`);
if (!item) return;
const locateButton = item.querySelector('.group-locate');
const progress = item.querySelector('.group-progress');
const meta = item.querySelector('.group-position-meta');
const known = hasPosition(group);
const positionTs = group.last_pos_ts;
const ageSeconds = positionTs ? Math.max(0, (now - positionTs) / 1000) : null;
let value = 0;
let enabled = false;
if (known) {
if (ageSeconds === null) {
enabled = true;
value = 0;
} else {
value = progressForAge(ageSeconds);
enabled = ageSeconds <= 3600;
}
}
locateButton.disabled = !enabled;
progress.value = Math.round(value);
if (known) {
meta.textContent = positionAgeLabel(ageSeconds);
} else {
meta.textContent = 'Position unbekannt';
}
});
}
function positionAgeLabel(ageSeconds) {
if (ageSeconds === null) return 'unbekannt';
if (ageSeconds < 30) return 'live';
if (ageSeconds < 120) return 'aktuell';
return `${Math.floor(ageSeconds / 60)} min`;
}
function progressForAge(ageSeconds) {
if (ageSeconds < 60) return 100;
if (ageSeconds >= 3600) return 0;
return Math.max(0, Math.min(100, 100 * (3600 - ageSeconds) / 3540));
}
function updateGroupSummary(group) {
const item = document.querySelector(`.group-item[data-group-id="${group.id}"]`);
if (!item) return;
const state = group.state || 'offen';
const badge = item.querySelector('.group-state');
if (badge) badge.textContent = state;
const select = item.querySelector('.group-state-select');
if (select && select.value !== state) select.value = state;
}
function changeGroupState(groupId, select) {
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) return;
const newState = select.value;
if (!GROUP_STATES.includes(newState)) {
select.value = group.state || 'offen';
return;
}
if (newState === (group.state || 'offen')) return;
const sent = sendWs({
code: 200,
msg: JSON.stringify({
group_id: group.id,
state: newState,
actor: currentAccountId
})
});
if (!sent) {
select.value = group.state || 'offen';
return;
}
group.state = newState;
updateGroupSummary(group);
}
function applyGroupAlias(group) {
const item = document.querySelector(`.group-item[data-group-id="${group.id}"]`);
if (item) {
const name = item.querySelector('.group-name');
if (name) name.textContent = groupDisplayName(group);
const stateSelect = item.querySelector('.group-state-select');
if (stateSelect) {
stateSelect.setAttribute(
'aria-label',
`Status von ${groupDisplayName(group)} ändern`
);
}
}
const marker = dispatcherState.markersByGroupId.get(Number(group.id));
if (marker) {
marker.setTooltipContent(tooltipElement(groupDisplayName(group)));
}
if (dispatcherState.streetsDialogGroupId === Number(group.id)
&& document.getElementById('groupStreetsModal').open) {
renderGroupStreetsDialog(group.id);
}
if (dispatcherState.chatGroupId === Number(group.id)
&& document.getElementById('chatModal').open) {
renderChat();
}
const streetModal = document.getElementById('streetModal');
if (streetModal.open) {
const selectedGroupId = document.getElementById('streetGroupSelect').value;
fillStreetGroupOptions(selectedGroupId);
}
}
function openGroupAliasModal(groupId) {
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) return;
dispatcherState.aliasGroupId = Number(group.id);
document.getElementById('groupAliasTitle').textContent =
`Aliasname – ${groupDisplayName(group)}`;
const input = document.getElementById('groupAliasInput');
input.value = group.aliasname || '';
const dialog = document.getElementById('groupAliasModal');
if (!dialog.open) dialog.showModal();
input.focus();
input.select();
}
function closeGroupAliasModal() {
const dialog = document.getElementById('groupAliasModal');
if (dialog.open) dialog.close();
dispatcherState.aliasGroupId = null;
}
async function saveGroupAlias() {
const group = dispatcherState.groupById.get(Number(dispatcherState.aliasGroupId));
if (!group) {
closeGroupAliasModal();
return;
}
const input = document.getElementById('groupAliasInput');
const saveButton = document.getElementById('groupAliasSave');
const aliasname = input.value.trim();
if (saveButton.disabled) return;
saveButton.disabled = true;
try {
const response = await fetch(`${apiBase}/groups/${group.id}/alias`, {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({aliasname})
});
let data = {};
try {
data = await response.json();
} catch (error) {
data = {};
}
if (!response.ok || !data.success) {
throw new Error(data.error || `HTTP ${response.status}`);
}
group.aliasname = data.aliasname ?? aliasname;
applyGroupAlias(group);
closeGroupAliasModal();
} catch (error) {
console.error('Aliasname konnte nicht gespeichert werden:', error);
alert(`Aliasname konnte nicht gespeichert werden: ${error.message}`);
} finally {
saveButton.disabled = false;
}
}
function locateGroup(groupId) {
const group = dispatcherState.groupById.get(Number(groupId));
if (!group || !hasPosition(group)) return;
map.setView([Number(group.last_lat), Number(group.last_lon)], 15);
}
function toggleCrosshair(groupId) {
const id = Number(groupId);
if (dispatcherState.crosshairGroupId === id) {
cancelCrosshair();
return;
}
dispatcherState.crosshairGroupId = id;
map.getContainer().classList.add('crosshair');
updateCrosshairButtons();
}
function cancelCrosshair() {
dispatcherState.crosshairGroupId = null;
map.getContainer().classList.remove('crosshair');
updateCrosshairButtons();
}
function updateCrosshairButtons() {
document.querySelectorAll('.group-crosshair').forEach(button => {
button.classList.toggle(
'active',
Number(button.dataset.groupId) === dispatcherState.crosshairGroupId
);
});
}
function handleMapClick(event) {
const groupId = dispatcherState.crosshairGroupId;
if (!groupId) return;
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) {
cancelCrosshair();
return;
}
const lat = event.latlng.lat;
const lon = event.latlng.lng;
const timestamp = Date.now();
const sent = sendWs({
code: 300,
msg: JSON.stringify({
group_id: group.id,
lat,
lon,
ts: timestamp,
actor: currentAccountId
})
});
if (!sent) {
cancelCrosshair();
return;
}
group.last_lat = lat;
group.last_lon = lon;
group.last_pos_ts = timestamp;
group.last_pos_at = new Date(timestamp).toISOString();
updateMarkerPosition(group);
refreshGroupControls();
cancelCrosshair();
}
/* ------------------------------------------------------------------ */
/* Straßen einer Gruppe */
/* ------------------------------------------------------------------ */
function positionGroupStreetsDialog(dialog, left, top, width = null, height = null) {
const rect = dialog.getBoundingClientRect();
const dialogWidth = width ?? rect.width;
const dialogHeight = height ?? rect.height;
const maxLeft = Math.max(0, window.innerWidth - dialogWidth);
const maxTop = Math.max(0, window.innerHeight - dialogHeight);
dialog.style.left = `${Math.min(Math.max(left, 0), maxLeft)}px`;
dialog.style.top = `${Math.min(Math.max(top, 0), maxTop)}px`;
}
function initGroupStreetsDialogDrag() {
const dialog = document.getElementById('groupStreetsModal');
const header = dialog.querySelector('header');
let dragState = null;
const finishDrag = event => {
if (!dragState || event.pointerId !== dragState.pointerId) return;
if (header.hasPointerCapture?.(event.pointerId)) {
header.releasePointerCapture(event.pointerId);
}
dialog.classList.remove('is-dragging');
dragState = null;
};
header.addEventListener('pointerdown', event => {
if (event.button !== 0 || event.isPrimary === false) return;
if (event.target.closest('button, a, input, select, textarea')) return;
const rect = dialog.getBoundingClientRect();
dragState = {
pointerId: event.pointerId,
startX: event.clientX,
startY: event.clientY,
left: rect.left,
top: rect.top,
width: rect.width,
height: rect.height
};
dialog.style.left = `${rect.left}px`;
dialog.style.top = `${rect.top}px`;
dialog.classList.add('is-dragging');
header.setPointerCapture?.(event.pointerId);
event.preventDefault();
});
header.addEventListener('pointermove', event => {
if (!dragState || event.pointerId !== dragState.pointerId) return;
positionGroupStreetsDialog(
dialog,
dragState.left + event.clientX - dragState.startX,
dragState.top + event.clientY - dragState.startY,
dragState.width,
dragState.height
);
});
header.addEventListener('pointerup', finishDrag);
header.addEventListener('pointercancel', finishDrag);
window.addEventListener('resize', () => {
if (!dialog.open) return;
const rect = dialog.getBoundingClientRect();
positionGroupStreetsDialog(dialog, rect.left, rect.top);
});
}
function openGroupStreetsModal(groupId) {
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) return;
dispatcherState.streetsDialogGroupId = Number(group.id);
renderGroupStreetsDialog(group.id);
const dialog = document.getElementById('groupStreetsModal');
if (!dialog.open) dialog.show();
const rect = dialog.getBoundingClientRect();
positionGroupStreetsDialog(dialog, rect.left, rect.top);
}
function closeGroupStreetsModal() {
const dialog = document.getElementById('groupStreetsModal');
if (dialog.open) dialog.close();
dispatcherState.streetsDialogGroupId = null;
}
function renderGroupStreetsDialog(groupId) {
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) {
closeGroupStreetsModal();
return;
}
document.getElementById('groupStreetsTitle').textContent =
`Straßen – ${groupDisplayName(group)}`;
const container = document.getElementById('groupStreetsContent');
container.innerHTML = '';
const assigned = dispatcherState.streets
.filter(street => Number(street.group_id) === Number(group.id))
.sort((a, b) => String(a.name).localeCompare(String(b.name), 'de'));
if (!assigned.length) {
const empty = document.createElement('p');
empty.className = 'group-streets-empty';
empty.textContent = 'Dieser Gruppe sind noch keine Straßen zugewiesen.';
container.appendChild(empty);
return;
}
const assignedStreets = assigned.filter(street => street.state === 'zugewiesen');
const completedStreets = assigned.filter(street => street.state === 'erledigt');
const otherStreets = assigned.filter(
street => street.state !== 'zugewiesen' && street.state !== 'erledigt'
);
appendGroupStreetSection(container, 'Zugewiesen', assignedStreets, true);
if (completedStreets.length) {
appendGroupStreetSection(container, 'Erledigt', completedStreets, false);
}
if (otherStreets.length) {
appendGroupStreetSection(container, 'Weitere', otherStreets, false);
}
}
function appendGroupStreetSection(container, title, streets, showEmpty) {
const section = document.createElement('section');
section.className = 'group-streets-section';
const heading = document.createElement('h4');
heading.textContent = title;
section.appendChild(heading);
if (!streets.length) {
if (showEmpty) {
const empty = document.createElement('p');
empty.className = 'group-streets-empty';
empty.textContent = 'Keine Straßen im Zustand „zugewiesen“.';
section.appendChild(empty);
}
container.appendChild(section);
return;
}
const list = document.createElement('ul');
list.className = 'group-streets-list';
streets.forEach(street => {
const item = document.createElement('li');
const button = document.createElement('button');
button.type = 'button';
button.className = 'group-street-entry';
button.title = `Auf die Bounding Box von ${street.name} zoomen`;
const name = document.createElement('span');
name.className = 'group-street-name';
name.textContent = street.name;
const state = document.createElement('span');
state.className = 'group-street-state';
state.textContent = street.state;
button.append(name, state);
button.addEventListener('click', () => zoomToStreet(street.id));
item.appendChild(button);
list.appendChild(item);
});
section.appendChild(list);
container.appendChild(section);
}
function zoomToStreet(streetId) {
const street = dispatcherState.streetById.get(Number(streetId));
if (!street) return;
let bounds = bboxToBounds(street.bbox);
if (!bounds || !bounds.isValid()) {
const lines = dispatcherState.polylinesByStreetId.get(Number(street.id)) || [];
const fallback = L.latLngBounds([]);
lines.forEach(line => {
line.getLatLngs().forEach(latlng => fallback.extend(latlng));
});
if (fallback.isValid()) bounds = fallback;
}
if (!bounds || !bounds.isValid()) return;
map.fitBounds(bounds, {padding: [30, 30], maxZoom: 18});
}
/* ------------------------------------------------------------------ */
/* Straßensuche und Hausnummern */
/* ------------------------------------------------------------------ */
const STREET_SEARCH_MIN_CHARS = 2;
const STREET_SEARCH_MAX_RESULTS = 8;
function normalizeStreetSearchText(value) {
return String(value || '')
.trim()
.toLocaleLowerCase('de-DE')
.replace(/ß/g, 'ss')
.normalize('NFD')
.replace(/[\u0300-\u036f]/g, '')
.replace(/\s+/g, ' ');
}
function findStreetBySearchName(value) {
const normalized = normalizeStreetSearchText(value);
if (!normalized) return null;
return dispatcherState.streets.find(street => (
normalizeStreetSearchText(street.name) === normalized
)) || null;
}
function splitStreetAndHouseNumber(value) {
const text = String(value || '').trim();
const match = text.match(/^(.*\S)\s+([0-9][0-9A-Za-zÄÖÜäöüß.\/-]*)$/u);
if (!match) return {streetText: text, houseNumber: null};
return {
streetText: match[1].trim(),
houseNumber: match[2]
};
}
function parseStreetSearch(value) {
const text = String(value || '').trim();
if (!text) {
return {text: '', streetText: '', houseNumber: null, street: null};
}
// Ein vollständiger Straßenname hat Vorrang, auch wenn er auf eine Zahl endet.
const exactStreet = findStreetBySearchName(text);
if (exactStreet) {
return {
text,
streetText: exactStreet.name,
houseNumber: null,
street: exactStreet
};
}
const split = splitStreetAndHouseNumber(text);
if (split.houseNumber) {
const street = findStreetBySearchName(split.streetText);
return {
text,
streetText: street ? street.name : split.streetText,
houseNumber: split.houseNumber,
street
};
}
return {text, streetText: text, houseNumber: null, street: null};
}
function getStreetSearchResults(streetText) {
const normalized = normalizeStreetSearchText(streetText);
if (normalized.length < STREET_SEARCH_MIN_CHARS) return [];
return dispatcherState.streets
.filter(street => normalizeStreetSearchText(street.name).startsWith(normalized))
.sort((a, b) => String(a.name).localeCompare(String(b.name), 'de'))
.slice(0, STREET_SEARCH_MAX_RESULTS);
}
function setStreetSearchStatus(text, isError = false) {
const element = document.getElementById('streetSearchStatus');
if (!element) return;
element.textContent = text || '';
element.classList.toggle('error', Boolean(text) && isError);
}
function closeStreetSearchResults() {
const list = document.getElementById('streetSearchResults');
const input = document.getElementById('streetSearchInput');
if (list) {
list.hidden = true;
list.innerHTML = '';
}
if (input) {
input.setAttribute('aria-expanded', 'false');
input.removeAttribute('aria-activedescendant');
}
dispatcherState.streetSearchResults = [];
dispatcherState.streetSearchActiveIndex = -1;
}
function setActiveStreetSearchIndex(index) {
const list = document.getElementById('streetSearchResults');
const input = document.getElementById('streetSearchInput');
const results = dispatcherState.streetSearchResults;
if (!list || !input || !results.length) return;
const normalizedIndex = ((index % results.length) + results.length) % results.length;
dispatcherState.streetSearchActiveIndex = normalizedIndex;
list.querySelectorAll('.street-search-option').forEach((option, optionIndex) => {
const active = optionIndex === normalizedIndex;
option.classList.toggle('is-active', active);
option.setAttribute('aria-selected', active ? 'true' : 'false');
});
const activeOption = list.querySelector(
`.street-search-option[data-index="${normalizedIndex}"]`
);
if (activeOption) {
input.setAttribute('aria-activedescendant', activeOption.id);
activeOption.scrollIntoView?.({block: 'nearest'});
}
}
function renderStreetSearchResults(results) {
const list = document.getElementById('streetSearchResults');
const input = document.getElementById('streetSearchInput');
if (!list || !input) return;
if (!results.length) {
closeStreetSearchResults();
return;
}
dispatcherState.streetSearchResults = results;
dispatcherState.streetSearchActiveIndex = -1;
list.innerHTML = '';
results.forEach((street, index) => {
const option = document.createElement('li');
option.id = `streetSearchOption${index}`;
option.className = 'street-search-option';
option.dataset.index = String(index);
option.setAttribute('role', 'option');
option.setAttribute('aria-selected', 'false');
option.textContent = street.name;
// Fokus im Eingabefeld halten, damit der Klick nicht vom blur-
// Handler verschluckt wird.
option.addEventListener('mousedown', event => event.preventDefault());
option.addEventListener('mouseenter', () => setActiveStreetSearchIndex(index));
option.addEventListener('click', () => selectStreetSearchResult(street));
list.appendChild(option);
});
list.hidden = false;
input.setAttribute('aria-expanded', 'true');
setActiveStreetSearchIndex(0);
}
function updateStreetSearchSuggestions() {
const input = document.getElementById('streetSearchInput');
if (!input) return;
const parsed = parseStreetSearch(input.value);
if (parsed.streetText.length < STREET_SEARCH_MIN_CHARS) {
closeStreetSearchResults();
return;
}
const results = parsed.street
? [parsed.street]
: getStreetSearchResults(parsed.streetText);
renderStreetSearchResults(results);
}
function handleStreetSearchInput() {
setStreetSearchStatus('');
updateStreetSearchSuggestions();
}
function handleStreetSearchKeydown(event) {
if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
if (!dispatcherState.streetSearchResults.length) {
updateStreetSearchSuggestions();
}
if (!dispatcherState.streetSearchResults.length) return;
event.preventDefault();
const direction = event.key === 'ArrowDown' ? 1 : -1;
setActiveStreetSearchIndex(
dispatcherState.streetSearchActiveIndex + direction
);
return;
}
if (event.key === 'Escape') {
closeStreetSearchResults();
return;
}
if (event.key !== 'Enter') return;
event.preventDefault();
const input = document.getElementById('streetSearchInput');
const parsed = parseStreetSearch(input.value);
if (dispatcherState.streetSearchResults.length
&& dispatcherState.streetSearchActiveIndex >= 0) {
selectStreetSearchResult(
dispatcherState.streetSearchResults[
dispatcherState.streetSearchActiveIndex
]
);
return;
}
if (parsed.street) {
performStreetSearch(input.value, parsed.street);
return;
}
const results = getStreetSearchResults(parsed.streetText);
if (results.length) {
selectStreetSearchResult(results[0]);
return;
}
closeStreetSearchResults();
setStreetSearchStatus('Keine Straße gefunden.', true);
}
function selectStreetSearchResult(street) {
const input = document.getElementById('streetSearchInput');
const parsed = parseStreetSearch(input.value);
const houseNumber = parsed.houseNumber;
input.value = houseNumber ? `${street.name} ${houseNumber}` : street.name;
closeStreetSearchResults();
performStreetSearch(input.value, street);
}
async function performStreetSearch(value, selectedStreet = null) {
const input = document.getElementById('streetSearchInput');
const text = String(value ?? input.value ?? '').trim();
const parsed = parseStreetSearch(text);
let street = selectedStreet || parsed.street;
if (!street) {
const results = getStreetSearchResults(parsed.streetText);
street = results[0] || null;
}
if (!street) {
closeStreetSearchResults();
setStreetSearchStatus('Keine Straße gefunden.', true);
return;
}
const houseNumber = parsed.houseNumber;
const requestId = ++dispatcherState.streetSearchRequestId;
clearHouseNumberMarker();
closeStreetSearchResults();
setStreetSearchStatus('');
input.value = houseNumber ? `${street.name} ${houseNumber}` : street.name;
zoomToStreet(street.id);
if (!houseNumber) return;
setStreetSearchStatus(`Hausnummer ${houseNumber} wird gesucht …`);
try {
const params = new URLSearchParams({
street: street.name,
house_number: houseNumber
});
const data = await fetchJson(`${apiBase}/init/hausnummern?${params.toString()}`);
if (requestId !== dispatcherState.streetSearchRequestId) return;
const latitude = Number(data.latitude);
const longitude = Number(data.longitude);
if (!data.found || !Number.isFinite(latitude) || !Number.isFinite(longitude)) {
setStreetSearchStatus(
`Für Hausnummer ${houseNumber} ist keine Koordinate hinterlegt.`
);
return;
}
setHouseNumberMarker(
[latitude, longitude],
`${street.name} ${houseNumber}`
);
setStreetSearchStatus(`Hausnummer ${houseNumber} markiert.`);
} catch (error) {
if (requestId !== dispatcherState.streetSearchRequestId) return;
console.error('Hausnummer konnte nicht geladen werden:', error);
setStreetSearchStatus('Hausnummer konnte nicht geladen werden.', true);
}
}
function clearHouseNumberMarker() {
if (!dispatcherState.houseNumberMarker) return;
map.removeLayer(dispatcherState.houseNumberMarker);
dispatcherState.houseNumberMarker = null;
}
function setHouseNumberMarker(latlng, label) {
clearHouseNumberMarker();
const marker = L.marker(latlng, {
title: label,
keyboard: true,
icon: L.divIcon({
className: 'house-number-marker-icon',
html: '<span class="house-number-flag"><span class="house-number-flag-label"></span></span>',
iconSize: null,
iconAnchor: [0, 34]
})
});
marker.addTo(map);
const labelElement = marker.getElement()?.querySelector('.house-number-flag-label');
if (labelElement) labelElement.textContent = label;
marker.bindTooltip(tooltipElement(label), {direction: 'top', offset: [0, -8]});
marker.on('click', event => {
if (event.originalEvent) L.DomEvent.stopPropagation(event.originalEvent);
clearHouseNumberMarker();
setStreetSearchStatus('Markierung entfernt.');
});
dispatcherState.houseNumberMarker = marker;
}
function initStreetSearch() {
const input = document.getElementById('streetSearchInput');
if (!input) return;
input.addEventListener('input', handleStreetSearchInput);
input.addEventListener('keydown', handleStreetSearchKeydown);
input.addEventListener('focus', () => {
if (input.value.trim()) updateStreetSearchSuggestions();
});
input.addEventListener('blur', () => {
window.setTimeout(closeStreetSearchResults, 120);
});
}
/* ------------------------------------------------------------------ */
/* Straßen-Dialog */
/* ------------------------------------------------------------------ */
function openStreetModal(streetId) {
const street = dispatcherState.streetById.get(Number(streetId));
if (!street) return;
dispatcherState.currentStreetId = Number(streetId);
document.getElementById('streetModalTitle').textContent = `Straße: ${street.name}`;
document.getElementById('streetStateSelect').value = street.state || 'unbearbeitet';
fillStreetGroupOptions(street.group_id);
updateStreetGroupVisibility();
document.getElementById('streetModal').showModal();
}
function closeStreetModal() {
document.getElementById('streetModal').close();
}
function fillStreetGroupOptions(selectedGroupId) {
const select = document.getElementById('streetGroupSelect');
select.innerHTML = '';
const empty = document.createElement('option');
empty.value = '';
empty.textContent = '-';
select.appendChild(empty);
dispatcherState.groups.forEach(group => {
const option = document.createElement('option');
option.value = group.id;
option.textContent = groupDisplayName(group);
option.selected = Number(selectedGroupId) === Number(group.id);
select.appendChild(option);
});
}
function updateStreetGroupVisibility() {
const state = document.getElementById('streetStateSelect').value;
const groupSelect = document.getElementById('streetGroupSelect');
const groupLabel = document.getElementById('streetGroupLabel');
const enabled = state === 'zugewiesen';
groupSelect.disabled = !enabled;
groupLabel.classList.toggle('muted', !enabled);
}
function saveStreetState() {
const street = dispatcherState.streetById.get(dispatcherState.currentStreetId);
if (!street) return;
const newState = document.getElementById('streetStateSelect').value;
if (!STREET_STATES.includes(newState)) return;
let groupId = null;
if (newState === 'zugewiesen') {
groupId = Number(document.getElementById('streetGroupSelect').value) || null;
if (!groupId) {
alert('Bitte eine Gruppe auswählen.');
return;
}
} else if (newState === 'erledigt' && street.group_id) {
// Bei "erledigt" bleibt eine bestehende Gruppenzuordnung erhalten.
groupId = Number(street.group_id);
}
const sent = sendWs({
code: 100,
msg: JSON.stringify({
name: street.name,
state: newState,
actor: currentAccountId,
street_id: street.id,
group_id: groupId
})
});
if (sent) closeStreetModal();
}
/* ------------------------------------------------------------------ */
/* Nachrichten und Chat */
/* ------------------------------------------------------------------ */
function openChat(groupId) {
dispatcherState.chatGroupId = Number(groupId);
renderChat();
document.getElementById('chatModal').showModal();
}
function closeChatModal() {
document.getElementById('chatModal').close();
}
function renderChat() {
const group = dispatcherState.groupById.get(Number(dispatcherState.chatGroupId));
if (!group) return;
document.getElementById('chatTitle').textContent =
`Chat – ${groupDisplayName(group)}`;
const container = document.getElementById('chatMessages');
container.innerHTML = '';
const entries = dispatcherState.chatByGroup.get(Number(group.id)) || [];
if (!entries.length) {
const empty = document.createElement('div');
empty.className = 'chat-empty';
empty.textContent = 'Noch keine Nachrichten.';
container.appendChild(empty);
return;
}
entries
.slice()
.sort((a, b) => a.ts - b.ts)
.forEach(entry => {
const message = document.createElement('div');
message.className = 'chat-message';
if (Number(entry.sender_id) === currentAccountId) {
message.classList.add('own');
}
const header = document.createElement('div');
header.className = 'chat-message-header';
const sender = document.createElement('span');
sender.textContent = senderLabel(entry.sender_id);
const time = document.createElement('span');
time.textContent = formatChatTime(entry.ts);
header.append(sender, time);
const text = document.createElement('div');
text.className = 'chat-message-text';
text.textContent = entry.text;
message.append(header, text);
container.appendChild(message);
});
container.scrollTop = container.scrollHeight;
}
function senderLabel(senderId) {
const id = Number(senderId);
if (id === currentAccountId) return 'Ich';
const group = dispatcherState.groups.find(item => Number(item.account_id) === id);
if (group) return groupDisplayName(group);
return id ? `Account ${id}` : 'System';
}
function formatChatTime(timestamp) {
if (!timestamp) return '';
const date = new Date(timestamp);
if (Number.isNaN(date.getTime())) return '';
return date.toLocaleString('de-DE', {
day: '2-digit',
month: '2-digit',
hour: '2-digit',
minute: '2-digit',
second: '2-digit',
hour12: false
});
}
function addChatMessage(groupId, entry) {
const id = Number(groupId);
if (!dispatcherState.groupById.has(id)) return;
if (!dispatcherState.chatByGroup.has(id)) {
dispatcherState.chatByGroup.set(id, []);
}
if (!dispatcherState.chatKeysByGroup.has(id)) {
dispatcherState.chatKeysByGroup.set(id, new Set());
}
const keys = dispatcherState.chatKeysByGroup.get(id);
const key = `${entry.code}|${entry.sender_id}|${entry.ts}|${entry.text}`;
if (keys.has(key)) return;
keys.add(key);
dispatcherState.chatByGroup.get(id).push(entry);
if (dispatcherState.chatGroupId === id
&& document.getElementById('chatModal').open) {
renderChat();
}
}
function addBroadcastChatMessage(entry) {
dispatcherState.groups.forEach(group => addChatMessage(group.id, entry));
}
function extractMessageText(value) {
if (typeof value === 'string') return value;
if (value === null || value === undefined) return '';
if (typeof value === 'object') return JSON.stringify(value);
return String(value);
}
function parsePayload(value) {
if (value && typeof value === 'object') return value;
if (typeof value !== 'string') return null;
try {
const parsed = JSON.parse(value);
return parsed && typeof parsed === 'object' ? parsed : null;
} catch (error) {
return null;
}
}
function handleGroupChatMessage(message) {
const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId);
if (!group) return;
const text = extractMessageText(payload.text ?? payload.msg ?? '');
const input = document.querySelector(
`.group-item[data-group-id="${group.id}"] .group-message`
);
if (input) input.value = text;
addChatMessage(group.id, {
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
}
/* ------------------------------------------------------------------ */
/* WebSocket */
/* ------------------------------------------------------------------ */
async function connectWebSocket() {
if (dispatcherState.unloading) return;
if (dispatcherState.ws
&& (dispatcherState.ws.readyState === WebSocket.OPEN
|| dispatcherState.ws.readyState === WebSocket.CONNECTING)) {
return;
}
try {
const tokenResponse = await fetchJson(`${apiBase}/auth/ws-token`);
const token = tokenResponse.token;
const ws = new WebSocket(wsUrl);
dispatcherState.ws = ws;
ws.addEventListener('open', () => {
ws.send(JSON.stringify({code: 0, msg: token}));
dispatcherState.authenticated = true;
setConnectionStatus('Verbunden', 'connected');
});
ws.addEventListener('message', handleWsMessage);
ws.addEventListener('close', () => {
dispatcherState.authenticated = false;
setConnectionStatus('Getrennt – neuer Versuch …', 'disconnected');
scheduleReconnect();
});
ws.addEventListener('error', () => {
setConnectionStatus('Verbindungsfehler', 'disconnected');
});
} catch (error) {
console.error('WebSocket-Token konnte nicht geladen werden:', error);
setConnectionStatus('Token nicht verfügbar – neuer Versuch …', 'disconnected');
scheduleReconnect();
}
}
function scheduleReconnect() {
if (dispatcherState.unloading || dispatcherState.reconnectTimer) return;
dispatcherState.reconnectTimer = setTimeout(() => {
dispatcherState.reconnectTimer = null;
connectWebSocket();
}, 3000);
}
function setConnectionStatus(text, cssClass) {
const element = document.getElementById('connectionStatus');
if (!element) return;
element.textContent = text;
element.classList.remove('connected', 'disconnected');
if (cssClass) element.classList.add(cssClass);
}
function sendWs(message) {
if (!dispatcherState.ws
|| dispatcherState.ws.readyState !== WebSocket.OPEN
|| !dispatcherState.authenticated) {
alert('Die WebSocket-Verbindung ist noch nicht verfügbar.');
return false;
}
dispatcherState.ws.send(JSON.stringify(message));
return true;
}
function handleWsMessage(event) {
let message;
try {
message = JSON.parse(event.data);
} catch (error) {
console.warn('Ungültige WebSocket-Nachricht:', event.data);
return;
}
switch (Number(message.code)) {
case 1:
// Heartbeat des Servers beantworten.
if (dispatcherState.ws && dispatcherState.ws.readyState === WebSocket.OPEN) {
dispatcherState.ws.send(JSON.stringify({code: 2, msg: 'pong'}));
}
break;
case 100:
handleStreetUpdate(message);
break;
case 200:
handleGroupStateUpdate(message);
break;
case 300:
handleGroupPositionUpdate(message);
break;
case 1000: {
const text = extractMessageText(message.msg);
addBroadcastChatMessage({
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
break;
}
case 1100: {
const groupId = Number(message.receiver_id);
const text = extractMessageText(message.msg);
addChatMessage(groupId, {
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
break;
}
case 2000:
handleGroupChatMessage(message);
break;
default:
break;
}
}
function handleStreetUpdate(message) {
const payload = parsePayload(message.msg) || {};
let street = payload.street_id
? dispatcherState.streetById.get(Number(payload.street_id))
: null;
if (!street && payload.name) {
street = dispatcherState.streets.find(item => item.name === payload.name);
}
if (!street) return;
if (STREET_STATES.includes(payload.state)) {
street.state = payload.state;
}
if (Object.prototype.hasOwnProperty.call(payload, 'group_id')) {
street.group_id = payload.group_id === null || payload.group_id === ''
? null
: Number(payload.group_id);
}
recolorStreet(street);
const streetsDialog = document.getElementById('groupStreetsModal');
if (dispatcherState.streetsDialogGroupId && streetsDialog.open) {
renderGroupStreetsDialog(dispatcherState.streetsDialogGroupId);
}
}
function handleGroupStateUpdate(message) {
const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId);
if (!group) return;
if (GROUP_STATES.includes(payload.state)) {
group.state = payload.state;
updateGroupSummary(group);
}
}
function handleGroupPositionUpdate(message) {
const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId);
if (!group) return;
const lat = Number(payload.lat);
const lon = Number(payload.lon);
if (Number.isFinite(lat) && Number.isFinite(lon)
&& payload.lat !== null && payload.lon !== null) {
group.last_lat = lat;
group.last_lon = lon;
// Code 300 kann den Zeitstempel als Millisekunden (Broker) oder als
// SQLite-/ISO-Zeitstring (z. B. aus der History-Wiederherstellung)
// enthalten.
group.last_pos_ts = parseTimestamp(payload.ts) || Date.now();
group.last_pos_at = new Date(group.last_pos_ts).toISOString();
updateMarkerPosition(group);
} else {
// Positionslöschung (null-Koordinaten): Marker an die Browserposition
// verschieben, da der eigentliche Standort unbekannt ist.
group.last_lat = null;
group.last_lon = null;
group.last_pos_at = null;
group.last_pos_ts = null;
const marker = dispatcherState.markersByGroupId.get(group.id);
if (marker) marker.setLatLng(dispatcherState.browserLatLng || map.getCenter());
}
refreshGroupControls();
}
/* ------------------------------------------------------------------ */
/* Uhr, Slider und Footer */
/* ------------------------------------------------------------------ */
function updateClock() {
const now = new Date();
const timeElement = document.getElementById('clockTime');
if (timeElement) {
timeElement.textContent = now.toLocaleTimeString('de-DE', {hour12: false});
}
const weekdayElement = document.getElementById('clockWeekday');
if (weekdayElement) {
weekdayElement.textContent = now
.toLocaleDateString('de-DE', {weekday: 'short'})
.replace('.', '')
.slice(0, 2);
}
const dayElement = document.getElementById('clockDay');
if (dayElement) {
dayElement.textContent = now.toLocaleDateString('de-DE', {
day: '2-digit',
month: '2-digit',
year: 'numeric'
});
}
refreshGroupControls(now.getTime());
}
function applySettingsToUi() {
const opacitySlider = document.getElementById('opacitySlider');
const weightSlider = document.getElementById('weightSlider');
if (opacitySlider) opacitySlider.value = dispatcherState.settings.opacity;
if (weightSlider) weightSlider.value = dispatcherState.settings.weight;
updateOpacityOutput();
updateWeightOutput();
updateAllPolylineStyles();
}
function updateOpacityOutput() {
const output = document.getElementById('opacityValue');
if (output) output.textContent = Number(dispatcherState.settings.opacity).toFixed(2);
}
function updateWeightOutput() {
const output = document.getElementById('weightValue');
if (output) output.textContent = `${dispatcherState.settings.weight} m`;
}
function parseTimestamp(value) {
if (value === null || value === undefined || value === '') return null;
if (typeof value === 'number') return normalizeTimestamp(value);
const text = String(value).trim();
if (/^\d+$/.test(text)) return normalizeTimestamp(Number(text));
let iso = text.replace(' ', 'T');
if (!/[zZ]|[+-]\d{2}:?\d{2}$/.test(iso)) {
iso += 'Z';
}
const parsed = Date.parse(iso);
return Number.isNaN(parsed) ? null : parsed;
}
function normalizeTimestamp(value) {
const number = Number(value);
if (!Number.isFinite(number) || number <= 0) return null;
return number < 1e12 ? number * 1000 : number;
}
/* ------------------------------------------------------------------ */
/* Statische UI-Elemente */
/* ------------------------------------------------------------------ */
function bindStaticUi() {
initTheme();
initStreetSearch();
document.getElementById('baseLayerSelect').addEventListener('change', event => {
setBaseLayer(event.target.value);
});
document.getElementById('opacitySlider').addEventListener('input', event => {
dispatcherState.settings.opacity = clampNumber(
event.target.value, 0, 1, DEFAULT_SETTINGS.opacity
);
updateOpacityOutput();
updateAllPolylineStyles();
saveStoredSettings();
});
document.getElementById('weightSlider').addEventListener('input', event => {
dispatcherState.settings.weight = clampNumber(
event.target.value, 1, 100, DEFAULT_SETTINGS.weight
);
updateWeightOutput();
updateAllPolylineStyles();
saveStoredSettings();
});
document.getElementById('fitBoundsButton').addEventListener('click', fitAllStreetBounds);
document.getElementById('speakerButton').addEventListener('click', openSpeakerModal);
document.getElementById('streetStateSelect').addEventListener('change', updateStreetGroupVisibility);
document.getElementById('groupAliasInput').addEventListener('keydown', event => {
if (event.key !== 'Enter') return;
event.preventDefault();
saveGroupAlias();
});
initGroupStreetsDialogDrag();
document.addEventListener('keydown', event => {
if (event.key === 'Escape' && dispatcherState.crosshairGroupId) {
cancelCrosshair();
}
});
}
function openSpeakerModal() {
document.getElementById('speakerText').value = '';
document.getElementById('speakerModal').showModal();
}
function closeSpeakerModal() {
document.getElementById('speakerModal').close();
}
function sendSpeakerMessage() {
const input = document.getElementById('speakerText');
const text = input.value.trim();
if (!text) return;
if (sendWs({code: 1000, msg: text})) {
input.value = '';
closeSpeakerModal();
}
}
function showAccordionError(text) {
const container = document.getElementById('groupAccordion');
container.innerHTML = '';
const message = document.createElement('p');
message.className = 'group-empty';
message.textContent = text;
container.appendChild(message);
}