432 lines
15 KiB
Dart
432 lines
15 KiB
Dart
import 'package:get/get.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
import 'package:supabase_flutter/supabase_flutter.dart';
|
|
import 'package:terepi_seged/services/app_logger.dart';
|
|
import 'package:terepi_seged/services/device_identity_service.dart';
|
|
import 'package:uuid/uuid.dart';
|
|
import '../models/project.dart';
|
|
import 'app_database.dart';
|
|
import 'ts_sync_service.dart';
|
|
|
|
class ProjectRequiresLoginException implements Exception {
|
|
final String message;
|
|
ProjectRequiresLoginException(
|
|
[this.message = 'Felhős projekt használatához be kell jelentkezni.']);
|
|
|
|
@override
|
|
String toString() => message;
|
|
}
|
|
|
|
class ProjectArchiveBlockedException implements Exception {
|
|
final String message;
|
|
ProjectArchiveBlockedException(this.message);
|
|
@override
|
|
String toString() => message;
|
|
}
|
|
|
|
class ProjectNoLongerExistsException implements Exception {
|
|
final String message;
|
|
ProjectNoLongerExistsException([
|
|
this.message = 'Ez a projekt már nem érhető el — törölték, vagy '
|
|
'kikerültél a tagságából.',
|
|
]);
|
|
@override
|
|
String toString() => message;
|
|
}
|
|
|
|
class ProjectService extends GetxService {
|
|
static ProjectService get to => Get.find();
|
|
|
|
final activeProject = Rxn<Project>();
|
|
final projects = <Project>[].obs;
|
|
|
|
int? get activeProjectId => activeProject.value?.id;
|
|
|
|
@override
|
|
Future<void> onInit() async {
|
|
super.onInit();
|
|
await _loadProjects();
|
|
await _restoreActiveProject();
|
|
|
|
Supabase.instance.client.auth.onAuthStateChange.listen((data) {
|
|
final loggedOut = data.session == null;
|
|
final active = activeProject.value;
|
|
|
|
if (loggedOut && active != null && !active.isLocalOnly) {
|
|
final fallback = projects.firstWhereOrNull((p) => p.isLocalOnly);
|
|
if (fallback != null) {
|
|
setActiveProject(fallback);
|
|
} else {
|
|
activeProject.value = null;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
Future<void> _loadProjects() async {
|
|
projects.value = await AppDatabase.instance.listProjects();
|
|
}
|
|
|
|
// Az utoljára aktív projektet tárolja a SharedPreferences
|
|
Future<void> _restoreActiveProject() async {
|
|
final prefs = await SharedPreferences.getInstance();
|
|
final savedId = prefs.getInt('active_project_id');
|
|
|
|
if (savedId != null) {
|
|
final project = await AppDatabase.instance.getProject(savedId);
|
|
if (project != null && project.status == ProjectStatus.active) {
|
|
activeProject.value = project;
|
|
return;
|
|
}
|
|
}
|
|
// Fallback: elsőként lokális projektet próbálunk (mindig biztonságos),
|
|
// csak ha nincs, esünk vissza bármelyikre — és a hibát itt is elkapjuk,
|
|
// hogy egy bejelentkezés-igénylő projekt ne akassza meg az indulást.
|
|
final fallback = projects.firstWhereOrNull((p) => p.isLocalOnly) ??
|
|
(projects.isNotEmpty ? projects.first : null);
|
|
if (fallback != null) {
|
|
try {
|
|
await setActiveProject(fallback);
|
|
} catch (_) {
|
|
// Nincs aktiválható projekt most (pl. csak felhős van, bejelentkezés
|
|
// nélkül) — activeProject marad null, a UI ezt már kezeli.
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> setActiveProject(Project project) async {
|
|
if (!project.isLocalOnly &&
|
|
Supabase.instance.client.auth.currentUser == null) {
|
|
AppLogger.event('project_activate_blocked_no_login', '', {
|
|
'device_id': DeviceIdentityService.to.deviceId,
|
|
'device_name': DeviceIdentityService.to.deviceLabel.value,
|
|
});
|
|
throw ProjectRequiresLoginException();
|
|
}
|
|
// Felhős projektnél: AZONNALI, élő ellenőrzés — nem várjuk meg a
|
|
// háttér-reconcile 3 ciklusos türelmi idejét. Az azért van, hogy egy
|
|
// ÁTMENETI hálózati/RLS-hiccup ne váltson ki téves törlést — itt
|
|
// viszont egyetlen, konkrét projektet kérdezünk le frissen, ahol
|
|
// nincs ilyen bizonytalanság: a deleted_at vagy ki van töltve, vagy
|
|
// nincs. Egy már bizonyítottan törölt projekthez való csatlakozás
|
|
// komoly félreértések forrása lenne (adatrögzítés egy halott
|
|
// projektbe), ezt nem érdemes kockáztatni pár perc türelmi idő
|
|
// kedvéért.
|
|
if (!project.isLocalOnly) {
|
|
try {
|
|
final row = await Supabase.instance.client
|
|
.from('terepi_seged_projects')
|
|
.select('deleted_at')
|
|
.eq('id', project.uuid)
|
|
.maybeSingle()
|
|
.timeout(const Duration(seconds: 6));
|
|
|
|
if (row == null || row['deleted_at'] != null) {
|
|
AppLogger.event('project_activate_blocked_deleted', '', {
|
|
'project_id': project.id,
|
|
'device_id': DeviceIdentityService.to.deviceId,
|
|
'device_name': DeviceIdentityService.to.deviceLabel.value,
|
|
'user_id': Supabase.instance.client.auth.currentUser?.id,
|
|
});
|
|
throw ProjectNoLongerExistsException();
|
|
}
|
|
} on ProjectNoLongerExistsException {
|
|
rethrow;
|
|
} catch (_) {
|
|
// Hálózati hiba/időtúllépés → NEM blokkolunk emiatt (fail-open,
|
|
// offline-first elv) — ha tényleg törölve van, a háttér-reconcile
|
|
// úgyis elkapja hamarosan.
|
|
}
|
|
}
|
|
|
|
// Helyi (SQLite) meglét ellenőrzése — ne aktiváljunk egy már a
|
|
// háttér-reconcile által helyileg törölt projektet sem.
|
|
final stillExists = await AppDatabase.instance.getProject(project.id!);
|
|
if (stillExists == null) {
|
|
await _loadProjects(); // a lista is frissüljön, ne maradjon árva
|
|
AppLogger.event('project_activate_blocked_gone', '', {
|
|
'project_id': project.id,
|
|
'device_id': DeviceIdentityService.to.deviceId,
|
|
'device_name': DeviceIdentityService.to.deviceLabel.value,
|
|
'user_id': Supabase.instance.client.auth.currentUser?.id,
|
|
});
|
|
throw ProjectNoLongerExistsException();
|
|
}
|
|
|
|
activeProject.value = project;
|
|
final prefs = await SharedPreferences.getInstance();
|
|
await prefs.setInt('active_project_id', project.id!);
|
|
|
|
// Csak lokális projektnél frissítjük az updated_at-et (lista-sorrendhez)
|
|
// — felhősnél ez feleslegesen szinkron-jelet váltana ki, ütközési
|
|
// kockázattal egy másik eszköz közbeni, valódi módosításával szemben.
|
|
if (project.isLocalOnly) {
|
|
await AppDatabase.instance.updateProject(project.copyWith());
|
|
}
|
|
await _loadProjects();
|
|
}
|
|
|
|
Future<Project> createProject({
|
|
required String name,
|
|
String client = '',
|
|
String description = '',
|
|
ProjectCrs crs = ProjectCrs.eov,
|
|
String color = '#185FA5',
|
|
}) async {
|
|
final now = DateTime.now();
|
|
final project = Project(
|
|
uuid: const Uuid().v4(),
|
|
name: name,
|
|
client: client,
|
|
description: description,
|
|
crs: crs,
|
|
color: color,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
);
|
|
final id = await AppDatabase.instance.insertProject(project);
|
|
final saved = project.copyWith();
|
|
await _loadProjects();
|
|
return await AppDatabase.instance.getProject(id) ?? saved;
|
|
}
|
|
|
|
/// Közös (szinkronizált) projekt.
|
|
///
|
|
/// OFFLINE-FIRST: csak lokálisan jön létre (sync_status = 'pending'),
|
|
/// a feltöltést a TsSyncService végzi, amint van hálózat — így a
|
|
/// projekt-létrehozás net nélkül is működik, és nem ír többé
|
|
/// közvetlenül a régi Supabase-táblába.
|
|
|
|
Future<Project> createOnlineProject({
|
|
required String name,
|
|
String client = '',
|
|
ProjectCrs crs = ProjectCrs.eov,
|
|
String color = '#185FA5',
|
|
}) async {
|
|
final project = Project(
|
|
uuid: const Uuid().v4(),
|
|
name: name,
|
|
client: client,
|
|
crs: crs,
|
|
color: color,
|
|
isLocalOnly: false, // ← szinkronizált
|
|
createdAt: DateTime.now(),
|
|
updatedAt: DateTime.now(),
|
|
);
|
|
|
|
// Lokálisan mentjük
|
|
final id = await AppDatabase.instance.insertProject(project);
|
|
|
|
await _loadProjects();
|
|
|
|
// Ha van net, azonnal fel is megy (és owner-tagság is létrejön).
|
|
if (Get.isRegistered<TsSyncService>()) {
|
|
TsSyncService.to.syncNow();
|
|
}
|
|
|
|
AppLogger.event('project_created_online', project.uuid,
|
|
{'name': name, 'client': client});
|
|
return await AppDatabase.instance.getProject(id) ?? project;
|
|
}
|
|
|
|
/// Lokális projekt — soha nem kerül Supabase-be
|
|
Future<Project> createLocalProject({
|
|
required String name,
|
|
String client = '',
|
|
ProjectCrs crs = ProjectCrs.eov,
|
|
String color = '#185FA5',
|
|
}) async {
|
|
final project = Project(
|
|
uuid: const Uuid().v4(),
|
|
name: name,
|
|
client: client,
|
|
crs: crs,
|
|
color: color,
|
|
isLocalOnly: true, // ← csak lokális
|
|
createdAt: DateTime.now(),
|
|
updatedAt: DateTime.now(),
|
|
);
|
|
|
|
// Csak lokálisan
|
|
final id = await AppDatabase.instance.insertProject(project);
|
|
await _loadProjects();
|
|
AppLogger.event('project_created_local', project.uuid,
|
|
{'name': name, 'client': client});
|
|
|
|
return await AppDatabase.instance.getProject(id) ?? project;
|
|
}
|
|
|
|
// ═════════════════════════════════════════════════════════════════
|
|
// Közös projektek — listázás és csatlakozás
|
|
// ═════════════════════════════════════════════════════════════════
|
|
|
|
/// A Supabase-en elérhető közös projektek listája
|
|
/// (név, tulajdonos, tagszám, is_member) — a ts_shared_projects view-ból.
|
|
Future<List<Map<String, dynamic>>> fetchSharedProjects() async {
|
|
final rows = await Supabase.instance.client
|
|
.from('terepi_seged_shared_projects')
|
|
.select()
|
|
.order('name', ascending: true);
|
|
return List<Map<String, dynamic>>.from(rows);
|
|
}
|
|
|
|
/// Csatlakozás egy közös projekthez (egyszerűsített modell):
|
|
/// 1. tagság-sor beszúrása (az RLS csak saját magunkat engedi felvenni),
|
|
/// 2. a projekt lokális sora létrejön a TÁVOLI uuid-dal — innentől a
|
|
/// szinkron ugyanúgy kezeli, mint a sajátokat,
|
|
/// 3. azonnali szinkron, hogy a projekt eddigi adatai lejöjjenek.
|
|
Future<Project> joinSharedProject(Map<String, dynamic> sharedRow) async {
|
|
final client = Supabase.instance.client;
|
|
final user = client.auth.currentUser;
|
|
if (user == null) {
|
|
AppLogger.event('project_join_blocked_no_login');
|
|
throw ProjectRequiresLoginException(
|
|
'Közös projekthez csatlakozáshoz be kell jelentkezni.');
|
|
}
|
|
final projectUuid = sharedRow['id'] as String;
|
|
|
|
try {
|
|
await client.from('terepi_seged_project_members').upsert(
|
|
{
|
|
'project_id': projectUuid,
|
|
'user_id': user.id,
|
|
'role': 'editor',
|
|
},
|
|
ignoreDuplicates: true,
|
|
);
|
|
} catch (e) {
|
|
AppLogger.e('ProjectService.joinSharedProject',
|
|
'Tagság-beszúrás hiba (project=$projectUuid): $e');
|
|
rethrow;
|
|
}
|
|
|
|
final localId =
|
|
await AppDatabase.instance.upsertProjectFromRemote(sharedRow);
|
|
await _loadProjects();
|
|
|
|
AppLogger.event(
|
|
'project_joined', projectUuid, {'user_id': user.id, 'role': 'editor'});
|
|
|
|
if (Get.isRegistered<TsSyncService>()) {
|
|
TsSyncService.to.syncNow();
|
|
}
|
|
|
|
return (await AppDatabase.instance.getProject(localId))!;
|
|
}
|
|
|
|
/// Kilépés egy közös projektből: a tagság törlődik a szerveren,
|
|
/// a lokális adat megmarad (archiválható külön).
|
|
Future<void> leaveSharedProject(Project project) async {
|
|
final client = Supabase.instance.client;
|
|
final user = client.auth.currentUser;
|
|
if (user == null) return;
|
|
try {
|
|
await client
|
|
.from('terepi_seged_project_members')
|
|
.delete()
|
|
.eq('project_id', project.uuid)
|
|
.eq('user_id', user.id);
|
|
AppLogger.event(
|
|
'shared_project_left', project.uuid, {'user_id': user.id});
|
|
} catch (e) {
|
|
AppLogger.e('ProjectService.leaveSharedProject',
|
|
'Kilépés hiba (project=${project.uuid}): $e');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
// ═════════════════════════════════════════════════════════════════
|
|
/// A projekt-lista frissítése — a háttér-szinkron hívja, miután a
|
|
/// reconcile-mechanizmus esetleg helyileg törölt egy, a szerveren már
|
|
/// nem létező projektet. Ha épp az AKTÍV projekt tűnt el, biztonságos
|
|
/// másikra váltunk, ne maradjon egy már nem létező projektre mutatva.
|
|
Future<void> reloadProjects() async {
|
|
await _loadProjects();
|
|
|
|
final active = activeProject.value;
|
|
if (active == null) return;
|
|
|
|
final stillThere = projects.firstWhereOrNull((p) => p.id == active.id);
|
|
if (stillThere == null) {
|
|
// A projekt eltűnt — biztonságos másikra váltunk.
|
|
final fallback = projects.firstWhereOrNull((p) => p.isLocalOnly) ??
|
|
(projects.isNotEmpty ? projects.first : null);
|
|
if (fallback != null) {
|
|
try {
|
|
await setActiveProject(fallback);
|
|
} catch (_) {
|
|
activeProject.value = null;
|
|
}
|
|
} else {
|
|
activeProject.value = null;
|
|
}
|
|
} else {
|
|
// A projekt megvan — de az ADATAI (pl. a neve) változhattak a
|
|
// szerveren. Az activeProject-et is friss példányra cseréljük,
|
|
// hogy minden, közvetlenül ezt figyelő UI (appbar, drawer) azonnal
|
|
// lássa a változást, ne csak a projekt-választó lista.
|
|
activeProject.value = stillThere;
|
|
}
|
|
}
|
|
|
|
Future<Map<String, int>> getStats(int projectId) =>
|
|
AppDatabase.instance.getProjectStats(projectId);
|
|
|
|
Future<void> archiveProject(int id) async {
|
|
await _loadProjects(); // friss állapot a döntéshez
|
|
final target = projects.firstWhereOrNull((p) => p.id == id);
|
|
if (target == null) return;
|
|
|
|
// Sose maradjon nulla aktív HELYI projekt — mindig kell legyen
|
|
// legalább egy, bejelentkezés nélkül is használható projekt.
|
|
if (target.isLocalOnly) {
|
|
final otherLocal = projects.where((p) =>
|
|
p.isLocalOnly && p.id != id && p.status == ProjectStatus.active);
|
|
if (otherLocal.isEmpty) {
|
|
AppLogger.event('project_archive_blocked_last_local', '', {
|
|
'project_id': id,
|
|
'user_id': Supabase.instance.client.auth.currentUser?.id,
|
|
'device_name': DeviceIdentityService.to.deviceLabel.value,
|
|
'device_id': DeviceIdentityService.to.deviceId,
|
|
});
|
|
throw ProjectArchiveBlockedException(
|
|
'Ez az utolsó helyi projekt — legalább egynek meg kell '
|
|
'maradnia, hogy bejelentkezés nélkül is legyen elérhető '
|
|
'projekt.');
|
|
}
|
|
}
|
|
|
|
await AppDatabase.instance.archiveProject(id);
|
|
AppLogger.event('project_archived', '', {
|
|
'project_id': id,
|
|
'user_id': Supabase.instance.client.auth.currentUser?.id,
|
|
'device_name': DeviceIdentityService.to.deviceLabel.value,
|
|
'device_id': DeviceIdentityService.to.deviceId,
|
|
});
|
|
await _loadProjects();
|
|
|
|
if (activeProject.value?.id == id) {
|
|
final fallback = projects.firstWhereOrNull((p) => p.isLocalOnly) ??
|
|
projects.firstWhereOrNull((p) => p.id != id);
|
|
if (fallback != null) {
|
|
try {
|
|
await setActiveProject(fallback);
|
|
} catch (_) {
|
|
activeProject.value = null;
|
|
}
|
|
} else {
|
|
activeProject.value = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> updateProject(Project project) async {
|
|
await AppDatabase.instance.updateProject(project);
|
|
await _loadProjects();
|
|
|
|
if (activeProject.value?.id == project.id) {
|
|
activeProject.value = project;
|
|
}
|
|
}
|
|
}
|