geonetwork-ui 2.4.0-dev.fe59f179 → 2.4.1-dev.73bac9979

package/src/libs/api/metadata-converter/src/lib/xml-utils.ts

@@ -1,11 +1,16 @@
 import {
   parseXml,
+  XmlCdata,
   XmlComment,
+  XmlDeclaration,
   XmlDocument,
+  XmlDocumentType,
   XmlElement,
+  XmlProcessingInstruction,
   XmlText,
 } from '@rgrove/parse-xml'
 import { ChainableFunction, fallback } from './function-utils'
+
 export { XmlDocument, XmlElement } from '@rgrove/parse-xml'
 
 export class XmlParseError extends Error {
@@ -35,7 +40,8 @@ export function createDocument(rootEl: XmlElement): XmlDocument {
     if (namespace === 'xmlns' || namespace === null) return
     if (rootEl.attributes[`xmlns:${namespace}`]) return
     if (!NAMESPACES[namespace]) {
-      throw new Error(`No known URI for namespace ${namespace}`)
+      // the namespace is unknown but it might still be declared correctly: ignore it
+      return
     }
     rootEl.attributes[`xmlns:${namespace}`] = NAMESPACES[namespace]
   }
@@ -115,6 +121,10 @@ export function allChildrenElement(element: XmlElement): Array<XmlElement> {
   ] as Array<XmlElement>
 }
 
+export function firstChildElement(element: XmlElement): XmlElement {
+  return allChildrenElement(element)[0] ?? null
+}
+
 /**
  * Will return all matching elements nested according to the given
  * names (similar to a path), starting form the input element;
@@ -175,11 +185,11 @@ export function findParent(
 
 export function readText(): ChainableFunction<XmlElement, string> {
   return (el) => {
-    const textNode =
-      el && Array.isArray(el.children)
-        ? (el.children.find((node) => node.type === 'text') as XmlText)
-        : null
-    return textNode ? textNode.text : null
+    if (!el) return null
+    const textNode = Array.isArray(el.children)
+      ? (el.children.find((node) => node.type === 'text') as XmlText)
+      : null
+    return textNode ? textNode.text : ''
   }
 }
 
@@ -190,9 +200,23 @@ export function readAttribute(
 }
 
 export function xmlToString(
-  el: XmlElement | XmlText | XmlComment | XmlDocument,
+  el:
+    | XmlDocument
+    | XmlElement
+    | XmlComment
+    | XmlProcessingInstruction
+    | XmlDeclaration
+    | XmlDocumentType
+    | XmlCdata
+    | XmlText,
   indentationLevel = 0
 ) {
+  const encodeEntities = (text: string) => {
+    return text
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+  }
   if (el instanceof XmlDocument)
     return `<?xml version="1.0" encoding="UTF-8"?>${xmlToString(
       el.children[0]
@@ -201,10 +225,7 @@ export function xmlToString(
     const text = el.text
     const isEmpty = !text || text.replace(/^\s+|\s+$/g, '') === ''
     if (isEmpty) return ''
-    return text
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
+    return encodeEntities(text)
   }
   if (!(el instanceof XmlElement)) return `<!-- unknown -->`
 
@@ -219,7 +240,7 @@ export function xmlToString(
         .join('')
     : ''
   const attrs = Object.keys(el.attributes).reduce(
-    (prev, curr) => prev + ` ${curr}="${el.attributes[curr]}"`,
+    (prev, curr) => prev + ` ${curr}="${encodeEntities(el.attributes[curr])}"`,
     ''
   )
   const parentPadding = '    '.repeat(Math.max(0, indentationLevel - 1))
@@ -228,6 +249,7 @@ export function xmlToString(
 ${padding}<${el.name}${attrs}/>
 ${parentPadding}`
   }
+
   return `
 ${padding}<${el.name}${attrs}>${children}</${el.name}>
 ${parentPadding}`
@@ -242,7 +264,7 @@ function extractNamespace(name: string): string | null {
   return colon > -1 ? name.substring(0, colon) : null
 }
 
-const NAMESPACES = {
+export const NAMESPACES = {
   gmd: 'http://www.isotc211.org/2005/gmd',
   gco: 'http://www.isotc211.org/2005/gco',
   gfc: 'http://www.isotc211.org/2005/gfc',
@@ -277,9 +299,26 @@ const NAMESPACES = {
   cat: 'http://standards.iso.org/iso/19115/-3/cat/1.0',
   lan: 'http://standards.iso.org/iso/19115/-3/lan/1.0',
   mrc: 'http://standards.iso.org/iso/19115/-3/mrc/2.0',
+  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+  foaf: 'http://xmlns.com/foaf/0.1/',
+  xsd: 'http://www.w3.org/2001/XMLSchema#',
+  dcat: 'http://www.w3.org/ns/dcat#',
+  dct: 'http://purl.org/dc/terms/',
+  skos: 'http://www.w3.org/2004/02/skos/core#',
+  schema_org: 'http://schema.org/',
+  spdx: 'https://spdx.org/rdf/terms/#',
+  adms: 'http://www.w3.org/ns/adms#',
+  dqv: 'http://www.w3.org/ns/dqv#',
+  owl: 'http://www.w3.org/2002/07/owl#',
+  vcard: 'http://www.w3.org/2006/vcard/ns#',
+  time: 'http://www.w3.org/2006/time#',
+  locn: 'http://www.w3.org/ns/locn#',
+  mdcat: 'https://data.vlaanderen.be/ns/metadata-dcat#',
 }
 
 /**
+ * Creates a single element, without parent or children
  * @param name Full name with namespace, e.g.: gmd:MD_Metadata
  */
 export function createElement(
@@ -288,7 +327,23 @@ export function createElement(
   return () => new XmlElement(name, {}, [])
 }
 
-export function addAttribute(
+/**
+ * Creates a tree of nested elements according to the given hierarchy
+ * @param elementNames Full names with namespaces
+ */
+export function createNestedElement(
+  ...elementNames: string[]
+): ChainableFunction<void, XmlElement> {
+  return () => {
+    let current = null
+    for (const name of elementNames) {
+      current = current ? createChild(name)(current) : createElement(name)()
+    }
+    return current
+  }
+}
+
+export function writeAttribute(
   name: string,
   value: string
 ): ChainableFunction<XmlElement, XmlElement> {
@@ -305,20 +360,13 @@ function getTreeRoot(element: XmlElement): XmlElement {
   return root
 }
 
-// stays on the parent element
-// if the given elements are part of a subtree, will add the root of subtree
-export function appendChildren(
-  ...childrenFns: Array<ChainableFunction<void, XmlElement>>
-): ChainableFunction<XmlElement, XmlElement> {
-  return (element) => {
-    if (!element) return null
-    element.children.push(...childrenFns.map((fn) => fn()).map(getTreeRoot))
-    element.children.forEach((el) => (el.parent = element))
-    return element
-  }
-}
-
-// switch to the tip of the subtree
+/**
+ * Appends the element returned by the given function to the children of the current active one
+ * Note that if the function returns the tip of a subtree that was just created (i.e. not attached to the main document),
+ * then the whole subtree will be attached to the current element as children (instead of just the tip of the subtree).
+ * The created element (or tip of the created subtree) is returned and becomes the active element.
+ * @param childrenFn
+ */
 export function appendChildTree(
   childrenFn: ChainableFunction<void, XmlElement>
 ): ChainableFunction<XmlElement, XmlElement> {
@@ -332,7 +380,29 @@ export function appendChildTree(
   }
 }
 
-// switches to the child element
+/**
+ * Leaves the current element as the active one; all elements returned by the given functions will be added as
+ * children to this current element.
+ * Note that if a function returns the tip of a subtree that was just created (i.e. not attached to the main document),
+ * then the whole subtree will be attached to the current element as children (instead of just the tip of the subtree).
+ * @param childrenFns Each function takes the parent as input and should return an element; if the returned value is
+ * falsy then it will be ignored
+ */
+export function appendChildren(
+  ...childrenFns: Array<ChainableFunction<void, XmlElement>>
+): ChainableFunction<XmlElement, XmlElement> {
+  return (element) => {
+    if (!element) return null
+    childrenFns.filter((fn) => fn).forEach((fn) => appendChildTree(fn)(element))
+    return element
+  }
+}
+
+/**
+ * Creates an element, append it to the children of the current active element and switches to the
+ * new element as the active one.
+ * @param childName
+ */
 export function createChild(
   childName: string
 ): ChainableFunction<XmlElement, XmlElement> {
@@ -345,12 +415,40 @@ export function createChild(
   }
 }
 
+/**
+ * Creates a tree of nested elements according to the given hierarchy, appends it to the children of the current
+ * active element and switches to the tip of the newly created tree of elements as the active one.
+ * @param elementNames Full names with namespaces
+ */
+export function createNestedChild(
+  ...elementNames: string[]
+): ChainableFunction<XmlElement, XmlElement> {
+  return (element) => {
+    let current = element
+    for (const name of elementNames) {
+      current = createChild(name)(current)
+    }
+    return current
+  }
+}
+
+/**
+ * Returns the matching children if found, or create a new element, append it to the current active element
+ * and switch to it as the active one.
+ * @param name
+ */
 export function findChildOrCreate(
   name: string
 ): ChainableFunction<XmlElement, XmlElement> {
   return fallback(findChildElement(name, false), createChild(name))
 }
 
+/**
+ * For each element name in the given hierarchy, either switch to a matching element if found,
+ * or create a new one, append it to the children of the previous one and switch to it as the active one.
+ * Eventually, the tip of the hierarchy (either existing or new element) becomes the active element.
+ * @param elementNames
+ */
 export function findNestedChildOrCreate(
   ...elementNames: string[]
 ): ChainableFunction<XmlElement, XmlElement> {
@@ -448,3 +546,21 @@ export function renameElements(
   doReplace(rootElement)
   return rootElement
 }
+
+/**
+ * This function use the DOMParser to check if the given xmlString is a valid XML file or throw an error
+ * (Generated by chatGPT)
+ * @param xmlString
+ */
+export function assertValidXml(xmlString: string): Document {
+  const parser = new DOMParser()
+  const xmlDoc = parser.parseFromString(xmlString, 'application/xml')
+  const parserError = xmlDoc.querySelector('parsererror')
+
+  if (parserError) {
+    console.error(parserError)
+    throw new Error('File is not a valid XML.')
+  }
+
+  return xmlDoc
+}

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

@@ -1,34 +1,63 @@
 import { Inject, Injectable, InjectionToken, Optional } from '@angular/core'
 import { LANG_2_TO_3_MAPPER } from '../../../../../../../libs/util/i18n/src'
 import { TranslateService } from '@ngx-translate/core'
+import { Location } from '@angular/common'
 
 export const DEFAULT_GN4_LOGIN_URL = `/geonetwork/srv/\${lang3}/catalog.signin?redirect=\${current_url}`
 export const LOGIN_URL = new InjectionToken<string>('loginUrl')
 
+export const DEFAULT_GN4_LOGOUT_URL = `/geonetwork/signout`
+export const LOGOUT_URL = new InjectionToken<string>('logoutUrl')
+
+export const DEFAULT_GN4_SETTINGS_URL = `/geonetwork/srv/\${lang3}/admin.console#/organization/users?userOrGroup=`
+export const SETTINGS_URL = new InjectionToken<string>('settingsUrl')
+
 @Injectable({
   providedIn: 'root',
 })
 export class AuthService {
   baseLoginUrl = this.baseLoginUrlToken || DEFAULT_GN4_LOGIN_URL
+  baseLogoutUrl = this.baseLogoutUrlToken || DEFAULT_GN4_LOGOUT_URL
+  baseSettingsUrl = this.baseSettingsUrlToken || DEFAULT_GN4_SETTINGS_URL
+
   get loginUrl() {
     let baseUrl = this.baseLoginUrl
-    const locationHasQueryParams = !!window.location.search
+    const locationHasQueryParams = !!new URL(
+      this.location.path(),
+      window.location.href
+    ).search
     // this is specific to georchestra login URL based on a ?login query param
     if (baseUrl.startsWith('${current_url}?') && locationHasQueryParams) {
       baseUrl = baseUrl.replace('?', '&')
     }
     return baseUrl
-      .replace('${current_url}', window.location.toString())
+      .replace(
+        '${current_url}',
+        new URL(this.location.path(), window.location.href).toString()
+      )
       .replace('${lang2}', this.translateService.currentLang)
       .replace(
         '${lang3}',
         LANG_2_TO_3_MAPPER[this.translateService.currentLang]
       )
   }
+
+  get logoutUrl() {
+    return this.baseLogoutUrl
+  }
+
+  get settingsUrl() {
+    return this.baseSettingsUrl.replace(
+      '${lang3}',
+      LANG_2_TO_3_MAPPER[this.translateService.currentLang]
+    )
+  }
+
   constructor(
-    @Optional()
-    @Inject(LOGIN_URL)
-    private baseLoginUrlToken: string,
-    private translateService: TranslateService
+    @Optional() @Inject(LOGIN_URL) private baseLoginUrlToken: string,
+    @Optional() @Inject(LOGOUT_URL) private baseLogoutUrlToken: string,
+    @Optional() @Inject(SETTINGS_URL) private baseSettingsUrlToken: string,
+    private translateService: TranslateService,
+    private location: Location
   ) {}
 }

package/src/libs/api/repository/src/lib/gn4/elasticsearch/date-range.utils.ts

@@ -0,0 +1,13 @@
+import { FieldFilter } from '../../../../../../../libs/common/domain/src/lib/model/search'
+
+export function isDateRange(filter: FieldFilter): boolean {
+  if (!filter) return false
+  return typeof filter === 'object' && ('start' in filter || 'end' in filter)
+}
+
+export function formatDate(date: Date): string {
+  const year = date.getFullYear()
+  const month = String(date.getMonth() + 1).padStart(2, '0')
+  const day = String(date.getDate()).padStart(2, '0')
+  return `${year}-${month}-${day}`
+}

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

@@ -11,7 +11,8 @@ import {
   AggregationsParams,
   FieldFilter,
   FieldFilters,
-  FilterAggregationParams,
+  FilterQuery,
+  FiltersAggregationParams,
   SortByField,
 } from '../../../../../../../libs/common/domain/src/lib/model/search'
 import { METADATA_LANGUAGE } from '../../metadata-language'
@@ -26,6 +27,9 @@ import {
   TermsAggregationResult,
 } from '../../../../../../../libs/api/metadata-converter/src'
 import { LangService } from '../../../../../../../libs/util/i18n/src'
+import { formatDate, isDateRange } from './date-range.utils'
+
+export type DateRange = { start?: Date; end?: Date }
 
 @Injectable({
   providedIn: 'root',
@@ -213,7 +217,9 @@ export class ElasticsearchService {
     return this.metadataLang === 'current'
   }
 
-  private filtersToQueryString(filters: FieldFilters): string {
+  private filtersToQuery(
+    filters: FieldFilters | FiltersAggregationParams | string
+  ): FilterQuery {
     const makeQuery = (filter: FieldFilter): string => {
       if (typeof filter === 'string') {
         return filter
@@ -227,13 +233,53 @@ export class ElasticsearchService {
         })
         .join(' OR ')
     }
-    return Object.keys(filters)
-      .filter(
-        (fieldname) =>
-          filters[fieldname] && JSON.stringify(filters[fieldname]) !== '{}'
-      )
-      .map((fieldname) => `${fieldname}:(${makeQuery(filters[fieldname])})`)
-      .join(' AND ')
+    const queryString =
+      typeof filters === 'string'
+        ? filters
+        : Object.keys(filters)
+            .filter((fieldname) => !isDateRange(filters[fieldname]))
+            .filter(
+              (fieldname) =>
+                filters[fieldname] &&
+                JSON.stringify(filters[fieldname]) !== '{}'
+            )
+            .map(
+              (fieldname) => `${fieldname}:(${makeQuery(filters[fieldname])})`
+            )
+            .join(' AND ')
+    const queryRange = Object.entries(filters)
+      .filter(([, value]) => isDateRange(value))
+      .map(([searchField, dateRange]) => {
+        return {
+          searchField,
+          dateRange,
+        } as {
+          searchField: string
+          dateRange: DateRange
+        }
+      })[0]
+    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',
+            },
+          },
+        },
+    ].filter(Boolean)
+    return queryParts.length > 0 ? (queryParts as FilterQuery) : undefined
   }
 
   private buildPayloadQuery(
@@ -266,13 +312,9 @@ export class ElasticsearchService {
         },
       })
     }
-    const queryFilters = this.filtersToQueryString(fieldSearchFilters)
+    const queryFilters = this.filtersToQuery(fieldSearchFilters)
     if (queryFilters) {
-      filter.push({
-        query_string: {
-          query: queryFilters,
-        },
-      })
+      filter.push(...queryFilters)
     }
     if (uuids) {
       filter.push({
@@ -480,14 +522,7 @@ export class ElasticsearchService {
               const filter = aggregation.filters[curr]
               return {
                 ...prev,
-                [curr]: {
-                  query_string: {
-                    query:
-                      typeof filter === 'string'
-                        ? filter
-                        : this.filtersToQueryString(filter),
-                  },
-                },
+                [curr]: this.filtersToQuery(filter)[0],
               }
             }, {}),
           }

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

@@ -1,2 +1,3 @@
 export * from './elasticsearch.service'
 export * from './constant'
+export * from './date-range.utils'