Files
Sternsinger/CMBNet/static/js/views/dispatcher.js
T
2026-11-09 12:04:51 +01:00

3716 lines
124 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 appUrl = window.CMBNET_APP_URL || ((path) => `/${String(path || '').replace(/^\/+/, '')}`);
const tenant = window.CMBNET_TENANT || '';
const apiBase = appUrl(`${tenant}/api`);
const wsUrl = `${window.location.protocol === 'https:' ? 'wss' : 'ws'}://${window.location.host}${appUrl(`${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 GROUP_POSITION_ZOOM_DEFAULT = 18;
const GROUP_POSITION_ZOOM_MIN = 1;
const GROUP_POSITION_ZOOM_MAX = 22;
const GROUP_STREET_HOVER_COLOR = '#f5c518';
const STREET_COLORS = {
unbearbeitet: '#1f6feb',
zugewiesen: '#d62828',
erledigt: '#2e9e4f'
};
const dispatcherState = {
settings: {...DEFAULT_SETTINGS},
streets: [],
streetById: new Map(),
groups: [],
groupById: new Map(),
accounts: [],
accountById: new Map(),
lastCode0ReceivedAt: Date.now(),
heartbeatTimeoutId: null,
heartbeatWarningShown: false,
groupMessageTargetId: null,
polylinesByStreetId: new Map(),
markersByGroupId: new Map(),
browserLatLng: null,
ws: null,
authenticated: false,
reconnectTimer: null,
lastWsSeq: null,
crosshairGroupId: null,
currentStreetId: null,
streetsDialogGroupId: null,
streetsDialogSelectedStreetIds: new Set(),
streetsDialogHoverId: null,
aliasGroupId: null,
chatGroupId: null,
chatByGroup: new Map(),
chatKeysByGroup: new Map(),
infoMessages: [],
infoMessageKeys: new Set(),
streetSearchResults: [],
streetSearchActiveIndex: -1,
streetSearchRequestId: 0,
houseNumberMarker: null,
unloading: false
};
const AudioContext = window.AudioContext || window.webkitAudioContext;
const audioCtx = new AudioContext();
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, accounts] = await Promise.all([
fetchJson(`${apiBase}/init/streets`),
fetchJson(`${apiBase}/init/groups`),
fetchJson(`${apiBase}/init/accounts`).catch(() => [])
]);
dispatcherState.streets = Array.isArray(streets) ? streets : [];
dispatcherState.groups = Array.isArray(groups) ? groups : [];
dispatcherState.accounts = Array.isArray(accounts) ? accounts : [];
indexData();
buildPolylines();
if (window.CMBNET_VIEW_MODE === 'observer') {
const accordion = document.getElementById('groupAccordion');
if (accordion) {
accordion.innerHTML = '';
}
} else {
buildGroupAccordion();
}
applySettingsToUi();
placeKnownGroupMarkers();
} catch (error) {
console.error('Initialdaten konnten nicht geladen werden:', error);
const accordion = document.getElementById('groupAccordion');
if (accordion && typeof showAccordionError === 'function') {
showAccordionError('Die Straßen und Gruppen konnten nicht geladen werden.');
}
}
ensureInitialView();
updateAllPolylineStyles();
placeUnknownGroupMarkers();
if (window.CMBNET_VIEW_MODE === 'observer') {
setInterval(() => {
const now = Date.now();
dispatcherState.groups.forEach(group => {
updateGroupMarkerOpacity(group, now);
const marker = dispatcherState.markersByGroupId.get(Number(group.id));
if (marker) {
updateGroupMarkerLabel(group, marker);
updateGroupMarkerTooltip(group, marker);
}
});
}, 30000);
}
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);
dispatcherState.accountById.clear();
dispatcherState.accounts.forEach(account => {
account.id = Number(account.id);
dispatcherState.accountById.set(account.id, account);
});
}
/* ------------------------------------------------------------------ */
/* 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 streetDisplayName(street) {
if (!street) return '';
const zusatz = String(street.zusatz || '').trim();
return zusatz ? `${street.name} ${zusatz}` : String(street.name || '');
}
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);
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(`${streetDisplayName(street)} (${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, street) {
if (!street || !street.name) return null;
const name = String(street.name).trim();
const zusatz = String(street.zusatz || '').trim();
const keys = zusatz ? [`${name} ${zusatz}`, name] : [name];
for (const key of keys) {
if (Array.isArray(fragments[key])) return fragments[key];
const lower = key.toLowerCase();
const matchingKey = Object.keys(fragments).find(
candidate => candidate.toLowerCase() === lower
);
if (matchingKey && Array.isArray(fragments[matchingKey])) {
return fragments[matchingKey];
}
}
return 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 isDispatcherView() {
return window.CMBNET_VIEW_MODE !== 'observer';
}
function streetIsInActiveGroupDialog(street) {
if (!isDispatcherView()) return true;
const dialogGroupId = dispatcherState.streetsDialogGroupId;
if (dialogGroupId === null || dialogGroupId === undefined) return true;
return Boolean(street)
&& Number(street.group_id) === Number(dialogGroupId);
}
function polylineOpacityForStreet(street) {
return streetIsInActiveGroupDialog(street)
? dispatcherState.settings.opacity
: 0;
}
function streetPolylineColor(street) {
if (!street) return STREET_COLORS.unbearbeitet;
if (dispatcherState.streetsDialogHoverId === Number(street.id)) {
return GROUP_STREET_HOVER_COLOR;
}
return STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet;
}
function recolorStreet(street) {
const lines = dispatcherState.polylinesByStreetId.get(Number(street.id));
if (!lines) return;
lines.forEach(line => {
line.setStyle({
color: streetPolylineColor(street),
opacity: polylineOpacityForStreet(street),
weight: currentPolylineWeight()
});
line.setTooltipContent(tooltipElement(`${streetDisplayName(street)} (${street.state})`));
});
}
function updateAllPolylineStyles() {
const weight = currentPolylineWeight();
dispatcherState.polylinesByStreetId.forEach((lines, streetId) => {
const street = dispatcherState.streetById.get(Number(streetId));
const opacity = street
? polylineOpacityForStreet(street)
: dispatcherState.settings.opacity;
lines.forEach(line => {
line.setStyle({opacity, weight});
});
});
}
/* ------------------------------------------------------------------ */
/* Gruppen, Marker und Accordion */
/* ------------------------------------------------------------------ */
function groupDisplayName(group) {
return group.aliasname && String(group.aliasname).trim()
? String(group.aliasname)
: String(group.id);
}
function findGroupForAccount(accountId) {
const id = Number(accountId);
if (!Number.isFinite(id)) return null;
return dispatcherState.groups.find(group =>
Array.isArray(group.account_ids)
&& group.account_ids.some(value => Number(value) === id)
) || null;
}
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 getGroupAgeInfo(group, now = Date.now()) {
if (!group.last_pos_ts) {
return {text: 'unbekannt', ageSeconds: null};
}
const ageSeconds = Math.max(0, (now - group.last_pos_ts) / 1000);
if (ageSeconds <= 120) {
return {text: 'live', ageSeconds};
}
if (ageSeconds <= 600) {
return {text: 'aktuell', ageSeconds};
}
const minutes = Math.floor(ageSeconds / 60);
if (minutes < 60) {
return {text: `${minutes} min`, ageSeconds};
}
const hours = Math.floor(minutes / 60);
const restMinutes = minutes % 60;
if (restMinutes === 0) {
return {text: `${hours} h`, ageSeconds};
}
return {text: `${hours} h ${restMinutes} min`, ageSeconds};
}
function getGroupLastMessagePreview(groupId) {
const entries = dispatcherState.chatByGroup.get(Number(groupId)) || [];
if (!entries.length) return '';
const sorted = entries.slice().sort((a, b) => (b.ts || 0) - (a.ts || 0));
const latest = sorted[0];
const text = extractMessageText(latest.text ?? latest.msg ?? '');
if (!text) return '';
return text.length > 80 ? `${text.slice(0, 77)}...` : text;
}
function updateGroupMarkerLabel(group, marker) {
const ageInfo = getGroupAgeInfo(group);
const element = marker.getElement();
if (!element) return;
let label = element.querySelector('.group-marker-label');
if (!label) {
label = document.createElement('div');
label.className = 'group-marker-label';
const name = document.createElement('div');
name.className = 'group-marker-label-name';
const age = document.createElement('div');
age.className = 'group-marker-label-age';
label.append(name, age);
element.appendChild(label);
}
const nameEl = label.querySelector('.group-marker-label-name');
const ageEl = label.querySelector('.group-marker-label-age');
if (nameEl) nameEl.textContent = groupDisplayName(group);
if (ageEl) ageEl.textContent = ageInfo.text;
}
function updateGroupMarkerTooltip(group, marker) {
if (window.CMBNET_VIEW_MODE !== 'observer') {
marker.bindTooltip(tooltipElement(groupDisplayName(group)), {direction: 'top', offset: [0, -12]});
return;
}
const preview = getGroupLastMessagePreview(group.id);
if (preview) {
marker.bindTooltip(tooltipElement(preview), {direction: 'top', offset: [0, -12]});
} else if (marker.getTooltip()) {
marker.unbindTooltip();
}
}
function createGroupMarker(group, latlng) {
const color = groupColor(group);
const isObserver = window.CMBNET_VIEW_MODE === 'observer';
const marker = L.marker(latlng, {
title: groupDisplayName(group),
riseOnHover: true,
icon: L.divIcon({
className: isObserver ? 'group-marker-icon group-marker-icon--with-label' : 'group-marker-icon',
html: `<span style="--marker-color:${color}"></span>${isObserver ? '<div class="group-marker-label"><div class="group-marker-label-name"></div><div class="group-marker-label-age"></div></div>' : ''}`,
iconSize: isObserver ? [28, 28] : [22, 22],
iconAnchor: isObserver ? [14, 14] : [11, 11]
})
});
if (isObserver) {
updateGroupMarkerTooltip(group, marker);
} else {
marker.bindTooltip(tooltipElement(groupDisplayName(group)), {direction: 'top', offset: [0, -12]});
}
marker.on('click', () => {
if (isObserver) {
openGroupStreetsModal(group.id);
}
});
marker.addTo(map);
dispatcherState.markersByGroupId.set(Number(group.id), marker);
if (isObserver) {
updateGroupMarkerLabel(group, 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);
if (window.CMBNET_VIEW_MODE === 'observer') {
const element = marker.getElement();
if (element) {
element.style.opacity = opacity <= 0 ? '0.3' : String(opacity);
element.classList.toggle('is-marker-hidden', opacity <= 0);
updateGroupMarkerLabel(group, marker);
}
if (opacity <= 0) marker.closeTooltip();
return;
}
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);
if (window.CMBNET_VIEW_MODE === 'observer') {
updateGroupMarkerTooltip(group, existing);
updateGroupMarkerLabel(group, existing);
} else {
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 controls = document.createElement('div');
controls.className = 'group-controls';
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 progressCircle = document.createElement('span');
progressCircle.className = 'group-progress-circle';
progressCircle.setAttribute('role', 'progressbar');
progressCircle.setAttribute('aria-valuemin', '0');
progressCircle.setAttribute('aria-valuemax', '100');
progressCircle.setAttribute('aria-valuenow', '0');
progressCircle.setAttribute('aria-label', 'Position unbekannt');
progressCircle.title = 'Position unbekannt';
const progressText = document.createElement('span');
progressText.className = 'group-progress-text';
progressText.textContent = '–';
progressCircle.appendChild(progressText);
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));
controls.append(
locateButton,
progressCircle,
stateSelect,
crosshairButton,
streetsButton,
aliasButton
);
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(controls, messageInput);
details.appendChild(content);
return details;
}
function updateGroupLastMessagePreview(groupId) {
const item = document.querySelector(`.group-item[data-group-id="${groupId}"]`);
if (!item) return;
const input = item.querySelector('.group-message');
if (!input) return;
const entries = dispatcherState.chatByGroup.get(Number(groupId)) || [];
if (!entries.length) {
input.value = '';
input.placeholder = 'Noch keine Gruppennachricht';
return;
}
const last = entries.slice().sort((a, b) => a.ts - b.ts).pop();
if (!last) {
input.value = '';
input.placeholder = 'Noch keine Gruppennachricht';
return;
}
input.placeholder = 'Chatverlauf öffnen';
const preview = extractMessageText(last.text);
input.value = `${getSenderDisplay(last.sender_id, last).name}: ${String(preview || '').replace(/\s+/g, ' ')}`;
}
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 progressCircle = item.querySelector('.group-progress-circle');
const progressText = item.querySelector('.group-progress-text');
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;
}
}
const rounded = Math.round(value);
const isLive = rounded >= 100;
locateButton.disabled = !enabled;
if (progressCircle) {
progressCircle.style.setProperty('--progress', String(rounded));
progressCircle.classList.toggle('is-live', isLive);
progressCircle.setAttribute('aria-valuenow', String(rounded));
progressCircle.setAttribute(
'aria-valuetext',
isLive
? 'Live'
: (known ? positionAgeLabel(ageSeconds) : 'Position unbekannt')
);
const label = !known
? 'Position unbekannt'
: (isLive ? 'Position: Live' : `Position: ${positionAgeLabel(ageSeconds)}`);
progressCircle.title = label;
progressCircle.setAttribute('aria-label', label);
}
if (progressText) {
if (!known || ageSeconds === null) {
progressText.textContent = '–';
} else if (isLive) {
progressText.textContent = 'Live';
} else {
progressText.textContent = `${Math.max(1, Math.floor(ageSeconds / 60))}m`;
}
}
});
}
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;
}
}
/* ------------------------------------------------------------------ */
/* Gruppenzuordnungen */
/* ------------------------------------------------------------------ */
function openGroupAssignmentModal() {
if (window.CMBNET_VIEW_MODE === 'observer') return;
renderGroupAssignmentTable();
const dialog = document.getElementById('groupAssignmentModal');
if (dialog && !dialog.open) dialog.showModal();
}
function closeGroupAssignmentModal() {
const dialog = document.getElementById('groupAssignmentModal');
if (dialog && dialog.open) dialog.close();
}
function buildAssignmentHeaderCell(label, className, rotated = false) {
const cell = document.createElement('th');
cell.scope = 'col';
cell.className = className;
if (rotated) {
const span = document.createElement('span');
span.className = 'group-column-label';
span.textContent = label;
cell.title = label;
cell.appendChild(span);
} else {
cell.textContent = label;
}
return cell;
}
function buildAssignmentRadioCell(accountId, accountName, value, checked, className, label) {
const cell = document.createElement('td');
cell.className = className;
const input = document.createElement('input');
input.type = 'radio';
input.name = `group-assignment-${accountId}`;
input.value = String(value);
input.checked = checked;
input.setAttribute('aria-label', `${label} für ${accountName}`);
cell.appendChild(input);
return cell;
}
function renderGroupAssignmentTable() {
const head = document.getElementById('groupAssignmentHead');
const body = document.getElementById('groupAssignmentBody');
const empty = document.getElementById('groupAssignmentEmpty');
const scroll = document.querySelector('.group-assignment-scroll');
const saveButton = document.getElementById('groupAssignmentSaveButton');
const table = document.getElementById('groupAssignmentTable');
if (!head || !body) return;
const accounts = dispatcherState.accounts
.filter(account => account.role === 'Gruppe')
.slice()
.sort((a, b) => String(a.name || '').localeCompare(String(b.name || ''), 'de'));
const groups = dispatcherState.groups
.slice()
.sort((a, b) => Number(a.id) - Number(b.id));
const assignmentByAccount = new Map();
groups.forEach(group => {
(Array.isArray(group.account_ids) ? group.account_ids : []).forEach(accountId => {
assignmentByAccount.set(Number(accountId), Number(group.id));
});
});
head.innerHTML = '';
body.innerHTML = '';
const headerRow = document.createElement('tr');
const longestGroupLabel = groups.reduce(
(maxLength, group) => Math.max(maxLength, groupDisplayName(group).length),
0
);
headerRow.style.setProperty(
'--group-header-height',
`${Math.min(14, Math.max(6.2, longestGroupLabel * 0.32 + 1.1))}rem`
);
const lastHeaderLabel = groups.length
? groupDisplayName(groups[groups.length - 1])
: 'Nicht dabei';
if (table) {
const rightSpace = Math.min(14, Math.max(1.5, lastHeaderLabel.length * 0.26 - 3.1));
table.style.setProperty('--assignment-right-space', `${rightSpace}rem`);
}
headerRow.appendChild(buildAssignmentHeaderCell('Account', 'assignment-account-header'));
headerRow.appendChild(buildAssignmentHeaderCell(
'Nicht dabei', 'not-participating-header', true
));
groups.forEach(group => {
headerRow.appendChild(buildAssignmentHeaderCell(
groupDisplayName(group), 'group-column-header', true
));
});
const spacerHeader = document.createElement('th');
spacerHeader.className = 'assignment-spacer-header';
spacerHeader.setAttribute('aria-hidden', 'true');
headerRow.appendChild(spacerHeader);
head.appendChild(headerRow);
accounts.forEach(account => {
const accountId = Number(account.id);
const accountName = account.name || `Account ${accountId}`;
const currentGroupId = assignmentByAccount.has(accountId)
? assignmentByAccount.get(accountId)
: null;
const row = document.createElement('tr');
row.dataset.accountId = String(accountId);
const rowHeader = document.createElement('th');
rowHeader.scope = 'row';
rowHeader.className = 'assignment-account-name';
rowHeader.textContent = accountName;
row.appendChild(rowHeader);
row.appendChild(buildAssignmentRadioCell(
accountId, accountName, 'none', currentGroupId === null,
'not-participating-cell', 'Nicht dabei'
));
groups.forEach(group => {
row.appendChild(buildAssignmentRadioCell(
accountId, accountName, group.id,
currentGroupId === Number(group.id),
'group-assignment-cell', groupDisplayName(group)
));
});
const spacerCell = document.createElement('td');
spacerCell.className = 'assignment-spacer-cell';
spacerCell.setAttribute('aria-hidden', 'true');
row.appendChild(spacerCell);
body.appendChild(row);
});
if (empty) empty.hidden = accounts.length > 0;
if (scroll) scroll.hidden = accounts.length === 0;
if (saveButton) saveButton.disabled = accounts.length === 0;
}
function updateLocalGroupAssignments(assignments) {
dispatcherState.groups.forEach(group => {
group.account_ids = [];
});
Object.entries(assignments).forEach(([accountId, groupId]) => {
if (groupId === null || groupId === undefined) return;
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) return;
if (!Array.isArray(group.account_ids)) group.account_ids = [];
group.account_ids.push(Number(accountId));
});
}
async function saveGroupAssignments() {
const saveButton = document.getElementById('groupAssignmentSaveButton');
if (!saveButton || saveButton.disabled) return;
const assignments = {};
document.querySelectorAll('#groupAssignmentBody tr[data-account-id]').forEach(row => {
const checked = row.querySelector('input[type="radio"]:checked');
const rawValue = checked ? checked.value : 'none';
assignments[row.dataset.accountId] = rawValue === 'none'
? null
: Number(rawValue);
});
if (!Object.keys(assignments).length) {
closeGroupAssignmentModal();
return;
}
saveButton.disabled = true;
try {
const response = await fetch(`${apiBase}/groups/assignments`, {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({assignments})
});
let data = {};
try {
data = await response.json();
} catch (error) {
data = {};
}
if (!response.ok || !data.success) {
throw new Error(data.error || `HTTP ${response.status}`);
}
updateLocalGroupAssignments(assignments);
closeGroupAssignmentModal();
} catch (error) {
console.error('Gruppenzuordnungen konnten nicht gespeichert werden:', error);
alert(`Gruppenzuordnungen konnten nicht gespeichert werden: ${error.message}`);
} finally {
saveButton.disabled = false;
}
}
function groupPositionZoomLevel() {
const configured = Number(window.CMBNET_GROUP_POSITION_ZOOM);
if (!Number.isFinite(configured)) return GROUP_POSITION_ZOOM_DEFAULT;
return Math.min(
GROUP_POSITION_ZOOM_MAX,
Math.max(GROUP_POSITION_ZOOM_MIN, Math.round(configured))
);
}
function buildGroupPositionShare(group) {
const lat = Number(group.last_lat);
const lon = Number(group.last_lon);
const mapsUrl = `https://www.google.com/maps?q=${lat.toFixed(6)},${lon.toFixed(6)}`;
const text = `Position von ${groupDisplayName(group)}: ${mapsUrl}`;
return {
lat,
lon,
mapsUrl,
whatsappUrl: `https://api.whatsapp.com/send?text=${encodeURIComponent(text)}`
};
}
function openGroupPositionSharePopup(group) {
let marker = dispatcherState.markersByGroupId.get(Number(group.id));
if (!marker) {
marker = createGroupMarker(group, [
Number(group.last_lat),
Number(group.last_lon)
]);
}
if (!marker) return;
const share = buildGroupPositionShare(group);
const container = document.createElement('div');
container.className = 'group-position-share';
const title = document.createElement('div');
title.className = 'group-position-share-title';
title.textContent = groupDisplayName(group);
const coordinates = document.createElement('div');
coordinates.className = 'group-position-share-coords';
coordinates.textContent = `${share.lat.toFixed(5)}, ${share.lon.toFixed(5)}`;
const canvas = document.createElement('canvas');
canvas.className = 'group-position-share-qr';
canvas.width = 200;
canvas.height = 200;
canvas.setAttribute(
'aria-label',
`QR-Code zum Teilen der Position von ${groupDisplayName(group)} über WhatsApp`
);
let qrRendered = false;
if (typeof QRious !== 'undefined') {
try {
new QRious({
element: canvas,
value: share.whatsappUrl,
size: 200,
level: 'M'
});
qrRendered = true;
} catch (error) {
console.error('QRious error', error);
}
}
const links = document.createElement('div');
links.className = 'group-position-share-links';
const whatsappLink = document.createElement('a');
whatsappLink.href = share.whatsappUrl;
whatsappLink.target = '_blank';
whatsappLink.rel = 'noopener';
whatsappLink.textContent = 'Per WhatsApp teilen';
const separator = document.createTextNode(' · ');
const mapsLink = document.createElement('a');
mapsLink.href = share.mapsUrl;
mapsLink.target = '_blank';
mapsLink.rel = 'noopener';
mapsLink.textContent = 'Kartenlink';
links.append(whatsappLink, separator, mapsLink);
container.append(title, coordinates);
if (qrRendered) {
container.appendChild(canvas);
} else {
const fallback = document.createElement('p');
fallback.textContent = 'QR-Code nicht verfügbar.';
container.appendChild(fallback);
}
container.appendChild(links);
marker.bindPopup(container, {
className: 'group-position-share-popup',
minWidth: 210,
maxWidth: 250,
autoClose: false,
closeOnClick: false,
closeButton: true,
offset: [0, -6]
});
marker.openPopup();
}
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)],
groupPositionZoomLevel()
);
openGroupPositionSharePopup(group);
}
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();
}
function startHeartbeatMonitoring() {
if (dispatcherState.heartbeatTimeoutId) {
clearTimeout(dispatcherState.heartbeatTimeoutId);
}
dispatcherState.heartbeatTimeoutId = setTimeout(checkHeartbeatTimeout, 95000);
}
function checkHeartbeatTimeout() {
const now = Date.now();
if (dispatcherState.lastCode0ReceivedAt
&& now - dispatcherState.lastCode0ReceivedAt > 90000) {
setConnectionStatus('Nicht verbunden', 'disconnected');
if (!dispatcherState.heartbeatWarningShown) {
dispatcherState.heartbeatWarningShown = true;
showHeartbeatWarning();
}
} else {
dispatcherState.heartbeatWarningShown = false;
}
startHeartbeatMonitoring();
}
function showHeartbeatWarning() {
const dialog = document.getElementById('heartbeatWarningModal');
if (!dialog) {
alert('Seit mehr als 90 Sekunden kein Kontakt zum Server.');
return;
}
if (typeof dialog.showModal === 'function') {
dialog.showModal();
} else {
dialog.show();
}
}
function closeHeartbeatWarningModal() {
const dialog = document.getElementById('heartbeatWarningModal');
if (dialog && dialog.open) dialog.close();
}
/* ------------------------------------------------------------------ */
/* 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');
if (!dialog) return;
dialog.addEventListener('close', cleanupGroupStreetsDialog);
const header = dialog.querySelector('header');
if (!header) return;
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);
dispatcherState.streetsDialogSelectedStreetIds.clear();
renderGroupStreetsDialog(group.id);
const dialog = document.getElementById('groupStreetsModal');
if (!dialog.open) dialog.show();
const rect = dialog.getBoundingClientRect();
positionGroupStreetsDialog(dialog, rect.left, rect.top);
if (!isDispatcherView()) return;
// Alle Straßen außerhalb der Gruppe ausblenden und auf die Gruppe zoomen.
updateAllPolylineStyles();
const bounds = combinedStreetBounds(groupStreetsForDialog(group.id));
if (map && bounds.isValid()) {
map.fitBounds(bounds, {padding: [32, 32], maxZoom: 18});
}
}
function closeGroupStreetsModal() {
const dialog = document.getElementById('groupStreetsModal');
if (dialog.open) dialog.close();
cleanupGroupStreetsDialog();
}
function cleanupGroupStreetsDialog() {
const dialog = document.getElementById('groupStreetsModal');
// Ein verspätetes close-Event darf einen bereits neu geöffneten Dialog
// nicht zurücksetzen.
if (dialog && dialog.open) return;
dispatcherState.streetsDialogGroupId = null;
dispatcherState.streetsDialogSelectedStreetIds.clear();
clearGroupStreetHover();
updateAllPolylineStyles();
updateGroupStreetsActionState();
}
function groupStreetsForDialog(groupId) {
return dispatcherState.streets
.filter(street => Number(street.group_id) === Number(groupId))
.sort((a, b) => {
const byName = String(a.name).localeCompare(String(b.name), 'de');
return byName || String(a.zusatz || '').localeCompare(String(b.zusatz || ''), 'de');
});
}
function canEditGroupStreets() {
return isDispatcherView();
}
function renderGroupStreetsDialog(groupId) {
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) {
closeGroupStreetsModal();
return;
}
clearGroupStreetHover();
document.getElementById('groupStreetsTitle').textContent =
`Straßen – ${groupDisplayName(group)}`;
const container = document.getElementById('groupStreetsContent');
container.innerHTML = '';
const assigned = groupStreetsForDialog(group.id);
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'
);
// Auswahl nur für Straßen behalten, die weiterhin im Zustand
// „zugewiesen“ und in dieser Gruppe sind.
const selectableIds = new Set(
assignedStreets.map(street => Number(street.id))
);
dispatcherState.streetsDialogSelectedStreetIds.forEach(streetId => {
if (!selectableIds.has(Number(streetId))) {
dispatcherState.streetsDialogSelectedStreetIds.delete(streetId);
}
});
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);
updateGroupStreetsActionState();
return;
}
const selectable = canEditGroupStreets();
appendGroupStreetSection(container, 'Zugewiesen', assignedStreets, true, selectable);
if (completedStreets.length) {
appendGroupStreetSection(container, 'Erledigt', completedStreets, false);
}
if (otherStreets.length) {
appendGroupStreetSection(container, 'Weitere', otherStreets, false);
}
updateGroupStreetsActionState();
}
function appendGroupStreetSection(container, title, streets, showEmpty, selectable = false) {
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';
const highlightOnHover = isDispatcherView();
streets.forEach(street => {
const streetId = Number(street.id);
const item = document.createElement('li');
item.className = 'group-street-item';
if (selectable) {
const checkbox = document.createElement('input');
checkbox.type = 'checkbox';
checkbox.className = 'group-street-select';
checkbox.value = String(streetId);
checkbox.checked = dispatcherState.streetsDialogSelectedStreetIds.has(streetId);
checkbox.setAttribute(
'aria-label',
`Straße ${streetDisplayName(street)} auswählen`
);
checkbox.addEventListener('change', () => {
if (checkbox.checked) {
dispatcherState.streetsDialogSelectedStreetIds.add(streetId);
} else {
dispatcherState.streetsDialogSelectedStreetIds.delete(streetId);
}
updateGroupStreetsActionState();
});
item.appendChild(checkbox);
}
const button = document.createElement('button');
button.type = 'button';
button.className = 'group-street-entry';
button.title = `Auf die Bounding Box von ${streetDisplayName(street)} zoomen`;
const name = document.createElement('span');
name.className = 'group-street-name';
name.textContent = streetDisplayName(street);
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);
if (highlightOnHover) {
item.addEventListener('mouseenter', () => setGroupStreetHover(streetId, true));
item.addEventListener('mouseleave', () => setGroupStreetHover(streetId, false));
}
list.appendChild(item);
});
section.appendChild(list);
container.appendChild(section);
}
function selectedGroupStreetIds() {
return Array.from(
document.querySelectorAll('#groupStreetsContent .group-street-select:checked')
)
.map(checkbox => Number(checkbox.value))
.filter(streetId => Number.isInteger(streetId) && streetId > 0);
}
function updateGroupStreetsActionState() {
const count = selectedGroupStreetIds().length;
['groupStreetsMarkUnbearbeitet', 'groupStreetsMarkErledigt'].forEach(id => {
const button = document.getElementById(id);
if (button) button.disabled = count === 0;
});
}
function setSelectedGroupStreetsState(newState) {
if (!canEditGroupStreets()) return;
if (newState !== 'unbearbeitet' && newState !== 'erledigt') return;
const selectedIds = selectedGroupStreetIds();
if (!selectedIds.length) return;
if (!dispatcherState.ws
|| dispatcherState.ws.readyState !== WebSocket.OPEN
|| !dispatcherState.authenticated) {
alert('Die WebSocket-Verbindung ist noch nicht verfügbar.');
return;
}
const fallbackGroupId = Number(dispatcherState.streetsDialogGroupId) || null;
let sentAll = true;
for (const streetId of selectedIds) {
const street = dispatcherState.streetById.get(streetId);
if (!street) {
sentAll = false;
break;
}
const groupId = newState === 'erledigt'
? (Number(street.group_id) || fallbackGroupId)
: null;
const sent = sendWs({
code: 100,
msg: JSON.stringify({
name: street.name,
state: newState,
actor: currentAccountId,
street_id: street.id,
group_id: groupId
})
});
if (!sent) {
sentAll = false;
break;
}
}
if (!sentAll) return;
dispatcherState.streetsDialogSelectedStreetIds.clear();
document.querySelectorAll('#groupStreetsContent .group-street-select').forEach(checkbox => {
checkbox.checked = false;
});
updateGroupStreetsActionState();
}
function clearGroupStreetHover() {
const streetId = dispatcherState.streetsDialogHoverId;
if (streetId === null || streetId === undefined) return;
dispatcherState.streetsDialogHoverId = null;
const street = dispatcherState.streetById.get(Number(streetId));
if (street) recolorStreet(street);
}
function setGroupStreetHover(streetId, hovered) {
const id = Number(streetId);
if (!Number.isFinite(id)) return;
if (!hovered) {
if (dispatcherState.streetsDialogHoverId === id) {
clearGroupStreetHover();
}
return;
}
if (dispatcherState.streetsDialogHoverId === id) return;
clearGroupStreetHover();
dispatcherState.streetsDialogHoverId = id;
const street = dispatcherState.streetById.get(id);
if (street) recolorStreet(street);
}
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});
}
function combinedStreetBounds(streets) {
const bounds = L.latLngBounds([]);
(streets || []).forEach(street => {
const streetBounds = bboxToBounds(street.bbox);
if (streetBounds && streetBounds.isValid()) {
bounds.extend(streetBounds);
return;
}
const lines = dispatcherState.polylinesByStreetId.get(Number(street.id)) || [];
lines.forEach(line => {
line.getLatLngs().forEach(latlng => bounds.extend(latlng));
});
});
return bounds;
}
function zoomToStreetSearchResult(street) {
if (!street) return;
const normalized = normalizeStreetSearchText(street.name);
const sameName = dispatcherState.streets.filter(
candidate => normalizeStreetSearchText(candidate.name) === normalized
);
const bounds = combinedStreetBounds(sameName.length ? sameName : [street]);
if (!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;
const exact = dispatcherState.streets.find(street => (
normalizeStreetSearchText(street.name) === normalized
));
if (exact) return exact;
// Der Zusatz wird bei der Suche ignoriert. Endet die Eingabe auf eine
// bekannte Richtung (auch kombiniert, z. B. "Nord-Süd"), wird sie für den
// Namensvergleich entfernt.
const withoutZusatz = normalized
.replace(/(?:[\s-]+(?:nord|sud|sued|ost|west))+$/u, '')
.trim();
if (!withoutZusatz || withoutZusatz === normalized) return null;
return dispatcherState.streets.find(street => (
normalizeStreetSearchText(street.name) === withoutZusatz
)) || 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 [];
const matches = dispatcherState.streets
.filter(street => normalizeStreetSearchText(street.name).startsWith(normalized))
.sort((a, b) => String(a.name).localeCompare(String(b.name), 'de'));
// Gleiche Straßennamen mit unterschiedlichen Zusätzen erscheinen nur
// einmal. Das Suchergebnis wird später über die gemeinsame Bounding Box
// aller Abschnitte angezeigt.
const seen = new Set();
const results = [];
for (const street of matches) {
const key = normalizeStreetSearchText(street.name);
if (seen.has(key)) continue;
seen.add(key);
results.push(street);
if (results.length >= STREET_SEARCH_MAX_RESULTS) break;
}
return 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;
zoomToStreetSearchResult(street);
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: ${streetDisplayName(street)}`;
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();
}
/* ------------------------------------------------------------------ */
/* Beobachter-Modus */
/* ------------------------------------------------------------------ */
const observerChatMessages = [];
const observerChatKeys = new Set();
function playNotificationSound() {
try {
const AudioContext = window.AudioContext || window.webkitAudioContext;
if (!AudioContext) return;
const ctx = new AudioContext();
const oscillator = ctx.createOscillator();
const gain = ctx.createGain();
oscillator.connect(gain);
gain.connect(ctx.destination);
oscillator.frequency.setValueAtTime(880, ctx.currentTime);
oscillator.frequency.exponentialRampToValueAtTime(440, ctx.currentTime + 0.15);
gain.gain.setValueAtTime(0.1, ctx.currentTime);
gain.gain.exponentialRampToValueAtTime(0.01, ctx.currentTime + 0.3);
oscillator.start(ctx.currentTime);
oscillator.stop(ctx.currentTime + 0.3);
} catch (error) {
// ignore
}
}
function formatObserverTime(timestamp) {
const ts = normalizeTimestamp(timestamp) || Date.now();
const date = new Date(ts);
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 addObserverMessage(message) {
if (window.CMBNET_VIEW_MODE !== 'observer') return;
const code = Number(message.code);
if (!Number.isFinite(code) || code < 1000) return;
const senderInfo = getSenderDisplay(message.sender_id, message);
const payload = extractMessagePayload(message.msg);
let receiverId = Number(message.receiver_id);
if (!Number.isFinite(receiverId) && payload && payload.group_id !== undefined) {
receiverId = Number(payload.group_id);
}
if (!Number.isFinite(receiverId) && payload && payload.receiver_id !== undefined) {
receiverId = Number(payload.receiver_id);
}
let receiver = '';
if (Number.isFinite(receiverId) && receiverId > 0) {
const group = dispatcherState.groupById.get(receiverId);
const account = dispatcherState.accountById.get(receiverId);
if (group) {
receiver = `Gruppe ${groupDisplayName(group)}`;
} else if (account) {
receiver = account.name;
} else {
receiver = `ID ${receiverId}`;
}
} else if (code === 1000 || (payload && payload.broadcast)) {
receiver = 'alle';
}
const text = extractMessageText(message.msg);
const time = formatObserverTime(message.ts);
const key = `${code}|${message.sender_id}|${message.receiver_id}|${time}|${text}`;
if (observerChatKeys.has(key)) return;
observerChatKeys.add(key);
observerChatMessages.push({
time,
sender: senderInfo.name,
receiver,
text
});
renderObserverChat();
playNotificationSound();
}
function renderObserverChat() {
const container = document.getElementById('observerChatMessages');
if (!container) return;
container.innerHTML = '';
if (!observerChatMessages.length) {
const empty = document.createElement('div');
empty.className = 'observer-chat-empty';
empty.textContent = 'Noch keine Nachrichten.';
container.appendChild(empty);
container.scrollTop = container.scrollHeight;
return;
}
observerChatMessages.forEach((entry, index) => {
const card = document.createElement('article');
card.className = 'observer-chat-card';
if (index % 2 === 1) {
card.classList.add('observer-chat-card--alt');
}
const meta = document.createElement('div');
meta.className = 'observer-chat-meta';
meta.textContent = entry.time;
const fromTo = document.createElement('div');
fromTo.className = 'observer-chat-fromto';
if (entry.receiver) {
fromTo.textContent = `${entry.sender} -> ${entry.receiver}`;
} else {
fromTo.textContent = entry.sender;
}
const text = document.createElement('div');
text.className = 'observer-chat-text';
text.textContent = entry.text;
card.append(meta, fromTo, text);
container.appendChild(card);
});
container.scrollTop = container.scrollHeight;
}
/* ------------------------------------------------------------------ */
/* Nachrichten und Chat */
/* ------------------------------------------------------------------ */
function openChat(groupId) {
dispatcherState.chatGroupId = Number(groupId);
renderChat();
const dialog = document.getElementById('chatModal');
if (dialog && !dialog.open) {
if (typeof dialog.showModal === 'function') {
dialog.showModal();
} else {
dialog.show();
}
}
const container = document.getElementById('chatMessages');
if (container) {
container.scrollTop = container.scrollHeight;
}
}
function closeChatModal() {
const dialog = document.getElementById('chatModal');
if (dialog && dialog.open) dialog.close();
}
function sendChatMessageFromModal() {
const groupId = dispatcherState.chatGroupId;
const group = groupId !== null ? dispatcherState.groupById.get(Number(groupId)) : null;
const input = document.getElementById('chatInput');
if (!group || !input) return;
const text = String(input.value).trim();
if (!text) return;
sendWs({
code: 1100,
receiver_id: group.id,
msg: JSON.stringify({group_id: group.id, text})
});
input.value = '';
input.focus();
}
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);
} else {
entries
.slice()
.sort((a, b) => a.ts - b.ts)
.forEach(entry => {
const message = document.createElement('div');
message.className = 'chat-message';
const senderInfo = getSenderDisplay(entry.sender_id, entry);
if (senderInfo.isMe) {
message.classList.add('own');
}
const header = document.createElement('div');
header.className = 'chat-message-header';
const sender = document.createElement('span');
sender.textContent = senderInfo.name;
const time = document.createElement('span');
time.textContent = formatChatTime(entry.ts);
header.append(sender, time);
const text = document.createElement('div');
text.className = 'chat-message-text';
const textContent = extractMessageText(entry.text);
text.textContent = textContent;
message.append(header, text);
container.appendChild(message);
});
}
container.scrollTop = container.scrollHeight;
}
function getSenderDisplay(senderId, messageOrPayload = null) {
let payload = null;
if (messageOrPayload && typeof messageOrPayload === 'object') {
payload = extractMessagePayload(messageOrPayload.msg ?? messageOrPayload);
if (!payload && (messageOrPayload.sender || messageOrPayload.group_id)) {
payload = messageOrPayload;
}
}
const payloadSender = payload && typeof payload.sender === 'object' ? payload.sender : null;
const id = Number(
payloadSender?.account_id
?? (typeof senderId === 'object' ? senderId.sender_id : senderId)
);
if (payloadSender && payloadSender.name) {
const name = payloadSender.name;
const alias = payloadSender.group_alias || payload?.group_alias;
if (alias && payloadSender.role === 'Gruppe') {
const display = `${name} (Gruppe: ${alias})`;
return {name: display, isMe: id === currentAccountId};
}
if (alias) {
const display = `${name} (Gruppe: ${alias})`;
return {name: display, isMe: id === currentAccountId};
}
if (payloadSender.role === 'Gruppe') {
return {name: `${name} (Gruppe)`, isMe: id === currentAccountId};
}
return {name, isMe: id === currentAccountId};
}
if (!Number.isFinite(id) || id <= 0) {
return {name: 'System', isMe: false};
}
if (id === currentAccountId) {
return {name: 'Ich', isMe: true};
}
const account = dispatcherState.accountById.get(id);
const group = findGroupForAccount(id);
const accountName = account && account.name ? account.name : `Account ${id}`;
if (group) {
const alias = group.aliasname && String(group.aliasname).trim();
if (alias) {
return {name: `${accountName} (Gruppe: ${alias})`, isMe: false};
}
return {name: `${accountName} (Gruppe ${group.id})`, isMe: false};
}
if (account && account.role === 'Gruppe') {
return {name: `${accountName} (Gruppe)`, isMe: false};
}
return {name: accountName, isMe: false};
}
function senderLabel(senderId) {
return getSenderDisplay(senderId).name;
}
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 textForKey = extractMessageText(entry.text ?? entry.msg ?? entry);
const keys = dispatcherState.chatKeysByGroup.get(id);
const key = `${entry.code}|${entry.sender_id}|${entry.ts}|${textForKey}`;
if (keys.has(key)) {
updateGroupLastMessagePreview(id);
return;
}
keys.add(key);
dispatcherState.chatByGroup.get(id).push({
...entry,
text: textForKey,
msg: entry.msg ?? textForKey
});
updateGroupLastMessagePreview(id);
if (window.CMBNET_VIEW_MODE === 'observer') {
const marker = dispatcherState.markersByGroupId.get(Number(id));
if (marker) {
updateGroupMarkerTooltip(dispatcherState.groupById.get(Number(id)) || {id}, marker);
}
return;
}
if (dispatcherState.chatGroupId === id
&& document.getElementById('chatModal').open) {
renderChat();
}
}
function playNotificationSound() {
try {
if (!AudioContext) return;
if (audioCtx.state === 'suspended') {
audioCtx.resume();
}
const oscillator = audioCtx.createOscillator();
const gain = audioCtx.createGain();
oscillator.connect(gain);
gain.connect(audioCtx.destination);
oscillator.frequency.setValueAtTime(880, audioCtx.currentTime);
oscillator.frequency.exponentialRampToValueAtTime(440, audioCtx.currentTime + 0.15);
gain.gain.setValueAtTime(0.1, audioCtx.currentTime);
gain.gain.exponentialRampToValueAtTime(0.01, audioCtx.currentTime + 0.3);
oscillator.start(audioCtx.currentTime);
oscillator.stop(audioCtx.currentTime + 0.3);
} catch (error) {
// ignore
}
}
function renderInfoMessages() {
const container = document.getElementById('infoMessages');
if (!container) return;
container.innerHTML = '';
if (!dispatcherState.infoMessages.length) {
const empty = document.createElement('div');
empty.className = 'chat-empty';
empty.textContent = 'Noch keine Nachrichten.';
container.appendChild(empty);
} else {
dispatcherState.infoMessages.forEach(entry => {
const message = document.createElement('div');
message.className = 'chat-message';
const header = document.createElement('div');
header.className = 'chat-message-header';
const sender = document.createElement('span');
sender.textContent = entry.senderLabel;
const time = document.createElement('span');
time.textContent = entry.time;
header.append(sender, time);
const meta = document.createElement('div');
meta.className = 'chat-message-text';
meta.style.fontSize = '0.8rem';
meta.style.opacity = '0.8';
meta.textContent = entry.meta;
const text = document.createElement('div');
text.className = 'chat-message-text';
text.textContent = entry.text;
message.append(header, meta, text);
container.appendChild(message);
});
}
container.scrollTop = container.scrollHeight;
}
function showInfoMessage(message) {
const dialog = document.getElementById('infoMessageModal');
if (!dialog) return;
const code = Number(message.code);
const senderInfo = getSenderDisplay(message.sender_id, message);
const sender = senderInfo.name;
const payload = extractMessagePayload(message.msg);
let receiverId = Number(message.receiver_id);
if (!Number.isFinite(receiverId) && payload && payload.group_id !== undefined) {
receiverId = Number(payload.group_id);
}
if (!Number.isFinite(receiverId) && payload && payload.receiver_id !== undefined) {
receiverId = Number(payload.receiver_id);
}
let receiver = '';
if (Number.isFinite(receiverId) && receiverId > 0) {
const group = dispatcherState.groupById.get(receiverId);
const account = dispatcherState.accountById.get(receiverId);
if (group) {
receiver = `Gruppe ${groupDisplayName(group)}`;
} else if (account) {
receiver = account.name;
} else {
receiver = `ID ${receiverId}`;
}
} else if (code === 1000 || (payload && payload.broadcast)) {
receiver = 'alle';
}
const time = formatChatTime(normalizeTimestamp(message.ts) || Date.now());
const text = extractMessageText(message.msg);
const senderLabel = receiver ? `${sender}` : sender;
const key = `${code}|${message.sender_id}|${message.receiver_id}|${time}|${text}`;
if (!dispatcherState.infoMessageKeys.has(key)) {
dispatcherState.infoMessageKeys.add(key);
dispatcherState.infoMessages.push({
senderLabel,
time,
text
});
playNotificationSound();
}
renderInfoMessages();
if (!dialog.open) {
if (typeof dialog.showModal === 'function') {
dialog.showModal();
} else {
dialog.show();
}
}
const container = document.getElementById('infoMessages');
if (container) {
container.scrollTop = container.scrollHeight;
}
}
function closeInfoMessageModal() {
const dialog = document.getElementById('infoMessageModal');
if (dialog && dialog.open) dialog.close();
dispatcherState.infoMessages = [];
dispatcherState.infoMessageKeys = new Set();
const container = document.getElementById('infoMessages');
if (container) {
container.innerHTML = '';
}
}
function extractMessagePayload(value) {
if (value === null || value === undefined) return null;
if (typeof value === 'object') {
return value;
}
if (typeof value === 'string') {
let text = value;
const trimmed = text.trim();
if (!trimmed) return null;
const colonIndex = trimmed.indexOf(':');
if (colonIndex > 0 && colonIndex < 80) {
const afterColon = trimmed.slice(colonIndex + 1).trim();
if ((afterColon.startsWith('{') && afterColon.endsWith('}'))
|| (afterColon.startsWith('[') && afterColon.endsWith(']'))) {
try {
const parsed = JSON.parse(afterColon);
if (parsed && typeof parsed === 'object') return parsed;
} catch (error) {
// ignore
}
}
}
if ((trimmed.startsWith('{') && trimmed.endsWith('}'))
|| (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
try {
const parsed = JSON.parse(trimmed);
if (parsed && typeof parsed === 'object') return parsed;
} catch (error) {
// ignore
}
}
}
return null;
}
function extractMessageText(value) {
const payload = extractMessagePayload(value);
if (payload && typeof payload === 'object') {
if (Object.prototype.hasOwnProperty.call(payload, 'text')) {
return String(payload.text ?? '');
}
if (Object.prototype.hasOwnProperty.call(payload, 'msg')) {
return extractMessageText(payload.msg);
}
return '';
}
if (value === null || value === undefined) return '';
if (typeof value === 'string') {
let text = value;
const trimmed = text.trim();
if (!trimmed) return '';
const colonIndex = trimmed.indexOf(':');
if (colonIndex > 0 && colonIndex < 80) {
const afterColon = trimmed.slice(colonIndex + 1).trim();
if (afterColon) return afterColon;
}
return trimmed;
}
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) {
if (Number(message.sender_id) !== currentAccountId) {
showInfoMessage(message);
}
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
});
if (Number(message.sender_id) !== currentAccountId) {
playNotificationSound();
openChat(group.id);
}
}
/* ------------------------------------------------------------------ */
/* 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,
client_id: window.CMBNET_CLIENT_ID
|| window.CMBNET_CLIENT_SESSION_ID
|| ''
}));
dispatcherState.authenticated = true;
setConnectionStatus('Verbunden', 'connected');
dispatcherState.lastCode0ReceivedAt = Date.now();
dispatcherState.heartbeatWarningShown = false;
startHeartbeatMonitoring();
});
ws.addEventListener('message', handleWsMessage);
ws.addEventListener('close', event => {
if (dispatcherState.ws !== ws) return;
console.warn('[WS] Verbindung geschlossen', {
code: event.code,
reason: event.reason,
wasClean: event.wasClean
});
dispatcherState.authenticated = false;
setConnectionStatus('Getrennt – neuer Versuch …', 'disconnected');
scheduleReconnect();
});
ws.addEventListener('error', event => {
if (dispatcherState.ws !== ws) return;
console.warn('[WS] Verbindungsfehler', event);
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 checkWsSequence(message) {
if (!Object.prototype.hasOwnProperty.call(message, 'seq')) return;
const seq = Number(message.seq);
if (!Number.isFinite(seq) || seq <= 0) return;
const lastSeq = dispatcherState.lastWsSeq;
if (lastSeq !== null && seq !== lastSeq + 1) {
const text = `Die WebSocket-Verbindung hat Nachrichten verloren `
+ `(erwartet: ${lastSeq + 1}, empfangen: ${seq}). `
+ 'Bitte lade die Seite neu, damit alle Änderungen sichtbar werden.';
if (typeof window.showReloadNotice === 'function') {
window.showReloadNotice(text);
} else {
alert(`${text}\n\nBitte die Webseite neu laden.`);
}
}
dispatcherState.lastWsSeq = lastSeq === null ? seq : Math.max(lastSeq, seq);
}
function handleWsMessage(event) {
let message;
try {
message = JSON.parse(event.data);
} catch (error) {
console.warn('Ungültige WebSocket-Nachricht:', event.data);
return;
}
checkWsSequence(message);
console.debug('[WS RX]', message);
console.log('[WS RX]', JSON.stringify(message));
switch (Number(message.code)) {
case 0:
dispatcherState.lastCode0ReceivedAt = Date.now();
dispatcherState.heartbeatWarningShown = false;
setConnectionStatus('Verbunden', 'connected');
startHeartbeatMonitoring();
break;
case 1:
dispatcherState.lastCode0ReceivedAt = Date.now();
dispatcherState.heartbeatWarningShown = false;
setConnectionStatus('Verbunden', 'connected');
startHeartbeatMonitoring();
// Heartbeat des Servers beantworten.
if (dispatcherState.ws && dispatcherState.ws.readyState === WebSocket.OPEN) {
dispatcherState.ws.send(JSON.stringify({code: 2, msg: 'pong'}));
}
break;
case 99: {
if (window.CMBNET_VIEW_MODE === 'observer') {
window.location.reload();
break;
}
const text = typeof message.msg === 'string'
? message.msg
: extractMessageText(message.msg);
if (typeof window.showReloadNotice === 'function') {
window.showReloadNotice(text);
} else {
alert(`${text}\n\nBitte die Webseite neu laden.`);
}
break;
}
case 100:
handleStreetUpdate(message);
break;
case 200:
handleGroupStateUpdate(message);
break;
case 300:
handleGroupPositionUpdate(message);
break;
case 1000: {
const text = extractMessageText(message.msg);
if (window.CMBNET_VIEW_MODE !== 'observer') {
dispatcherState.groups.forEach(group => {
addChatMessage(group.id, {
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
});
}
if (window.CMBNET_VIEW_MODE === 'observer') {
addObserverMessage({
code: message.code,
sender_id: message.sender_id,
receiver_id: message.receiver_id,
msg: text,
ts: message.ts
});
} else if (Number(message.sender_id) !== currentAccountId) {
showInfoMessage({
code: message.code,
sender_id: message.sender_id,
receiver_id: message.receiver_id,
msg: text,
ts: message.ts
});
}
break;
}
case 1100: {
const payload = parsePayload(message.msg) || {};
const groupId = Number(message.receiver_id) || Number(payload.group_id);
const text = extractMessageText(payload.text ?? message.msg);
if (window.CMBNET_VIEW_MODE !== 'observer') {
if (groupId) {
addChatMessage(groupId, {
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
}
}
if (window.CMBNET_VIEW_MODE === 'observer') {
addObserverMessage({
code: message.code,
sender_id: message.sender_id,
receiver_id: groupId || message.receiver_id,
msg: text,
ts: message.ts
});
} else if (Number(message.sender_id) !== currentAccountId) {
playNotificationSound();
if (groupId) {
openChat(groupId);
} else {
showInfoMessage({
code: message.code,
sender_id: message.sender_id,
receiver_id: message.receiver_id,
msg: text,
ts: message.ts
});
}
}
break;
}
case 2000:
if (window.CMBNET_VIEW_MODE !== 'observer') {
handleGroupChatMessage(message);
}
break;
default:
if (Number(message.code) >= 1000) {
const text = extractMessageText(message.msg);
if (window.CMBNET_VIEW_MODE === 'observer') {
addObserverMessage({
code: message.code,
sender_id: message.sender_id,
receiver_id: message.receiver_id,
msg: text,
ts: message.ts
});
break;
}
if (Number(message.code) === 1000) {
dispatcherState.groups.forEach(group => {
addChatMessage(group.id, {
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
});
}
if (Number(message.sender_id) !== currentAccountId) {
showInfoMessage({
code: message.code,
sender_id: message.sender_id,
receiver_id: message.receiver_id,
msg: text,
ts: message.ts
});
}
break;
}
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) {
console.warn('[WS] Code 100: Straße nicht im lokalen Zustand', payload);
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);
// Ein offener Straßendialog muss den neuen Serverzustand anzeigen.
const streetModal = document.getElementById('streetModal');
if (streetModal && streetModal.open
&& dispatcherState.currentStreetId === Number(street.id)) {
const stateSelect = document.getElementById('streetStateSelect');
if (stateSelect) stateSelect.value = street.state || 'unbearbeitet';
fillStreetGroupOptions(street.group_id);
updateStreetGroupVisibility();
}
const streetsDialog = document.getElementById('groupStreetsModal');
if (dispatcherState.streetsDialogGroupId && streetsDialog && streetsDialog.open) {
renderGroupStreetsDialog(dispatcherState.streetsDialogGroupId);
updateAllPolylineStyles();
}
}
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) {
console.warn('[WS] Code 200: Gruppe nicht im lokalen Zustand', payload);
return;
}
if (GROUP_STATES.includes(payload.state)) {
group.state = payload.state;
updateGroupSummary(group);
refreshGroupControls();
}
}
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) {
console.warn('[WS] Code 300: Gruppe nicht im lokalen Zustand', payload);
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();
const baseLayerSelect = document.getElementById('baseLayerSelect');
if (baseLayerSelect) {
baseLayerSelect.addEventListener('change', event => {
setBaseLayer(event.target.value);
});
}
const opacitySlider = document.getElementById('opacitySlider');
if (opacitySlider) {
opacitySlider.addEventListener('input', event => {
dispatcherState.settings.opacity = clampNumber(
event.target.value, 0, 1, DEFAULT_SETTINGS.opacity
);
updateOpacityOutput();
updateAllPolylineStyles();
saveStoredSettings();
});
}
const weightSlider = document.getElementById('weightSlider');
if (weightSlider) {
weightSlider.addEventListener('input', event => {
dispatcherState.settings.weight = clampNumber(
event.target.value, 1, 100, DEFAULT_SETTINGS.weight
);
updateWeightOutput();
updateAllPolylineStyles();
saveStoredSettings();
});
}
const fitBoundsButton = document.getElementById('fitBoundsButton');
if (fitBoundsButton) {
fitBoundsButton.addEventListener('click', fitAllStreetBounds);
}
const speakerButton = document.getElementById('speakerButton');
if (speakerButton && window.CMBNET_VIEW_MODE !== 'observer') {
speakerButton.addEventListener('click', openSpeakerModal);
}
const groupAssignmentButton = document.getElementById('groupAssignmentButton');
if (groupAssignmentButton && window.CMBNET_VIEW_MODE !== 'observer') {
groupAssignmentButton.addEventListener('click', openGroupAssignmentModal);
}
const wakeMobileButton = document.getElementById('wakeMobileButton');
if (wakeMobileButton && window.CMBNET_VIEW_MODE !== 'observer') {
wakeMobileButton.addEventListener('click', wakeMobileClients);
}
const streetStateSelect = document.getElementById('streetStateSelect');
if (streetStateSelect && window.CMBNET_VIEW_MODE !== 'observer') {
streetStateSelect.addEventListener('change', updateStreetGroupVisibility);
}
const groupAliasInput = document.getElementById('groupAliasInput');
if (groupAliasInput && window.CMBNET_VIEW_MODE !== 'observer') {
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 closeSpeakerQrModal() {
const dialog = document.getElementById('speakerQrModal');
if (dialog && dialog.open) dialog.close();
}
function sendSpeakerMessage() {
const input = document.getElementById('speakerText');
const text = input.value.trim();
if (!text) return;
if (sendWs({code: 1000, msg: JSON.stringify({text})})) {
closeSpeakerModal();
showSpeakerQr(text);
input.value = '';
}
}
async function wakeMobileClients() {
const button = document.getElementById('wakeMobileButton');
if (button) button.disabled = true;
try {
const response = await fetch(`${apiBase}/push/wake`, {
method: 'POST',
credentials: 'same-origin',
headers: {'Content-Type': 'application/json'},
body: '{}'
});
const result = await response.json().catch(() => ({}));
if (!response.ok) {
throw new Error(result.error || `HTTP ${response.status}`);
}
const sent = Number(result.sent) || 0;
if (sent > 0) {
setStreetSearchStatus(`${sent} mobile Clients geweckt.`);
} else {
const tokens = Number(result.valid_tokens) || 0;
const connected = Number(result.connected) || 0;
setStreetSearchStatus(
'Keine mobilen Clients mit Push-Token gefunden '
+ `(registriert: ${tokens}, verbunden: ${connected}).`
);
}
setTimeout(() => setStreetSearchStatus(''), 5000);
} catch (error) {
setStreetSearchStatus(`Wecken fehlgeschlagen: ${error.message}`, true);
setTimeout(() => setStreetSearchStatus(''), 6000);
} finally {
if (button) button.disabled = false;
}
}
function showSpeakerQr(text) {
const dialog = document.getElementById('speakerQrModal');
if (!dialog) return;
const encoded = encodeURIComponent(text);
const url = `https://api.whatsapp.com/send?text=${encoded}`;
const canvas = document.getElementById('speakerQrCanvas');
const qrLink = document.getElementById('speakerQrLink');
if (canvas && typeof QRious !== 'undefined') {
try {
new QRious({
element: canvas,
value: url,
size: 240
});
} catch (e) {
console.error('QRious error', e);
}
}
if (qrLink) {
qrLink.href = url;
qrLink.textContent = 'WhatsApp öffnen';
}
if (typeof dialog.showModal === 'function') {
dialog.showModal();
} else {
dialog.show();
}
}
function openGroupMessageModal() {}
function closeGroupMessageModal() {}
function sendGroupMessageFromDialog() {}
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);
}