1100 lines
37 KiB
Dart
1100 lines
37 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:supabase_flutter/supabase_flutter.dart';
|
|
import '../models/aset_model.dart';
|
|
import '../models/foto_aset_model.dart';
|
|
import '../models/satuan_waktu_model.dart';
|
|
import '../models/satuan_waktu_sewa_model.dart';
|
|
import 'package:intl/intl.dart';
|
|
|
|
class AsetProvider extends GetxService {
|
|
late final SupabaseClient client;
|
|
|
|
AsetProvider() {
|
|
client = Supabase.instance.client;
|
|
}
|
|
|
|
// Mendapatkan semua aset dengan kategori "sewa"
|
|
Future<List<AsetModel>> getSewaAsets() async {
|
|
try {
|
|
debugPrint('Fetching aset with kategori: sewa');
|
|
|
|
// Query untuk mendapatkan semua aset dengan kategori "sewa"
|
|
final response = await client
|
|
.from('aset')
|
|
.select('*')
|
|
.eq('kategori', 'sewa')
|
|
.eq('status', 'tersedia') // Hanya yang tersedia
|
|
.order('nama', ascending: true); // Urutan berdasarkan nama
|
|
|
|
debugPrint('Fetched ${response.length} aset');
|
|
|
|
// Konversi response ke list AsetModel
|
|
List<AsetModel> asets =
|
|
response.map<AsetModel>((item) => AsetModel.fromJson(item)).toList();
|
|
|
|
// Untuk setiap aset, ambil foto pertama dan satuan waktu sewa
|
|
for (var aset in asets) {
|
|
await _attachFirstPhoto(aset);
|
|
await attachSatuanWaktuSewa(aset);
|
|
}
|
|
|
|
return asets;
|
|
} catch (e) {
|
|
debugPrint('Error fetching aset: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Mendapatkan semua aset dengan kategori "langganan"
|
|
Future<List<AsetModel>> getLanggananAsets() async {
|
|
try {
|
|
debugPrint('Fetching aset with kategori: langganan');
|
|
|
|
// Query untuk mendapatkan semua aset dengan kategori "langganan"
|
|
final response = await client
|
|
.from('aset')
|
|
.select('*')
|
|
.eq('kategori', 'langganan')
|
|
.eq('status', 'tersedia') // Hanya yang tersedia
|
|
.order('nama', ascending: true); // Urutan berdasarkan nama
|
|
|
|
debugPrint('Fetched ${response.length} langganan aset');
|
|
|
|
// Konversi response ke list AsetModel
|
|
List<AsetModel> asets =
|
|
response.map<AsetModel>((item) => AsetModel.fromJson(item)).toList();
|
|
|
|
// Untuk setiap aset, ambil foto pertama dan satuan waktu sewa
|
|
for (var aset in asets) {
|
|
await _attachFirstPhoto(aset);
|
|
await attachSatuanWaktuSewa(aset);
|
|
}
|
|
|
|
return asets;
|
|
} catch (e) {
|
|
debugPrint('Error fetching langganan asets: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Mendapatkan aset berdasarkan ID
|
|
Future<AsetModel?> getAsetById(String asetId) async {
|
|
try {
|
|
debugPrint('📂 Fetching aset with ID: $asetId');
|
|
|
|
// Query untuk mendapatkan aset dengan ID tertentu
|
|
final response =
|
|
await client.from('aset').select('*').eq('id', asetId).maybeSingle();
|
|
|
|
debugPrint('📂 Raw response type: ${response.runtimeType}');
|
|
debugPrint('📂 Raw response: $response');
|
|
|
|
if (response == null) {
|
|
debugPrint('❌ Aset dengan ID $asetId tidak ditemukan');
|
|
return null;
|
|
}
|
|
|
|
debugPrint(
|
|
'✅ Successfully fetched aset with ID: $asetId, name: ${response['nama']}',
|
|
);
|
|
|
|
// Konversi response ke AsetModel
|
|
AsetModel aset = AsetModel.fromJson(response);
|
|
debugPrint('✅ AsetModel created: ${aset.id} - ${aset.nama}');
|
|
|
|
// Ambil foto dan satuan waktu sewa untuk aset ini
|
|
await _attachFirstPhoto(aset);
|
|
await attachSatuanWaktuSewa(aset);
|
|
await loadAssetPhotos(aset);
|
|
|
|
return aset;
|
|
} catch (e, stackTrace) {
|
|
debugPrint('❌ Error fetching aset by ID: $e');
|
|
debugPrint('❌ StackTrace: $stackTrace');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Load all photos for an asset
|
|
Future<void> loadAssetPhotos(AsetModel aset) async {
|
|
try {
|
|
final photos = await getAsetPhotos(aset.id);
|
|
if (photos.isNotEmpty &&
|
|
(aset.imageUrl == null || aset.imageUrl!.isEmpty)) {
|
|
aset.imageUrl = photos.first.fotoAset;
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Error loading asset photos for ID ${aset.id}: $e');
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk mengambil foto pertama dari aset
|
|
Future<void> _attachFirstPhoto(AsetModel aset) async {
|
|
try {
|
|
final responsePhoto =
|
|
await client
|
|
.from('foto_aset')
|
|
.select('*')
|
|
.eq('id_aset', aset.id)
|
|
.limit(1)
|
|
.maybeSingle();
|
|
|
|
if (responsePhoto != null) {
|
|
final fotoAset = FotoAsetModel.fromJson(responsePhoto);
|
|
aset.imageUrl = fotoAset.fotoAset;
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Error fetching photo for aset ${aset.id}: $e');
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk mendapatkan semua foto aset berdasarkan ID aset
|
|
Future<List<FotoAsetModel>> getAsetPhotos(String asetId) async {
|
|
try {
|
|
debugPrint('Fetching photos for aset ID: $asetId');
|
|
|
|
final response = await client
|
|
.from('foto_aset')
|
|
.select('*')
|
|
.eq('id_aset', asetId)
|
|
.order('created_at');
|
|
|
|
debugPrint('Fetched ${response.length} photos for aset ID: $asetId');
|
|
|
|
// Konversi response ke list FotoAsetModel
|
|
return (response as List)
|
|
.map<FotoAsetModel>((item) => FotoAsetModel.fromJson(item))
|
|
.toList();
|
|
} catch (e) {
|
|
debugPrint('Error fetching photos for aset ID $asetId: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Retrieve bookings for a specific asset on a specific date
|
|
Future<List<Map<String, dynamic>>> getAsetBookings(
|
|
String asetId,
|
|
String date,
|
|
) async {
|
|
try {
|
|
// Convert the date to DateTime for comparison
|
|
final targetDate = DateTime.parse(date);
|
|
debugPrint('🔍 Fetching bookings for asset $asetId on date $date');
|
|
|
|
// Query booked_detail table (previously was sewa_aset table) for bookings related to this asset
|
|
final response = await client
|
|
.from('booked_detail')
|
|
.select('id, waktu_mulai, waktu_selesai, sewa_aset_id, kuantitas')
|
|
.eq('aset_id', asetId)
|
|
.order('waktu_mulai', ascending: true);
|
|
|
|
// Filter bookings to only include those that overlap with our target date
|
|
final bookingsForDate =
|
|
response.where((booking) {
|
|
if (booking['waktu_mulai'] == null ||
|
|
booking['waktu_selesai'] == null) {
|
|
debugPrint('⚠️ Booking has null timestamp: $booking');
|
|
return false;
|
|
}
|
|
|
|
// Parse the timestamps
|
|
final DateTime waktuMulai = DateTime.parse(booking['waktu_mulai']);
|
|
final DateTime waktuSelesai = DateTime.parse(
|
|
booking['waktu_selesai'],
|
|
);
|
|
|
|
// Check if booking overlaps with our target date
|
|
final bookingStartDate = DateTime(
|
|
waktuMulai.year,
|
|
waktuMulai.month,
|
|
waktuMulai.day,
|
|
);
|
|
final bookingEndDate = DateTime(
|
|
waktuSelesai.year,
|
|
waktuSelesai.month,
|
|
waktuSelesai.day,
|
|
);
|
|
|
|
final targetDateOnly = DateTime(
|
|
targetDate.year,
|
|
targetDate.month,
|
|
targetDate.day,
|
|
);
|
|
|
|
// The booking overlaps with our target date if:
|
|
// 1. The booking starts on or before our target date AND
|
|
// 2. The booking ends on or after our target date
|
|
return !bookingStartDate.isAfter(targetDateOnly) &&
|
|
!bookingEndDate.isBefore(targetDateOnly);
|
|
}).toList();
|
|
|
|
debugPrint(
|
|
'📅 Found ${bookingsForDate.length} bookings for date $date from booked_detail table',
|
|
);
|
|
|
|
// Return the complete booking information with original timestamps
|
|
return bookingsForDate.map((booking) {
|
|
// Parse the timestamps for debugging
|
|
final DateTime waktuMulai = DateTime.parse(booking['waktu_mulai']);
|
|
final DateTime waktuSelesai = DateTime.parse(booking['waktu_selesai']);
|
|
|
|
// Return the full booking data with formatted display times
|
|
return {
|
|
'id':
|
|
booking['sewa_aset_id'] ??
|
|
booking['id'], // Use sewa_aset_id as id if available
|
|
'waktu_mulai': booking['waktu_mulai'], // Keep original ISO timestamp
|
|
'waktu_selesai':
|
|
booking['waktu_selesai'], // Keep original ISO timestamp
|
|
'jam_mulai': DateFormat('HH:mm').format(waktuMulai), // For display
|
|
'jam_selesai': DateFormat(
|
|
'HH:mm',
|
|
).format(waktuSelesai), // For display
|
|
'tanggal_mulai': DateFormat(
|
|
'yyyy-MM-dd',
|
|
).format(waktuMulai), // For calculations
|
|
'tanggal_selesai': DateFormat(
|
|
'yyyy-MM-dd',
|
|
).format(waktuSelesai), // For calculations
|
|
'kuantitas':
|
|
booking['kuantitas'] ?? 1, // Default to 1 if not specified
|
|
};
|
|
}).toList();
|
|
} catch (e) {
|
|
debugPrint('❌ Error getting asset bookings: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk membuat pesanan sewa aset
|
|
Future<bool> createSewaAsetOrder(Map<String, dynamic> orderData) async {
|
|
try {
|
|
debugPrint('🔄 Creating sewa_aset order with data:');
|
|
orderData.forEach((key, value) {
|
|
debugPrint(' $key: $value');
|
|
});
|
|
|
|
final response =
|
|
await client.from('sewa_aset').insert(orderData).select().single();
|
|
|
|
debugPrint('✅ Order created successfully: ${response['id']}');
|
|
return true;
|
|
} catch (e) {
|
|
debugPrint('❌ Error creating sewa_aset order: $e');
|
|
debugPrint('❌ Stack trace: ${StackTrace.current}');
|
|
|
|
// Check for specific error types
|
|
if (e.toString().contains('duplicate key')) {
|
|
debugPrint('❌ This appears to be a duplicate key error');
|
|
} else if (e.toString().contains('violates foreign key constraint')) {
|
|
debugPrint('❌ This appears to be a foreign key constraint violation');
|
|
} else if (e.toString().contains('violates not-null constraint')) {
|
|
debugPrint('❌ This appears to be a null value in a required field');
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk membuat tagihan sewa
|
|
Future<bool> createTagihanSewa(Map<String, dynamic> tagihanData) async {
|
|
try {
|
|
debugPrint('🔄 Creating tagihan_sewa with data:');
|
|
tagihanData.forEach((key, value) {
|
|
debugPrint(' $key: $value');
|
|
});
|
|
|
|
// Ensure we don't try to insert a nama_aset field that no longer exists
|
|
if (tagihanData.containsKey('nama_aset')) {
|
|
debugPrint(
|
|
'⚠️ Removing nama_aset field from tagihan_sewa data as it does not exist in the table',
|
|
);
|
|
tagihanData.remove('nama_aset');
|
|
}
|
|
|
|
final response =
|
|
await client
|
|
.from('tagihan_sewa')
|
|
.insert(tagihanData)
|
|
.select()
|
|
.single();
|
|
|
|
debugPrint('✅ Tagihan created successfully: ${response['id']}');
|
|
return true;
|
|
} catch (e) {
|
|
debugPrint('❌ Error creating tagihan_sewa: $e');
|
|
debugPrint('❌ Stack trace: ${StackTrace.current}');
|
|
|
|
// Check for specific error types
|
|
if (e.toString().contains('duplicate key')) {
|
|
debugPrint('❌ This appears to be a duplicate key error');
|
|
} else if (e.toString().contains('violates foreign key constraint')) {
|
|
debugPrint('❌ This appears to be a foreign key constraint violation');
|
|
} else if (e.toString().contains('violates not-null constraint')) {
|
|
debugPrint('❌ This appears to be a null value in a required field');
|
|
} else if (e.toString().contains('Could not find the')) {
|
|
debugPrint(
|
|
'❌ This appears to be a column mismatch error - check field names',
|
|
);
|
|
// Print the field names from the data to help debug
|
|
debugPrint('❌ Fields in provided data: ${tagihanData.keys.toList()}');
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk membuat booked detail
|
|
Future<bool> createBookedDetail(Map<String, dynamic> bookedDetailData) async {
|
|
try {
|
|
debugPrint('🔄 Creating booked_detail with data:');
|
|
bookedDetailData.forEach((key, value) {
|
|
debugPrint(' $key: $value');
|
|
});
|
|
|
|
// Ensure we don't try to insert a status field that no longer exists
|
|
if (bookedDetailData.containsKey('status')) {
|
|
debugPrint(
|
|
'⚠️ Removing status field from booked_detail data as it does not exist in the table',
|
|
);
|
|
bookedDetailData.remove('status');
|
|
}
|
|
|
|
final response =
|
|
await client
|
|
.from('booked_detail')
|
|
.insert(bookedDetailData)
|
|
.select()
|
|
.single();
|
|
|
|
debugPrint('✅ Booked detail created successfully: ${response['id']}');
|
|
return true;
|
|
} catch (e) {
|
|
debugPrint('❌ Error creating booked_detail: $e');
|
|
debugPrint('❌ Stack trace: ${StackTrace.current}');
|
|
|
|
// Check for specific error types
|
|
if (e.toString().contains('duplicate key')) {
|
|
debugPrint('❌ This appears to be a duplicate key error');
|
|
} else if (e.toString().contains('violates foreign key constraint')) {
|
|
debugPrint('❌ This appears to be a foreign key constraint violation');
|
|
} else if (e.toString().contains('violates not-null constraint')) {
|
|
debugPrint('❌ This appears to be a null value in a required field');
|
|
} else if (e.toString().contains('Could not find the')) {
|
|
debugPrint(
|
|
'❌ This appears to be a column mismatch error - check field names',
|
|
);
|
|
// Print the field names from the data to help debug
|
|
debugPrint(
|
|
'❌ Fields in provided data: ${bookedDetailData.keys.toList()}',
|
|
);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk membuat pesanan lengkap (sewa_aset, booked_detail, dan tagihan_sewa) dalam satu operasi
|
|
Future<bool> createCompleteOrder({
|
|
required Map<String, dynamic> sewaAsetData,
|
|
required Map<String, dynamic> bookedDetailData,
|
|
required Map<String, dynamic> tagihanSewaData,
|
|
}) async {
|
|
try {
|
|
debugPrint('🔄 Creating complete order with transaction');
|
|
debugPrint('📦 sewa_aset data:');
|
|
sewaAsetData.forEach((key, value) => debugPrint(' $key: $value'));
|
|
|
|
debugPrint('📦 booked_detail data:');
|
|
bookedDetailData.forEach((key, value) => debugPrint(' $key: $value'));
|
|
|
|
// Ensure we don't try to insert a status field that no longer exists
|
|
if (bookedDetailData.containsKey('status')) {
|
|
debugPrint(
|
|
'⚠️ Removing status field from booked_detail data as it does not exist in the table',
|
|
);
|
|
bookedDetailData.remove('status');
|
|
}
|
|
|
|
debugPrint('📦 tagihan_sewa data:');
|
|
tagihanSewaData.forEach((key, value) => debugPrint(' $key: $value'));
|
|
|
|
// Ensure we don't try to insert a nama_aset field that no longer exists
|
|
if (tagihanSewaData.containsKey('nama_aset')) {
|
|
debugPrint(
|
|
'⚠️ Removing nama_aset field from tagihan_sewa data as it does not exist in the table',
|
|
);
|
|
tagihanSewaData.remove('nama_aset');
|
|
}
|
|
|
|
// Insert all three records
|
|
final sewaAsetResult =
|
|
await client.from('sewa_aset').insert(sewaAsetData).select().single();
|
|
debugPrint('✅ sewa_aset created: ${sewaAsetResult['id']}');
|
|
|
|
final bookedDetailResult =
|
|
await client
|
|
.from('booked_detail')
|
|
.insert(bookedDetailData)
|
|
.select()
|
|
.single();
|
|
debugPrint('✅ booked_detail created: ${bookedDetailResult['id']}');
|
|
|
|
final tagihanSewaResult =
|
|
await client
|
|
.from('tagihan_sewa')
|
|
.insert(tagihanSewaData)
|
|
.select()
|
|
.single();
|
|
debugPrint('✅ tagihan_sewa created: ${tagihanSewaResult['id']}');
|
|
|
|
debugPrint('✅ Complete order created successfully!');
|
|
return true;
|
|
} catch (e) {
|
|
debugPrint('❌ Error creating complete order: $e');
|
|
debugPrint('❌ Stack trace: ${StackTrace.current}');
|
|
|
|
// Check for specific error types
|
|
if (e.toString().contains('duplicate key')) {
|
|
debugPrint('❌ This appears to be a duplicate key error');
|
|
} else if (e.toString().contains('violates foreign key constraint')) {
|
|
debugPrint('❌ This appears to be a foreign key constraint violation');
|
|
} else if (e.toString().contains('violates not-null constraint')) {
|
|
debugPrint('❌ This appears to be a null value in a required field');
|
|
} else if (e.toString().contains('Could not find the')) {
|
|
debugPrint(
|
|
'❌ This appears to be a column mismatch error - check field names',
|
|
);
|
|
// Print the field names from each data object to help debug
|
|
debugPrint('❌ Fields in sewa_aset data: ${sewaAsetData.keys.toList()}');
|
|
debugPrint(
|
|
'❌ Fields in booked_detail data: ${bookedDetailData.keys.toList()}',
|
|
);
|
|
debugPrint(
|
|
'❌ Fields in tagihan_sewa data: ${tagihanSewaData.keys.toList()}',
|
|
);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk mendapatkan data satuan waktu berdasarkan ID dari tabel `satuan_waktu`
|
|
Future<SatuanWaktuModel?> getSatuanWaktuById(String id) async {
|
|
try {
|
|
// Asumsikan client adalah instance Supabase (atau library serupa)
|
|
final response =
|
|
await client
|
|
.from('satuan_waktu')
|
|
.select('*')
|
|
.eq('id', id)
|
|
.maybeSingle();
|
|
|
|
if (response == null) {
|
|
debugPrint('Tidak ditemukan data satuan waktu untuk id: $id');
|
|
return null;
|
|
}
|
|
|
|
return SatuanWaktuModel.fromJson(response);
|
|
} catch (e) {
|
|
debugPrint('Error fetching satuan waktu by id: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk mendapatkan semua data satuan waktu dari tabel `satuan_waktu`
|
|
// Biasanya digunakan untuk menampilkan pilihan pada form atau filter
|
|
Future<List<SatuanWaktuModel>> getAllSatuanWaktu() async {
|
|
try {
|
|
final response = await client
|
|
.from('satuan_waktu')
|
|
.select('*')
|
|
.order('nama_satuan_waktu', ascending: true);
|
|
|
|
// Pastikan response berupa list
|
|
return (response as List)
|
|
.map<SatuanWaktuModel>((item) => SatuanWaktuModel.fromJson(item))
|
|
.toList();
|
|
} catch (e) {
|
|
debugPrint('Error fetching all satuan waktu: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk mendapatkan data satuan waktu sewa untuk suatu aset tertentu
|
|
// Data diambil dari tabel `satuan_waktu_sewa` dan langsung melakukan join ke tabel `satuan_waktu`
|
|
Future<List<Map<String, dynamic>>> getSatuanWaktuSewa(String asetId) async {
|
|
try {
|
|
debugPrint('Fetching satuan waktu sewa for aset $asetId with join...');
|
|
|
|
// Query untuk mendapatkan data dari satuan_waktu_sewa dengan join ke satuan_waktu
|
|
final response = await client
|
|
.from('satuan_waktu_sewa')
|
|
.select('''
|
|
id,
|
|
aset_id,
|
|
satuan_waktu_id,
|
|
harga,
|
|
denda,
|
|
maksimal_waktu,
|
|
satuan_waktu:satuan_waktu_id(id, nama_satuan_waktu)
|
|
''')
|
|
.eq('aset_id', asetId);
|
|
|
|
debugPrint('Join query raw response type: ${response.runtimeType}');
|
|
debugPrint('Join query raw response: $response');
|
|
|
|
List<Map<String, dynamic>> result = [];
|
|
|
|
debugPrint('Response is List with ${response.length} items');
|
|
for (var item in response) {
|
|
try {
|
|
debugPrint('Processing item: $item');
|
|
|
|
// Pengecekan null dan tipe data yang lebih aman
|
|
var satuanWaktu = item['satuan_waktu'];
|
|
String namaSatuanWaktu = '';
|
|
|
|
if (satuanWaktu != null) {
|
|
if (satuanWaktu is Map) {
|
|
// Jika satuan_waktu adalah Map
|
|
namaSatuanWaktu =
|
|
satuanWaktu['nama_satuan_waktu']?.toString() ?? '';
|
|
} else if (satuanWaktu is List && satuanWaktu.isNotEmpty) {
|
|
// Jika satuan_waktu adalah List
|
|
var firstItem = satuanWaktu.first;
|
|
if (firstItem is Map) {
|
|
namaSatuanWaktu =
|
|
firstItem['nama_satuan_waktu']?.toString() ?? '';
|
|
}
|
|
}
|
|
}
|
|
|
|
final resultItem = {
|
|
'id': item['id']?.toString() ?? '',
|
|
'aset_id': item['aset_id']?.toString() ?? '',
|
|
'satuan_waktu_id': item['satuan_waktu_id']?.toString() ?? '',
|
|
'harga': item['harga'] ?? 0,
|
|
'denda': item['denda'] ?? 0,
|
|
'maksimal_waktu': item['maksimal_waktu'] ?? 0,
|
|
'nama_satuan_waktu': namaSatuanWaktu,
|
|
};
|
|
|
|
debugPrint('Successfully processed item: $resultItem');
|
|
result.add(resultItem);
|
|
} catch (e) {
|
|
debugPrint('Error processing item: $e');
|
|
debugPrint('Item data: $item');
|
|
}
|
|
}
|
|
|
|
debugPrint(
|
|
'Processed ${result.length} satuan waktu sewa records for aset $asetId',
|
|
);
|
|
return result;
|
|
} catch (e) {
|
|
debugPrint('Error fetching satuan waktu sewa for aset $asetId: $e');
|
|
debugPrint('Stack trace: ${StackTrace.current}');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk melampirkan data satuan waktu sewa ke model aset secara langsung
|
|
// Fungsi ini akan dipanggil misalnya saat Anda memuat detail aset atau list aset
|
|
Future<void> attachSatuanWaktuSewa(AsetModel aset) async {
|
|
try {
|
|
debugPrint(
|
|
'Attaching satuan waktu sewa to aset ${aset.id} (${aset.nama})',
|
|
);
|
|
|
|
// Ambil semua data satuan waktu sewa untuk aset tersebut
|
|
final satuanWaktuSewaList = await getSatuanWaktuSewa(aset.id);
|
|
|
|
// Urutkan data satuan waktu sewa, Jam dulu, kemudian Hari, kemudian lainnya
|
|
satuanWaktuSewaList.sort((a, b) {
|
|
final namaA = (a['nama_satuan_waktu'] ?? '').toString().toLowerCase();
|
|
final namaB = (b['nama_satuan_waktu'] ?? '').toString().toLowerCase();
|
|
|
|
// Jika ada 'jam', tempatkan di urutan pertama
|
|
if (namaA.contains('jam') && !namaB.contains('jam')) {
|
|
return -1;
|
|
}
|
|
// Jika ada 'hari', tempatkan di urutan kedua
|
|
else if (!namaA.contains('jam') &&
|
|
namaA.contains('hari') &&
|
|
!namaB.contains('jam') &&
|
|
!namaB.contains('hari')) {
|
|
return -1;
|
|
}
|
|
// Jika keduanya 'jam' atau keduanya 'hari' atau keduanya lainnya, pertahankan urutan asli
|
|
else if ((namaA.contains('jam') && namaB.contains('jam')) ||
|
|
(namaA.contains('hari') && namaB.contains('hari'))) {
|
|
return 0;
|
|
}
|
|
// Jika b adalah 'jam', tempatkan b lebih dulu
|
|
else if (!namaA.contains('jam') && namaB.contains('jam')) {
|
|
return 1;
|
|
}
|
|
// Jika b adalah 'hari' dan a bukan 'jam', tempatkan b lebih dulu
|
|
else if (!namaA.contains('jam') &&
|
|
!namaA.contains('hari') &&
|
|
!namaB.contains('jam') &&
|
|
namaB.contains('hari')) {
|
|
return 1;
|
|
}
|
|
// Default, pertahankan urutan
|
|
return 0;
|
|
});
|
|
|
|
debugPrint('Sorted satuan waktu sewa list: $satuanWaktuSewaList');
|
|
|
|
// Bersihkan data lama dan masukkan data baru
|
|
aset.satuanWaktuSewa.clear();
|
|
aset.satuanWaktuSewa.addAll(satuanWaktuSewaList);
|
|
|
|
// Debug: tampilkan data satuan waktu sewa yang berhasil dilampirkan
|
|
if (satuanWaktuSewaList.isNotEmpty) {
|
|
debugPrint(
|
|
'Attached ${satuanWaktuSewaList.length} satuan waktu sewa to aset ${aset.id}:',
|
|
);
|
|
for (var sws in satuanWaktuSewaList) {
|
|
debugPrint(
|
|
' - ID: ${sws['id']}, Harga: ${sws['harga']}, Satuan Waktu: ${sws['nama_satuan_waktu']} (${sws['satuan_waktu_id']})',
|
|
);
|
|
}
|
|
} else {
|
|
debugPrint('No satuan waktu sewa found for aset ${aset.id}');
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Error attaching satuan waktu sewa: $e');
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk memformat harga ke format rupiah (contoh: Rp 3.000)
|
|
String formatPrice(int price) {
|
|
// RegExp untuk menambahkan titik sebagai pemisah ribuan
|
|
return 'Rp ${price.toString().replaceAllMapped(RegExp(r'(\d{1,3})(?=(\d{3})+(?!\d))'), (Match m) => '${m[1]}.')}';
|
|
}
|
|
|
|
String _formatNumber(dynamic number) {
|
|
if (number == null) return '0';
|
|
|
|
// Pastikan angka dikonversi ke string
|
|
var numStr = number.toString();
|
|
|
|
// Tangani kasus ketika number bukan angka
|
|
try {
|
|
return numStr.replaceAllMapped(
|
|
RegExp(r'(\d{1,3})(?=(\d{3})+(?!\d))'),
|
|
(Match match) => '${match[1]}.',
|
|
);
|
|
} catch (e) {
|
|
return numStr;
|
|
}
|
|
}
|
|
|
|
// Method untuk pemesanan aset
|
|
Future<bool> orderAset({
|
|
required String userId,
|
|
required String asetId,
|
|
required String satuanWaktuSewaId,
|
|
required int durasi,
|
|
required int totalHarga,
|
|
}) async {
|
|
try {
|
|
debugPrint('Creating order for aset $asetId by user $userId');
|
|
|
|
// Dapatkan tanggal hari ini
|
|
final tanggalPemesanan = DateTime.now().toIso8601String();
|
|
|
|
// Buat pesanan baru
|
|
final response =
|
|
await client
|
|
.from('pesanan')
|
|
.insert({
|
|
'user_id': userId,
|
|
'aset_id': asetId,
|
|
'satuan_waktu_sewa_id': satuanWaktuSewaId,
|
|
'tanggal_pemesanan': tanggalPemesanan,
|
|
'durasi': durasi,
|
|
'total_harga': totalHarga,
|
|
'status': 'pending', // Status awal pesanan
|
|
})
|
|
.select('id')
|
|
.single();
|
|
|
|
// Periksa apakah pesanan berhasil dibuat
|
|
if (response['id'] != null) {
|
|
debugPrint('Order created successfully with ID: ${response['id']}');
|
|
return true;
|
|
} else {
|
|
debugPrint('Failed to create order: Response is null or missing ID');
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Error creating order: $e');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Get daily bookings for an asset for a date range
|
|
Future<List<Map<String, dynamic>>> getAsetDailyBookings(
|
|
String asetId,
|
|
String startDate,
|
|
String endDate,
|
|
) async {
|
|
try {
|
|
debugPrint(
|
|
'🔍 Fetching daily bookings for asset $asetId from $startDate to $endDate from booked_detail table',
|
|
);
|
|
|
|
// Parse dates for comparison
|
|
final startDateTime = DateTime.parse(startDate);
|
|
final endDateTime = DateTime.parse(endDate);
|
|
|
|
// Query booked_detail table (previously was sewa_aset table) for daily bookings related to this asset
|
|
final response = await client
|
|
.from('booked_detail')
|
|
.select('id, waktu_mulai, waktu_selesai, sewa_aset_id, kuantitas')
|
|
.eq('aset_id', asetId)
|
|
.order('waktu_mulai', ascending: true);
|
|
|
|
// Filter bookings that overlap with the requested date range
|
|
final List<Map<String, dynamic>> bookingsInRange =
|
|
response.where((booking) {
|
|
if (booking['waktu_mulai'] == null ||
|
|
booking['waktu_selesai'] == null) {
|
|
debugPrint('⚠️ Booking has null dates: $booking');
|
|
return false;
|
|
}
|
|
|
|
// Parse the dates
|
|
final DateTime bookingStartDate = DateTime.parse(
|
|
booking['waktu_mulai'],
|
|
);
|
|
final DateTime bookingEndDate = DateTime.parse(
|
|
booking['waktu_selesai'],
|
|
);
|
|
|
|
// A booking overlaps with our date range if:
|
|
// 1. The booking ends after or on our start date AND
|
|
// 2. The booking starts before or on our end date
|
|
return !bookingEndDate.isBefore(startDateTime) &&
|
|
!bookingStartDate.isAfter(endDateTime);
|
|
}).toList();
|
|
|
|
debugPrint(
|
|
'📅 Found ${bookingsInRange.length} bookings in the specified range from booked_detail table',
|
|
);
|
|
|
|
// Debug the booking details
|
|
if (bookingsInRange.isNotEmpty) {
|
|
for (var booking in bookingsInRange) {
|
|
debugPrint(
|
|
'📋 Booking ID: ${booking['sewa_aset_id'] ?? booking['id']}',
|
|
);
|
|
debugPrint(' - Start: ${booking['waktu_mulai']}');
|
|
debugPrint(' - End: ${booking['waktu_selesai']}');
|
|
debugPrint(' - Quantity: ${booking['kuantitas']}');
|
|
}
|
|
}
|
|
|
|
return bookingsInRange.map((booking) {
|
|
final Map<String, dynamic> result = Map<String, dynamic>.from(booking);
|
|
// Use sewa_aset_id as the id if available
|
|
if (booking['sewa_aset_id'] != null) {
|
|
result['id'] = booking['sewa_aset_id'];
|
|
}
|
|
return result;
|
|
}).toList();
|
|
} catch (e) {
|
|
debugPrint('❌ Error getting daily bookings: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
bool _isBeforeToday(DateTime date) {
|
|
final today = DateTime.now();
|
|
final todayDate = DateTime(today.year, today.month, today.day);
|
|
final checkDate = DateTime(date.year, date.month, date.day);
|
|
// Return true if date is today or before today (meaning it should be disabled)
|
|
return !checkDate.isAfter(todayDate);
|
|
}
|
|
|
|
// Get tagihan sewa by sewa_aset_id
|
|
Future<Map<String, dynamic>?> getTagihanSewa(String sewaAsetId) async {
|
|
try {
|
|
debugPrint('🔍 Fetching tagihan sewa for sewa_aset_id: $sewaAsetId');
|
|
|
|
final response =
|
|
await client
|
|
.from('tagihan_sewa')
|
|
.select('*')
|
|
.eq('sewa_aset_id', sewaAsetId)
|
|
.maybeSingle();
|
|
|
|
if (response == null) {
|
|
debugPrint('⚠️ No tagihan sewa found for sewa_aset_id: $sewaAsetId');
|
|
return null;
|
|
}
|
|
|
|
debugPrint('✅ Tagihan sewa found: ${response['id']}');
|
|
return response;
|
|
} catch (e) {
|
|
debugPrint('❌ Error fetching tagihan sewa: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Get bank accounts from akun_bank table
|
|
Future<List<Map<String, dynamic>>> getBankAccounts() async {
|
|
try {
|
|
debugPrint('🔍 Fetching bank accounts from akun_bank table');
|
|
|
|
final response = await client
|
|
.from('akun_bank')
|
|
.select('*')
|
|
.order('nama_bank', ascending: true);
|
|
|
|
debugPrint('✅ Fetched ${response.length} bank accounts');
|
|
|
|
// Convert response to List<Map<String, dynamic>>
|
|
List<Map<String, dynamic>> accounts = List<Map<String, dynamic>>.from(response);
|
|
|
|
return accounts;
|
|
} catch (e) {
|
|
debugPrint('❌ Error fetching bank accounts: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Get sewa_aset details with aset data
|
|
Future<Map<String, dynamic>?> getSewaAsetWithAsetData(
|
|
String sewaAsetId,
|
|
) async {
|
|
try {
|
|
debugPrint('🔍 Fetching sewa_aset with aset data for id: $sewaAsetId');
|
|
|
|
// First get the sewa_aset record
|
|
debugPrint('📊 Executing query: FROM sewa_aset WHERE id = $sewaAsetId');
|
|
final sewaResponse =
|
|
await client
|
|
.from('sewa_aset')
|
|
.select('*')
|
|
.eq('id', sewaAsetId)
|
|
.maybeSingle();
|
|
|
|
if (sewaResponse == null) {
|
|
debugPrint('⚠️ No sewa_aset found with id: $sewaAsetId');
|
|
return null;
|
|
}
|
|
|
|
debugPrint('📋 Raw sewa_aset response:');
|
|
sewaResponse.forEach((key, value) {
|
|
debugPrint(' $key: $value');
|
|
});
|
|
|
|
// Get the aset_id from the sewa_aset record
|
|
final asetId = sewaResponse['aset_id'];
|
|
if (asetId == null) {
|
|
debugPrint('⚠️ sewa_aset record has no aset_id');
|
|
return sewaResponse;
|
|
}
|
|
|
|
debugPrint('🔍 Found aset_id: $asetId, now fetching aset details');
|
|
|
|
// Get the aset details
|
|
final asetResponse =
|
|
await client.from('aset').select('*').eq('id', asetId).maybeSingle();
|
|
|
|
if (asetResponse == null) {
|
|
debugPrint('⚠️ No aset found with id: $asetId');
|
|
return sewaResponse;
|
|
}
|
|
|
|
// Combine the data
|
|
final result = Map<String, dynamic>.from(sewaResponse);
|
|
result['aset_detail'] = asetResponse;
|
|
|
|
debugPrint('✅ Combined sewa_aset and aset data successfully');
|
|
debugPrint('📋 Final combined data:');
|
|
result.forEach((key, value) {
|
|
if (key != 'aset_detail') {
|
|
// Skip the nested object for clearer output
|
|
debugPrint(' $key: $value');
|
|
}
|
|
});
|
|
|
|
// Specifically check waktu_mulai and waktu_selesai
|
|
debugPrint('⏰ CRITICAL TIME FIELDS CHECK:');
|
|
debugPrint(' waktu_mulai exists: ${result.containsKey('waktu_mulai')}');
|
|
debugPrint(' waktu_mulai value: ${result['waktu_mulai']}');
|
|
debugPrint(
|
|
' waktu_selesai exists: ${result.containsKey('waktu_selesai')}',
|
|
);
|
|
debugPrint(' waktu_selesai value: ${result['waktu_selesai']}');
|
|
|
|
return result;
|
|
} catch (e) {
|
|
debugPrint('❌ Error fetching sewa_aset with aset data: $e');
|
|
debugPrint(' Stack trace: ${StackTrace.current}');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Fungsi untuk mengambil foto pertama dari paket
|
|
Future<String?> _getFirstPaketPhoto(String paketId) async {
|
|
try {
|
|
debugPrint('Fetching first photo for paket ID: $paketId');
|
|
final responsePhoto =
|
|
await client
|
|
.from('foto_aset')
|
|
.select('*')
|
|
.eq('id_paket', paketId)
|
|
.limit(1)
|
|
.maybeSingle();
|
|
|
|
if (responsePhoto != null) {
|
|
debugPrint(
|
|
'Found photo for paket $paketId: ${responsePhoto['foto_aset']}',
|
|
);
|
|
return responsePhoto['foto_aset'];
|
|
}
|
|
return null;
|
|
} catch (e) {
|
|
debugPrint('Error fetching photo for paket $paketId: $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Get all photos for a paket using id_paket column
|
|
Future<List<dynamic>> getFotoPaket(String paketId) async {
|
|
try {
|
|
debugPrint('📷 Fetching all photos for paket ID: $paketId');
|
|
|
|
final response = await client
|
|
.from('foto_aset')
|
|
.select('*')
|
|
.eq('id_paket', paketId);
|
|
|
|
if (response.isEmpty) {
|
|
debugPrint('⚠️ No photos found for paket $paketId');
|
|
return [];
|
|
}
|
|
|
|
debugPrint('✅ Found ${response.length} photos for paket $paketId');
|
|
return response;
|
|
} catch (e) {
|
|
debugPrint('❌ Error fetching photos for paket $paketId: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Get paket data with their associated satuan waktu sewa data
|
|
Future<List<dynamic>> getPakets() async {
|
|
try {
|
|
final response = await client
|
|
.from('paket')
|
|
.select('*')
|
|
.order('created_at');
|
|
final List<dynamic> pakets = response;
|
|
|
|
// Fetch satuan waktu sewa data for each paket
|
|
for (var paket in pakets) {
|
|
// Fetch the first photo for this paket
|
|
final paketId = paket['id'];
|
|
final photoUrl = await _getFirstPaketPhoto(paketId);
|
|
if (photoUrl != null) {
|
|
paket['gambar_url'] = photoUrl;
|
|
}
|
|
|
|
final swsResponse = await client
|
|
.from('satuan_waktu_sewa')
|
|
.select('*, satuan_waktu(id, nama_satuan_waktu)')
|
|
.eq('paket_id', paket['id']);
|
|
|
|
// Transform the response to include nama_satuan_waktu
|
|
final List<Map<String, dynamic>> formattedSWS = [];
|
|
for (var sws in swsResponse) {
|
|
final Map<String, dynamic> formattedItem = {...sws};
|
|
if (sws['satuan_waktu'] != null) {
|
|
formattedItem['nama_satuan_waktu'] =
|
|
sws['satuan_waktu']['nama_satuan_waktu'];
|
|
}
|
|
formattedSWS.add(formattedItem);
|
|
}
|
|
|
|
paket['satuanWaktuSewa'] = formattedSWS;
|
|
}
|
|
|
|
return pakets;
|
|
} catch (e) {
|
|
debugPrint('Error getting pakets: $e');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
// Order a paket
|
|
Future<bool> orderPaket({
|
|
required String userId,
|
|
required String paketId,
|
|
required String satuanWaktuSewaId,
|
|
required int durasi,
|
|
required int totalHarga,
|
|
}) async {
|
|
try {
|
|
// Get satuan waktu sewa details to determine waktu_mulai and waktu_selesai
|
|
final swsResponse =
|
|
await client
|
|
.from('satuan_waktu_sewa')
|
|
.select('*, satuan_waktu(id, nama)')
|
|
.eq('id', satuanWaktuSewaId)
|
|
.single();
|
|
|
|
// Calculate waktu_mulai and waktu_selesai based on satuan waktu
|
|
final DateTime now = DateTime.now();
|
|
final DateTime waktuMulai = now.add(Duration(days: 1)); // Start tomorrow
|
|
|
|
// Default to hourly if not specified
|
|
String satuanWaktu = 'jam';
|
|
if (swsResponse != null &&
|
|
swsResponse['satuan_waktu'] != null &&
|
|
swsResponse['satuan_waktu']['nama'] != null) {
|
|
satuanWaktu = swsResponse['satuan_waktu']['nama'];
|
|
}
|
|
|
|
// Calculate waktu_selesai based on satuan waktu and durasi
|
|
DateTime waktuSelesai;
|
|
if (satuanWaktu.toLowerCase() == 'hari') {
|
|
waktuSelesai = waktuMulai.add(Duration(days: durasi));
|
|
} else {
|
|
waktuSelesai = waktuMulai.add(Duration(hours: durasi));
|
|
}
|
|
|
|
// Create the order
|
|
final sewa = {
|
|
'user_id': userId,
|
|
'paket_id': paketId,
|
|
'satuan_waktu_sewa_id': satuanWaktuSewaId,
|
|
'kuantitas': 1, // Default to 1 for packages
|
|
'durasi': durasi,
|
|
'total_harga': totalHarga,
|
|
'status': 'MENUNGGU_PEMBAYARAN',
|
|
'waktu_mulai': waktuMulai.toIso8601String(),
|
|
'waktu_selesai': waktuSelesai.toIso8601String(),
|
|
};
|
|
|
|
final response = await client.from('sewa_paket').insert(sewa).select();
|
|
|
|
if (response != null && response.isNotEmpty) {
|
|
return true;
|
|
}
|
|
return false;
|
|
} catch (e) {
|
|
debugPrint('Error ordering paket: $e');
|
|
return false;
|
|
}
|
|
}
|
|
}
|