geonetwork-ui 2.1.0-initial

package/src/libs/util/data-fetcher/src/lib/readers/geojson.ts

@@ -0,0 +1,29 @@
+import { DataItem, PropertyInfo } from '../model'
+import { fetchDataAsText, processItemProperties } from '../utils'
+import { BaseFileReader } from './base-file'
+
+/**
+ * This parser supports both Geojson Feature collections or arrays
+ * of Features
+ * @param text
+ */
+export function parseGeojson(text: string): {
+  items: DataItem[]
+  properties: PropertyInfo[]
+} {
+  const parsed = JSON.parse(text)
+  const features =
+    parsed.type === 'FeatureCollection' ? parsed.features : parsed
+  if (!Array.isArray(features)) {
+    throw new Error(
+      'Could not parse GeoJSON, expected a features collection or an array of features at root level'
+    )
+  }
+  return processItemProperties(features)
+}
+
+export class GeojsonReader extends BaseFileReader {
+  getData() {
+    return fetchDataAsText(this.url).then(parseGeojson)
+  }
+}

package/src/libs/util/data-fetcher/src/lib/readers/gml.ts

@@ -0,0 +1,54 @@
+import { BaseFileReader } from './base-file'
+import { DataItem, PropertyInfo } from '../model'
+import { fetchDataAsText, processItemProperties } from '../utils'
+import { GeoJSON, WFS } from 'ol/format'
+import { WfsVersion } from '@camptocamp/ogc-client'
+
+export function parseGml(
+  text: string,
+  namespace: string,
+  version: string
+): {
+  items: DataItem[]
+  properties: PropertyInfo[]
+} {
+  const splittedNamespace = namespace.split(':')
+  const regex = new RegExp(`xmlns:${splittedNamespace[0]}=["']([^'"]*)["']`)
+  const match = regex.exec(text)
+
+  if (match && match.length >= 2) {
+    const wf = new WFS({
+      featureNS: match[1],
+      featureType: splittedNamespace[1],
+      version: version,
+    })
+
+    let features
+    try {
+      features = wf.readFeatures(text)
+    } catch (e) {
+      throw Error("Couldn't parse WFS with GML features")
+    }
+
+    const geojsonItem = new GeoJSON().writeFeaturesObject(features)
+    return processItemProperties(geojsonItem.features, true)
+  }
+  throw Error("Couldn't retrieve namespace url")
+}
+
+export class GmlReader extends BaseFileReader {
+  namespace: string
+  version: WfsVersion
+
+  constructor(url, namespace, version) {
+    super(url)
+    this.namespace = namespace
+    this.version = version
+  }
+
+  protected getData() {
+    return fetchDataAsText(this.url).then((text) =>
+      parseGml(text, this.namespace, this.version)
+    )
+  }
+}

package/src/libs/util/data-fetcher/src/lib/readers/json.ts

@@ -0,0 +1,28 @@
+import { DataItem, PropertyInfo } from '../model'
+import {
+  fetchDataAsText,
+  jsonToGeojsonFeature,
+  processItemProperties,
+} from '../utils'
+import { BaseFileReader } from './base-file'
+
+/**
+ * This parser only supports arrays of simple flat objects with properties
+ * @param text
+ */
+export function parseJson(text: string): {
+  items: DataItem[]
+  properties: PropertyInfo[]
+} {
+  const parsed = JSON.parse(text) as any[]
+  if (!Array.isArray(parsed)) {
+    throw new Error('Could not parse JSON, expected an array at root level')
+  }
+  return processItemProperties(parsed.map(jsonToGeojsonFeature))
+}
+
+export class JsonReader extends BaseFileReader {
+  getData() {
+    return fetchDataAsText(this.url).then(parseJson)
+  }
+}

package/src/libs/util/data-fetcher/src/lib/sql-utils.ts

@@ -0,0 +1,115 @@
+import {
+  FieldAggregation,
+  FieldFilter,
+  FieldGroupBy,
+  FieldName,
+  FieldSort,
+} from './model'
+
+function filterToSql(filter: FieldFilter): string {
+  const operator = filter[0]
+  const args = filter.slice(1)
+  function valueToSql(value: string | number) {
+    return typeof value === 'number' ? value : `'${value}'`
+  }
+  switch (operator) {
+    case '<':
+    case '<=':
+    case '>':
+    case '>=':
+    case '=':
+    case '!=':
+    case 'like':
+      return `[${args[0]}] ${operator.toUpperCase()} ${valueToSql(
+        args[1] as string | number
+      )}`
+    case 'in': {
+      const values = args.slice(1) as string[] | number[]
+      return `[${args[0]}] IN (${values.map(valueToSql).join(', ')})`
+    }
+    case 'and':
+    case 'or': {
+      const children = (args as FieldFilter[])
+        .map(filterToSql)
+        .join(` ${operator.toUpperCase()} `)
+      return `(${children})`
+    }
+    case 'not':
+      return `NOT (${filterToSql(args[0] as FieldFilter)})`
+  }
+  throw new Error(
+    `Could not generate SQL query, operator not recognized: ${operator}`
+  )
+}
+
+function aggregationToSql(aggregation: FieldAggregation): string {
+  const operation = aggregation[0]
+  const field = aggregation[1]
+
+  switch (operation) {
+    case 'average':
+      return `AVG([${field}]) as [average(${field})]`
+    case 'sum':
+    case 'max':
+    case 'min':
+      return `${operation.toUpperCase()}([${field}]) as [${operation}(${field})]`
+    case 'count':
+      return 'COUNT(*) as [count()]'
+  }
+}
+
+/**
+ * Leave arguments at null if not used
+ * @param selected
+ * @param filter
+ * @param sort
+ * @param startIndex
+ * @param count
+ * @param groupBy
+ * @param aggregations
+ */
+export function generateSqlQuery(
+  selected: FieldName[] = null,
+  filter: FieldFilter = null,
+  sort: FieldSort[] = null,
+  startIndex: number = null,
+  count: number = null,
+  groupBy: FieldGroupBy[] = null,
+  aggregations: FieldAggregation[] = null
+): string {
+  let sqlSelect = 'SELECT *'
+  const sqlFrom = ' FROM ?'
+  let sqlOrderBy = ''
+  let sqlWhere = ''
+  let sqlLimit = ''
+  let sqlGroupBy = ''
+  if (selected !== null) {
+    sqlSelect = `SELECT ${selected.map((name) => `[${name}]`).join(', ')}`
+  }
+  if (filter !== null) {
+    sqlWhere = ` WHERE ${filterToSql(filter)}`
+  }
+  if (sort?.length) {
+    sqlOrderBy = ` ORDER BY ${sort
+      .map((sort) => `[${sort[1]}] ${sort[0].toUpperCase()}`)
+      .join(', ')}`
+  }
+  if (startIndex !== null && count !== null) {
+    sqlLimit = ` LIMIT ${count} OFFSET ${startIndex}`
+  }
+  if (groupBy !== null && aggregations !== null) {
+    sqlSelect = `SELECT ${aggregations.map(aggregationToSql).join(', ')}`
+    const groupedByDistinct = groupBy.filter((group) => group[0] === 'distinct')
+    const sqlGroupByFields = groupedByDistinct
+      .map((group) => `[${group[1]}]`)
+      .join(', ')
+    const sqlGroupBySelect = groupedByDistinct
+      .map((group) => `[${group[1]}] as [distinct(${group[1]})]`)
+      .join(', ')
+    if (sqlGroupByFields && sqlGroupBySelect) {
+      sqlGroupBy = ` GROUP BY ${sqlGroupByFields}`
+      sqlSelect += `, ${sqlGroupBySelect}`
+    }
+  }
+  return sqlSelect + sqlFrom + sqlGroupBy + sqlOrderBy + sqlWhere + sqlLimit
+}

package/src/libs/util/data-fetcher/src/lib/utils.ts

@@ -0,0 +1,253 @@
+import {
+  DataItem,
+  DatasetHeaders,
+  FetchError,
+  PropertyInfo,
+  SupportedType,
+  SupportedTypes,
+} from './model'
+import { sharedFetch, useCache } from '@camptocamp/ogc-client'
+import { parseHeaders } from './headers'
+import parseDate from 'date-fns/parse'
+import parseIsoDate from 'date-fns/parseISO'
+
+export async function inferDatasetType(
+  url: string,
+  typeHint?: SupportedType
+): Promise<SupportedType> {
+  const fileExtensionMatches = new URL(
+    url,
+    typeof window !== 'undefined' ? window.location.toString() : undefined
+  ).pathname.match(/\.(.+)$/)
+  const fileExtension =
+    fileExtensionMatches && fileExtensionMatches.length
+      ? (fileExtensionMatches[1].toLowerCase() as SupportedType)
+      : null
+
+  // 1. type hint
+  if (typeHint) return Promise.resolve(typeHint)
+
+  // 2. content-type header
+  const headers = await fetchHeaders(url)
+  if ('supportedType' in headers) return headers.supportedType
+  // 3. file extension from url
+  else if (SupportedTypes.indexOf(fileExtension) > -1) return fileExtension
+
+  // no type inferred or hinted
+  if ('mimeType' in headers) throw FetchError.unsupportedType(headers.mimeType)
+  else throw FetchError.unknownType()
+}
+
+export function fetchHeaders(url: string): Promise<DatasetHeaders> {
+  return sharedFetch(url, 'HEAD')
+    .catch((error) => {
+      throw FetchError.corsOrNetwork(error.message)
+    })
+    .then((response) => {
+      if (!response.ok) {
+        throw FetchError.http(response.status)
+      }
+      return parseHeaders(response.headers)
+    })
+}
+
+export function fetchDataAsText(url: string): Promise<string> {
+  return useCache(
+    () =>
+      sharedFetch(url)
+        .catch((error) => {
+          throw FetchError.corsOrNetwork(error.message)
+        })
+        .then(async (response) => {
+          if (!response.ok) {
+            throw FetchError.http(response.status)
+          }
+          return response.text()
+        }),
+    url,
+    'asText'
+  )
+}
+export function fetchDataAsArrayBuffer(url: string): Promise<ArrayBuffer> {
+  return useCache(
+    () =>
+      sharedFetch(url)
+        .catch((error) => {
+          throw FetchError.corsOrNetwork(error.message)
+        })
+        .then(async (response) => {
+          if (!response.ok) {
+            throw FetchError.http(response.status)
+          }
+          // convert to a numeric array so that we can store the response in cache
+          return Array.from(new Uint8Array(await response.arrayBuffer()))
+        }),
+    url,
+    'asArrayBuffer'
+  ).then((array) => {
+    return new Uint8Array(array).buffer
+  })
+}
+
+export function tryParseDate(input: string): Date | null {
+  function tryIso() {
+    const parsed = parseIsoDate(input)
+    return isNaN(parsed.getDate()) ? null : parsed
+  }
+  function tryFormat(format: string) {
+    const parsed = parseDate(input, format, new Date())
+    return isNaN(parsed.getDate()) ? null : parsed
+  }
+  return (
+    tryIso() ||
+    tryFormat('dd/MM/yyyy') ||
+    tryFormat('dd.MM.yyyy') ||
+    tryFormat('MM/dd/yyyy') ||
+    null
+  )
+}
+
+export function tryParseNumber(input: string): number | null {
+  if (isNaN(input as any)) return null
+  const parsed = parseFloat(input)
+  return isNaN(parsed) ? null : parsed
+}
+
+export function jsonToGeojsonFeature(object: { [key: string]: any }): DataItem {
+  const { id, properties } = Object.keys(object)
+    .map((property) => (property ? property : 'unknown')) //prevent empty strings
+    .reduce(
+      (prev, curr) =>
+        curr.toLowerCase().endsWith('id')
+          ? {
+              ...prev,
+              id: object[curr],
+            }
+          : {
+              ...prev,
+              properties: { ...prev.properties, [curr]: object[curr] },
+            },
+      { id: undefined, properties: {} }
+    )
+  return {
+    type: 'Feature',
+    geometry: null,
+    properties,
+    ...(id !== undefined && { id }),
+  }
+}
+
+function mutateProperties(
+  items: DataItem[],
+  mutators: { [fieldName: string]: (value: unknown) => unknown }
+): DataItem[] {
+  const mutatorKeys = Object.keys(mutators)
+  for (let i = 0, ii = items.length; i < ii; i++) {
+    const item = items[i]
+    for (const mutatorField of mutatorKeys) {
+      if (!(mutatorField in item.properties)) continue
+      item.properties[mutatorField] = mutators[mutatorField](
+        item.properties[mutatorField]
+      )
+    }
+  }
+  return items
+}
+
+const SAMPLE_SIZE = 20
+
+/**
+ * This will infer field types from a list of data items and cast the values accordingly
+ * @param items
+ * @param inferTypes
+ */
+export function processItemProperties(
+  items: DataItem[],
+  inferTypes = false
+): {
+  items: DataItem[]
+  properties: PropertyInfo[]
+} {
+  const foundFields: { [name: string]: PropertyInfo } = {}
+  for (let i = 0, ii = Math.min(SAMPLE_SIZE, items.length); i < ii; i++) {
+    const item = items[i]
+    const fields = Object.keys(item.properties)
+    for (const field of fields) {
+      if (!(field in foundFields)) {
+        foundFields[field] = {
+          label: field,
+          name: field,
+          type: null,
+        }
+      }
+      const value = item.properties[field]
+      const info = foundFields[field]
+      if (value === undefined || value === '' || value === null) continue
+
+      if (!inferTypes) {
+        if (info.type === null && typeof value === 'number') {
+          info.type = 'number'
+        } else if (info.type === 'number' && typeof value !== 'number') {
+          info.type = 'string'
+        }
+        continue
+      }
+
+      const parsedNumber = tryParseNumber(value)
+      if (info.type === null && parsedNumber !== null) {
+        info.type = 'number'
+        continue
+      } else if (info.type === 'number' && parsedNumber === null) {
+        info.type = 'string'
+        continue
+      }
+      const parsedDate = tryParseDate(value)
+      if (info.type === null && parsedDate !== null) {
+        info.type = 'date'
+      } else if (info.type === 'date' && parsedDate === null) {
+        info.type = 'string'
+      }
+    }
+  }
+
+  const properties: PropertyInfo[] = []
+  const mutators = {}
+  for (const field in foundFields) {
+    const info = foundFields[field]
+    if (info.type === 'number') {
+      mutators[field] = tryParseNumber
+    } else if (info.type === 'date') {
+      mutators[field] = tryParseDate
+    }
+    properties.push({ ...info, type: info.type || 'string' })
+  }
+  if (inferTypes) {
+    mutateProperties(items, mutators)
+  }
+  return { items, properties }
+}
+
+/**
+ * This creates a Proxy that allows reading and writing to the data item properties
+ * as if it was a simple array of JSON objects
+ * @param items
+ */
+export function getJsonDataItemsProxy(
+  items: DataItem[]
+): Record<string, unknown>[] {
+  return new Proxy<Record<string, unknown>[]>(items as any, {
+    get(target: Record<string, unknown>[], p: string | symbol) {
+      if (
+        typeof p === 'string' &&
+        !Number.isNaN(parseInt(p)) &&
+        target[p]?.properties
+      ) {
+        return target[p].properties
+      }
+      return target[p]
+    },
+    set() {
+      throw new Error('This object is read-only')
+    },
+  })
+}

package/src/libs/util/i18n/src/index.ts

@@ -0,0 +1,7 @@
+export * from './lib/util-i18n.module'
+export * from './lib/i18n.constants'
+export * from './lib/i18n.interceptor'
+export * from './lib/lang.service'
+export * from './lib/file.translate.loader'
+export * from './lib/testing/test.translate.module'
+export * from './lib/embedded.translate.loader'

package/src/libs/util/i18n/src/lib/embedded.translate.loader.ts

@@ -0,0 +1,18 @@
+import { TranslateLoader } from '@ngx-translate/core'
+import { Observable, map, of } from 'rxjs'
+import { dropEmptyTranslations } from './translate.loader.utils'
+import de from '../../../../../translations/de.json'
+import en from '../../../../../translations/en.json'
+import es from '../../../../../translations/es.json'
+import fr from '../../../../../translations/fr.json'
+import it from '../../../../../translations/it.json'
+import nl from '../../../../../translations/nl.json'
+import pt from '../../../../../translations/pt.json'
+
+export class EmbeddedTranslateLoader implements TranslateLoader {
+  getTranslation(lang: string): Observable<any> {
+    const langs = { de, en, es, fr, it, nl, pt }
+    const translations = langs[lang.substring(0, 2)]
+    return of(translations).pipe(map(dropEmptyTranslations))
+  }
+}

package/src/libs/util/i18n/src/lib/file.translate.loader.ts

@@ -0,0 +1,14 @@
+import { TranslateHttpLoader } from '@ngx-translate/http-loader'
+import { map } from 'rxjs/operators'
+import { dropEmptyTranslations } from './translate.loader.utils'
+
+/**
+ * This loader will rely on JSON files in the app assets
+ * Implements a fallback on default lang if translated labels are empty
+ */
+export class FileTranslateLoader extends TranslateHttpLoader {
+  getTranslation(lang: string) {
+    const baseLang = lang.substring(0, 2) // removing the right part of e.g. en_EN
+    return super.getTranslation(baseLang).pipe(map(dropEmptyTranslations))
+  }
+}

package/src/libs/util/i18n/src/lib/i18n.constants.ts

@@ -0,0 +1,72 @@
+import { HttpClient } from '@angular/common/http'
+import { TranslateCompiler, TranslateLoader } from '@ngx-translate/core'
+import { TranslateMessageFormatCompiler } from 'ngx-translate-messageformat-compiler'
+import { FileTranslateLoader } from './file.translate.loader'
+import { marker } from '@biesbjerg/ngx-translate-extract-marker'
+
+marker('language.en')
+marker('language.nl')
+marker('language.fr')
+marker('language.de')
+marker('language.ko')
+marker('language.es')
+marker('language.cs')
+marker('language.ca')
+marker('language.fi')
+marker('language.is')
+marker('language.it')
+marker('language.pt')
+marker('language.ru')
+marker('language.zh')
+marker('language.sk')
+
+export const DEFAULT_LANG = 'en'
+
+export const LANG_3_TO_2_MAPPER = {
+  eng: 'en',
+  dut: 'nl',
+  fre: 'fr',
+  ger: 'de',
+  kor: 'ko',
+  spa: 'es',
+  cze: 'cs',
+  cat: 'ca',
+  fin: 'fi',
+  ice: 'is',
+  ita: 'it',
+  por: 'pt',
+  rus: 'ru',
+  chi: 'zh',
+  slo: 'sk',
+}
+
+// Caution: changing this can break language selection from third parties!
+export const LANGUAGE_STORAGE_KEY = 'geonetwork-ui-language'
+
+export const LANG_2_TO_3_MAPPER = Object.entries(LANG_3_TO_2_MAPPER).reduce(
+  (mapperObject, langEntry) => {
+    return { ...mapperObject, [langEntry[1]]: langEntry[0] }
+  },
+  {}
+)
+
+export function HttpLoaderFactory(http: HttpClient) {
+  return new FileTranslateLoader(http, './assets/i18n/')
+}
+//Deprecated, but currently still used in datafeeder
+export function getLangFromBrowser() {
+  return navigator.language.substr(0, 2)
+}
+const COMPILER_CONFIG = {
+  provide: TranslateCompiler,
+  useClass: TranslateMessageFormatCompiler,
+}
+export const TRANSLATE_DEFAULT_CONFIG = {
+  compiler: COMPILER_CONFIG,
+  loader: {
+    provide: TranslateLoader,
+    useFactory: HttpLoaderFactory,
+    defaultLanguage: DEFAULT_LANG,
+    deps: [HttpClient],
+  },
+}

package/src/libs/util/i18n/src/lib/i18n.interceptor.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core'
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor,
+} from '@angular/common/http'
+import { TranslateService } from '@ngx-translate/core'
+import { Observable } from 'rxjs'
+import { DEFAULT_LANG } from './i18n.constants'
+
+@Injectable()
+export class I18nInterceptor implements HttpInterceptor {
+  constructor(private translate: TranslateService) {}
+
+  intercept(
+    request: HttpRequest<any>,
+    next: HttpHandler
+  ): Observable<HttpEvent<any>> {
+    request = request.clone({
+      setHeaders: {
+        'Accept-Language': this.translate.currentLang || DEFAULT_LANG,
+      },
+    })
+    return next.handle(request)
+  }
+}

package/src/libs/util/i18n/src/lib/lang.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core'
+import { LANG_2_TO_3_MAPPER } from './i18n.constants'
+import { TranslateService } from '@ngx-translate/core'
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LangService {
+  constructor(private translate: TranslateService) {}
+
+  get iso2() {
+    return this.translate.currentLang
+  }
+  get iso3(): string {
+    return LANG_2_TO_3_MAPPER[this.iso2]
+  }
+  get index(): string {
+    return `lang${this.iso3}`
+  }
+  get gnLang() {
+    return this.iso3 ? 'lang' + this.iso3 : null
+  }
+}

package/src/libs/util/i18n/src/lib/testing/test.translate.loader.ts

@@ -0,0 +1,26 @@
+import { TranslateLoader } from '@ngx-translate/core'
+import { Observable, of as observableOf } from 'rxjs'
+import { Translations, LanguageTranslations } from './translations.model'
+
+// IMPORTANT:
+// This was copy-pasted from https://github.com/mwootendev/ngx-translate-plugins/blob/7c6c73c7d16c9519a7bafff939d29fd8ea5e574a/projects/testing/src/lib/test-translate-loader.service.ts
+// because the original package was expecting rxjs 7+ as a peer dep and that was conflicting with many other dependencies
+// FIXME: when rxjs 7 can be used in the project, remove this and do `npm install ngx-translate-testing --save-dev`
+
+export class TestTranslateLoader extends TranslateLoader {
+  constructor(private _translations: Translations = {}) {
+    super()
+  }
+
+  /**
+   * Returns an {Observable} of translations for the specified language. If the
+   * language is not recognized, an empty translations object will be returned.
+   *
+   * @param language the language for which the translations should be retrieved.
+   * @returns the translations for the specified
+   *          language or an empty set of translations if the language is not recognized.
+   */
+  public getTranslation(language: string): Observable<LanguageTranslations> {
+    return observableOf(this._translations[language] || {})
+  }
+}