CategoryFilterLocationBloc

import 'package:bloc/bloc.dart';
import 'package:bloc_concurrency/bloc_concurrency.dart';
import 'package:equatable/equatable.dart';
import 'package:module_category/domain/entities/category_filter_location_default.dart';
import 'package:module_category/domain/entities/category_filter_location_search.dart';
import 'package:module_category/domain/usecases/get_category_filter_location_search.dart';
import 'package:module_category/domain/usecases/post_category_filter_location_default.dart';
import 'package:module_core/common/state_enum.dart';
import 'package:rxdart/src/transformers/backpressure/debounce.dart';
import 'package:rxdart/src/transformers/flat_map.dart';

part 'category_filter_location_event.dart';
part 'category_filter_location_state.dart';

class CategoryFilterLocationBloc
    extends Bloc<CategoryFilterLocationEvent, CategoryFilterLocationState> {
  final PostCategoryFilterLocationDefault _postCategoryFilterLocationDefault;
  final GetCategoryFilterLocationSearch _getCategoryFilterLocationSearch;
  CategoryFilterLocationBloc(this._postCategoryFilterLocationDefault,
      this._getCategoryFilterLocationSearch)
      : super(CategoryFilterLocationState.initial()) {
    on<OnClickFilterLocationDefault>(
      (event, emit) async {
        emit(state.copyWith(state: RequestState.Loading));
        final result = await _postCategoryFilterLocationDefault.execute();

        result.fold(
          (failure) => emit(state.copyWith(
              state: RequestState.Error, message: failure.message)),
          (categoryFilterLocationDefault) {
            emit(
              state.copyWith(
                  state: RequestState.Loaded,
                  dataDefault: categoryFilterLocationDefault,
                  dataSearch: null),
            );
            if (categoryFilterLocationDefault.response.data.province?.length ==
                0) {
              emit(
                state.copyWith(
                    state: RequestState.Empty,
                    message: 'Empty Category Filter Location'),
              );
            }
          },
        );
      },
      transformer: restartable(),
    );

    on<OnChangeFilterLocationSearch>((event, emit) async {
      final city = event.city;
      emit(state.copyWith(state: RequestState.Loading));
      final result = await _getCategoryFilterLocationSearch.execute(city);

      result.fold(
        (failure) => emit(state.copyWith(
            state: RequestState.Error, message: failure.message)),
        (categoryFilterLocationSearch) {
          emit(
            state.copyWith(
                state: RequestState.Loaded,
                dataSearch: categoryFilterLocationSearch,
                dataDefault: null),
          );
          if (categoryFilterLocationSearch.response.data.isEmpty) {
            emit(
              state.copyWith(
                  state: RequestState.Empty,
                  message: 'Empty Category Filter Location'),
            );
          }
        },
      );
    }, transformer: debounce(const Duration(milliseconds: 700)));
  }
}

EventTransformer<MyEvent> debounce<MyEvent>(Duration duration) {
  return (events, mapper) => events.debounceTime(duration).flatMap(mapper);
}