geonetwork-ui 2.11.0-dev.0504d85cc → 2.11.0-dev.0559cfd9d

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

@@ -1,5 +1,8 @@
 import {
   CatalogRecord,
+  DatasetFeatureAttribute,
+  DatasetFeatureAttributeValue,
+  DatasetFeatureType,
   DatasetRecord,
   Individual,
   LanguageCode,
@@ -616,3 +619,131 @@ export function writeAssociatedRecords(
     )
   )(rootEl)
 }
+
+function createNilElement(name: string, nilReason: string) {
+  return pipe(createElement(name), writeAttribute('gco:nilReason', nilReason))
+}
+
+function createFeatureCatalogueShell() {
+  return pipe(
+    createNestedElement(
+      'mdb:contentInfo',
+      'mrc:MD_FeatureCatalogue',
+      'mrc:featureCatalogue',
+      'gfc:FC_FeatureCatalogue'
+    ),
+    // create mandatory elements which are not part of the model yet
+    appendChildren(
+      createNilElement('cat:name', 'missing'),
+      createNilElement('cat:scope', 'missing'),
+      createNilElement('cat:versionNumber', 'missing'),
+      createNilElement('cat:versionDate', 'missing'),
+      createNilElement('gfc:producer', 'missing')
+    )
+  )
+}
+
+function createListedValue(value: DatasetFeatureAttributeValue) {
+  return pipe(
+    createNestedElement('gfc:listedValue', 'gfc:FC_ListedValue'),
+    appendChildren(
+      value.label
+        ? pipe(createElement('gfc:label'), writeCharacterString(value.label))
+        : createNilElement('gfc:label', 'missing'),
+      value.value
+        ? pipe(createElement('gfc:code'), writeCharacterString(value.value))
+        : null,
+      value.description
+        ? pipe(
+            createElement('gfc:definition'),
+            writeCharacterString(value.description)
+          )
+        : null
+    )
+  )
+}
+
+function createFeatureAttribute(attribute: DatasetFeatureAttribute) {
+  return pipe(
+    createNestedElement(
+      'gfc:carrierOfCharacteristics',
+      'gfc:FC_FeatureAttribute'
+    ),
+    appendChildren(
+      pipe(createElement('gfc:memberName'), setTextContent(attribute.name)),
+      attribute.description
+        ? pipe(
+            createElement('gfc:definition'),
+            writeCharacterString(attribute.description)
+          )
+        : null,
+      createNilElement('gfc:cardinality', 'missing'),
+      attribute.label
+        ? pipe(
+            createElement('gfc:designation'),
+            writeCharacterString(attribute.label)
+          )
+        : null,
+      attribute.code
+        ? pipe(createElement('gfc:code'), writeCharacterString(attribute.code))
+        : null,
+      attribute.type
+        ? pipe(
+            createNestedElement('gfc:valueType', 'gco:TypeName', 'gco:aName'),
+            writeCharacterString(attribute.type)
+          )
+        : null,
+      ...(attribute.values ?? [])
+        .filter((value) => value.value || value.label)
+        .map(createListedValue)
+    )
+  )
+}
+
+function createFeatureType(featureType: DatasetFeatureType) {
+  return pipe(
+    createNestedElement('gfc:featureType', 'gfc:FC_FeatureType'),
+    appendChildren(
+      pipe(createElement('gfc:typeName'), setTextContent(featureType.name)),
+      featureType.description
+        ? pipe(
+            createElement('gfc:definition'),
+            writeCharacterString(featureType.description)
+          )
+        : null,
+      pipe(
+        createNestedElement('gfc:isAbstract', 'gco:Boolean'),
+        setTextContent('false')
+      ),
+      featureType.label
+        ? pipe(
+            createElement('gfc:designation'),
+            writeCharacterString(featureType.label)
+          )
+        : null,
+      ...featureType.attributes.map(createFeatureAttribute),
+      createNilElement('gfc:featureCatalogue', 'missing')
+    )
+  )
+}
+
+export function writeFeatureTypeDescriptions(
+  record: DatasetRecord,
+  rootEl: XmlElement
+) {
+  const featureTypes = record.featureTypeDescriptions ?? []
+  const catalogues = findNestedElements(
+    'mdb:contentInfo',
+    'mrc:MD_FeatureCatalogue',
+    'mrc:featureCatalogue',
+    'gfc:FC_FeatureCatalogue'
+  )(rootEl)
+  catalogues.forEach((catalogue) =>
+    removeChildrenByName('gfc:featureType')(catalogue)
+  )
+  if (!featureTypes.length) return
+
+  const catalogue =
+    catalogues[0] ?? appendChildTree(createFeatureCatalogueShell())(rootEl)
+  appendChildren(...featureTypes.map(createFeatureType))(catalogue)
+}

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

@@ -118,6 +118,7 @@ export class Iso19139Converter extends BaseConverter<string> {
     lineage: readLineage,
     sourceRecords: readSourceRecords,
     associatedRecords: readAssociatedRecords,
+    featureTypeDescriptions: () => undefined,
     onlineResources: readOnlineResources,
     temporalExtents: readTemporalExtents,
     spatialExtents: readSpatialExtents,
@@ -161,6 +162,7 @@ export class Iso19139Converter extends BaseConverter<string> {
     lineage: writeLineage,
     sourceRecords: writeSourceRecords,
     associatedRecords: writeAssociatedRecords,
+    featureTypeDescriptions: () => undefined,
     onlineResources: writeOnlineResources,
     temporalExtents: writeTemporalExtents,
     spatialExtents: writeSpatialExtents,
@@ -306,6 +308,10 @@ export class Iso19139Converter extends BaseConverter<string> {
       const sourceRecords = this.readers['sourceRecords'](rootEl, tr)
       const associatedRecords = this.readers['associatedRecords'](rootEl, tr)
       const updateFrequency = this.readers['updateFrequency'](rootEl, tr)
+      const featureTypeDescriptions = this.readers['featureTypeDescriptions'](
+        rootEl,
+        tr
+      ) as DatasetRecord['featureTypeDescriptions']
 
       return this.afterRecordRead({
         ...this.readBaseRecord(rootEl, tr),
@@ -317,6 +323,7 @@ export class Iso19139Converter extends BaseConverter<string> {
         ...(spatialRepresentation && { spatialRepresentation }),
         temporalExtents,
         updateFrequency,
+        ...(featureTypeDescriptions?.length && { featureTypeDescriptions }),
         translations: tr,
       } as DatasetRecord)
     } else if (kind === 'reuse') {
@@ -416,6 +423,8 @@ export class Iso19139Converter extends BaseConverter<string> {
 
     if (record.kind === 'dataset') {
       fieldChanged('status') && this.writers['status'](record, rootEl)
+      fieldChanged('featureTypeDescriptions') &&
+        this.writers['featureTypeDescriptions'](record, rootEl)
     }
     if (record.kind === 'dataset' || record.kind === 'reuse') {
       fieldChanged('updateFrequency') &&

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

@@ -69,7 +69,8 @@ export function extractCharacterString(): ChainableFunction<
     fallback(
       findChildElement('gco:CharacterString', false),
       findChildElement('gmx:Anchor', false),
-      findChildElement('gmx:MimeFileType', false)
+      findChildElement('gmx:MimeFileType', false),
+      findChildElement('gco:LocalName', false)
     ),
     readText()
   )

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

@@ -59,6 +59,8 @@ export class ElasticsearchService {
     { script: string; type: 'keyword' | 'date' }
   > = {}
 
+  private fieldAliases: Record<string, string> = {}
+
   // we're using getters in case the defined languages change over time
   private get metadataLang(): LanguageCode {
     const mdLangValue = this.injector.get(METADATA_LANGUAGE, null)
@@ -155,6 +157,10 @@ export class ElasticsearchService {
     this.runtimeFields[fieldName] = { script: expression, type }
   }
 
+  registerFieldAlias(fieldIdentifier: string, esFieldName: string) {
+    this.fieldAliases[fieldIdentifier] = esFieldName
+  }
+
   getMetadataByIdsPayload(uuids: string[]): EsSearchParams {
     return {
       query: {
@@ -293,12 +299,25 @@ export class ElasticsearchService {
     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
+  // builds a query matching records whose dates intersect the filter range
   private buildDateRangeQuery(searchField: string, dateRange: DateRange) {
+    // fields ending with 'DateRange' maps as ES range type
+    if (searchField.endsWith('DateRange')) {
+      return {
+        range: {
+          [searchField]: {
+            ...(dateRange.start && { gte: formatDate(dateRange.start) }),
+            ...(dateRange.end && { lte: formatDate(dateRange.end) }),
+            format: 'yyyy-MM-dd',
+            relation: 'intersects',
+          },
+        },
+      }
+    }
     const minField = `${searchField}Min`
     const maxField = `${searchField}Max`
     if (minField in this.runtimeFields && maxField in this.runtimeFields) {
+      // min/max runtime fields form an interval per record; match if it intersects the filter range
       const filter = [
         dateRange.start && {
           range: {
@@ -362,7 +381,8 @@ export class ElasticsearchService {
                 JSON.stringify(filters[fieldname]) !== '{}'
             )
             .map(
-              (fieldname) => `${fieldname}:(${makeQuery(filters[fieldname])})`
+              (fieldname) =>
+                `${this.fieldAliases[fieldname] ?? fieldname}:(${makeQuery(filters[fieldname])})`
             )
             .join(' AND ')
     if (filters['gn-ui-crossFieldFilter']) {
@@ -708,6 +728,12 @@ export class ElasticsearchService {
               order: {
                 [`_${aggregation.sort[1]}`]: aggregation.sort[0],
               },
+              ...(aggregation.includeValues && {
+                include: aggregation.includeValues,
+              }),
+              ...(aggregation.excludeValues && {
+                exclude: aggregation.excludeValues,
+              }),
             },
           }
         case 'histogram':

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

@@ -17,7 +17,6 @@ import {
   AssociatedRecord,
   CatalogRecord,
   DatasetFeatureCatalog,
-  DatasetFeatureType,
   LanguageCode,
   LinkedRecord,
   RecordRelation,
@@ -182,43 +181,15 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       )
   }
 
-  private mapEmbeddedFeatureCatalog(
-    featureTypes: Array<DatasetFeatureType>
-  ): DatasetFeatureCatalog {
-    return {
-      featureTypes: featureTypes.map((featureType) => ({
-        name: featureType.typeName || '',
-        definition: featureType.definition || '',
-        attributes: Array.isArray(featureType.attributeTable)
-          ? featureType.attributeTable.map((attr) => {
-              const values = attr.values
-                ?.filter((v) => v.code || v.label)
-                .map((v) => ({
-                  code: v.code,
-                  label: v.label,
-                }))
-              return {
-                name: attr.name,
-                code: attr.code,
-                definition: attr.definition,
-                type: attr.type,
-                ...(values?.length > 0 ? { values } : {}),
-              }
-            })
-          : [],
-      })),
-    }
-  }
-  getFeatureCatalog(
+  queryLinkedFeatureCatalog(
     record: CatalogRecord,
     visited: Set<string> = new Set() // prevent looping
   ): Observable<DatasetFeatureCatalog | null> {
     if (
-      record.extras?.['featureTypes'] &&
-      Array.isArray(record.extras['featureTypes']) &&
-      record.extras['featureTypes'].length > 0
+      'featureTypeDescriptions' in record &&
+      record.featureTypeDescriptions?.length > 0
     ) {
-      return of(this.mapEmbeddedFeatureCatalog(record.extras['featureTypes']))
+      return of({ featureTypes: record.featureTypeDescriptions })
     }
 
     const featureCatalogIdentifier = record.extras[
@@ -228,7 +199,7 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       visited.add(featureCatalogIdentifier)
       return this.getRecord(featureCatalogIdentifier).pipe(
         switchMap((record) =>
-          record ? this.getFeatureCatalog(record, visited) : of(null)
+          record ? this.queryLinkedFeatureCatalog(record, visited) : of(null)
         )
       )
     }

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

@@ -316,6 +316,7 @@ export interface DatasetRecord extends BaseRecord {
   spatialExtents: Array<DatasetSpatialExtent>
   temporalExtents: Array<DatasetTemporalExtent>
   spatialRepresentation?: SpatialRepresentationType
+  featureTypeDescriptions?: Array<DatasetFeatureType>
 }
 
 export interface ServiceEndpoint {
@@ -347,33 +348,28 @@ export interface ReuseRecord extends BaseRecord {
   temporalExtents: Array<DatasetTemporalExtent>
 }
 
+export interface DatasetFeatureType {
+  name: string
+  label?: string
+  description?: string
+  attributes: DatasetFeatureAttribute[]
+}
 export type DatasetFeatureCatalog = {
-  featureTypes: Array<{
-    name: string
-    definition: string
-    attributes: DatasetFeatureAttribute[]
-  }>
+  featureTypes: Array<DatasetFeatureType>
 }
 export interface DatasetFeatureAttributeValue {
-  code?: string
-  definition?: string
+  value: string // empty string when the value has no code
   label?: string
+  description?: string
 }
 export interface DatasetFeatureAttribute {
   name: string
-  definition: string
-  type: string
-  code: string
+  label?: string
+  description?: string
+  type?: string
+  code?: string
   values?: Array<DatasetFeatureAttributeValue>
 }
-export interface DatasetFeatureType {
-  aliases: string
-  code: string
-  isAbstract: string
-  typeName: string
-  definition: string
-  attributeTable: Array<DatasetFeatureAttribute>
-}
 
 export type ReuseType = 'application' | 'map' | 'other'
 

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

@@ -7,6 +7,8 @@ export interface TermsAggregationParams {
   limit: number
   sort: AggregationSort
   filter?: string
+  includeValues?: string[]
+  excludeValues?: string[]
 }
 export interface HistogramAggregationParams {
   type: 'histogram'

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

@@ -21,7 +21,10 @@ export type QueryString = {
   query_string: string
 }
 export type QueryRange = {
-  range: Record<string, { format: string; gte: string; lte: string }>
+  range: Record<
+    string,
+    { format: string; gte?: string; lte?: string; relation?: string }
+  >
 }
 export type QueryGeoShape = {
   geo_shape: {

package/src/libs/common/domain/src/lib/repository/records-repository.interface.ts

@@ -17,7 +17,7 @@ export abstract class RecordsRepositoryInterface {
   abstract search(params: SearchParams): Observable<SearchResults>
   abstract getMatchesCount(filters: FieldFilters): Observable<number>
   abstract getRecord(uniqueIdentifier: string): Observable<CatalogRecord | null>
-  abstract getFeatureCatalog(
+  abstract queryLinkedFeatureCatalog(
     record: CatalogRecord
   ): Observable<DatasetFeatureCatalog | null>
   abstract aggregate(params: AggregationsParams): Observable<Aggregations>

package/src/libs/common/fixtures/src/lib/records.fixtures.ts

@@ -164,69 +164,49 @@ As such, **it is not very interesting at all.**`,
     extras: {
       isPublishedToAll: true,
       edit: true,
-      featureTypes: [
-        {
-          attributeTable: [
-            {
-              code: 'OBJECTID',
-              name: 'OBJECTID',
-              link: '',
-              definition: 'Object identifier',
-              type: 'OID',
-            },
-            {
-              code: 'NOM',
-              name: 'Nom',
-              link: '',
-              definition: 'Nom de la rue',
-              type: 'String (48)',
-              values: [
-                {
-                  code: 'Pomme',
-                  label: 'Les Pommiers',
-                  description: 'Sous les pommiers',
-                },
-                {
-                  code: 'Cotton',
-                  label: 'Rue Cotton',
-                  description: 'Rue Cotton',
-                },
-                { code: "Passage de l'échiquier" },
-                { description: 'Rue du Charlieu' },
-              ],
-            },
-            {
-              code: 'RUE',
-              name: 'Rue',
-              link: '',
-              definition: '',
-              type: 'String (50)',
-            },
-          ],
-          code: '',
-          aliases: '',
-          typeName: "Catalogue d'attributs N°1",
-          definition: 'Définition du catalogue d attributs N°1',
-          isAbstract: 'false',
-        },
-        {
-          attributeTable: [
-            {
-              code: 'UniqueObject',
-              name: 'unique object ',
-              link: '',
-              definition: 'this is the only object of this catalog',
-              type: 'String (50)',
-            },
-          ],
-          code: '',
-          aliases: '',
-          typeName: "Catalogue d'attributs N°2",
-          definition: 'Définition du catalogue d attributs N°2',
-          isAbstract: 'false',
-        },
-      ],
     },
+    featureTypeDescriptions: [
+      {
+        name: "Catalogue d'attributs N°1",
+        description: 'Définition du catalogue d attributs N°1',
+        attributes: [
+          {
+            name: 'OBJECTID',
+            description: 'Object identifier',
+            code: 'OBJECTID',
+            type: 'OID',
+          },
+          {
+            name: 'Nom',
+            description: 'Nom de la rue',
+            code: 'NOM',
+            type: 'String (48)',
+            values: [
+              { value: 'Pomme', label: 'Les Pommiers' },
+              { value: 'Cotton', label: 'Rue Cotton' },
+              { value: "Passage de l'échiquier" },
+            ],
+          },
+          {
+            name: 'Rue',
+            code: 'RUE',
+            type: 'String (50)',
+          },
+        ],
+      },
+      {
+        name: "Catalogue d'attributs N°2",
+        description: 'Définition du catalogue d attributs N°2',
+        attributes: [
+          {
+            name: 'unique object ',
+            description: 'this is the only object of this catalog',
+            code: 'UniqueObject',
+            type: 'String (50)',
+          },
+        ],
+      },
+    ],
   },
   {
     uniqueIdentifier: '7d002c4c-92ef-4b9f-a568-d732f740b99e',

package/src/libs/feature/dataviz/src/lib/service/data.service.ts

@@ -209,7 +209,8 @@ export class DataService {
     ogcApiLink: DatasetServiceDistribution
   ): Promise<DatasetOnlineResource[]> {
     const collectionInfo = await this.getDownloadUrlsFromOgcApi(
-      ogcApiLink.url.href
+      ogcApiLink.url.href,
+      ogcApiLink.name
     )
 
     return Object.keys(collectionInfo.bulkDownloadLinks).map((mimeType) => {
@@ -229,31 +230,41 @@ export class DataService {
     })
   }
 
-  async getDownloadUrlsFromOgcApi(url: string): Promise<OgcApiCollectionInfo> {
+  private async getTargetCollectionId(
+    endpoint: OgcApiEndpoint,
+    collectionId?: string
+  ): Promise<string | undefined> {
+    const collections = await endpoint.featureCollections
+    return collections.length === 1 && !collectionId
+      ? collections[0]
+      : collectionId
+  }
+
+  async getDownloadUrlsFromOgcApi(
+    url: string,
+    collectionId?: string
+  ): Promise<OgcApiCollectionInfo> {
     const endpoint = new OgcApiEndpoint(url)
-    return await endpoint.featureCollections
-      .then((collections) => {
-        return endpoint.getCollectionInfo(collections[0])
-      })
-      .catch((error) => {
-        throw new Error(`ogc.unreachable.unknown`)
-      })
+    try {
+      const id = await this.getTargetCollectionId(endpoint, collectionId)
+      return await endpoint.getCollectionInfo(id)
+    } catch {
+      throw new Error('ogc.unreachable.unknown')
+    }
   }
 
   async getItemsFromOgcApi(
     url: string,
+    collectionId?: string,
     limit?: number
   ): Promise<OgcApiRecord[]> {
     const endpoint = new OgcApiEndpoint(url)
-    return await endpoint.featureCollections
-      .then((collections) => {
-        return collections.length
-          ? endpoint.getCollectionItems(collections[0], limit)
-          : null
-      })
-      .catch(() => {
-        throw new Error(`ogc.unreachable.unknown`)
-      })
+    try {
+      const id = await this.getTargetCollectionId(endpoint, collectionId)
+      return await endpoint.getCollectionItems(id, limit)
+    } catch {
+      throw new Error('ogc.unreachable.unknown')
+    }
   }
 
   async getItemsFromStacApi(
@@ -381,7 +392,9 @@ export class DataService {
       link.type === 'service' &&
       link.accessServiceProtocol === 'ogcFeatures'
     ) {
-      return from(this.getDownloadUrlsFromOgcApi(link.url.href)).pipe(
+      return from(
+        this.getDownloadUrlsFromOgcApi(link.url.href, link.name)
+      ).pipe(
         switchMap((collectionInfo) => {
           const isMimeTypeJson = (mimeType: string): boolean => {
             return mimeType.toLowerCase().indexOf('json') > -1

package/src/libs/feature/map/src/index.ts

@@ -6,7 +6,6 @@ export * from './lib/feature-map.module'
 export * from './lib/map-state-container/map-state-container.component'
 export * from './lib/constant'
 export * from './lib/utils'
-export * from './lib/style'
 export * from './lib/layers-panel/layers-panel.component'
 export * from './lib/add-layer-from-catalog/add-layer-from-catalog.component'
 export * from './lib/add-layer-from-catalog/add-layer-record-preview/add-layer-record-preview.component'

package/src/libs/feature/notify-reuse/src/lib/notify-reuse-form/notify-reuse-form.component.ts

@@ -33,7 +33,6 @@ import { RecordsRepositoryInterface } from '../../../../../../libs/common/domain
 import { NOT_KNOWN_CONSTRAINT } from '../../../../../../libs/feature/editor/src'
 import { NotificationsService } from '../../../../../../libs/feature/notifications/src'
 import { ButtonComponent, TextInputComponent } from '../../../../../../libs/ui/inputs/src'
-import { getOptionalEditorConfig } from '../../../../../../libs/util/app-config/src'
 import { NgIcon, provideIcons, provideNgIconsConfig } from '@ng-icons/core'
 import { iconoirAppWindow, iconoirPlusCircle } from '@ng-icons/iconoir'
 import { matCloseOutline } from '@ng-icons/material-icons/outline'
@@ -48,6 +47,10 @@ marker('notify.reuse.form.error.title')
 marker('notify.reuse.form.error.body')
 
 export const REUSE_FORM_URL = new InjectionToken<string>('reuseFormUrl')
+// language assigned to the created reuse record; falls back to the current UI language
+export const NEW_RECORD_DEFAULT_LANGUAGE = new InjectionToken<string>(
+  'newRecordDefaultLanguage'
+)
 
 @Component({
   selector: 'gn-ui-notify-reuse-form',
@@ -86,6 +89,9 @@ export class NotifyReuseFormComponent implements OnDestroy {
   private readonly notificationsService = inject(NotificationsService)
   private readonly platformServiceInterface = inject(PlatformServiceInterface)
   reuseFormUrl = inject(REUSE_FORM_URL, { optional: true })
+  private newRecordDefaultLanguage = inject(NEW_RECORD_DEFAULT_LANGUAGE, {
+    optional: true,
+  })
   private locationStrategy = inject(LocationStrategy)
 
   me = toSignal(this.platformServiceInterface.getMe())
@@ -158,8 +164,7 @@ export class NotifyReuseFormComponent implements OnDestroy {
   submit() {
     if (!this.isFormValid()) return
     const defaultLang =
-      getOptionalEditorConfig()?.NEW_RECORD_DEFAULT_LANGUAGE ??
-      this.translate.currentLang
+      this.newRecordDefaultLanguage ?? this.translate.currentLang
     const onlineResource: OnlineLinkResource = {
       type: 'link',
       url: new URL(this.url()),

package/src/libs/feature/record/src/lib/state/mdview.effects.ts

@@ -40,7 +40,9 @@ export class MdViewEffects {
     this.actions$.pipe(
       ofType(MdViewActions.loadFullMetadataSuccess),
       filter(({ full }) => full !== undefined),
-      switchMap(({ full }) => this.recordsRepository.getFeatureCatalog(full)),
+      switchMap(({ full }) =>
+        this.recordsRepository.queryLinkedFeatureCatalog(full)
+      ),
       map((featureCatalog) =>
         MdViewActions.loadFeatureCatalogSuccess({
           datasetCatalog: featureCatalog,

package/src/libs/feature/record/src/lib/state/mdview.facade.ts

@@ -162,7 +162,7 @@ export class MdViewFacade {
               link.accessServiceProtocol === 'ogcFeatures'
             ) {
               return from(
-                this.dataService.getItemsFromOgcApi(link.url.href, 1)
+                this.dataService.getItemsFromOgcApi(link.url.href, link.name, 1)
               ).pipe(
                 map((collectionRecords: OgcApiRecord[]) => {
                   return collectionRecords &&