geonetwork-ui 2.4.0-dev.fdf8f64b → 2.4.1-dev.c1a684900

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

@@ -1,8 +1,12 @@
 import {
   parseXml,
+  XmlCdata,
   XmlComment,
+  XmlDeclaration,
   XmlDocument,
+  XmlDocumentType,
   XmlElement,
+  XmlProcessingInstruction,
   XmlText,
 } from '@rgrove/parse-xml'
 import { ChainableFunction, fallback } from './function-utils'
@@ -196,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, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+  }
   if (el instanceof XmlDocument)
     return `<?xml version="1.0" encoding="UTF-8"?>${xmlToString(
       el.children[0]
@@ -207,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 -->`
 
@@ -225,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))
@@ -303,6 +318,7 @@ export const NAMESPACES = {
 }
 
 /**
+ * Creates a single element, without parent or children
  * @param name Full name with namespace, e.g.: gmd:MD_Metadata
  */
 export function createElement(
@@ -311,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> {
@@ -328,22 +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
-// will filter out falsy elements
-export function appendChildren(
-  ...childrenFns: Array<ChainableFunction<void, XmlElement>>
-): ChainableFunction<XmlElement, XmlElement> {
-  return (element) => {
-    if (!element) return null
-    childrenFns = childrenFns.filter((fn) => fn)
-    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> {
@@ -357,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> {
@@ -370,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> {

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'

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

@@ -1,12 +1,37 @@
+import {
+  HttpClient,
+  HttpErrorResponse,
+  HttpHeaders,
+} from '@angular/common/http'
 import { Injectable } from '@angular/core'
+import {
+  assertValidXml,
+  findConverterForDocument,
+  Gn4Converter,
+  Gn4SearchResults,
+  Iso19139Converter,
+} from '../../../../../../libs/api/metadata-converter/src'
+import { PublicationVersionError } from '../../../../../../libs/common/domain/src/lib/model/error'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+import {
+  Aggregations,
+  AggregationsParams,
+  FieldFilters,
+} from '../../../../../../libs/common/domain/src/lib/model/search'
+import {
+  SearchParams,
+  SearchResults,
+} from '../../../../../../libs/common/domain/src/lib/model/search/search.model'
+import { PlatformServiceInterface } from '../../../../../../libs/common/domain/src/lib/platform.service.interface'
+import { RecordsRepositoryInterface } from '../../../../../../libs/common/domain/src/lib/repository/records-repository.interface'
 import {
   RecordsApiService,
   SearchApiService,
 } from '../../../../../../libs/data-access/gn4/src'
-import { ElasticsearchService } from './elasticsearch'
 import {
   combineLatest,
   exhaustMap,
+  forkJoin,
   from,
   Observable,
   of,
@@ -14,30 +39,11 @@ import {
   switchMap,
   throwError,
 } from 'rxjs'
-import { RecordsRepositoryInterface } from '../../../../../../libs/common/domain/src/lib/repository/records-repository.interface'
-import {
-  SearchParams,
-  SearchResults,
-} from '../../../../../../libs/common/domain/src/lib/model/search/search.model'
-import {
-  Aggregations,
-  AggregationsParams,
-  FieldFilters,
-} from '../../../../../../libs/common/domain/src/lib/model/search'
 import { catchError, map, tap } from 'rxjs/operators'
-import {
-  assertValidXml,
-  findConverterForDocument,
-  Gn4Converter,
-  Gn4SearchResults,
-  Iso19139Converter,
-} from '../../../../../../libs/api/metadata-converter/src'
-import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
-import {
-  HttpClient,
-  HttpErrorResponse,
-  HttpHeaders,
-} from '@angular/common/http'
+import { lt } from 'semver'
+import { ElasticsearchService } from './elasticsearch'
+
+const minPublicationApiVersion = '4.2.5'
 
 const TEMPORARY_ID_PREFIX = 'TEMP-ID-'
 
@@ -53,7 +59,8 @@ export class Gn4Repository implements RecordsRepositoryInterface {
     private gn4SearchApi: SearchApiService,
     private gn4SearchHelper: ElasticsearchService,
     private gn4Mapper: Gn4Converter,
-    private gn4RecordsApi: RecordsApiService
+    private gn4RecordsApi: RecordsApiService,
+    private platformService: PlatformServiceInterface
   ) {}
 
   search({
@@ -242,33 +249,36 @@ export class Gn4Repository implements RecordsRepositoryInterface {
     record: CatalogRecord,
     referenceRecordSource?: string
   ): Observable<string> {
-    return this.serializeRecordToXml(record, referenceRecordSource).pipe(
+    return this.platformService.getApiVersion().pipe(
+      map((version) => {
+        if (lt(version, minPublicationApiVersion)) {
+          throw new PublicationVersionError(version)
+        }
+      }),
+      switchMap(() => this.serializeRecordToXml(record, referenceRecordSource)),
       switchMap((recordXml) =>
-        this.gn4RecordsApi
-          .insert(
-            'METADATA',
-            undefined,
-            undefined,
-            undefined,
-            true,
-            undefined,
-            'OVERWRITE',
-            undefined,
-            undefined,
-            undefined,
-            '_none_',
-            undefined,
-            undefined,
-            undefined,
-            recordXml
-          )
-          .pipe(
-            map((response) => {
-              const metadataId = Object.keys(response.metadataInfos)[0]
-              return response.metadataInfos[metadataId][0].uuid
-            })
-          )
-      )
+        this.gn4RecordsApi.insert(
+          'METADATA',
+          undefined,
+          undefined,
+          undefined,
+          true,
+          undefined,
+          'OVERWRITE',
+          undefined,
+          undefined,
+          undefined,
+          '_none_',
+          undefined,
+          undefined,
+          undefined,
+          recordXml
+        )
+      ),
+      map((response) => {
+        const metadataId = Object.keys(response.metadataInfos)[0]
+        return response.metadataInfos[metadataId][0].uuid
+      })
     )
   }
 
@@ -340,11 +350,60 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       .filter((draft) => draft !== null)
     return from(
       Promise.all(
-        drafts.map((draft) => findConverterForDocument(draft).readRecord(draft))
+        drafts.map((draft) => {
+          return findConverterForDocument(draft).readRecord(draft)
+        })
       )
     )
   }
 
+  getDraftsCount(): Observable<number> {
+    const items = { ...window.localStorage }
+    const draftCount = Object.keys(items)
+      .filter((key) => key.startsWith('geonetwork-ui-draft-'))
+      .map((key) => window.localStorage.getItem(key))
+      .filter((draft) => draft !== null).length
+    return of(draftCount)
+  }
+
+  hasRecordChangedSinceDraft(localRecord: CatalogRecord) {
+    return of({
+      isUnsaved: this.isRecordNotYetSaved(localRecord.uniqueIdentifier),
+      hasDraft: this.recordHasDraft(localRecord.uniqueIdentifier),
+    }).pipe(
+      switchMap(({ isUnsaved, hasDraft }) => {
+        if (isUnsaved || !hasDraft) {
+          return of({ user: undefined, date: undefined })
+        }
+        return forkJoin([
+          this.getAllDrafts().pipe(
+            map((drafts) => {
+              const matchingRecord = drafts.find(
+                (draft) =>
+                  draft.uniqueIdentifier === localRecord.uniqueIdentifier
+              )
+              return matchingRecord?.recordUpdated || null
+            })
+          ),
+          this.getRecord(localRecord.uniqueIdentifier),
+        ]).pipe(
+          map(([draftRecordUpdated, recentRecord]) => {
+            if (recentRecord?.recordUpdated > draftRecordUpdated) {
+              const user = recentRecord.extras?.['ownerInfo']
+                ?.toString()
+                ?.split('|')
+              return {
+                user: `${user[2]} ${user[1]}`,
+                date: recentRecord.recordUpdated,
+              }
+            }
+            return { user: undefined, date: undefined }
+          })
+        )
+      })
+    )
+  }
+
   private getRecordAsXml(uniqueIdentifier: string): Observable<string | null> {
     return this.gn4RecordsApi
       .getRecordAs(

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

@@ -37,7 +37,7 @@ export class Gn4PlatformMapper {
 
     return this.avatarService
       .getProfileIcon(hash)
-      .pipe(map((profileIcon) => ({ ...user, profileIcon } as UserModel)))
+      .pipe(map((profileIcon) => ({ ...user, profileIcon }) as UserModel))
   }
 
   userFromApi(apiUser: UserApiModel): UserModel {