@collectionspace/cspace-public-browser 1.5.1

package/src/actions/detailActions.js

@@ -0,0 +1,231 @@
+/* global fetch */
+
+import config from '../config';
+import { locationToDetailParams } from '../helpers/urlHelpers';
+
+import {
+  getDetailData,
+  getDetailParams,
+  isDetailPending,
+  isDetailInstSearchPending,
+} from '../reducers';
+
+import {
+  CLEAR_DETAIL,
+  DETAIL_READ_FULFILLED,
+  DETAIL_READ_REJECTED,
+  DETAIL_READ_STARTED,
+  INST_SEARCH_FULFILLED,
+  INST_SEARCH_REJECTED,
+  INST_SEARCH_STARTED,
+  SET_DETAIL_PARAMS,
+} from '../constants/actionCodes';
+
+import {
+  getSearchResultPayload,
+} from '../helpers/esQueryHelpers';
+
+export const clearDetail = () => ({
+  type: CLEAR_DETAIL,
+});
+
+export const setDetailParams = (location, match) => {
+  const params = locationToDetailParams(location, match);
+
+  return {
+    type: SET_DETAIL_PARAMS,
+    payload: params,
+  };
+};
+
+export const findInstitutionHoldings = (institutionId) => (dispatch, getState) => {
+  const params = getDetailParams(getState());
+  const data = getDetailData(getState());
+
+  if (
+    !params
+    || !data
+    || isDetailPending(getState())
+    || isDetailInstSearchPending(getState(), institutionId)
+  ) {
+    return Promise.resolve();
+  }
+
+  const holdingsConfig = config.get('institutionHoldings') || {};
+
+  const {
+    sortField,
+    sortOrder,
+    query: queryBuilder,
+  } = holdingsConfig;
+
+  const institutionsConfig = config.get('institutions') || {};
+  const institutionConfig = institutionsConfig[institutionId];
+
+  if (!queryBuilder || !institutionConfig) {
+    return Promise.resolve();
+  }
+
+  const {
+    gatewayUrl,
+  } = institutionConfig;
+
+  const url = `${gatewayUrl}/es/doc/_search`;
+  const query = queryBuilder(data);
+
+  const payload = {
+    query,
+    from: 0,
+    size: 500,
+  };
+
+  if (sortField) {
+    payload.sort = {
+      [sortField]: {
+        order: sortOrder || 'asc',
+      },
+    };
+  }
+
+  dispatch({
+    type: INST_SEARCH_STARTED,
+    meta: {
+      institutionId,
+      params,
+    },
+  });
+
+  return fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  })
+    .then((response) => {
+      if (!response.ok) {
+        const error = new Error();
+
+        error.response = response;
+
+        return Promise.reject(error);
+      }
+
+      return response.json();
+    })
+    .then((responseData) => {
+      dispatch({
+        type: INST_SEARCH_FULFILLED,
+        payload: responseData,
+        meta: {
+          institutionId,
+          params,
+        },
+      });
+    })
+    .catch((error) => {
+      dispatch({
+        type: INST_SEARCH_REJECTED,
+        payload: error,
+        meta: {
+          institutionId,
+          params,
+        },
+      });
+    });
+};
+
+export const findAllInstitutionHoldings = () => (dispatch) => {
+  const institutionsConfig = config.get('institutions');
+
+  if (!institutionsConfig) {
+    return Promise.resolve();
+  }
+
+  return Promise.all(Object.keys(institutionsConfig).map((institutionId) => (
+    dispatch(findInstitutionHoldings(institutionId))
+  )));
+};
+
+export const readDetail = () => (dispatch, getState) => {
+  const params = getDetailParams(getState());
+
+  if (!params || isDetailPending(getState())) {
+    return Promise.resolve();
+  }
+
+  const gatewayUrl = config.get('gatewayUrl');
+  const url = `${gatewayUrl}/es/doc/_msearch`;
+
+  const csid = params.get('csid');
+  const index = params.get('index');
+  const searchParams = params.get('searchParams');
+
+  const detailPayload = {
+    query: {
+      term: {
+        'ecm:name': csid,
+      },
+    },
+    from: 0,
+    size: 1,
+  };
+
+  const bodyParts = [
+    JSON.stringify({ preference: 'detail' }),
+    JSON.stringify(detailPayload),
+  ];
+
+  if (searchParams && typeof index !== 'undefined') {
+    const adjacentResultsPayload = getSearchResultPayload(
+      searchParams,
+      3,
+      Math.max(0, index - 1),
+    );
+
+    bodyParts.push(JSON.stringify({ preference: 'adjacent' }));
+    bodyParts.push(JSON.stringify(adjacentResultsPayload));
+  }
+
+  dispatch({
+    type: DETAIL_READ_STARTED,
+    meta: {
+      params,
+    },
+  });
+
+  return fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-ndjson' },
+    body: bodyParts.join('\n'),
+  })
+    .then((response) => {
+      if (!response.ok) {
+        const error = new Error();
+
+        error.response = response;
+
+        return Promise.reject(error);
+      }
+
+      return response.json();
+    })
+    .then((data) => {
+      dispatch({
+        type: DETAIL_READ_FULFILLED,
+        payload: data,
+        meta: {
+          params,
+        },
+      });
+
+      dispatch(findAllInstitutionHoldings());
+    })
+    .catch((error) => {
+      dispatch({
+        type: DETAIL_READ_REJECTED,
+        payload: error,
+        meta: {
+          params,
+        },
+      });
+    });
+};

package/src/actions/filterActions.js

@@ -0,0 +1,10 @@
+import { SET_FILTER_SEARCH_VALUE } from '../constants/actionCodes';
+
+// eslint-disable-next-line import/prefer-default-export
+export const setFilterSearchValue = (id, value) => ({
+  type: SET_FILTER_SEARCH_VALUE,
+  payload: value,
+  meta: {
+    id,
+  },
+});

package/src/actions/mediaActions.js

@@ -0,0 +1,65 @@
+/* global fetch */
+
+import get from 'lodash/get';
+import config from '../config';
+import { getMedia } from '../reducers';
+
+import {
+  SET_MEDIA,
+} from '../constants/actionCodes';
+
+export const setMedia = (referenceValue, institutionId, mediaCsids, mediaAltTexts, title) => ({
+  type: SET_MEDIA,
+  payload: {
+    title,
+    csids: mediaCsids,
+    altTexts: mediaAltTexts,
+  },
+  meta: {
+    institutionId,
+    referenceValue,
+  },
+});
+
+export const findMedia = (referenceValue, institutionId) => (dispatch, getState) => {
+  if (getMedia(getState(), referenceValue, institutionId)) {
+    return Promise.resolve();
+  }
+
+  let gatewayUrl;
+
+  if (institutionId === null) {
+    gatewayUrl = config.get('gatewayUrl');
+  } else {
+    gatewayUrl = config.get(['institutions', institutionId, 'gatewayUrl']);
+  }
+
+  const url = `${gatewayUrl}/es/doc/_search`;
+  const referenceField = config.get('referenceField');
+
+  const query = {
+    _source: ['collectionspace_denorm:mediaCsid', 'collectionspace_denorm:mediaAltText', 'collectionspace_denorm:title'],
+    query: {
+      term: {
+        [referenceField]: referenceValue,
+      },
+    },
+    size: 1,
+    terminate_after: 1,
+  };
+
+  return fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(query),
+  })
+    .then((response) => response.json())
+    .then((data) => {
+      const source = get(data, ['hits', 'hits', 0, '_source']);
+      const title = get(source, 'collectionspace_denorm:title');
+      const mediaCsids = get(source, 'collectionspace_denorm:mediaCsid') || [];
+      const mediaAltTexts = get(source, 'collectionspace_denorm:mediaAltText') || [];
+
+      return dispatch(setMedia(referenceValue, institutionId, mediaCsids, mediaAltTexts, title));
+    });
+};

package/src/actions/prefsActions.js

@@ -0,0 +1,95 @@
+/* global window */
+
+import Immutable from 'immutable';
+
+import {
+  EXPAND_PANEL,
+  PREFS_LOADED,
+  TOGGLE_PANEL,
+} from '../constants/actionCodes';
+
+import config from '../config';
+import { getPrefs } from '../reducers';
+
+// Username to use for pref storage when user is not logged in
+const anonymousUsername = '*';
+
+export const loadPrefs = () => (dispatch) => {
+  const username = anonymousUsername;
+  const storageKey = config.get('storageKey');
+
+  let userPrefs = null;
+
+  if (username) {
+    const serializedPrefs = window.localStorage.getItem(storageKey);
+
+    if (serializedPrefs) {
+      try {
+        userPrefs = Immutable.fromJS((JSON.parse(serializedPrefs))[username]);
+      } catch (error) {
+        userPrefs = null;
+      }
+    }
+  }
+
+  const defaultUserPrefs = config.get('defaultUserPrefs');
+
+  if (defaultUserPrefs) {
+    userPrefs = (Immutable.fromJS(defaultUserPrefs)).mergeDeep(userPrefs);
+  }
+
+  dispatch({
+    type: PREFS_LOADED,
+    payload: userPrefs,
+  });
+};
+
+export const savePrefs = () => (dispatch, getState) => {
+  const username = anonymousUsername;
+  const storageKey = config.get('storageKey');
+
+  let prefs;
+
+  if (username) {
+    const serializedPrefs = window.localStorage.getItem(storageKey);
+
+    if (serializedPrefs) {
+      try {
+        prefs = JSON.parse(serializedPrefs);
+      } catch (error) {
+        prefs = null;
+      }
+    }
+
+    if (!prefs) {
+      prefs = {};
+    }
+
+    prefs[username] = getPrefs(getState()).toJS();
+
+    window.localStorage.setItem(storageKey, JSON.stringify(prefs));
+  }
+};
+
+export const expandPanel = (id, expanded = true) => (dispatch) => {
+  dispatch({
+    type: EXPAND_PANEL,
+    payload: expanded,
+    meta: {
+      id,
+    },
+  });
+
+  dispatch(savePrefs());
+};
+
+export const togglePanel = (id) => (dispatch) => {
+  dispatch({
+    type: TOGGLE_PANEL,
+    meta: {
+      id,
+    },
+  });
+
+  dispatch(savePrefs());
+};

package/src/actions/searchActions.js

@@ -0,0 +1,188 @@
+/* global fetch, window */
+
+import Immutable from 'immutable';
+import config from '../config';
+import { SEARCH_QUERY_ID, SORT_ID } from '../constants/ids';
+import { locationToSearchParams, searchParamsToQueryString } from '../helpers/urlHelpers';
+
+import {
+  getSearchNextOffset,
+  getSearchPageSize,
+  getSearchParams,
+  isSearchPending,
+  searchHasMore,
+} from '../reducers';
+
+import {
+  OPEN_SEARCH,
+  SEARCH_STARTED,
+  SEARCH_FULFILLED,
+  SEARCH_REJECTED,
+  SET_SEARCH_PAGE_SIZE,
+  SET_SEARCH_PARAMS,
+} from '../constants/actionCodes';
+
+import {
+  getAggs,
+  getSearchResultPayload,
+  getQuery,
+  getFilterAgg,
+} from '../helpers/esQueryHelpers';
+
+export const openSearch = (history, params = Immutable.Map()) => {
+  const queryString = searchParamsToQueryString(params);
+
+  history.push({
+    search: `?${queryString}`,
+  });
+
+  return {
+    type: OPEN_SEARCH,
+    payload: queryString,
+  };
+};
+
+export const search = (fetchDelay = 0) => (dispatch, getState) => {
+  const params = getSearchParams(getState());
+
+  if (!params || isSearchPending(getState()) || !searchHasMore(getState())) {
+    return Promise.resolve();
+  }
+
+  const gatewayUrl = config.get('gatewayUrl');
+  const url = `${gatewayUrl}/es/doc/_msearch`;
+
+  const offset = getSearchNextOffset(getState()) || 0;
+  const pageSize = getSearchPageSize(getState()) || 15;
+  const resultPayload = getSearchResultPayload(params, pageSize, offset);
+
+  let filterAggPayloads = [];
+
+  if (offset === 0) {
+    // When loading the first page, get aggregations.
+
+    resultPayload.aggs = getAggs(params);
+
+    filterAggPayloads = params
+      .delete(SORT_ID)
+      .delete(SEARCH_QUERY_ID)
+      .keySeq()
+      .flatMap((id) => {
+        const filterFieldConfig = config.getFilterFieldConfig(id);
+
+        return [
+          {
+            preference: id,
+          },
+          {
+            query: getQuery(params.delete(id)),
+            size: 0,
+            aggs: {
+              [id]: getFilterAgg(filterFieldConfig),
+            },
+          },
+        ];
+      })
+      .toJS();
+  }
+
+  dispatch({
+    type: SEARCH_STARTED,
+  });
+
+  const delay = new Promise((resolve) => {
+    window.setTimeout(() => {
+      resolve();
+    }, fetchDelay);
+  });
+
+  return delay
+    .then(() => fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-ndjson' },
+      body: [
+        JSON.stringify({ preference: 'result' }),
+        JSON.stringify(resultPayload),
+        ...filterAggPayloads.map((payload) => JSON.stringify(payload)),
+      ].join('\n'),
+    }))
+    .then((response) => {
+      if (!response.ok) {
+        const error = new Error();
+
+        error.response = response;
+
+        return Promise.reject(error);
+      }
+
+      return response.json();
+    })
+    .then((data) => {
+      dispatch({
+        type: SEARCH_FULFILLED,
+        payload: data,
+        meta: {
+          offset,
+          pageSize,
+          params,
+        },
+      });
+    })
+    .catch((error) => {
+      dispatch({
+        type: SEARCH_REJECTED,
+        payload: error,
+        meta: {
+          offset,
+          pageSize,
+          params,
+        },
+      });
+    });
+};
+
+export const setSearchPageSize = (pageSize) => ({
+  type: SET_SEARCH_PAGE_SIZE,
+  payload: pageSize,
+});
+
+export const setSearchParams = (location) => {
+  const params = locationToSearchParams(location);
+
+  return {
+    type: SET_SEARCH_PARAMS,
+    payload: params,
+  };
+};
+
+export const applyFilter = (history, id, value, isSelected) => (dispatch, getState) => {
+  const params = getSearchParams(getState());
+
+  let selectedValues = params.get(id) || Immutable.List();
+
+  if (!Immutable.List.isList(selectedValues)) {
+    selectedValues = Immutable.List.of(selectedValues);
+  }
+
+  let nextParams;
+
+  if (isSelected) {
+    nextParams = params.set(id, selectedValues.push(value));
+  } else {
+    const selectedIndex = selectedValues.indexOf(value);
+
+    if (selectedIndex >= 0) {
+      nextParams = (selectedValues.size > 1)
+        ? params.set(id, selectedValues.delete(selectedIndex))
+        : params.delete(id);
+    } else {
+      nextParams = params;
+    }
+  }
+
+  return dispatch(openSearch(history, nextParams));
+};
+
+export const applySortOrder = (history, sortOrder) => (dispatch, getState) => (
+  dispatch(openSearch(history, getSearchParams(getState()).set(SORT_ID, sortOrder)))
+);

package/src/actions/searchEntryFormActions.js

@@ -0,0 +1,15 @@
+import { openSearch } from './searchActions';
+import { getSearchEntryFormParams } from '../reducers';
+import { SET_SEARCH_ENTRY_FORM_PARAM } from '../constants/actionCodes';
+
+export const setSearchEntryFormParam = (id, value) => ({
+  type: SET_SEARCH_ENTRY_FORM_PARAM,
+  payload: value,
+  meta: {
+    id,
+  },
+});
+
+export const applySearchEntryForm = (history) => (dispatch, getState) => (
+  dispatch(openSearch(history, getSearchEntryFormParams(getState())))
+);

package/src/components/App.jsx

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Redirect, Route, Switch } from 'react-router';
+import { BrowserRouter as Router } from 'react-router-dom';
+import config from '../config';
+import RootPage from './pages/RootPage';
+
+export default function App() {
+  const basename = config.get('basename');
+
+  return (
+    <Router basename={basename}>
+      <Switch>
+        <Redirect exact path="/" to="/search" />
+        <Route component={RootPage} />
+      </Switch>
+    </Router>
+  );
+}