1326 lines
42 KiB
JavaScript
1326 lines
42 KiB
JavaScript
/*
|
||
* 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: '© OpenStreetMap-Mitwirkende'
|
||
});
|
||
aerialLayer = L.tileLayer(
|
||
'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
|
||
{
|
||
maxZoom: 19,
|
||
attribution: 'Tiles © 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);
|
||
}
|