[Backport 2024.01.xx] #10272: Choice of OGC service type for single layer in CSW catalog (#10304)

web/client/api/CSW.js

@@ -110,12 +110,28 @@ const extractWMSParamsFromURL = wms => {
  return false;
 };
 
+// Extract the relevant information from the wfs URL for (RNDT / INSPIRE)
+const extractWFSParamsFromURL = wfs => {
+ const lowerCaseParams = new Map(Array.from(new URLSearchParams(wfs.value)).map(([key, value]) => [key.toLowerCase(), value]));
+ const layerName = lowerCaseParams.get('typename');
+ if (layerName) {
+ return {
+ ...wfs,
+ protocol: 'OGC:WFS',
+ name: layerName,
+ value: `${wfs.value.match(/[^\?]+[\?]+/g)}service=WFS`
+ };
+ }
+ return false;
+};
+
 const toReference = (layerType, data, options) => {
  if (!data.name) {
  return null;
  }
  switch (layerType) {
  case 'wms':
+ case 'wfs':
  const urlValue = !(data.value.indexOf("http") === 0)
  ? (options && options.catalogURL || "") + "/" + data.value
  : data.value;
@@ -142,39 +158,69 @@ const toReference = (layerType, data, options) => {
 };
 
 const REGEX_WMS_EXPLICIT = [/^OGC:WMS-(.*)-http-get-map/g, /^OGC:WMS/g];
+const REGEX_WFS_EXPLICIT = [/^OGC:WFS-(.*)-http-get-(capabilities|feature)/g, /^OGC:WFS/g];
 const REGEX_WMS_EXTRACT = /serviceType\/ogc\/wms/g;
+const REGEX_WFS_EXTRACT = /serviceType\/ogc\/wfs/g;
 const REGEX_WMS_ALL = REGEX_WMS_EXPLICIT.concat(REGEX_WMS_EXTRACT);
 
 export const getLayerReferenceFromDc = (dc, options, checkEsri = true) => {
  const URI = dc?.URI && castArray(dc.URI);
+ const isWMS = isNil(options?.type) || options?.type === "wms";
+ const isWFS = options?.type === "wfs";
  // look in URI objects for wms and thumbnail
  if (URI) {
- const wms = head(URI.map(uri => {
- if (uri.protocol) {
- if (REGEX_WMS_EXPLICIT.some(regex => uri.protocol.match(regex))) {
+ if (isWMS) {
+ const wms = head(URI.map(uri => {
+ if (uri.protocol) {
+ if (REGEX_WMS_EXPLICIT.some(regex => uri.protocol.match(regex))) {
  /** wms protocol params are explicitly defined as attributes (INSPIRE)*/
- return uri;
- }
- if (uri.protocol.match(REGEX_WMS_EXTRACT)) {
+  return uri;
+  }
+  if (uri.protocol.match(REGEX_WMS_EXTRACT)) {
  /** wms protocol params must be extracted from the element text (RNDT / INSPIRE) */
- return extractWMSParamsFromURL(uri);
+ return extractWMSParamsFromURL(uri);
+ }
  }
+ return false;
+ }).filter(item => item));
+ if (wms) {
+ return toReference('wms', wms, options);
+ }
+ }
+ if (isWFS) {
+ const wfs = head(URI.map(uri => {
+ if (uri.protocol) {
+ if (REGEX_WFS_EXPLICIT.some(regex => uri.protocol.match(regex))) {
+ /** wfs protocol params are explicitly defined as attributes (INSPIRE)*/
+ return uri;
+ }
+ if (uri.protocol.match(REGEX_WFS_EXTRACT)) {
+ /** wfs protocol params must be extracted from the element text (RNDT / INSPIRE) */
+ return extractWFSParamsFromURL(uri);
+ }
+ }
+ return false;
+ }).filter(item => item));
+ if (wfs) {
+ return toReference('wfs', wfs, options);
  }
- return false;
- }).filter(item => item));
- if (wms) {
- return toReference('wms', wms, options);
  }
  }
  // look in references objects
  if (dc?.references?.length) {
  const refs = castArray(dc.references);
  const wms = head(refs.filter((ref) => { return ref.scheme && REGEX_WMS_EXPLICIT.some(regex => ref.scheme.match(regex)); }));
- if (wms) {
+ const wfs = head(refs.filter((ref) => { return ref.scheme && REGEX_WFS_EXPLICIT.some(regex => ref.scheme.match(regex)); }));
+ if (isWMS && wms) {
  let urlObj = urlUtil.parse(getDefaultUrl(wms.value), true);
  let layerName = urlObj.query && urlObj.query.layers || dc.alternative;
  return toReference('wms', { ...wms, value: urlUtil.format(urlObj), name: layerName }, options);
  }
+ if (isWFS && wfs) {
+ let urlObj = urlUtil.parse(getDefaultUrl(wfs.value), true);
+ let layerName = urlObj.query && urlObj.query.layers || dc.alternative;
+ return toReference('wfs', { ...wfs, value: urlUtil.format(urlObj), name: layerName }, options);
+ }
  if (checkEsri) {
  // checks for esri arcgis in geonode csw
  const esri = head(refs.filter((ref) => {

web/client/api/__tests__/CSW-test.js

@@ -440,6 +440,34 @@ describe("getLayerReferenceFromDc", () => {
  expect(layerRef.type).toBe('OGC:WMS');
  expect(layerRef.url).toBe('catalog_url/wmsurl?SERVICE=WMS&VERSION=1.3.0');
  });
+ it("test layer reference with dc.references of scheme OGC:WFS", () => {
+ const dc = {references: [{value: "http://wmsurl", scheme: 'OGC:WMS'}, {value: "http://wfsurl", scheme: 'OGC:WFS'}], alternative: "some_layer"};
+ const layerRef = getLayerReferenceFromDc(dc, {type: "wfs"});
+ expect(layerRef.params.name).toBe('some_layer');
+ expect(layerRef.type).toBe('OGC:WFS');
+ expect(layerRef.url).toBe('http://wfsurl/');
+ });
+ it("test layer reference with dc.references of scheme OGC:WMS-http-get-capabilities", () => {
+ const dc = {references: [{value: "http://wmsurl", scheme: 'OGC:WMS-http-get-map'}, {value: "http://wfsurl", scheme: 'OGC:WFS-http-get-capabilities'}], alternative: "some_layer"};
+ const layerRef = getLayerReferenceFromDc(dc, {type: "wfs"});
+ expect(layerRef.params.name).toBe('some_layer');
+ expect(layerRef.type).toBe('OGC:WFS-http-get-capabilities');
+ expect(layerRef.url).toBe('http://wfsurl/');
+ });
+ it("test layer reference with dc.references of scheme OGC:WMS-http-get-feature", () => {
+ const dc = {references: [{value: "http://wmsurl", scheme: 'OGC:WMS-http-get-map'}, {value: "http://wfsurl", scheme: 'OGC:WFS-http-get-feature'}], alternative: "some_layer"};
+ const layerRef = getLayerReferenceFromDc(dc, {type: "wfs"});
+ expect(layerRef.params.name).toBe('some_layer');
+ expect(layerRef.type).toBe('OGC:WFS-http-get-feature');
+ expect(layerRef.url).toBe('http://wfsurl/');
+ });
+ it("test layer reference with dc.URI of scheme serviceType/ogc/wfs and options", () => {
+ const dc = {URI: [{value: "wfsurl?service=wfs&typename=some_layer&version=1.3.0", protocol: 'serviceType/ogc/wfs'}, {value: "wmsurl", protocol: 'OGC:WMS'}]};
+ const layerRef = getLayerReferenceFromDc(dc, {type: "wfs", catalogURL: "catalog_url"});
+ expect(layerRef.params.name).toBe('some_layer');
+ expect(layerRef.type).toBe('OGC:WFS');
+ expect(layerRef.url).toBe('catalog_url/wfsurl?service=WFS');
+ });
  it("test layer reference with multiple dc.URI of scheme OGC:WMS", () => {
  const dc = {URI: [{value: "http://wmsurl", protocol: 'OGC:WMS', name: 'some_layer'}, {value: "wfsurl", protocol: 'OGC:WFS'}]};
  const layerRef = getLayerReferenceFromDc(dc);
@@ -480,6 +508,15 @@ describe("getLayerReferenceFromDc", () => {
 
  expect(getLayerReferenceFromDc(dc).url).toBe(_url[0]);
  });
+ it('getLayerReferenceFromDc for service type WFS', () => {
+ const _url = [
+ 'http://gs-stable.geosolutionsgroup.com:443/geoserver1',
+ 'http://gs-stable.geosolutionsgroup.com:443/geoserver2',
+ 'http://gs-stable.geosolutionsgroup.com:443/geoserver3'
+ ];
+ const dc = {references: [{value: 'wmsurl', scheme: 'OGC:WMS'}, {value: _url, scheme: 'OGC:WFS'}], alternative: "some_layer"};
+ expect(getLayerReferenceFromDc(dc, {type: "wfs"}).url).toBe(_url[0]);
+ });
 });
 
 

web/client/api/catalog/CSW.js

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { head, isString, includes, castArray, sortBy, uniq } from 'lodash';
+import { head, isString, includes, castArray, sortBy, uniq, isEmpty } from 'lodash';
 import { getLayerFromRecord as getLayerFromWMSRecord } from './WMS';
 import { getMessageById } from '../../utils/LocaleUtils';
 import { transformExtentToObj} from '../../utils/CoordinatesUtils';
@@ -104,12 +104,22 @@ function getThumbnailFromDc(dc, options) {
  }
  return thumbURL;
 }
+
+/**
+ * Extract bounding box object from the record
+ * @param {Object} record from OGC service
+ */
+function getBoundingBox(record) {
+ if (isEmpty(record.boundingBox?.crs) || isEmpty(record.boundingBox?.extent)) {
+ return null;
+ }
+ return {
+ crs: record.boundingBox?.crs,
+ bounds: transformExtentToObj(record.boundingBox?.extent)
+ };
+}
 function getCatalogRecord3DTiles(record, metadata) {
  const dc = record.dc;
- let bbox = {
- crs: record.boundingBox.crs,
- bounds: transformExtentToObj(record.boundingBox.extent)
- };
  return {
  serviceType: '3dtiles',
  isValid: true,
@@ -118,7 +128,7 @@ function getCatalogRecord3DTiles(record, metadata) {
  identifier: dc && isString(dc.identifier) && dc.identifier || '',
  url: dc?.URI?.value || "",
  thumbnail: null,
- bbox,
+ bbox: getBoundingBox(record),
  format: dc && dc.format || "",
  references: [],
  catalogType: 'csw',
@@ -136,6 +146,28 @@ const recordToLayer = (record, options) => {
  return null;
  }
 };
+const ADDITIONAL_OGC_SERVICES = ['wfs']; // Add services when support is provided
+const getAdditionalOGCService = (record, references, parsedReferences = {}) => {
+ const hasAdditionalService = ADDITIONAL_OGC_SERVICES.some(serviceType => !isEmpty(parsedReferences[serviceType]));
+ if (hasAdditionalService) {
+ return {
+ additionalOGCServices: {
+ ...ADDITIONAL_OGC_SERVICES
+ .map(serviceType => {
+ const ogcReferences = parsedReferences[serviceType] ?? {};
+ const {url, params: {name} = {}} = ogcReferences;
+ return {[serviceType]: {
+ url, name, references, ogcReferences, fetchCapabilities: true,
+ boundingBox: getBoundingBox(record)
+ }};
+ })
+ .flat()
+ .reduce((a, c) => ({...c, ...a}), {})
+ }
+ };
+ }
+ return null;
+};
 
 export const preprocess = commonPreprocess;
 export const validate = commonValidate;
@@ -168,9 +200,11 @@ export const getCatalogRecords = (records, options, locales) => {
  });
  }
 
- const layerReference = getLayerReferenceFromDc(dc, options);
- if (layerReference) {
- references.push(layerReference);
+ const layerReferences = ['wms', ...ADDITIONAL_OGC_SERVICES].map(serviceType => {
+ return getLayerReferenceFromDc(dc, {...options, type: serviceType});
+ }).filter(ref => ref);
+ if (!isEmpty(layerReferences)) {
+ references = references.concat(layerReferences);
  }
 
  // create the references array (now only wms is supported)
@@ -229,16 +263,16 @@ export const getCatalogRecords = (records, options, locales) => {
  ...extractEsriReferences({ references })
  };
 
- const layerType = Object.keys(parsedReferences).find(key => parsedReferences[key]);
- const ogcReferences = layerType && layerType !== 'esri'
- ? parsedReferences[layerType]
- : undefined;
  let catRecord;
  if (dc && dc.format === THREE_D_TILES) {
  catRecord = getCatalogRecord3DTiles(record, metadata);
  } else if (dc && dc.format === MODEL) {
  // todo: handle get catalog record for ifc
  } else {
+ const layerType = Object.keys(parsedReferences).filter(key => !ADDITIONAL_OGC_SERVICES.includes(key)).find(key => parsedReferences[key]);
+ const ogcReferences = layerType && layerType !== 'esri'
+ ? parsedReferences[layerType]
+ : undefined;
  catRecord = {
  serviceType: 'csw',
  layerType,
@@ -253,7 +287,8 @@ export const getCatalogRecords = (records, options, locales) => {
  tags: dc && dc.tags || '',
  metadata,
  capabilities: record.capabilities,
- ogcReferences
+ ogcReferences,
+ ...getAdditionalOGCService(record, references, parsedReferences)
  };
  }
  return catRecord;

web/client/api/catalog/WFS.js

@@ -17,7 +17,7 @@ import {
  testService as commonTestService,
  preprocess as commonPreprocess
 } from './common';
-import { get, castArray } from 'lodash';
+import { get, castArray, isEmpty } from 'lodash';
 
 const capabilitiesCache = {};
 
@@ -142,7 +142,25 @@ export const getCatalogRecords = ({records} = {}) => {
  return null;
 };
 
+/**
+ * Formulate WFS layer data from record
+ * and fetch capabilities if needed to add capibilities specific data
+ * @param {Object} record data obtained from catalog service
+ * @param {Object} options props specific to wfs
+ * @returns {Promise} promise that resolves to formulated layer data
+ */
+const getLayerData = (record, options) => {
+ const layer = recordToLayer(record, options);
+ return getRecords(record.url, 1, 1, record.name).then((result)=> {
+ const [newRecord] = result?.records ?? [];
+ return isEmpty(newRecord) ? layer : recordToLayer(newRecord, options);
+ }).catch(() => layer);
+};
+
 export const getLayerFromRecord = (record, options, asPromise) => {
+ if (options.fetchCapabilities && asPromise) {
+ return getLayerData(record, options);
+ }
  const layer = recordToLayer(record, options);
  return asPromise ? Promise.resolve(layer) : layer;
 };