@collectionspace/cspace-public-browser 1.5.1

package/src/config/publicart.js

@@ -0,0 +1,3 @@
+export default {
+  gatewayUrl: 'http://localhost:8180/gateway/publicart',
+};

package/src/constants/actionCodes.js

@@ -0,0 +1,26 @@
+export const PREFS_LOADED = 'PREFS_LOADED';
+export const EXPAND_PANEL = 'EXPAND_PANEL';
+export const TOGGLE_PANEL = 'TOGGLE_PANEL';
+
+export const SET_MEDIA = 'SET_MEDIA';
+
+export const OPEN_SEARCH = 'OPEN_SEARCH';
+export const SET_SEARCH_PAGE_SIZE = 'SET_SEARCH_PAGE_SIZE';
+export const SET_SEARCH_PARAMS = 'SET_SEARCH_PARAMS';
+export const SEARCH_STARTED = 'SEARCH_STARTED';
+export const SEARCH_FULFILLED = 'SEARCH_FULFILLED';
+export const SEARCH_REJECTED = 'SEARCH_REJECTED';
+
+export const SET_SEARCH_ENTRY_FORM_PARAM = 'SET_SEARCH_ENTRY_FORM_PARAM';
+
+export const SET_FILTER_SEARCH_VALUE = 'SET_FILTER_SEARCH_VALUE';
+
+export const CLEAR_DETAIL = 'CLEAR_DETAIL';
+export const SET_DETAIL_PARAMS = 'SET_DETAIL_PARAMS';
+export const DETAIL_READ_STARTED = 'DETAIL_READ_STARTED';
+export const DETAIL_READ_FULFILLED = 'DETAIL_READ_FULFILLED';
+export const DETAIL_READ_REJECTED = 'DETAIL_READ_REJECTED';
+
+export const INST_SEARCH_STARTED = 'INST_SEARCH_STARTED';
+export const INST_SEARCH_FULFILLED = 'INST_SEARCH_FULFILLED';
+export const INST_SEARCH_REJECTED = 'INST_SEARCH_REJECTED';

package/src/constants/ids.js

@@ -0,0 +1,3 @@
+export const FILTER_PANEL_ID = 'filter';
+export const SEARCH_QUERY_ID = 'search';
+export const SORT_ID = 'sort';

package/src/helpers/bodyClassName.js

@@ -0,0 +1,5 @@
+export default (className) => {
+  const name = className.split('--', 1)[0];
+
+  return `has-${name}`;
+};

package/src/helpers/esQueryHelpers.js

@@ -0,0 +1,224 @@
+import config from '../config';
+import { SEARCH_QUERY_ID, SORT_ID } from '../constants/ids';
+
+export const fulltextParamToQuery = (value) => {
+  if (!value) {
+    return undefined;
+  }
+
+  const fulltextSearchFields = config.get('fulltextSearchFields');
+
+  return {
+    bool: {
+      should: [
+        {
+          multi_match: {
+            query: value,
+            fields: fulltextSearchFields,
+            type: 'cross_fields',
+            operator: 'and',
+          },
+        },
+        {
+          multi_match: {
+            query: value,
+            fields: fulltextSearchFields,
+            type: 'phrase_prefix',
+            operator: 'and',
+          },
+        },
+      ],
+      minimum_should_match: '1',
+    },
+  };
+};
+
+export const termFilterParamToQuery = (field, value) => ({
+  terms: {
+    [field]: value.toJS(),
+  },
+});
+
+export const histogramFilterParamToQuery = (field, value, interval) => {
+  const clauses = value.map((v) => ({
+    range: {
+      [field]: {
+        gte: v,
+        lt: v + interval,
+      },
+    },
+  })).toJS();
+
+  if (clauses.length === 1) {
+    return clauses[0];
+  }
+
+  return {
+    bool: {
+      should: clauses,
+    },
+  };
+};
+
+export const filterParamToQuery = (id, value) => {
+  const filterFieldConfig = config.getFilterFieldConfig(id);
+
+  if (!filterFieldConfig) {
+    return undefined;
+  }
+
+  const {
+    field,
+    type,
+  } = filterFieldConfig;
+
+  if (type === 'histogram') {
+    return histogramFilterParamToQuery(field, value, filterFieldConfig.interval);
+  }
+
+  return termFilterParamToQuery(field, value);
+};
+
+export const getSearchQuery = (params) => fulltextParamToQuery(params.get(SEARCH_QUERY_ID));
+
+export const getFilterQueries = (params) => params
+  .delete(SEARCH_QUERY_ID)
+  .entrySeq()
+  .map(([id, value]) => filterParamToQuery(id, value))
+  .toJS();
+
+export const getQuery = (params) => {
+  const clauses = [
+    config.get('defaultQuery'),
+    getSearchQuery(params),
+    ...getFilterQueries(params),
+  ]
+    .filter((clause) => !!clause);
+
+  if (clauses.length > 1) {
+    return {
+      bool: {
+        must: clauses,
+      },
+    };
+  }
+
+  if (clauses.length > 0) {
+    return clauses[0];
+  }
+
+  return {
+    match_all: {},
+  };
+};
+
+export const getHistogramAgg = (field, interval = 1) => ({
+  histogram: {
+    field,
+    interval,
+    min_doc_count: 1,
+  },
+});
+
+export const getTermsAgg = (field, order = { _term: 'asc' }) => ({
+  terms: {
+    field,
+    order,
+    size: 300,
+  },
+});
+
+export const getFilterAgg = (filterFieldConfig) => {
+  const {
+    field,
+    order,
+    type,
+  } = filterFieldConfig;
+
+  if (type === 'histogram') {
+    return getHistogramAgg(field, filterFieldConfig.interval);
+  }
+
+  return getTermsAgg(field, order);
+};
+
+let aggs;
+
+export const getAggs = (params) => {
+  if (!aggs) {
+    aggs = {};
+
+    const filterFieldsConfig = config.get('filters').fields;
+
+    Object.entries(filterFieldsConfig).forEach(([id, filterFieldConfig]) => {
+      const param = params.get(id);
+      const hasValue = param && param.size > 0;
+
+      if (!hasValue) {
+        aggs[id] = getFilterAgg(filterFieldConfig);
+      }
+    });
+  }
+
+  return aggs;
+};
+
+export const getSort = (params) => {
+  const sortOrder = params.get(SORT_ID) || config.get('defaultSortOrder');
+
+  const effectiveSortOrder = (sortOrder === 'bestmatch' && params.delete(SORT_ID).isEmpty())
+    ? 'newest'
+    : sortOrder;
+
+  switch (effectiveSortOrder) {
+    case 'bestmatch':
+      return [
+        {
+          _score: {
+            order: 'desc',
+          },
+        },
+        {
+          [config.get('sortField')]: {
+            order: 'asc',
+          },
+        },
+      ];
+    case 'atoz':
+      return {
+        [config.get('sortField')]: {
+          order: 'asc',
+        },
+      };
+    case 'ztoa':
+      return {
+        [config.get('sortField')]: {
+          order: 'desc',
+        },
+      };
+    case 'newest':
+      return {
+        'collectionspace_core:createdAt': {
+          order: 'desc',
+        },
+      };
+    case 'oldest':
+      return {
+        'collectionspace_core:createdAt': {
+          order: 'asc',
+        },
+      };
+    default:
+      return {};
+  }
+};
+
+export const getSearchResultPayload = (params, pageSize, offset) => ({
+  query: getQuery(params.delete(SORT_ID)),
+  from: offset,
+  size: pageSize,
+  _source: {
+    includes: config.get('includeFields'),
+  },
+  sort: getSort(params),
+});

package/src/helpers/formatHelpers.jsx

@@ -0,0 +1,361 @@
+import React from 'react';
+import get from 'lodash/get';
+import qs from 'qs';
+import { Link } from 'react-router-dom';
+import { getDisplayName } from 'cspace-refname';
+import FieldValueList from '../components/detail/FieldValueList';
+import linkStyles from '../../styles/cspace/Link.css';
+
+export const renderLink = (url, text, type) => {
+  if (!url) {
+    return text;
+  }
+
+  if (type === 'external') {
+    const fullUrl = !url.startsWith('http') ? `http://${url}` : url;
+    const content = text || url;
+
+    // Make sure urls with no spaces are able to wrap anywhere.
+
+    const inlineStyle = content.startsWith('http')
+      ? { overflowWrap: 'anywhere' }
+      : undefined;
+
+    return (
+      <a
+        className={linkStyles[type]}
+        href={fullUrl}
+        rel="noopener noreferrer"
+        style={inlineStyle}
+        target="_blank"
+      >
+        {content}
+      </a>
+    );
+  }
+
+  return <Link className={type && linkStyles[type]} to={url}>{text || url}</Link>;
+};
+
+export const renderFilterLink = (filterId, filterValue, linkText) => {
+  if (!filterValue) {
+    return null;
+  }
+
+  const values = [filterValue];
+  const query = qs.stringify({ [filterId]: JSON.stringify(values) });
+
+  return renderLink(
+    `/search?${query}`,
+    typeof linkText === 'undefined' ? filterValue : linkText,
+  );
+};
+
+export const renderJoined = (parts, separator = '') => {
+  const nonEmptyParts = parts.filter(
+    (part) => (typeof part !== 'undefined' && part !== null && part !== ''),
+  );
+
+  if (nonEmptyParts.length === 0) {
+    return null;
+  }
+
+  const separatorElement = (separator === '\n') ? <br /> : separator;
+
+  return nonEmptyParts.reduce((joinedParts, nextPart) => (
+    // eslint-disable-next-line react/jsx-one-expression-per-line
+    <span>{joinedParts}{separatorElement}{nextPart}</span>
+  ));
+};
+
+const renderList = (values, inline = false) => {
+  if (Array.isArray(values)) {
+    if (values.length > 1) {
+      return (
+        <FieldValueList inline={inline}>
+          {/* eslint-disable-next-line react/no-array-index-key */}
+          {values.map((value, index) => <li key={index}>{value}</li>)}
+        </FieldValueList>
+      );
+    }
+
+    return values[0];
+  }
+
+  return values;
+};
+
+export const unformatted = (data) => data;
+
+export const boolean = (value) => {
+  switch (value) {
+    case 0:
+      return 'No';
+    case 1:
+      return 'Yes';
+    default:
+      return value;
+  }
+};
+
+export const literal = (value) => () => value;
+
+export const collectionValue = (value) => value.replace('_', '-');
+
+export const objectTypeValue = (value) => value.replace('_', '-');
+
+export const lines = (values) => values && values.join('\n');
+
+export const list = (values) => renderList(values);
+
+export const inlineList = (values) => renderJoined(values, ', ');
+
+export const listOf = (format) => (array, fieldName) => (
+  renderList(array.map((value) => format(value, fieldName)))
+);
+
+export const inlineListOf = (format) => (array, fieldName) => (
+  renderJoined(array.map((value) => format(value, fieldName)), ', ')
+);
+
+export const displayName = (value) => (getDisplayName(value) || value);
+
+export const displayNameFrom = (name) => (data) => displayName(data[name]);
+
+export const unqualifiedFieldName = (data, fieldName) => {
+  const parts = fieldName.split(':');
+
+  return (parts.length > 1 ? parts[1] : parts[0]);
+};
+
+export const filterLink = (config) => (data, fieldName) => {
+  const {
+    filterIdFormat = unqualifiedFieldName,
+    filterValueFormat = unformatted,
+    linkTextFormat,
+  } = config;
+
+  const formattedFilterId = filterIdFormat(data, fieldName);
+  const formattedFilterValue = filterValueFormat(data, fieldName);
+
+  const formattedLinkText = linkTextFormat
+    ? linkTextFormat(data, fieldName)
+    : formattedFilterValue;
+
+  return renderFilterLink(
+    formattedFilterId,
+    formattedFilterValue,
+    formattedLinkText,
+  );
+};
+
+export const linkNote = (urlField, noteField, separator = ' - ') => (object) => {
+  const {
+    [noteField]: note,
+    [urlField]: url,
+  } = object;
+
+  const link = renderLink(url);
+
+  return (
+    <>
+      {/* eslint-disable-next-line react/jsx-one-expression-per-line */}
+      {link}{link && note && separator}{note}
+    </>
+  );
+};
+
+export const linkedDisplayName = (filterId) => (data) => (
+  renderFilterLink(filterId, displayName(data))
+);
+
+export const linkText = (config) => (data) => {
+  const {
+    urlFieldName,
+    textFieldName,
+    type,
+  } = config;
+
+  return renderLink(data[urlFieldName], data[textFieldName], type);
+};
+
+export const nameValue = (config) => (data, fieldName) => {
+  const {
+    nameFormat,
+    valueFormat,
+    separator = ': ',
+  } = config;
+
+  const formattedName = nameFormat(data, fieldName);
+  const formattedValue = valueFormat(data, fieldName);
+
+  const parts = [
+    formattedName,
+    formattedValue,
+  ];
+
+  return renderJoined(parts, separator);
+};
+
+export const property = (config) => (data) => {
+  const {
+    nameFieldName,
+    valueFieldName,
+    separator = ': ',
+  } = config;
+
+  const parts = [
+    renderFilterLink(nameFieldName, displayName(data[nameFieldName])),
+    data[valueFieldName],
+  ];
+
+  return renderJoined(parts, separator);
+};
+
+export const nameRole = (config) => (data) => {
+  const {
+    nameFieldName,
+    roleFieldName,
+    linkName = true,
+    separator = ' ',
+  } = config;
+
+  const name = displayName(data[nameFieldName]);
+
+  let role = displayName(data[roleFieldName]);
+
+  if (role) {
+    role = `(${role})`;
+  }
+
+  const parts = [
+    linkName ? renderFilterLink(nameFieldName, name) : name,
+    role,
+  ];
+
+  return renderJoined(parts, separator);
+};
+
+export const valueWithNote = (config) => (data) => {
+  const {
+    valueFieldName,
+    noteFieldName,
+    linkValue = true,
+    separator = '\n',
+    noteLabel = 'Note: ',
+  } = config;
+
+  const value = displayName(data[valueFieldName]);
+
+  let note = data[noteFieldName];
+
+  if (note) {
+    note = `${noteLabel}${note}`;
+  }
+
+  const parts = [
+    linkValue ? renderFilterLink(valueFieldName, value) : value,
+    note,
+  ];
+
+  return renderJoined(parts, separator);
+};
+
+export const numericRange = (config) => (data) => {
+  const {
+    linkQualifier,
+    lowFieldName,
+    highFieldName,
+    unitFieldName,
+    qualifierFieldName,
+    qualifierSeparator = ' ',
+  } = config;
+
+  let {
+    unit,
+  } = config;
+
+  const low = data[lowFieldName];
+  const high = data[highFieldName];
+  const range = [low, high].filter((part) => !!part).join('-');
+
+  if (range) {
+    unit = unit || displayName(data[unitFieldName]);
+  } else {
+    unit = null;
+  }
+
+  const qualifier = displayName(data[qualifierFieldName]);
+  const rangeUnit = renderJoined([range, unit], ' ');
+
+  return renderJoined([
+    rangeUnit,
+    linkQualifier ? renderFilterLink(qualifierFieldName, qualifier) : qualifier,
+  ], qualifierSeparator);
+};
+
+export const paragraphs = (array) => (
+  // eslint-disable-next-line react/no-array-index-key
+  array && array.length > 0 && array.map((value, index) => <p key={index}>{value}</p>)
+);
+
+export const valueAt = (config) => (data) => {
+  const {
+    path,
+    format = unformatted,
+  } = config;
+
+  const value = get(data, path);
+  const fieldName = Array.isArray(path) ? path[path.length - 1] : path;
+
+  return format(value, fieldName);
+};
+
+export const pickFromList = (config) => (array) => {
+  const {
+    condition,
+    format,
+  } = config;
+
+  const {
+    path,
+    value: targetValue,
+  } = condition;
+
+  const value = array.find((candidateItem) => {
+    const candidateValue = path ? get(candidateItem, path) : candidateItem;
+
+    return (candidateValue === targetValue);
+  });
+
+  return (format ? format(value) : value);
+};
+
+export const pickAllFromList = (config) => (array) => {
+  const {
+    condition,
+    format,
+  } = config;
+
+  const {
+    path,
+    value: targetValue,
+  } = condition;
+
+  const values = array.filter((candidateItem) => {
+    const candidateValue = path ? get(candidateItem, path) : candidateItem;
+
+    return (candidateValue === targetValue);
+  });
+
+  return renderJoined((format ? values.map(format) : values), '\n');
+};
+
+export const decade = (startYear) => {
+  const endYear = startYear + 9;
+
+  return `${startYear}–${endYear}`;
+};
+
+// eslint-disable-next-line react/no-danger
+export const html = (value) => <div dangerouslySetInnerHTML={{ __html: value }} />;

package/src/helpers/searchDimensions.js

@@ -0,0 +1,21 @@
+/* global window */
+
+import cssDimensions from '../../styles/dimensions.css';
+
+const {
+  searchResultTileWidth: cssTileWidth,
+  searchResultTileBodyHeight: cssTileBodyHeight,
+} = cssDimensions;
+
+export const tileWidth = parseInt(cssTileWidth, 10);
+export const tileBodyHeight = parseInt(cssTileBodyHeight, 10);
+export const tileHeight = tileWidth + tileBodyHeight;
+
+export function calculateSearchPageSize() {
+  const width = window.innerWidth;
+  const height = window.innerHeight;
+  const ratio = window.devicePixelRatio || 1;
+  const pageSize = ((width / tileWidth) * (height / tileHeight + 2)) / ratio;
+
+  return Math.max(Math.ceil(pageSize), 12);
+}

package/src/helpers/urlHelpers.js

@@ -0,0 +1,49 @@
+import qs from 'qs';
+import Immutable from 'immutable';
+
+export const blobUrl = (gatewayUrl, mediaCsid, derivative) => (
+  `${gatewayUrl}/cspace-services/media/${mediaCsid}/blob/derivatives/${derivative}/content`
+);
+
+export const searchParamsToQueryString = (params) => qs.stringify(
+  params.map((value) => (value && JSON.stringify(value)))
+    .filter((value) => !!value)
+    .toJS(),
+  { format: 'RFC1738' },
+);
+
+export const locationToSearchParams = (location) => (
+  Immutable.Map(qs.parse(location.search, { ignoreQueryPrefix: true }))
+    .filter((value) => !!value)
+    .map((value) => Immutable.fromJS(JSON.parse(value)))
+);
+
+export const locationToDetailParams = (location, match) => {
+  let params = Immutable.fromJS(match.params);
+
+  const {
+    hash,
+    state,
+  } = location;
+
+  if (hash) {
+    params = params.set('#', hash.substring(1));
+  }
+
+  if (state) {
+    const {
+      index,
+      searchParams,
+    } = state;
+
+    if (typeof index !== 'undefined') {
+      params = params.set('index', index);
+    }
+
+    if (typeof searchParams !== 'undefined') {
+      params = params.set('searchParams', Immutable.fromJS(searchParams));
+    }
+  }
+
+  return params;
+};