Strassenverwaltung plus: Teilen von Strassenzügen

This commit is contained in:
concierge committed 2026-11-05 12:24:26 +01:00
1 parent d54a986c14
commit 3eb3b746ab
22 files changed
+17384 -151

No files matched your search

+38
View File
@@ -18,6 +18,44 @@ flask --app cmbnet run --debug --host 127.0.0.1 --port 5000
Öffne http://127.0.0.1:5000 und wähle einen Mandanten (BV, RV, SV).
## Mandantenspezifische Straßen-Polylines
Die Karten-Views laden `static/js/str2pl-<tenant>.js`, sofern diese Datei
existiert (z. B. `static/js/str2pl-RV.js`). Andernfalls wird die gemeinsame
`static/js/str2pl.js` verwendet. Eine mandantenspezifische Datei ersetzt die
gemeinsame Datei vollständig und muss dieselbe Struktur besitzen
(`window.STRASSE2POLYLINES = { ... }`).
Im View „Straßenverwaltung“ kann ein Administrator die Datei über den Button
„Polyline-Datei erzeugen“ neu schreiben lassen. Dabei werden immer alle
Straßen des Mandanten aus der Datenbank berücksichtigt; die gemeinsame
`str2pl.js` dient als Geometriequelle. Segmente außerhalb der jeweiligen
Bounding Box werden verworfen, aneinanderhängende Segmente mit identischen
Endpunkten werden zusammengefasst. Eine vorhandene mandantenspezifische Datei
wird überschrieben.
### Zusatz und geteilte Straßen
Jede Straße besitzt neben dem Namen einen optionalen `Zusatz`. Die
Polyline-Datei verwendet bei gesetztem Zusatz den Key `<Name> <Zusatz>`
(z. B. `Aggerstraße Nord`). Fehlt dieser Key, wird automatisch der Key ohne
Zusatz verwendet. Bei der Suche im Dispatcher wird der Zusatz ignoriert; die
Karte zoomt auf die gemeinsame Bounding Box aller Straßen mit demselben Namen.
Über den Button „Schneiden“ kann eine Straße an einer Hausnummer in zwei
Abschnitte geteilt werden. Beide Abschnitte enthalten die Trennnummer, erhalten
neu berechnete Bounding Boxes und bekommen je nach räumlicher Lage einen Zusatz
aus `Nord`, `Süd`, `Ost` oder `West`.
## Straßen- und Hausnummernimport
Der Import in der Straßenverwaltung erwartet eine CSV-Datei mit dem Trenner
`;` und den Spalten `#Straßenname;Hausnummer;Longitude;Latitude`. Aus den
Einträgen werden die Straßen gruppiert und jeweils minimale/maximale
Hausnummer sowie die Bounding Box berechnet. Der Import ersetzt die Straßen-
und Hausnummerndaten des Mandanten vollständig; neue Straßen starten mit dem
Status `unbearbeitet` und leerem Zusatz.
## Betrieb hinter einem Reverse-Proxy (URI-Prefix)
Die Anwendung kann unter einem beliebigen Pfad ausgeliefert werden, z. B.
+6
View File
@@ -97,6 +97,12 @@ def create_app(config_name=None):
'DISPLAY_TITLE', '20*C+M+B+27'
)
# Mandantenspezifisches Polyline-Skript (str2pl-<tenant>.js) mit Rückfall
# auf die gemeinsame str2pl.js.
from cmbnet.utils.helpers import str2pl_asset, str2pl_asset_version
app.jinja_env.globals['str2pl_asset'] = str2pl_asset
app.jinja_env.globals['str2pl_asset_version'] = str2pl_asset_version
# Middleware registrieren
app.wsgi_app = PrefixMiddleware(app.wsgi_app)
+147 -72
View File
@@ -1,7 +1,7 @@
"""
Admin API Endpunkte
"""
from flask import Blueprint, request, jsonify, g, session
from flask import Blueprint, request, jsonify, g, session, current_app
from cmbnet.auth import role_required
from cmbnet.db import get_db
from cmbnet.auth import hash_password
@@ -11,8 +11,10 @@ from cmbnet.models.streets import StreetModel
from cmbnet.services.groups_service import GroupsService
from cmbnet.services.history_service import HistoryService
from cmbnet.services.api_token_service import ApiTokenService
from cmbnet.services.streets_service import StreetsService
from cmbnet.services.str2pl_service import Str2PlService
from cmbnet.utils.helpers import log_transaction, notify_reload
from cmbnet.utils.csv_utils import parse_streets_csv, parse_house_numbers_csv
from cmbnet.utils.csv_utils import parse_house_numbers_csv
from cmbnet.ws import broker
from cmbnet.ws.protocol import WSMessage
import json
@@ -256,20 +258,23 @@ def create_street(**kwargs):
name = data.get('name', '').strip()
if not name:
return jsonify({'error': 'Name erforderlich'}), 400
zusatz = str(data.get('zusatz') or '').strip()
street_id = StreetModel.create(g.tenant_id, name,
hn_min=data.get('hn_min'),
hn_max=data.get('hn_max'),
bbox=data.get('bbox'),
state='unbearbeitet',
group_id=None)
group_id=None,
zusatz=zusatz)
db = get_db()
db.execute(
'INSERT INTO street_state_history (tenant_id, street_id, from_state, to_state, group_id, actor_account_id) VALUES (?, ?, ?, ?, ?, ?)',
(g.tenant_id, street_id, None, 'unbearbeitet', None, session['account_id'])
)
db.commit()
log_transaction('street.create', 'street', street_id, {'name': name})
notify_reload(f'Administration: Straße „{name}“ wurde erstellt.')
log_transaction('street.create', 'street', street_id, {'name': name, 'zusatz': zusatz})
display_name = f'{name} {zusatz}'.strip()
notify_reload(f'Administration: Straße „{display_name}“ wurde erstellt.')
return jsonify({'success': True, 'id': street_id})
@@ -283,10 +288,14 @@ def update_street(street_id, **kwargs):
return jsonify({'error': 'Straße nicht gefunden'}), 404
changes = {}
for key in ['name', 'hn_min', 'hn_max', 'bbox', 'group_id']:
for key in ['name', 'hn_min', 'hn_max', 'bbox', 'group_id', 'zusatz']:
if key in data:
if key == 'group_id' and (data[key] == '' or data[key] is None):
changes[key] = None
elif key == 'zusatz':
changes[key] = str(data[key] or '').strip()
elif key == 'name':
changes[key] = str(data[key] or '').strip()
elif key in ['hn_min', 'hn_max'] and data[key] != '' and data[key] is not None:
try:
changes[key] = int(data[key])
@@ -333,6 +342,87 @@ def delete_street(street_id, **kwargs):
return jsonify({'success': True})
@admin_api_bp.route('/strassen/bulk-delete', methods=['POST'])
@role_required('Administrator')
def bulk_delete_streets(**kwargs):
"""Löscht mehrere ausgewählte Straßen samt Hausnummern-Einträgen."""
data = request.get_json(silent=True)
if not isinstance(data, dict):
return jsonify({'error': 'JSON-Objekt erforderlich'}), 400
raw_ids = data.get('ids')
if not isinstance(raw_ids, list) or not raw_ids:
return jsonify({'error': 'Keine Straßen ausgewählt'}), 400
if len(raw_ids) > 10000:
return jsonify({'error': 'Zu viele Straßen auf einmal ausgewählt'}), 400
ids = []
for value in raw_ids:
if isinstance(value, bool):
return jsonify({'error': 'Ungültige Straßen-ID'}), 400
if isinstance(value, int):
street_id = value
elif isinstance(value, str) and value.strip().isdigit():
street_id = int(value.strip())
else:
return jsonify({'error': 'Ungültige Straßen-ID'}), 400
if street_id <= 0 or street_id > 9223372036854775807:
return jsonify({'error': 'Ungültige Straßen-ID'}), 400
if street_id not in ids:
ids.append(street_id)
result = StreetModel.delete_many(ids, g.tenant_id)
deleted_streets = result['streets']
if not deleted_streets:
return jsonify({'error': 'Keine passenden Straßen gefunden'}), 404
deleted_ids = [street['id'] for street in deleted_streets]
deleted_names = [street['name'] for street in deleted_streets]
log_transaction('street.bulk_delete', 'street', None, {
'ids': deleted_ids,
'names': deleted_names,
'house_numbers': result['house_numbers']
})
notify_reload(
f'Administration: {len(deleted_streets)} Straße(n) wurden gelöscht.'
)
return jsonify({
'success': True,
'deleted': len(deleted_streets),
'ids': deleted_ids,
'house_numbers_deleted': result['house_numbers']
})
@admin_api_bp.route('/strassen/str2pl', methods=['POST'])
@role_required('Administrator')
def generate_str2pl(**kwargs):
"""Erzeugt die mandantenspezifische Polyline-Datei neu.
Es werden immer alle Straßen des Mandanten aus der Datenbank
berücksichtigt; eine eventuelle Auswahl in der Oberfläche spielt keine
Rolle.
"""
try:
stats = Str2PlService.generate_for_tenant(g.tenant_id, g.tenant_code)
except FileNotFoundError as exc:
return jsonify({'error': str(exc)}), 400
except ValueError as exc:
return jsonify({'error': str(exc)}), 500
except OSError as exc:
current_app.logger.warning(
'Polyline-Datei konnte nicht geschrieben werden: %s', exc
)
return jsonify({'error': 'Polyline-Datei konnte nicht geschrieben werden'}), 500
log_transaction('street.str2pl_generate', 'street', None, stats)
notify_reload(
f'Administration: Polyline-Datei für Mandant {g.tenant_code} '
'wurde neu erzeugt.'
)
return jsonify({'success': True, **stats})
@admin_api_bp.route('/strassen/<int:street_id>/history')
@role_required('Administrator')
def street_history(street_id, **kwargs):
@@ -357,6 +447,7 @@ def revert_street_hist(street_id, hist_id, **kwargs):
@admin_api_bp.route('/strassen/import', methods=['POST'])
@role_required('Administrator')
def import_streets(**kwargs):
"""Importiert Straßen und Hausnummern aus einer gemeinsamen CSV-Datei."""
if 'file' not in request.files:
return jsonify({'error': 'Keine Datei'}), 400
file = request.files['file']
@@ -367,26 +458,59 @@ def import_streets(**kwargs):
if len(content) > 5_000_000:
return jsonify({'error': 'Datei zu groß'}), 400
streets_data = parse_streets_csv(content)
if not streets_data:
house_numbers = parse_house_numbers_csv(content)
if not house_numbers:
return jsonify({
'error': 'Keine gültigen Straßen in der CSV gefunden. '
'Erwartete Spalten: Name;Hausnummer minimal;Hausnummer maximal;Bounding Box'
'error': 'Keine gültigen Einträge in der CSV gefunden. '
'Erwartete Spalten: Straßenname;Hausnummer;Longitude;Latitude'
}), 400
db = get_db()
count = 0
for s in streets_data:
street_id = StreetModel.create(g.tenant_id, s['name'], s['hn_min'], s['hn_max'], s['bbox'], 'unbearbeitet', None)
db.execute(
'INSERT INTO street_state_history (tenant_id, street_id, from_state, to_state, group_id, actor_account_id) VALUES (?, ?, ?, ?, ?, ?)',
(g.tenant_id, street_id, None, 'unbearbeitet', None, session['account_id'])
)
log_transaction('street.import', 'street', street_id, {'name': s['name']})
count += 1
db.commit()
notify_reload(f'Administration: {count} Straßen wurden importiert.')
return jsonify({'success': True, 'count': count})
stats = StreetsService.import_from_house_numbers(
g.tenant_id, house_numbers, session['account_id']
)
log_transaction('street.import', 'street', None, stats)
notify_reload(
f'Administration: {stats["streets"]} Straßen und '
f'{stats["house_numbers"]} Hausnummern wurden importiert.'
)
return jsonify({
'success': True,
'count': stats['streets'],
'streets': stats['streets'],
'house_numbers': stats['house_numbers'],
})
@admin_api_bp.route('/strassen/<int:street_id>/split-options', methods=['GET'])
@role_required('Administrator')
def street_split_options(street_id, **kwargs):
"""Liefert die für eine Teilung wählbaren Hausnummern."""
options = StreetsService.get_split_options(street_id, g.tenant_id)
if options is None:
return jsonify({'error': 'Straße nicht gefunden'}), 404
return jsonify(options)
@admin_api_bp.route('/strassen/<int:street_id>/split', methods=['POST'])
@role_required('Administrator')
def split_street(street_id, **kwargs):
"""Teilt eine Straße an einer Hausnummer in zwei Abschnitte."""
data = request.get_json(silent=True) or {}
success, result = StreetsService.split_street(
street_id,
g.tenant_id,
data.get('house_number'),
session['account_id']
)
if not success:
return jsonify({'error': result}), 400
log_transaction('street.split', 'street', street_id, result)
notify_reload(
f'Administration: Straße „{result["lower"]["zusatz"]}“ / '
f'„{result["upper"]["zusatz"]}“ wurde geteilt.'
)
return jsonify({'success': True, **result})
@admin_api_bp.route('/broker/status')
@@ -411,52 +535,3 @@ def broker_status(**kwargs):
'group_alias': conn['group_alias']
})
return jsonify({'connections': result})
@admin_api_bp.route('/hausnummern/import', methods=['POST'])
@role_required('Administrator')
def import_house_numbers(**kwargs):
if 'file' not in request.files:
return jsonify({'error': 'Keine Datei'}), 400
file = request.files['file']
if file.filename == '':
return jsonify({'error': 'Keine Datei ausgewählt'}), 400
content = file.read()
if len(content) > 5_000_000:
return jsonify({'error': 'Datei zu groß'}), 400
house_numbers = parse_house_numbers_csv(content)
if not house_numbers:
return jsonify({
'error': 'Keine gültigen Hausnummern in der CSV gefunden. '
'Erwartete Spalten: Straßenname;Hausnummer;Longitude;Latitude'
}), 400
db = get_db()
for entry in house_numbers:
db.execute(
'''INSERT INTO street_house_numbers
(tenant_id, street_name, house_number, longitude, latitude)
VALUES (?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, street_name, house_number)
DO UPDATE SET longitude = excluded.longitude,
latitude = excluded.latitude''',
(
g.tenant_id,
entry['street_name'],
entry['house_number'],
entry['longitude'],
entry['latitude']
)
)
db.commit()
log_transaction(
'house_number.import',
'street_house_number',
None,
{'count': len(house_numbers)}
)
notify_reload(f'Administration: {len(house_numbers)} Hausnummern wurden importiert.')
return jsonify({'success': True, 'count': len(house_numbers)})
+1 -1
View File
@@ -14,7 +14,7 @@ def strassen(**kwargs):
"""Straßenverwaltung"""
db = get_db()
strassen = db.execute(
'SELECT s.*, g.aliasname as group_name FROM streets s LEFT JOIN groups g ON s.group_id = g.id WHERE s.tenant_id = ? ORDER BY s.name',
'SELECT s.*, g.aliasname as group_name FROM streets s LEFT JOIN groups g ON s.group_id = g.id WHERE s.tenant_id = ? ORDER BY s.name, s.zusatz',
(g.tenant_id,)
).fetchall()
gruppen = db.execute(
+19
View File
@@ -109,6 +109,24 @@ def ensure_api_schema(db):
db.commit()
def ensure_street_schema(db):
"""Ergänzt bestehende Datenbanken um das Straßenfeld ``zusatz``."""
streets_table = db.execute(
"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'streets'"
).fetchone()
if not streets_table:
return
columns = {
row['name'] for row in db.execute('PRAGMA table_info(streets)').fetchall()
}
if 'zusatz' not in columns:
db.execute(
"ALTER TABLE streets ADD COLUMN zusatz TEXT NOT NULL DEFAULT ''"
)
db.commit()
def ensure_schema():
"""Ergänzt bestehende Datenbanken um das Gruppen-Account-Zuordnungsmodell.
@@ -120,6 +138,7 @@ def ensure_schema():
db = get_db()
ensure_ws_schema(db)
ensure_api_schema(db)
ensure_street_schema(db)
groups_table = db.execute(
"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'groups'"
).fetchone()
+99 -5
View File
@@ -4,6 +4,12 @@ Street Model - Abstraktionsschicht für Datenbankzugriffe
from cmbnet.db import get_db
def _chunks(values, size=400):
"""Teilt eine Liste in Blöcke, damit SQLite-Parameterlimits nicht greifen."""
for index in range(0, len(values), size):
yield values[index:index + size]
class StreetModel:
@staticmethod
def get_all_by_tenant(tenant_id):
@@ -30,11 +36,11 @@ class StreetModel:
).fetchall()
@staticmethod
def create(tenant_id, name, hn_min=None, hn_max=None, bbox=None, state='unbearbeitet', group_id=None):
def create(tenant_id, name, hn_min=None, hn_max=None, bbox=None, state='unbearbeitet', group_id=None, zusatz=''):
db = get_db()
cursor = db.execute(
'INSERT INTO streets (tenant_id, name, hn_min, hn_max, bbox, state, group_id) VALUES (?, ?, ?, ?, ?, ?, ?)',
(tenant_id, name, hn_min, hn_max, bbox, state, group_id)
'INSERT INTO streets (tenant_id, name, hn_min, hn_max, bbox, state, group_id, zusatz) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
(tenant_id, name, hn_min, hn_max, bbox, state, group_id, zusatz or '')
)
db.commit()
return cursor.lastrowid
@@ -42,7 +48,7 @@ class StreetModel:
@staticmethod
def update(street_id, tenant_id, **kwargs):
db = get_db()
allowed = ['name', 'state', 'group_id', 'hn_min', 'hn_max', 'bbox']
allowed = ['name', 'state', 'group_id', 'hn_min', 'hn_max', 'bbox', 'zusatz']
updates = []
values = []
for k, v in kwargs.items():
@@ -58,6 +64,94 @@ class StreetModel:
@staticmethod
def delete(street_id, tenant_id):
"""Löscht eine Straße samt ihrer Hausnummern-Einträge.
Die Hausnummern-Einträge werden nur entfernt, wenn danach kein
weiterer Abschnitt derselben Straße mehr existiert.
"""
return StreetModel.delete_many([street_id], tenant_id)
@staticmethod
def delete_many(street_ids, tenant_id):
"""Löscht mehrere Straßen samt ihrer Hausnummern-Einträge.
Die Hausnummern-Tabelle ist über den Straßennamen und nicht über die
Straßen-ID verknüpft. Deshalb werden die Namen vor dem Löschen der
Straßen gelesen und die passenden Hausnummern-Einträge mitgelöscht.
Rückgabe: ``{'streets': [...], 'house_numbers': <Anzahl>}``.
"""
ids = []
for value in street_ids:
try:
street_id = int(value)
except (TypeError, ValueError):
continue
if street_id > 0 and street_id not in ids:
ids.append(street_id)
result = {'streets': [], 'house_numbers': 0}
if not ids:
return result
db = get_db()
db.execute('DELETE FROM streets WHERE id = ? AND tenant_id = ?', (street_id, tenant_id))
rows = []
try:
for chunk in _chunks(ids):
placeholders = ', '.join('?' for _ in chunk)
rows.extend(db.execute(
f'''SELECT id, name FROM streets
WHERE tenant_id = ? AND id IN ({placeholders})''',
(tenant_id, *chunk)
).fetchall())
if not rows:
return result
found_ids = [row['id'] for row in rows]
names = []
for row in rows:
if row['name'] not in names:
names.append(row['name'])
# Zuerst die Straßen löschen. Hausnummern sind nur über den Namen
# verknüpft und werden erst entfernt, wenn kein anderer Abschnitt
# derselben Straße mehr existiert.
for chunk in _chunks(found_ids):
placeholders = ', '.join('?' for _ in chunk)
db.execute(
f'''DELETE FROM streets
WHERE tenant_id = ? AND id IN ({placeholders})''',
(tenant_id, *chunk)
)
remaining_names = set()
for chunk in _chunks(names):
placeholders = ', '.join('?' for _ in chunk)
remaining_names.update(
row['name'] for row in db.execute(
f'''SELECT DISTINCT name FROM streets
WHERE tenant_id = ? AND name IN ({placeholders})''',
(tenant_id, *chunk)
).fetchall()
)
names_to_delete = [
name for name in names if name not in remaining_names
]
for chunk in _chunks(names_to_delete):
placeholders = ', '.join('?' for _ in chunk)
cursor = db.execute(
f'''DELETE FROM street_house_numbers
WHERE tenant_id = ? AND street_name IN ({placeholders})''',
(tenant_id, *chunk)
)
result['house_numbers'] += max(cursor.rowcount, 0)
db.commit()
except Exception:
db.rollback()
raise
result['streets'] = [dict(row) for row in rows]
return result
+1
View File
@@ -1,3 +1,4 @@
from .groups_service import GroupsService
from .streets_service import StreetsService
from .accounts_service import AccountsService
from .str2pl_service import Str2PlService
+278
View File
@@ -0,0 +1,278 @@
"""
Erzeugung der mandantenspezifischen Polyline-Datei ``str2pl-<tenant>.js``.
"""
import ast
import json
import os
import tempfile
from pathlib import Path
from flask import current_app
from cmbnet.models.streets import StreetModel
from cmbnet.utils.geo_utils import parse_bbox, to_float
from cmbnet.utils.helpers import str2pl_filename
class Str2PlService:
"""Erzeugt das JavaScript-Dict der Straßen-Polylines für einen Mandanten."""
@staticmethod
def generate_for_tenant(tenant_id, tenant_code):
"""Schreibt ``static/js/str2pl-<tenant>.js`` neu.
Als Geometriequelle dient die gemeinsame ``str2pl.js``. Nur Straßen,
die in der Datenbank des Mandanten vorhanden sind, werden übernommen.
Bei gesetztem Zusatz wird der Key ``<Name> <Zusatz>`` erzeugt; die
Geometrie stammt weiterhin vom Namen ohne Zusatz. Segmente außerhalb
der Straßen-Bounding-Box werden verworfen; aneinanderhängende Segmente
mit identischen Endpunkten werden zusammengefasst.
Rückgabe: Statistik-Dict für die Rückmeldung an die Oberfläche.
"""
static_folder = Path(current_app.static_folder)
target = static_folder / str2pl_filename(tenant_code)
source = static_folder / 'js' / 'str2pl.js'
if not source.is_file():
# Falls die gemeinsame Datei fehlt, kann eine bereits vorhandene
# mandantenspezifische Datei als Quelle dienen.
source = target
if not source.is_file():
raise FileNotFoundError(
'Weder str2pl.js noch eine mandantenspezifische '
'Polyline-Datei gefunden.'
)
source_data = _load_polylines(source)
source_by_name = {}
for key, value in source_data.items():
normalized = str(key).strip().casefold()
if normalized and normalized not in source_by_name:
source_by_name[normalized] = value
streets = StreetModel.get_all_by_tenant(tenant_id)
output = {}
stats = {
'streets_total': len(streets),
'streets_with_geometry': 0,
'streets_without_geometry': 0,
'segments_written': 0,
'segments_outside_bbox': 0,
'segments_merged': 0,
}
for street in streets:
name = str(street['name'] or '').strip()
if not name:
continue
zusatz = str(street['zusatz'] or '').strip()
output_key = f'{name} {zusatz}' if zusatz else name
bounds = parse_bbox(street['bbox'])
source_segments = _find_source_segments(
source_by_name, name, zusatz
)
segments = []
if isinstance(source_segments, list):
oriented = _orient_segments(source_segments, bounds)
kept = []
for segment in oriented:
if bounds and not _segment_intersects_bbox(segment, bounds):
stats['segments_outside_bbox'] += 1
continue
kept.append(segment)
merged = _merge_segments(kept)
stats['segments_merged'] += max(len(kept) - len(merged), 0)
segments = [
[[lat, lon] for lat, lon in segment]
for segment in merged
]
if segments:
stats['streets_with_geometry'] += 1
else:
stats['streets_without_geometry'] += 1
# Auch Straßen ohne passende Quelle werden mit einer leeren Liste
# aufgenommen, damit das Dict ausschließlich die Straßen der
# Datenbank enthält. Der Key enthält bei geteilten Straßen den
# Zusatz; die Laufzeit fällt bei fehlendem Key auf den Namen zurück.
if output_key in output:
output[output_key] = output[output_key] + segments
else:
output[output_key] = segments
stats['segments_written'] = sum(len(value) for value in output.values())
_write_polyline_file(target, output, tenant_code)
return stats
def _load_polylines(path):
"""Liest ``window.STRASSE2POLYLINES = { ... };`` als Python-Dict."""
text = path.read_text(encoding='utf-8')
start = text.find('{')
end = text.rfind('}')
if start < 0 or end <= start:
raise ValueError('Polyline-Datei enthält kein JavaScript-Objekt')
body = text[start:end + 1]
try:
data = ast.literal_eval(body)
except (SyntaxError, ValueError) as exc:
raise ValueError(f'Polyline-Datei konnte nicht gelesen werden: {exc}') from exc
if not isinstance(data, dict):
raise ValueError('Polyline-Datei enthält kein Straßen-Dict')
return data
def _find_source_segments(source_by_name, name, zusatz):
"""Sucht die Ursprungsgeometrie einer Straße.
Bevorzugt wird immer der Straßenname ohne Zusatz. Nur wenn dafür keine
Geometrie existiert, wird der exakte Key aus Name und Zusatz verwendet.
"""
candidates = [name]
if zusatz:
candidates.append(f'{name} {zusatz}')
for candidate in candidates:
segments = source_by_name.get(str(candidate).strip().casefold())
if isinstance(segments, list):
return segments
return None
def _orient_segments(segments, bounds):
"""Wandelt Segmentpunkte in die Reihenfolge ``[lat, lon]`` um.
Das mitgelieferte Fragment enthält historisch ``[lat, lon]``, die
Spezifikation nennt dagegen ``[lon, lat]``. Anhand der Straßen-Bounding-Box
wird die passende Reihenfolge je Straße bestimmt.
"""
if bounds is None:
return _clean_segments(segments, swap=False)
direct = _count_inside(segments, bounds, swap=False)
swapped = _count_inside(segments, bounds, swap=True)
return _clean_segments(segments, swap=swapped > direct)
def _count_inside(segments, bounds, swap):
lat_min, lat_max, lon_min, lon_max = bounds
count = 0
for segment in segments:
if not isinstance(segment, (list, tuple)):
continue
for point in segment:
if not isinstance(point, (list, tuple)) or len(point) < 2:
continue
first = to_float(point[0])
second = to_float(point[1])
if first is None or second is None:
continue
lat, lon = (second, first) if swap else (first, second)
if lat_min <= lat <= lat_max and lon_min <= lon <= lon_max:
count += 1
return count
def _clean_segments(segments, swap):
result = []
for segment in segments:
if not isinstance(segment, (list, tuple)):
continue
points = []
for point in segment:
if not isinstance(point, (list, tuple)) or len(point) < 2:
continue
first = to_float(point[0])
second = to_float(point[1])
if first is None or second is None:
continue
lat, lon = (second, first) if swap else (first, second)
points.append((lat, lon))
if len(points) >= 2:
result.append(points)
return result
def _segment_intersects_bbox(segment, bounds):
"""Prüft, ob das Segment die Straßen-Bounding-Box berührt."""
lat_min, lat_max, lon_min, lon_max = bounds
lats = [point[0] for point in segment]
lons = [point[1] for point in segment]
return not (
max(lats) < lat_min
or min(lats) > lat_max
or max(lons) < lon_min
or min(lons) > lon_max
)
def _merge_segments(segments):
"""Fasst Segmente mit identischen Endpunkten zu einem Segment zusammen."""
merged = [list(segment) for segment in segments]
changed = True
while changed:
changed = False
for index in range(len(merged)):
for other in range(index + 1, len(merged)):
joined = _join_segments(merged[index], merged[other])
if joined is None:
continue
merged[index] = joined
del merged[other]
changed = True
break
if changed:
break
return merged
def _join_segments(first, second):
"""Verbindet zwei Segmente, wenn sie einen Endpunkt teilen."""
if not first or not second:
return None
if first[-1] == second[0]:
return first[:-1] + second
if first[-1] == second[-1]:
return first[:-1] + second[::-1]
if first[0] == second[-1]:
return second[:-1] + first
if first[0] == second[0]:
return first[::-1] + second[1:]
return None
def _write_polyline_file(target, data, tenant_code):
"""Schreibt die Polyline-Datei atomar."""
content = (
'// Automatisch erzeugt durch die CMBNet-Straßenverwaltung '
f'für Mandant {tenant_code}.\n'
'window.STRASSE2POLYLINES = '
+ json.dumps(data, ensure_ascii=False, indent=4)
+ ';\n'
)
target.parent.mkdir(parents=True, exist_ok=True)
fd, temp_name = tempfile.mkstemp(
dir=str(target.parent),
prefix=f'.{target.name}.',
suffix='.tmp'
)
try:
with os.fdopen(fd, 'w', encoding='utf-8') as handle:
handle.write(content)
os.replace(temp_name, target)
except Exception:
try:
os.unlink(temp_name)
except OSError:
pass
raise
+314 -1
View File
@@ -1,10 +1,66 @@
"""
Streets Service - Geschäftslogik für Straßen
"""
import json
import math
import re
from cmbnet.models.streets import StreetModel
from cmbnet.db import get_db
from cmbnet.utils.geo_utils import bbox_center, bbox_from_lonlat
from cmbnet.utils.helpers import log_transaction
import json
_HOUSE_NUMBER_RE = re.compile(r'^\s*(\d+)')
def _house_number_value(value):
"""Liefert den führenden numerischen Teil einer Hausnummer oder ``None``."""
match = _HOUSE_NUMBER_RE.match(str(value or ''))
if not match:
return None
try:
return int(match.group(1))
except ValueError:
return None
def _normalize_name(value):
"""Vereinheitlicht einen Straßennamen für Gruppierung und Vergleiche."""
return ' '.join(str(value or '').split())
def _combine_zusatz(existing, direction):
"""Ergänzt einen bestehenden Zusatz um die neue Richtung."""
existing = _normalize_name(existing)
if not existing:
return direction
return f'{existing}-{direction}'
def _direction_suffixes(lower_bbox, upper_bbox):
"""Bestimmt die Richtungszusätze anhand der beiden Bounding-Box-Mittelpunkte.
Rückgabe: ``(zusatz_unten, zusatz_oben)``.
"""
lower_center = bbox_center(lower_bbox)
upper_center = bbox_center(upper_bbox)
if lower_center is None or upper_center is None:
return 'Nord', 'Süd'
delta_lat = lower_center[0] - upper_center[0]
delta_lon = lower_center[1] - upper_center[1]
mean_lat = math.radians((lower_center[0] + upper_center[0]) / 2)
east_west_distance = abs(delta_lon) * math.cos(mean_lat)
if abs(delta_lat) >= east_west_distance:
if delta_lat >= 0:
return 'Nord', 'Süd'
return 'Süd', 'Nord'
if delta_lon >= 0:
return 'Ost', 'West'
return 'West', 'Ost'
class StreetsService:
@@ -17,6 +73,7 @@ class StreetsService:
result.append({
'id': street['id'],
'name': street['name'],
'zusatz': street['zusatz'] or '',
'state': street['state'],
'group_id': street['group_id'],
'hn_min': street['hn_min'],
@@ -25,6 +82,262 @@ class StreetsService:
})
return result
@staticmethod
def import_from_house_numbers(tenant_id, entries, actor_account_id=None):
"""Ersetzt Straßen und Hausnummern eines Mandanten durch einen Import.
Die Hausnummern-Einträge werden nach Straßenname gruppiert. Pro Straße
werden minimale/maximale Hausnummer und die Bounding Box aus allen
Koordinaten berechnet. Der Zusatz startet nach dem Import immer leer.
"""
grouped = {}
for entry in entries or []:
name = _normalize_name(entry.get('street_name'))
if not name:
continue
key = name.casefold()
group = grouped.setdefault(key, {'name': name, 'entries': []})
group['entries'].append(entry)
stats = {
'streets': len(grouped),
'house_numbers': len(entries or []),
}
if not grouped:
return stats
db = get_db()
try:
# Der Import ist die alleinige Quelle für Straßen und Hausnummern.
# Bestehende Einträge (inkl. früherer Teilungen) werden ersetzt.
db.execute(
'DELETE FROM street_state_history WHERE tenant_id = ?',
(tenant_id,)
)
db.execute(
'DELETE FROM street_house_numbers WHERE tenant_id = ?',
(tenant_id,)
)
db.execute(
'DELETE FROM streets WHERE tenant_id = ?',
(tenant_id,)
)
for group in grouped.values():
name = group['name']
numbers = []
points = []
for entry in group['entries']:
number = _house_number_value(entry.get('house_number'))
if number is not None:
numbers.append(number)
try:
longitude = float(entry.get('longitude'))
latitude = float(entry.get('latitude'))
except (TypeError, ValueError):
continue
points.append((longitude, latitude))
hn_min = min(numbers) if numbers else None
hn_max = max(numbers) if numbers else None
bbox = bbox_from_lonlat(points)
cursor = db.execute(
'''INSERT INTO streets
(tenant_id, name, state, group_id, hn_min, hn_max, bbox, zusatz)
VALUES (?, ?, 'unbearbeitet', NULL, ?, ?, ?, '')''',
(tenant_id, name, hn_min, hn_max, bbox)
)
street_id = cursor.lastrowid
db.execute(
'''INSERT INTO street_state_history
(tenant_id, street_id, from_state, to_state, group_id,
actor_account_id, reason)
VALUES (?, ?, NULL, 'unbearbeitet', NULL, ?, 'Import')''',
(tenant_id, street_id, actor_account_id)
)
for entry in group['entries']:
db.execute(
'''INSERT INTO street_house_numbers
(tenant_id, street_name, house_number, longitude, latitude)
VALUES (?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, street_name, house_number)
DO UPDATE SET longitude = excluded.longitude,
latitude = excluded.latitude''',
(
tenant_id,
name,
entry.get('house_number'),
entry.get('longitude'),
entry.get('latitude')
)
)
db.commit()
stats['house_numbers'] = db.execute(
'SELECT COUNT(*) FROM street_house_numbers WHERE tenant_id = ?',
(tenant_id,)
).fetchone()[0]
except Exception:
db.rollback()
raise
return stats
@staticmethod
def get_split_options(street_id, tenant_id):
"""Liefert die im gültigen Bereich liegenden Hausnummern einer Straße."""
street = StreetModel.get_by_id(street_id, tenant_id)
if not street:
return None
hn_min = street['hn_min']
hn_max = street['hn_max']
numbers = set()
if hn_min is not None and hn_max is not None:
rows = get_db().execute(
'''SELECT house_number FROM street_house_numbers
WHERE tenant_id = ? AND street_name = ?''',
(tenant_id, street['name'])
).fetchall()
for row in rows:
number = _house_number_value(row['house_number'])
if number is not None and hn_min <= number <= hn_max:
numbers.add(number)
return {
'id': street['id'],
'name': street['name'],
'zusatz': street['zusatz'] or '',
'hn_min': hn_min,
'hn_max': hn_max,
'house_numbers': sorted(numbers),
}
@staticmethod
def split_street(street_id, tenant_id, house_number, actor_account_id=None):
"""Teilt eine Straße an einer Hausnummer in zwei Abschnitte.
Rückgabe: ``(True, result)`` oder ``(False, fehlermeldung)``.
"""
street = StreetModel.get_by_id(street_id, tenant_id)
if not street:
return False, 'Straße nicht gefunden'
try:
split_number = int(str(house_number).strip())
except (TypeError, ValueError):
return False, 'Ungültige Hausnummer'
hn_min = street['hn_min']
hn_max = street['hn_max']
if hn_min is None or hn_max is None:
return False, 'Für diese Straße ist kein Hausnummernbereich hinterlegt'
if split_number < hn_min or split_number > hn_max:
return False, (
f'Die Hausnummer muss zwischen {hn_min} und {hn_max} liegen'
)
rows = get_db().execute(
'''SELECT house_number, longitude, latitude
FROM street_house_numbers
WHERE tenant_id = ? AND street_name = ?''',
(tenant_id, street['name'])
).fetchall()
lower_points = []
upper_points = []
for row in rows:
number = _house_number_value(row['house_number'])
if number is None or number < hn_min or number > hn_max:
continue
try:
point = (float(row['longitude']), float(row['latitude']))
except (TypeError, ValueError):
continue
if number <= split_number:
lower_points.append(point)
if number >= split_number:
upper_points.append(point)
if not lower_points or not upper_points:
return False, (
'Für beide Abschnitte werden Hausnummern-Koordinaten benötigt'
)
lower_bbox = bbox_from_lonlat(lower_points)
upper_bbox = bbox_from_lonlat(upper_points)
if lower_bbox is None or upper_bbox is None:
return False, 'Bounding Boxes konnten nicht berechnet werden'
lower_direction, upper_direction = _direction_suffixes(
lower_bbox, upper_bbox
)
lower_zusatz = _combine_zusatz(street['zusatz'], lower_direction)
upper_zusatz = _combine_zusatz(street['zusatz'], upper_direction)
db = get_db()
existing_zusatz = {
(row['zusatz'] or '').casefold()
for row in db.execute(
'''SELECT zusatz FROM streets
WHERE tenant_id = ? AND name = ? AND id <> ?''',
(tenant_id, street['name'], street_id)
).fetchall()
}
for zusatz in (lower_zusatz, upper_zusatz):
if zusatz.casefold() in existing_zusatz:
return False, f'Der Zusatz „{zusatz}“ ist bereits vergeben'
try:
db.execute(
'''UPDATE streets
SET hn_min = ?, hn_max = ?, bbox = ?, zusatz = ?,
updated_at = CURRENT_TIMESTAMP
WHERE id = ? AND tenant_id = ?''',
(hn_min, split_number, lower_bbox, lower_zusatz,
street_id, tenant_id)
)
cursor = db.execute(
'''INSERT INTO streets
(tenant_id, name, state, group_id, hn_min, hn_max, bbox, zusatz)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)''',
(tenant_id, street['name'], street['state'], street['group_id'],
split_number, hn_max, upper_bbox, upper_zusatz)
)
new_street_id = cursor.lastrowid
db.execute(
'''INSERT INTO street_state_history
(tenant_id, street_id, from_state, to_state, group_id,
actor_account_id, reason)
VALUES (?, ?, NULL, ?, ?, ?, 'Straße geteilt')''',
(tenant_id, new_street_id, street['state'],
street['group_id'], actor_account_id)
)
db.commit()
except Exception:
db.rollback()
raise
return True, {
'street_id': street_id,
'new_street_id': new_street_id,
'split_house_number': split_number,
'lower': {
'hn_min': hn_min,
'hn_max': split_number,
'zusatz': lower_zusatz,
'bbox': lower_bbox,
},
'upper': {
'hn_min': split_number,
'hn_max': hn_max,
'zusatz': upper_zusatz,
'bbox': upper_bbox,
},
}
@staticmethod
def update_street(street_id, tenant_id, changes, actor_account_id=None):
"""Aktualisiert eine Straße und schreibt History/Log"""
+112
View File
@@ -0,0 +1,112 @@
"""
Hilfsfunktionen für Bounding Boxes und Koordinaten.
"""
import json
import math
def to_float(value):
"""Wandelt einen Wert in eine endliche Fließkommazahl um."""
try:
number = float(value)
except (TypeError, ValueError):
return None
return number if math.isfinite(number) else None
def parse_bbox(raw):
"""Liefert ``(lat_min, lat_max, lon_min, lon_max)`` oder ``None``.
Unterstützt das im Projekt verwendete Format
``[[lon, lat], [lon, lat]]`` sowie ``[west, south, east, north]`` und
Dict-Varianten mit ``south``/``west``/``north``/``east``.
"""
if raw is None or raw == '':
return None
if isinstance(raw, str):
try:
value = json.loads(raw)
except (TypeError, ValueError):
return None
else:
value = raw
if isinstance(value, (list, tuple)):
if (len(value) == 2
and all(isinstance(item, (list, tuple)) and len(item) >= 2
for item in value)):
first_lon = to_float(value[0][0])
first_lat = to_float(value[0][1])
second_lon = to_float(value[1][0])
second_lat = to_float(value[1][1])
if None not in (first_lon, first_lat, second_lon, second_lat):
return (
min(first_lat, second_lat),
max(first_lat, second_lat),
min(first_lon, second_lon),
max(first_lon, second_lon),
)
elif len(value) == 4:
numbers = [to_float(item) for item in value]
if all(number is not None for number in numbers):
west, south, east, north = numbers
return (
min(south, north),
max(south, north),
min(west, east),
max(west, east),
)
if isinstance(value, dict):
south = _first_number(value, 'south', 'minLat')
north = _first_number(value, 'north', 'maxLat')
west = _first_number(value, 'west', 'minLon')
east = _first_number(value, 'east', 'maxLon')
if None not in (south, north, west, east):
return (
min(south, north),
max(south, north),
min(west, east),
max(west, east),
)
return None
def bbox_from_lonlat(points):
"""Erzeugt den Bounding-Box-String aus ``(lon, lat)``-Paaren."""
valid = [
(lon, lat)
for lon, lat in points
if lon is not None and lat is not None
]
if not valid:
return None
min_lon = min(point[0] for point in valid)
max_lon = max(point[0] for point in valid)
min_lat = min(point[1] for point in valid)
max_lat = max(point[1] for point in valid)
return json.dumps([
[min_lon, max_lat],
[max_lon, min_lat],
])
def bbox_center(raw):
"""Mittelpunkt einer Bounding Box als ``(lat, lon)``."""
bounds = parse_bbox(raw)
if bounds is None:
return None
lat_min, lat_max, lon_min, lon_max = bounds
return ((lat_min + lat_max) / 2, (lon_min + lon_max) / 2)
def _first_number(mapping, *keys):
for key in keys:
if key in mapping:
number = to_float(mapping[key])
if number is not None:
return number
return None
+49 -1
View File
@@ -1,8 +1,56 @@
"""
Hilfsfunktionen für CMBNet
"""
from flask import current_app, g
import json
import os
import re
from flask import current_app, g
# Mandantencodes werden als Dateinamensbestandteil verwendet. Nur Zeichen
# zulassen, die keinen Pfadwechsel (../) oder Sonderpfade erzeugen können.
_TENANT_FILE_RE = re.compile(r'^[A-Za-z0-9_-]+$')
def str2pl_filename(tenant_code):
"""Relativer Dateiname der mandantenspezifischen Polyline-Datei."""
tenant_code = (tenant_code or '').strip()
if not _TENANT_FILE_RE.match(tenant_code):
raise ValueError('Ungültiger Mandantencode für den Polyline-Dateinamen')
return f'js/str2pl-{tenant_code}.js'
def str2pl_asset(tenant_code=None):
"""Dateiname des Polyline-Skripts für einen Mandanten.
Existiert ``static/js/str2pl-<tenant>.js``, wird diese mandantenspezifische
Datei verwendet. Andernfalls wird auf die gemeinsame ``str2pl.js``
zurückgegriffen.
"""
if tenant_code is None:
tenant_code = getattr(g, 'tenant_code', None)
tenant_code = (tenant_code or '').strip()
if tenant_code and _TENANT_FILE_RE.match(tenant_code):
candidate = str2pl_filename(tenant_code)
static_folder = current_app.static_folder
if static_folder and os.path.isfile(os.path.join(static_folder, candidate)):
return candidate
return 'js/str2pl.js'
def str2pl_asset_version(tenant_code=None):
"""Cache-Busting-Version der aktuell verwendeten Polyline-Datei."""
filename = str2pl_asset(tenant_code)
static_folder = current_app.static_folder
if not static_folder:
return 0
try:
stat = os.stat(os.path.join(static_folder, filename))
except OSError:
return 0
return f'{int(stat.st_mtime)}-{stat.st_size}'
def get_tenant_id():
+1
View File
@@ -60,6 +60,7 @@ CREATE TABLE IF NOT EXISTS streets (
hn_min INTEGER,
hn_max INTEGER,
bbox TEXT,
zusatz TEXT NOT NULL DEFAULT '',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (tenant_id) REFERENCES tenants(id),
File diff suppressed because it is too large. Load diff
+26 -2
View File
@@ -5,7 +5,7 @@
* damit er sowohl die mobilen Views als auch die statischen Assets
* kontrolliert. Der Cache-Name wird pro App-Wurzel gebildet.
*/
const VERSION = 'cmbnet-pwa-v14';
const VERSION = 'cmbnet-pwa-v16';
const BASE = new URL('./', self.location).href;
const SHELL_CACHE = `${VERSION}-shell`;
const TILE_CACHE = `${VERSION}-tiles`;
@@ -18,7 +18,8 @@ const PRECACHE_PATHS = [
'static/css/admin.css',
'static/css/mobile.css',
'static/js/leaflet.js',
'static/js/str2pl.js',
// str2pl.js bzw. str2pl-<tenant>.js wird nach der Registrierung gezielt
// vom Client angemeldet, weil die passende Datei vom Mandanten abhängt.
'static/js/reload_notice.js',
'static/js/views/mobile.js',
'static/img/logo.png',
@@ -79,8 +80,31 @@ self.addEventListener('message', event => {
if (event.data && event.data.type === 'SKIP_WAITING') {
self.skipWaiting();
}
if (event.data && event.data.type === 'CACHE_URLS' && Array.isArray(event.data.urls)) {
event.waitUntil(cacheUrls(event.data.urls));
}
});
async function cacheUrls(urls) {
const cache = await caches.open(SHELL_CACHE);
await Promise.allSettled(
urls.map(async url => {
try {
const cached = await cache.match(url);
if (cached) return;
const response = await fetch(new Request(url, {cache: 'reload'}));
if (response && (response.ok || response.type === 'opaque')) {
await cache.put(url, response);
}
} catch (error) {
// Einzelne fehlende Assets dürfen das Caching nicht verhindern.
}
})
);
}
/* ------------------------------------------------------------------ */
/* Fetch-Strategien */
/* ------------------------------------------------------------------ */
+310 -32
View File
@@ -3,6 +3,7 @@ const tenant = window.CMBNET_TENANT || '';
const apiBase = appUrl(`${tenant}/admin/api`);
let currentStreetId = null;
let editMode = false;
let splitStreetId = null;
function updateStrasse(streetId, data) {
fetch(`${apiBase}/strassen/${streetId}`, {
@@ -17,7 +18,7 @@ function updateStrasse(streetId, data) {
}
function deleteStrasse(streetId) {
if (!confirm('Straße wirklich löschen?')) return;
if (!confirm('Straße wirklich löschen?\n\nDabei werden auch die zugehörigen Einträge in der Hausnummern-Tabelle gelöscht, sofern keine weiteren Abschnitte derselben Straße mehr existieren.')) return;
fetch(`${apiBase}/strassen/${streetId}`, {
method: 'DELETE'
}).then(r => r.json()).then(data => {
@@ -25,11 +26,133 @@ function deleteStrasse(streetId) {
});
}
// === Mehrfachauswahl ===
function getStreetCheckboxes() {
return Array.from(document.querySelectorAll('#strassenTable .street-select'));
}
function getVisibleStreetCheckboxes() {
return getStreetCheckboxes().filter(checkbox => {
const row = checkbox.closest('tr');
return row && row.style.display !== 'none';
});
}
function getSelectedStreetCheckboxes() {
return getStreetCheckboxes().filter(checkbox => checkbox.checked);
}
function updateStreetSelectionState() {
const count = getSelectedStreetCheckboxes().length;
const visible = getVisibleStreetCheckboxes();
const allVisibleSelected = visible.length > 0
&& visible.every(checkbox => checkbox.checked);
const deleteButton = document.getElementById('deleteSelectedStreets');
if (deleteButton) {
deleteButton.disabled = count === 0;
deleteButton.textContent = `Ausgewählte löschen (${count})`;
}
const selectButton = document.getElementById('selectVisibleStreets');
if (selectButton) {
selectButton.textContent = allVisibleSelected
? 'Auswahl aufheben'
: 'Alle sichtbaren auswählen';
}
const info = document.getElementById('streetSelectionInfo');
if (info) {
info.textContent = count === 0
? ''
: `${count} Straße(n) ausgewählt`;
}
}
function selectVisibleStreets() {
const visible = getVisibleStreetCheckboxes();
if (!visible.length) return;
// Sind bereits alle sichtbaren Straßen ausgewählt, hebt der Button die
// Auswahl wieder auf. Andernfalls werden alle sichtbaren ausgewählt.
const allSelected = visible.every(checkbox => checkbox.checked);
visible.forEach(checkbox => {
checkbox.checked = !allSelected;
});
updateStreetSelectionState();
}
function invertStreetSelection() {
getVisibleStreetCheckboxes().forEach(checkbox => {
checkbox.checked = !checkbox.checked;
});
updateStreetSelectionState();
}
function selectedStreetNames(selected) {
const names = selected.map(checkbox => {
const row = checkbox.closest('tr');
if (!row || !row.cells[2]) return `#${checkbox.value}`;
const name = row.cells[2].innerText.trim();
const zusatz = row.cells[8] ? row.cells[8].innerText.trim() : '';
return zusatz ? `${name} ${zusatz}` : name;
});
const limit = 10;
if (names.length <= limit) return names.join('\n');
return `${names.slice(0, limit).join('\n')}\n… und ${names.length - limit} weitere`;
}
function deleteSelectedStreets() {
const selected = getSelectedStreetCheckboxes();
if (!selected.length) return;
const ids = selected
.map(checkbox => Number(checkbox.value))
.filter(streetId => Number.isInteger(streetId) && streetId > 0);
if (!ids.length) return;
const message = (
`Achtung: ${ids.length} Straße(n) werden endgültig gelöscht.\n\n` +
'Dabei werden auch die zugehörigen Einträge in der ' +
'Hausnummern-Tabelle gelöscht, sofern keine weiteren Abschnitte ' +
'derselben Straße mehr existieren.\n\n' +
`Ausgewählte Straßen:\n${selectedStreetNames(selected)}\n\n` +
'Fortfahren?'
);
if (!confirm(message)) return;
const deleteButton = document.getElementById('deleteSelectedStreets');
if (deleteButton) deleteButton.disabled = true;
fetch(`${apiBase}/strassen/bulk-delete`, {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({ids})
}).then(async response => {
const data = await response.json().catch(() => ({}));
if (!response.ok || !data.success) {
throw new Error(data.error || `HTTP ${response.status}`);
}
return data;
}).then(data => {
alert(
`${data.deleted} Straße(n) gelöscht, ` +
`${data.house_numbers_deleted || 0} Hausnummern-Einträge entfernt.`
);
location.reload();
}).catch(error => {
alert(error.message || 'Straßen konnten nicht gelöscht werden');
updateStreetSelectionState();
});
}
function openCreateStrasseModal() {
editMode = false;
document.getElementById('strasseModalTitle').innerText = 'Neue Straße';
document.getElementById('strasseId').value = '';
document.getElementById('strasseName').value = '';
document.getElementById('strasseZusatz').value = '';
document.getElementById('strasseHnMin').value = '';
document.getElementById('strasseHnMax').value = '';
document.getElementById('strasseBbox').value = '';
@@ -45,13 +168,14 @@ function editStrasse(streetId) {
const row = document.querySelector(`tr[data-id="${streetId}"]`);
document.getElementById('strasseModalTitle').innerText = 'Straße bearbeiten';
document.getElementById('strasseId').value = streetId;
document.getElementById('strasseName').value = row.cells[1].innerText;
document.getElementById('strasseHnMin').value = row.cells[4].innerText === '-' ? '' : row.cells[4].innerText;
document.getElementById('strasseHnMax').value = row.cells[5].innerText === '-' ? '' : row.cells[5].innerText;
document.getElementById('strasseName').value = row.cells[2].innerText.trim();
document.getElementById('strasseZusatz').value = row.cells[8].innerText.trim();
document.getElementById('strasseHnMin').value = row.cells[5].innerText === '-' ? '' : row.cells[5].innerText;
document.getElementById('strasseHnMax').value = row.cells[6].innerText === '-' ? '' : row.cells[6].innerText;
document.getElementById('strasseBbox').value = row.dataset.bbox || '';
document.getElementById('strasseState').value = row.cells[2].querySelector('select').value;
document.getElementById('strasseState').value = row.cells[3].querySelector('select').value;
document.getElementById('strasseState').disabled = false;
document.getElementById('strasseGroup').value = row.cells[3].querySelector('select').value;
document.getElementById('strasseGroup').value = row.cells[4].querySelector('select').value;
document.getElementById('strasseGroup').disabled = false;
document.getElementById('strasseModal').showModal();
}
@@ -64,6 +188,7 @@ function saveStrasse() {
const id = document.getElementById('strasseId').value;
const data = {
name: document.getElementById('strasseName').value,
zusatz: document.getElementById('strasseZusatz').value,
hn_min: document.getElementById('strasseHnMin').value || null,
hn_max: document.getElementById('strasseHnMax').value || null,
bbox: document.getElementById('strasseBbox').value || null,
@@ -100,38 +225,167 @@ function saveStrasse() {
function importCSV(input) {
const file = input.files[0];
if (!file) return;
if (!confirm(
'Der Import ersetzt alle Straßen- und Hausnummerndaten dieses ' +
'Mandanten, einschließlich früherer Teilungen, Status- und ' +
'Gruppenzuordnungen.\n\nFortfahren?'
)) {
input.value = '';
return;
}
const formData = new FormData();
formData.append('file', file);
fetch(`${apiBase}/strassen/import`, {
method: 'POST',
body: formData
}).then(r => r.json()).then(data => {
if (data.success) {
alert(`${data.count} Straßen importiert`);
location.reload();
} else {
alert(data.error);
}).then(async response => {
const data = await response.json().catch(() => ({}));
if (!response.ok || !data.success) {
throw new Error(data.error || `HTTP ${response.status}`);
}
return data;
}).then(data => {
alert(
`${data.streets ?? data.count ?? 0} Straßen und ` +
`${data.house_numbers ?? 0} Hausnummern importiert.`
);
location.reload();
}).catch(error => {
alert(error.message || 'Import fehlgeschlagen');
}).finally(() => {
input.value = '';
});
}
function importHouseNumbers(input) {
const file = input.files[0];
if (!file) return;
const formData = new FormData();
formData.append('file', file);
fetch(`${apiBase}/hausnummern/import`, {
method: 'POST',
body: formData
}).then(r => r.json()).then(data => {
if (data.success) {
alert(`${data.count} Hausnummern importiert`);
location.reload();
} else {
alert(data.error);
function generateStr2plFile() {
const confirmed = confirm(
'Die mandantenspezifische Polyline-Datei wird aus allen Straßen der ' +
'Datenbank neu erzeugt.\n\n' +
'Eine bereits vorhandene Datei wird überschrieben. Die aktuelle ' +
'Auswahl in der Tabelle spielt keine Rolle.\n\n' +
'Fortfahren?'
);
if (!confirmed) return;
const button = document.getElementById('generateStr2pl');
if (button) button.disabled = true;
fetch(`${apiBase}/strassen/str2pl`, {method: 'POST'})
.then(async response => {
const data = await response.json().catch(() => ({}));
if (!response.ok || !data.success) {
throw new Error(data.error || `HTTP ${response.status}`);
}
}).finally(() => {
input.value = '';
return data;
})
.then(data => {
alert(
'Polyline-Datei erzeugt.\n\n' +
`Straßen in der Datenbank: ${data.streets_total}\n` +
`Mit Geometrie übernommen: ${data.streets_with_geometry}\n` +
`Ohne Geometrie: ${data.streets_without_geometry}\n` +
`Segmente geschrieben: ${data.segments_written}\n` +
`Segmente außerhalb der Bounding Box verworfen: ${data.segments_outside_bbox}\n` +
`Segmente zusammengeführt: ${data.segments_merged}`
);
})
.catch(error => {
alert(error.message || 'Polyline-Datei konnte nicht erzeugt werden');
})
.finally(() => {
if (button) button.disabled = false;
});
}
function openSplitStrasse(streetId) {
splitStreetId = streetId;
const dialog = document.getElementById('splitStrasseModal');
const info = document.getElementById('splitStrasseInfo');
const select = document.getElementById('splitHouseNumber');
const error = document.getElementById('splitStrasseError');
info.textContent = 'Lade Hausnummern …';
select.innerHTML = '';
error.textContent = '';
fetch(`${apiBase}/strassen/${streetId}/split-options`)
.then(async response => {
const data = await response.json().catch(() => ({}));
if (!response.ok) {
throw new Error(data.error || `HTTP ${response.status}`);
}
return data;
})
.then(data => {
if (!Array.isArray(data.house_numbers) || !data.house_numbers.length) {
throw new Error('Für diese Straße sind keine teilbaren Hausnummern hinterlegt.');
}
const displayName = `${data.name} ${data.zusatz || ''}`.trim();
info.textContent = (
`Straße „${displayName}“, gültiger Hausnummernbereich ` +
`${data.hn_min}–${data.hn_max}. Beide Abschnitte enthalten ` +
'die gewählte Trennnummer.'
);
data.house_numbers.forEach(number => {
const option = document.createElement('option');
option.value = String(number);
option.textContent = String(number);
select.appendChild(option);
});
if (typeof dialog.showModal === 'function') dialog.showModal();
else dialog.show();
})
.catch(err => {
splitStreetId = null;
alert(err.message || 'Teilungsoptionen konnten nicht geladen werden');
});
}
function closeSplitStrasseModal() {
splitStreetId = null;
const dialog = document.getElementById('splitStrasseModal');
if (dialog && dialog.open) dialog.close();
}
function confirmSplitStrasse() {
if (!splitStreetId) return;
const select = document.getElementById('splitHouseNumber');
const error = document.getElementById('splitStrasseError');
const houseNumber = select ? select.value : '';
if (!houseNumber) {
if (error) error.textContent = 'Bitte eine Hausnummer auswählen.';
return;
}
if (!confirm(`Straße an Hausnummer ${houseNumber} in zwei Abschnitte teilen?`)) {
return;
}
fetch(`${apiBase}/strassen/${splitStreetId}/split`, {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({house_number: Number(houseNumber)})
}).then(async response => {
const data = await response.json().catch(() => ({}));
if (!response.ok || !data.success) {
throw new Error(data.error || `HTTP ${response.status}`);
}
return data;
}).then(data => {
alert(
'Straße geteilt.\n\n' +
`Unten: HN ${data.lower.hn_min}–${data.lower.hn_max}, ` +
`Zusatz „${data.lower.zusatz}“\n` +
`Oben: HN ${data.upper.hn_min}–${data.upper.hn_max}, ` +
`Zusatz „${data.upper.zusatz}“`
);
location.reload();
}).catch(err => {
if (error) error.textContent = err.message || 'Straße konnte nicht geteilt werden';
});
}
@@ -193,10 +447,10 @@ function applyStreetFilters() {
document.querySelectorAll('#strassenTable tbody tr').forEach(row => {
if (!row.dataset.id) return;
const nameCell = row.cells[1];
const nameCell = row.cells[2];
const nameText = normalizeForFilter(nameCell ? nameCell.innerText : '');
const stateSelect = row.cells[2] ? row.cells[2].querySelector('select') : null;
const groupSelect = row.cells[3] ? row.cells[3].querySelector('select') : null;
const stateSelect = row.cells[3] ? row.cells[3].querySelector('select') : null;
const groupSelect = row.cells[4] ? row.cells[4].querySelector('select') : null;
const stateVal = stateSelect ? stateSelect.value : '';
const groupVal = groupSelect ? groupSelect.value : '';
@@ -212,9 +466,33 @@ function applyStreetFilters() {
}
row.style.display = visible ? '' : 'none';
});
updateStreetSelectionState();
}
document.addEventListener('DOMContentLoaded', applyStreetFilters);
document.addEventListener('DOMContentLoaded', () => {
applyStreetFilters();
getStreetCheckboxes().forEach(checkbox => {
checkbox.addEventListener('change', updateStreetSelectionState);
});
const selectButton = document.getElementById('selectVisibleStreets');
if (selectButton) {
selectButton.addEventListener('click', selectVisibleStreets);
}
const invertButton = document.getElementById('invertStreetSelection');
if (invertButton) {
invertButton.addEventListener('click', invertStreetSelection);
}
const deleteButton = document.getElementById('deleteSelectedStreets');
if (deleteButton) {
deleteButton.addEventListener('click', deleteSelectedStreets);
}
updateStreetSelectionState();
});
function closeStreetHistoryModal() {
document.getElementById('streetHistoryModal').close();
+90 -17
View File
@@ -404,6 +404,12 @@ function tooltipElement(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
@@ -416,7 +422,7 @@ function buildPolylines() {
: map.getCenter());
dispatcherState.streets.forEach(street => {
const segments = findStreetSegments(fragments, street.name);
const segments = findStreetSegments(fragments, street);
if (!Array.isArray(segments)) return;
const streetBounds = bboxToBounds(street.bbox) || regionBounds;
@@ -430,7 +436,7 @@ function buildPolylines() {
if (latlngs.length < 2) return;
const line = L.polyline(latlngs, polylineStyle(street.state));
line.bindTooltip(tooltipElement(`${street.name} (${street.state})`), {sticky: true});
line.bindTooltip(tooltipElement(`${streetDisplayName(street)} (${street.state})`), {sticky: true});
line.on('click', () => {
if (dispatcherState.crosshairGroupId) return;
openStreetModal(street.id);
@@ -445,13 +451,25 @@ function buildPolylines() {
});
}
function findStreetSegments(fragments, name) {
if (!name) return null;
if (fragments[name]) return fragments[name];
function findStreetSegments(fragments, street) {
if (!street || !street.name) return null;
const lower = String(name).toLowerCase();
const matchingKey = Object.keys(fragments).find(key => key.toLowerCase() === lower);
return matchingKey ? fragments[matchingKey] : 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) {
@@ -552,7 +570,7 @@ function recolorStreet(street) {
opacity: dispatcherState.settings.opacity,
weight: currentPolylineWeight()
});
line.setTooltipContent(tooltipElement(`${street.name} (${street.state})`));
line.setTooltipContent(tooltipElement(`${streetDisplayName(street)} (${street.state})`));
});
}
@@ -1642,11 +1660,11 @@ function appendGroupStreetSection(container, title, streets, showEmpty) {
const button = document.createElement('button');
button.type = 'button';
button.className = 'group-street-entry';
button.title = `Auf die Bounding Box von ${street.name} zoomen`;
button.title = `Auf die Bounding Box von ${streetDisplayName(street)} zoomen`;
const name = document.createElement('span');
name.className = 'group-street-name';
name.textContent = street.name;
name.textContent = streetDisplayName(street);
const state = document.createElement('span');
state.className = 'group-street-state';
@@ -1681,6 +1699,35 @@ function zoomToStreet(streetId) {
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 */
/* ------------------------------------------------------------------ */
@@ -1702,8 +1749,21 @@ function findStreetBySearchName(value) {
const normalized = normalizeStreetSearchText(value);
if (!normalized) return null;
return dispatcherState.streets.find(street => (
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;
}
@@ -1753,10 +1813,23 @@ function getStreetSearchResults(streetText) {
const normalized = normalizeStreetSearchText(streetText);
if (normalized.length < STREET_SEARCH_MIN_CHARS) return [];
return dispatcherState.streets
const matches = dispatcherState.streets
.filter(street => normalizeStreetSearchText(street.name).startsWith(normalized))
.sort((a, b) => String(a.name).localeCompare(String(b.name), 'de'))
.slice(0, STREET_SEARCH_MAX_RESULTS);
.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) {
@@ -1951,7 +2024,7 @@ async function performStreetSearch(value, selectedStreet = null) {
closeStreetSearchResults();
setStreetSearchStatus('');
input.value = houseNumber ? `${street.name} ${houseNumber}` : street.name;
zoomToStreet(street.id);
zoomToStreetSearchResult(street);
if (!houseNumber) return;
@@ -2045,7 +2118,7 @@ function openStreetModal(streetId) {
if (!street) return;
dispatcherState.currentStreetId = Number(streetId);
document.getElementById('streetModalTitle').textContent = `Straße: ${street.name}`;
document.getElementById('streetModalTitle').textContent = `Straße: ${streetDisplayName(street)}`;
document.getElementById('streetStateSelect').value = street.state || 'unbearbeitet';
fillStreetGroupOptions(street.group_id);
updateStreetGroupVisibility();
+62 -10
View File
@@ -164,12 +164,34 @@ function registerServiceWorker() {
const swUrl = window.CMBNET_SW_URL || '/sw.js';
window.addEventListener('load', () => {
navigator.serviceWorker.register(swUrl).catch(error => {
navigator.serviceWorker.register(swUrl)
.then(cachePolylineScript)
.catch(error => {
console.warn('Service Worker konnte nicht registriert werden.', error);
});
});
}
function cachePolylineScript() {
// Das Polyline-Skript ist mandantenabhängig (str2pl-<tenant>.js oder
// str2pl.js) und kann deshalb nicht statisch im Service Worker
// vorabgespeichert werden. Der Client meldet die tatsächlich geladene
// Datei nach der Registrierung zum Caching an.
const script = document.querySelector('script[src*="str2pl"]');
if (!script || !script.src) return;
navigator.serviceWorker.ready
.then(registration => {
const worker = registration.active
|| registration.waiting
|| registration.installing;
if (worker) {
worker.postMessage({type: 'CACHE_URLS', urls: [script.src]});
}
})
.catch(() => {});
}
function initPwaInstall() {
const button = document.getElementById('mobileInstallBtn');
if (!button) return;
@@ -740,7 +762,7 @@ async function loadGroupData(groupId) {
if (state.streets.length) {
const first = state.streets[0];
state.currentStreetId = first.id;
loadStreetPolyline(first.name);
loadStreetPolyline(first);
fitToPositionAndPolyline();
updateWorkButton();
} else {
@@ -774,7 +796,7 @@ function buildStreetList() {
btn.type = 'button';
btn.className = 'mobile-street-item';
if (state.currentStreetId == street.id) btn.classList.add('active');
btn.textContent = `${street.name} (${street.state || 'unbearbeitet'})`;
btn.textContent = `${mobileStreetDisplayName(street)} (${street.state || 'unbearbeitet'})`;
btn.addEventListener('click', () => {
selectStreet(street);
closeMobileStreetSelect();
@@ -790,24 +812,54 @@ function selectStreet(street) {
map.removeLayer(state.currentPolyline);
state.currentPolyline = null;
}
loadStreetPolyline(street.name);
loadStreetPolyline(street);
fitToPositionAndPolyline();
updateWorkButton();
buildStreetList();
}
function mobileStreetDisplayName(street) {
if (!street) return '';
const zusatz = String(street.zusatz || '').trim();
return zusatz ? `${street.name} ${zusatz}` : String(street.name || '');
}
function getStreetFragments() {
if (typeof STRASSE2POLYLINES !== 'undefined') return STRASSE2POLYLINES;
if (typeof Strasse2Polylines !== 'undefined') return Strasse2Polylines;
return window.STRASSE2POLYLINES || window.Strasse2Polylines || {};
}
function loadStreetPolyline(name) {
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 loadStreetPolyline(street) {
const currentStreet = street
|| state.streetById.get(Number(state.currentStreetId));
if (!currentStreet) return;
const fragments = getStreetFragments();
const segments = fragments[name];
const segments = findStreetSegments(fragments, currentStreet);
if (!Array.isArray(segments)) return;
const street = state.streetById.get(Number(state.currentStreetId));
const color = STREET_COLORS[street?.state] || STREET_COLORS.unbearbeitet;
const color = STREET_COLORS[currentStreet.state] || STREET_COLORS.unbearbeitet;
const style = {
color,
opacity: state.settings.opacity,
@@ -894,7 +946,7 @@ function openStreetStateDialog() {
alert('Bitte erst eine Straße auswählen.');
return;
}
document.getElementById('mobileStreetStateTitle').textContent = `Straße: ${street.name}`;
document.getElementById('mobileStreetStateTitle').textContent = `Straße: ${mobileStreetDisplayName(street)}`;
document.getElementById('mobileStreetStateSelect').value = street.state || 'unbearbeitet';
fillMobileStreetGroupSelect(street.group_id);
updateMobileStreetGroupVisibility();
@@ -1502,7 +1554,7 @@ function applyMobileStreetUpdate(payload) {
const dialog = document.getElementById('mobileStreetStateDialog');
if (dialog && dialog.open) {
document.getElementById('mobileStreetStateTitle').textContent =
`Straße: ${street.name}`;
`Straße: ${mobileStreetDisplayName(street)}`;
document.getElementById('mobileStreetStateSelect').value =
street.state || 'unbearbeitet';
fillMobileStreetGroupSelect(street.group_id);
+44 -6
View File
@@ -6,6 +6,13 @@
<p><a href="{{ url_for('admin.dashboard', tenant=session.tenant_code) }}">← Zurück zum Dashboard</a></p>
<h1>Straßenverwaltung</h1>
<div style="display: flex; flex-wrap: wrap; gap: 0.75rem; align-items: center; margin-bottom: 0.75rem;">
<button type="button" id="selectVisibleStreets">Alle sichtbaren auswählen</button>
<button type="button" id="invertStreetSelection" class="secondary">Auswahl invertieren</button>
<button type="button" id="deleteSelectedStreets" class="secondary" disabled>Ausgewählte löschen (0)</button>
<span id="streetSelectionInfo" style="color: var(--muted-color);"></span>
</div>
<div style="display: flex; flex-wrap: wrap; gap: 0.75rem; align-items: end; margin-bottom: 0.75rem;">
<label style="margin: 0;">Name filtern
<input type="text" id="streetNameFilter" placeholder="z. B. Haupt" oninput="applyStreetFilters()">
@@ -31,6 +38,7 @@
<table id="strassenTable">
<thead>
<tr>
<th style="width: 4.5rem;">Auswahl</th>
<th>ID</th>
<th>Name</th>
<th>State</th>
@@ -38,12 +46,17 @@
<th>HN Min</th>
<th>HN Max</th>
<th>BBox</th>
<th>Zusatz</th>
<th>Aktionen</th>
</tr>
</thead>
<tbody>
{% for strasse in strassen %}
<tr data-id="{{ strasse.id }}" data-bbox="{{ strasse.bbox or '' }}">
<td>
<input type="checkbox" class="street-select" value="{{ strasse.id }}"
aria-label="Straße {{ strasse.name }} auswählen">
</td>
<td>{{ strasse.id }}</td>
<td>{{ strasse.name }}</td>
<td>
@@ -64,8 +77,11 @@
<td>{{ strasse.hn_min or '-' }}</td>
<td>{{ strasse.hn_max or '-' }}</td>
<td style="word-break: break-all;">{{ strasse.bbox or '-' }}</td>
<td class="street-zusatz">{{ strasse.zusatz or '' }}</td>
<td>
<button onclick="editStrasse({{ strasse.id }})">✎</button>
<button onclick="openSplitStrasse({{ strasse.id }})"
title="Straße an einer Hausnummer in zwei Abschnitte teilen">Schneiden</button>
<button onclick="showStreetHistory({{ strasse.id }})">Historie</button>
<button class="secondary" onclick="deleteStrasse({{ strasse.id }})">🗑</button>
</td>
@@ -75,13 +91,13 @@
</table>
<button onclick="openCreateStrasseModal()">Neue Straße</button>
<button onclick="document.getElementById('csvFile').click()">Import CSV</button>
<input type="file" id="csvFile" accept=".csv" style="display:none" onchange="importCSV(this)">
<button onclick="document.getElementById('houseNumberCsvFile').click()">
Hausnummern importieren ({{ house_number_count }})
<button onclick="document.getElementById('csvFile').click()">
Import Straßen + Hausnummern ({{ house_number_count }})
</button>
<input type="file" id="houseNumberCsvFile" accept=".csv" style="display:none"
onchange="importHouseNumbers(this)">
<input type="file" id="csvFile" accept=".csv,text/csv" style="display:none" onchange="importCSV(this)">
<button type="button" id="generateStr2pl" class="secondary"
title="Erzeugt die mandantenspezifische Polyline-Datei aus allen Straßen der Datenbank"
onclick="generateStr2plFile()">Polyline-Datei erzeugen</button>
<p style="margin-top: 2rem;"><a href="{{ url_for('admin.dashboard', tenant=session.tenant_code) }}">← Zurück zum Dashboard</a></p>
<!-- Create/Edit Strasse Modal -->
@@ -95,6 +111,9 @@
<label>Name
<input type="text" id="strasseName">
</label>
<label>Zusatz
<input type="text" id="strasseZusatz" placeholder="z. B. Nord">
</label>
<label>Hausnummer minimal
<input type="number" id="strasseHnMin">
</label>
@@ -151,6 +170,25 @@
</footer>
</article>
</dialog>
<!-- Split Modal -->
<dialog id="splitStrasseModal">
<article>
<header>
<a href="#close" aria-label="Close" class="close" onclick="closeSplitStrasseModal()"></a>
<h3>Straße schneiden</h3>
</header>
<p id="splitStrasseInfo"></p>
<label>Hausnummer
<select id="splitHouseNumber"></select>
</label>
<p id="splitStrasseError" style="color: var(--error-color, #b00020);"></p>
<footer>
<button onclick="closeSplitStrasseModal()">Abbrechen</button>
<button onclick="confirmSplitStrasse()">Schneiden</button>
</footer>
</article>
</dialog>
{% endblock %}
{% block scripts %}
+1 -1
View File
@@ -114,6 +114,6 @@
window.CMBNET_VIEW_MODE = 'observer';
</script>
<script src="{{ url_for('static', filename='js/leaflet.js') }}"></script>
<script src="{{ url_for('static', filename='js/str2pl.js') }}"></script>
<script src="{{ url_for('static', filename=str2pl_asset()) }}?v={{ str2pl_asset_version() }}"></script>
<script src="{{ url_for('static', filename='js/views/dispatcher.js') }}"></script>
{% endblock %}
+1 -1
View File
@@ -299,6 +299,6 @@
window.CMBNET_LOGOUT_URL = {{ url_for('auth.logout', tenant=session.tenant_code)|tojson }};
</script>
<script src="{{ url_for('static', filename='js/qrious.min.js') }}"></script>
<script src="{{ url_for('static', filename='js/str2pl.js') }}"></script>
<script src="{{ url_for('static', filename=str2pl_asset()) }}?v={{ str2pl_asset_version() }}"></script>
<script src="{{ url_for('static', filename='js/views/dispatcher.js') }}"></script>
{% endblock %}
+1 -1
View File
@@ -151,6 +151,6 @@
window.CMBNET_VIEW_MODE = 'mobile_dispatcher';
</script>
<script src="{{ url_for('static', filename='js/leaflet.js') }}"></script>
<script src="{{ url_for('static', filename='js/str2pl.js') }}"></script>
<script src="{{ url_for('static', filename=str2pl_asset()) }}?v={{ str2pl_asset_version() }}"></script>
<script src="{{ url_for('static', filename='js/views/mobile.js') }}"></script>
{% endblock %}
+1 -1
View File
@@ -156,6 +156,6 @@
window.CMBNET_VIEW_MODE = 'mobile_group';
</script>
<script src="{{ url_for('static', filename='js/leaflet.js') }}"></script>
<script src="{{ url_for('static', filename='js/str2pl.js') }}"></script>
<script src="{{ url_for('static', filename=str2pl_asset()) }}?v={{ str2pl_asset_version() }}"></script>
<script src="{{ url_for('static', filename='js/views/mobile.js') }}"></script>
{% endblock %}