753 lines
24 KiB
Dart
753 lines
24 KiB
Dart
import 'package:flutter/foundation.dart';
|
|
import 'package:supabase_flutter/supabase_flutter.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:flutter_dotenv/flutter_dotenv.dart';
|
|
|
|
class AuthProvider extends GetxService {
|
|
late final SupabaseClient client;
|
|
bool _isInitialized = false;
|
|
|
|
Future<AuthProvider> init() async {
|
|
// Cek jika sudah diinisialisasi sebelumnya
|
|
if (_isInitialized) {
|
|
debugPrint('Supabase already initialized');
|
|
return this;
|
|
}
|
|
|
|
try {
|
|
// Cek jika dotenv sudah dimuat
|
|
if (dotenv.env['SUPABASE_URL'] == null ||
|
|
dotenv.env['SUPABASE_ANON_KEY'] == null) {
|
|
await dotenv.load();
|
|
}
|
|
|
|
final supabaseUrl = dotenv.env['SUPABASE_URL'];
|
|
final supabaseKey = dotenv.env['SUPABASE_ANON_KEY'];
|
|
|
|
if (supabaseUrl == null || supabaseKey == null) {
|
|
throw Exception('Supabase credentials not found in .env file');
|
|
}
|
|
|
|
debugPrint(
|
|
'Initializing Supabase with URL: ${supabaseUrl.substring(0, 15)}...',
|
|
);
|
|
|
|
await Supabase.initialize(
|
|
url: supabaseUrl,
|
|
anonKey: supabaseKey,
|
|
debug: true, // Aktifkan debugging untuk membantu troubleshooting
|
|
);
|
|
|
|
client = Supabase.instance.client;
|
|
_isInitialized = true;
|
|
debugPrint('Supabase initialized successfully');
|
|
return this;
|
|
} catch (e) {
|
|
debugPrint('Error initializing Supabase: $e');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
// Authentication methods
|
|
Future<AuthResponse> signUp({
|
|
required String email,
|
|
required String password,
|
|
Map<String, dynamic>? data,
|
|
}) async {
|
|
return await client.auth.signUp(
|
|
email: email,
|
|
password: password,
|
|
data: data,
|
|
);
|
|
}
|
|
|
|
Future<AuthResponse> signIn({
|
|
required String email,
|
|
required String password,
|
|
}) async {
|
|
return await client.auth.signInWithPassword(
|
|
email: email,
|
|
password: password,
|
|
);
|
|
}
|
|
|
|
Future<void> signOut() async {
|
|
await client.auth.signOut();
|
|
}
|
|
|
|
// Method to clear any cached data in the AuthProvider
|
|
void clearAuthData() {
|
|
// Clear any cached user data or state
|
|
// This method is called during logout to ensure all user-related data is cleared
|
|
debugPrint('Clearing AuthProvider cached data');
|
|
|
|
// Explicitly clear any cached data that might be stored in the provider
|
|
// This is important to ensure no user data remains after logout or registration
|
|
try {
|
|
// Force refresh of the auth state
|
|
client.auth.refreshSession();
|
|
|
|
// Log the cleanup action
|
|
debugPrint('AuthProvider cached data cleared successfully');
|
|
} catch (e) {
|
|
debugPrint('Error clearing AuthProvider cached data: $e');
|
|
}
|
|
}
|
|
|
|
User? get currentUser => client.auth.currentUser;
|
|
|
|
Stream<AuthState> get authChanges => client.auth.onAuthStateChange;
|
|
|
|
String? getCurrentUserId() {
|
|
try {
|
|
final session = Supabase.instance.client.auth.currentSession;
|
|
return session?.user.id;
|
|
} catch (e) {
|
|
print('Error getting current user ID: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan role_id dari raw_user_meta_data
|
|
Future<String?> getUserRoleId() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting role');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching role_id from user metadata for user ID: ${user.id}');
|
|
|
|
// Cek user metadata untuk role_id
|
|
final userMetadata = user.userMetadata;
|
|
debugPrint('User metadata: $userMetadata');
|
|
|
|
// Cek beberapa kemungkinan nama field untuk role_id
|
|
if (userMetadata != null) {
|
|
if (userMetadata.containsKey('role_id')) {
|
|
final roleId = userMetadata['role_id'].toString();
|
|
debugPrint('Found role_id in metadata: $roleId');
|
|
return roleId;
|
|
}
|
|
|
|
if (userMetadata.containsKey('role')) {
|
|
final role = userMetadata['role'].toString();
|
|
debugPrint('Found role in metadata: $role');
|
|
|
|
// Coba konversi nama role ke UUID (from hardcoded data)
|
|
if (role.toUpperCase() == 'WARGA') {
|
|
return 'bb5360d5-8fd0-404e-8f6f-71ec4d8ad0ae';
|
|
}
|
|
if (role.toUpperCase() == 'PETUGAS_BUMDES') {
|
|
return '38a8a23c-1873-4033-b977-3293247903b';
|
|
}
|
|
if (role.toUpperCase() == 'PETUGAS_MITRA') {
|
|
return '8b1af754-0866-4e12-a9d8-da8ed31bec15';
|
|
}
|
|
}
|
|
}
|
|
|
|
// Jika tidak ada di metadata, coba cari di tabel roles dengan user_id
|
|
debugPrint('Checking roles table for user ID: ${user.id}');
|
|
|
|
try {
|
|
// Mencoba mengambil roles berdasarkan id user di auth
|
|
final roleData =
|
|
await client
|
|
.from('roles')
|
|
.select('id')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
debugPrint('Role data by user_id: $roleData');
|
|
|
|
if (roleData != null && roleData.containsKey('id')) {
|
|
final roleId = roleData['id'].toString();
|
|
debugPrint('Found role ID in roles table: $roleId');
|
|
return roleId;
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Error querying roles by user_id: $e');
|
|
}
|
|
|
|
// Jika tidak ditemukan dengan user_id, coba lihat seluruh tabel roles
|
|
// untuk debugging
|
|
debugPrint('Getting all roles to debug matching issues');
|
|
final allRoles = await client.from('roles').select('*').limit(10);
|
|
|
|
debugPrint('All roles in table: $allRoles');
|
|
|
|
// Fallback - tampaknya user belum di-assign role
|
|
// Berikan hardcoded role berdasarkan email pattern
|
|
final email = user.email?.toLowerCase();
|
|
if (email != null) {
|
|
if (email.contains('bumdes')) {
|
|
return '38a8a23c-1873-4033-b977-3293247903b'; // PETUGAS_BUMDES
|
|
} else if (email.contains('mitra')) {
|
|
return '8b1af754-0866-4e12-a9d8-da8ed31bec15'; // PETUGAS_MITRA
|
|
}
|
|
}
|
|
|
|
// Default ke WARGA
|
|
return 'bb5360d5-8fd0-404e-8f6f-71ec4d8ad0ae'; // WARGA
|
|
} catch (e) {
|
|
debugPrint('Error fetching user role_id: $e');
|
|
// Default ke WARGA sebagai fallback
|
|
return 'bb5360d5-8fd0-404e-8f6f-71ec4d8ad0ae';
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan nama role dari tabel roles berdasarkan role_id
|
|
Future<String?> getRoleName(String roleId) async {
|
|
try {
|
|
debugPrint('Fetching role name for role_id: $roleId');
|
|
|
|
// Ambil nama role dari tabel roles
|
|
// ID di tabel roles adalah tipe UUID, pastikan format roleId sesuai
|
|
final roleData =
|
|
await client
|
|
.from('roles')
|
|
.select('nama_role, id')
|
|
.eq('id', roleId)
|
|
.maybeSingle();
|
|
|
|
debugPrint('Query result for roles table: $roleData');
|
|
|
|
if (roleData != null) {
|
|
// Cek berbagai kemungkinan nama kolom
|
|
String? roleName;
|
|
if (roleData.containsKey('nama_role')) {
|
|
roleName = roleData['nama_role'].toString();
|
|
} else if (roleData.containsKey('nama_role')) {
|
|
roleName = roleData['nama_role'].toString();
|
|
} else if (roleData.containsKey('role_name')) {
|
|
roleName = roleData['role_name'].toString();
|
|
}
|
|
|
|
if (roleName != null) {
|
|
debugPrint('Found role name in roles table: $roleName');
|
|
return roleName;
|
|
}
|
|
|
|
// Jika tidak ada nama kolom yang cocok, tampilkan kolom yang tersedia
|
|
debugPrint(
|
|
'Available columns in roles table: ${roleData.keys.join(', ')}',
|
|
);
|
|
}
|
|
|
|
// Lihat data lengkap tabel untuk troubleshooting
|
|
debugPrint('Getting all roles data for troubleshooting');
|
|
final allRoles = await client.from('roles').select('*').limit(5);
|
|
|
|
debugPrint('All roles table data (up to 5 rows): $allRoles');
|
|
|
|
// Hardcoded fallback berdasarkan UUID roleId yang dilihat dari data
|
|
debugPrint('Using hardcoded fallback for role_id: $roleId');
|
|
if (roleId == 'bb5360d5-8fd0-404e-8f6f-71ec4d8ad0ae') return 'WARGA';
|
|
if (roleId == '38a8a23c-1873-4033-b977-3293247903b') {
|
|
return 'PETUGAS_BUMDES';
|
|
}
|
|
if (roleId == '8b1af754-0866-4e12-a9d8-da8ed31bec15') {
|
|
return 'PETUGAS_MITRA';
|
|
}
|
|
|
|
// Default fallback jika role_id tidak dikenali
|
|
debugPrint('Unrecognized role_id: $roleId, defaulting to WARGA');
|
|
return 'WARGA';
|
|
} catch (e) {
|
|
debugPrint('Error fetching role name: $e');
|
|
return 'WARGA'; // Default fallback
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan nama lengkap dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserFullName() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting full name');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching nama_lengkap for user_id: ${user.id}');
|
|
|
|
// Coba ambil nama lengkap dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('nama_lengkap')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
debugPrint('User data from warga_desa table: $userData');
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('nama_lengkap')) {
|
|
final namaLengkap = userData['nama_lengkap']?.toString();
|
|
if (namaLengkap != null && namaLengkap.isNotEmpty) {
|
|
debugPrint('Found nama_lengkap: $namaLengkap');
|
|
return namaLengkap;
|
|
}
|
|
}
|
|
|
|
// Jika tidak ada data di warga_desa, coba cek struktur tabel untuk troubleshooting
|
|
debugPrint('Checking warga_desa table structure');
|
|
final tableData =
|
|
await client.from('warga_desa').select('*').limit(1).maybeSingle();
|
|
|
|
if (tableData != null) {
|
|
debugPrint(
|
|
'Available columns in warga_desa table: ${tableData.keys.join(', ')}',
|
|
);
|
|
} else {
|
|
debugPrint('No data found in warga_desa table');
|
|
}
|
|
|
|
// Fallback ke data dari Supabase Auth
|
|
final userMetadata = user.userMetadata;
|
|
if (userMetadata != null) {
|
|
if (userMetadata.containsKey('full_name')) {
|
|
return userMetadata['full_name']?.toString();
|
|
}
|
|
if (userMetadata.containsKey('name')) {
|
|
return userMetadata['name']?.toString();
|
|
}
|
|
}
|
|
|
|
// Gunakan email jika nama tidak ditemukan
|
|
return user.email?.split('@').first ?? 'Pengguna Warga';
|
|
} catch (e) {
|
|
debugPrint('Error fetching user full name: $e');
|
|
return 'Pengguna Warga'; // Default fallback
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan avatar dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserAvatar() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting avatar');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching avatar for user_id: ${user.id}');
|
|
|
|
// Coba ambil avatar dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('avatar')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
debugPrint('Avatar data from warga_desa table: $userData');
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('avatar')) {
|
|
final avatarUrl = userData['avatar']?.toString();
|
|
if (avatarUrl != null && avatarUrl.isNotEmpty) {
|
|
debugPrint('Found avatar URL: $avatarUrl');
|
|
return avatarUrl;
|
|
}
|
|
}
|
|
|
|
// Fallback ke data dari Supabase Auth
|
|
final userMetadata = user.userMetadata;
|
|
if (userMetadata != null && userMetadata.containsKey('avatar_url')) {
|
|
return userMetadata['avatar_url']?.toString();
|
|
}
|
|
|
|
return null; // No avatar found
|
|
} catch (e) {
|
|
debugPrint('Error fetching user avatar: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan email pengguna
|
|
Future<String?> getUserEmail() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting email');
|
|
return null;
|
|
}
|
|
|
|
// Email ada di data user Supabase Auth
|
|
return user.email;
|
|
}
|
|
|
|
// Metode untuk mendapatkan NIK dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserNIK() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting NIK');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching NIK for user_id: ${user.id}');
|
|
|
|
// Coba ambil NIK dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('nik')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('nik')) {
|
|
final nik = userData['nik']?.toString();
|
|
if (nik != null && nik.isNotEmpty) {
|
|
debugPrint('Found NIK: $nik');
|
|
return nik;
|
|
}
|
|
}
|
|
|
|
// Fallback ke data dari metadata
|
|
final userMetadata = user.userMetadata;
|
|
if (userMetadata != null && userMetadata.containsKey('nik')) {
|
|
return userMetadata['nik']?.toString();
|
|
}
|
|
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching user NIK: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan nomor telepon dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserPhone() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting phone');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching phone for user_id: ${user.id}');
|
|
|
|
// Coba ambil nomor telepon dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('no_hp')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
// Jika berhasil mendapatkan data, cek beberapa kemungkinan nama kolom
|
|
if (userData != null) {
|
|
if (userData.containsKey('no_hp')) {
|
|
final phone = userData['no_hp']?.toString();
|
|
if (phone != null && phone.isNotEmpty) return phone;
|
|
}
|
|
}
|
|
// Fallback ke data dari Supabase Auth
|
|
final userMetadata = user.userMetadata;
|
|
if (userMetadata != null) {
|
|
if (userMetadata.containsKey('phone')) {
|
|
return userMetadata['phone']?.toString();
|
|
}
|
|
if (userMetadata.containsKey('phone_number')) {
|
|
return userMetadata['phone_number']?.toString();
|
|
}
|
|
}
|
|
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching user phone: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan alamat dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserAddress() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting address');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching address for user_id: ${user.id}');
|
|
|
|
// Coba ambil alamat dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('alamat')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('alamat')) {
|
|
final address = userData['alamat']?.toString();
|
|
if (address != null && address.isNotEmpty) {
|
|
debugPrint('Found address: $address');
|
|
return address;
|
|
}
|
|
}
|
|
|
|
// Fallback ke data dari Supabase Auth
|
|
final userMetadata = user.userMetadata;
|
|
if (userMetadata != null && userMetadata.containsKey('address')) {
|
|
return userMetadata['address']?.toString();
|
|
}
|
|
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching user address: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan tanggal lahir dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserTanggalLahir() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting tanggal_lahir');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching tanggal_lahir for user_id: ${user.id}');
|
|
|
|
// Coba ambil tanggal lahir dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('tanggal_lahir')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('tanggal_lahir')) {
|
|
final tanggalLahir = userData['tanggal_lahir']?.toString();
|
|
if (tanggalLahir != null && tanggalLahir.isNotEmpty) {
|
|
debugPrint('Found tanggal_lahir: $tanggalLahir');
|
|
return tanggalLahir;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching user tanggal_lahir: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan RT/RW dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserRtRw() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting rt_rw');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching rt_rw for user_id: ${user.id}');
|
|
|
|
// Coba ambil RT/RW dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('rt_rw')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('rt_rw')) {
|
|
final rtRw = userData['rt_rw']?.toString();
|
|
if (rtRw != null && rtRw.isNotEmpty) {
|
|
debugPrint('Found rt_rw: $rtRw');
|
|
return rtRw;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching user rt_rw: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan kelurahan/desa dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserKelurahanDesa() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting kelurahan_desa');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching kelurahan_desa for user_id: ${user.id}');
|
|
|
|
// Coba ambil kelurahan/desa dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('kelurahan_desa')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('kelurahan_desa')) {
|
|
final kelurahanDesa = userData['kelurahan_desa']?.toString();
|
|
if (kelurahanDesa != null && kelurahanDesa.isNotEmpty) {
|
|
debugPrint('Found kelurahan_desa: $kelurahanDesa');
|
|
return kelurahanDesa;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching user kelurahan_desa: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Metode untuk mendapatkan kecamatan dari tabel warga_desa berdasarkan user_id
|
|
Future<String?> getUserKecamatan() async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting kecamatan');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
debugPrint('Fetching kecamatan for user_id: ${user.id}');
|
|
|
|
// Coba ambil kecamatan dari tabel warga_desa
|
|
final userData =
|
|
await client
|
|
.from('warga_desa')
|
|
.select('kecamatan')
|
|
.eq('user_id', user.id)
|
|
.maybeSingle();
|
|
|
|
// Jika berhasil mendapatkan data
|
|
if (userData != null && userData.containsKey('kecamatan')) {
|
|
final kecamatan = userData['kecamatan']?.toString();
|
|
if (kecamatan != null && kecamatan.isNotEmpty) {
|
|
debugPrint('Found kecamatan: $kecamatan');
|
|
return kecamatan;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching user kecamatan: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Mendapatkan data sewa_aset berdasarkan status (misal: MENUNGGU PEMBAYARAN, PEMBAYARANAN DENDA)
|
|
Future<List<Map<String, dynamic>>> getSewaAsetByStatus(
|
|
List<String> statuses,
|
|
) async {
|
|
final user = currentUser;
|
|
if (user == null) {
|
|
debugPrint('No current user found when getting sewa_aset by status');
|
|
return [];
|
|
}
|
|
try {
|
|
debugPrint(
|
|
'Fetching sewa_aset for user_id: ${user.id} with statuses: ${statuses.join(', ')}',
|
|
);
|
|
// Supabase expects the IN filter as a comma-separated string in parentheses
|
|
final statusString = '(${statuses.map((s) => '"$s"').join(',')})';
|
|
|
|
// Get sewa_aset records filtered by user_id and status
|
|
final response = await client
|
|
.from('sewa_aset')
|
|
.select('*')
|
|
.eq('user_id', user.id)
|
|
.filter('status', 'in', statusString)
|
|
.order('created_at', ascending: false);
|
|
|
|
debugPrint('Fetched sewa_aset count: ${response.length}');
|
|
|
|
// Process the response to handle package data
|
|
if (response is List) {
|
|
final List<Map<String, dynamic>> processedResponse = [];
|
|
|
|
for (var item in response) {
|
|
final Map<String, dynamic> processedItem = Map<String, dynamic>.from(
|
|
item,
|
|
);
|
|
|
|
// Ensure updated_at is not null, use created_at as fallback
|
|
if (processedItem['updated_at'] == null &&
|
|
processedItem['created_at'] != null) {
|
|
debugPrint('updated_at is null, using created_at as fallback');
|
|
processedItem['updated_at'] = processedItem['created_at'];
|
|
} else if (processedItem['updated_at'] == null &&
|
|
processedItem['created_at'] == null) {
|
|
// If both are null, use current timestamp as last resort
|
|
debugPrint(
|
|
'Both updated_at and created_at are null, using current timestamp',
|
|
);
|
|
processedItem['updated_at'] = DateTime.now().toIso8601String();
|
|
}
|
|
|
|
// Debug the updated_at field
|
|
debugPrint(
|
|
'updated_at after processing: ${processedItem['updated_at']}',
|
|
);
|
|
|
|
// If aset_id is null and paket_id is not null, fetch package data
|
|
if (item['aset_id'] == null && item['paket_id'] != null) {
|
|
final String paketId = item['paket_id'];
|
|
debugPrint(
|
|
'Found rental with paket_id: $paketId, fetching package details',
|
|
);
|
|
|
|
try {
|
|
// Get package name from paket table
|
|
final paketResponse =
|
|
await client
|
|
.from('paket')
|
|
.select('nama')
|
|
.eq('id', paketId)
|
|
.maybeSingle();
|
|
|
|
if (paketResponse != null && paketResponse['nama'] != null) {
|
|
processedItem['nama_paket'] = paketResponse['nama'];
|
|
debugPrint('Found package name: ${paketResponse['nama']}');
|
|
}
|
|
|
|
// Get package photo from foto_aset table
|
|
final fotoResponse =
|
|
await client
|
|
.from('foto_aset')
|
|
.select('foto_aset')
|
|
.eq('id_paket', paketId)
|
|
.limit(1)
|
|
.maybeSingle();
|
|
|
|
if (fotoResponse != null && fotoResponse['foto_aset'] != null) {
|
|
processedItem['foto_paket'] = fotoResponse['foto_aset'];
|
|
debugPrint('Found package photo: ${fotoResponse['foto_aset']}');
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Error fetching package details: $e');
|
|
}
|
|
}
|
|
|
|
processedResponse.add(processedItem);
|
|
}
|
|
|
|
return processedResponse;
|
|
} else {
|
|
return [];
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Error fetching sewa_aset by status: ${e.toString()}');
|
|
return [];
|
|
}
|
|
}
|
|
}
|