Files
Sternsinger/CMBNet/static/js/views/dispatcher.js
T
2026-10-23 00:05:06 +02:00

1326 lines
42 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* Dispatcher-View
*
* Initialisierung:
* 1. Straßen und Gruppen per AJAX laden
* 2. Zugriffstoken holen und WebSocket mit Code 0 authentifizieren
* 3. Karte, Polylines, Marker und Kontrollansicht aufbauen
*/
const tenant = window.CMBNET_TENANT || window.location.pathname.split('/')[1];
const apiBase = `/${tenant}/api`;
const wsUrl = `${window.location.protocol === 'https:' ? 'wss' : 'ws'}://${window.location.host}/${tenant}/ws`;
const storageKey = `cmbnet:${tenant}:map`;
const currentAccountId = Number(window.CMBNET_ACCOUNT_ID) || null;
const DEFAULT_SETTINGS = {
opacity: 0.7,
weight: 20,
baseLayer: 'osm',
center: null,
zoom: null
};
const STREET_STATES = ['unbearbeitet', 'zugewiesen', 'erledigt'];
const GROUP_STATES = ['offen', 'unterwegs', 'online', 'pausierend', 'fertig'];
const STREET_COLORS = {
unbearbeitet: '#1f6feb',
zugewiesen: '#d62828',
erledigt: '#2e9e4f'
};
const dispatcherState = {
settings: {...DEFAULT_SETTINGS},
streets: [],
streetById: new Map(),
groups: [],
groupById: new Map(),
polylinesByStreetId: new Map(),
markersByGroupId: new Map(),
browserLatLng: null,
ws: null,
authenticated: false,
reconnectTimer: null,
crosshairGroupId: null,
currentStreetId: null,
chatGroupId: null,
chatByGroup: new Map(),
chatKeysByGroup: new Map(),
unloading: false
};
let map;
let osmLayer;
let aerialLayer;
let currentBaseLayer;
document.addEventListener('DOMContentLoaded', initDispatcher);
async function initDispatcher() {
loadStoredSettings();
initMap();
bindStaticUi();
updateClock();
setInterval(updateClock, 1000);
try {
const [streets, groups] = await Promise.all([
fetchJson(`${apiBase}/init/streets`),
fetchJson(`${apiBase}/init/groups`)
]);
dispatcherState.streets = Array.isArray(streets) ? streets : [];
dispatcherState.groups = Array.isArray(groups) ? groups : [];
indexData();
buildPolylines();
buildGroupAccordion();
applySettingsToUi();
placeKnownGroupMarkers();
} catch (error) {
console.error('Initialdaten konnten nicht geladen werden:', error);
showAccordionError('Die Straßen und Gruppen konnten nicht geladen werden.');
}
ensureInitialView();
placeUnknownGroupMarkers();
setConnectionStatus('Verbinde …', '');
connectWebSocket();
window.addEventListener('beforeunload', () => {
dispatcherState.unloading = true;
if (dispatcherState.reconnectTimer) clearTimeout(dispatcherState.reconnectTimer);
if (dispatcherState.ws) dispatcherState.ws.close();
});
}
/* ------------------------------------------------------------------ */
/* Initialdaten und LocalStorage */
/* ------------------------------------------------------------------ */
async function fetchJson(url, options = {}) {
const response = await fetch(url, {credentials: 'same-origin', ...options});
if (!response.ok) {
throw new Error(`${url}: HTTP ${response.status}`);
}
return response.json();
}
function loadStoredSettings() {
let saved = {};
try {
const raw = localStorage.getItem(storageKey);
if (raw) saved = JSON.parse(raw);
} catch (error) {
console.warn('Gespeicherte Karteneinstellungen konnten nicht gelesen werden.', error);
}
const center = Array.isArray(saved.center) && saved.center.length === 2
? saved.center.map(Number)
: null;
const validCenter = center
&& center.every(Number.isFinite)
&& Math.abs(center[0]) <= 90
&& Math.abs(center[1]) <= 180
? center
: null;
dispatcherState.settings = {
opacity: clampNumber(saved.opacity, 0, 1, DEFAULT_SETTINGS.opacity),
weight: clampNumber(saved.weight, 1, 100, DEFAULT_SETTINGS.weight),
baseLayer: saved.baseLayer === 'aerial' ? 'aerial' : 'osm',
center: validCenter,
zoom: Number.isFinite(Number(saved.zoom)) && Number(saved.zoom) > 0
? Number(saved.zoom)
: null
};
}
function saveStoredSettings() {
if (map) {
const center = map.getCenter();
dispatcherState.settings.center = [center.lat, center.lng];
dispatcherState.settings.zoom = map.getZoom();
}
try {
localStorage.setItem(storageKey, JSON.stringify(dispatcherState.settings));
} catch (error) {
console.warn('Karteneinstellungen konnten nicht gespeichert werden.', error);
}
}
function clampNumber(value, min, max, fallback) {
const number = Number(value);
if (!Number.isFinite(number)) return fallback;
return Math.min(max, Math.max(min, number));
}
function indexData() {
dispatcherState.streetById.clear();
dispatcherState.streets.forEach(street => {
dispatcherState.streetById.set(Number(street.id), street);
});
dispatcherState.groupById.clear();
dispatcherState.groups.forEach(group => {
group.id = Number(group.id);
group.last_pos_ts = parseTimestamp(group.last_pos_at);
dispatcherState.groupById.set(group.id, group);
});
dispatcherState.groups.sort((a, b) => a.id - b.id);
}
/* ------------------------------------------------------------------ */
/* Karte */
/* ------------------------------------------------------------------ */
function initMap() {
map = L.map('map', {
zoomControl: true,
preferCanvas: true,
minZoom: 2
});
map.setView([51.0, 10.0], 6);
osmLayer = L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
maxZoom: 19,
attribution: '&copy; OpenStreetMap-Mitwirkende'
});
aerialLayer = L.tileLayer(
'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
{
maxZoom: 19,
attribution: 'Tiles &copy; Esri'
}
);
setBaseLayer(dispatcherState.settings.baseLayer, false);
map.on('moveend zoomend', saveStoredSettings);
map.on('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 select = document.getElementById('baseLayerSelect');
if (select) select.value = dispatcherState.settings.baseLayer;
if (persist) saveStoredSettings();
}
function ensureInitialView() {
if (dispatcherState.settings.center && dispatcherState.settings.zoom !== null) {
map.setView(dispatcherState.settings.center, dispatcherState.settings.zoom);
return;
}
const bounds = collectAllStreetBounds();
if (bounds.isValid()) {
map.fitBounds(bounds, {padding: [24, 24], maxZoom: 16});
}
}
function collectAllStreetBounds() {
const bounds = L.latLngBounds([]);
dispatcherState.streets.forEach(street => {
const streetBounds = bboxToBounds(street.bbox);
if (streetBounds) bounds.extend(streetBounds);
});
if (!bounds.isValid()) {
dispatcherState.polylinesByStreetId.forEach(lines => {
lines.forEach(line => {
line.getLatLngs().forEach(latlng => bounds.extend(latlng));
});
});
}
return bounds;
}
/**
* Unterstützt das im Projekt verwendete Format [[nwLon, nwLat], [seLon, seLat]]
* sowie flache GeoJSON-Bounding-Boxen [west, south, east, north].
*/
function bboxToBounds(bbox) {
if (!bbox) return null;
if (Array.isArray(bbox) && bbox.length === 2
&& Array.isArray(bbox[0]) && Array.isArray(bbox[1])
&& bbox[0].length >= 2 && bbox[1].length >= 2) {
const lon1 = Number(bbox[0][0]);
const lat1 = Number(bbox[0][1]);
const lon2 = Number(bbox[1][0]);
const lat2 = Number(bbox[1][1]);
if ([lon1, lat1, lon2, lat2].every(Number.isFinite)) {
return L.latLngBounds([lat1, lon1], [lat2, lon2]);
}
}
if (Array.isArray(bbox) && bbox.length === 4 && bbox.every(Number.isFinite)) {
const [west, south, east, north] = bbox.map(Number);
return L.latLngBounds([south, west], [north, east]);
}
if (bbox && typeof bbox === 'object' && !Array.isArray(bbox)) {
const south = Number(bbox.south ?? bbox.minLat);
const west = Number(bbox.west ?? bbox.minLon);
const north = Number(bbox.north ?? bbox.maxLat);
const east = Number(bbox.east ?? bbox.maxLon);
if ([south, west, north, east].every(Number.isFinite)) {
return L.latLngBounds([south, west], [north, east]);
}
}
return null;
}
function fitAllStreetBounds() {
const bounds = collectAllStreetBounds();
if (bounds.isValid()) {
map.fitBounds(bounds, {padding: [24, 24], maxZoom: 16});
} else {
map.setView([51.0, 10.0], 6);
}
}
/* ------------------------------------------------------------------ */
/* Polylines */
/* ------------------------------------------------------------------ */
function getStreetFragments() {
// Unterstützt sowohl window-Zuweisungen (window.Strasse2Polylines /
// window.STRASSE2POLYLINES) als auch globale const/let-Deklarationen im
// externen str2pl.js-Fragment.
if (typeof Strasse2Polylines !== 'undefined') return Strasse2Polylines;
if (typeof STRASSE2POLYLINES !== 'undefined') return STRASSE2POLYLINES;
return window.Strasse2Polylines || window.STRASSE2POLYLINES || {};
}
function tooltipElement(text) {
// Leaflet interpretiert String-Inhalte als HTML. Gruppennamen und
// Straßennamen stammen aus der Datenbank und werden deshalb als
// Textknoten übergeben.
const element = document.createElement('span');
element.textContent = String(text);
return element;
}
function buildPolylines() {
const fragments = getStreetFragments();
const regionBounds = dispatcherState.streets
.map(street => bboxToBounds(street.bbox))
.find(bounds => bounds && bounds.isValid()) || null;
const fallbackCenter = regionBounds
? regionBounds.getCenter()
: (dispatcherState.settings.center
? L.latLng(dispatcherState.settings.center)
: map.getCenter());
dispatcherState.streets.forEach(street => {
const segments = findStreetSegments(fragments, street.name);
if (!Array.isArray(segments)) return;
const streetBounds = bboxToBounds(street.bbox) || regionBounds;
const lines = [];
segments.forEach(segment => {
if (!Array.isArray(segment)) return;
const latlngs = segment
.map(point => normalizeStreetPoint(point, streetBounds, fallbackCenter))
.filter(Boolean);
if (latlngs.length < 2) return;
const line = L.polyline(latlngs, polylineStyle(street.state));
line.bindTooltip(tooltipElement(`${street.name} (${street.state})`), {sticky: true});
line.on('click', () => {
if (dispatcherState.crosshairGroupId) return;
openStreetModal(street.id);
});
line.addTo(map);
lines.push(line);
});
if (lines.length) {
dispatcherState.polylinesByStreetId.set(Number(street.id), lines);
}
});
}
function findStreetSegments(fragments, name) {
if (!name) return null;
if (fragments[name]) return fragments[name];
const lower = String(name).toLowerCase();
const matchingKey = Object.keys(fragments).find(key => key.toLowerCase() === lower);
return matchingKey ? fragments[matchingKey] : null;
}
function normalizeStreetPoint(point, bounds, fallbackCenter) {
if (!Array.isArray(point) || point.length < 2) return null;
const first = Number(point[0]);
const second = Number(point[1]);
if (!Number.isFinite(first) || !Number.isFinite(second)) return null;
// Die Spezifikation erwartet [Longitude, Latitude]. Das mitgelieferte
// Godesberg-Fragment enthält historisch bedingt [Latitude, Longitude].
// Beide Varianten werden akzeptiert und anhand der Straßen-Bounding-Box
// (bzw. des Kartenmittelpunkts) eindeutig zugeordnet.
const candidates = [
[second, first], // [lon, lat]
[first, second] // [lat, lon]
].filter(([lat, lon]) => (
Number.isFinite(lat) && Number.isFinite(lon)
&& lat >= -90 && lat <= 90
&& lon >= -180 && lon <= 180
));
if (!candidates.length) return null;
if (candidates.length === 1) return candidates[0];
let pool = candidates;
if (bounds && bounds.isValid()) {
const inside = candidates.filter(([lat, lon]) => bounds.contains([lat, lon]));
if (inside.length) pool = inside;
}
const center = bounds && bounds.isValid() ? bounds.getCenter() : fallbackCenter;
if (!center) return pool[0];
let best = pool[0];
let bestDistance = squaredCoordinateDistance(best, center);
for (let i = 1; i < pool.length; i += 1) {
const distance = squaredCoordinateDistance(pool[i], center);
if (distance < bestDistance) {
best = pool[i];
bestDistance = distance;
}
}
return best;
}
function squaredCoordinateDistance(latlng, center) {
const dLat = latlng[0] - center.lat;
const dLng = latlng[1] - center.lng;
return dLat * dLat + dLng * dLng;
}
function polylineStyle(state) {
return {
color: STREET_COLORS[state] || STREET_COLORS.unbearbeitet,
opacity: dispatcherState.settings.opacity,
weight: dispatcherState.settings.weight,
lineCap: 'round',
lineJoin: 'round'
};
}
function recolorStreet(street) {
const lines = dispatcherState.polylinesByStreetId.get(Number(street.id));
if (!lines) return;
const color = STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet;
lines.forEach(line => {
line.setStyle({
color,
opacity: dispatcherState.settings.opacity,
weight: dispatcherState.settings.weight
});
line.setTooltipContent(tooltipElement(`${street.name} (${street.state})`));
});
}
function updateAllPolylineStyles() {
dispatcherState.polylinesByStreetId.forEach(lines => {
lines.forEach(line => {
line.setStyle({
opacity: dispatcherState.settings.opacity,
weight: dispatcherState.settings.weight
});
});
});
}
/* ------------------------------------------------------------------ */
/* Gruppen, Marker und Accordion */
/* ------------------------------------------------------------------ */
function groupDisplayName(group) {
return group.aliasname && String(group.aliasname).trim()
? String(group.aliasname)
: String(group.id);
}
function groupColor(group) {
const id = Number(group.id) || 0;
const hue = Math.round((id * 137.508) % 360);
return `hsl(${hue}, 72%, 45%)`;
}
function hasPosition(group) {
return group.last_lat !== null && group.last_lat !== undefined
&& group.last_lon !== null && group.last_lon !== undefined
&& Number.isFinite(Number(group.last_lat))
&& Number.isFinite(Number(group.last_lon));
}
function createGroupMarker(group, latlng) {
const color = groupColor(group);
const marker = L.marker(latlng, {
title: groupDisplayName(group),
riseOnHover: true,
icon: L.divIcon({
className: 'group-marker-icon',
html: `<span style="--marker-color:${color}"></span>`,
iconSize: [22, 22],
iconAnchor: [11, 11]
})
});
marker.bindTooltip(tooltipElement(groupDisplayName(group)), {direction: 'top', offset: [0, -12]});
marker.addTo(map);
dispatcherState.markersByGroupId.set(Number(group.id), marker);
return marker;
}
function placeKnownGroupMarkers() {
dispatcherState.groups.forEach(group => {
if (!hasPosition(group)) return;
createGroupMarker(group, [Number(group.last_lat), Number(group.last_lon)]);
});
}
async function placeUnknownGroupMarkers() {
if (!dispatcherState.groups.some(group => !hasPosition(group))) return;
dispatcherState.browserLatLng = await getBrowserLatLng();
dispatcherState.groups.forEach(group => {
if (hasPosition(group)) return;
const existing = dispatcherState.markersByGroupId.get(Number(group.id));
if (existing) {
existing.setLatLng(dispatcherState.browserLatLng);
} else {
createGroupMarker(group, dispatcherState.browserLatLng);
}
});
}
function getBrowserLatLng() {
return new Promise(resolve => {
if (!navigator.geolocation) {
resolve(map.getCenter());
return;
}
navigator.geolocation.getCurrentPosition(
position => resolve(L.latLng(
position.coords.latitude,
position.coords.longitude
)),
() => resolve(map.getCenter()),
{timeout: 8000, maximumAge: 60000}
);
});
}
function updateMarkerPosition(group) {
if (!hasPosition(group)) return;
const latlng = [Number(group.last_lat), Number(group.last_lon)];
const existing = dispatcherState.markersByGroupId.get(Number(group.id));
if (existing) {
existing.setLatLng(latlng);
existing.setTooltipContent(tooltipElement(groupDisplayName(group)));
} else {
createGroupMarker(group, latlng);
}
}
function buildGroupAccordion() {
const container = document.getElementById('groupAccordion');
container.innerHTML = '';
if (!dispatcherState.groups.length) {
const empty = document.createElement('p');
empty.className = 'group-empty';
empty.textContent = 'Keine Gruppen vorhanden.';
container.appendChild(empty);
return;
}
dispatcherState.groups.forEach(group => {
container.appendChild(createGroupElement(group));
});
refreshGroupControls();
}
function createGroupElement(group) {
const details = document.createElement('details');
details.className = 'group-item';
details.dataset.groupId = group.id;
const summary = document.createElement('summary');
const dot = document.createElement('span');
dot.className = 'group-dot';
dot.style.background = groupColor(group);
const name = document.createElement('span');
name.className = 'group-name';
name.textContent = groupDisplayName(group);
const stateBadge = document.createElement('span');
stateBadge.className = 'group-state';
stateBadge.textContent = group.state || 'offen';
summary.append(dot, name, stateBadge);
details.appendChild(summary);
const content = document.createElement('div');
content.className = 'group-details';
const positionRow = document.createElement('div');
positionRow.className = 'group-position-row';
const locateButton = document.createElement('button');
locateButton.type = 'button';
locateButton.className = 'icon-button group-locate';
locateButton.textContent = '📍';
locateButton.title = 'Karte auf Gruppenposition zentrieren';
locateButton.setAttribute('aria-label', 'Karte auf Gruppenposition zentrieren');
locateButton.addEventListener('click', () => locateGroup(group.id));
const progress = document.createElement('progress');
progress.className = 'group-progress';
progress.max = 100;
progress.value = 0;
positionRow.append(locateButton, progress);
const meta = document.createElement('div');
meta.className = 'group-position-meta';
meta.textContent = 'Position unbekannt';
const actions = document.createElement('div');
actions.className = 'group-actions';
const crosshairButton = document.createElement('button');
crosshairButton.type = 'button';
crosshairButton.className = 'icon-button group-crosshair';
crosshairButton.dataset.groupId = group.id;
crosshairButton.textContent = '⌖';
crosshairButton.title = 'Position auf der Karte setzen';
crosshairButton.setAttribute('aria-label', 'Position auf der Karte setzen');
crosshairButton.addEventListener('click', () => toggleCrosshair(group.id));
actions.appendChild(crosshairButton);
const messageInput = document.createElement('input');
messageInput.type = 'text';
messageInput.className = 'group-message';
messageInput.readOnly = true;
messageInput.placeholder = 'Noch keine Gruppennachricht';
messageInput.title = 'Chatverlauf öffnen';
messageInput.addEventListener('click', () => openChat(group.id));
content.append(positionRow, meta, actions, messageInput);
details.appendChild(content);
return details;
}
function refreshGroupControls(now = Date.now()) {
dispatcherState.groups.forEach(group => {
const item = document.querySelector(`.group-item[data-group-id="${group.id}"]`);
if (!item) return;
const locateButton = item.querySelector('.group-locate');
const progress = item.querySelector('.group-progress');
const meta = item.querySelector('.group-position-meta');
const known = hasPosition(group);
const positionTs = group.last_pos_ts;
const ageSeconds = positionTs ? Math.max(0, (now - positionTs) / 1000) : null;
let value = 0;
let enabled = false;
if (known) {
if (ageSeconds === null) {
enabled = true;
value = 0;
} else {
value = progressForAge(ageSeconds);
enabled = ageSeconds <= 3600;
}
}
locateButton.disabled = !enabled;
progress.value = Math.round(value);
if (known) {
meta.textContent = `${Number(group.last_lat).toFixed(5)}, ${Number(group.last_lon).toFixed(5)}`;
} else {
meta.textContent = 'Position unbekannt';
}
});
}
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 badge = item.querySelector('.group-state');
if (badge) badge.textContent = group.state || 'offen';
}
function locateGroup(groupId) {
const group = dispatcherState.groupById.get(Number(groupId));
if (!group || !hasPosition(group)) return;
map.setView([Number(group.last_lat), Number(group.last_lon)], 15);
}
function toggleCrosshair(groupId) {
const id = Number(groupId);
if (dispatcherState.crosshairGroupId === id) {
cancelCrosshair();
return;
}
dispatcherState.crosshairGroupId = id;
map.getContainer().classList.add('crosshair');
updateCrosshairButtons();
}
function cancelCrosshair() {
dispatcherState.crosshairGroupId = null;
map.getContainer().classList.remove('crosshair');
updateCrosshairButtons();
}
function updateCrosshairButtons() {
document.querySelectorAll('.group-crosshair').forEach(button => {
button.classList.toggle(
'active',
Number(button.dataset.groupId) === dispatcherState.crosshairGroupId
);
});
}
function handleMapClick(event) {
const groupId = dispatcherState.crosshairGroupId;
if (!groupId) return;
const group = dispatcherState.groupById.get(Number(groupId));
if (!group) {
cancelCrosshair();
return;
}
const lat = event.latlng.lat;
const lon = event.latlng.lng;
const timestamp = Date.now();
const sent = sendWs({
code: 300,
msg: JSON.stringify({
group_id: group.id,
lat,
lon,
ts: timestamp,
actor: currentAccountId
})
});
if (!sent) 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();
}
/* ------------------------------------------------------------------ */
/* Straßen-Dialog */
/* ------------------------------------------------------------------ */
function openStreetModal(streetId) {
const street = dispatcherState.streetById.get(Number(streetId));
if (!street) return;
dispatcherState.currentStreetId = Number(streetId);
document.getElementById('streetModalTitle').textContent = `Straße: ${street.name}`;
document.getElementById('streetStateSelect').value = street.state || 'unbearbeitet';
fillStreetGroupOptions(street.group_id);
updateStreetGroupVisibility();
document.getElementById('streetModal').showModal();
}
function closeStreetModal() {
document.getElementById('streetModal').close();
}
function fillStreetGroupOptions(selectedGroupId) {
const select = document.getElementById('streetGroupSelect');
select.innerHTML = '';
const empty = document.createElement('option');
empty.value = '';
empty.textContent = '-';
select.appendChild(empty);
dispatcherState.groups.forEach(group => {
const option = document.createElement('option');
option.value = group.id;
option.textContent = groupDisplayName(group);
option.selected = Number(selectedGroupId) === Number(group.id);
select.appendChild(option);
});
}
function updateStreetGroupVisibility() {
const state = document.getElementById('streetStateSelect').value;
const groupSelect = document.getElementById('streetGroupSelect');
const groupLabel = document.getElementById('streetGroupLabel');
const enabled = state === 'zugewiesen';
groupSelect.disabled = !enabled;
groupLabel.classList.toggle('muted', !enabled);
}
function saveStreetState() {
const street = dispatcherState.streetById.get(dispatcherState.currentStreetId);
if (!street) return;
const newState = document.getElementById('streetStateSelect').value;
if (!STREET_STATES.includes(newState)) return;
let groupId = null;
if (newState === 'zugewiesen') {
groupId = Number(document.getElementById('streetGroupSelect').value) || null;
if (!groupId) {
alert('Bitte eine Gruppe auswählen.');
return;
}
} else if (newState === 'erledigt' && street.group_id) {
// Bei "erledigt" bleibt eine bestehende Gruppenzuordnung erhalten.
groupId = Number(street.group_id);
}
const sent = sendWs({
code: 100,
msg: JSON.stringify({
name: street.name,
state: newState,
actor: currentAccountId,
street_id: street.id,
group_id: groupId
})
});
if (sent) closeStreetModal();
}
/* ------------------------------------------------------------------ */
/* Nachrichten und Chat */
/* ------------------------------------------------------------------ */
function openChat(groupId) {
dispatcherState.chatGroupId = Number(groupId);
renderChat();
document.getElementById('chatModal').showModal();
}
function closeChatModal() {
document.getElementById('chatModal').close();
}
function renderChat() {
const group = dispatcherState.groupById.get(Number(dispatcherState.chatGroupId));
if (!group) return;
document.getElementById('chatTitle').textContent =
`Chat – ${groupDisplayName(group)}`;
const container = document.getElementById('chatMessages');
container.innerHTML = '';
const entries = dispatcherState.chatByGroup.get(Number(group.id)) || [];
if (!entries.length) {
const empty = document.createElement('div');
empty.className = 'chat-empty';
empty.textContent = 'Noch keine Nachrichten.';
container.appendChild(empty);
return;
}
entries
.slice()
.sort((a, b) => a.ts - b.ts)
.forEach(entry => {
const message = document.createElement('div');
message.className = 'chat-message';
if (Number(entry.sender_id) === currentAccountId) {
message.classList.add('own');
}
const header = document.createElement('div');
header.className = 'chat-message-header';
const sender = document.createElement('span');
sender.textContent = senderLabel(entry.sender_id);
const time = document.createElement('span');
time.textContent = formatChatTime(entry.ts);
header.append(sender, time);
const text = document.createElement('div');
text.className = 'chat-message-text';
text.textContent = entry.text;
message.append(header, text);
container.appendChild(message);
});
container.scrollTop = container.scrollHeight;
}
function senderLabel(senderId) {
const id = Number(senderId);
if (id === currentAccountId) return 'Ich';
const group = dispatcherState.groups.find(item => Number(item.account_id) === id);
if (group) return groupDisplayName(group);
return id ? `Account ${id}` : 'System';
}
function formatChatTime(timestamp) {
if (!timestamp) return '';
const date = new Date(timestamp);
if (Number.isNaN(date.getTime())) return '';
return date.toLocaleString('de-DE', {
day: '2-digit',
month: '2-digit',
hour: '2-digit',
minute: '2-digit',
second: '2-digit',
hour12: false
});
}
function addChatMessage(groupId, entry) {
const id = Number(groupId);
if (!dispatcherState.groupById.has(id)) return;
if (!dispatcherState.chatByGroup.has(id)) {
dispatcherState.chatByGroup.set(id, []);
}
if (!dispatcherState.chatKeysByGroup.has(id)) {
dispatcherState.chatKeysByGroup.set(id, new Set());
}
const keys = dispatcherState.chatKeysByGroup.get(id);
const key = `${entry.code}|${entry.sender_id}|${entry.ts}|${entry.text}`;
if (keys.has(key)) return;
keys.add(key);
dispatcherState.chatByGroup.get(id).push(entry);
if (dispatcherState.chatGroupId === id
&& document.getElementById('chatModal').open) {
renderChat();
}
}
function addBroadcastChatMessage(entry) {
dispatcherState.groups.forEach(group => addChatMessage(group.id, entry));
}
function extractMessageText(value) {
if (typeof value === 'string') return value;
if (value === null || value === undefined) return '';
if (typeof value === 'object') return JSON.stringify(value);
return String(value);
}
function parsePayload(value) {
if (value && typeof value === 'object') return value;
if (typeof value !== 'string') return null;
try {
const parsed = JSON.parse(value);
return parsed && typeof parsed === 'object' ? parsed : null;
} catch (error) {
return null;
}
}
function handleGroupChatMessage(message) {
const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId);
if (!group) return;
const text = extractMessageText(payload.text ?? payload.msg ?? '');
const input = document.querySelector(
`.group-item[data-group-id="${group.id}"] .group-message`
);
if (input) input.value = text;
addChatMessage(group.id, {
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
}
/* ------------------------------------------------------------------ */
/* WebSocket */
/* ------------------------------------------------------------------ */
async function connectWebSocket() {
if (dispatcherState.unloading) return;
if (dispatcherState.ws
&& (dispatcherState.ws.readyState === WebSocket.OPEN
|| dispatcherState.ws.readyState === WebSocket.CONNECTING)) {
return;
}
try {
const tokenResponse = await fetchJson(`${apiBase}/auth/ws-token`);
const token = tokenResponse.token;
const ws = new WebSocket(wsUrl);
dispatcherState.ws = ws;
ws.addEventListener('open', () => {
ws.send(JSON.stringify({code: 0, msg: token}));
dispatcherState.authenticated = true;
setConnectionStatus('Verbunden', 'connected');
});
ws.addEventListener('message', handleWsMessage);
ws.addEventListener('close', () => {
dispatcherState.authenticated = false;
setConnectionStatus('Getrennt – neuer Versuch …', 'disconnected');
scheduleReconnect();
});
ws.addEventListener('error', () => {
setConnectionStatus('Verbindungsfehler', 'disconnected');
});
} catch (error) {
console.error('WebSocket-Token konnte nicht geladen werden:', error);
setConnectionStatus('Token nicht verfügbar – neuer Versuch …', 'disconnected');
scheduleReconnect();
}
}
function scheduleReconnect() {
if (dispatcherState.unloading || dispatcherState.reconnectTimer) return;
dispatcherState.reconnectTimer = setTimeout(() => {
dispatcherState.reconnectTimer = null;
connectWebSocket();
}, 3000);
}
function setConnectionStatus(text, cssClass) {
const element = document.getElementById('connectionStatus');
if (!element) return;
element.textContent = text;
element.classList.remove('connected', 'disconnected');
if (cssClass) element.classList.add(cssClass);
}
function sendWs(message) {
if (!dispatcherState.ws
|| dispatcherState.ws.readyState !== WebSocket.OPEN
|| !dispatcherState.authenticated) {
alert('Die WebSocket-Verbindung ist noch nicht verfügbar.');
return false;
}
dispatcherState.ws.send(JSON.stringify(message));
return true;
}
function handleWsMessage(event) {
let message;
try {
message = JSON.parse(event.data);
} catch (error) {
console.warn('Ungültige WebSocket-Nachricht:', event.data);
return;
}
switch (Number(message.code)) {
case 1:
// Heartbeat des Servers beantworten.
if (dispatcherState.ws && dispatcherState.ws.readyState === WebSocket.OPEN) {
dispatcherState.ws.send(JSON.stringify({code: 2, msg: 'pong'}));
}
break;
case 100:
handleStreetUpdate(message);
break;
case 200:
handleGroupStateUpdate(message);
break;
case 300:
handleGroupPositionUpdate(message);
break;
case 1000: {
const text = extractMessageText(message.msg);
addBroadcastChatMessage({
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
break;
}
case 1100: {
const groupId = Number(message.receiver_id);
const text = extractMessageText(message.msg);
addChatMessage(groupId, {
sender_id: message.sender_id,
code: message.code,
ts: normalizeTimestamp(message.ts) || Date.now(),
text
});
break;
}
case 2000:
handleGroupChatMessage(message);
break;
default:
break;
}
}
function handleStreetUpdate(message) {
const payload = parsePayload(message.msg) || {};
let street = payload.street_id
? dispatcherState.streetById.get(Number(payload.street_id))
: null;
if (!street && payload.name) {
street = dispatcherState.streets.find(item => item.name === payload.name);
}
if (!street) return;
if (STREET_STATES.includes(payload.state)) {
street.state = payload.state;
}
if (Object.prototype.hasOwnProperty.call(payload, 'group_id')) {
street.group_id = payload.group_id === null || payload.group_id === ''
? null
: Number(payload.group_id);
}
recolorStreet(street);
}
function handleGroupStateUpdate(message) {
const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId);
if (!group) return;
if (GROUP_STATES.includes(payload.state)) {
group.state = payload.state;
updateGroupSummary(group);
}
}
function handleGroupPositionUpdate(message) {
const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId);
if (!group) return;
const lat = Number(payload.lat);
const lon = Number(payload.lon);
if (Number.isFinite(lat) && Number.isFinite(lon)
&& payload.lat !== null && payload.lon !== null) {
group.last_lat = lat;
group.last_lon = lon;
// Code 300 kann den Zeitstempel als Millisekunden (Broker) oder als
// SQLite-/ISO-Zeitstring (z. B. aus der History-Wiederherstellung)
// enthalten.
group.last_pos_ts = parseTimestamp(payload.ts) || Date.now();
group.last_pos_at = new Date(group.last_pos_ts).toISOString();
updateMarkerPosition(group);
} else {
// Positionslöschung (null-Koordinaten): Marker an die Browserposition
// verschieben, da der eigentliche Standort unbekannt ist.
group.last_lat = null;
group.last_lon = null;
group.last_pos_at = null;
group.last_pos_ts = null;
const marker = dispatcherState.markersByGroupId.get(group.id);
if (marker) marker.setLatLng(dispatcherState.browserLatLng || map.getCenter());
}
refreshGroupControls();
}
/* ------------------------------------------------------------------ */
/* Uhr, Slider und Footer */
/* ------------------------------------------------------------------ */
function updateClock() {
const now = new Date();
const timeElement = document.getElementById('clockTime');
if (timeElement) {
timeElement.textContent = now.toLocaleTimeString('de-DE', {hour12: false});
}
const dateElement = document.getElementById('clockDate');
if (dateElement) {
const weekday = now.toLocaleDateString('de-DE', {weekday: 'long'});
const date = now.toLocaleDateString('de-DE', {
day: '2-digit',
month: '2-digit',
year: 'numeric'
});
dateElement.textContent = `${weekday}, ${date}`;
}
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 = String(dispatcherState.settings.weight);
}
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() {
document.getElementById('baseLayerSelect').addEventListener('change', event => {
setBaseLayer(event.target.value);
});
document.getElementById('opacitySlider').addEventListener('input', event => {
dispatcherState.settings.opacity = clampNumber(
event.target.value, 0, 1, DEFAULT_SETTINGS.opacity
);
updateOpacityOutput();
updateAllPolylineStyles();
saveStoredSettings();
});
document.getElementById('weightSlider').addEventListener('input', event => {
dispatcherState.settings.weight = clampNumber(
event.target.value, 1, 100, DEFAULT_SETTINGS.weight
);
updateWeightOutput();
updateAllPolylineStyles();
saveStoredSettings();
});
document.getElementById('fitBoundsButton').addEventListener('click', fitAllStreetBounds);
document.getElementById('speakerButton').addEventListener('click', openSpeakerModal);
document.getElementById('streetStateSelect').addEventListener('change', updateStreetGroupVisibility);
document.addEventListener('keydown', event => {
if (event.key === 'Escape' && dispatcherState.crosshairGroupId) {
cancelCrosshair();
}
});
}
function openSpeakerModal() {
document.getElementById('speakerText').value = '';
document.getElementById('speakerModal').showModal();
}
function closeSpeakerModal() {
document.getElementById('speakerModal').close();
}
function sendSpeakerMessage() {
const input = document.getElementById('speakerText');
const text = input.value.trim();
if (!text) return;
if (sendWs({code: 1000, msg: text})) {
input.value = '';
closeSpeakerModal();
}
}
function showAccordionError(text) {
const container = document.getElementById('groupAccordion');
container.innerHTML = '';
const message = document.createElement('p');
message.className = 'group-empty';
message.textContent = text;
container.appendChild(message);
}