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
+17391 -158

No files matched your search

+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
+318 -5
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'],
@@ -24,7 +81,263 @@ class StreetsService:
'bbox': json.loads(street['bbox']) if street['bbox'] else None
})
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"""
@@ -32,9 +345,9 @@ class StreetsService:
old_street = StreetModel.get_by_id(street_id, tenant_id)
if not old_street:
return False
StreetModel.update(street_id, tenant_id, **changes)
# History bei State-Wechsel
if 'state' in changes and changes['state'] != old_street['state']:
db.execute(
@@ -49,5 +362,5 @@ class StreetsService:
{'from': old_street['state'], 'to': changes['state']})
else:
log_transaction('street.update', 'street', street_id, changes)
return True