Navigációs képernyőn útvonal megjelenítése supabase táblából és navigációs képernyővel történő indítás beállítások alapján

2026-10-04 22:24:31 +02:00
parent e3ff7d070c
commit f1bb0191d5
9 changed files with 1221 additions and 1 deletions
@@ -0,0 +1,253 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:get/get.dart';
+import 'package:supabase_flutter/supabase_flutter.dart';
+import 'package:terepi_seged/models/vibro_nav_route.dart';
+import 'package:terepi_seged/services/app_logger.dart';
+
+/// Egy GeoJSON-ból kiolvasott, még NEM mentett útvonal.
+class RouteDraft {
+  final String name;
+  final Map<String, dynamic> geometry;
+  final String crs; // 'wgs84' | 'eov' (az import eldönti)
+  const RouteDraft(
+      {required this.name, required this.geometry, required this.crs});
+}
+
+class RouteParseResult {
+  final List<RouteDraft> drafts;
+  final int skipped; // nem vonal geometriájú elemek (pont, terület…)
+  const RouteParseResult(this.drafts, this.skipped);
+}
+
+/// Navigációs útvonalak (kerülők) — élő lekérdezés + szerkesztés.
+///
+/// Az olvasás ugyanazt a bevált mintát követi, mint a forráspontoknál:
+/// szerveroldalon szűrt lekérdezés + Realtime csatorna, ami CSAK jelzés
+/// (debounce-olt újratöltés). A `.stream()`-et SZÁNDÉKOSAN kerüljük.
+class VibroNavRouteService extends GetxService {
+  static VibroNavRouteService get to => Get.find();
+
+  static const _table = 'terepi_seged_vibro_nav_routes';
+
+  SupabaseClient get _client => Supabase.instance.client;
+
+  /// A térképnek: csak az aktív, MAI napra érvényes vagy dátum nélküli
+  /// útvonalak. (A járműre szűrést a controller végzi, az a kis lista
+  /// miatt kliensoldalon is olcsó, és a járműváltásra azonnal reagál.)
+  Stream<List<VibroNavRoute>> watchForToday(String projectId) =>
+      _watch(projectId, todayOnly: true);
+
+  /// Az admin oldalnak: MINDEN útvonal, dátumtól és állapottól függetlenül.
+  Stream<List<VibroNavRoute>> watchAll(String projectId) =>
+      _watch(projectId, todayOnly: false);
+
+  Stream<List<VibroNavRoute>> _watch(String projectId,
+      {required bool todayOnly}) {
+    late StreamController<List<VibroNavRoute>> controller;
+    RealtimeChannel? channel;
+    Timer? debounce;
+    var disposed = false;
+    var fetching = false;
+    var again = false;
+
+    Future<void> refetch() async {
+      if (disposed) return;
+      if (fetching) {
+        again = true;
+        return;
+      }
+      fetching = true;
+      try {
+        do {
+          again = false;
+          final list = await _fetch(projectId, todayOnly);
+          if (!disposed) controller.add(list);
+        } while (again && !disposed);
+      } catch (e, s) {
+        if (!disposed) controller.addError(e, s);
+      } finally {
+        fetching = false;
+      }
+    }
+
+    controller = StreamController<List<VibroNavRoute>>(
+      onListen: () {
+        refetch();
+        channel = _client
+            .channel('vibro_routes_${projectId}_${todayOnly ? 'day' : 'all'}')
+            .onPostgresChanges(
+              event: PostgresChangeEvent.all,
+              schema: 'public',
+              table: _table,
+              filter: PostgresChangeFilter(
+                type: PostgresChangeFilterType.eq,
+                column: 'project_id',
+                value: projectId,
+              ),
+              callback: (_) {
+                debounce?.cancel();
+                debounce = Timer(const Duration(milliseconds: 500), refetch);
+              },
+            )
+            .subscribe();
+      },
+      onCancel: () async {
+        disposed = true;
+        debounce?.cancel();
+        if (channel != null) await _client.removeChannel(channel!);
+      },
+    );
+    return controller.stream;
+  }
+
+  String _todayStr() {
+    final n = DateTime.now();
+    return '${n.year}-${n.month.toString().padLeft(2, '0')}-'
+        '${n.day.toString().padLeft(2, '0')}';
+  }
+
+  Future<List<VibroNavRoute>> _fetch(String projectId, bool todayOnly) async {
+    final base = _client.from(_table).select().eq('project_id', projectId);
+    final filtered = todayOnly
+        ? base
+            .eq('is_active', true)
+            .or('valid_date.eq.${_todayStr()},valid_date.is.null')
+        : base;
+
+    final rows = await filtered
+        .order('valid_date', ascending: false, nullsFirst: true)
+        .order('name')
+        .limit(500);
+
+    final out = <VibroNavRoute>[];
+    for (final r in rows) {
+      try {
+        out.add(VibroNavRoute.fromMap(r));
+      } catch (e) {
+        // Egyetlen hibás sor ne akassza meg az egész listát.
+        AppLogger.e('VibroNavRouteService', 'Hibás útvonal-sor kihagyva: $e');
+      }
+    }
+    return out;
+  }
+
+  // ═════════════════════════════════════════════════════════════════
+  // Írás
+  // ═════════════════════════════════════════════════════════════════
+
+  Future<void> insertRoutes(List<Map<String, dynamic>> rows) async {
+    if (rows.isEmpty) return;
+    await _client.from(_table).insert(rows);
+  }
+
+  Future<void> updateRoute(String id, Map<String, dynamic> patch) async {
+    await _client.from(_table).update(patch).eq('id', id);
+  }
+
+  Future<void> deleteRoute(String id) async {
+    await _client.from(_table).delete().eq('id', id);
+  }
+
+  // ═════════════════════════════════════════════════════════════════
+  // GeoJSON-import
+  // ═════════════════════════════════════════════════════════════════
+
+  static const _nameKeys = [
+    'name',
+    'nev',
+    'név',
+    'megnevezes',
+    'megnevezés',
+    'title',
+  ];
+
+  /// FeatureCollection / Feature / puszta geometria → vonal-útvonalak.
+  /// Csak LineString és MultiLineString kerül be; a többit megszámolja.
+  /// A koordinátarendszert (WGS84 / EOV) fájlonként a nagyságrend dönti el.
+  static RouteParseResult parseGeoJson(String content, String fallbackName) {
+    final dynamic json;
+    try {
+      json = jsonDecode(content);
+    } catch (e) {
+      throw FormatException('Érvénytelen GeoJSON (nem elemezhető JSON): $e');
+    }
+
+    // Minden elemet (geometria + tulajdonságok) egységes listába szedünk.
+    final items =
+        <({Map<String, dynamic> geometry, Map<String, dynamic> props})>[];
+
+    void addGeometry(dynamic g, dynamic props) {
+      if (g is Map) {
+        items.add((
+          geometry: Map<String, dynamic>.from(g),
+          props: props is Map ? Map<String, dynamic>.from(props) : const {},
+        ));
+      }
+    }
+
+    if (json is Map && json['type'] == 'FeatureCollection') {
+      final features = json['features'];
+      if (features is List) {
+        for (final f in features) {
+          if (f is Map) addGeometry(f['geometry'], f['properties']);
+        }
+      }
+    } else if (json is Map && json['type'] == 'Feature') {
+      addGeometry(json['geometry'], json['properties']);
+    } else if (json is Map && json['type'] != null) {
+      addGeometry(json, null);
+    }
+
+    if (items.isEmpty) {
+      throw const FormatException('Nem található geometria a GeoJSON-ban.');
+    }
+
+    final drafts = <RouteDraft>[];
+    var skipped = 0;
+    var counter = 0;
+
+    for (final it in items) {
+      final type = it.geometry['type'];
+      if (type != 'LineString' && type != 'MultiLineString') {
+        skipped++;
+        continue;
+      }
+      // A geometria legyen értelmezhető (legalább egy 2 pontos vonal).
+      final crs = VibroNavRoute.detectCrs(it.geometry);
+      final lines = VibroNavRoute.toWgsLines(it.geometry, crs);
+      if (lines.isEmpty) {
+        skipped++;
+        continue;
+      }
+      counter++;
+      drafts.add(RouteDraft(
+        name: _nameFrom(it.props) ?? '$fallbackName $counter',
+        geometry: {
+          'type': type,
+          'coordinates': it.geometry['coordinates'],
+        },
+        crs: crs,
+      ));
+    }
+
+    if (drafts.isEmpty) {
+      throw const FormatException(
+          'A fájl nem tartalmaz érvényes vonal (LineString / MultiLineString) '
+          'geometriát.');
+    }
+    return RouteParseResult(drafts, skipped);
+  }
+
+  static String? _nameFrom(Map<String, dynamic> props) {
+    final lower = {for (final e in props.entries) e.key.toLowerCase(): e.value};
+    for (final k in _nameKeys) {
+      final v = lower[k];
+      if (v != null && v.toString().trim().isNotEmpty) {
+        return v.toString().trim();
+      }
+    }
+    return null;
+  }
+}