Vaibhav Surve
03b82764ed
- Updated AttendanceController to use Rx<DateTime> for date ranges. - Introduced DateRangePickerWidget for selecting date ranges in attendance and expense filters. - Refactored attendance filter bottom sheet to utilize the new DateRangePickerWidget. - Enhanced user document filter bottom sheet with date range selection. - Improved expense filter bottom sheet to include date range selection and refactored UI components for better readability. - Cleaned up unused code and improved overall code structure for maintainability.
412 lines
13 KiB
Dart
412 lines
13 KiB
Dart
import 'dart:io';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:image_picker/image_picker.dart';
|
|
import 'package:geolocator/geolocator.dart';
|
|
import 'package:intl/intl.dart';
|
|
|
|
import 'package:marco/helpers/services/app_logger.dart';
|
|
import 'package:marco/helpers/services/api_service.dart';
|
|
import 'package:marco/helpers/widgets/my_image_compressor.dart';
|
|
import 'package:marco/helpers/widgets/time_stamp_image_helper.dart';
|
|
|
|
import 'package:marco/model/attendance/attendance_model.dart';
|
|
import 'package:marco/model/project_model.dart';
|
|
import 'package:marco/model/employees/employee_model.dart';
|
|
import 'package:marco/model/attendance/attendance_log_model.dart';
|
|
import 'package:marco/model/regularization_log_model.dart';
|
|
import 'package:marco/model/attendance/attendance_log_view_model.dart';
|
|
import 'package:marco/model/attendance/organization_per_project_list_model.dart';
|
|
import 'package:marco/controller/project_controller.dart';
|
|
|
|
class AttendanceController extends GetxController {
|
|
// ------------------ Data Models ------------------
|
|
List<AttendanceModel> attendances = [];
|
|
List<ProjectModel> projects = [];
|
|
List<EmployeeModel> employees = [];
|
|
List<AttendanceLogModel> attendanceLogs = [];
|
|
List<RegularizationLogModel> regularizationLogs = [];
|
|
List<AttendanceLogViewModel> attendenceLogsView = [];
|
|
|
|
// ------------------ Organizations ------------------
|
|
List<Organization> organizations = [];
|
|
Organization? selectedOrganization;
|
|
final isLoadingOrganizations = false.obs;
|
|
|
|
// ------------------ States ------------------
|
|
String selectedTab = 'todaysAttendance';
|
|
|
|
// ✅ Reactive date range
|
|
final Rx<DateTime> startDateAttendance =
|
|
DateTime.now().subtract(const Duration(days: 7)).obs;
|
|
final Rx<DateTime> endDateAttendance =
|
|
DateTime.now().subtract(const Duration(days: 1)).obs;
|
|
|
|
final isLoading = true.obs;
|
|
final isLoadingProjects = true.obs;
|
|
final isLoadingEmployees = true.obs;
|
|
final isLoadingAttendanceLogs = true.obs;
|
|
final isLoadingRegularizationLogs = true.obs;
|
|
final isLoadingLogView = true.obs;
|
|
final uploadingStates = <String, RxBool>{}.obs;
|
|
var showPendingOnly = false.obs;
|
|
|
|
final searchQuery = ''.obs;
|
|
|
|
@override
|
|
void onInit() {
|
|
super.onInit();
|
|
_initializeDefaults();
|
|
}
|
|
|
|
void _initializeDefaults() {
|
|
_setDefaultDateRange();
|
|
}
|
|
|
|
void _setDefaultDateRange() {
|
|
final today = DateTime.now();
|
|
startDateAttendance.value = today.subtract(const Duration(days: 7));
|
|
endDateAttendance.value = today.subtract(const Duration(days: 1));
|
|
logSafe(
|
|
"Default date range set: ${startDateAttendance.value} to ${endDateAttendance.value}");
|
|
}
|
|
|
|
// ------------------ Computed Filters ------------------
|
|
List<EmployeeModel> get filteredEmployees {
|
|
if (searchQuery.value.isEmpty) return employees;
|
|
return employees
|
|
.where((e) =>
|
|
e.name.toLowerCase().contains(searchQuery.value.toLowerCase()))
|
|
.toList();
|
|
}
|
|
|
|
List<AttendanceLogModel> get filteredLogs {
|
|
if (searchQuery.value.isEmpty) return attendanceLogs;
|
|
return attendanceLogs
|
|
.where((log) =>
|
|
log.name.toLowerCase().contains(searchQuery.value.toLowerCase()))
|
|
.toList();
|
|
}
|
|
|
|
List<RegularizationLogModel> get filteredRegularizationLogs {
|
|
if (searchQuery.value.isEmpty) return regularizationLogs;
|
|
return regularizationLogs
|
|
.where((log) =>
|
|
log.name.toLowerCase().contains(searchQuery.value.toLowerCase()))
|
|
.toList();
|
|
}
|
|
|
|
// ------------------ Project & Employee APIs ------------------
|
|
Future<void> refreshDataFromNotification({String? projectId}) async {
|
|
projectId ??= Get.find<ProjectController>().selectedProject?.id;
|
|
if (projectId == null) {
|
|
logSafe("No project selected for attendance refresh from notification",
|
|
level: LogLevel.warning);
|
|
return;
|
|
}
|
|
await fetchProjectData(projectId);
|
|
logSafe(
|
|
"Attendance data refreshed from notification for project $projectId");
|
|
}
|
|
|
|
Future<void> fetchTodaysAttendance(String? projectId) async {
|
|
if (projectId == null) return;
|
|
|
|
isLoadingEmployees.value = true;
|
|
|
|
final response = await ApiService.getTodaysAttendance(
|
|
projectId,
|
|
organizationId: selectedOrganization?.id,
|
|
);
|
|
if (response != null) {
|
|
employees = response.map((e) => EmployeeModel.fromJson(e)).toList();
|
|
for (var emp in employees) {
|
|
uploadingStates[emp.id] = false.obs;
|
|
}
|
|
logSafe("Employees fetched: ${employees.length} for project $projectId");
|
|
} else {
|
|
logSafe("Failed to fetch employees for project $projectId",
|
|
level: LogLevel.error);
|
|
}
|
|
|
|
isLoadingEmployees.value = false;
|
|
update();
|
|
}
|
|
|
|
Future<void> fetchOrganizations(String projectId) async {
|
|
isLoadingOrganizations.value = true;
|
|
final response = await ApiService.getAssignedOrganizations(projectId);
|
|
if (response != null) {
|
|
organizations = response.data;
|
|
logSafe("Organizations fetched: ${organizations.length}");
|
|
} else {
|
|
logSafe("Failed to fetch organizations for project $projectId",
|
|
level: LogLevel.error);
|
|
}
|
|
isLoadingOrganizations.value = false;
|
|
update();
|
|
}
|
|
|
|
// ------------------ Attendance Capture ------------------
|
|
Future<bool> captureAndUploadAttendance(
|
|
String id,
|
|
String employeeId,
|
|
String projectId, {
|
|
String comment = "Marked via mobile app",
|
|
required int action,
|
|
bool imageCapture = true,
|
|
String? markTime,
|
|
String? date,
|
|
}) async {
|
|
try {
|
|
uploadingStates[employeeId]?.value = true;
|
|
|
|
XFile? image;
|
|
if (imageCapture) {
|
|
image = await ImagePicker()
|
|
.pickImage(source: ImageSource.camera, imageQuality: 80);
|
|
if (image == null) {
|
|
logSafe("Image capture cancelled.", level: LogLevel.warning);
|
|
return false;
|
|
}
|
|
|
|
final timestampedFile = await TimestampImageHelper.addTimestamp(
|
|
imageFile: File(image.path));
|
|
|
|
final compressedBytes =
|
|
await compressImageToUnder100KB(timestampedFile);
|
|
if (compressedBytes == null) {
|
|
logSafe("Image compression failed.", level: LogLevel.error);
|
|
return false;
|
|
}
|
|
|
|
final compressedFile = await saveCompressedImageToFile(compressedBytes);
|
|
image = XFile(compressedFile.path);
|
|
}
|
|
|
|
if (!await _handleLocationPermission()) return false;
|
|
final position = await Geolocator.getCurrentPosition(
|
|
desiredAccuracy: LocationAccuracy.high);
|
|
|
|
final imageName = imageCapture
|
|
? ApiService.generateImageName(employeeId, employees.length + 1)
|
|
: "";
|
|
|
|
final now = DateTime.now();
|
|
DateTime effectiveDate = now;
|
|
|
|
if (action == 1) {
|
|
final log = attendanceLogs.firstWhereOrNull(
|
|
(log) => log.employeeId == employeeId && log.checkOut == null,
|
|
);
|
|
if (log?.checkIn != null) effectiveDate = log!.checkIn!;
|
|
}
|
|
|
|
final formattedMarkTime = markTime ?? DateFormat('hh:mm a').format(now);
|
|
final formattedDate =
|
|
date ?? DateFormat('yyyy-MM-dd').format(effectiveDate);
|
|
|
|
final result = await ApiService.uploadAttendanceImage(
|
|
id,
|
|
employeeId,
|
|
image,
|
|
position.latitude,
|
|
position.longitude,
|
|
imageName: imageName,
|
|
projectId: projectId,
|
|
comment: comment,
|
|
action: action,
|
|
imageCapture: imageCapture,
|
|
markTime: formattedMarkTime,
|
|
date: formattedDate,
|
|
);
|
|
|
|
logSafe(
|
|
"Attendance uploaded for $employeeId, action: $action, date: $formattedDate");
|
|
return result;
|
|
} catch (e, stacktrace) {
|
|
logSafe("Error uploading attendance",
|
|
level: LogLevel.error, error: e, stackTrace: stacktrace);
|
|
return false;
|
|
} finally {
|
|
uploadingStates[employeeId]?.value = false;
|
|
}
|
|
}
|
|
|
|
Future<bool> _handleLocationPermission() async {
|
|
LocationPermission permission = await Geolocator.checkPermission();
|
|
|
|
if (permission == LocationPermission.denied) {
|
|
permission = await Geolocator.requestPermission();
|
|
if (permission == LocationPermission.denied) {
|
|
logSafe('Location permissions are denied', level: LogLevel.warning);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (permission == LocationPermission.deniedForever) {
|
|
logSafe('Location permissions are permanently denied',
|
|
level: LogLevel.error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ------------------ Attendance Logs ------------------
|
|
Future<void> fetchAttendanceLogs(String? projectId,
|
|
{DateTime? dateFrom, DateTime? dateTo}) async {
|
|
if (projectId == null) return;
|
|
|
|
isLoadingAttendanceLogs.value = true;
|
|
|
|
final response = await ApiService.getAttendanceLogs(
|
|
projectId,
|
|
dateFrom: dateFrom,
|
|
dateTo: dateTo,
|
|
organizationId: selectedOrganization?.id,
|
|
);
|
|
if (response != null) {
|
|
attendanceLogs =
|
|
response.map((e) => AttendanceLogModel.fromJson(e)).toList();
|
|
logSafe("Attendance logs fetched: ${attendanceLogs.length}");
|
|
} else {
|
|
logSafe("Failed to fetch attendance logs for project $projectId",
|
|
level: LogLevel.error);
|
|
}
|
|
|
|
isLoadingAttendanceLogs.value = false;
|
|
update();
|
|
}
|
|
|
|
Map<String, List<AttendanceLogModel>> groupLogsByCheckInDate() {
|
|
final groupedLogs = <String, List<AttendanceLogModel>>{};
|
|
|
|
for (var logItem in attendanceLogs) {
|
|
final checkInDate = logItem.checkIn != null
|
|
? DateFormat('dd MMM yyyy').format(logItem.checkIn!)
|
|
: 'Unknown';
|
|
groupedLogs.putIfAbsent(checkInDate, () => []).add(logItem);
|
|
}
|
|
|
|
final sortedEntries = groupedLogs.entries.toList()
|
|
..sort((a, b) {
|
|
if (a.key == 'Unknown') return 1;
|
|
if (b.key == 'Unknown') return -1;
|
|
final dateA = DateFormat('dd MMM yyyy').parse(a.key);
|
|
final dateB = DateFormat('dd MMM yyyy').parse(b.key);
|
|
return dateB.compareTo(dateA);
|
|
});
|
|
|
|
return Map<String, List<AttendanceLogModel>>.fromEntries(sortedEntries);
|
|
}
|
|
|
|
// ------------------ Regularization Logs ------------------
|
|
Future<void> fetchRegularizationLogs(String? projectId) async {
|
|
if (projectId == null) return;
|
|
|
|
isLoadingRegularizationLogs.value = true;
|
|
|
|
final response = await ApiService.getRegularizationLogs(
|
|
projectId,
|
|
organizationId: selectedOrganization?.id,
|
|
);
|
|
if (response != null) {
|
|
regularizationLogs =
|
|
response.map((e) => RegularizationLogModel.fromJson(e)).toList();
|
|
logSafe("Regularization logs fetched: ${regularizationLogs.length}");
|
|
} else {
|
|
logSafe("Failed to fetch regularization logs for project $projectId",
|
|
level: LogLevel.error);
|
|
}
|
|
|
|
isLoadingRegularizationLogs.value = false;
|
|
update();
|
|
}
|
|
|
|
// ------------------ Attendance Log View ------------------
|
|
Future<void> fetchLogsView(String? id) async {
|
|
if (id == null) return;
|
|
|
|
isLoadingLogView.value = true;
|
|
|
|
final response = await ApiService.getAttendanceLogView(id);
|
|
if (response != null) {
|
|
attendenceLogsView =
|
|
response.map((e) => AttendanceLogViewModel.fromJson(e)).toList();
|
|
attendenceLogsView.sort((a, b) => (b.activityTime ?? DateTime(2000))
|
|
.compareTo(a.activityTime ?? DateTime(2000)));
|
|
logSafe("Attendance log view fetched for ID: $id");
|
|
} else {
|
|
logSafe("Failed to fetch attendance log view for ID $id",
|
|
level: LogLevel.error);
|
|
}
|
|
|
|
isLoadingLogView.value = false;
|
|
update();
|
|
}
|
|
|
|
// ------------------ Combined Load ------------------
|
|
Future<void> loadAttendanceData(String projectId) async {
|
|
isLoading.value = true;
|
|
await fetchProjectData(projectId);
|
|
isLoading.value = false;
|
|
}
|
|
|
|
Future<void> fetchProjectData(String? projectId) async {
|
|
if (projectId == null) return;
|
|
|
|
await fetchOrganizations(projectId);
|
|
|
|
switch (selectedTab) {
|
|
case 'todaysAttendance':
|
|
await fetchTodaysAttendance(projectId);
|
|
break;
|
|
case 'attendanceLogs':
|
|
await fetchAttendanceLogs(
|
|
projectId,
|
|
dateFrom: startDateAttendance.value,
|
|
dateTo: endDateAttendance.value,
|
|
);
|
|
break;
|
|
case 'regularizationRequests':
|
|
await fetchRegularizationLogs(projectId);
|
|
break;
|
|
}
|
|
|
|
logSafe(
|
|
"Project data fetched for project ID: $projectId, tab: $selectedTab");
|
|
update();
|
|
}
|
|
|
|
// ------------------ UI Interaction ------------------
|
|
Future<void> selectDateRangeForAttendance(
|
|
BuildContext context, AttendanceController controller) async {
|
|
final today = DateTime.now();
|
|
|
|
final picked = await showDateRangePicker(
|
|
context: context,
|
|
firstDate: DateTime(2022),
|
|
lastDate: today.subtract(const Duration(days: 1)),
|
|
initialDateRange: DateTimeRange(
|
|
start: startDateAttendance.value,
|
|
end: endDateAttendance.value,
|
|
),
|
|
);
|
|
|
|
if (picked != null) {
|
|
startDateAttendance.value = picked.start;
|
|
endDateAttendance.value = picked.end;
|
|
|
|
logSafe(
|
|
"Date range selected: ${startDateAttendance.value} to ${endDateAttendance.value}");
|
|
|
|
await controller.fetchAttendanceLogs(
|
|
Get.find<ProjectController>().selectedProject?.id,
|
|
dateFrom: picked.start,
|
|
dateTo: picked.end,
|
|
);
|
|
}
|
|
}
|
|
}
|