collections_bloc.dart

Go to the documentation of this file.

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import '../../../../../core/common/enums/collection_status.dart';
import '../../../../../core/common/use_case/use_case.dart';
import '../../../../../core/error/failures.dart';
import '../../../../../core/services/service_locator.dart';
import '../../../../../core/ui/theme/color_palette.dart';
import '../../../../../core/common/entities/collection_entity.dart';
import '../../../domain/entities/res/res_cancellation_reason_entity.dart';
import '../../../domain/entities/res/res_collection_status_entity.dart';
import '../../../domain/usecases/get_cancellation_reason_usecase.dart';
import '../../../domain/usecases/get_collections_usecase.dart';
import '../../../domain/usecases/update_collection_status_usecase.dart';
import '../../../domain/usecases/validate_collection_usecase.dart';
 
part 'collections_event.dart';
part 'collections_state.dart';
 
class CollectionsBloc extends Bloc<CollectionsEvent, CollectionsState> {
  final GetCollectionsUseCase getCollectionsUseCase = sl<GetCollectionsUseCase>();
  final GetCancellationReasonsUseCase getCancelationReasonsUseCase = sl<GetCancellationReasonsUseCase>();
  final UpdateCollectionStatusUsecase updateCollectionStatusUsecase = sl<UpdateCollectionStatusUsecase>();
  final ValidateCollectionUsecase validateCollectionUseCase = sl<ValidateCollectionUsecase>();
 
  CollectionsBloc() : super(CollectionsInitial()) {
    on<LoadCollectionsEvent>(_onLoadCollections);
    on<UpdateCollectionStatusEvent>(_onUpdateCollectionStatus);
    on<LoadCancellationReasonsEvent>(_onLoadCancellationReasons);
    on<ValidateCollectionEvent>(_onValidateCollection);
  }
 
  Future<void> _onLoadCollections(
    LoadCollectionsEvent event,
    Emitter<CollectionsState> emit,
  ) async {
    emit(CollectionsLoading());
 
    final result = await getCollectionsUseCase(
      GetCollectionsParams(
        userId: event.userId,
        notForToday: event.notForToday,
        type: event.type,
      ),
    );
 
    result.fold(
      (failure) => emit(CollectionsError(failure: failure)),
      (collections) => emit(
        CollectionsLoaded(
          collections: collections..sort(
            (a, b) => (a.order ?? 0).compareTo(b.order ?? 0),
          ),
        ),
      ),
    );
  }
 
  Future<void> _onUpdateCollectionStatus(
    UpdateCollectionStatusEvent event,
    Emitter<CollectionsState> emit,
  ) async {
    emit(CollectionsLoading());
    final result = await updateCollectionStatusUsecase(
      UpdateCollectionStatusParams(
        collectionId: event.collectionId,
        status: event.status,
        cancellationReasonId: event.cancellationReasonId,
        reference: event.reference,
      ),
    );
 
    result.fold(
      (failure) => emit(CollectionStatusUpdateError(failure: failure)),
      (success) {
        emit(CollectionStatusUpdateSuccess(resCollectionStatusEntity: success));
        if (event.userId != null) {
          add(
            LoadCollectionsEvent(
              userId: event.userId!,
              notForToday: false,
              type: "todo",
            ),
          );
        } else {
          emit(const CollectionStatusUpdateError(
            failure: UnknownFailure(
              message: "Error, action not complited",
              color: ColorPalette.red,
            ),
          ));
        }
      },
    );
  }
 
  Future<void> _onLoadCancellationReasons(
    LoadCancellationReasonsEvent event,
    Emitter<CollectionsState> emit,
  ) async {
    emit(CancellationReasonsLoading());
    final result = await getCancelationReasonsUseCase(NoParams());
    result.fold(
      (failure) => emit(CancellationReasonsError(failure: failure)),
      (reasons) => emit(CancellationReasonsLoaded(reasons: reasons)),
    );
  }
 
  Future<void> _onValidateCollection(
    ValidateCollectionEvent event,
    Emitter<CollectionsState> emit,
  ) async {
    emit(CollectionValidationLoading());
    final result = await validateCollectionUseCase(
      ValidateCollectionParams(
        collectionId: event.collectionId,
        userId: event.userId,
      ),
    );
 
    result.fold(
      (failure) => emit(CollectionValidationError(failure: failure)),
      (success) => emit(CollectionValidationSuccess(isValid: success)),
    );
  }
}