PostListPagedBloc constructor

PostListPagedBloc(AccessDetermined theAcessDetermined, String memberId, EliudQuery eliudQuery, { required PostRepository postRepository, })

Implementation

PostListPagedBloc(
    AccessDetermined theAcessDetermined, this.memberId, this.eliudQuery,
    {required PostRepository postRepository})
    : accessDetermined = theAcessDetermined,
      _postRepository = postRepository,
      super(PostListPagedState(
          blockedMembers: theAcessDetermined is LoggedIn
              ? theAcessDetermined.getBlocked()
              : const <String>[],
          canBlock: theAcessDetermined is LoggedIn)) {
  on<PostListPagedFetched>((event, emit) async {
    var value = await _mapPostFetchedToState(state);
    if (value != null) emit(value);
  });

  on<UpdatePostPaged>((event, emit) async {
    await _mapUpdatePost(event);

    // We update the entry in the current state avoiding interaction with repository
    var newListOfValues = <PostDetails>[];
    for (var element in state.values) {
      if (element.postModel.documentID != event.value.documentID) {
        newListOfValues.add(element);
      } else {
        newListOfValues.add(element.copyWith(postModel: event.value));
      }
    }

    emit(state.copyWith(values: newListOfValues));
  });

  on<BlockMemberFromPost>((event, emit) async {
    if (accessDetermined is LoggedIn) {
      LoggedIn loggedIn = accessDetermined as LoggedIn;
      var newBlocked = loggedIn
          .registerBlockedMember(event.blockTheAuthorOfThisPost.authorId);
      var newValues = filterBlockedMembers(state.values, newBlocked);
      emit(state.copyWith(values: newValues, blockedMembers: newBlocked));
    }
  });

  on<BlockMemberFromComment>((event, emit) async {
    if (accessDetermined is LoggedIn) {
      LoggedIn loggedIn = accessDetermined as LoggedIn;
      if (event.blockTheAuthorOfThisComment.member != null) {
        loggedIn.registerBlockedMember(
            event.blockTheAuthorOfThisComment.member!.documentID);
        emit(PostListPagedState(
            blockedMembers: theAcessDetermined is LoggedIn
                ? theAcessDetermined.getBlocked()
                : const <String>[],
            canBlock: theAcessDetermined is LoggedIn));
        add(PostListPagedFetched()); // refresh all
      }
    }
  });

  on<AddPostPaged>((event, emit) async {
    var details = PostDetails(postModel: event.value);
    await _mapAddPost(event);
    List<PostDetails> newListOfValues = [];
    newListOfValues.add(details);
    newListOfValues.addAll(state.values);
    emit(state.copyWith(values: newListOfValues));
  });

  on<DeletePostPaged>((event, emit) async {
    await _mapDeletePost(event);

    // We delete the entry and add it whilst limiting interaction with repository
    var newListOfValues = <PostDetails>[];
    for (var element in state.values) {
      if (element.postModel.documentID != event.value!.documentID) {
        newListOfValues.add(element);
      }
    }

    final extraValues = await _fetchPosts(
        lastRowFetched: state.lastRowFetched,
        limit: 1,
        blockedMembers: state.blockedMembers);
    final extraExtraValues = filterBlockedMembers(
        List.of(newListOfValues)..addAll(extraValues), state.blockedMembers);
    var newState = extraValues.isEmpty
        ? state.copyWith(
            hasReachedMax: true,
            status: PostListPagedStatus.success,
            values: extraExtraValues,
          )
        : state.copyWith(
            status: PostListPagedStatus.success,
            values: extraExtraValues,
            lastRowFetched: lastRowFetched,
            hasReachedMax:
                _hasReachedMax(newListOfValues.length + extraValues.length),
          );
    emit(newState);
  });

  on<LikePostEvent>((event, emit) async {
    emit(await _updateEmotion(state, null, event.likeType, event.postDetail));
  });

  on<LikeCommentPostEvent>((event, emit) async {
    emit(await _updateEmotion(
        state, event.postCommentContainer, event.likeType, event.postDetail));
  });

  on<AddCommentEvent>((event, emit) async {
    emit(await _comment(state, event.comment, event.postDetail));
  });

  on<AddCommentCommentEvent>((event, emit) async {
    emit(await _commentComment(
        state, event.postDetail, event.postCommentContainer, event.comment));
  });

  on<DeleteCommentEvent>((event, emit) async {
    emit(await _deleteComment(state, event.deleteThis, event.postDetail));
  });

  on<UpdateCommentEvent>((event, emit) async {
    emit(await _updateComment(
      state,
      event.updateThis,
      event.postDetail,
      event.newValue,
    ));
  });
}