authentication_repository_impl.dart

Go to the documentation of this file.

import 'dart:developer';
 
import 'package:aidra_drive/features/auth/domain/entities/session_entity.dart';
import 'package:dartz/dartz.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
 
import '../../../../core/isar/isar_local_database.dart';
import '../../../../core/isar/models/collections/cancellation_reason_isar_model.dart';
import '../../../../core/isar/models/collections/collection_rating_reason_isar_model.dart';
import '../../../../core/isar/models/collections/completed_collection_isar_model.dart';
import '../../../../core/isar/models/collections/restaurant_collection_contacts_isar_model.dart';
import '../../../../core/isar/models/collections/restaurant_partner_payments_isar_model.dart';
import '../../../../core/isar/models/history/pending_collection_isar_model.dart';
import '../../../../core/isar/models/collections/todo_collection_isar_model.dart';
import '../../../../core/isar/models/history/this_month_collection_isar_model.dart';
import '../../../../core/isar/models/history/this_week_collection_isar_model.dart';
import '../../../../core/services/user_info_service.dart';
import '../../domain/entities/credentials_entity.dart';
import '../datasources/remote_datasource/authentication_remote_datasource.dart';
import '../datasources/local_datasource/credentials_local_datasource.dart';
import '../datasources/local_datasource/session_local_datasource.dart';
import '../datasources/local_datasource/token_local_datasource.dart';
import '../../domain/repository/authentication_repository.dart';
import '../../../../core/error/exception_failure_adapter.dart';
import '../../../../core/services/service_locator.dart';
import '../../../../core/ui/theme/color_palette.dart';
import '../../../../core/error/failures.dart';
import '../datasources/remote_datasource/check_in_out_remote_datasource.dart';
import '../models/credentials_model.dart';
import '../models/session_model.dart';
import '../models/vehicle_check_model.dart';
import '../models/vehicle_model.dart';
 
class AuthenticationReposiptyImpl extends AuthenticationRepository {
  final _remoteDataSource = sl<AuthenticationRemoteDataSource>();
  final _credentialsLocalDataSource = sl<CredentialsLocalDataSource>();
  final _checkInOutDataSource = sl<CheckInOutRemoteDatasource>();
  final _tokenLocaldataDource = sl<TokenLocalDataSource>();
  final _sessionLocalDataSource = sl<SessionLocalDataSource>();
  final isar = IsarLocalDatabase.instance;
 
  @override
  Future<Either<Failure, SessionModel>> singIn({
    required CredentialsEntity reqEntity,
  }) async {
    try {
      final credentials = CredentialsModel(
        email: reqEntity.email,
        password: reqEntity.password,
      );
      final response = await _remoteDataSource.signInWithCredentials(
        credentials: credentials,
      );
      final session = SessionModel.fromJson(response);
      final token = session.token;
      await _sessionLocalDataSource.saveSession(session: session);
      await _tokenLocaldataDource.saveToken(token: token!);
      await _credentialsLocalDataSource.saveCredentials(
        credentials: credentials,
      );
 
      UserInfoService.instance.deleteUserInfo();
      await isar.clear<TodoCollectionIsarModel>();
      await isar.clear<CompletedCollectionIsarModel>();
      await isar.clear<PendingCollectionIsarModel>();
      await isar.clear<CancellationReasonIsarModel>();
      await isar.clear<RestaurantPartnerPaymentsIsarModel>();
      await isar.clear<RestaurantCollectionContactsIsarModel>();
      await isar.clear<CollectionRatingReasonIsarModel>();
      await isar.clear<ThisMonthCollectionIsarModel>();
      await isar.clear<ThisWeekCollectionIsarModel>();
 
      final isTodoCollectionsSavedInLocalDatabase = await saveTodoCollectionToLocalDatabase(
        userId: session.userContext?.uid ?? 0,
        type: 'todo'
      );
 
      final isCompletedCollectionsSavedInLocalDatabase = await saveCompletedCollectionToLocalDatabase(
        userId: session.userContext?.uid ?? 0,
      );
 
      final isPendingCollectionsSavedInLocalDatabase = await savePendingCollectionToLocalDatabase(
        userId: session.userContext?.uid ?? 0,
      );
 
      final isCollectionCancelationReasonsSavedInLocalDatabase = await saveCollectionCancelationReasonsToLocalDatabase();
 
      final isPartnerPaymentsSavedInLocalDatabase = await savePartnerPaymentsToLocalDatabase();
 
      final isPartnerContactsSavedInLocalDatabase = await savePartnerContactsToLocalDatabase();
 
      final isCollectionRatingReasonsSavedInLocalDatabase = await saveCollectionRatingReasonsToLocalDatabase();
 
      final isThisWeekHistorySavedInLocalDatabase = await saveThisWeekHistoryToLocalDatabase(
        userId: session.userContext?.uid ?? 0,
      );
 
      final isThisMonthHistorySavedInLocalDatabase = await saveThisMonthHistoryToLocalDatabase(
        userId: session.userContext?.uid ?? 0,
      );
 
      UserInfoService.instance.fetchAndSaveUserInfo(session.uid ?? 0);
 
      final test = isTodoCollectionsSavedInLocalDatabase;
      final test2 = isCompletedCollectionsSavedInLocalDatabase;
      final test3 = isPendingCollectionsSavedInLocalDatabase;
      final test4 = isCollectionCancelationReasonsSavedInLocalDatabase;
      final test5 = isPartnerPaymentsSavedInLocalDatabase;
      final test6 = isPartnerContactsSavedInLocalDatabase;
      final test7 = isCollectionRatingReasonsSavedInLocalDatabase;
      final test8 = isThisWeekHistorySavedInLocalDatabase;
      final test9 = isThisMonthHistorySavedInLocalDatabase;
 
      log("========= DATA DOWNLOADING =========");
      log("Todo Collections Saved In LocalDatabase: ${test.toString()}");
      log("Completed Collections Saved In LocalDatabase: ${test2.toString()}");
      log("Pending Collections Saved In LocalDatabase: ${test3.toString()}");
      log("Collection Cancelation Reasons Saved In LocalDatabase: ${test4.toString()}");
      log("Partner Payments Saved In LocalDatabase: ${test5.toString()}");
      log("Partner Contacts Saved In LocalDatabase: ${test6.toString()}");
      log("Collection Rating Reasons Saved In LocalDatabase: ${test7.toString()}");
      log("This Week-History Saved In LocalDatabase: ${test8.toString()}");
      log("This Month-History Saved In LocalDatabase: ${test9.toString()}");
      log("====================================");
 
      if (isTodoCollectionsSavedInLocalDatabase &&
       isCompletedCollectionsSavedInLocalDatabase &&
        isPendingCollectionsSavedInLocalDatabase &&
        isCollectionCancelationReasonsSavedInLocalDatabase &&
        isPartnerPaymentsSavedInLocalDatabase &&
        isPartnerContactsSavedInLocalDatabase &&
        isCollectionRatingReasonsSavedInLocalDatabase &&
        isThisWeekHistorySavedInLocalDatabase &&
        isThisMonthHistorySavedInLocalDatabase){
        return right(session);
      } else {
        await signOut();
        return left(
          ServerFailure(
            color: ColorPalette.red,
            message: "Please, try again",
          ),
        );
      }
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
 
  
 
  @override
  Future<Either<Failure, void>> signOut() async {
    try {
      await isar.clear<TodoCollectionIsarModel>();
      await isar.clear<CompletedCollectionIsarModel>();
      await isar.clear<PendingCollectionIsarModel>();
      await isar.clear<CancellationReasonIsarModel>();
      await isar.clear<RestaurantPartnerPaymentsIsarModel>();
      await isar.clear<RestaurantCollectionContactsIsarModel>();
      await isar.clear<CollectionRatingReasonIsarModel>();
      await isar.clear<ThisMonthCollectionIsarModel>();
      await isar.clear<ThisWeekCollectionIsarModel>();
      await _sessionLocalDataSource.deleteSession();
      await _tokenLocaldataDource.deleteToken();
      return right(null);
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
 
  @override
  Future<Either<Failure, SessionModel?>> loadSession() async {
    try {
      final user = await _sessionLocalDataSource.fetchSession();
      return right(user);
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
 
  @override
  Future<Either<Failure, CredentialsModel?>> loadCredentials() async {
    try {
      final credentials = await _credentialsLocalDataSource.fetchCredentials();
      return right(credentials);
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
 
  @override
  Future<Either<Failure, List<VehicleModel>>> getAvailableVehicles({required int userId}) async {
    try {
      final vehicles = await _checkInOutDataSource.getAvailableVehicles(userId: userId);
      return right(vehicles);
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
 
  @override
  Future<Either<Failure, bool>> vehicleCheck({required VehicleCheckModel vehicleCheckModel}) async {
    try {
      await _checkInOutDataSource.vehicleCheck(
        vehicleCheckModel: vehicleCheckModel,
      );
      
      final storage = const FlutterSecureStorage(
        aOptions: AndroidOptions(
          encryptedSharedPreferences: true,
        ),
        iOptions: IOSOptions(
          accessibility: KeychainAccessibility.first_unlock,
        ),
      );
      
 
      if (vehicleCheckModel.type == 'checkin') {
        await storage.write(key: 'is_checked_in', value: 'true');
      } else if (vehicleCheckModel.type == 'checkout') {
        await storage.delete(key: 'is_checked_in');
      }
      
      return right(true);
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
 
  @override
  Future<Either<Failure, bool>> checkBiometricAuthAvailability() async {
    try {
      final credentials = await _credentialsLocalDataSource.fetchCredentials();
      return right(credentials != null ? true : false);
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
 
  Future<bool> saveTodoCollectionToLocalDatabase({
    required int userId,
    required String? type,
  }) async {
    try {
      final todoCollection = await _remoteDataSource.getCollections(
        userId: userId,
        notForToday: false,
        type: type,
      );
      final isarTodoCollectionList = todoCollection.map(
        (e) => TodoCollectionIsarModel.fromModel(e)
      ).toList();
      await isar.putAll<TodoCollectionIsarModel>(isarTodoCollectionList);
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> saveCompletedCollectionToLocalDatabase({
    required int userId,
  }) async {
    try {
      final todoCollection = await _remoteDataSource.getCollections(
        userId: userId,
        notForToday: false,
        type: null,
      );
      final isarCompletedCollectionList = todoCollection.map(
        (e) => CompletedCollectionIsarModel.fromModel(e)
      ).toList();
      await isar.putAll<CompletedCollectionIsarModel>(isarCompletedCollectionList);
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> savePendingCollectionToLocalDatabase({
    required int userId,
  }) async {
    try {
      final pendingCollection = await _remoteDataSource.getCollections(
        userId: userId,
        notForToday: true,
        type: 'pending',
      );
      final isarPendingCollectionList = pendingCollection.map(
        (e) => PendingCollectionIsarModel.fromModel(e)
      ).toList();
      await isar.putAll<PendingCollectionIsarModel>(isarPendingCollectionList);
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> saveThisWeekHistoryToLocalDatabase({
    required int userId,
  }) async {
    try {
      final thisWeekHistory = await _remoteDataSource.getHistoryCollections(
        userId: userId,
        period: 'week'
      );
      final isarThisWeekCollectionList = thisWeekHistory.map(
        (e) => ThisWeekCollectionIsarModel.fromModel(e)
      ).toList();
      await isar.putAll<ThisWeekCollectionIsarModel>(isarThisWeekCollectionList);
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> saveThisMonthHistoryToLocalDatabase({
    required int userId,
  }) async {
    try {
      final thisMonthHistory = await _remoteDataSource.getHistoryCollections(
        userId: userId,
        period: 'month'
      );
      final isarThisMonthCollectionList = thisMonthHistory.map(
        (e) => ThisMonthCollectionIsarModel.fromModel(e)
      ).toList();
      await isar.putAll<ThisMonthCollectionIsarModel>(isarThisMonthCollectionList);
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> saveCollectionCancelationReasonsToLocalDatabase() async {
    try {
      final cancelationReasons = await _remoteDataSource.getCollectionCancelationReasons();
      final isarCancelationReasonsList = cancelationReasons.map(
        (e) => CancellationReasonIsarModel.fromModel(e)
      ).toList();
      await isar.putAll<CancellationReasonIsarModel>(isarCancelationReasonsList);
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> savePartnerPaymentsToLocalDatabase() async {
    try {
      final collections = await isar.getAll<TodoCollectionIsarModel>();
      
      for (final e in collections) {
        final paymentModeList = await _remoteDataSource.getCollectionPaymentModeList(
          restaurentId: e.restaurantId ?? 0,
        );
        RestaurantPartnerPaymentsIsarModel payment = RestaurantPartnerPaymentsIsarModel.fromModel(
          restaurantId: e.restaurantId ?? 0,
          payments: paymentModeList,
        );
        await isar.put<RestaurantPartnerPaymentsIsarModel>(payment);
      }
      
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> savePartnerContactsToLocalDatabase() async {
    try {
      final collections = await isar.getAll<TodoCollectionIsarModel>();
      
      for (final e in collections) {
        final contactsList = await _remoteDataSource.getCollectionContactList(
          restaurentId: e.restaurantId ?? 0,
        );
        RestaurantCollectionContactsIsarModel contact = RestaurantCollectionContactsIsarModel.fromModel(
          restaurantId: e.restaurantId ?? 0,
          contacts: contactsList,
        );
        await isar.put<RestaurantCollectionContactsIsarModel>(contact);
      }
      
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> saveCollectionRatingReasonsToLocalDatabase() async {
    try {
      final ratingReasons = await _remoteDataSource.getCollectionRatingReasons();
      final isarRatingReasonsList = ratingReasons.map(
        (e) => CollectionRatingReasonIsarModel.fromModel(e)
      ).toList();
      await isar.putAll<CollectionRatingReasonIsarModel>(isarRatingReasonsList);
      return true;
    } catch (e) {
      return false;
    }
  }
 
  @override
  Future<Either<Failure, SessionEntity>> fastSingIn({required CredentialsEntity reqEntity}) async {
    try {
      final credentials = CredentialsModel(
        email: reqEntity.email,
        password: reqEntity.password,
      );
      final response = await _remoteDataSource.signInWithCredentials(
        credentials: credentials,
      );
      final session = SessionModel.fromJson(response);
      final token = session.token;
      await _sessionLocalDataSource.saveSession(session: session);
      await _tokenLocaldataDource.saveToken(token: token!);
      await _credentialsLocalDataSource.saveCredentials(
        credentials: credentials,
      );
      return right(session);
    } catch (e) {
      return left(ExceptionFailureAdapter.adapt(e));
    }
  }
}