geonetwork-ui 2.4.0-dev.618ec561 → 2.4.0-dev.66a33793

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

@@ -1,9 +1,10 @@
 import {
   Constraint,
-  DatasetDistribution,
+  DatasetOnlineResource,
   GraphicOverview,
   Individual,
   Keyword,
+  OnlineResource,
   Organization,
   RecordKind,
   RecordStatus,
@@ -326,12 +327,12 @@ const getMimeType = pipe(
 )
 
 /**
- * Extract distributions from a MD_Distribution element
+ * Extract online resources from an MD_Distribution element
  * @param getMimeTypeFn This function starts from a gmd:transferOptions element
  */
-export function extractDatasetDistributions(
+export function extractDatasetOnlineResources(
   getMimeTypeFn: ChainableFunction<XmlElement, string>
-): ChainableFunction<XmlElement, DatasetDistribution[]> {
+): ChainableFunction<XmlElement, DatasetOnlineResource[]> {
   const getUrl = pipe(findChildElement('gmd:linkage'), extractMandatoryUrl())
   const getProtocolStr = pipe(
     findChildElement('gmd:protocol'),
@@ -774,14 +775,6 @@ export function readLineage(rootEl: XmlElement): string {
   )(rootEl)
 }
 
-export function readDistributions(rootEl: XmlElement): DatasetDistribution[] {
-  return pipe(
-    findNestedElements('gmd:distributionInfo', 'gmd:MD_Distribution'),
-    mapArray(extractDatasetDistributions(getMimeType)),
-    flattenArray()
-  )(rootEl)
-}
-
 export function readUpdateFrequency(rootEl: XmlElement): UpdateFrequency {
   return pipe(
     findIdentification(),
@@ -845,9 +838,14 @@ export function extractServiceOnlineResources(): ChainableFunction<
   )
 }
 
-export function readOnlineResources(
-  rootEl: XmlElement
-): ServiceOnlineResource[] {
+export function readOnlineResources(rootEl: XmlElement): OnlineResource[] {
+  if (readKind(rootEl) === 'dataset') {
+    return pipe(
+      findNestedElements('gmd:distributionInfo', 'gmd:MD_Distribution'),
+      mapArray(extractDatasetOnlineResources(getMimeType)),
+      flattenArray()
+    )(rootEl)
+  }
   return pipe(
     findNestedElements('gmd:distributionInfo', 'gmd:MD_Distribution'),
     mapArray(extractServiceOnlineResources()),

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

@@ -1,7 +1,7 @@
 import {
   CatalogRecord,
   Constraint,
-  DatasetDistribution,
+  DatasetOnlineResource,
   DatasetRecord,
   DatasetServiceDistribution,
   Individual,
@@ -29,7 +29,6 @@ import {
   tap,
 } from '../function-utils'
 import {
-  XmlElement,
   addAttribute,
   appendChildren,
   createChild,
@@ -44,6 +43,7 @@ import {
   removeChildren,
   removeChildrenByName,
   setTextContent,
+  XmlElement,
 } from '../xml-utils'
 import { readKind } from './read-parts'
 import { writeGeometry } from './utils/geometry'
@@ -179,7 +179,7 @@ export function getRoleCode(role: Role): string {
   }
 }
 
-export function getDistributionProtocol(
+export function getServiceDistributionProtocol(
   distribution: DatasetServiceDistribution
 ): string {
   switch (distribution.accessServiceProtocol.toLowerCase()) {
@@ -610,11 +610,11 @@ export function createLicense(license: Constraint) {
   )
 }
 
-export function removeDistributions() {
+export function removeOnlineResources() {
   return pipe(removeChildrenByName('gmd:distributionInfo'))
 }
 
-function appendDistributionFormat(mimeType: string) {
+function appendOnlineResourceFormat(mimeType: string) {
   return appendChildren(
     pipe(
       createElement('gmd:distributionFormat'),
@@ -638,8 +638,8 @@ export function createDistributionInfo() {
 }
 
 // apply to MD_Distribution
-export function appendDistribution(
-  distribution: DatasetDistribution,
+export function appendOnlineResource(
+  onlineResource: DatasetOnlineResource,
   appendFormatFn: (
     mimeType: string
   ) => ChainableFunction<XmlElement, XmlElement>
@@ -647,16 +647,16 @@ export function appendDistribution(
   let name: string
   let functionCode: string
   let protocol: string
-  if (distribution.type === 'service') {
-    name = distribution.identifierInService // this is for GeoNetwork to know the layer name
+  if (onlineResource.type === 'service') {
+    name = onlineResource.identifierInService // this is for GeoNetwork to know the layer name
     functionCode = 'download'
-    protocol = getDistributionProtocol(distribution)
-  } else if (distribution.type === 'download') {
-    name = distribution.name
+    protocol = getServiceDistributionProtocol(onlineResource)
+  } else if (onlineResource.type === 'download') {
+    name = onlineResource.name
     functionCode = 'download'
     protocol = 'WWW:DOWNLOAD'
   } else {
-    name = distribution.name
+    name = onlineResource.name
     functionCode = 'information'
     protocol = 'WWW:LINK'
   }
@@ -666,12 +666,12 @@ export function appendDistribution(
       createChild('gmd:MD_DigitalTransferOptions'),
       createChild('gmd:onLine'),
       createChild('gmd:CI_OnlineResource'),
-      writeLinkage(distribution.url),
-      'description' in distribution
+      writeLinkage(onlineResource.url),
+      'description' in onlineResource
         ? appendChildren(
             pipe(
               createElement('gmd:description'),
-              writeCharacterString(distribution.description)
+              writeCharacterString(onlineResource.description)
             )
           )
         : noop,
@@ -695,7 +695,9 @@ export function appendDistribution(
     )
   )
   return pipe(
-    'mimeType' in distribution ? appendFormatFn(distribution.mimeType) : noop,
+    'mimeType' in onlineResource
+      ? appendFormatFn(onlineResource.mimeType)
+      : noop,
     appendTransferOptions
   )
 }
@@ -743,33 +745,6 @@ export function writeKind(record: CatalogRecord, rootEl: XmlElement) {
   )(rootEl)
 }
 
-export function writeOwnerOrganization(
-  record: CatalogRecord,
-  rootEl: XmlElement
-) {
-  // if no contact matches the owner org, create an empty one
-  const ownerContact: Individual = record.contacts.find(
-    (contact) => contact.organization.name === record.ownerOrganization.name
-  )
-  pipe(
-    findChildOrCreate('gmd:contact'),
-    removeAllChildren(),
-    appendResponsibleParty(
-      ownerContact
-        ? {
-            ...ownerContact,
-            // owner responsible party is always point of contact
-            role: 'point_of_contact',
-          }
-        : {
-            organization: record.ownerOrganization,
-            email: '',
-            role: 'point_of_contact',
-          }
-    )
-  )(rootEl)
-}
-
 export function writeRecordUpdated(record: CatalogRecord, rootEl: XmlElement) {
   pipe(
     findChildOrCreate('gmd:dateStamp'),
@@ -1032,20 +1007,6 @@ export function writeGraphicOverviews(
   )(rootEl)
 }
 
-export function writeDistributions(record: DatasetRecord, rootEl: XmlElement) {
-  pipe(
-    removeDistributions(),
-    appendChildren(
-      ...record.distributions.map((d) =>
-        pipe(
-          createDistributionInfo(),
-          appendDistribution(d, appendDistributionFormat)
-        )
-      )
-    )
-  )(rootEl)
-}
-
 export function writeLineage(record: DatasetRecord, rootEl: XmlElement) {
   pipe(
     findNestedChildOrCreate(
@@ -1127,16 +1088,40 @@ export function createOnlineResource(onlineResource: ServiceOnlineResource) {
   )
 }
 
-export function writeOnlineResources(
-  record: ServiceRecord,
+export function appendDatasetOnlineResources(
+  record: DatasetRecord,
   rootEl: XmlElement
 ) {
-  pipe(
-    removeDistributions(),
-    appendChildren(...record.onlineResources.map(createOnlineResource))
+  appendChildren(
+    ...record.onlineResources.map((d) =>
+      pipe(
+        createDistributionInfo(),
+        appendOnlineResource(d, appendOnlineResourceFormat)
+      )
+    )
   )(rootEl)
 }
 
+export function appendServiceOnlineResources(
+  record: ServiceRecord,
+  rootEl: XmlElement
+) {
+  appendChildren(...record.onlineResources.map(createOnlineResource))(rootEl)
+}
+
+export function writeOnlineResources(
+  record: CatalogRecord,
+  rootEl: XmlElement
+) {
+  removeOnlineResources()(rootEl)
+
+  if (record.kind === 'dataset') {
+    appendDatasetOnlineResources(record, rootEl)
+    return
+  }
+  appendServiceOnlineResources(record, rootEl)
+}
+
 export function writeTemporalExtents(
   record: DatasetRecord,
   rootEl: XmlElement

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

@@ -36,7 +36,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]
   }
@@ -180,11 +181,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 : ''
   }
 }
 
@@ -456,3 +457,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/gn4-repository.ts

@@ -6,9 +6,11 @@ import {
 import { ElasticsearchService } from './elasticsearch'
 import {
   combineLatest,
+  exhaustMap,
   from,
   Observable,
   of,
+  Subject,
   switchMap,
   throwError,
 } from 'rxjs'
@@ -24,18 +26,30 @@ import {
 } from '../../../../../../libs/common/domain/src/lib/model/search'
 import { catchError, map, tap } from 'rxjs/operators'
 import {
-  BaseConverter,
+  assertValidXml,
   findConverterForDocument,
   Gn4Converter,
   Gn4SearchResults,
   Iso19139Converter,
 } from '../../../../../../libs/api/metadata-converter/src'
 import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
-import { HttpErrorResponse } from '@angular/common/http'
+import {
+  HttpClient,
+  HttpErrorResponse,
+  HttpHeaders,
+} from '@angular/common/http'
+
+const TEMPORARY_ID_PREFIX = 'TEMP-ID-'
+
+export type RecordAsXml = string
 
 @Injectable()
 export class Gn4Repository implements RecordsRepositoryInterface {
+  _draftsChanged = new Subject<void>()
+  draftsChanged$ = this._draftsChanged.asObservable()
+
   constructor(
+    private httpClient: HttpClient,
     private gn4SearchApi: SearchApiService,
     private gn4SearchHelper: ElasticsearchService,
     private gn4Mapper: Gn4Converter,
@@ -135,6 +149,7 @@ export class Gn4Repository implements RecordsRepositoryInterface {
         )
       )
   }
+
   aggregate(params: AggregationsParams): Observable<Aggregations> {
     // if aggregations are empty, return an empty object right away
     if (Object.keys(params).length === 0) return of({})
@@ -179,44 +194,12 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       )
   }
 
-  /**
-   * Returns null if the record is not found
-   */
-  private loadRecordAsXml(uniqueIdentifier: string): Observable<string | null> {
-    return this.gn4RecordsApi
-      .getRecordAs(
-        uniqueIdentifier,
-        undefined,
-        false,
-        undefined,
-        undefined,
-        undefined,
-        'application/xml',
-        'response',
-        undefined,
-        { httpHeaderAccept: 'text/xml,application/xml' as 'application/xml' } // this is to make sure that the response is parsed as text
-      )
-      .pipe(
-        map((response) => response.body),
-        catchError((error: HttpErrorResponse) =>
-          error.status === 404 ? of(null) : throwError(() => error)
-        )
-      )
-  }
-
-  private getLocalStorageKeyForRecord(uniqueIdentifier: string) {
-    return `geonetwork-ui-draft-${uniqueIdentifier}`
-  }
-
   openRecordForEdition(
     uniqueIdentifier: string
   ): Observable<[CatalogRecord, string, boolean] | null> {
-    const draft$ = of(
-      window.localStorage.getItem(
-        this.getLocalStorageKeyForRecord(uniqueIdentifier)
-      )
-    )
-    const recordAsXml$ = this.loadRecordAsXml(uniqueIdentifier)
+    const draft$ = of(this.getRecordFromLocalStorage(uniqueIdentifier))
+    const recordAsXml$ = this.getRecordAsXml(uniqueIdentifier)
+
     return combineLatest([draft$, recordAsXml$]).pipe(
       switchMap(([draft, recordAsXml]) => {
         const xml = draft ?? recordAsXml
@@ -234,33 +217,27 @@ export class Gn4Repository implements RecordsRepositoryInterface {
   openRecordForDuplication(
     uniqueIdentifier: string
   ): Observable<[CatalogRecord, string, false] | null> {
-    return this.loadRecordAsXml(uniqueIdentifier).pipe(
-      switchMap(async (recordAsXml) => {
-        const converter = findConverterForDocument(recordAsXml)
-        const record = await converter.readRecord(recordAsXml)
-        record.uniqueIdentifier = `TEMP-ID-${Date.now()}`
+    return this.getRecordAsXml(uniqueIdentifier).pipe(
+      switchMap(async (fetchedRecordAsXml) => {
+        const converter = findConverterForDocument(fetchedRecordAsXml)
+        const record = await converter.readRecord(fetchedRecordAsXml)
+
+        record.uniqueIdentifier = `${TEMPORARY_ID_PREFIX}${Date.now()}`
         record.title = `${record.title} (Copy)`
-        const xml = await converter.writeRecord(record, recordAsXml)
-        window.localStorage.setItem(
-          this.getLocalStorageKeyForRecord(record.uniqueIdentifier),
-          xml
+
+        const recordAsXml = await converter.writeRecord(
+          record,
+          fetchedRecordAsXml
         )
-        return [record, xml, false] as [CatalogRecord, string, false]
+
+        this.saveRecordToLocalStorage(recordAsXml, record.uniqueIdentifier)
+        this._draftsChanged.next()
+
+        return [record, recordAsXml, false] as [CatalogRecord, string, false]
       })
     )
   }
 
-  private serializeRecordToXml(
-    record: CatalogRecord,
-    referenceRecordSource?: string
-  ): Observable<string> {
-    // if there's a reference record, use that standard; otherwise, use iso19139
-    const converter = referenceRecordSource
-      ? findConverterForDocument(referenceRecordSource)
-      : new Iso19139Converter()
-    return from(converter.writeRecord(record, referenceRecordSource))
-  }
-
   saveRecord(
     record: CatalogRecord,
     referenceRecordSource?: string
@@ -295,32 +272,63 @@ export class Gn4Repository implements RecordsRepositoryInterface {
     )
   }
 
+  duplicateExternalRecord(recordDownloadUrl: string): Observable<string> {
+    return this.getExternalRecordAsXml(recordDownloadUrl).pipe(
+      exhaustMap(async (fetchedRecordAsXml: string) => {
+        const converter = findConverterForDocument(fetchedRecordAsXml)
+        const record = await converter.readRecord(fetchedRecordAsXml)
+        const tempId = this.generateTemporaryId()
+
+        record.title = `${record.title} (Copy)`
+        record.uniqueIdentifier = tempId
+
+        const recordAsXml = await converter.writeRecord(
+          record,
+          fetchedRecordAsXml
+        )
+
+        this.saveRecordToLocalStorage(recordAsXml, record.uniqueIdentifier)
+        this._draftsChanged.next()
+
+        return tempId
+      }),
+      catchError((error: HttpErrorResponse) => {
+        return throwError(() => error)
+      })
+    )
+  }
+
+  deleteRecord(uniqueIdentifier: string): Observable<void> {
+    return this.gn4RecordsApi.deleteRecord(uniqueIdentifier)
+  }
+
+  generateTemporaryId(): string {
+    return `${TEMPORARY_ID_PREFIX}${Date.now()}`
+  }
+
   saveRecordAsDraft(
     record: CatalogRecord,
     referenceRecordSource?: string
   ): Observable<string> {
     return this.serializeRecordToXml(record, referenceRecordSource).pipe(
-      tap((recordXml) =>
-        window.localStorage.setItem(
-          this.getLocalStorageKeyForRecord(record.uniqueIdentifier),
-          recordXml
-        )
-      )
+      tap((recordXml) => {
+        this.saveRecordToLocalStorage(recordXml, record.uniqueIdentifier)
+        this._draftsChanged.next()
+      })
     )
   }
 
   clearRecordDraft(uniqueIdentifier: string): void {
-    window.localStorage.removeItem(
-      this.getLocalStorageKeyForRecord(uniqueIdentifier)
-    )
+    this.removeRecordFromLocalStorage(uniqueIdentifier)
+    this._draftsChanged.next()
   }
 
   recordHasDraft(uniqueIdentifier: string): boolean {
-    return (
-      window.localStorage.getItem(
-        this.getLocalStorageKeyForRecord(uniqueIdentifier)
-      ) !== null
-    )
+    return this.getRecordFromLocalStorage(uniqueIdentifier) !== null
+  }
+
+  isRecordNotYetSaved(uniqueIdentifier: string): boolean {
+    return uniqueIdentifier.startsWith(TEMPORARY_ID_PREFIX)
   }
 
   // generated by copilot
@@ -336,4 +344,80 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       )
     )
   }
+
+  private getRecordAsXml(uniqueIdentifier: string): Observable<string | null> {
+    return this.gn4RecordsApi
+      .getRecordAs(
+        uniqueIdentifier,
+        undefined,
+        false,
+        undefined,
+        undefined,
+        undefined,
+        'application/xml',
+        'response',
+        undefined,
+        { httpHeaderAccept: 'text/xml,application/xml' as 'application/xml' } // this is to make sure that the response is parsed as text
+      )
+      .pipe(
+        map((response) => response.body),
+        catchError((error: HttpErrorResponse) =>
+          error.status === 404 ? of(null) : throwError(() => error)
+        )
+      )
+  }
+
+  private serializeRecordToXml(
+    record: CatalogRecord,
+    referenceRecordSource?: string
+  ): Observable<string> {
+    // if there's a reference record, use that standard; otherwise, use iso19139
+    const converter = referenceRecordSource
+      ? findConverterForDocument(referenceRecordSource)
+      : new Iso19139Converter()
+    return from(converter.writeRecord(record, referenceRecordSource))
+  }
+
+  private getExternalRecordAsXml(
+    recordDownloadUrl: string
+  ): Observable<string> {
+    let headers = new HttpHeaders()
+    const responseType_ = 'text'
+    headers = headers.set('Accept', 'text/xml,application/xml')
+
+    return this.httpClient
+      .get<string>(recordDownloadUrl, {
+        responseType: <any>responseType_,
+        headers: headers,
+        observe: 'body',
+      })
+      .pipe(
+        map((recordAsXmlFile) => {
+          assertValidXml(recordAsXmlFile)
+
+          return recordAsXmlFile
+        })
+      )
+  }
+
+  private getLocalStorageKeyForRecord(recordId: string): string {
+    return `geonetwork-ui-draft-${recordId}` // Never change this prefix as it is a breaking change
+  }
+
+  private saveRecordToLocalStorage(recordAsXml: RecordAsXml, recordId: string) {
+    window.localStorage.setItem(
+      this.getLocalStorageKeyForRecord(recordId),
+      recordAsXml
+    )
+  }
+
+  private getRecordFromLocalStorage(recordId: string): RecordAsXml {
+    return window.localStorage.getItem(
+      this.getLocalStorageKeyForRecord(recordId)
+    )
+  }
+
+  private removeRecordFromLocalStorage(recordId: string): void {
+    window.localStorage.removeItem(this.getLocalStorageKeyForRecord(recordId))
+  }
 }

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

@@ -79,6 +79,16 @@ export class Gn4PlatformMapper {
         (thes) => keyword.thesaurusKey === thes.key
       )
 
+      let bbox: [number, number, number, number]
+      if (keyword.coordWest) {
+        bbox = [
+          parseFloat(keyword.coordWest),
+          parseFloat(keyword.coordSouth),
+          parseFloat(keyword.coordEast),
+          parseFloat(keyword.coordNorth),
+        ]
+      }
+
       return {
         key,
         label,
@@ -90,7 +100,8 @@ export class Gn4PlatformMapper {
           url: new URL(matchedThesaurus?.url),
           type: matchedThesaurus?.dname as KeywordType,
         },
-      }
+        ...(bbox && { bbox }),
+      } as Keyword
     })
   }