check_in_service.dart

Go to the documentation of this file.

import 'dart:developer';
 
import '../api/api_client.dart';
import '../api/api_endpoints.dart';
import '../common/models/check_in_status_model.dart';
import 'service_locator.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'dart:convert';
import 'package:geolocator/geolocator.dart';
 
class CheckInService {
  final ApiClient _apiClient = sl<ApiClient>();
  static const String _checkInStatusKey = 'check_in_status';
 
  CheckInService();
 
  Future<CheckInStatusModel?> getCheckInStatus({required int userId}) async {
    try {
      final url = ApiEndpoints.getCheckInStatus(userId: userId);
 
      final response = await _apiClient.get(path: url);
 
      if (response is Map && response.isEmpty) {
        return null;
      }
 
      return CheckInStatusModel.fromJson(response);
    } catch (e) {
      return null;
    }
  }
 
  // Save check-in status locally and send location to server
  Future<bool> saveCheckInStatus({
    required int vehicleId,
    required String immatriculation,
    required int driverId,
  }) async {
    try {
      // Get current location
      final position = await _getCurrentLocation();
      if (position == null) {
        return false;
      }
 
      // Send location to server with 'start' status
      final locationSent = await _sendLocationToServer(
        driverId: driverId,
        latitude: position.latitude,
        longitude: position.longitude,
        poId: null,
        poStatus: 'start',
      );
 
      if (!locationSent) {
        return false;
      }
 
      // Save check-in status locally only if server call succeeded
      final prefs = await SharedPreferences.getInstance();
      final checkInStatus = CheckInStatusModel(
        userId: driverId,
        vehicleId: vehicleId,
        immatriculation: immatriculation,
      );
 
      await prefs.setString(
          _checkInStatusKey, jsonEncode(checkInStatus.toJson()));
      return true;
    } catch (e) {
      log('Error saving check-in status: $e');
      return false;
    }
  }
 
  Future<Position?> _getCurrentLocation() async {
    try {
      bool serviceEnabled = await Geolocator.isLocationServiceEnabled();
      if (!serviceEnabled) {
        return null;
      }
 
      LocationPermission permission = await Geolocator.checkPermission();
      if (permission == LocationPermission.denied) {
        permission = await Geolocator.requestPermission();
        if (permission == LocationPermission.denied) {
          return null;
        }
      }
 
      if (permission == LocationPermission.deniedForever) {
        return null;
      }
 
      return await Geolocator.getCurrentPosition(
        locationSettings: const LocationSettings(
          accuracy: LocationAccuracy.high,
        ),
      );
    } catch (e) {
      log('Error getting current location: $e');
      return null;
    }
  }
 
  Future<bool> _sendLocationToServer({
    required int driverId,
    required double latitude,
    required double longitude,
    int? poId,
    String? poStatus,
  }) async {
    try {
      final data = {
        "driverId": driverId,
        "lag": latitude.toString(),
        "longitude": longitude.toString(),
        "poId": poId,
        "poStatus": poStatus,
      };
 
      final response = await _apiClient.post(
        url: ApiEndpoints.sendGeoLocation,
        data: data,
      );
 
      return response.isNotEmpty;
    } catch (e) {
      log('Error sending location to server: $e');
      return false;
    }
  }
 
  // Check if user is already checked in
  Future<bool> isUserCheckedIn() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      final statusJson = prefs.getString(_checkInStatusKey);
 
      return statusJson != null;
    } catch (e) {
      log('Error checking check-in status: $e');
      return false;
    }
  }
 
  // Clear check-in status (checkout)
  Future<void> clearCheckInStatus() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      await prefs.remove(_checkInStatusKey);
    } catch (e) {
      // Handle error silently
      log('Error clearing check-in status: $e');
    }
  }
}