cluedin-widget/core/action/search.js

This project contains all the pages needed for browsing entities and searching them. The aim is to replace the CluedIn.Webapp project with this one when all the pages ( including the Admin page ) will be ported to REACT.

import constants from '../constants';
import { unauthorized } from './generic';
import { suggestedSearch, search, aggregationSearch, getFacetsSearch } from '../data/search';

const requestSuggestedSearch = () => ({
  type: constants.search.REQUEST_SUGGESTED_SEARCH,
});

const receiveGenericLastTasks = (query, suggested) => ({
  type: constants.search.RECEIVE_SUGGESTED_SEARCH,
  data: {
    suggestedSearches: suggested,
    suggestedSearchQuery: query,
  },
});

const invalidGenericLastTasks = () => ({
  type: constants.search.INVALID_SUGGESTED_SEARCH,
});

export function shouldFetchSuggestedSearch(q) {
  return (dispatch) => {
    dispatch(requestSuggestedSearch());

    suggestedSearch(q).then((resp) => {
      dispatch(receiveGenericLastTasks(q, resp));
    }).catch(unauthorized(dispatch, invalidGenericLastTasks));
  };
}

const requestSearch = (q, sortingDirection, filters, type) => ({
  type: constants.search.REQUEST_SEARCH,
  data: {
    q,
    sortingDirection,
    filters,
    type,
  },
});

const receiveSearch = (searchResult) => ({
  type: constants.search.RECEIVE_SEARCH,
  data: {
    searchResult,
  },
});

const invalidSearch = () => ({
  type: constants.search.INVALID_SEARCH,
});

export function shouldFetchSearch(q, sortDirection, filters, aggregation, type) {
  return (dispatch) => {
    dispatch(requestSearch(q, sortDirection, filters, type));

    return search(q, { sortDirection, filters, aggregation, type }).then((resp) => {
      dispatch(receiveSearch(resp));
    }).catch(unauthorized(dispatch, invalidSearch));
  };
}

const requestInitialSearch = (q, query) => ({
  type: constants.search.REQUEST_INITIAL_SEARCH,
  data: {
    q,
    query,
  },
});

const receiveInitialSearch = (searchResult, q, query) => ({
  type: constants.search.RECEIVE_INITIAL_SEARCH,
  data: {
    searchResult,
    q,
    query,
  },
});

const invalidInitialSearch = () => ({
  type: constants.search.INVALID_INITIAL_SEARCH,
});

export function shouldFetchInitialSearch(q, query) {
  return (dispatch, getState) => {
    dispatch(requestInitialSearch(q, query));

    const {
      selectedFilters,
    } = getState().search;

    search(q, Object.assign(query, { filters: selectedFilters })).then((resp) => {
      dispatch(receiveInitialSearch(resp, q, query));
    }).catch(unauthorized(dispatch, invalidInitialSearch));
  };
}

const requestSearchWithFilter = (q, searchFilter) => ({
  type: constants.search.REQUEST_SEARCH_WITH_FILTER,
  data: {
    q,
    searchFilter,
  },
});

const receiveSearchWithFilter = (searchResult) => ({
  type: constants.search.RECEIVE_SEARCH_WITH_FILTER,
  data: {
    searchResult,
  },
});

const invalidSearchWithFilter = () => ({
  type: constants.search.INVALID_SEARCH_WITH_FILTER,
});

export function addSearchFilter(q, options) {
  const { sortDirection, filterType, facet, aggregation, type } = options;

  return (dispatch, getState) => {
    dispatch(requestSearchWithFilter(q, {
      filterType,
      facet,
    }));

    const {
      selectedFilters,
    } = getState().search;

    search(q, {
      sortDirection: sortDirection,
      aggregation,
      filters: selectedFilters,
      type,
    }).then((resp) => {
      dispatch(receiveSearchWithFilter(resp));
    }).catch(unauthorized(dispatch, invalidSearchWithFilter));
  };
}

const requestRemoveFilter = (filterType) => ({
  type: constants.search.REQUEST_REMOVE_FILTER_SEARCH,
  data: {
    filterType,
  },
});

const receiveRemoveFilter = (searchResult) => ({
  type: constants.search.RECEIVE_REMOVE_FILTER_SEARCH,
  data: {
    searchResult,
  },
});

const invalidRemoveFilter = () => ({
  type: constants.search.INVALID_REMOVE_FILTER_SEARCH,
});

export function removeFilter(q, sortDirection, filterType, aggregation, type) {
  return (dispatch, getState) => {
    dispatch(requestRemoveFilter(filterType));

    const {
      selectedFilters,
    } = getState().search;

    return search(q, { sortDirection, filters: selectedFilters, aggregation, type: type }).then((resp) => {
      dispatch(receiveRemoveFilter(resp));
    }).catch(unauthorized(dispatch, invalidRemoveFilter));
  };
}

const requestNextPage = (pageNumber) => ({
  type: constants.search.REQUEST_NEXT_PAGE_NUMBER,
  data: {
    pageNumber,
  },
});

const receiveNextPage = (searchResult) => ({
  type: constants.search.RECEIVE_NEXT_PAGE_NUMBER,
  data: {
    searchResult,
  },
});

const invalidNextPage = () => ({
  type: constants.search.INVALID_NEXT_PAGE_NUMBER,
});

export function nextPage(q, sortDirection, filters, pageNumber, aggregation, type) {
  return (dispatch) => {
    dispatch(requestNextPage(pageNumber));

    search(q, {
      sortDirection,
      filters,
      pageNumber,
      aggregation,
      type,
    }).then((resp) => {
      dispatch(receiveNextPage(resp));
    }).catch(unauthorized(dispatch, invalidNextPage));
  };
}

const requestAggregationSearch = (id) => ({
  type: constants.search.REQUEST_AGGREGATION_SEARCH,
  data: {
    id,
  },
});

const receiveAggregationSerch = (searchResult) => ({
  type: constants.search.RECEIVE_AGGREGATION_SEARCH,
  data: {
    searchResult,
  },
});

const invalidAggregationSearch = (id) => ({
  type: constants.search.INVALID_AGGREGATION_SEARCH,
  data: {
    id,
  },
});

export function fetchAggregationSearch(id) {
  return (dispatch) => {
    dispatch(requestAggregationSearch(id));

    aggregationSearch(id).then((res) => {
      dispatch(receiveAggregationSerch(res));
    }).catch(unauthorized(dispatch, invalidAggregationSearch));
  };
}

const requestEntityFacets = (q, page, take) => ({
  type: constants.search.REQUEST_ENTITY_FACETS,
  data: {
    q,
    page,
    take,
  },
});

const receiveEntityFacets = (facets) => ({
  type: constants.search.RECEIVE_ENTITY_FACETS,
  data: {
    facets,
  },
});

const invalidEntityFacets = (q, page, take) => ({
  type: constants.search.INVALID_ENTITY_FACETS,
});

export function fetchEntityFacets(q, page = 0, take = 10) {
  return (dispatch) => {
    dispatch(requestEntityFacets);

    getFacetsSearch(q, page, take).then((resp) => {
      dispatch(receiveEntityFacets(resp));
    }).catch(unauthorized(dispatch, invalidEntityFacets));
  };
}