521 lines
17 KiB
Dart
521 lines
17 KiB
Dart
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
import 'package:supabase_flutter/supabase_flutter.dart';
|
|
import 'package:uuid/uuid.dart';
|
|
|
|
import '../brick/cache_helpers.dart';
|
|
import '../models/pass_slip.dart';
|
|
import '../utils/app_time.dart';
|
|
import '../utils/snackbar.dart' show isOfflineSaveError;
|
|
import 'connectivity_provider.dart';
|
|
import 'profile_provider.dart';
|
|
import 'supabase_provider.dart';
|
|
import 'stream_recovery.dart';
|
|
import 'realtime_controller.dart';
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Offline-pending state
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Pass slips filed offline that haven't been confirmed by Supabase yet.
|
|
final offlinePendingPassSlipsProvider =
|
|
StateProvider<List<PassSlip>>((ref) => const []);
|
|
|
|
/// Status edits (approve/reject/complete) made offline, keyed by slip id.
|
|
final offlinePendingPassSlipUpdatesProvider =
|
|
StateProvider<Map<String, Map<String, dynamic>>>((ref) => const {});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Read provider
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// All visible pass slips (own for staff, all for admin/dispatcher).
|
|
final passSlipsProvider = StreamProvider<List<PassSlip>>((ref) {
|
|
final client = ref.watch(supabaseClientProvider);
|
|
final profileAsync = ref.watch(currentProfileProvider);
|
|
final profile = profileAsync.valueOrNull;
|
|
if (profile == null) return Stream.value(const <PassSlip>[]);
|
|
|
|
final isAdmin = profile.role == 'admin' || profile.role == 'dispatcher';
|
|
final hasFullAccess = isAdmin || profile.role == 'programmer';
|
|
|
|
final pendingNew = ref.watch(offlinePendingPassSlipsProvider);
|
|
final pendingUpdates = ref.watch(offlinePendingPassSlipUpdatesProvider);
|
|
|
|
List<PassSlip> applyPending(List<PassSlip> rows) {
|
|
final byId = {for (final r in rows) r.id: r};
|
|
pendingUpdates.forEach((id, fields) {
|
|
final existing = byId[id];
|
|
if (existing == null) return;
|
|
byId[id] = PassSlip(
|
|
id: existing.id,
|
|
userId: existing.userId,
|
|
dutyScheduleId: existing.dutyScheduleId,
|
|
reason: existing.reason,
|
|
status: (fields['status'] as String?) ?? existing.status,
|
|
requestedAt: existing.requestedAt,
|
|
approvedBy: (fields['approved_by'] as String?) ?? existing.approvedBy,
|
|
approvedAt: fields.containsKey('approved_at')
|
|
? (fields['approved_at'] is String
|
|
? AppTime.parse(fields['approved_at'] as String)
|
|
: existing.approvedAt)
|
|
: existing.approvedAt,
|
|
slipStart: fields.containsKey('slip_start')
|
|
? (fields['slip_start'] is String
|
|
? AppTime.parse(fields['slip_start'] as String)
|
|
: existing.slipStart)
|
|
: existing.slipStart,
|
|
slipEnd: fields.containsKey('slip_end')
|
|
? (fields['slip_end'] is String
|
|
? AppTime.parse(fields['slip_end'] as String)
|
|
: existing.slipEnd)
|
|
: existing.slipEnd,
|
|
requestedStart: existing.requestedStart,
|
|
);
|
|
});
|
|
for (final p in pendingNew) {
|
|
if (hasFullAccess || p.userId == profile.id) {
|
|
byId.putIfAbsent(p.id, () => p);
|
|
}
|
|
}
|
|
final merged = byId.values.toList()
|
|
..sort((a, b) => b.requestedAt.compareTo(a.requestedAt));
|
|
return merged;
|
|
}
|
|
|
|
final wrapper = StreamRecoveryWrapper<PassSlip>(
|
|
stream: hasFullAccess
|
|
? client
|
|
.from('pass_slips')
|
|
.stream(primaryKey: ['id'])
|
|
.order('requested_at', ascending: false)
|
|
: client
|
|
.from('pass_slips')
|
|
.stream(primaryKey: ['id'])
|
|
.eq('user_id', profile.id)
|
|
.order('requested_at', ascending: false),
|
|
onPollData: () async {
|
|
final query = client.from('pass_slips').select();
|
|
final data = hasFullAccess
|
|
? await query.order('requested_at', ascending: false)
|
|
: await query
|
|
.eq('user_id', profile.id)
|
|
.order('requested_at', ascending: false);
|
|
return data.map(PassSlip.fromMap).toList();
|
|
},
|
|
fromMap: PassSlip.fromMap,
|
|
channelName: 'pass_slips',
|
|
onStatusChanged: ref.read(realtimeControllerProvider).handleChannelStatus,
|
|
onOfflineData: () async {
|
|
final all = await cachedListFromBrick<PassSlip>();
|
|
final filtered = hasFullAccess
|
|
? all
|
|
: all.where((s) => s.userId == profile.id).toList();
|
|
return applyPending(filtered);
|
|
},
|
|
onCacheMirror: (rows) =>
|
|
mirrorBatchToBrick<PassSlip>(rows, tag: 'pass_slips'),
|
|
);
|
|
|
|
ref.onDispose(wrapper.dispose);
|
|
|
|
// Reconnect-replay
|
|
ref.listen<bool>(isOnlineProvider, (wasOnline, isNowOnline) async {
|
|
if (wasOnline == true || !isNowOnline) return;
|
|
|
|
final pending = List<PassSlip>.from(ref.read(offlinePendingPassSlipsProvider));
|
|
if (pending.isNotEmpty) {
|
|
debugPrint('[passSlipsProvider] reconnected — syncing ${pending.length} slip(s)');
|
|
final synced = <String>[];
|
|
for (final slip in pending) {
|
|
try {
|
|
await client.from('pass_slips').insert({
|
|
'id': slip.id,
|
|
'user_id': slip.userId,
|
|
'duty_schedule_id': slip.dutyScheduleId,
|
|
'reason': slip.reason,
|
|
'status': slip.status,
|
|
'requested_at': slip.requestedAt.toIso8601String(),
|
|
if (slip.requestedStart != null)
|
|
'requested_start': slip.requestedStart!.toIso8601String(),
|
|
});
|
|
synced.add(slip.id);
|
|
} catch (e) {
|
|
final msg = e.toString();
|
|
if (msg.contains('23505') || msg.contains('duplicate key')) {
|
|
synced.add(slip.id);
|
|
} else {
|
|
debugPrint('[passSlipsProvider] failed to sync slip id=${slip.id}: $e');
|
|
}
|
|
}
|
|
}
|
|
if (synced.isNotEmpty) {
|
|
final remaining = ref.read(offlinePendingPassSlipsProvider)
|
|
.where((s) => !synced.contains(s.id))
|
|
.toList();
|
|
ref.read(offlinePendingPassSlipsProvider.notifier).state =
|
|
List.unmodifiable(remaining);
|
|
}
|
|
}
|
|
|
|
final pendingMap = Map<String, Map<String, dynamic>>.from(
|
|
ref.read(offlinePendingPassSlipUpdatesProvider),
|
|
);
|
|
if (pendingMap.isNotEmpty) {
|
|
debugPrint(
|
|
'[passSlipsProvider] reconnected — syncing ${pendingMap.length} status edit(s)',
|
|
);
|
|
final syncedIds = <String>[];
|
|
for (final entry in pendingMap.entries) {
|
|
try {
|
|
await client
|
|
.from('pass_slips')
|
|
.update(entry.value)
|
|
.eq('id', entry.key);
|
|
syncedIds.add(entry.key);
|
|
} catch (e) {
|
|
debugPrint('[passSlipsProvider] failed to sync edit id=${entry.key}: $e');
|
|
}
|
|
}
|
|
if (syncedIds.isNotEmpty) {
|
|
final remaining = Map<String, Map<String, dynamic>>.from(
|
|
ref.read(offlinePendingPassSlipUpdatesProvider),
|
|
);
|
|
for (final id in syncedIds) {
|
|
remaining.remove(id);
|
|
}
|
|
ref.read(offlinePendingPassSlipUpdatesProvider.notifier).state = remaining;
|
|
}
|
|
}
|
|
});
|
|
|
|
return wrapper.stream.map((result) => applyPending(result.data));
|
|
});
|
|
|
|
/// Currently active pass slip for the logged-in user (approved, not completed).
|
|
final activePassSlipProvider = Provider<PassSlip?>((ref) {
|
|
final slips = ref.watch(passSlipsProvider).valueOrNull ?? [];
|
|
final userId = ref.watch(currentUserIdProvider);
|
|
if (userId == null) return null;
|
|
try {
|
|
return slips.firstWhere((s) => s.userId == userId && s.isActive);
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
});
|
|
|
|
/// Active pass slips for all users (for dashboard IT Staff Pulse).
|
|
final activePassSlipsProvider = Provider<List<PassSlip>>((ref) {
|
|
final slips = ref.watch(passSlipsProvider).valueOrNull ?? [];
|
|
return slips.where((s) => s.isActive).toList();
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Controller
|
|
// ---------------------------------------------------------------------------
|
|
|
|
final passSlipControllerProvider = Provider<PassSlipController>((ref) {
|
|
final client = ref.watch(supabaseClientProvider);
|
|
return PassSlipController(client, ref);
|
|
});
|
|
|
|
class PassSlipController {
|
|
PassSlipController(this._client, [this._ref]);
|
|
|
|
final SupabaseClient _client;
|
|
final Ref? _ref;
|
|
|
|
void _queuePendingSlip(PassSlip slip) {
|
|
final ref = _ref;
|
|
if (ref == null) return;
|
|
final current = List<PassSlip>.from(
|
|
ref.read(offlinePendingPassSlipsProvider),
|
|
);
|
|
current.add(slip);
|
|
ref.read(offlinePendingPassSlipsProvider.notifier).state =
|
|
List.unmodifiable(current);
|
|
mirrorBatchToBrick<PassSlip>([slip], tag: 'offline_pass_slip');
|
|
}
|
|
|
|
void _queueSlipStatusUpdate(String slipId, Map<String, dynamic> fields) {
|
|
final ref = _ref;
|
|
if (ref == null) return;
|
|
final current = Map<String, Map<String, dynamic>>.from(
|
|
ref.read(offlinePendingPassSlipUpdatesProvider),
|
|
);
|
|
current[slipId] = {...?current[slipId], ...fields};
|
|
ref.read(offlinePendingPassSlipUpdatesProvider.notifier).state = current;
|
|
}
|
|
|
|
Future<void> requestSlip({
|
|
required String dutyScheduleId,
|
|
required String reason,
|
|
DateTime? requestedStart,
|
|
}) async {
|
|
final userId = _client.auth.currentUser?.id;
|
|
if (userId == null) throw Exception('Not authenticated');
|
|
final id = const Uuid().v4();
|
|
final now = DateTime.now().toUtc();
|
|
final payload = {
|
|
'id': id,
|
|
'user_id': userId,
|
|
'duty_schedule_id': dutyScheduleId,
|
|
'reason': reason,
|
|
'status': 'pending',
|
|
'requested_at': now.toIso8601String(),
|
|
if (requestedStart != null)
|
|
'requested_start': requestedStart.toUtc().toIso8601String(),
|
|
};
|
|
|
|
Map<String, dynamic>? inserted;
|
|
try {
|
|
final insertedRaw = await _client
|
|
.from('pass_slips')
|
|
.insert(payload)
|
|
.select()
|
|
.maybeSingle();
|
|
inserted = insertedRaw is Map<String, dynamic> ? insertedRaw : null;
|
|
} catch (e) {
|
|
if (!isOfflineSaveError(e)) rethrow;
|
|
_queuePendingSlip(PassSlip(
|
|
id: id,
|
|
userId: userId,
|
|
dutyScheduleId: dutyScheduleId,
|
|
reason: reason,
|
|
status: 'pending',
|
|
requestedAt: AppTime.toAppTime(now),
|
|
requestedStart: requestedStart,
|
|
));
|
|
return;
|
|
}
|
|
|
|
// Notify admins for approval (best-effort)
|
|
try {
|
|
final adminIds = await _fetchRoleUserIds(
|
|
roles: const ['admin'],
|
|
excludeUserId: userId,
|
|
);
|
|
if (adminIds.isEmpty) return;
|
|
|
|
String actorName = 'Someone';
|
|
try {
|
|
final p = await _client
|
|
.from('profiles')
|
|
.select('full_name,display_name,name')
|
|
.eq('id', userId)
|
|
.maybeSingle();
|
|
if (p != null) {
|
|
if (p['full_name'] != null) {
|
|
actorName = p['full_name'].toString();
|
|
} else if (p['display_name'] != null) {
|
|
actorName = p['display_name'].toString();
|
|
} else if (p['name'] != null) {
|
|
actorName = p['name'].toString();
|
|
}
|
|
}
|
|
} catch (_) {}
|
|
|
|
final slipId = (inserted ?? <String, dynamic>{})['id']?.toString() ?? id;
|
|
final title = 'Pass Slip Filed for Approval';
|
|
final body = '$actorName filed a pass slip that requires approval.';
|
|
final notificationId = (inserted ?? <String, dynamic>{})['id']?.toString();
|
|
|
|
final dataPayload = <String, dynamic>{
|
|
'type': 'pass_slip_filed',
|
|
'pass_slip_id': slipId,
|
|
...?(notificationId != null ? {'notification_id': notificationId} : null),
|
|
};
|
|
|
|
await _client.from('notifications').insert(
|
|
adminIds
|
|
.map((adminId) => {
|
|
'user_id': adminId,
|
|
'actor_id': userId,
|
|
'type': 'pass_slip_filed',
|
|
'pass_slip_id': slipId,
|
|
})
|
|
.toList(),
|
|
);
|
|
|
|
final res = await _client.functions.invoke(
|
|
'send_fcm',
|
|
body: {
|
|
'user_ids': adminIds,
|
|
'title': title,
|
|
'body': body,
|
|
'data': dataPayload,
|
|
},
|
|
);
|
|
debugPrint('pass slip send_fcm result: $res');
|
|
} catch (e) {
|
|
debugPrint('pass slip send_fcm error: $e');
|
|
}
|
|
}
|
|
|
|
Future<void> approveSlip(String slipId) async {
|
|
final userId = _client.auth.currentUser?.id;
|
|
if (userId == null) throw Exception('Not authenticated');
|
|
|
|
final nowUtc = DateTime.now().toUtc();
|
|
|
|
// Try to determine slip start time online; if offline use now.
|
|
String slipStartIso = nowUtc.toIso8601String();
|
|
try {
|
|
final row = await _client
|
|
.from('pass_slips')
|
|
.select('requested_start')
|
|
.eq('id', slipId)
|
|
.maybeSingle();
|
|
if (row != null && row['requested_start'] != null) {
|
|
final requestedStart = DateTime.parse(row['requested_start'] as String);
|
|
if (requestedStart.isAfter(nowUtc)) {
|
|
slipStartIso = requestedStart.toIso8601String();
|
|
}
|
|
}
|
|
} catch (_) {
|
|
// Stick with nowUtc.
|
|
}
|
|
|
|
final fields = {
|
|
'status': 'approved',
|
|
'approved_by': userId,
|
|
'approved_at': nowUtc.toIso8601String(),
|
|
'slip_start': slipStartIso,
|
|
};
|
|
|
|
try {
|
|
await _client.from('pass_slips').update(fields).eq('id', slipId);
|
|
} catch (e) {
|
|
if (!isOfflineSaveError(e)) rethrow;
|
|
_queueSlipStatusUpdate(slipId, fields);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await _notifyRequester(slipId: slipId, actorId: userId, approved: true);
|
|
} catch (_) {}
|
|
}
|
|
|
|
Future<void> rejectSlip(String slipId) async {
|
|
final userId = _client.auth.currentUser?.id;
|
|
if (userId == null) throw Exception('Not authenticated');
|
|
|
|
final fields = {
|
|
'status': 'rejected',
|
|
'approved_by': userId,
|
|
'approved_at': DateTime.now().toUtc().toIso8601String(),
|
|
};
|
|
|
|
try {
|
|
await _client.from('pass_slips').update(fields).eq('id', slipId);
|
|
} catch (e) {
|
|
if (!isOfflineSaveError(e)) rethrow;
|
|
_queueSlipStatusUpdate(slipId, fields);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await _notifyRequester(slipId: slipId, actorId: userId, approved: false);
|
|
} catch (_) {}
|
|
}
|
|
|
|
Future<void> _notifyRequester({
|
|
required String slipId,
|
|
required String actorId,
|
|
required bool approved,
|
|
}) async {
|
|
try {
|
|
final row = await _client
|
|
.from('pass_slips')
|
|
.select('user_id')
|
|
.eq('id', slipId)
|
|
.maybeSingle();
|
|
// ignore: unnecessary_cast
|
|
final rowMap = row as Map<String, dynamic>?;
|
|
final userId = rowMap?['user_id']?.toString();
|
|
if (userId == null || userId.isEmpty) return;
|
|
|
|
String actorName = 'Someone';
|
|
try {
|
|
final p = await _client
|
|
.from('profiles')
|
|
.select('full_name,display_name,name')
|
|
.eq('id', actorId)
|
|
.maybeSingle();
|
|
if (p != null) {
|
|
if (p['full_name'] != null) {
|
|
actorName = p['full_name'].toString();
|
|
} else if (p['display_name'] != null) {
|
|
actorName = p['display_name'].toString();
|
|
} else if (p['name'] != null) {
|
|
actorName = p['name'].toString();
|
|
}
|
|
}
|
|
} catch (_) {}
|
|
|
|
final title = approved ? 'Pass Slip Approved' : 'Pass Slip Rejected';
|
|
final body = approved
|
|
? '$actorName approved your pass slip.'
|
|
: '$actorName rejected your pass slip.';
|
|
|
|
final dataPayload = <String, dynamic>{
|
|
'type': approved ? 'pass_slip_approved' : 'pass_slip_rejected',
|
|
'pass_slip_id': slipId,
|
|
};
|
|
|
|
await _client.from('notifications').insert({
|
|
'user_id': userId,
|
|
'actor_id': actorId,
|
|
'type': approved ? 'pass_slip_approved' : 'pass_slip_rejected',
|
|
'pass_slip_id': slipId,
|
|
});
|
|
|
|
await _client.functions.invoke(
|
|
'send_fcm',
|
|
body: {
|
|
'user_ids': [userId],
|
|
'title': title,
|
|
'body': body,
|
|
'data': dataPayload,
|
|
},
|
|
);
|
|
} catch (_) {
|
|
// non-fatal
|
|
}
|
|
}
|
|
|
|
Future<void> completeSlip(String slipId) async {
|
|
final fields = {
|
|
'status': 'completed',
|
|
'slip_end': DateTime.now().toUtc().toIso8601String(),
|
|
};
|
|
try {
|
|
await _client.from('pass_slips').update(fields).eq('id', slipId);
|
|
} catch (e) {
|
|
if (!isOfflineSaveError(e)) rethrow;
|
|
_queueSlipStatusUpdate(slipId, fields);
|
|
}
|
|
}
|
|
|
|
Future<List<String>> _fetchRoleUserIds({
|
|
required List<String> roles,
|
|
required String? excludeUserId,
|
|
}) async {
|
|
try {
|
|
final data = await _client
|
|
.from('profiles')
|
|
.select('id, role')
|
|
.inFilter('role', roles);
|
|
final rows = data as List<dynamic>;
|
|
final ids = rows
|
|
.map((row) => row['id'] as String?)
|
|
.whereType<String>()
|
|
.where((id) => id.isNotEmpty && id != excludeUserId)
|
|
.toList();
|
|
return ids;
|
|
} catch (_) {
|
|
return [];
|
|
}
|
|
}
|
|
}
|