geonetwork-ui 2.1.0-initial

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

@@ -0,0 +1,235 @@
+import { ModuleWithProviders, NgModule } from '@angular/core'
+import {
+  FakeMissingTranslationHandler,
+  TranslateDefaultParser,
+  TranslateFakeCompiler,
+  TranslateModule,
+  TranslateService,
+  TranslateCompiler,
+} from '@ngx-translate/core'
+import { TestTranslateLoader } from './test.translate.loader'
+import { LanguageTranslations, Translations } from './translations.model'
+
+// IMPORTANT:
+// This was copy-pasted from https://github.com/mwootendev/ngx-translate-plugins/blob/7c6c73c7d16c9519a7bafff939d29fd8ea5e574a/projects/testing/src/lib/testing.module.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`
+
+/**
+ * The TranslateTestingModule provides the {TranslateModule} as well as a
+ * {TranslateService} configured to return translations specific for the
+ * test environment.
+ *
+ * @export
+ */
+@NgModule({
+  imports: [TranslateModule],
+  exports: [TranslateModule],
+})
+export class TranslateTestingModule
+  implements ModuleWithProviders<TranslateTestingModule>
+{
+  private _translations: Translations = {}
+
+  private _defaultLanguage: string
+
+  private _compiler: TranslateCompiler
+
+  /**
+   * Creates a new instance of the {TranslateTestingModule} with translations for the specified language.
+   *
+   * @example
+   *
+   * const ENGLISH_TRANSLATIONS = { greeting: 'Hello' };
+   * const translateModule = TranslateTestingModule.withTranslations('en', ENGLISH_TRANSLATIONS);
+   *
+   * @example
+   *
+   * TranslateTestingModule.withTranslations('en', require('../../assets/i18n/en.json'));
+   *
+   * @static
+   * @param {string} language the language for the translations.
+   * @param {Translations} translations the translations to be used in the tests.
+   * @returns the new instance that can be used to chain additional configuration.
+   * @memberof TranslateTestingModule
+   */
+  public static withTranslations(
+    language: string,
+    translations: LanguageTranslations
+  ): TranslateTestingModule
+
+  /**
+   * Creates a new instance of the {TranslateTestingModule} with the provided translations.
+   *
+   * @example
+   *
+   * const TRANSLATIONS = { en: { greeting: 'Hello' }, es: { greeting: 'Hola' } };
+   * const translateModule = TranslateTestingModule.withTranslations(TRANSLATIONS);
+   *
+   * @example
+   *
+   * TranslateTestingModule.withTranslations(require('./test.i18n.json'));
+   *
+   * @static
+   * @param {Translations} the language translations the translations to be used in the tests.
+   * @returns the new instance that can be used to chain additional configuration.
+   * @memberof TranslateTestingModule
+   */
+  public static withTranslations(
+    translations: Translations
+  ): TranslateTestingModule
+
+  public static withTranslations(
+    languageOrTranslations: string | Translations,
+    translations?: LanguageTranslations
+  ): TranslateTestingModule {
+    const translateTestingModule = new TranslateTestingModule()
+
+    if (typeof languageOrTranslations === 'string') {
+      return translateTestingModule.withTranslations(
+        <string>languageOrTranslations,
+        translations
+      )
+    }
+
+    return translateTestingModule.withTranslations(languageOrTranslations)
+  }
+
+  public get ngModule() {
+    return TranslateTestingModule
+  }
+
+  public get providers() {
+    const translateService = new TranslateService(
+      null,
+      new TestTranslateLoader(this._translations),
+      this._compiler || new TranslateFakeCompiler(),
+      new TranslateDefaultParser(),
+      new FakeMissingTranslationHandler(),
+      true,
+      true,
+      false,
+      this._defaultLanguage
+    )
+
+    return [
+      {
+        provide: TranslateService,
+        useValue: translateService,
+      },
+    ]
+  }
+
+  /**
+   * Updates the {TranslateTestingModule} instance with additional translations. The
+   * translations will be shallowly merged with any existing translations.
+   *
+   * @example
+   *
+   * const ENGLISH_TRANSLATIONS = { en: { greeting: 'Hello' } };
+   * const SPANISH_TRANSLATIONS = { en: { greeting: 'Hola' } };
+   * const translateModule = TranslateTestingModule.withTranslations(ENGLISH_TRANSLATIONS)
+   *   .withTranslations(SPANISH_TRANSLATIONS);
+   *
+   * @param {Translations} translations the additional translations to add to the testing service.
+   * @returns the instance that can be used to chain additional configuration.
+   * @memberof TranslateTestingModule
+   */
+  public withTranslations(translations: Translations): TranslateTestingModule
+
+  /**
+   * Updates the {TranslateTestingModule} instance with additional translations for a
+   * specified language. The translations will be shallowly merged with any existing translations.
+   *
+   * @example
+   *
+   * const ENGLISH_TRANSLATIONS = { greeting: 'Hello' };
+   * const SPANISH_TRANSLATIONS = { greeting: 'Hola' };
+   * const translateModule = TranslateTestingModule.withTranslations('en', ENGLISH_TRANSLATIONS)
+   *   .withTranslations('es', SPANISH_TRANSLATIONS);
+   *
+   * @example
+   *
+   * TranslateTestingModule.withTranslations('en', require('../../assets/i18n/en.json'))
+   *   .withTranslations('es', require('../../assets/i18n/es.json'));
+   *
+   * @param {string} language the language for which the new translations are being added.
+   * @param {LanguageTranslations} translations the translations for the specified language.
+   * @returns the instance that can be used to chain additional configuration.
+   * @memberof TranslateTestingModule
+   */
+  public withTranslations(
+    language: string,
+    translations: LanguageTranslations
+  ): TranslateTestingModule
+
+  public withTranslations(
+    languageOrTranslations: string | Translations,
+    translations?: LanguageTranslations
+  ): TranslateTestingModule {
+    if (typeof languageOrTranslations === 'string' && translations) {
+      this.addTranslations(languageOrTranslations, translations)
+      this._defaultLanguage = languageOrTranslations
+    } else if (languageOrTranslations) {
+      Object.keys(languageOrTranslations).forEach((language) =>
+        this.addTranslations(language, languageOrTranslations[language])
+      )
+    }
+    return this
+  }
+
+  /**
+   * Updates the {TranslationTestingModule} to provide a {TranslateService} that will
+   * use the provided {TranslateCompiler} to translate the test translations.
+   *
+   * @example
+   *
+   * TranslateTestingModule.withTranslations('en', {people: '{gender, select, male{He is} female{She is} other{They are}} {how})'})
+   *   .withCompiler(new TranslateMessageFormatCompiler());
+   *
+   * @param compiler the compiler to use to compile the test translations.
+   * @returns the instance that can be used to chain additional configuration.
+   * @memberof TranslateTestingModule
+   */
+  public withCompiler(compiler: TranslateCompiler): TranslateTestingModule {
+    this._compiler = compiler
+    return this
+  }
+
+  /**
+   * Updates the {TranslateTestingModule} to use the provided language as the default language.
+   * By default, the default language will be set to the first language provided.
+   *
+   * @example
+   *
+   * TranslateTestingModule.withTranslations('es', SPANISH_TRANSLATIONS)
+   *   .withTranslations('en', ENGLISH_TRANSLATIONS)
+   *   .withDefaultLanguage('en');
+   *
+   * @param language the new default language for translations.
+   * @returns the instance that can be used to chain additional configuration.
+   * @memberof TranslateTestingModule
+   */
+  public withDefaultLanguage(language: string): TranslateTestingModule {
+    this._defaultLanguage = language || this._defaultLanguage
+    return this
+  }
+
+  private addTranslations(
+    language: string,
+    translations: LanguageTranslations
+  ) {
+    if (!this._defaultLanguage) {
+      this._defaultLanguage = language
+    }
+
+    if (this._translations[language]) {
+      this._translations[language] = {
+        ...this._translations[language],
+        ...translations,
+      }
+    } else {
+      this._translations[language] = translations
+    }
+  }
+}

package/src/libs/util/i18n/src/lib/testing/translations.model.ts

@@ -0,0 +1,28 @@
+// IMPORTANT:
+// This was copy-pasted from https://github.com/mwootendev/ngx-translate-plugins/blob/7c6c73c7d16c9519a7bafff939d29fd8ea5e574a/projects/testing/src/lib/translations.model.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 declare type LanguageTranslation =
+  | string
+  | string[]
+  | { [translationKey: string]: LanguageTranslation }
+
+/**
+ * LanguageTranslations represents a mapping between a translation key and the translation for that key
+ * or to nested translation keys.
+ *
+ * @export
+ */
+export interface LanguageTranslations {
+  [translationKey: string]: LanguageTranslation
+}
+
+/**
+ * Translations represents a mapping between a language and the translations for that language.
+ *
+ * @export
+ */
+export interface Translations {
+  [language: string]: LanguageTranslations
+}

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

@@ -0,0 +1,11 @@
+export function dropEmptyTranslations(translations) {
+  // filter out empty keys: this should let us fallback on the default lang or
+  // untranslated key, instead of having a blank space
+  return Object.keys(translations).reduce(
+    (prev, curr) =>
+      translations[curr].trim().length
+        ? { ...prev, [curr]: translations[curr] }
+        : prev,
+    {}
+  )
+}

package/src/libs/util/i18n/src/lib/util-i18n.module.ts

@@ -0,0 +1,26 @@
+import { HTTP_INTERCEPTORS, HttpClientModule } from '@angular/common/http'
+import { NgModule } from '@angular/core'
+import { TranslateModule, TranslateService } from '@ngx-translate/core'
+import { DEFAULT_LANG, LANGUAGE_STORAGE_KEY } from './i18n.constants'
+import { I18nInterceptor } from './i18n.interceptor'
+import { CommonModule } from '@angular/common'
+
+@NgModule({
+  imports: [HttpClientModule, TranslateModule.forChild(), CommonModule],
+  exports: [],
+  providers: [
+    { provide: HTTP_INTERCEPTORS, useClass: I18nInterceptor, multi: true },
+  ],
+})
+export class UtilI18nModule {
+  constructor(translate: TranslateService) {
+    translate.setDefaultLang(DEFAULT_LANG)
+    let storageLang = null
+    try {
+      storageLang = localStorage.getItem(LANGUAGE_STORAGE_KEY)
+    } catch (error) {
+      console.warn(error)
+    }
+    translate.use(storageLang || translate.getBrowserLang() || DEFAULT_LANG)
+  }
+}

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

@@ -0,0 +1,6 @@
+export * from './lib/util-shared.module'
+export * from './lib/services'
+export * from './lib/utils'
+export * from './lib/links'
+export * from './lib/pipes'
+export * from './lib/image-fallback.directive'

package/src/libs/util/shared/src/lib/image-fallback.directive.ts

@@ -0,0 +1,19 @@
+import { Directive, ElementRef, HostListener, Input } from '@angular/core'
+
+@Directive({
+  selector: 'img[gnUiImageFallback]',
+})
+export class ImageFallbackDirective {
+  @Input() fallbackUrl: string
+  @HostListener('error')
+  useFallback() {
+    const fallbackUrl = new URL(
+      this.fallbackUrl,
+      window.location.toString()
+    ).toString()
+    if (this.el.nativeElement.src !== fallbackUrl) {
+      this.el.nativeElement.src = fallbackUrl
+    }
+  }
+  constructor(private el: ElementRef) {}
+}

package/src/libs/util/shared/src/lib/links/index.ts

@@ -0,0 +1,2 @@
+export * from './link-utils'
+export * from './link-classifier.service'

package/src/libs/util/shared/src/lib/links/link-classifier.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core'
+import { DatasetDistribution } from '../../../../../../libs/common/domain/src/lib/record'
+import { getFileFormat } from './link-utils'
+export enum LinkUsage {
+  API = 'api',
+  MAP_API = 'mapapi',
+  DOWNLOAD = 'download',
+  DATA = 'data',
+  GEODATA = 'geodata',
+  LANDING_PAGE = 'landingpage',
+  UNKNOWN = 'unknown',
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LinkClassifierService {
+  getUsagesForLink(link: DatasetDistribution): LinkUsage[] {
+    switch (link.type) {
+      case 'service': {
+        switch (link.accessServiceProtocol) {
+          case 'esriRest':
+          case 'wfs':
+            return [LinkUsage.API, LinkUsage.DOWNLOAD, LinkUsage.GEODATA]
+          case 'wms':
+          case 'wmts':
+            return [LinkUsage.API, LinkUsage.MAP_API]
+          default:
+            return [LinkUsage.UNKNOWN]
+        }
+      }
+      case 'link':
+        return [LinkUsage.UNKNOWN]
+      case 'download': {
+        switch (getFileFormat(link)) {
+          case 'json':
+          case 'csv':
+          case 'excel':
+            return [LinkUsage.DOWNLOAD, LinkUsage.DATA]
+          case 'geojson':
+            return [LinkUsage.DOWNLOAD, LinkUsage.GEODATA]
+          default:
+            if (link.url.toString().match(/\/wfs/i)) {
+              return [LinkUsage.DOWNLOAD, LinkUsage.GEODATA]
+            }
+            return [LinkUsage.DOWNLOAD]
+        }
+      }
+    }
+  }
+
+  hasUsage(link: DatasetDistribution, usage: LinkUsage) {
+    return this.getUsagesForLink(link).indexOf(usage) > -1
+  }
+}

package/src/libs/util/shared/src/lib/links/link-utils.ts

@@ -0,0 +1,200 @@
+import { marker } from '@biesbjerg/ngx-translate-extract-marker'
+import { DatasetDistribution } from '../../../../../../libs/common/domain/src/lib/record'
+
+marker('downloads.wfs.featuretype.not.found')
+
+export const FORMATS = {
+  csv: {
+    extensions: ['csv'],
+    priority: 1,
+    color: '#559d7f',
+    mimeTypes: ['text/csv', 'application/csv'],
+  },
+  excel: {
+    extensions: [
+      'excel',
+      'xls',
+      'xlsx',
+      'ms-excel',
+      'openxmlformats-officedocument',
+    ],
+    priority: 2,
+    color: '#0f4395',
+    mimeTypes: [
+      'application/vnd.ms-excel',
+      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    ],
+  },
+  geojson: {
+    extensions: ['geojson'],
+    priority: 3,
+    color: '#1e5180',
+    mimeTypes: ['application/geo+json', 'application/vnd.geo+json'],
+  },
+  json: {
+    extensions: ['json'],
+    priority: 3,
+    color: '#1e5180',
+    mimeTypes: ['application/json'],
+  },
+  shp: {
+    extensions: ['shp', 'shape', 'zipped-shapefile'],
+    priority: 4,
+    color: '#328556',
+    mimeTypes: ['x-gis/x-shapefile'],
+  },
+  kml: {
+    extensions: ['kml', 'kmz'],
+    priority: 5,
+    color: '#348009',
+    mimeTypes: [
+      'application/vnd.google-earth.kml+xml',
+      'application/vnd.google-earth.kmz',
+    ],
+  },
+  gpkg: {
+    extensions: ['gpkg', 'geopackage'],
+    priority: 6,
+    color: '#ea79ba',
+    mimeTypes: ['application/geopackage+sqlite3'],
+  },
+  zip: {
+    extensions: ['zip'],
+    priority: 7,
+    color: '#f2bb3a',
+    mimeTypes: ['application/zip'],
+  },
+  pdf: {
+    extensions: ['pdf'],
+    priority: 8,
+    color: '#db544a',
+    mimeTypes: ['application/pdf'],
+  },
+  jpg: {
+    extensions: ['jpg', 'jpeg', 'jfif', 'pjpeg', 'pjp'],
+    priority: 8,
+    color: '#673ab7',
+    mimeTypes: ['image/jpg'],
+  },
+  svg: {
+    extensions: ['svg'],
+    priority: 9,
+    color: '#d98294',
+    mimeTypes: ['image/svg+xml'],
+  },
+} as const
+
+export type FileFormat = keyof typeof FORMATS
+
+export function getFormatPriority(linkFormat: FileFormat): number {
+  for (const format in FORMATS) {
+    for (const ext of FORMATS[format].extensions) {
+      if (new RegExp(`${ext}`, 'i').test(linkFormat)) {
+        if (FORMATS[format].priority === 0) return 0
+        return Object.keys(FORMATS).length - FORMATS[format].priority
+      }
+    }
+  }
+  return 0
+}
+
+export function getLinkPriority(link: DatasetDistribution): number {
+  return getFormatPriority(getFileFormat(link))
+}
+
+export function extensionToFormat(extension: string): FileFormat {
+  for (const format in FORMATS) {
+    for (const alias of FORMATS[format].extensions) {
+      if (alias === extension.toLowerCase()) return format as FileFormat
+    }
+  }
+  return undefined
+}
+
+export function getFileFormat(link: DatasetDistribution): FileFormat {
+  if ('mimeType' in link) {
+    return mimeTypeToFormat(link.mimeType)
+  }
+  for (const format in FORMATS) {
+    for (const alias of FORMATS[format].extensions) {
+      if (checkFileFormat(link, alias)) return format as FileFormat
+      if (isFormatInQueryParam(link, alias)) return format as FileFormat
+    }
+  }
+  return null
+}
+
+export function isFormatInQueryParam(
+  link: DatasetDistribution,
+  alias: string
+): boolean {
+  const queryParams = link.url.searchParams
+  for (const [key, value] of queryParams.entries()) {
+    if (key === 'format' || key === 'f') {
+      return value === alias
+    }
+  }
+  return false
+}
+
+export function mimeTypeToFormat(mimeType: string): FileFormat {
+  for (const format in FORMATS) {
+    for (const mt of FORMATS[format].mimeTypes) {
+      if (mimeType === mt) return format as FileFormat
+    }
+  }
+  return undefined
+}
+
+export function checkFileFormat(
+  link: DatasetDistribution,
+  format: FileFormat
+): boolean {
+  return (
+    ('name' in link && new RegExp(`[./]${format}`, 'i').test(link.name)) ||
+    ('url' in link &&
+      new RegExp(`[./]${format}`, 'i').test(link.url.toString()))
+  )
+}
+
+export function getBadgeColor(linkFormat: FileFormat): string {
+  for (const format in FORMATS) {
+    for (const alias of FORMATS[format].extensions) {
+      if (new RegExp(`${alias}`, 'i').test(linkFormat))
+        return FORMATS[format].color
+    }
+  }
+  return 'var(--color-gray-700)' // Default color ?
+}
+
+export function getLinkLabel(link: DatasetDistribution): string {
+  let format = ''
+  switch (link.type) {
+    case 'service':
+      {
+        switch (link.accessServiceProtocol) {
+          case 'wfs':
+            format = 'WFS'
+            break
+          case 'wms':
+            format = 'WMS'
+            break
+          case 'wmts':
+            format = 'WMTS'
+            break
+          case 'esriRest':
+            format = 'REST'
+            break
+        }
+      }
+      break
+    default:
+      format = getFileFormat(link)
+  }
+  const label = link.description || link.name
+  return format ? `${label} (${format})` : label
+}
+
+export function getMimeTypeForFormat(format: FileFormat): string | null {
+  return format in FORMATS ? FORMATS[format.toLowerCase()].mimeTypes[0] : null
+}

package/src/libs/util/shared/src/lib/pipes/SafePipe.ts

@@ -0,0 +1,36 @@
+import { Pipe, PipeTransform } from '@angular/core'
+import {
+  DomSanitizer,
+  SafeHtml,
+  SafeStyle,
+  SafeScript,
+  SafeUrl,
+  SafeResourceUrl,
+} from '@angular/platform-browser'
+
+@Pipe({
+  name: 'safe',
+})
+export class SafePipe implements PipeTransform {
+  constructor(protected sanitizer: DomSanitizer) {}
+
+  public transform(
+    value: any,
+    type: string
+  ): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl {
+    switch (type) {
+      case 'html':
+        return this.sanitizer.bypassSecurityTrustHtml(value)
+      case 'style':
+        return this.sanitizer.bypassSecurityTrustStyle(value)
+      case 'script':
+        return this.sanitizer.bypassSecurityTrustScript(value)
+      case 'url':
+        return this.sanitizer.bypassSecurityTrustUrl(value)
+      case 'resourceUrl':
+        return this.sanitizer.bypassSecurityTrustResourceUrl(value)
+      default:
+        throw new Error(`Invalid safe type specified: ${type}`)
+    }
+  }
+}

package/src/libs/util/shared/src/lib/pipes/index.ts

@@ -0,0 +1 @@
+export * from './SafePipe'

package/src/libs/util/shared/src/lib/services/index.ts

@@ -0,0 +1,3 @@
+export * from './theme.service'
+export * from './log.service'
+export * from './proxy.service'

package/src/libs/util/shared/src/lib/services/log.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core'
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LogService {
+  log(message: string, ...objects: any[]): void {
+    console.log.apply(this, [message, ...objects])
+  }
+  warn(message: string, ...objects: any[]): void {
+    console.warn.apply(this, [message, ...objects])
+  }
+  error(message: string, ...objects: any[]): void {
+    console.error.apply(this, [message, ...objects])
+  }
+}

package/src/libs/util/shared/src/lib/services/proxy.service.ts

@@ -0,0 +1,34 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core'
+
+export const PROXY_PATH = new InjectionToken<string>('proxyPath')
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ProxyService {
+  constructor(@Optional() @Inject(PROXY_PATH) private proxyPath: string) {}
+
+  /**
+   * Transforms the URL to go through a proxy specified with the PROXY_PATH
+   * injection token.
+   * @param url
+   */
+  getProxiedUrl(url: string): string {
+    if (!this.proxyPath) return url
+    const urlObj = new URL(url)
+    const current = window.location
+    const proxyUrl = new URL(this.proxyPath, current.toString()).toString()
+    if (
+      current.hostname === urlObj.hostname &&
+      current.protocol === urlObj.protocol &&
+      current.port === urlObj.port
+    ) {
+      return url
+    }
+    if (url.indexOf(proxyUrl) === 0) return url
+    return new URL(
+      `${this.proxyPath}${encodeURIComponent(url)}`,
+      window.location.toString()
+    ).toString()
+  }
+}