collection_local_datasource.dart

Go to the documentation of this file.

// import '../../../../core/common/models/collection_model.dart';
import '../../../../core/common/enums/collection_status.dart';
import '../../../../core/common/models/collection_model.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/pending_collection_operation_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/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_validation_entity.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_status_model.dart';
import '../models/res/res_cancelation_reason_model.dart';
import '../models/res/res_collection_confirmation_model.dart';
import '../models/res/res_collection_contact_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 '../models/res/res_partner_payment_model.dart';
 
class CollectionLocalDatasource {
  final localDatabase = IsarLocalDatabase.instance;
  final offlineSyncService = OfflineSyncService();
 
  Future<ResCollectionStatusModel> updateCollectionStatus({
    required int collectionId,
    required String status,
    required String reference,
    String? cancelationReasonId
  }) async {
    try {
      await offlineSyncService.addPendingOperation(
        collectionId: collectionId,
        data: ReqCollectionStatusModel(
          id: collectionId.toString(),
          status: collectionStatusFromJson(status),
          cancellationReason: cancelationReasonId != null 
              ? ResCancelationReasonModel(
                id: int.tryParse(cancelationReasonId),
              ) 
              : null
        ).toJson(),
        operationOrder: 0,
        step: CollectionStep.statusUpdate,
      );
 
      if (cancelationReasonId != null && status == CollectionStatus.cancelled.value){
        final todoCollection = await localDatabase.get<TodoCollectionIsarModel>(collectionId);
        if (todoCollection != null){
          todoCollection.status = CollectionStatus.cancelled.value;
          await localDatabase.put<CompletedCollectionIsarModel>(todoCollection.toCompletedIsarModel());
          await localDatabase.delete<TodoCollectionIsarModel>(collectionId);
        }
      } else {
        final todoCollection = await localDatabase.get<TodoCollectionIsarModel>(collectionId);
        if (todoCollection != null){
          todoCollection.status = status;
          await localDatabase.put<TodoCollectionIsarModel>(todoCollection);
        }
      }
      
      return ResCollectionStatusModel(
        id: collectionId,
        reference: reference,
        status: collectionStatusFromJson(status),
        cancelationReason: null,
      );
    } catch (e) {
      rethrow;
    }
  }
 
  Future<void> validateCollection({
    required ReqCollectionValidationEntity validateCollection,
  }) async {
    await offlineSyncService.addPendingOperation(
      collectionId: int.tryParse(validateCollection.id ?? '') ?? 0,
      step: CollectionStep.validation,
      data: validateCollection.toJson(),
      operationOrder: 1,
    );
  }
 
  Future<ResCollectionInformationModel> sendCollectionInformation({
    required ReqCollectionInformationModel model,
    required String reference,
    required String address,
    required String restaurant,
    required int restaurantId,
  }) async {
    try {
      await offlineSyncService.addPendingOperation(
        collectionId: int.tryParse(model.id) ?? 0,
        step: CollectionStep.information,
        data: ReqCollectionInformationModel(
          id: model.id,
          collectionRequest: model.collectionRequest,
          depositedDrum: model.depositedDrum,
          recoveredDrum: model.recoveredDrum,
          userId: model.userId,
          volumeCollected: model.volumeCollected,
          volumeDeclared: model.volumeDeclared,
        ).toJson(),
        operationOrder: 2,
      );
 
      return ResCollectionInformationModel(
        id: int.tryParse(model.id) ?? 0,
        address: address,
        depositedDrum: model.depositedDrum,
        recoveredDrum: model.recoveredDrum,
        reference: reference,
        restaurant: restaurant,
        volume: double.tryParse(model.volumeDeclared) ?? 0.0,
        volumeCollected: double.tryParse(model.volumeCollected) ?? 0.0,
        restaurantId: restaurantId,
      );
    } catch (e) {
      rethrow;
    }
  }
 
  Future<ResCollectionConfirmationModel> 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.addPendingOperation(
        collectionId: int.tryParse(confirmation.id) ?? 0,
        step: CollectionStep.confirmation,
        data: ReqCollectionConfirmationModel(
          id: confirmation.id,
          containerImage: confirmation.containerImage,
          invoiceDateDue: confirmation.invoiceDateDue,
          userId: confirmation.userId,
          voucherImage: confirmation.voucherImage,
        ).toJson(),
        operationOrder: 3,
      );
 
      return ResCollectionConfirmationModel(
        id: int.tryParse(confirmation.id) ?? 0,
        address: address,
        reference: reference,
        restaurant: restaurant,
        restaurantId: restaurantId,
        volumeCollected: volumeCollected,
        volumeDeclared: volumeDeclared,
      );
    } catch (e) {
      rethrow;
    }
  }
 
  Future<List<ResCancelationReasonModel>> getCollectionCancelationReasons() async {
    final result = await localDatabase.getAll<CancellationReasonIsarModel>();
    final cancelationReasons = result.map((e) => e.toModel()).toList();
    return cancelationReasons;
  }
 
  Future<List<CollectionModel>> getCollections({
    required bool notForToday,
    required String? type,
  }) async {
    if (type == 'todo' && notForToday == false){
      final result = await localDatabase.getAll<TodoCollectionIsarModel>();
      final todoCollections = result.map((e) => e.toModel()).toList();
      return todoCollections;
    } else {
      final result = await localDatabase.getAll<CompletedCollectionIsarModel>();
      final completedCollections = result.map((e) => e.toModel()).toList();
      return completedCollections;
    }
  }
 
  Future<List<ResPartnerPaymentModel>> getCollectionPaymentModeList({
    required int restaurentId,
  }) async {
    final partnerPaymentsIsar = await localDatabase.getAll<RestaurantPartnerPaymentsIsarModel>();
    final result = partnerPaymentsIsar.where(
      (e) => e.restaurantId == restaurentId
    ).toList();
    final resPartnerPaymentModelList = result.first.partnerPayments?.map(
      (e) => e.toModel()
    ).toList();
    return resPartnerPaymentModelList ?? [];
  }
 
  Future<List<ResCollectionContactModel>> getCollectionContactList({
    required int restaurentId,
  }) async {
    final partnerContactsIsar = await localDatabase.getAll<RestaurantCollectionContactsIsarModel>();
    final result = partnerContactsIsar.where(
      (e) => e.restaurantId == restaurentId
    ).toList();
    final resPartnerContactsList = result.first.collectionContacts?.map(
      (e) => e.toModel()
    ).toList();
    return resPartnerContactsList ?? [];
  }
 
  Future<void> sendCollectionPayment({
    required ReqCollectionPaymentModel reqCollectionPaymentModel,
  }) async {
    await offlineSyncService.addPendingOperation(
      collectionId: int.parse(reqCollectionPaymentModel.id),
      data: reqCollectionPaymentModel.toJson(),
      operationOrder: 4,
      step: CollectionStep.payment,
    );
  }
 
  Future<List<ResCollectionRatingReasonModel>> getRatingReasons() async {
    final result = await localDatabase.getAll<CollectionRatingReasonIsarModel>();
    final ratingReasons = result.map((e) => e.toModel()).toList();
    return ratingReasons;
  }
 
  Future<void> sendCollectionRating({
    required ReqCollectionRatingModel reqCollectionRatingModel,
  }) async {
    await offlineSyncService.addPendingOperation(
      collectionId: int.parse(reqCollectionRatingModel.id),
      data: reqCollectionRatingModel.toJson(),
      operationOrder: 5,
      step: CollectionStep.rating,
    );
    final todoCollection = await localDatabase.get<TodoCollectionIsarModel>(
      int.parse(reqCollectionRatingModel.id),
    );
    if (todoCollection != null){
      todoCollection.status = CollectionStatus.done.value;
      await localDatabase.put<CompletedCollectionIsarModel>(todoCollection.toCompletedIsarModel());
      await localDatabase.delete<TodoCollectionIsarModel>(int.parse(reqCollectionRatingModel.id));
    }
  }
}