Strassenverwaltung plus: Teilen von Strassenzügen
This commit is contained in:
1 parent
d54a986c14
commit
3eb3b746ab
22 files changed
+17391
-158
No files matched your search
@@ -96,6 +96,12 @@ def create_app(config_name=None):
|
||||
app.jinja_env.globals['APP_TITLE'] = app.config.get(
|
||||
'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)
|
||||
|
||||
+148
-73
@@ -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)})
|
||||
@@ -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(
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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))
|
||||
db.commit()
|
||||
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,3 +1,4 @@
|
||||
from .groups_service import GroupsService
|
||||
from .streets_service import StreetsService
|
||||
from .accounts_service import AccountsService
|
||||
from .str2pl_service import Str2PlService
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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():
|
||||
|
||||
Reference in new issue
Block a user