geonetwork-ui 2.10.3-dev.4154db07d → 2.11.0-dev.0ddf1324b

package/src/libs/api/metadata-converter/src/lib/gn4/gn4.field.mapper.ts

@@ -15,9 +15,11 @@ import {
 } from './atomic-operations'
 import { MetadataUrlService } from './metadata-url.service'
 import { inject, Injectable } from '@angular/core'
+import { getAssociationTypeFromCode } from '../iso19139/utils/association-type.mapper'
 import { getStatusFromStatusCode } from '../iso19139/utils/status.mapper'
 import { getUpdateFrequencyFromFrequencyCode } from '../iso19139/utils/update-frequency.mapper'
 import {
+  AssociatedRecord,
   CatalogRecord,
   Constraint,
   DatasetSpatialExtent,
@@ -318,25 +320,16 @@ export class Gn4FieldMapper {
         output
       ),
     related: (output, source) => {
+      const related = <SourceWithUnknownProps>selectField(source, 'related')
       const fcatSource = selectField(
-        getFirstValue(
-          selectField(
-            <SourceWithUnknownProps>selectField(source, 'related'),
-            'fcats'
-          )
-        ) ?? {},
+        getFirstValue(selectField(related, 'fcats')) ?? {},
         '_source'
       )
       const featureCatalogIdentifier: string = selectField(
         <SourceWithUnknownProps>fcatSource,
         'uuid'
       )
-      const sourceOfLinks = getAsArray(
-        selectField(
-          <SourceWithUnknownProps>selectField(source, 'related'),
-          'hassources'
-        )
-      )
+      const sourceOfLinks = getAsArray(selectField(related, 'hassources'))
       const sourceOfIdentifiers: string[] = sourceOfLinks
         .filter((link) => link['origin'] === 'catalog')
         .map((link) => {
@@ -345,13 +338,50 @@ export class Gn4FieldMapper {
             'uuid'
           )
         })
-      const extraValues: Record<string, string | string[]> = {}
+      const siblingLinks = getAsArray(selectField(related, 'siblings'))
+      const siblings: AssociatedRecord[] = siblingLinks
+        .filter((link) => link['origin'] === 'catalog')
+        .map((link) => ({
+          uniqueIdentifier: selectField<string>(
+            selectField(<SourceWithUnknownProps>link, '_source'),
+            'uuid'
+          ),
+          associationType: getAssociationTypeFromCode(
+            selectField<string>(
+              selectField(<SourceWithUnknownProps>link, 'properties'),
+              'associationType'
+            )
+          ),
+        }))
+      const associatedLinks = getAsArray(selectField(related, 'associated'))
+      const associatedIdentifiers: string[] = associatedLinks
+        .filter((link) => link['origin'] === 'catalog')
+        .map((link) => {
+          return selectField<string>(
+            selectField(<SourceWithUnknownProps>link, '_source'),
+            'uuid'
+          )
+        })
+        .filter(
+          (uuid) =>
+            !siblings.some((sibling) => sibling.uniqueIdentifier === uuid)
+        )
+      const extraValues: Record<
+        string,
+        string | string[] | AssociatedRecord[]
+      > = {}
       if (featureCatalogIdentifier) {
         extraValues.featureCatalogIdentifier = featureCatalogIdentifier
       }
       if (sourceOfIdentifiers && sourceOfIdentifiers.length > 0) {
         extraValues.sourceOfIdentifiers = sourceOfIdentifiers
       }
+      if (associatedIdentifiers && associatedIdentifiers.length > 0) {
+        extraValues.associatedIdentifiers = associatedIdentifiers
+      }
+      if (siblings && siblings.length > 0) {
+        extraValues.siblings = siblings
+      }
       return Object.keys(extraValues).length > 0
         ? this.addExtra(extraValues, output)
         : output

package/src/libs/api/metadata-converter/src/lib/gn4/types/elasticsearch.model.ts

@@ -2,7 +2,19 @@ export type SortOrder = 'asc' | 'desc'
 interface SortParam {
   [key: string]: SortOrder
 }
-export type SortParams = string | SortParam | (string | SortParam)[]
+type EsFieldSort = {
+  order: SortOrder
+  mode?: 'max' | 'min'
+  missing?: '_last'
+  nested?: {
+    path: string
+  }
+}
+export type SortParams =
+  | string
+  | SortParam
+  | { [property: string]: EsFieldSort }
+  | (string | SortParam | { [property: string]: EsFieldSort })[]
 
 export interface EsRequestAggTerm {
   field?: string

package/src/libs/api/metadata-converter/src/lib/iso19115-3/write-parts.ts

@@ -587,7 +587,7 @@ export function writeAssociatedRecords(
     removeChildrenByName('mri:associatedResource'),
     appendChildren(
       ...record.associatedRecords
-        .filter((assoc) => assoc.uuid && assoc.associationType)
+        .filter((assoc) => assoc.uniqueIdentifier && assoc.associationType)
         .map((assoc) =>
           pipe(
             createNestedElement(
@@ -608,7 +608,7 @@ export function writeAssociatedRecords(
               ),
               pipe(
                 createElement('mri:metadataReference'),
-                writeAttribute('uuidref', assoc.uuid)
+                writeAttribute('uuidref', assoc.uniqueIdentifier)
               )
             )
           )

package/src/libs/api/metadata-converter/src/lib/iso19139/read-parts.ts

@@ -51,6 +51,7 @@ import {
   readText,
   XmlElement,
 } from '../xml-utils'
+import { getAssociationTypeFromCode } from './utils/association-type.mapper'
 import { readGeometry } from './utils/geometry'
 import { fullNameToParts } from './utils/individual-name'
 import { getKeywordTypeFromKeywordTypeCode } from './utils/keyword.mapper'
@@ -931,19 +932,22 @@ export function readSourceRecords(rootEl: XmlElement): SourceRecord[] {
 export function extractAssociatedRecords(
   containerName: string,
   aggregateName: string,
-  readUuid: ChainableFunction<XmlElement, string>
+  readIdentifier: ChainableFunction<XmlElement, string>
 ): ChainableFunction<XmlElement, AssociatedRecord[]> {
   return pipe(
     findChildrenElement(containerName, false),
     mapArray((el) => {
       const aggregateEl = findChildElement(aggregateName, false)(el)
-      const uuid = readUuid(aggregateEl)
-      const associationType = pipe(
+      const uniqueIdentifier = readIdentifier(aggregateEl)
+      const associationTypeCode = pipe(
         findNestedElement('gmd:associationType', 'gmd:DS_AssociationTypeCode'),
         readAttribute('codeListValue')
       )(aggregateEl)
-      if (!uuid || !associationType) return null
-      return { uuid, associationType }
+      if (!uniqueIdentifier || !associationTypeCode) return null
+      return {
+        uniqueIdentifier,
+        associationType: getAssociationTypeFromCode(associationTypeCode),
+      }
     }),
     filterArray((r): r is AssociatedRecord => r !== null)
   )

package/src/libs/api/metadata-converter/src/lib/iso19139/utils/association-type.mapper.ts

@@ -0,0 +1,12 @@
+import {
+  AssociationType,
+  associationTypeValues,
+} from '../../../../../../../libs/common/domain/src/lib/model/record'
+
+export function getAssociationTypeFromCode(
+  associationTypeCode: string
+): AssociationType {
+  return associationTypeValues.includes(associationTypeCode as AssociationType)
+    ? (associationTypeCode as AssociationType)
+    : 'crossReference'
+}

package/src/libs/api/metadata-converter/src/lib/iso19139/write-parts.ts

@@ -1276,7 +1276,7 @@ export function writeAssociatedRecords(
     removeChildrenByName('gmd:aggregationInfo'),
     appendChildren(
       ...record.associatedRecords
-        .filter((assoc) => assoc.uuid && assoc.associationType)
+        .filter((assoc) => assoc.uniqueIdentifier && assoc.associationType)
         .map((assoc) =>
           pipe(
             createNestedElement(
@@ -1290,7 +1290,7 @@ export function writeAssociatedRecords(
                   'gmd:MD_Identifier',
                   'gmd:code'
                 ),
-                writeCharacterString(assoc.uuid)
+                writeCharacterString(assoc.uniqueIdentifier)
               ),
               pipe(
                 createNestedElement(

package/src/libs/api/repository/src/lib/gn4/elasticsearch/elasticsearch.service.ts

@@ -11,6 +11,7 @@ import {
   AggregationsParams,
   FieldFilter,
   FieldFilters,
+  FieldSort,
   FilterQuery,
   FiltersAggregationParams,
   SortByField,
@@ -33,7 +34,12 @@ import {
   LanguageCode,
 } from '../../../../../../../libs/common/domain/src/lib/model/record'
 import { TranslateService } from '@ngx-translate/core'
-import { getGeometryBoundingBox } from '../../../../../../../libs/util/shared/src'
+import {
+  bboxToPolygon,
+  BoundingBox,
+  getGeometryBoundingBox,
+  isBoundingBox,
+} from '../../../../../../../libs/util/shared/src'
 import { getLength as getGeodesicLength } from 'ol/sphere.js'
 import { LineString } from 'ol/geom.js'
 
@@ -48,7 +54,10 @@ export class ElasticsearchService {
 
   // runtime fields are computed using a Painless script
   // see: https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-mapping-fields.html
-  private runtimeFields: Record<string, string> = {}
+  private runtimeFields: Record<
+    string,
+    { script: string; type: 'keyword' | 'date' }
+  > = {}
 
   // we're using getters in case the defined languages change over time
   private get metadataLang(): LanguageCode {
@@ -90,8 +99,8 @@ export class ElasticsearchService {
     const addMapping = (fieldName: string) => {
       if (!payload.runtime_mappings) payload.runtime_mappings = {}
       payload.runtime_mappings[fieldName] = {
-        type: 'keyword',
-        script: this.runtimeFields[fieldName],
+        type: this.runtimeFields[fieldName].type,
+        script: this.runtimeFields[fieldName].script,
       }
     }
     const lookForField = (node: unknown) => {
@@ -112,6 +121,14 @@ export class ElasticsearchService {
         ) {
           addMapping(runtimeField)
         }
+        if (
+          runtimeField in node &&
+          typeof node[runtimeField] === 'object' &&
+          node[runtimeField] !== null &&
+          ('gte' in node[runtimeField] || 'lte' in node[runtimeField])
+        ) {
+          addMapping(runtimeField)
+        }
         if (
           'query' in node &&
           typeof node.query === 'string' &&
@@ -130,8 +147,12 @@ export class ElasticsearchService {
     return payload
   }
 
-  registerRuntimeField(fieldName: string, expression: string) {
-    this.runtimeFields[fieldName] = expression
+  registerRuntimeField(
+    fieldName: string,
+    expression: string,
+    type: 'keyword' | 'date' = 'keyword'
+  ) {
+    this.runtimeFields[fieldName] = { script: expression, type }
   }
 
   getMetadataByIdsPayload(uuids: string[]): EsSearchParams {
@@ -141,6 +162,7 @@ export class ElasticsearchService {
           values: uuids,
         },
       },
+      size: uuids.length,
     }
   }
 
@@ -199,9 +221,27 @@ export class ElasticsearchService {
   }
 
   private buildPayloadSort(sortBy: SortByField): SortParams {
-    if (sortBy === null) return undefined
-    const fields = Array.isArray(sortBy[0]) ? sortBy : [sortBy]
-    return fields.map((field) => ({ [field[1]]: field[0] }))
+    if (!sortBy || sortBy.length === 0) return undefined
+    const fields = Array.isArray(sortBy[0])
+      ? (sortBy as FieldSort[])
+      : [sortBy as FieldSort]
+    return fields.map((field) => {
+      // Sort by nested array of dates only works with the explicit syntax
+      if (field[1].endsWith('.date')) {
+        const nestedPath = field[1].slice(0, field[1].lastIndexOf('.date'))
+        return {
+          [field[1]]: {
+            order: field[0] as 'desc' | 'asc',
+            mode: field[0] === 'desc' ? 'max' : 'min',
+            missing: '_last',
+            nested: {
+              path: nestedPath,
+            },
+          },
+        }
+      }
+      return { [field[1]]: field[0] }
+    })
   }
 
   private injectLangInQueryStringFields(
@@ -244,8 +284,55 @@ export class ElasticsearchService {
     return this.metadataLang === 'current'
   }
 
-  private filtersToQuery(
+  private findSpatialFilterExtent(
     filters: FieldFilters | FiltersAggregationParams | string
+  ): BoundingBox | undefined {
+    if (typeof filters === 'string') {
+      return undefined
+    }
+    return Object.values(filters).find(isBoundingBox)
+  }
+
+  // if a field registered min/max runtime fields, its dates form an interval
+  // the record matches if that interval intersects the filter range
+  private buildDateRangeQuery(searchField: string, dateRange: DateRange) {
+    const minField = `${searchField}Min`
+    const maxField = `${searchField}Max`
+    if (minField in this.runtimeFields && maxField in this.runtimeFields) {
+      const filter = [
+        dateRange.start && {
+          range: {
+            [maxField]: {
+              gte: formatDate(dateRange.start),
+              format: 'yyyy-MM-dd',
+            },
+          },
+        },
+        dateRange.end && {
+          range: {
+            [minField]: {
+              lte: formatDate(dateRange.end),
+              format: 'yyyy-MM-dd',
+            },
+          },
+        },
+      ].filter(Boolean)
+      return { bool: { filter } }
+    }
+    return {
+      range: {
+        [searchField]: {
+          ...(dateRange.start && { gte: formatDate(dateRange.start) }),
+          ...(dateRange.end && { lte: formatDate(dateRange.end) }),
+          format: 'yyyy-MM-dd',
+        },
+      },
+    }
+  }
+
+  private filtersToQuery(
+    filters: FieldFilters | FiltersAggregationParams | string,
+    spatialFilterExtent = this.findSpatialFilterExtent(filters)
   ): FilterQuery {
     const addQuote = (key: string) => (/^\/.+\/$/.test(key) ? key : `"${key}"`)
     const makeQuery = (filter: FieldFilter): string => {
@@ -266,7 +353,9 @@ export class ElasticsearchService {
         ? filters
         : Object.keys(filters)
             .filter((fieldname) => fieldname !== 'gn-ui-crossFieldFilter')
+            .filter((fieldname) => !isBoundingBox(filters[fieldname]))
             .filter((fieldname) => !isDateRange(filters[fieldname]))
+            .filter((fieldname) => !Array.isArray(filters[fieldname]))
             .filter(
               (fieldname) =>
                 filters[fieldname] &&
@@ -279,37 +368,33 @@ export class ElasticsearchService {
     if (filters['gn-ui-crossFieldFilter']) {
       queryString = `${queryString} AND (${filters['gn-ui-crossFieldFilter']})`
     }
-    const queryRange = Object.entries(filters)
-      .filter(([, value]) => isDateRange(value))
-      .map(([searchField, dateRange]) => {
-        return {
-          searchField,
-          dateRange,
-        } as {
-          searchField: string
-          dateRange: DateRange
-        }
-      })[0]
+    const queryRanges = Object.entries(filters).filter(([, value]) =>
+      isDateRange(value)
+    ) as [string, DateRange][]
     const queryParts = [
       queryString && {
         query_string: {
           query: queryString,
         },
       },
-      queryRange &&
-        queryRange.dateRange && {
-          range: {
-            [queryRange.searchField]: {
-              ...(queryRange.dateRange.start && {
-                gte: formatDate(queryRange.dateRange.start),
-              }),
-              ...(queryRange.dateRange.end && {
-                lte: formatDate(queryRange.dateRange.end),
-              }),
-              format: 'yyyy-MM-dd',
+      ...queryRanges.map(([searchField, dateRange]) =>
+        this.buildDateRangeQuery(searchField, dateRange)
+      ),
+      spatialFilterExtent && {
+        geo_shape: {
+          geom: {
+            shape: {
+              type: 'envelope',
+              // spatialFilterExtent is [minX, minY, maxX, maxY]; envelope coordinates are [top-left, bottom-right]
+              coordinates: [
+                [spatialFilterExtent[0], spatialFilterExtent[3]],
+                [spatialFilterExtent[2], spatialFilterExtent[1]],
+              ],
             },
+            relation: 'intersects',
           },
         },
+      },
     ].filter(Boolean)
     return queryParts.length > 0 ? (queryParts as FilterQuery) : undefined
   }
@@ -348,7 +433,12 @@ export class ElasticsearchService {
         },
       })
     }
-    const queryFilters = this.filtersToQuery(fieldSearchFilters)
+    // a spatial extent filter takes precedence over the preference geometry for boosting
+    const spatialFilterExtent = this.findSpatialFilterExtent(fieldSearchFilters)
+    const queryFilters = this.filtersToQuery(
+      fieldSearchFilters,
+      spatialFilterExtent
+    )
     if (queryFilters) {
       filter.push(...queryFilters)
     }
@@ -359,7 +449,10 @@ export class ElasticsearchService {
         },
       })
     }
-    if (geometry) {
+    const boostGeometry = spatialFilterExtent
+      ? bboxToPolygon(spatialFilterExtent)
+      : geometry
+    if (boostGeometry) {
       // boosts applied using the filter geometry:
       // * records completely within the geometry receive a boost of 5
       // * records intersecting the geometry receive a boost of 2
@@ -369,7 +462,7 @@ export class ElasticsearchService {
         {
           geo_shape: {
             geom: {
-              shape: geometry,
+              shape: boostGeometry,
               relation: 'within',
             },
             boost: 5.0,
@@ -378,7 +471,7 @@ export class ElasticsearchService {
         {
           geo_shape: {
             geom: {
-              shape: geometry,
+              shape: boostGeometry,
               relation: 'intersects',
             },
             boost: 2.0,
@@ -389,7 +482,7 @@ export class ElasticsearchService {
       // this will boost the results variably depending on their distance from the given geometry
       // note: this takes into account the `location` field of a record; this is generally the center of all spatial extents
       // combined, and thus the actual size/coverage of the record spatial extent isn't relevant here
-      const bbox = getGeometryBoundingBox(geometry)
+      const bbox = getGeometryBoundingBox(boostGeometry)
       const center = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]
       const northToCenter = new LineString([
         [center[0], bbox[3]],

package/src/libs/api/repository/src/lib/gn4/gn4-repository.ts

@@ -14,10 +14,13 @@ import {
 } from '../../../../../../libs/api/metadata-converter/src'
 import { PublicationVersionError } from '../../../../../../libs/common/domain/src/lib/model/error'
 import {
+  AssociatedRecord,
   CatalogRecord,
   DatasetFeatureCatalog,
   DatasetFeatureType,
   LanguageCode,
+  LinkedRecord,
+  RecordRelation,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
 import {
   Aggregations,
@@ -145,7 +148,7 @@ export class Gn4Repository implements RecordsRepositoryInterface {
     return this.gn4SearchApi
       .search(
         'bucket',
-        ['fcats', 'hassources'],
+        ['fcats', 'hassources', 'siblings', 'associated'],
         JSON.stringify(
           this.gn4SearchHelper.getMetadataByIdsPayload([uniqueIdentifier])
         )
@@ -249,22 +252,43 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       )
   }
 
-  getSources(record: CatalogRecord): Observable<CatalogRecord[]> {
-    const sourcesIdentifiers = record.extras?.['sourcesIdentifiers'] as string[]
-    if (sourcesIdentifiers && sourcesIdentifiers.length > 0) {
-      return this.getMultipleRecords(sourcesIdentifiers)
-    }
-    return of(null)
-  }
-
-  getSourceOf(record: CatalogRecord): Observable<CatalogRecord[]> {
-    const sourceOfIdentifiers = record.extras?.[
-      'sourceOfIdentifiers'
-    ] as string[]
-    if (sourceOfIdentifiers && sourceOfIdentifiers.length > 0) {
-      return this.getMultipleRecords(sourceOfIdentifiers)
+  getLinkedRecords(record: CatalogRecord): Observable<LinkedRecord[]> {
+    const siblings = (record.extras?.['siblings'] ?? []) as AssociatedRecord[]
+    const relations: Array<[RecordRelation, string[]]> = [
+      ['source', (record.extras?.['sourcesIdentifiers'] ?? []) as string[]],
+      ['sourceOf', (record.extras?.['sourceOfIdentifiers'] ?? []) as string[]],
+      ['sibling', siblings.map(({ uniqueIdentifier }) => uniqueIdentifier)],
+      [
+        'associated',
+        (record.extras?.['associatedIdentifiers'] ?? []) as string[],
+      ],
+    ]
+    const requested = relations.filter(
+      ([, identifiers]) => identifiers.length > 0
+    )
+    if (requested.length === 0) {
+      return of([])
     }
-    return of(null)
+    return forkJoin(
+      requested.map(([relation, identifiers]) =>
+        this.getMultipleRecords(identifiers).pipe(
+          map((records) =>
+            (records ?? []).map((record) => ({
+              record,
+              relation,
+              associationType:
+                relation === 'sibling'
+                  ? siblings.find(
+                      ({ uniqueIdentifier }) =>
+                        uniqueIdentifier === record.uniqueIdentifier
+                    )?.associationType
+                  : undefined,
+            }))
+          ),
+          catchError(() => of([]))
+        )
+      )
+    ).pipe(map((groups) => groups.flat()))
   }
 
   aggregate(params: AggregationsParams): Observable<Aggregations> {

package/src/libs/common/domain/src/lib/model/record/metadata.model.ts

@@ -260,12 +260,50 @@ export interface SourceRecord {
   href?: string
 }
 
+marker('domain.record.associationType.crossReference')
+marker('domain.record.associationType.largerWorkCitation')
+marker('domain.record.associationType.partOfSeamlessDatabase')
+marker('domain.record.associationType.stereoMate')
+marker('domain.record.associationType.isComposedOf')
+marker('domain.record.associationType.collectiveTitle')
+marker('domain.record.associationType.series')
+marker('domain.record.associationType.dependency')
+marker('domain.record.associationType.revisionOf')
+
+// DS_AssociationTypeCode values of the ISO19115-3 codelist, any unrecognized value
+// being mapped to 'crossReference'
+export const associationTypeValues = [
+  'crossReference',
+  'largerWorkCitation',
+  'partOfSeamlessDatabase',
+  'stereoMate',
+  'isComposedOf',
+  'collectiveTitle',
+  'series',
+  'dependency',
+  'revisionOf',
+] as const
+
+export type AssociationType = (typeof associationTypeValues)[number]
+
 /**
  * Represents another record associated with this one (e.g. a parent/sibling dataset).
  */
 export interface AssociatedRecord {
-  uuid: string
-  associationType: string
+  uniqueIdentifier: string
+  associationType: AssociationType
+}
+
+/**
+ * Nature of the link between a record and another one; the association type is
+ * only known for 'sibling' relations, as it is held by the declaring record.
+ */
+export type RecordRelation = 'source' | 'sourceOf' | 'sibling' | 'associated'
+
+export interface LinkedRecord {
+  record: CatalogRecord
+  relation: RecordRelation
+  associationType?: AssociationType
 }
 
 export interface DatasetRecord extends BaseRecord {

package/src/libs/common/domain/src/lib/model/search/filter.model.ts

@@ -6,11 +6,15 @@ export type FieldFilterByRange = {
   start?: Date
   end?: Date
 }
+// matches util/shared's BoundingBox; duplicated here to avoid a circular
+// dependency (util/shared already depends on common/domain)
+export type FieldFilterByBoundingBox = [number, number, number, number]
 
 export type FieldFilter =
   | FieldFilterByExpression
   | FieldFilterByValues
   | FieldFilterByRange
+  | FieldFilterByBoundingBox
 export type FieldFilters = Record<FieldName, FieldFilter>
 
 export type QueryString = {
@@ -19,4 +23,19 @@ export type QueryString = {
 export type QueryRange = {
   range: Record<string, { format: string; gte: string; lte: string }>
 }
-export type FilterQuery = Array<QueryString | QueryRange>
+export type QueryGeoShape = {
+  geo_shape: {
+    geom: {
+      shape: { type: string; coordinates: number[][] }
+      relation: string
+    }
+  }
+}
+export type QueryBool = {
+  bool: {
+    filter: QueryRange[]
+  }
+}
+export type FilterQuery = Array<
+  QueryString | QueryRange | QueryGeoShape | QueryBool
+>

package/src/libs/common/domain/src/lib/model/search/sort-by.model.ts

@@ -6,9 +6,5 @@ export const SortByEnum: Record<string, SortByField> = {
   RELEVANCY: ['desc', '_score'],
   QUALITY_SCORE: ['desc', 'qualityScore'],
   CHANGE_DATE: ['desc', 'changeDate'],
-  RESOURCE_DATES: [
-    ['desc', 'revisionDateForResource'],
-    ['desc', 'publicationDateForResource'],
-    ['desc', 'creationDateForResource'],
-  ],
+  RESOURCE_DATE: ['desc', 'resourceDate.date'],
 }