offline_sync_service.dart

Go to the documentation of this file.

import 'dart:convert';
import 'package:internet_connection_checker_plus/internet_connection_checker_plus.dart';
import 'package:isar/isar.dart';
import '../../features/collections/data/models/req/req_collection_confirmation_model.dart';
import '../../features/collections/data/models/req/req_collection_information_model.dart';
import '../../features/collections/data/models/req/req_collection_payment_model.dart';
import '../../features/collections/data/models/req/req_collection_rating_model.dart';
import '../../features/collections/data/models/req/req_collection_validation_model.dart';
import '../isar/isar_local_database.dart';
import '../isar/models/collections/pending_collection_operation_isar_model.dart';
import '../../features/collections/data/datasources/collection_remote_datasource.dart';
import '../../core/services/service_locator.dart';
 
class OfflineSyncService {
  final _localDatabase = IsarLocalDatabase.instance;
  final _remoteDataSource = sl<CollectionsRemoteDataSource>();
 
  Future<bool> isAllOperationsSynced() async {
    final pendingOperations = await _localDatabase
        .collection<PendingCollectionOperationIsarModel>()
        .where()
        .filter()
        .isSyncedEqualTo(false)
        .count();
    
    return pendingOperations == 0;
  }
 
  Future<bool> isOperationsSynced(int collectionId) async {
    final pendingOperations = await _localDatabase
        .collection<PendingCollectionOperationIsarModel>()
        .where()
        .filter()
        .collectionIdEqualTo(collectionId)
        .isSyncedEqualTo(false)
        .count();
    
    return pendingOperations == 0;
  }
 
  Future<CollectionStep> getOperationCurrentStep(int collectionId) async {
    final latestOperation = await _localDatabase
        .collection<PendingCollectionOperationIsarModel>()
        .where()
        .filter()
        .collectionIdEqualTo(collectionId)
        .isSyncedEqualTo(false)
        .sortByTimestampDesc()
        .findFirst();
    
    return latestOperation?.step ?? CollectionStep.statusUpdate;
  }
 
  Future<void> addPendingOperation({
    required int collectionId,
    required CollectionStep step,
    required Map<String, dynamic> data,
    required int operationOrder,
  }) async {
    // Check if operation already exists
    final existingOperation = await _localDatabase
        .collection<PendingCollectionOperationIsarModel>()
        .where()
        .filter()
        .collectionIdEqualTo(collectionId)
        .stepEqualTo(step)
        .findFirst();
    
    if (existingOperation != null && existingOperation.isSynced) return;
 
    if (existingOperation != null) {
      // Update existing operation
      existingOperation.payload = jsonEncode(data);
      existingOperation.operationOrder = operationOrder;
      existingOperation.timestamp = DateTime.now();
      existingOperation.isSynced = false;
      
      await _localDatabase.put<PendingCollectionOperationIsarModel>(existingOperation);
    } else {
      // Create new operation
      final operation = PendingCollectionOperationIsarModel(
        collectionId: collectionId,
        step: step,
        payload: jsonEncode(data),
        operationOrder: operationOrder,
        timestamp: DateTime.now(),
        isSynced: false
      );
      
      await _localDatabase.put<PendingCollectionOperationIsarModel>(operation);
    }
  }
  
  Future<void> syncPendingOperations() async {
    final hasInternet = await InternetConnection().hasInternetAccess;
    if (!hasInternet) return;
 
    // Get all unique collection IDs that have pending operations
    final pendingCollections = await _localDatabase
        .collection<PendingCollectionOperationIsarModel>()
        .where()
        .filter()
        .isSyncedEqualTo(false)
        .collectionIdProperty()
        .findAll();
 
    final uniqueCollections = pendingCollections.toSet().toList();
 
    // Process each collection's operations in order
    for (final collectionId in uniqueCollections) {
      final operations = await _localDatabase
          .collection<PendingCollectionOperationIsarModel>()
          .where()
          .filter()
          .collectionIdEqualTo(collectionId)
          .isSyncedEqualTo(false)
          .sortByOperationOrder()
          .findAll();
 
      // Process operations sequentially
      for (final operation in operations) {
        try {
          final success = await _processPendingOperation(operation);
          if (!success) {
            break;
          }
          
          operation.isSynced = true;
          await _localDatabase.put<PendingCollectionOperationIsarModel>(operation);
        } catch (e) {
          break;
        }
      }
    }
  }
 
  Future<bool> _processPendingOperation(PendingCollectionOperationIsarModel operation) async {
    final data = jsonDecode(operation.payload);
    
    switch (operation.step) {
      case CollectionStep.statusUpdate:
        return await _processStatusUpdate(data);
      case CollectionStep.validation:
        return await _processValidation(data);
      case CollectionStep.information:
        return await _processInformation(data);
      case CollectionStep.confirmation:
        return await _processConfirmation(data);
      case CollectionStep.payment:
        return await _processPayment(data);
      case CollectionStep.rating:
        return await _processRating(data);
    }
  }
 
  Future<bool> _processStatusUpdate(Map<String, dynamic> data) async {
    try {
      final String id = data['id'] as String;
      final int idToInt = int.parse(id);
      final String status = data['status'];
      final int? cancelationReasonId = data['cancellationReason']?['id'];
      
      await _remoteDataSource.updateCollectionStatus(
        collectionId: idToInt,
        status: status,
        cancelationReasonId: cancelationReasonId?.toString(),
      );
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> _processValidation(Map<String, dynamic> data) async {
    try {
      await _remoteDataSource.validateCollection(
        reqValidationCollectionModel: ReqCollectionValidationModel.fromJson(data),
      );
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> _processInformation(Map<String, dynamic> data) async {
    try {
      await _remoteDataSource.sendCollectionsInformation(
        reqInformationCollectionModel: ReqCollectionInformationModel.fromJson(data),
      );
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> _processConfirmation(Map<String, dynamic> data) async {
    try {
      await _remoteDataSource.sendCollectionConfirmation(
        reqCollectionConfirmationModel: ReqCollectionConfirmationModel.fromJson(data),
      );
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> _processPayment(Map<String, dynamic> data) async {
    try {
      await _remoteDataSource.sendCollectionPayment(
        reqCollectionPaymentModel: ReqCollectionPaymentModel.fromJson(data),
      );
      return true;
    } catch (e) {
      return false;
    }
  }
 
  Future<bool> _processRating(Map<String, dynamic> data) async {
    try {
      await _remoteDataSource.sendCollectionRating(
        reqCollectionRatingModel: ReqCollectionRatingModel.fromJson(data),
      );
      return true;
    } catch (e) {
      return false;
    }
  }
}