collection_repository_impl.dart

Go to the documentation of this file.

import 'package:dartz/dartz.dart';
import 'package:internet_connection_checker_plus/internet_connection_checker_plus.dart';
 
import '../../../../core/common/entities/collection_entity.dart';
import '../../../../core/error/exceptipns/server_exception.dart';
import '../../../../core/isar/isar_local_database.dart';
import '../../../../core/isar/models/collections/completed_collection_isar_model.dart';
import '../../../../core/isar/models/collections/todo_collection_isar_model.dart';
import '../../../../core/services/offline_sync_service.dart';
import '../../domain/entities/req/req_collection_confirmation_entity.dart';
import '../../domain/entities/req/req_collection_information_entity.dart';
import '../../domain/entities/req/req_collection_payment_entity.dart';
import '../../domain/entities/req/req_collection_rating_entity.dart';
import '../../domain/entities/req/req_collection_validation_entity.dart';
import '../../domain/entities/res/res_collection_confirmation_entity.dart';
import '../../domain/entities/res/res_collection_contact_entity.dart';
import '../../domain/entities/res/res_collection_information_entity.dart';
import '../../domain/entities/res/res_collection_rating_reason_entity.dart';
import '../../domain/entities/res/res_partner_payment_entity.dart';
import '../../domain/repositories/collection_repository.dart';
import '../datasources/collection_local_datasource.dart';
import '../datasources/collection_remote_datasource.dart';
import '../models/req/req_collection_confirmation_model.dart';
import '../models/req/req_collection_information_model.dart';
import '../models/req/req_collection_payment_model.dart';
import '../models/req/req_collection_rating_model.dart';
import '../models/req/req_collection_validation_model.dart';
import '../models/res/res_cancelation_reason_model.dart';
import '../models/res/res_collection_confirmation_model.dart';
import '../models/res/res_collection_information_model.dart';
import '../models/res/res_collection_rating_reason_model.dart';
import '../models/res/res_collection_status_model.dart';
import '../../../../core/ui/theme/color_palette.dart';
import '../../../../core/error/failures.dart';
import '../models/res/res_partner_payment_model.dart';
 
class CollectionsRepositoryImpl implements CollectionsRepository {
  final CollectionsRemoteDataSource remoteDataSource;
  final CollectionLocalDatasource localDatasource;
  final OfflineSyncService offlineSyncService = OfflineSyncService();
  final isar = IsarLocalDatabase.instance;
 
  CollectionsRepositoryImpl({
    required this.remoteDataSource,
    required this.localDatasource,
  });
 
  @override
  Future<Either<Failure, List<CollectionEntity>>> getCollections({
    required int userId,
    required bool notForToday,
    required String? type,
  }) async {
    try {
      await offlineSyncService.syncPendingOperations();
      List<CollectionEntity> result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      bool isOfflineOperationsSynced = await offlineSyncService.isAllOperationsSynced();
      if (hasInternetConnection && isOfflineOperationsSynced) {
        result = await remoteDataSource.getCollections(
          userId: userId,
          notForToday: notForToday,
          type: type,
        );
        if (notForToday == false && type =='todo'){
          await isar.clear<TodoCollectionIsarModel>();
          final todoIsarModelsList = result.map(
            (e) => TodoCollectionIsarModel.fromModel(e.toModel())
          ).toList();
          await isar.putAll<TodoCollectionIsarModel>(todoIsarModelsList);
        }
        if (notForToday == false && type == null) {
          await isar.clear<CompletedCollectionIsarModel>();
          final completedIsarModelsList = result.map(
            (e) => CompletedCollectionIsarModel.fromModel(e.toModel())
          ).toList();
          await isar.putAll<CompletedCollectionIsarModel>(completedIsarModelsList);
        }
      } else {
        result = await localDatasource.getCollections(notForToday: notForToday, type: type);
      }
      return right(result);
    } on ServerException catch (e) {
      return left(ServerFailure(message: e.message, color: ColorPalette.red));
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, ResCollectionStatusModel>> updateCollectionStatus({
    required int collectionId,
    required String status,
    required String? cancellationReasonId,
    required String reference,
  }) async {
    try {
      await offlineSyncService.syncPendingOperations();
      ResCollectionStatusModel result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if(hasInternetConnection) {
        result = await remoteDataSource.updateCollectionStatus(
          collectionId: collectionId,
          status: status,
          cancelationReasonId: cancellationReasonId,
        );
      } else {
        result = await localDatasource.updateCollectionStatus(
          collectionId: collectionId,
          status: status,
          reference: reference,
          cancelationReasonId: cancellationReasonId,
        );
      }
      return right(result);
    } on ServerException catch (e) {
      return left(ServerFailure(message: e.message, color: ColorPalette.red));
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, List<ResCancelationReasonModel>>> getCollectionCancellationReasons() async {
    try {
      List<ResCancelationReasonModel> result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        result = await remoteDataSource.getCollectionCancelationReasons();
      } else {
        result = await localDatasource.getCollectionCancelationReasons();
      }
      return right(result);
    } on ServerException catch (e) {
      return left(ServerFailure(message: e.message, color: ColorPalette.red));
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, ResCollectionInformationEntity>> sendCollectionsInformation({
    required ReqCollectionInformationEntity information,
    required String reference,
    required String address,
    required String restaurant,
    required int restaurantId,
  }) async {
    try {
      await offlineSyncService.syncPendingOperations();
      ResCollectionInformationModel result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      final model = ReqCollectionInformationModel.fromEntity(information);
      if (hasInternetConnection) {
        result = await remoteDataSource.sendCollectionsInformation(
          reqInformationCollectionModel: model,
        );
      } else {
        result = await localDatasource.sendCollectionInformation(
          model: model,
          address: address,
          reference: reference,
          restaurant: restaurant,
          restaurantId: restaurantId,
        );
      }
      return right(result);
    } on ServerException catch (e) {
      return left(ServerFailure(message: e.message, color: ColorPalette.red));
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
  
  @override
  Future<Either<Failure, bool>> validateCollection({required ReqCollectionValidationEntity validation}) async {
    try {
      await offlineSyncService.syncPendingOperations();
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        await remoteDataSource.validateCollection(
          reqValidationCollectionModel: ReqCollectionValidationModel.fromEntity(validation)
        );
      } else {
        await localDatasource.validateCollection(validateCollection: validation);
      }
      return right(true);
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, ResCollectionConfirmationEntity>> sendCollectionConfirmation({
    required ReqCollectionConfirmationEntity confirmation,
    required String address,
    required String reference,
    required String restaurant,
    required int? restaurantId,
    required double volumeCollected,
    required double volumeDeclared
  }) async {
    try {
      await offlineSyncService.syncPendingOperations();
      ResCollectionConfirmationModel result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        result = await remoteDataSource.sendCollectionConfirmation(
          reqCollectionConfirmationModel: ReqCollectionConfirmationModel.fromEntity(confirmation)
        );
      } else {
        result = await localDatasource.sendCollectionConfirmation(
          confirmation: confirmation,
          address: address,
          reference: reference,
          restaurant: restaurant,
          restaurantId: restaurantId,
          volumeCollected: volumeCollected,
          volumeDeclared: volumeDeclared,
        );
      }
      return right(result);
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, bool>> sendCollectionPayment({required ReqCollectionPaymentEntity payment}) async {
    try {
      await offlineSyncService.syncPendingOperations();
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        await remoteDataSource.sendCollectionPayment(
          reqCollectionPaymentModel: ReqCollectionPaymentModel.fromEntity(payment),
        );
      } else {
        await localDatasource.sendCollectionPayment(
          reqCollectionPaymentModel: ReqCollectionPaymentModel.fromEntity(payment),
        );
      }
      return right(true);
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, bool>> sendCollectionRating({required ReqCollectionRatingEntity rating}) async {
    try {
      await offlineSyncService.syncPendingOperations();
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        await remoteDataSource.sendCollectionRating(
          reqCollectionRatingModel: ReqCollectionRatingModel.fromEntity(rating),
        );
      } else {
        await localDatasource.sendCollectionRating(
          reqCollectionRatingModel: ReqCollectionRatingModel.fromEntity(rating),
        );
      }
      return right(true);
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, List<ResCollectionContactEntity>>> getCollectionContactList({required int restaurantId}) async {
    try {
      List<ResCollectionContactEntity> result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        result = await remoteDataSource.getCollectionContactList(restaurentId: restaurantId);
      } else {
        result = await localDatasource.getCollectionContactList(restaurentId: restaurantId);
      }
      return right(result);
    } on ServerException catch (e) {
      return left(ServerFailure(message: e.message, color: ColorPalette.red));
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
 
  @override
  Future<Either<Failure, List<ResCollectionRatingReasonEntity>>> getCollectionRatingReasons() async {
    try {
      List<ResCollectionRatingReasonModel> result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        result = await remoteDataSource.getRatingReasons();
      } else {
        result = await localDatasource.getRatingReasons();
      }
      return right(result);
    } on ServerException catch (e) {
      return left(ServerFailure(message: e.message, color: ColorPalette.red));
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
  
  @override
  Future<Either<Failure, List<ResPartnerPaymentEntity>>> getCollectionPaymentModeList({
    required int restaurentId,
  }) async {
    try {
      List<ResPartnerPaymentModel> result;
      bool hasInternetConnection = await InternetConnection().hasInternetAccess;
      if (hasInternetConnection) {
        result = await remoteDataSource.getCollectionPaymentModeList(restaurentId: restaurentId);
      } else {
        result = await localDatasource.getCollectionPaymentModeList(restaurentId: restaurentId);
      }
      return right(result);
    } on ServerException catch (e) {
      return left(ServerFailure(message: e.message, color: ColorPalette.red));
    } catch (e) {
      return left(ServerFailure(message: e.toString(), color: ColorPalette.red));
    }
  }
}