filters: createFilterSettings()

in src/views/issues/issues-actions.ts [666:774]
97 lines of code
17 McCabe index (conditional complexity)

        filters: createFilterSettings(visibleFiltersNames, filterFields, settings),
      },
    };
    dispatch(cachedIssuesSettings(settings));
  } else {
    dispatch(switchToQuerySearchSetting());
  }
};

const onSettingsChange = (settings: IssuesSettings, preventReload?: boolean): ReduxAction => async (
  dispatch: ReduxThunkDispatch,
  getState: ReduxStateGetter,
) => {
  const currentSettings: IssuesSettings = getState().issueList.settings;
  const eventContext = dispatch(isHelpDeskMode()) ? `Issues` : `Tickets`;
  if (settings.search.mode !== currentSettings.search.mode) {
    trackEvent(`${eventContext} settings: switch mode to ${settings.search.mode}`);
    dispatch(issuesActions.SET_ISSUES_QUERY(''));
    await flushStoragePart({query: null});
  }
  if (settings.view.mode !== currentSettings.view.mode) {
    trackEvent(`${eventContext} settings: change preview size to ${settings.view.mode}`);
  }
  await dispatch(cachedIssuesSettings(settings));
  await flushStoragePart({issuesCache: null});
  if (settings.search.mode === issuesSearchSettingMode.filter) {
    await dispatch(setFilters());
  }
  dispatch(issuesActions.RECEIVE_ISSUES([]));
  if (!preventReload) {
    dispatch(refreshIssues());
  }
};

const setIssuesMode = (): ReduxAction => async (dispatch: ReduxThunkDispatch) => {
  dispatch(issuesActions.SET_HELPDESK_MODE(false));
};

const setIssuesFromCache = (): ReduxAction => async (dispatch: ReduxThunkDispatch) => {
  const cachedIssues: IssueOnListExtended[] = getStorageState().issuesCache || [];
  if (cachedIssues.length > 0) {
    log.info(`Issues Actions: Cached issues are loaded`);
    dispatch(issuesActions.RECEIVE_ISSUES(cachedIssues));
  }
};

const initializeIssuesList = (searchQuery?: string): ReduxAction => async (dispatch: ReduxThunkDispatch) => {
  dispatch(startIssuesLoading());

  if (searchQuery) {
    await dispatch(switchToQuerySearchSetting(true));
    await dispatch(storeIssuesQuery(searchQuery));
  }

  await dispatch(initSearchContext(searchQuery));
  await dispatch(initSearchQuery());
  await dispatch(setFilters());
  dispatch(refreshIssues());
};

const loadMoreIssues = (): ReduxAction => async (
  dispatch: ReduxThunkDispatch,
  getState: ReduxStateGetter,
) => {
  const entityType = isHelpDeskMode() ? 'tickets' : 'issues';
  try {
    const isOffline: boolean = getState().app?.networkState?.isConnected === false;
    if (isOffline) {
      return;
    }

    const {
      isInitialized,
      isLoadingMore,
      isRefreshing,
      loadingError,
      isListEndReached,
      skip,
      issues,
    } = getState().issueList;

    if (
      !isInitialized ||
      isLoadingMore ||
      isRefreshing ||
      loadingError ||
      isListEndReached
    ) {
      return;
    }

    const pageSize: number = dispatch(getPageSize());
    const newSkip: number = skip + pageSize;
    log.info(`Issues Actions: Loading more ${entityType}. newSkip = ${newSkip}`);
    dispatch(issuesActions.START_LOADING_MORE(newSkip));

    try {
      const searchQuery = await dispatch(composeSearchQuery());
      let moreIssues = await dispatch(doLoadIssues(searchQuery, pageSize, newSkip));
      log.info(`Issues Actions: Loaded more ${entityType}.`);
      moreIssues = ApiHelper.fillIssuesFieldHash<IssueOnListExtended>(moreIssues);
      const updatedIssues = ApiHelper.removeDuplicatesByPropName(
        issues.concat(moreIssues),
        'id',
      ) as IssueOnListExtended[];
      dispatch(issuesActions.RECEIVE_ISSUES(updatedIssues));
      dispatch(cacheIssues(updatedIssues));

      if (moreIssues.length < pageSize) {