invoice/lib/redux/group/group_reducer.dart

// Package imports:
import 'package:built_collection/built_collection.dart';
import 'package:redux/redux.dart';

// Project imports:
import 'package:invoiceninja_flutter/data/models/entities.dart';
import 'package:invoiceninja_flutter/data/models/group_model.dart';
import 'package:invoiceninja_flutter/redux/app/app_actions.dart';
import 'package:invoiceninja_flutter/redux/company/company_actions.dart';
import 'package:invoiceninja_flutter/redux/group/group_actions.dart';
import 'package:invoiceninja_flutter/redux/group/group_state.dart';
import 'package:invoiceninja_flutter/redux/ui/entity_ui_state.dart';
import 'package:invoiceninja_flutter/redux/ui/list_ui_state.dart';

EntityUIState groupUIReducer(GroupUIState state, dynamic action) {
  return state.rebuild((b) => b
    ..listUIState.replace(groupListReducer(state.listUIState, action))
    ..editing.replace(editingReducer(state.editing, action))
    ..selectedId = selectedIdReducer(state.selectedId, action)
    ..forceSelected = forceSelectedReducer(state.forceSelected, action));
}

final forceSelectedReducer = combineReducers<bool>([
  TypedReducer<bool, ViewGroup>((completer, action) => true),
  TypedReducer<bool, ViewGroupList>((completer, action) => false),
  TypedReducer<bool, FilterGroupsByState>((completer, action) => false),
  TypedReducer<bool, FilterGroups>((completer, action) => false),
]);

Reducer<String> selectedIdReducer = combineReducers([
  TypedReducer<String, ArchiveGroupSuccess>((completer, action) => ''),
  TypedReducer<String, DeleteGroupSuccess>((completer, action) => ''),
  TypedReducer<String, PreviewEntity>((selectedId, action) =>
      action.entityType == EntityType.group ? action.entityId : selectedId),
  TypedReducer<String, ViewGroup>(
      (String selectedId, action) => action.groupId),
  TypedReducer<String, AddGroupSuccess>(
      (String selectedId, action) => action.group.id),
  TypedReducer<String, SelectCompany>(
      (selectedId, action) => action.clearSelection ? '' : selectedId),
  TypedReducer<String, ClearEntityFilter>((selectedId, action) => ''),
  TypedReducer<String, SortGroups>((selectedId, action) => ''),
  TypedReducer<String, FilterGroups>((selectedId, action) => ''),
  TypedReducer<String, FilterGroupsByState>((selectedId, action) => ''),
  TypedReducer<String, ClearEntitySelection>((selectedId, action) =>
      action.entityType == EntityType.group ? '' : selectedId),
  TypedReducer<String, FilterByEntity>(
      (selectedId, action) => action.clearSelection
          ? ''
          : action.entityType == EntityType.group
              ? action.entityId
              : selectedId),
]);

final editingReducer = combineReducers<GroupEntity>([
  TypedReducer<GroupEntity, SaveGroupSuccess>(_updateEditing),
  TypedReducer<GroupEntity, AddGroupSuccess>(_updateEditing),
  TypedReducer<GroupEntity, RestoreGroupSuccess>((groups, action) {
    return action.groups[0];
  }),
  TypedReducer<GroupEntity, ArchiveGroupSuccess>((groups, action) {
    return action.groups[0];
  }),
  TypedReducer<GroupEntity, DeleteGroupSuccess>((groups, action) {
    return action.groups[0];
  }),
  TypedReducer<GroupEntity, EditGroup>(_updateEditing),
  TypedReducer<GroupEntity, UpdateGroup>((group, action) {
    return action.group.rebuild((b) => b..isChanged = true);
  }),
  TypedReducer<GroupEntity, DiscardChanges>(_clearEditing),
]);

GroupEntity _clearEditing(GroupEntity group, dynamic action) {
  return GroupEntity();
}

GroupEntity _updateEditing(GroupEntity group, dynamic action) {
  return action.group;
}

final groupListReducer = combineReducers<ListUIState>([
  TypedReducer<ListUIState, SortGroups>(_sortGroups),
  TypedReducer<ListUIState, FilterGroupsByState>(_filterGroupsByState),
  TypedReducer<ListUIState, FilterGroups>(_filterGroups),
  TypedReducer<ListUIState, StartGroupMultiselect>(_startListMultiselect),
  TypedReducer<ListUIState, AddToGroupMultiselect>(_addToListMultiselect),
  TypedReducer<ListUIState, RemoveFromGroupMultiselect>(
      _removeFromListMultiselect),
  TypedReducer<ListUIState, ClearGroupMultiselect>(_clearListMultiselect),
  TypedReducer<ListUIState, ViewGroupList>(_viewGroupList),
]);

ListUIState _viewGroupList(ListUIState groupListState, ViewGroupList action) {
  return groupListState.rebuild((b) => b
    ..selectedIds = null
    ..filter = null
    ..filterClearedAt = DateTime.now().millisecondsSinceEpoch);
}

ListUIState _filterGroupsByState(
    ListUIState groupListState, FilterGroupsByState action) {
  if (groupListState.stateFilters.contains(action.state)) {
    return groupListState.rebuild((b) => b..stateFilters.remove(action.state));
  } else {
    return groupListState.rebuild((b) => b..stateFilters.add(action.state));
  }
}

ListUIState _filterGroups(ListUIState groupListState, FilterGroups action) {
  return groupListState.rebuild((b) => b
    ..filter = action.filter
    ..filterClearedAt = action.filter == null
        ? DateTime.now().millisecondsSinceEpoch
        : groupListState.filterClearedAt);
}

ListUIState _sortGroups(ListUIState groupListState, SortGroups action) {
  return groupListState.rebuild((b) => b
    ..sortAscending = b.sortField != action.field || !b.sortAscending
    ..sortField = action.field);
}

ListUIState _startListMultiselect(
    ListUIState groupListState, StartGroupMultiselect action) {
  return groupListState.rebuild((b) => b..selectedIds = ListBuilder());
}

ListUIState _addToListMultiselect(
    ListUIState groupListState, AddToGroupMultiselect action) {
  return groupListState.rebuild((b) => b..selectedIds.add(action.entity.id));
}

ListUIState _removeFromListMultiselect(
    ListUIState groupListState, RemoveFromGroupMultiselect action) {
  return groupListState.rebuild((b) => b..selectedIds.remove(action.entity.id));
}

ListUIState _clearListMultiselect(
    ListUIState groupListState, ClearGroupMultiselect action) {
  return groupListState.rebuild((b) => b..selectedIds = null);
}

final groupsReducer = combineReducers<GroupState>([
  TypedReducer<GroupState, SaveGroupSuccess>(_updateGroup),
  TypedReducer<GroupState, AddGroupSuccess>(_addGroup),
  TypedReducer<GroupState, LoadGroupsSuccess>(_setLoadedGroups),
  TypedReducer<GroupState, LoadGroupSuccess>(_setLoadedGroup),
  TypedReducer<GroupState, LoadCompanySuccess>(_setLoadedCompany),
  TypedReducer<GroupState, ArchiveGroupSuccess>(_archiveGroupSuccess),
  TypedReducer<GroupState, DeleteGroupSuccess>(_deleteGroupSuccess),
  TypedReducer<GroupState, RestoreGroupSuccess>(_restoreGroupSuccess),
]);

GroupState _archiveGroupSuccess(
    GroupState groupState, ArchiveGroupSuccess action) {
  return groupState.rebuild((b) {
    for (final group in action.groups) {
      b.map[group.id] = group;
    }
  });
}

GroupState _deleteGroupSuccess(
    GroupState groupState, DeleteGroupSuccess action) {
  return groupState.rebuild((b) {
    for (final group in action.groups) {
      b.map[group.id] = group;
    }
  });
}

GroupState _restoreGroupSuccess(
    GroupState groupState, RestoreGroupSuccess action) {
  return groupState.rebuild((b) {
    for (final group in action.groups) {
      b.map[group.id] = group;
    }
  });
}

GroupState _addGroup(GroupState groupState, AddGroupSuccess action) {
  return groupState.rebuild((b) => b
    ..map[action.group.id] = action.group
    ..list.add(action.group.id));
}

GroupState _updateGroup(GroupState groupState, SaveGroupSuccess action) {
  return groupState.rebuild((b) => b..map[action.group.id] = action.group);
}

GroupState _setLoadedGroup(GroupState groupState, LoadGroupSuccess action) {
  return groupState.rebuild((b) => b..map[action.group.id] = action.group);
}

GroupState _setLoadedGroups(GroupState groupState, LoadGroupsSuccess action) {
  final state = groupState.rebuild((b) => b
    ..map.addAll(Map.fromIterable(
      action.groups,
      key: (dynamic item) => item.id,
      value: (dynamic item) => item,
    )));

  return state.rebuild((b) => b..list.replace(state.map.keys));
}

GroupState _setLoadedCompany(GroupState groupState, LoadCompanySuccess action) {
  final state = groupState.rebuild((b) => b
    ..map.addAll(Map.fromIterable(
      action.userCompany.company.groups,
      key: (dynamic item) => item.id,
      value: (dynamic item) => item,
    )));

  return state.rebuild((b) => b..list.replace(state.map.keys));
}