geonetwork-ui 2.1.0-initial

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

@@ -0,0 +1,162 @@
+import { Injectable } from '@angular/core'
+import { SearchApiService } from '../../../../../../libs/data-access/gn4/src'
+import { ElasticsearchService } from './elasticsearch'
+import { Observable, of, switchMap } from 'rxjs'
+import { RecordsRepositoryInterface } from '../../../../../../libs/common/domain/src/lib/records-repository.interface'
+import {
+  SearchParams,
+  SearchResults,
+} from '../../../../../../libs/common/domain/src/lib/search/search.model'
+import {
+  Aggregations,
+  AggregationsParams,
+  FieldFilters,
+} from '../../../../../../libs/common/domain/src/lib/search'
+import { map } from 'rxjs/operators'
+import {
+  Gn4MetadataMapper,
+  Gn4SearchResults,
+} from '../../../../../../libs/api/metadata-converter/src'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/record'
+
+@Injectable()
+export class Gn4Repository implements RecordsRepositoryInterface {
+  constructor(
+    private gn4SearchApi: SearchApiService,
+    private gn4SearchHelper: ElasticsearchService,
+    private gn4Mapper: Gn4MetadataMapper
+  ) {}
+
+  search({
+    filters,
+    fields,
+    offset,
+    limit,
+    sort,
+    filterIds,
+    filterGeometry,
+  }: SearchParams): Observable<SearchResults> {
+    return this.gn4SearchApi
+      .search(
+        'bucket',
+        JSON.stringify(
+          this.gn4SearchHelper.getSearchRequestBody(
+            {},
+            limit,
+            offset,
+            sort,
+            fields,
+            filters,
+            undefined,
+            filterIds,
+            filterGeometry
+          )
+        )
+      )
+      .pipe(
+        switchMap((results: Gn4SearchResults) =>
+          this.gn4Mapper.readRecords(results.hits.hits).then((records) => ({
+            count: results.hits.total?.value || 0,
+            records,
+          }))
+        )
+      )
+  }
+
+  getMatchesCount(filters: FieldFilters): Observable<number> {
+    return this.gn4SearchApi
+      .search(
+        'records-count',
+        JSON.stringify({
+          ...this.gn4SearchHelper.getSearchRequestBody(
+            {},
+            0,
+            0,
+            undefined,
+            undefined,
+            filters
+          ),
+          track_total_hits: true,
+        })
+      )
+      .pipe(map((results: Gn4SearchResults) => results.hits.total?.value || 0))
+  }
+
+  getByUniqueIdentifier(
+    uniqueIdentifier: string
+  ): Observable<CatalogRecord | null> {
+    return this.gn4SearchApi
+      .search(
+        'bucket',
+        JSON.stringify(
+          this.gn4SearchHelper.getMetadataByIdPayload(uniqueIdentifier)
+        )
+      )
+      .pipe(
+        map((results: Gn4SearchResults) => results.hits.hits[0]),
+        switchMap((record) =>
+          record ? this.gn4Mapper.readRecord(record) : of(null)
+        )
+      )
+  }
+
+  getSimilarRecords(similarTo: CatalogRecord): Observable<CatalogRecord[]> {
+    return this.gn4SearchApi
+      .search(
+        'bucket',
+        JSON.stringify(
+          this.gn4SearchHelper.getRelatedRecordPayload(
+            similarTo.title,
+            similarTo.uniqueIdentifier,
+            3
+          )
+        )
+      )
+      .pipe(
+        switchMap((results: Gn4SearchResults) =>
+          this.gn4Mapper.readRecords(results.hits.hits)
+        )
+      )
+  }
+  aggregate(params: AggregationsParams): Observable<Aggregations> {
+    // if aggregations are empty, return an empty object right away
+    if (Object.keys(params).length === 0) return of({})
+
+    const aggregations = this.gn4SearchHelper.buildAggregationsPayload(params)
+    return this.gn4SearchApi
+      .search(
+        'bucket',
+        JSON.stringify(this.gn4SearchHelper.getSearchRequestBody(aggregations))
+      )
+      .pipe(
+        map((response: Gn4SearchResults) =>
+          Object.keys(response.aggregations).reduce(
+            (prev, curr) => ({
+              ...prev,
+              [curr]: this.gn4SearchHelper.parseAggregationResult(
+                response.aggregations[curr],
+                params[curr]
+              ),
+            }),
+            {}
+          )
+        )
+      )
+  }
+
+  fuzzySearch(query: string): Observable<SearchResults> {
+    return this.gn4SearchApi
+      .search(
+        'bucket',
+        JSON.stringify(this.gn4SearchHelper.buildAutocompletePayload(query))
+      )
+      .pipe(
+        switchMap((results: Gn4SearchResults) =>
+          this.gn4Mapper.readRecords(results.hits.hits).then((records) => ({
+            count: results.hits.total?.value || 0,
+            records,
+          }))
+        )
+      )
+  }
+}

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

@@ -0,0 +1,6 @@
+export * from './gn4-repository'
+export * from './organizations'
+export * from './elasticsearch'
+export * from './settings/gn4-settings.service'
+export * from './auth'
+export * from './favorites/favorites.service'

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

@@ -0,0 +1,13 @@
+export * from './organizations-from-metadata.service'
+export * from './organizations-from-groups.service'
+
+import { InjectionToken } from '@angular/core'
+
+export type OrganizationsStrategy = 'metadata' | 'groups'
+
+export const ORGANIZATIONS_STRATEGY = new InjectionToken<OrganizationsStrategy>(
+  'organizations-strategy',
+  {
+    factory: () => 'metadata',
+  }
+)

package/src/libs/api/repository/src/lib/gn4/organizations/organizations-from-groups.service.ts

@@ -0,0 +1,137 @@
+import { Injectable } from '@angular/core'
+import {
+  GroupApiModel,
+  GroupsApiService,
+  SearchApiService,
+} from '../../../../../../../libs/data-access/gn4/src'
+import { forkJoin, Observable, of } from 'rxjs'
+import { map, shareReplay } from 'rxjs/operators'
+import { TranslateService } from '@ngx-translate/core'
+import { LANG_2_TO_3_MAPPER } from '../../../../../../../libs/util/i18n/src'
+import { FieldFilters } from '../../../../../../../libs/common/domain/src/lib/search'
+import {
+  CatalogRecord,
+  Organization,
+} from '../../../../../../../libs/common/domain/src/lib/record'
+import { OrganizationsServiceInterface } from '../../../../../../../libs/common/domain/src/lib/organizations.service.interface'
+import { ElasticsearchService } from '../elasticsearch'
+import { getAsUrl, MetadataObject } from '../../../../../../../libs/api/metadata-converter/src'
+
+const IMAGE_URL = '/geonetwork/images/harvesting/'
+
+@Injectable()
+export class OrganizationsFromGroupsService
+  implements OrganizationsServiceInterface
+{
+  private groups$: Observable<GroupApiModel[]> = this.groupsApiService
+    .getGroups()
+    .pipe(shareReplay())
+  private groupsAggregation$ = this.searchApiService
+    .search(
+      'bucket',
+      JSON.stringify(
+        this.esService.getSearchRequestBody({
+          groups: {
+            terms: {
+              field: 'groupOwner',
+              size: 5000,
+            },
+          },
+        })
+      )
+    )
+    .pipe(
+      map((response) => response.aggregations.groups.buckets),
+      shareReplay()
+    )
+  organisations$ = forkJoin([this.groupsAggregation$, this.groups$]).pipe(
+    map(([groupsAgg, groups]) => this.mapGroups(groupsAgg, groups)),
+    shareReplay()
+  )
+  organisationsCount$ = this.organisations$.pipe(map((orgs) => orgs.length))
+
+  constructor(
+    private esService: ElasticsearchService,
+    private searchApiService: SearchApiService,
+    private groupsApiService: GroupsApiService,
+    private translateService: TranslateService
+  ) {}
+
+  private mapGroups(groupBuckets: any[], groups: GroupApiModel[]) {
+    return groupBuckets
+      .filter(({ key }) => !!groups.find((g) => g.id.toString() === key))
+      .map(({ key, doc_count }) => {
+        const group = groups.find((g) => g.id.toString() === key)
+        const org = this.mapOrgFromGroup(group)
+        return {
+          ...org,
+          recordCount: doc_count,
+        } as Organization
+      })
+  }
+
+  private mapOrgFromGroup(group: GroupApiModel) {
+    const lang3 = LANG_2_TO_3_MAPPER[this.translateService.currentLang]
+    return {
+      name: group.label[lang3],
+      ...(group.description && { description: group.description }),
+      ...(group.logo && {
+        logoUrl: getAsUrl(`${IMAGE_URL}${group.logo}`),
+      }),
+      ...(group.website && {
+        website: getAsUrl(group.website),
+      }),
+    } as Organization
+  }
+
+  getFiltersForOrgs(orgs: Organization[]): Observable<FieldFilters> {
+    return this.groups$.pipe(
+      map((allGroups) => {
+        const lang3 = LANG_2_TO_3_MAPPER[this.translateService.currentLang]
+        const groups = orgs.map((org) =>
+          allGroups.find((group) => group.label[lang3] === org.name)
+        )
+        return {
+          groupOwner: groups.reduce(
+            (prev, curr) => ({ ...prev, [curr.id.toString()]: true }),
+            {} as Record<string, boolean>
+          ),
+        }
+      })
+    )
+  }
+
+  getOrgsFromFilters(filters: FieldFilters): Observable<Organization[]> {
+    if (!('groupOwner' in filters)) return of([])
+    return forkJoin([this.groups$, this.organisations$]).pipe(
+      map(([groups, orgs]) => {
+        const groupIds = Object.keys(filters['groupOwner'])
+        const lang3 = LANG_2_TO_3_MAPPER[this.translateService.currentLang]
+        return groupIds.map((id) => {
+          const group = groups.find((group) => group.id.toString() === id)
+          return orgs.find((org) => org.name === group.label[lang3])
+        })
+      })
+    )
+  }
+
+  addOrganizationToRecordFromSource(
+    source: MetadataObject,
+    record: CatalogRecord
+  ): Observable<CatalogRecord> {
+    if (!('groupOwner' in source)) return of(record)
+
+    const groupId = parseInt(source.groupOwner as string)
+    return this.groups$.pipe(
+      map((groups) => {
+        const group = groups.find((g) => g.id === groupId)
+        if (!group) return record
+        const ownerOrganization = this.mapOrgFromGroup(group)
+        return {
+          ...record,
+          ownerOrganization,
+        }
+      })
+    )
+  }
+}

package/src/libs/api/repository/src/lib/gn4/organizations/organizations-from-metadata.service.ts

@@ -0,0 +1,319 @@
+import { Injectable } from '@angular/core'
+import {
+  GroupApiModel,
+  GroupsApiService,
+  SearchApiService,
+  SiteApiService,
+} from '../../../../../../../libs/data-access/gn4/src'
+import {
+  FieldFilterByValues,
+  FieldFilters,
+} from '../../../../../../../libs/common/domain/src/lib/search'
+import {
+  CatalogRecord,
+  Organization,
+} from '../../../../../../../libs/common/domain/src/lib/record'
+import { OrganizationsServiceInterface } from '../../../../../../../libs/common/domain/src/lib/organizations.service.interface'
+import { ElasticsearchService } from '../elasticsearch'
+import {
+  getAsArray,
+  getAsUrl,
+  mapOrganization,
+  MetadataObject,
+  selectFallback,
+  selectField,
+  selectTranslatedField,
+  SourceWithUnknownProps,
+} from '../../../../../../../libs/api/metadata-converter/src'
+import { combineLatest, Observable, of, switchMap, takeLast } from 'rxjs'
+import { filter, map, shareReplay, startWith, tap } from 'rxjs/operators'
+import { LangService } from '../../../../../../../libs/util/i18n/src'
+
+const IMAGE_URL = '/geonetwork/images/harvesting/'
+
+type ESBucket = {
+  key: string
+  doc_count: number
+}
+interface OrganizationAggsBucket extends ESBucket {
+  mail: {
+    buckets: ESBucket[]
+  }
+  logoUrl: {
+    buckets: ESBucket[]
+  }
+}
+interface IncompleteOrganization {
+  name: string
+  emails: string[]
+  recordCount: number
+}
+
+@Injectable()
+export class OrganizationsFromMetadataService
+  implements OrganizationsServiceInterface
+{
+  geonetworkVersion$ = of(true).pipe(
+    switchMap(() => this.siteApiService.getSiteOrPortalDescription()),
+    map((info) => info['system/platform/version']),
+    shareReplay(1)
+  )
+
+  private groups$: Observable<GroupApiModel[]> = of(true).pipe(
+    switchMap(() => this.groupsApiService.getGroups()),
+    shareReplay()
+  )
+  private organisationsAggs$: Observable<OrganizationAggsBucket[]> =
+    this.geonetworkVersion$.pipe(
+      switchMap((version) =>
+        this.searchApiService.search(
+          'bucket',
+          JSON.stringify(this.getAggregationSearchRequest(version))
+        )
+      ),
+      filter((response) => !!response.aggregations.contact.org),
+      tap((response) =>
+        response.aggregations.contact.org.buckets.forEach(
+          (r) =>
+            (r.doc_count =
+              response.aggregations.orgForResource.buckets.find(
+                (org) => org.key === r.key
+              )?.doc_count || r.doc_count)
+        )
+      ),
+      map((response) => response.aggregations.contact.org.buckets),
+      shareReplay()
+    )
+  private organisationsWithoutGroups$: Observable<IncompleteOrganization[]> =
+    this.organisationsAggs$.pipe(
+      map((buckets) =>
+        buckets.map((bucket) => {
+          const logoUrl = bucket.logoUrl.buckets?.[0]?.key
+          return {
+            name: bucket.key,
+            emails: bucket.mail.buckets
+              .map((bucket) => bucket.key)
+              .filter((mail) => !!mail),
+            recordCount: bucket.doc_count,
+            ...(logoUrl && { logoUrl: getAsUrl(logoUrl) }),
+          }
+        })
+      )
+    )
+  organisationsCount$ = this.organisationsAggs$.pipe(
+    map((organisations) => organisations.length)
+  )
+  organisations$ = combineLatest([
+    this.organisationsWithoutGroups$,
+    this.groups$.pipe(startWith(null)),
+  ]).pipe(
+    map(([organisations, groups]) => {
+      return !groups ? organisations : this.mapWithGroups(organisations, groups)
+    }),
+    shareReplay()
+  )
+
+  constructor(
+    private esService: ElasticsearchService,
+    private searchApiService: SearchApiService,
+    private groupsApiService: GroupsApiService,
+    private siteApiService: SiteApiService,
+    private langService: LangService
+  ) {}
+
+  private lang3 = this.langService.gnLang
+
+  equalsNormalizedStrings(
+    str1: string,
+    str2: string,
+    replaceSpecialChars = true
+  ): boolean {
+    if (!str1 || !str2) return false
+    return (
+      this.normalizeString(str1, replaceSpecialChars) ===
+      this.normalizeString(str2, replaceSpecialChars)
+    )
+  }
+
+  normalizeString(str: string, replaceSpecialChars = true): string {
+    function normalize(str: string) {
+      return str
+        .normalize('NFD') // decompose graphemes to remove accents from letters
+        .replace(/[\u0300-\u036f]/g, '') // remove accent characters
+        .toLowerCase()
+    }
+    if (replaceSpecialChars) {
+      return normalize(str).replace(/[^a-z0-9]/g, '') // replace all except letters & numbers
+    } else {
+      return normalize(str)
+    }
+  }
+
+  private getAggregationSearchRequest(gnVersion: string) {
+    return this.esService.getSearchRequestBody({
+      contact: {
+        nested: {
+          path: 'contactForResource',
+        },
+        aggs: {
+          org: {
+            terms: {
+              field: gnVersion.startsWith('4.2.2')
+                ? 'contactForResource.organisation'
+                : 'contactForResource.organisationObject.default.keyword',
+              exclude: '',
+              size: 5000,
+              order: { _key: 'asc' },
+            },
+            aggs: {
+              mail: {
+                terms: {
+                  size: 50,
+                  exclude: '',
+                  field:
+                    gnVersion.startsWith('4.2.2') ||
+                    gnVersion.startsWith('4.2.3') ||
+                    gnVersion.startsWith('4.2.4')
+                      ? 'contactForResource.email.keyword'
+                      : 'contactForResource.email',
+                },
+              },
+              logoUrl: {
+                terms: {
+                  size: 1,
+                  exclude: '',
+                  field: 'contactForResource.logo.keyword',
+                },
+              },
+            },
+          },
+        },
+      },
+      orgForResource: {
+        terms: {
+          size: 5000,
+          exclude: '',
+          field: gnVersion.startsWith('4.2.2')
+            ? 'OrgForResource'
+            : 'OrgForResourceObject.default',
+          order: {
+            _key: 'asc',
+          },
+        },
+      },
+    })
+  }
+
+  private mapWithGroups(
+    organisations: IncompleteOrganization[],
+    groups: GroupApiModel[]
+  ): Organization[] {
+    return organisations.map((organisation) => {
+      const group =
+        groups.find((group) =>
+          this.equalsNormalizedStrings(
+            group.label['eng'] ? group.label['eng'] : group.name,
+            organisation.name
+          )
+        ) ??
+        groups
+          .filter((group) => !!group.email)
+          .find((group) =>
+            organisation.emails
+              .map((mail) => this.normalizeString(mail, false))
+              .includes(this.normalizeString(group.email, false))
+          )
+      const { emails, ...fullOrg } = organisation
+      if (!group) return fullOrg
+      return {
+        ...fullOrg,
+        ...(group.description && { description: group.description }),
+        ...(group.logo && { logoUrl: getAsUrl(`${IMAGE_URL}${group.logo}`) }),
+        ...(group.website && { website: getAsUrl(group.website) }),
+      }
+    })
+  }
+
+  getFiltersForOrgs(organisations: Organization[]): Observable<FieldFilters> {
+    return this.geonetworkVersion$.pipe(
+      map((gnVersion) => {
+        const fieldName = gnVersion.startsWith('4.2.2')
+          ? 'OrgForResource'
+          : 'OrgForResourceObject.default'
+        return {
+          [fieldName]: organisations.reduce(
+            (prev, curr) => ({ ...prev, [curr.name]: true }),
+            {}
+          ),
+        }
+      })
+    )
+  }
+
+  getOrgsFromFilters(filters: FieldFilters): Observable<Organization[]> {
+    return this.geonetworkVersion$.pipe(
+      switchMap((gnVersion) => {
+        const fieldName = gnVersion.startsWith('4.2.2')
+          ? 'OrgForResource'
+          : 'OrgForResourceObject.default'
+
+        if (!(fieldName in filters)) return of([])
+
+        return this.organisations$.pipe(
+          map((orgs: IncompleteOrganization[]) => {
+            const orgNames = Object.keys(
+              filters[fieldName] as FieldFilterByValues
+            )
+            return orgNames.map((name) =>
+              orgs.find(
+                (org: Organization | IncompleteOrganization) =>
+                  org.name === name
+              )
+            )
+          })
+        )
+      })
+    )
+  }
+
+  addOrganizationToRecordFromSource(
+    source: MetadataObject,
+    record: CatalogRecord
+  ): Observable<CatalogRecord> {
+    const contacts: SourceWithUnknownProps[] = getAsArray(
+      selectFallback(
+        selectTranslatedField(source, 'contactObject', this.lang3),
+        selectField(source, 'contact')
+      )
+    )
+    const resourceContacts: SourceWithUnknownProps[] = getAsArray(
+      selectFallback(
+        selectTranslatedField(source, 'contactForResourceObject', this.lang3),
+        selectField(source, 'contactForResource')
+      )
+    )
+    const allContactOrgs = resourceContacts
+      .concat(contacts)
+      .map((contact) => mapOrganization(contact, this.lang3))
+
+    if (!allContactOrgs.length) return of(record)
+
+    const ownerOrganization = allContactOrgs[0]
+
+    return this.organisations$.pipe(
+      takeLast(1),
+      map((organisations: IncompleteOrganization[]) => {
+        const recordOrganisation = organisations.filter(
+          (org) => org.name === ownerOrganization.name
+        )[0]
+        return {
+          ...record,
+          ownerOrganization: {
+            ...ownerOrganization,
+            ...recordOrganisation,
+          },
+        }
+      })
+    )
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core'
+import { SiteApiService } from '../../../../../../../libs/data-access/gn4/src'
+import { map, shareReplay } from 'rxjs/operators'
+import { Observable } from 'rxjs'
+
+@Injectable({
+  providedIn: 'root',
+})
+export class Gn4SettingsService {
+  public identicon$: Observable<string> = this.getSettingsSetValueByKey(
+    'system/users/identicon'
+  )
+
+  constructor(private siteApiService: SiteApiService) {}
+
+  private getSettingsSetValueByKey(key: string) {
+    return this.siteApiService.getSettingsSet(null, [key]).pipe(
+      map((v) => v[key]),
+      shareReplay({ bufferSize: 1, refCount: true })
+    )
+  }
+}

package/src/libs/api/repository/src/lib/metadata-language.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core'
+
+export const METADATA_LANGUAGE = new InjectionToken<string>('metadata-language')

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

@@ -0,0 +1,14 @@
+import { Configuration } from '../../../../../libs/data-access/gn4/src'
+import { Provider } from '@angular/core'
+
+export function provideRepositoryUrl(
+  urlFactory: string | (() => string)
+): Provider {
+  return {
+    provide: Configuration,
+    useFactory: () =>
+      new Configuration({
+        basePath: typeof urlFactory === 'function' ? urlFactory() : urlFactory,
+      }),
+  }
+}

package/src/libs/common/domain/src/lib/dataviz-configuration.model.ts

@@ -0,0 +1,19 @@
+export type AggregationTypes = 'count' | 'sum' | 'min' | 'max' | 'average'
+
+export const CHART_TYPE_VALUES = [
+  'bar',
+  'bar-horizontal',
+  'line',
+  'line-interpolated',
+  'scatter',
+  'pie',
+] as const
+
+export type InputChartType = typeof CHART_TYPE_VALUES[number]
+
+export interface DatavizConfigurationModel {
+  xProperty: string
+  yProperty: string
+  aggregation: AggregationTypes
+  chartType: InputChartType
+}