routing_planning_bloc.dart

Go to the documentation of this file.

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
 
import '../../../../../core/error/failures.dart';
import '../../../../../core/services/service_locator.dart';
import '../../../domain/entities/req/req_create_routing_entity.dart';
import '../../../domain/entities/res/res_create_routing_entity.dart';
import '../../../domain/entities/res/res_weekly_collection_entity.dart';
import '../../../domain/entities/res/res_collection_to_schedule_entity.dart';
import '../../../domain/usecases/create_routing_usecase.dart';
 
part 'routing_planning_event.dart';
part 'routing_planning_state.dart';
 
class RoutingPlanningBloc
    extends Bloc<RoutingPlanningEvent, RoutingPlanningState> {
  final CreateRoutingUseCase createRoutingUseCase = sl<CreateRoutingUseCase>();
 
  RoutingPlanningBloc() : super(RoutingPlanningInitial()) {
    on<SetStartLocationEvent>(_onSetStartLocation);
    on<SetSelectedCollectionsEvent>(_onSetSelectedCollections);
    on<SetCollectionsToScheduleEvent>(_onSetCollectionsToSchedule);
    on<SetEndLocationEvent>(_onSetEndLocation);
    on<CreateRoutingEvent>(_onCreateRouting);
    on<ResetRoutingPlanningEvent>(_onResetRoutingPlanning);
  }
 
  void _onSetStartLocation(
    SetStartLocationEvent event,
    Emitter<RoutingPlanningState> emit,
  ) {
    final currentState = state;
    if (currentState is RoutingPlanningLoaded) {
      emit(currentState.copyWith(
        startLocation: event.location,
        startAddress: event.address,
      ));
    } else {
      emit(RoutingPlanningLoaded(
        startLocation: event.location,
        startAddress: event.address,
      ));
    }
  }
 
  void _onSetSelectedCollections(
    SetSelectedCollectionsEvent event,
    Emitter<RoutingPlanningState> emit,
  ) {
    final currentState = state;
    if (currentState is RoutingPlanningLoaded) {
      emit(currentState.copyWith(selectedCollections: event.collections));
    } else {
      emit(RoutingPlanningLoaded(selectedCollections: event.collections));
    }
  }
 
  void _onSetCollectionsToSchedule(
    SetCollectionsToScheduleEvent event,
    Emitter<RoutingPlanningState> emit,
  ) {
    final currentState = state;
    if (currentState is RoutingPlanningLoaded) {
      emit(currentState.copyWith(collectionsToSchedule: event.collections));
    } else {
      emit(RoutingPlanningLoaded(collectionsToSchedule: event.collections));
    }
  }
 
  void _onSetEndLocation(
    SetEndLocationEvent event,
    Emitter<RoutingPlanningState> emit,
  ) {
    final currentState = state;
    if (currentState is RoutingPlanningLoaded) {
      emit(currentState.copyWith(
        endLocation: event.location,
        endAddress: event.address,
      ));
    } else {
      emit(RoutingPlanningLoaded(
        endLocation: event.location,
        endAddress: event.address,
      ));
    }
  }
 
  Future<void> _onCreateRouting(
    CreateRoutingEvent event,
    Emitter<RoutingPlanningState> emit,
  ) async {
    final currentState = state;
 
    // Handle both RoutingPlanningLoaded and RoutingPlanningError states
    LatLng? startLocation;
    String? startAddress;
    Set<ResWeeklyCollectionEntity>? selectedCollections;
    List<ResCollectionToScheduleEntity>? collectionsToSchedule;
    LatLng? endLocation;
    String? endAddress;
    bool isComplete = false;
 
    if (currentState is RoutingPlanningLoaded) {
      startLocation = currentState.startLocation;
      startAddress = currentState.startAddress;
      selectedCollections = currentState.selectedCollections;
      collectionsToSchedule = currentState.collectionsToSchedule;
      endLocation = currentState.endLocation;
      endAddress = currentState.endAddress;
      isComplete = currentState.isComplete;
    } else if (currentState is RoutingPlanningError) {
      startLocation = currentState.startLocation;
      startAddress = currentState.startAddress;
      selectedCollections = currentState.selectedCollections;
      collectionsToSchedule = currentState.collectionsToSchedule;
      endLocation = currentState.endLocation;
      endAddress = currentState.endAddress;
      isComplete = currentState.isComplete;
    } else {
      return;
    }
 
    if (!isComplete) {
      emit(RoutingPlanningError(
        failure: const ValidationFailure(
            message: 'Missing required data for routing creation'),
        startLocation: startLocation,
        startAddress: startAddress,
        selectedCollections: selectedCollections,
        collectionsToSchedule: collectionsToSchedule,
        endLocation: endLocation,
        endAddress: endAddress,
      ));
      return;
    }
 
    emit(RoutingPlanningLoading());
 
    final purchaseOrders = collectionsToSchedule!
        .map((collection) => PurchaseOrderEntity(
              id: collection.id,
              reference: collection.reference,
            ))
        .toList();
 
    final drivers = [DriverEntity(id: event.driverId)];
 
    final request = ReqCreateRoutingEntity(
      duration: event.duration,
      startLocationLatitude: startLocation!.latitude.toString(),
      startLocationLongitude: startLocation.longitude.toString(),
      endLocationLatitude: endLocation!.latitude.toString(),
      endLocationLongitude: endLocation.longitude.toString(),
      purchaseOrders: purchaseOrders,
      drivers: drivers,
    );
 
    final result = await createRoutingUseCase(request);
 
    result.fold(
      (failure) => emit(RoutingPlanningError(
        failure: failure,
        startLocation: startLocation,
        startAddress: startAddress,
        selectedCollections: selectedCollections,
        collectionsToSchedule: collectionsToSchedule,
        endLocation: endLocation,
        endAddress: endAddress,
      )),
      (routing) => emit(RoutingPlanningSuccess(routing: routing)),
    );
  }
 
  void _onResetRoutingPlanning(
    ResetRoutingPlanningEvent event,
    Emitter<RoutingPlanningState> emit,
  ) {
    emit(RoutingPlanningInitial());
  }
}