ngx-edu-sharing-metaqs2 0.9.29 → 0.9.31

package/README.md

@@ -75,20 +75,30 @@ This library provides the following widgets:
 
 ### Metadatenvollständigkeit von Sammlungen
 [TreeCollectionDetailsComponent](./src/lib/tree-collection-details/tree-collection-details.component.ts)
-selector: `<app-tree-collection-details />`
+- selector: `<metaqs2-tree-collection-details />`
+- inputs: 
+    - `collectionId` (required) - the id of the collection to display
+
 ### Metadatenvollständigkeit von Quellen
 [QualityMatrixComponent](./src/lib/components/quality-matrix/quality_matrix.ts)
-selector: `<app-quality-matrix-v2 />`
-### Material in Sammlungen
+selector: `<metaqs2--quality-matrix-v2 />`
+### Sammlungsfüllstand
 [TreeSearchCountsComponent](./src/lib/tree-search-counts/tree-search-counts.component.ts)
-selector: `<app-tree-search-counts />`
+- selector: `<metaqs2-tree-search-counts />`
+- inputs: 
+    - `collectionId` (required) - the id of the collection to display
 ### Sammlungsverlauf
 Übersicht über die Anzahl der Materialien in Sammlungen über die Zeit.
 [CollectionCountHistoryComponent](./src/lib/collection-count-history/collection-count-history.component.ts)
 
 ### Counts with History
 [CountHistoryComponent](./src/lib/counts-with-history/counts-with-history.component.ts)
-selector: `<lib-counts-with-history />`.
+- selector: `<metaqs2-counts-with-history />`.
+- inputs:
+    - `apiMethod` (required) - the method to call on the MetaApiService
+    - `sourceType` (optional) - the type of the source ( 'replicationSource' | 'collection')
+    - `pageTitle` (optional) - translation key for the title
+    - `columnTranslationkey` (optional) - translation key for the columns
 
 This is a generic component that can be used to display counts with a history.
 It can be configered by providing the follwing data structure in it's routing configuration
@@ -101,6 +111,7 @@ or by providing it as an input to the component:
       pageTitle: 'pageTitle.content-type-count', // translation key for the title (if not provided or empty, the page header will not be displayed)
       apiMethod: 'getMaterialTypeCountsByReplicationSource', // the method to call on the MetaApiService (required)
       columnTranslationkey: 'issues.', // translation key for the columns (optional)
+      sourceType: 'replicationSource' // the type of the source ( 'replicationSource' | 'collection')e
   },
 }
 ```
@@ -110,7 +121,9 @@ Currently the following manifestations are implemented:
 {
   path: 'content-type-count',
   component: CountsWithHistoryComponent,
-  data: { pageTitle: 'pageTitle.content-type-count', apiMethod: 'getMaterialTypeCountsByReplicationSource' }
+  data: { pageTitle: 'pageTitle.content-type-count', 
+          apiMethod: 'getMaterialTypeCountsByReplicationSource',
+          sourceType: 'replicationSource' }
 }
 ```
 #### Lizenzarten nach Quellen
@@ -119,7 +132,9 @@ Currently the following manifestations are implemented:
 {
   path: 'license-count-sources',
   component: CountsWithHistoryComponent,
-  data: { pageTitle: 'pageTitle.license-count-sources', apiMethod: 'getLicenseCountsByReplicationSource' },
+  data: { pageTitle: 'pageTitle.license-count-sources', 
+          apiMethod: 'getLicenseCountsByReplicationSource',
+          sourceType: 'replicationSource' }
 },
 ```
 #### Lizenzarten nach Sammlungen
@@ -127,7 +142,9 @@ Currently the following manifestations are implemented:
 {
   path: 'license-count-collections',
   component: CountsWithHistoryComponent,
-  data: { pageTitle: 'pageTitle.license-count-collections', apiMethod: 'getMaterialCountMatrixByLicenseGroup' },
+  data: { pageTitle: 'pageTitle.license-count-collections', 
+          apiMethod: 'getMaterialCountMatrixByLicenseGroup',
+          sourceType: 'collection' }
 }
 ```
 ####  Quellen und ihre Qualitätsprobleme
@@ -137,7 +154,8 @@ Currently the following manifestations are implemented:
     component: CountsWithHistoryComponent,
     data: {
         pageTitle: 'pageTitle.issues-replicationsources',
-        apiMethod: 'getCompletenessForReplicationSources',
+        apiMethod: 'getCompletenessForReplicationSources', 
+        sourceType: 'replicationSource',
         columnTranslationkey: 'issues.'},
 },
 ```
@@ -149,6 +167,7 @@ Currently the following manifestations are implemented:
   data: {
     title: 'pageTitle.issues-collections',
     apiMethod: 'getCompletenessForDisciplinaryPortals',
+    sourceType: 'collection',  
     columnTranslationkey: 'issues.',
   }
 },

package/esm2022/lib/collection-count-history/collection-count-history.component.mjs

@@ -110,7 +110,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 type: ViewChild,
                 args: [BaseChartDirective]
             }], pageTitle: [{
-                type: Input,
-                args: [{ required: true }]
+                type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-count-history.component.js","sourceRoot":"","sources":["../../../../../projects/ng-meta-widgets-lib/src/lib/collection-count-history/collection-count-history.component.ts","../../../../../projects/ng-meta-widgets-lib/src/lib/collection-count-history/collection-count-history.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, DestroyRef, Input, OnInit, signal, ViewChild } from '@angular/core';\nimport { ChartConfiguration, ChartDataset } from 'chart.js';\nimport { BaseChartDirective } from 'ng2-charts';\nimport { DateTime, DateTimeUnit } from 'luxon';\nimport { MatCard, MatCardContent, MatCardHeader, MatCardTitle } from '@angular/material/card';\nimport { FormControl, FormGroup, ReactiveFormsModule } from '@angular/forms';\n\nimport { MonthpickerComponent } from './monthpicker/monthpicker.component';\nimport { Count } from '../java-api';\nimport { MetaApiService } from '../meta-api.service';\nimport { BehaviorSubject } from 'rxjs';\nimport { AsyncPipe, NgClass, NgIf } from '@angular/common';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { distinctUntilChanged, finalize, take } from 'rxjs/operators';\nimport { MaterialCountFilter } from '../java-api';\n\n@Component({\n  selector: 'metaqs2-collection-count-history',\n  standalone: true,\n  imports: [\n    BaseChartDirective,\n    MonthpickerComponent,\n    MatCard,\n    MatCardHeader,\n    MatCardTitle,\n    MatCardContent,\n    AsyncPipe,\n    ReactiveFormsModule,\n    NgClass,\n    NgIf,\n  ],\n  templateUrl: './collection-count-history.component.html',\n  styleUrl: './collection-count-history.component.scss',\n})\nexport class CollectionCountHistoryComponent implements OnInit {\n  @ViewChild(BaseChartDirective) chart?: BaseChartDirective;\n  protected lineChartOptions: ChartConfiguration['options'] = {\n    parsing: {\n      xAxisKey: 'date',\n      yAxisKey: 'count',\n    },\n    font: {\n      family: 'Montserrat',\n    },\n    animation: false,\n  };\n  protected datapoints$ = new BehaviorSubject<ChartDataset<'line', Count[]>[]>([]);\n  protected isLoading = signal(true);\n  readonly range: FormGroup<{\n    start: FormControl<DateTime<boolean>>;\n    end: FormControl<DateTime<boolean>>;\n  }> = new FormGroup({\n    start: new FormControl(),\n    end: new FormControl(),\n  });\n  protected granularities: DateTimeUnit[] = ['year', 'month', 'week', 'day'];\n  protected granularity = new FormControl<DateTimeUnit>('month', { nonNullable: true });\n\n  @Input({ required: true })\n  protected pageTitle: string;\n  constructor(private readonly metaApi: MetaApiService, private readonly destroyRef: DestroyRef) {}\n\n  ngOnInit(): void {\n    this.registerDateRangeFilter();\n  }\n\n  registerDateRangeFilter() {\n    this.range.valueChanges\n      .pipe(\n        takeUntilDestroyed(this.destroyRef),\n        //the Material Datepicker emits the initial values 4 times when it starts, so we need to distinct them\n        distinctUntilChanged((prev, curr) => {\n          return prev.start === curr.start && prev.end === curr.end;\n        })\n      )\n      .subscribe(() => {\n        this.loadData();\n      });\n    this.metaApi\n      .getTimerangeFilter()\n      .pipe(take(1))\n      .subscribe((rangeFilter) => {\n        if (rangeFilter) {\n          const startDate = DateTime.fromISO(rangeFilter.values.find((v) => v.id === 'rangeStart')?.label!, {\n            zone: 'utc',\n          }).startOf(this.granularity.value);\n          const endDate = DateTime.fromISO(rangeFilter.values.find((v) => v.id === 'rangeEnd')?.label!, {\n            zone: 'utc',\n          }).endOf(this.granularity.value);\n          this.range.setControl('start', new FormControl<DateTime>(startDate, { nonNullable: true }), {\n            emitEvent: false,\n          });\n          this.range.setControl('end', new FormControl<DateTime>(endDate, { nonNullable: true }), { emitEvent: false });\n        }\n      });\n  }\n\n  private loadData(): void {\n    this.isLoading.set(true);\n\n    const request: MaterialCountFilter = {\n      startDate: this.range.value.start?.toISO()!,\n      endDate: this.range.value.end?.toISO()!,\n      granularity: this.granularity.value,\n    };\n\n    this.metaApi\n      .getEditorialMaterialCounts(request)\n      .pipe(\n        take(1),\n        finalize(() => this.isLoading.set(false))\n      )\n      .subscribe((response) => {\n        const datapoints = response.map((data) => {\n          return {\n            data: data.counts.map((count) => {\n              return {\n                date: DateTime.fromISO(count.date).toFormat('LLLL yyyy')!,\n                count: count.count,\n              };\n            }),\n            label: data.name,\n          };\n        });\n        this.datapoints$.next(datapoints);\n      });\n  }\n}\n","<mat-card appearance=\"outlined\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title>\n      {{ pageTitle }}{{ isLoading() ? \": Lade neue Daten.\" : \"\" }}\n    </mat-card-title>\n  </mat-card-header>\n  <mat-card-content>\n\n    <metaqs2-monthpicker\n      [inputGroup]=\"range\"></metaqs2-monthpicker>\n\n    <div [ngClass]=\"{'while-loading': isLoading()}\">\n      <canvas\n        baseChart\n        [datasets]=\"(datapoints$ | async) || []\"\n        [options]=\"lineChartOptions\"\n        [type]=\"'line'\"\n      ></canvas>\n    </div>\n  </mat-card-content>\n</mat-card>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-count-history.component.js","sourceRoot":"","sources":["../../../../../projects/ng-meta-widgets-lib/src/lib/collection-count-history/collection-count-history.component.ts","../../../../../projects/ng-meta-widgets-lib/src/lib/collection-count-history/collection-count-history.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, DestroyRef, Input, OnInit, signal, ViewChild } from '@angular/core';\nimport { ChartConfiguration, ChartDataset } from 'chart.js';\nimport { BaseChartDirective } from 'ng2-charts';\nimport { DateTime, DateTimeUnit } from 'luxon';\nimport { MatCard, MatCardContent, MatCardHeader, MatCardTitle } from '@angular/material/card';\nimport { FormControl, FormGroup, ReactiveFormsModule } from '@angular/forms';\n\nimport { MonthpickerComponent } from './monthpicker/monthpicker.component';\nimport { Count } from '../java-api';\nimport { MetaApiService } from '../meta-api.service';\nimport { BehaviorSubject } from 'rxjs';\nimport { AsyncPipe, NgClass, NgIf } from '@angular/common';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { distinctUntilChanged, finalize, take } from 'rxjs/operators';\nimport { MaterialCountFilter } from '../java-api';\n\n@Component({\n  selector: 'metaqs2-collection-count-history',\n  standalone: true,\n  imports: [\n    BaseChartDirective,\n    MonthpickerComponent,\n    MatCard,\n    MatCardHeader,\n    MatCardTitle,\n    MatCardContent,\n    AsyncPipe,\n    ReactiveFormsModule,\n    NgClass,\n    NgIf,\n  ],\n  templateUrl: './collection-count-history.component.html',\n  styleUrl: './collection-count-history.component.scss',\n})\nexport class CollectionCountHistoryComponent implements OnInit {\n  @ViewChild(BaseChartDirective) chart?: BaseChartDirective;\n  protected lineChartOptions: ChartConfiguration['options'] = {\n    parsing: {\n      xAxisKey: 'date',\n      yAxisKey: 'count',\n    },\n    font: {\n      family: 'Montserrat',\n    },\n    animation: false,\n  };\n  protected datapoints$ = new BehaviorSubject<ChartDataset<'line', Count[]>[]>([]);\n  protected isLoading = signal(true);\n  readonly range: FormGroup<{\n    start: FormControl<DateTime<boolean>>;\n    end: FormControl<DateTime<boolean>>;\n  }> = new FormGroup({\n    start: new FormControl(),\n    end: new FormControl(),\n  });\n  protected granularities: DateTimeUnit[] = ['year', 'month', 'week', 'day'];\n  protected granularity = new FormControl<DateTimeUnit>('month', { nonNullable: true });\n\n  @Input()\n  pageTitle: string;\n  constructor(private readonly metaApi: MetaApiService, private readonly destroyRef: DestroyRef) {}\n\n  ngOnInit(): void {\n    this.registerDateRangeFilter();\n  }\n\n  registerDateRangeFilter() {\n    this.range.valueChanges\n      .pipe(\n        takeUntilDestroyed(this.destroyRef),\n        //the Material Datepicker emits the initial values 4 times when it starts, so we need to distinct them\n        distinctUntilChanged((prev, curr) => {\n          return prev.start === curr.start && prev.end === curr.end;\n        })\n      )\n      .subscribe(() => {\n        this.loadData();\n      });\n    this.metaApi\n      .getTimerangeFilter()\n      .pipe(take(1))\n      .subscribe((rangeFilter) => {\n        if (rangeFilter) {\n          const startDate = DateTime.fromISO(rangeFilter.values.find((v) => v.id === 'rangeStart')?.label!, {\n            zone: 'utc',\n          }).startOf(this.granularity.value);\n          const endDate = DateTime.fromISO(rangeFilter.values.find((v) => v.id === 'rangeEnd')?.label!, {\n            zone: 'utc',\n          }).endOf(this.granularity.value);\n          this.range.setControl('start', new FormControl<DateTime>(startDate, { nonNullable: true }), {\n            emitEvent: false,\n          });\n          this.range.setControl('end', new FormControl<DateTime>(endDate, { nonNullable: true }), { emitEvent: false });\n        }\n      });\n  }\n\n  private loadData(): void {\n    this.isLoading.set(true);\n\n    const request: MaterialCountFilter = {\n      startDate: this.range.value.start?.toISO()!,\n      endDate: this.range.value.end?.toISO()!,\n      granularity: this.granularity.value,\n    };\n\n    this.metaApi\n      .getEditorialMaterialCounts(request)\n      .pipe(\n        take(1),\n        finalize(() => this.isLoading.set(false))\n      )\n      .subscribe((response) => {\n        const datapoints = response.map((data) => {\n          return {\n            data: data.counts.map((count) => {\n              return {\n                date: DateTime.fromISO(count.date).toFormat('LLLL yyyy')!,\n                count: count.count,\n              };\n            }),\n            label: data.name,\n          };\n        });\n        this.datapoints$.next(datapoints);\n      });\n  }\n}\n","<mat-card appearance=\"outlined\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title>\n      {{ pageTitle }}{{ isLoading() ? \": Lade neue Daten.\" : \"\" }}\n    </mat-card-title>\n  </mat-card-header>\n  <mat-card-content>\n\n    <metaqs2-monthpicker\n      [inputGroup]=\"range\"></metaqs2-monthpicker>\n\n    <div [ngClass]=\"{'while-loading': isLoading()}\">\n      <canvas\n        baseChart\n        [datasets]=\"(datapoints$ | async) || []\"\n        [options]=\"lineChartOptions\"\n        [type]=\"'line'\"\n      ></canvas>\n    </div>\n  </mat-card-content>\n</mat-card>"]}

package/esm2022/lib/components/editorial-link-service/editorial-link.service.mjs

@@ -1,41 +1,89 @@
 import { Injectable } from '@angular/core';
 import { inject } from '@angular/core';
 import { ConfigHelperService } from '../../config-helper.service';
+import { MetaApiService } from '../../meta-api.service';
+import { BehaviorSubject } from 'rxjs';
+import { take } from 'rxjs/operators';
 import * as i0 from "@angular/core";
+/**
+ * This service provides methods to create links to the editorial desk with specific filters.
+ */
+/*  This map makes it easier for me to keep track which issues are mapped to which filters */
+const FilterNames2Issues = {
+    //Lizenzen
+    'virtual:editorial_license': ['oer', 'other_cc', 'copyright', 'without_license'],
+    //Materialtypen werden im Constructor gesetzt
+    'virtual:oeh_lrt': [],
+    'virtual:editorial_exclusion': [
+        'outdated',
+        'without_preview',
+        'without_title',
+        'without_description',
+        'without_url',
+        'without_type',
+        'without_taxonomy_id',
+        'without_education_level',
+        'without_target_group',
+        'without_license',
+        'without_publisher',
+    ],
+};
+// Here we map back the issues to the filter names in the editorial desk, so we can look up the filter name for a given issue
+const Issues2FilterNames = Object.entries(FilterNames2Issues).reduce((map, [key, value]) => {
+    value.forEach((issue) => map.set(issue, key));
+    return map;
+}, new Map());
+// maps our values to the values of the filter in the editorial desk
+const MapValuesForFilter = {
+    'virtual:editorial_exclusion': {
+        outdated: null,
+        without_preview: null,
+        without_title: ['missing_title'],
+        without_description: ['missing_description'],
+        without_url: ['links'],
+        without_type: ['missing_oeh_lrt'],
+        without_taxonomy_id: ['without_taxonomy_id'],
+        without_education_level: ['missing_educationalcontext'],
+        without_target_group: ['missing_educationalintendedenduserrole'],
+        without_license: ['missing_license'],
+        without_publisher: ['missing_replicationsource'],
+    },
+    'virtual:editorial_license': {
+        oer: ['oer'],
+        copyright: ['none_oer'],
+        without_license: ['none'],
+    },
+    'virtual:oeh_lrt': {},
+};
 /*
 This is a map from properties of a document to filter names
  */
 const PROPERTIES2FILTERS = new Map([
     ['metadata.educationalContexts', 'ccm:educationalcontext'],
     ['metadata.disciplines', 'virtual:taxonid'],
-    ['collections.nodeRef.id.keyword', 'virtual:collection_id_primary'],
     //["responsibility", "virtual:collection_id_primary"] // das zeigt auf "sammlungszugehörigkeit" und ist falsch
 ]);
-/*
-This map our column "names" to the valid values of the virtual:editorial_exclusion Filter
-*/
-const ISSUETYPE2FILTERS = new Map([
-    ['without_title', 'missing_title'],
-    ['without_description', 'missing_description'],
-    ['without_education_level', 'missing_educationalcontext'],
-    ['without_target_group', 'missing_educationalintendedenduserrole'],
-    ['without_taxonomy_id', 'missing_taxonid'],
-    ['without_category', 'missing_oeh_lrt'],
-    ['without_license', 'missing_license'],
-]);
-/*
-interestingly it is not necessary to combine the nodeRef.id
-with https://vocabs.openeduhub.de/w3id.org/openeduhub/vocabs/oeh-topics/{nodeRef.id}
- */
 export class EditorialLinkService {
     constructor() {
         this.env = inject(ConfigHelperService);
+        this.api = inject(MetaApiService);
+        this.typesLoaded$ = new BehaviorSubject(false);
+        this.api
+            .getMaterialTypesMapping()
+            .pipe(take(1))
+            .subscribe((types) => {
+            for (const [key, value] of Object.entries(types)) {
+                Issues2FilterNames.set(key, 'virtual:oeh_lrt');
+                MapValuesForFilter['virtual:oeh_lrt'][key] = value;
+            }
+            this.typesLoaded$.next(true);
+        });
     }
     openByReplicationsourceAndIssueTypeWithFilters(source, issue, selectedFilters) {
         const filters = {};
         filters['virtual:audit_filter'] = ['all'];
         filters['ccm:oeh_publisher_combined'] = [source];
-        filters['virtual:editorial_exclusion'] = [ISSUETYPE2FILTERS.get(issue)];
+        filters['virtual:editorial_exclusion'] = MapValuesForFilter['virtual:editorial_exclusion'][issue];
         for (const [field, values] of Object.entries(selectedFilters)) {
             if (values && values.length) {
                 const editorialFiltername = PROPERTIES2FILTERS.get(field);
@@ -51,7 +99,7 @@ export class EditorialLinkService {
     openByCollectionAndIssueType(collectionId, issueType, pageTitle) {
         const filters = {};
         filters['virtual:audit_filter'] = ['all'];
-        filters['virtual:editorial_exclusion'] = [ISSUETYPE2FILTERS.get(issueType)];
+        filters['virtual:editorial_exclusion'] = MapValuesForFilter['virtual:editorial_exclusion'][issueType];
         filters['virtual:collection_id_primary'] = [collectionId];
         const theUrl = this.env.eduSharingPath + '/components/editorial-desk';
         const params = new URLSearchParams();
@@ -67,6 +115,46 @@ export class EditorialLinkService {
         params.set('mode', 'render');
         window.open(`${theUrl}?${params}`, 'editor_frontend');
     }
+    /**
+     * This method creates a link to the editorial desk with specific filters.
+     * It returns the URL to the editorial desk with the filters applied or null if the issueId is not mapped to a filter.
+     * With this we can render a link with an href attribute to the editorial desk in the frontend.
+     * @see the counts-with-history.component.scss how we style links only if their hrefs are not null
+     *
+     * @param sourceType The type of the source, e.g. "replicationSource" or "collection"
+     * @param sourceId The id of the source. This is the first column in the table.
+     * @param issueId The id of the issue. These are the other columns in the table.
+     */
+    createLinkForCountsWithHistory(sourceType, sourceId, issueId) {
+        const filters = {};
+        filters['virtual:audit_filter'] = ['all'];
+        // determine the "main" filter
+        if (sourceType === 'replicationSource') {
+            filters['ccm:oeh_publisher_combined'] = [sourceId];
+        }
+        else if (sourceType === 'collection') {
+            filters['virtual:collection_id_primary'] = [sourceId];
+        }
+        if (!Issues2FilterNames.has(issueId)) {
+            return null;
+        }
+        const filterName = Issues2FilterNames.get(issueId);
+        if (!filterName) {
+            // console.debug("No filter name found for issue id: " + issueId);
+            return null;
+        }
+        const filterValue = MapValuesForFilter[filterName][issueId];
+        if (!filterValue) {
+            // console.debug("No filter value found for issue id: " + issueId);
+            return null;
+        }
+        filters[filterName] = filterValue;
+        const theUrl = this.env.eduSharingPath + '/components/editorial-desk';
+        const params = new URLSearchParams();
+        params.set('mode', 'audit');
+        params.set('filters', JSON.stringify(filters));
+        return `${theUrl}?${params}`;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EditorialLinkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EditorialLinkService, providedIn: 'root' }); }
 }
@@ -76,4 +164,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editorial-link.service.js","sourceRoot":"","sources":["../../../../../../projects/ng-meta-widgets-lib/src/lib/components/editorial-link-service/editorial-link.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { inject } from '@angular/core';\nimport { ConfigHelperService } from '../../config-helper.service';\n\n/*\nThis is a map from properties of a document to filter names\n */\nconst PROPERTIES2FILTERS = new Map<string, string>([\n  ['metadata.educationalContexts', 'ccm:educationalcontext'],\n  ['metadata.disciplines', 'virtual:taxonid'],\n  ['collections.nodeRef.id.keyword', 'virtual:collection_id_primary'],\n  //[\"responsibility\", \"virtual:collection_id_primary\"] // das zeigt auf \"sammlungszugehörigkeit\" und ist falsch\n]);\n/*\nThis map our column \"names\" to the valid values of the virtual:editorial_exclusion Filter\n*/\n\nconst ISSUETYPE2FILTERS: Map<string, string> = new Map<string, string>([\n  ['without_title', 'missing_title'],\n  ['without_description', 'missing_description'],\n  ['without_education_level', 'missing_educationalcontext'],\n  ['without_target_group', 'missing_educationalintendedenduserrole'],\n  ['without_taxonomy_id', 'missing_taxonid'],\n  ['without_category', 'missing_oeh_lrt'],\n  ['without_license', 'missing_license'],\n]);\n/*\ninterestingly it is not necessary to combine the nodeRef.id\nwith https://vocabs.openeduhub.de/w3id.org/openeduhub/vocabs/oeh-topics/{nodeRef.id}\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class EditorialLinkService {\n  private env = inject(ConfigHelperService);\n\n  constructor() {}\n\n  public openByReplicationsourceAndIssueTypeWithFilters(\n    source: string,\n    issue: string,\n    selectedFilters: { [key: string]: string[] | undefined }\n  ): void {\n    const filters: any = {};\n    filters['virtual:audit_filter'] = ['all'];\n    filters['ccm:oeh_publisher_combined'] = [source];\n    filters['virtual:editorial_exclusion'] = [ISSUETYPE2FILTERS.get(issue)];\n    for (const [field, values] of Object.entries(selectedFilters)) {\n      if (values && values.length) {\n        const editorialFiltername = PROPERTIES2FILTERS.get(field) as string;\n        filters[editorialFiltername] = values;\n      }\n    }\n\n    const theUrl: string = this.env.eduSharingPath + '/components/editorial-desk';\n    const params = new URLSearchParams();\n    params.set('mode', 'audit');\n    params.set('filters', JSON.stringify(filters));\n    window.open(`${theUrl}?${params}`, 'editor_frontend');\n  }\n  public openByCollectionAndIssueType(collectionId: string, issueType: string, pageTitle: string): void {\n    const filters: any = {};\n    filters['virtual:audit_filter'] = ['all'];\n    filters['virtual:editorial_exclusion'] = [ISSUETYPE2FILTERS.get(issueType)];\n    filters['virtual:collection_id_primary'] = [collectionId];\n    const theUrl: string = this.env.eduSharingPath + '/components/editorial-desk';\n    const params = new URLSearchParams();\n    params.set('title', pageTitle);\n    params.set('mode', 'audit');\n    params.set('filters', JSON.stringify(filters));\n    window.open(`${theUrl}?${params}`, 'editor_frontend');\n  }\n\n  public openByCollectionId(collectionId: string): void {\n    const theUrl: string = this.env.eduSharingPath + '/components/editorial-desk';\n    const params = new URLSearchParams();\n    params.set('ids', collectionId);\n    params.set('mode', 'render');\n    window.open(`${theUrl}?${params}`, 'editor_frontend');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editorial-link.service.js","sourceRoot":"","sources":["../../../../../../projects/ng-meta-widgets-lib/src/lib/components/editorial-link-service/editorial-link.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { inject } from '@angular/core';\nimport { ConfigHelperService } from '../../config-helper.service';\nimport { MetaApiService } from '../../meta-api.service';\nimport { BehaviorSubject } from 'rxjs';\nimport { take } from 'rxjs/operators';\n\n/**\n * This service provides methods to create links to the editorial desk with specific filters.\n */\n/*  This map makes it easier for me to keep track which issues are mapped to which filters */\nconst FilterNames2Issues: { [key: string]: string[] } = {\n  //Lizenzen\n  'virtual:editorial_license': ['oer', 'other_cc', 'copyright', 'without_license'],\n  //Materialtypen werden im Constructor gesetzt\n  'virtual:oeh_lrt': [],\n  'virtual:editorial_exclusion': [\n    'outdated',\n    'without_preview',\n    'without_title',\n    'without_description',\n    'without_url',\n    'without_type',\n    'without_taxonomy_id',\n    'without_education_level',\n    'without_target_group',\n    'without_license',\n    'without_publisher',\n  ],\n};\n// Here we map back the issues to the filter names in the editorial desk, so we can look up the filter name for a given issue\nconst Issues2FilterNames: Map<string, string> = Object.entries(FilterNames2Issues).reduce((map, [key, value]) => {\n  value.forEach((issue) => map.set(issue, key));\n  return map;\n}, new Map<string, string>());\n\n// maps our values to the values of the filter in the editorial desk\nconst MapValuesForFilter: { [key: string]: { [key: string]: string[] | null } } = {\n  'virtual:editorial_exclusion': {\n    outdated: null,\n    without_preview: null,\n    without_title: ['missing_title'],\n    without_description: ['missing_description'],\n    without_url: ['links'],\n    without_type: ['missing_oeh_lrt'],\n    without_taxonomy_id: ['without_taxonomy_id'],\n    without_education_level: ['missing_educationalcontext'],\n    without_target_group: ['missing_educationalintendedenduserrole'],\n    without_license: ['missing_license'],\n    without_publisher: ['missing_replicationsource'],\n  },\n  'virtual:editorial_license': {\n    oer: ['oer'],\n    copyright: ['none_oer'],\n    without_license: ['none'],\n  },\n  'virtual:oeh_lrt': {},\n};\n\n/*\nThis is a map from properties of a document to filter names\n */\nconst PROPERTIES2FILTERS = new Map<string, string>([\n  ['metadata.educationalContexts', 'ccm:educationalcontext'],\n  ['metadata.disciplines', 'virtual:taxonid'],\n  //[\"responsibility\", \"virtual:collection_id_primary\"] // das zeigt auf \"sammlungszugehörigkeit\" und ist falsch\n]);\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class EditorialLinkService {\n  private env = inject(ConfigHelperService);\n  private api = inject(MetaApiService);\n  public typesLoaded$ = new BehaviorSubject(false);\n\n  constructor() {\n    this.api\n      .getMaterialTypesMapping()\n      .pipe(take(1))\n      .subscribe((types) => {\n        for (const [key, value] of Object.entries(types)) {\n          Issues2FilterNames.set(key, 'virtual:oeh_lrt');\n          MapValuesForFilter['virtual:oeh_lrt'][key] = value;\n        }\n        this.typesLoaded$.next(true);\n      });\n  }\n\n  public openByReplicationsourceAndIssueTypeWithFilters(\n    source: string,\n    issue: string,\n    selectedFilters: { [key: string]: string[] | undefined }\n  ): void {\n    const filters: any = {};\n    filters['virtual:audit_filter'] = ['all'];\n    filters['ccm:oeh_publisher_combined'] = [source];\n    filters['virtual:editorial_exclusion'] = MapValuesForFilter['virtual:editorial_exclusion'][issue];\n    for (const [field, values] of Object.entries(selectedFilters)) {\n      if (values && values.length) {\n        const editorialFiltername = PROPERTIES2FILTERS.get(field) as string;\n        filters[editorialFiltername] = values;\n      }\n    }\n\n    const theUrl: string = this.env.eduSharingPath + '/components/editorial-desk';\n    const params = new URLSearchParams();\n    params.set('mode', 'audit');\n    params.set('filters', JSON.stringify(filters));\n    window.open(`${theUrl}?${params}`, 'editor_frontend');\n  }\n\n  public openByCollectionAndIssueType(collectionId: string, issueType: string, pageTitle: string): void {\n    const filters: any = {};\n    filters['virtual:audit_filter'] = ['all'];\n    filters['virtual:editorial_exclusion'] = MapValuesForFilter['virtual:editorial_exclusion'][issueType];\n    filters['virtual:collection_id_primary'] = [collectionId];\n    const theUrl: string = this.env.eduSharingPath + '/components/editorial-desk';\n    const params = new URLSearchParams();\n    params.set('title', pageTitle);\n    params.set('mode', 'audit');\n    params.set('filters', JSON.stringify(filters));\n    window.open(`${theUrl}?${params}`, 'editor_frontend');\n  }\n\n  public openByCollectionId(collectionId: string): void {\n    const theUrl: string = this.env.eduSharingPath + '/components/editorial-desk';\n    const params = new URLSearchParams();\n    params.set('ids', collectionId);\n    params.set('mode', 'render');\n    window.open(`${theUrl}?${params}`, 'editor_frontend');\n  }\n\n  /**\n   * This method creates a link to the editorial desk with specific filters.\n   * It returns the URL to the editorial desk with the filters applied or null if the issueId is not mapped to a filter.\n   * With this we can render a link with an href attribute to the editorial desk in the frontend.\n   * @see the counts-with-history.component.scss how we style links only if their hrefs are not null\n   *\n   * @param sourceType The type of the source, e.g. \"replicationSource\" or \"collection\"\n   * @param sourceId The id of the source. This is the first column in the table.\n   * @param issueId The id of the issue. These are the other columns in the table.\n   */\n  public createLinkForCountsWithHistory(sourceType: string, sourceId: string, issueId: string): string | null {\n    const filters: { [key: string]: string[] } = {};\n    filters['virtual:audit_filter'] = ['all'];\n    // determine the \"main\" filter\n    if (sourceType === 'replicationSource') {\n      filters['ccm:oeh_publisher_combined'] = [sourceId];\n    } else if (sourceType === 'collection') {\n      filters['virtual:collection_id_primary'] = [sourceId];\n    }\n    if (!Issues2FilterNames.has(issueId)) {\n      return null;\n    }\n    const filterName = Issues2FilterNames.get(issueId);\n    if (!filterName) {\n      // console.debug(\"No filter name found for issue id: \" + issueId);\n      return null;\n    }\n    const filterValue = MapValuesForFilter[filterName][issueId];\n    if (!filterValue) {\n      // console.debug(\"No filter value found for issue id: \" + issueId);\n      return null;\n    }\n    filters[filterName] = filterValue;\n\n    const theUrl: string = this.env.eduSharingPath + '/components/editorial-desk';\n    const params = new URLSearchParams();\n    params.set('mode', 'audit');\n    params.set('filters', JSON.stringify(filters));\n    return `${theUrl}?${params}`;\n  }\n}\n"]}

package/esm2022/lib/counts-with-history/counts-with-history.component.mjs

@@ -6,18 +6,20 @@ import { BehaviorSubject, Subject } from 'rxjs';
 import { TranslateModule } from '@ngx-translate/core';
 import { AsyncPipe, NgClass, NgForOf, NgIf } from '@angular/common';
 import { DateTime } from 'luxon';
-import { finalize, map, takeUntil, tap } from 'rxjs/operators';
+import { finalize, map, skipWhile, take, takeUntil, tap } from 'rxjs/operators';
 import { FormControl, FormGroup } from '@angular/forms';
 import { DatepickerComponent } from '../components/filter/datepicker/datepicker.component';
 import { MatIcon } from '@angular/material/icon';
 import * as i0 from "@angular/core";
 import * as i1 from "../meta-api.service";
-import * as i2 from "@angular/material/card";
-import * as i3 from "@angular/material/table";
-import * as i4 from "@ngx-translate/core";
+import * as i2 from "../components/editorial-link-service/editorial-link.service";
+import * as i3 from "@angular/material/card";
+import * as i4 from "@angular/material/table";
+import * as i5 from "@ngx-translate/core";
 export class CountsWithHistoryComponent {
-    constructor(metaApi) {
+    constructor(metaApi, linkService) {
         this.metaApi = metaApi;
+        this.linkService = linkService;
         this.isLoading = signal(true);
         this.timeFilterLoaded = signal(false);
         this.destroyed$ = new Subject();
@@ -115,6 +117,15 @@ export class CountsWithHistoryComponent {
         const trend = delta === 0 ? 'trending_flat' : delta < 0 ? 'trending_down' : 'trending_up';
         return { delta, trend, value: pastValue };
     }
+    openInEditor(sourceId, issueId) {
+        if (this.sourceType === 'replicationSource') {
+            // find the long name for the source
+            sourceId = this.recentTypeCount$.value.rows.find((r) => r.meta.id === sourceId)?.meta.label || sourceId;
+        }
+        return this.linkService.typesLoaded$.pipe(skipWhile((loaded) => !loaded), take(1), map(() => {
+            return this.linkService.createLinkForCountsWithHistory(this.sourceType, sourceId, issueId);
+        }));
+    }
     ngOnInit() {
         this.getTimeRangeFilter();
         this.getCountByDate(this.range.controls.end.value)
@@ -129,8 +140,8 @@ export class CountsWithHistoryComponent {
         this.destroyed$.next();
         this.destroyed$.complete();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CountsWithHistoryComponent, deps: [{ token: i1.MetaApiService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CountsWithHistoryComponent, isStandalone: true, selector: "metaqs2-counts-with-history", inputs: { apiMethod: "apiMethod", columnTranslationkey: "columnTranslationkey", pageTitle: "pageTitle" }, ngImport: i0, template: "<mat-card appearance=\"raised\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title data-test-id=\"page-title\">\n      Qualit\u00E4tsmetrik: {{ pageTitle | translate}}{{isLoading() ? \": Lade neue Daten.\" : \"\"}}\n    </mat-card-title>\n  </mat-card-header>\n  <!-- consider to put the filter in the table header to avoid that it is scrolled out of view-->\n  <!-- show the filter after the values are loaded to avoid loading current data twice -->\n  <mat-card-content *ngIf=\"timeFilterLoaded()\">\n    <metaqs2-datepicker [disabled]=\"isLoading()\" [inputGroup]=\"range\" ></metaqs2-datepicker>\n  </mat-card-content>\n</mat-card>\n<mat-card>\n  <table [ngClass]=\"{'while-loading': isLoading()}\" mat-table [dataSource]=\"recentTypeCount$.value.rows\" class=\"quality-matrix\">\n    <!-- Define columns of table -->\n    <!-- Row Header Column -->\n    <ng-container matColumnDef=\"label-col\" sticky>\n      <th rowspan=\"2\" mat-header-cell *matHeaderCellDef>Quelle</th>\n      <td\n        mat-cell\n        *matCellDef=\"let row\"\n        matTooltip=\"{{row.meta.alt_label}}\"\n        class=\"label-col\"\n      >\n        {{row.meta.label}}\n      </td>\n    </ng-container>\n    <!-- one column for each type -->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_type'\">\n      <th colspan=\"2\" mat-header-cell *matHeaderCellDef matTooltip=\"{{col.label}}\" >\n        {{columnTranslationkey ? (columnTranslationkey + col.label | translate ) : col.label }}\n      </th>\n    </ng-container>\n    <!-- one column for each type for the most current date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_recent'\">\n      <th class=\"recent-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >{{ range.controls.end.value.toLocaleString(DateTime.DATE_SHORT) }}</th>\n      <td class=\"recent-data-cell\" mat-cell *matCellDef=\"let row\">{{ row.counts[col.id] ?? 'n/a' }}</td>\n    </ng-container>\n    <!-- one column for each type for the older date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_past'\">\n      <th class=\"past-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >\n        {{ pastTypeCount$.value.rows.length ? range.controls.start.value.toLocaleString(DateTime.DATE_SHORT) : 'no past data' }}\n      </th>\n      <td class=\"past-data-cell\" mat-cell *matCellDef=\"let row;\">\n        <ng-container *ngIf=\"pastTypeCount$.value.rows.length && pastTypeCount(row, col.id) as trend\">\n          <span [ngClass]=\"trend.trend\"> {{ trend.value ?? 'n/a' }}<mat-icon aria-hidden=\"false\" [attr.aria-label]=\"trend.trend\" [fontIcon]=\"trend.trend!\" /></span>\n          <span class=\"cdk-visually-hidden\">{{trend.trend}}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n    <!-- generate actual table -->\n    <tr mat-header-row *matHeaderRowDef=\"['label-col'].concat(typeColumns); sticky:true;\"></tr>\n    <tr mat-header-row *matHeaderRowDef=\"allColumns; sticky: true;\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: ['label-col'].concat(allColumns)\"></tr>\n\n  </table>\n</mat-card>", styles: ["tr:nth-child(2n){background-color:#e4e4e4}tr:nth-child(2n)>td.label-col,tr:nth-child(2n) td.recent-data-cell{border-right:1px solid white}tr:nth-child(odd){background-color:#fff}tr:nth-child(odd)>td.label-col,tr:nth-child(odd) td.recent-data-cell{border-right:1px solid #e4e4e4}td.label-col{text-align:left}.mat-mdc-header-cell,.mat-mdc-cell{text-align:center}.mat-mdc-header-cell a,.mat-mdc-cell a{cursor:pointer;text-decoration:underline}.mat-mdc-header-cell a:hover,.mat-mdc-cell a:hover{text-decoration:underline}.mat-mdc-header-cell mat-icon,.mat-mdc-cell mat-icon{margin-left:5px;vertical-align:middle}.trending_down{color:#4abeff}.trending_up{color:#c20808}\n"], dependencies: [{ kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i2.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i2.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i2.MatCardHeader, selector: "mat-card-header" }, { kind: "directive", type: i2.MatCardTitle, selector: "mat-card-title, [mat-card-title], [matCardTitle]" }, { kind: "directive", type: MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatTableModule }, { kind: "component", type: i3.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i3.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i3.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i3.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i3.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i3.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i3.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i3.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "component", type: i3.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i3.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }, { kind: "directive", type: NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: DatepickerComponent, selector: "metaqs2-datepicker", inputs: ["disabled", "inputGroup"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CountsWithHistoryComponent, deps: [{ token: i1.MetaApiService }, { token: i2.EditorialLinkService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CountsWithHistoryComponent, isStandalone: true, selector: "metaqs2-counts-with-history", inputs: { apiMethod: "apiMethod", columnTranslationkey: "columnTranslationkey", pageTitle: "pageTitle", sourceType: "sourceType" }, ngImport: i0, template: "<mat-card appearance=\"raised\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title data-test-id=\"page-title\">\n      Qualit\u00E4tsmetrik: {{ pageTitle | translate}}{{isLoading() ? \": Lade neue Daten.\" : \"\"}}\n    </mat-card-title>\n  </mat-card-header>\n  <!-- consider to put the filter in the table header to avoid that it is scrolled out of view-->\n  <!-- show the filter after the values are loaded to avoid loading current data twice -->\n  <mat-card-content *ngIf=\"timeFilterLoaded()\">\n    <metaqs2-datepicker [disabled]=\"isLoading()\" [inputGroup]=\"range\" ></metaqs2-datepicker>\n  </mat-card-content>\n</mat-card>\n<mat-card>\n  <table [ngClass]=\"{'while-loading': isLoading()}\" mat-table [dataSource]=\"recentTypeCount$.value.rows\" class=\"quality-matrix\">\n    <!-- Define columns of table -->\n    <!-- Row Header Column -->\n    <ng-container matColumnDef=\"label-col\" sticky>\n      <th rowspan=\"2\" mat-header-cell *matHeaderCellDef>Quelle</th>\n      <td\n        mat-cell\n        *matCellDef=\"let row\"\n        matTooltip=\"{{row.meta.alt_label}}\"\n        class=\"label-col\"\n      >\n        {{row.meta.label}}\n      </td>\n    </ng-container>\n    <!-- one column for each type -->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_type'\">\n      <th colspan=\"2\" mat-header-cell *matHeaderCellDef matTooltip=\"{{col.label}}\" >\n        {{columnTranslationkey ? (columnTranslationkey + col.label | translate ) : col.label }}\n      </th>\n    </ng-container>\n    <!-- one column for each type for the most current date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_recent'\">\n      <th class=\"recent-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >{{ range.controls.end.value.toLocaleString(DateTime.DATE_SHORT) }}</th>\n      <td class=\"recent-data-cell\" mat-cell *matCellDef=\"let row\">\n        <a [attr.href]=\"openInEditor(row.meta.id, col.id) | async\" target=\"editor_frontend\">{{ row.counts[col.id] ?? 'n/a' }}</a>\n      </td>\n    </ng-container>\n    <!-- one column for each type for the older date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_past'\">\n      <th class=\"past-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >\n        {{ pastTypeCount$.value.rows.length ? range.controls.start.value.toLocaleString(DateTime.DATE_SHORT) : 'no past data' }}\n      </th>\n      <td class=\"past-data-cell\" mat-cell *matCellDef=\"let row;\">\n        <ng-container *ngIf=\"pastTypeCount$.value.rows.length && pastTypeCount(row, col.id) as trend\">\n          <span [ngClass]=\"trend.trend\"> {{ trend.value ?? 'n/a' }}<mat-icon aria-hidden=\"false\" [attr.aria-label]=\"trend.trend\" [fontIcon]=\"trend.trend!\" /></span>\n          <span class=\"cdk-visually-hidden\">{{trend.trend}}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n    <!-- generate actual table -->\n    <tr mat-header-row *matHeaderRowDef=\"['label-col'].concat(typeColumns); sticky:true;\"></tr>\n    <tr mat-header-row *matHeaderRowDef=\"allColumns; sticky: true;\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: ['label-col'].concat(allColumns)\"></tr>\n\n  </table>\n</mat-card>", styles: ["tr:nth-child(2n){background-color:#e4e4e4}tr:nth-child(2n)>td.label-col,tr:nth-child(2n) td.recent-data-cell{border-right:1px solid white}tr:nth-child(odd){background-color:#fff}tr:nth-child(odd)>td.label-col,tr:nth-child(odd) td.recent-data-cell{border-right:1px solid #e4e4e4}td.label-col{text-align:left}.mat-mdc-header-cell,.mat-mdc-cell{text-align:center}.mat-mdc-header-cell a[href],.mat-mdc-cell a[href]{color:var(--mat-table-row-item-label-text-color);cursor:pointer;text-decoration:underline}.mat-mdc-header-cell a[href]:hover,.mat-mdc-cell a[href]:hover{text-decoration:underline}.mat-mdc-header-cell mat-icon,.mat-mdc-cell mat-icon{margin-left:5px;vertical-align:middle}.trending_down{color:#4abeff}.trending_up{color:#c20808}\n"], dependencies: [{ kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i3.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i3.MatCardHeader, selector: "mat-card-header" }, { kind: "directive", type: i3.MatCardTitle, selector: "mat-card-title, [mat-card-title], [matCardTitle]" }, { kind: "directive", type: MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatTableModule }, { kind: "component", type: i4.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i4.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i4.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i4.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i4.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i4.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i4.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i4.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "component", type: i4.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i4.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "directive", type: NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: DatepickerComponent, selector: "metaqs2-datepicker", inputs: ["disabled", "inputGroup"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: AsyncPipe, name: "async" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CountsWithHistoryComponent, decorators: [{
             type: Component,
@@ -154,13 +165,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                         MatIcon,
                         NgIf,
                         AsyncPipe,
-                    ], template: "<mat-card appearance=\"raised\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title data-test-id=\"page-title\">\n      Qualit\u00E4tsmetrik: {{ pageTitle | translate}}{{isLoading() ? \": Lade neue Daten.\" : \"\"}}\n    </mat-card-title>\n  </mat-card-header>\n  <!-- consider to put the filter in the table header to avoid that it is scrolled out of view-->\n  <!-- show the filter after the values are loaded to avoid loading current data twice -->\n  <mat-card-content *ngIf=\"timeFilterLoaded()\">\n    <metaqs2-datepicker [disabled]=\"isLoading()\" [inputGroup]=\"range\" ></metaqs2-datepicker>\n  </mat-card-content>\n</mat-card>\n<mat-card>\n  <table [ngClass]=\"{'while-loading': isLoading()}\" mat-table [dataSource]=\"recentTypeCount$.value.rows\" class=\"quality-matrix\">\n    <!-- Define columns of table -->\n    <!-- Row Header Column -->\n    <ng-container matColumnDef=\"label-col\" sticky>\n      <th rowspan=\"2\" mat-header-cell *matHeaderCellDef>Quelle</th>\n      <td\n        mat-cell\n        *matCellDef=\"let row\"\n        matTooltip=\"{{row.meta.alt_label}}\"\n        class=\"label-col\"\n      >\n        {{row.meta.label}}\n      </td>\n    </ng-container>\n    <!-- one column for each type -->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_type'\">\n      <th colspan=\"2\" mat-header-cell *matHeaderCellDef matTooltip=\"{{col.label}}\" >\n        {{columnTranslationkey ? (columnTranslationkey + col.label | translate ) : col.label }}\n      </th>\n    </ng-container>\n    <!-- one column for each type for the most current date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_recent'\">\n      <th class=\"recent-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >{{ range.controls.end.value.toLocaleString(DateTime.DATE_SHORT) }}</th>\n      <td class=\"recent-data-cell\" mat-cell *matCellDef=\"let row\">{{ row.counts[col.id] ?? 'n/a' }}</td>\n    </ng-container>\n    <!-- one column for each type for the older date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_past'\">\n      <th class=\"past-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >\n        {{ pastTypeCount$.value.rows.length ? range.controls.start.value.toLocaleString(DateTime.DATE_SHORT) : 'no past data' }}\n      </th>\n      <td class=\"past-data-cell\" mat-cell *matCellDef=\"let row;\">\n        <ng-container *ngIf=\"pastTypeCount$.value.rows.length && pastTypeCount(row, col.id) as trend\">\n          <span [ngClass]=\"trend.trend\"> {{ trend.value ?? 'n/a' }}<mat-icon aria-hidden=\"false\" [attr.aria-label]=\"trend.trend\" [fontIcon]=\"trend.trend!\" /></span>\n          <span class=\"cdk-visually-hidden\">{{trend.trend}}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n    <!-- generate actual table -->\n    <tr mat-header-row *matHeaderRowDef=\"['label-col'].concat(typeColumns); sticky:true;\"></tr>\n    <tr mat-header-row *matHeaderRowDef=\"allColumns; sticky: true;\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: ['label-col'].concat(allColumns)\"></tr>\n\n  </table>\n</mat-card>", styles: ["tr:nth-child(2n){background-color:#e4e4e4}tr:nth-child(2n)>td.label-col,tr:nth-child(2n) td.recent-data-cell{border-right:1px solid white}tr:nth-child(odd){background-color:#fff}tr:nth-child(odd)>td.label-col,tr:nth-child(odd) td.recent-data-cell{border-right:1px solid #e4e4e4}td.label-col{text-align:left}.mat-mdc-header-cell,.mat-mdc-cell{text-align:center}.mat-mdc-header-cell a,.mat-mdc-cell a{cursor:pointer;text-decoration:underline}.mat-mdc-header-cell a:hover,.mat-mdc-cell a:hover{text-decoration:underline}.mat-mdc-header-cell mat-icon,.mat-mdc-cell mat-icon{margin-left:5px;vertical-align:middle}.trending_down{color:#4abeff}.trending_up{color:#c20808}\n"] }]
-        }], ctorParameters: () => [{ type: i1.MetaApiService }], propDecorators: { apiMethod: [{
+                    ], template: "<mat-card appearance=\"raised\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title data-test-id=\"page-title\">\n      Qualit\u00E4tsmetrik: {{ pageTitle | translate}}{{isLoading() ? \": Lade neue Daten.\" : \"\"}}\n    </mat-card-title>\n  </mat-card-header>\n  <!-- consider to put the filter in the table header to avoid that it is scrolled out of view-->\n  <!-- show the filter after the values are loaded to avoid loading current data twice -->\n  <mat-card-content *ngIf=\"timeFilterLoaded()\">\n    <metaqs2-datepicker [disabled]=\"isLoading()\" [inputGroup]=\"range\" ></metaqs2-datepicker>\n  </mat-card-content>\n</mat-card>\n<mat-card>\n  <table [ngClass]=\"{'while-loading': isLoading()}\" mat-table [dataSource]=\"recentTypeCount$.value.rows\" class=\"quality-matrix\">\n    <!-- Define columns of table -->\n    <!-- Row Header Column -->\n    <ng-container matColumnDef=\"label-col\" sticky>\n      <th rowspan=\"2\" mat-header-cell *matHeaderCellDef>Quelle</th>\n      <td\n        mat-cell\n        *matCellDef=\"let row\"\n        matTooltip=\"{{row.meta.alt_label}}\"\n        class=\"label-col\"\n      >\n        {{row.meta.label}}\n      </td>\n    </ng-container>\n    <!-- one column for each type -->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_type'\">\n      <th colspan=\"2\" mat-header-cell *matHeaderCellDef matTooltip=\"{{col.label}}\" >\n        {{columnTranslationkey ? (columnTranslationkey + col.label | translate ) : col.label }}\n      </th>\n    </ng-container>\n    <!-- one column for each type for the most current date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_recent'\">\n      <th class=\"recent-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >{{ range.controls.end.value.toLocaleString(DateTime.DATE_SHORT) }}</th>\n      <td class=\"recent-data-cell\" mat-cell *matCellDef=\"let row\">\n        <a [attr.href]=\"openInEditor(row.meta.id, col.id) | async\" target=\"editor_frontend\">{{ row.counts[col.id] ?? 'n/a' }}</a>\n      </td>\n    </ng-container>\n    <!-- one column for each type for the older date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_past'\">\n      <th class=\"past-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >\n        {{ pastTypeCount$.value.rows.length ? range.controls.start.value.toLocaleString(DateTime.DATE_SHORT) : 'no past data' }}\n      </th>\n      <td class=\"past-data-cell\" mat-cell *matCellDef=\"let row;\">\n        <ng-container *ngIf=\"pastTypeCount$.value.rows.length && pastTypeCount(row, col.id) as trend\">\n          <span [ngClass]=\"trend.trend\"> {{ trend.value ?? 'n/a' }}<mat-icon aria-hidden=\"false\" [attr.aria-label]=\"trend.trend\" [fontIcon]=\"trend.trend!\" /></span>\n          <span class=\"cdk-visually-hidden\">{{trend.trend}}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n    <!-- generate actual table -->\n    <tr mat-header-row *matHeaderRowDef=\"['label-col'].concat(typeColumns); sticky:true;\"></tr>\n    <tr mat-header-row *matHeaderRowDef=\"allColumns; sticky: true;\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: ['label-col'].concat(allColumns)\"></tr>\n\n  </table>\n</mat-card>", styles: ["tr:nth-child(2n){background-color:#e4e4e4}tr:nth-child(2n)>td.label-col,tr:nth-child(2n) td.recent-data-cell{border-right:1px solid white}tr:nth-child(odd){background-color:#fff}tr:nth-child(odd)>td.label-col,tr:nth-child(odd) td.recent-data-cell{border-right:1px solid #e4e4e4}td.label-col{text-align:left}.mat-mdc-header-cell,.mat-mdc-cell{text-align:center}.mat-mdc-header-cell a[href],.mat-mdc-cell a[href]{color:var(--mat-table-row-item-label-text-color);cursor:pointer;text-decoration:underline}.mat-mdc-header-cell a[href]:hover,.mat-mdc-cell a[href]:hover{text-decoration:underline}.mat-mdc-header-cell mat-icon,.mat-mdc-cell mat-icon{margin-left:5px;vertical-align:middle}.trending_down{color:#4abeff}.trending_up{color:#c20808}\n"] }]
+        }], ctorParameters: () => [{ type: i1.MetaApiService }, { type: i2.EditorialLinkService }], propDecorators: { apiMethod: [{
                 type: Input,
                 args: [{ required: true }]
             }], columnTranslationkey: [{
                 type: Input
             }], pageTitle: [{
                 type: Input
+            }], sourceType: [{
+                type: Input,
+                args: [{ required: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"counts-with-history.component.js","sourceRoot":"","sources":["../../../../../projects/ng-meta-widgets-lib/src/lib/counts-with-history/counts-with-history.component.ts","../../../../../projects/ng-meta-widgets-lib/src/lib/counts-with-history/counts-with-history.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, OnInit, signal } from '@angular/core';\nimport { MatCard, MatCardContent, MatCardHeader, MatCardModule, MatCardTitle } from '@angular/material/card';\nimport { MatTooltip } from '@angular/material/tooltip';\nimport { MatHeaderRow, MatHeaderRowDef, MatRow, MatRowDef, MatTable, MatTableModule } from '@angular/material/table';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { AsyncPipe, NgClass, NgForOf, NgIf } from '@angular/common';\nimport { MetaApiService } from '../meta-api.service';\nimport { Filter, MatrixRowWithCounts, MatrixWithCounts, QualityMatrixHeader } from '../java-api';\nimport { DateTime } from 'luxon';\nimport { finalize, map, takeUntil, tap } from 'rxjs/operators';\nimport { FormControl, FormGroup } from '@angular/forms';\nimport { DatepickerComponent } from '../components/filter/datepicker/datepicker.component';\nimport { MatIcon } from '@angular/material/icon';\n\n@Component({\n  selector: 'metaqs2-counts-with-history',\n  standalone: true,\n  imports: [\n    MatCardModule,\n    MatCard,\n    MatCardHeader,\n    MatCardTitle,\n    MatCardContent,\n    MatTooltip,\n    MatTableModule,\n    MatTable,\n    TranslateModule,\n    MatHeaderRow,\n    MatHeaderRowDef,\n    MatRow,\n    MatRowDef,\n    NgForOf,\n    DatepickerComponent,\n    NgClass,\n    MatIcon,\n    NgIf,\n    AsyncPipe,\n  ],\n  templateUrl: './counts-with-history.component.html',\n  styleUrl: './counts-with-history.component.scss',\n})\nexport class CountsWithHistoryComponent implements OnInit, OnDestroy {\n  protected readonly isLoading = signal(true);\n  protected readonly timeFilterLoaded = signal(false);\n  private readonly destroyed$ = new Subject<void>();\n  protected readonly recentTypeCount$ = new BehaviorSubject<MatrixWithCounts>({ columns: [], rows: [] });\n  protected readonly pastTypeCount$ = new BehaviorSubject<MatrixWithCounts>({ columns: [], rows: [] });\n  private columns: QualityMatrixHeader[] = [];\n\n  @Input({ required: true })\n  private apiMethod: keyof MetaApiService = 'getMaterialTypeCountsByReplicationSource';\n  @Input()\n  protected columnTranslationkey: string | null = null;\n  @Input()\n  protected readonly pageTitle: string;\n\n  /* In this widget's backend we do have data for today\n   * therefore we set the end date to today and use the timerange() endpoint to only set the start date\n   */\n  readonly range: FormGroup<{\n    start: FormControl<DateTime<boolean>>;\n    end: FormControl<DateTime<boolean>>;\n  }> = new FormGroup({\n    start: new FormControl(),\n    end: new FormControl(DateTime.utc().startOf('day'), { nonNullable: true }),\n  });\n\n  constructor(private readonly metaApi: MetaApiService) {}\n  columnIdent(_index: number, col: QualityMatrixHeader) {\n    return col.id;\n  }\n\n  get typeColumns(): string[] {\n    return this.columns.map((c) => c.id + '_type');\n  }\n\n  get recentColumns(): string[] {\n    return this.columns.map((c) => c.id + '_recent');\n  }\n\n  get pastColumns(): string[] {\n    return this.columns.map((c) => c.id + '_past');\n  }\n\n  get allColumns(): string[] {\n    return this.pastColumns.flatMap((e, i) => [e, this.recentColumns[i]]);\n  }\n\n  private registerDateRangeFilter() {\n    /* we cannot use the takeUntilDestroyed() helper here,\n     * because this method is indirectly called in the finalization of the getTimerangeFilter() call\n     */\n    this.range.controls.end.valueChanges.pipe(takeUntil(this.destroyed$)).subscribe((date) => {\n      this.getCountByDate(date).subscribe((response) => {\n        this.recentTypeCount$.next(response);\n      });\n    });\n    this.range.controls.start.valueChanges.pipe(takeUntil(this.destroyed$)).subscribe((date) => {\n      this.getCountByDate(date).subscribe((response) => {\n        this.pastTypeCount$.next(response);\n      });\n    });\n  }\n\n  private getTimeRangeFilter() {\n    return this.metaApi\n      .getTimerangeFilter()\n      .pipe(\n        finalize(() => {\n          this.timeFilterLoaded.set(true);\n          this.registerDateRangeFilter();\n          this.range.controls.start.reset();\n        })\n      )\n      .subscribe((rangeFilter) => {\n        if (rangeFilter) {\n          const startDate = DateTime.fromISO(rangeFilter.values.find((v) => v.id === 'rangeStart')?.label!, {\n            zone: 'utc',\n          }).startOf('day');\n          //this is to have a default value for the start date => the min date of the range\n          this.range.setControl('start', new FormControl<DateTime>(startDate, { nonNullable: true }));\n        }\n      });\n  }\n\n  private getCountByDate(date: DateTime): Observable<MatrixWithCounts> {\n    this.isLoading.set(true);\n    const filter: Filter = {\n      field: 'asOf',\n      values: [{ id: date.toISO({ includeOffset: false })!, label: '' }],\n    };\n    // type of this.metaApi[this.apiMethod]([filter]) is Observable<MatrixWithCounts>\n    // but typescript does not know that\n    // @ts-ignore\n    return this.metaApi[this.apiMethod]([filter]).pipe(\n      // typesript gets confused here\n      // @ts-ignore\n      finalize(() => this.isLoading.set(false)),\n      map((response: MatrixWithCounts) => {\n        response.rows.sort((a, b) => a.meta.label.localeCompare(b.meta.label));\n        return response;\n      })\n    );\n  }\n\n  protected pastTypeCount(row: MatrixRowWithCounts, columnid: string) {\n    if (!this.pastTypeCount$.value.rows.length) {\n      return {};\n    }\n    const past_row = this.pastTypeCount$.value.rows.find((pr) => pr.meta.id == row.meta.id);\n    const past_column = this.pastTypeCount$.value.columns.find((c) => c.id == columnid);\n    if (!past_row || !past_column) {\n      return {};\n    }\n\n    const currentValue = row.counts[columnid];\n    const pastValue = past_row.counts[columnid];\n\n    const delta = (currentValue || 0) - (pastValue || 0);\n    const trend = delta === 0 ? 'trending_flat' : delta < 0 ? 'trending_down' : 'trending_up';\n    return { delta, trend, value: pastValue };\n  }\n\n  ngOnInit(): void {\n    this.getTimeRangeFilter();\n    this.getCountByDate(this.range.controls.end.value)\n      .pipe(\n        tap((response) => {\n          this.columns = response.columns.slice();\n        })\n      )\n      .subscribe((response) => {\n        this.recentTypeCount$.next(response);\n      });\n  }\n\n  protected readonly DateTime = DateTime;\n\n  ngOnDestroy(): void {\n    this.destroyed$.next();\n    this.destroyed$.complete();\n  }\n}\n","<mat-card appearance=\"raised\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title data-test-id=\"page-title\">\n      Qualitätsmetrik: {{ pageTitle | translate}}{{isLoading() ? \": Lade neue Daten.\" : \"\"}}\n    </mat-card-title>\n  </mat-card-header>\n  <!-- consider to put the filter in the table header to avoid that it is scrolled out of view-->\n  <!-- show the filter after the values are loaded to avoid loading current data twice -->\n  <mat-card-content *ngIf=\"timeFilterLoaded()\">\n    <metaqs2-datepicker [disabled]=\"isLoading()\" [inputGroup]=\"range\" ></metaqs2-datepicker>\n  </mat-card-content>\n</mat-card>\n<mat-card>\n  <table [ngClass]=\"{'while-loading': isLoading()}\" mat-table [dataSource]=\"recentTypeCount$.value.rows\" class=\"quality-matrix\">\n    <!-- Define columns of table -->\n    <!-- Row Header Column -->\n    <ng-container matColumnDef=\"label-col\" sticky>\n      <th rowspan=\"2\" mat-header-cell *matHeaderCellDef>Quelle</th>\n      <td\n        mat-cell\n        *matCellDef=\"let row\"\n        matTooltip=\"{{row.meta.alt_label}}\"\n        class=\"label-col\"\n      >\n        {{row.meta.label}}\n      </td>\n    </ng-container>\n    <!-- one column for each type -->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_type'\">\n      <th colspan=\"2\" mat-header-cell *matHeaderCellDef matTooltip=\"{{col.label}}\" >\n        {{columnTranslationkey ? (columnTranslationkey + col.label | translate ) : col.label }}\n      </th>\n    </ng-container>\n    <!-- one column for each type for the most current date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_recent'\">\n      <th class=\"recent-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >{{ range.controls.end.value.toLocaleString(DateTime.DATE_SHORT) }}</th>\n      <td class=\"recent-data-cell\" mat-cell *matCellDef=\"let row\">{{ row.counts[col.id] ?? 'n/a' }}</td>\n    </ng-container>\n    <!-- one column for each type for the older date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_past'\">\n      <th class=\"past-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >\n        {{ pastTypeCount$.value.rows.length ? range.controls.start.value.toLocaleString(DateTime.DATE_SHORT) : 'no past data' }}\n      </th>\n      <td class=\"past-data-cell\" mat-cell *matCellDef=\"let row;\">\n        <ng-container *ngIf=\"pastTypeCount$.value.rows.length && pastTypeCount(row, col.id) as trend\">\n          <span [ngClass]=\"trend.trend\"> {{ trend.value ?? 'n/a' }}<mat-icon aria-hidden=\"false\" [attr.aria-label]=\"trend.trend\" [fontIcon]=\"trend.trend!\" /></span>\n          <span class=\"cdk-visually-hidden\">{{trend.trend}}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n    <!-- generate actual table -->\n    <tr mat-header-row *matHeaderRowDef=\"['label-col'].concat(typeColumns); sticky:true;\"></tr>\n    <tr mat-header-row *matHeaderRowDef=\"allColumns; sticky: true;\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: ['label-col'].concat(allColumns)\"></tr>\n\n  </table>\n</mat-card>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"counts-with-history.component.js","sourceRoot":"","sources":["../../../../../projects/ng-meta-widgets-lib/src/lib/counts-with-history/counts-with-history.component.ts","../../../../../projects/ng-meta-widgets-lib/src/lib/counts-with-history/counts-with-history.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, OnInit, signal } from '@angular/core';\nimport { MatCard, MatCardContent, MatCardHeader, MatCardModule, MatCardTitle } from '@angular/material/card';\nimport { MatTooltip } from '@angular/material/tooltip';\nimport { MatHeaderRow, MatHeaderRowDef, MatRow, MatRowDef, MatTable, MatTableModule } from '@angular/material/table';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { AsyncPipe, NgClass, NgForOf, NgIf } from '@angular/common';\nimport { MetaApiService } from '../meta-api.service';\nimport { Filter, MatrixRowWithCounts, MatrixWithCounts, QualityMatrixHeader } from '../java-api';\nimport { DateTime } from 'luxon';\nimport { finalize, map, skipWhile, take, takeUntil, tap } from 'rxjs/operators';\nimport { FormControl, FormGroup } from '@angular/forms';\nimport { DatepickerComponent } from '../components/filter/datepicker/datepicker.component';\nimport { MatIcon } from '@angular/material/icon';\nimport { EditorialLinkService } from '../components/editorial-link-service/editorial-link.service';\n\n@Component({\n  selector: 'metaqs2-counts-with-history',\n  standalone: true,\n  imports: [\n    MatCardModule,\n    MatCard,\n    MatCardHeader,\n    MatCardTitle,\n    MatCardContent,\n    MatTooltip,\n    MatTableModule,\n    MatTable,\n    TranslateModule,\n    MatHeaderRow,\n    MatHeaderRowDef,\n    MatRow,\n    MatRowDef,\n    NgForOf,\n    DatepickerComponent,\n    NgClass,\n    MatIcon,\n    NgIf,\n    AsyncPipe,\n  ],\n  templateUrl: './counts-with-history.component.html',\n  styleUrl: './counts-with-history.component.scss',\n})\nexport class CountsWithHistoryComponent implements OnInit, OnDestroy {\n  protected readonly isLoading = signal(true);\n  protected readonly timeFilterLoaded = signal(false);\n  private readonly destroyed$ = new Subject<void>();\n  protected readonly recentTypeCount$ = new BehaviorSubject<MatrixWithCounts>({ columns: [], rows: [] });\n  protected readonly pastTypeCount$ = new BehaviorSubject<MatrixWithCounts>({ columns: [], rows: [] });\n  private columns: QualityMatrixHeader[] = [];\n\n  @Input({ required: true })\n  apiMethod: keyof MetaApiService = 'getMaterialTypeCountsByReplicationSource';\n  @Input()\n  columnTranslationkey: string | null = null;\n  @Input()\n  pageTitle: string;\n  @Input({ required: true })\n  sourceType: 'replicationSource' | 'collection';\n\n  /* In this widget's backend we do have data for today\n   * therefore we set the end date to today and use the timerange() endpoint to only set the start date\n   */\n  readonly range: FormGroup<{\n    start: FormControl<DateTime<boolean>>;\n    end: FormControl<DateTime<boolean>>;\n  }> = new FormGroup({\n    start: new FormControl(),\n    end: new FormControl(DateTime.utc().startOf('day'), { nonNullable: true }),\n  });\n\n  constructor(private readonly metaApi: MetaApiService, private readonly linkService: EditorialLinkService) {}\n  columnIdent(_index: number, col: QualityMatrixHeader) {\n    return col.id;\n  }\n\n  get typeColumns(): string[] {\n    return this.columns.map((c) => c.id + '_type');\n  }\n\n  get recentColumns(): string[] {\n    return this.columns.map((c) => c.id + '_recent');\n  }\n\n  get pastColumns(): string[] {\n    return this.columns.map((c) => c.id + '_past');\n  }\n\n  get allColumns(): string[] {\n    return this.pastColumns.flatMap((e, i) => [e, this.recentColumns[i]]);\n  }\n\n  private registerDateRangeFilter() {\n    /* we cannot use the takeUntilDestroyed() helper here,\n     * because this method is indirectly called in the finalization of the getTimerangeFilter() call\n     */\n    this.range.controls.end.valueChanges.pipe(takeUntil(this.destroyed$)).subscribe((date) => {\n      this.getCountByDate(date).subscribe((response) => {\n        this.recentTypeCount$.next(response);\n      });\n    });\n    this.range.controls.start.valueChanges.pipe(takeUntil(this.destroyed$)).subscribe((date) => {\n      this.getCountByDate(date).subscribe((response) => {\n        this.pastTypeCount$.next(response);\n      });\n    });\n  }\n\n  private getTimeRangeFilter() {\n    return this.metaApi\n      .getTimerangeFilter()\n      .pipe(\n        finalize(() => {\n          this.timeFilterLoaded.set(true);\n          this.registerDateRangeFilter();\n          this.range.controls.start.reset();\n        })\n      )\n      .subscribe((rangeFilter) => {\n        if (rangeFilter) {\n          const startDate = DateTime.fromISO(rangeFilter.values.find((v) => v.id === 'rangeStart')?.label!, {\n            zone: 'utc',\n          }).startOf('day');\n          //this is to have a default value for the start date => the min date of the range\n          this.range.setControl('start', new FormControl<DateTime>(startDate, { nonNullable: true }));\n        }\n      });\n  }\n\n  private getCountByDate(date: DateTime): Observable<MatrixWithCounts> {\n    this.isLoading.set(true);\n    const filter: Filter = {\n      field: 'asOf',\n      values: [{ id: date.toISO({ includeOffset: false })!, label: '' }],\n    };\n    // type of this.metaApi[this.apiMethod]([filter]) is Observable<MatrixWithCounts>\n    // but typescript does not know that\n    // @ts-ignore\n    return this.metaApi[this.apiMethod]([filter]).pipe(\n      // typesript gets confused here\n      // @ts-ignore\n      finalize(() => this.isLoading.set(false)),\n      map((response: MatrixWithCounts) => {\n        response.rows.sort((a, b) => a.meta.label.localeCompare(b.meta.label));\n        return response;\n      })\n    );\n  }\n\n  protected pastTypeCount(row: MatrixRowWithCounts, columnid: string) {\n    if (!this.pastTypeCount$.value.rows.length) {\n      return {};\n    }\n    const past_row = this.pastTypeCount$.value.rows.find((pr) => pr.meta.id == row.meta.id);\n    const past_column = this.pastTypeCount$.value.columns.find((c) => c.id == columnid);\n    if (!past_row || !past_column) {\n      return {};\n    }\n\n    const currentValue = row.counts[columnid];\n    const pastValue = past_row.counts[columnid];\n\n    const delta = (currentValue || 0) - (pastValue || 0);\n    const trend = delta === 0 ? 'trending_flat' : delta < 0 ? 'trending_down' : 'trending_up';\n    return { delta, trend, value: pastValue };\n  }\n\n  protected openInEditor(sourceId: string, issueId: string) {\n    if (this.sourceType === 'replicationSource') {\n      // find the long name for the source\n      sourceId = this.recentTypeCount$.value.rows.find((r) => r.meta.id === sourceId)?.meta.label || sourceId;\n    }\n    return this.linkService.typesLoaded$.pipe(\n      skipWhile((loaded) => !loaded),\n      take(1),\n      map(() => {\n        return this.linkService.createLinkForCountsWithHistory(this.sourceType, sourceId, issueId);\n      })\n    );\n  }\n\n  ngOnInit(): void {\n    this.getTimeRangeFilter();\n    this.getCountByDate(this.range.controls.end.value)\n      .pipe(\n        tap((response) => {\n          this.columns = response.columns.slice();\n        })\n      )\n      .subscribe((response) => {\n        this.recentTypeCount$.next(response);\n      });\n  }\n\n  protected readonly DateTime = DateTime;\n\n  ngOnDestroy(): void {\n    this.destroyed$.next();\n    this.destroyed$.complete();\n  }\n}\n","<mat-card appearance=\"raised\">\n  <mat-card-header *ngIf=\"pageTitle\">\n    <mat-card-title data-test-id=\"page-title\">\n      Qualitätsmetrik: {{ pageTitle | translate}}{{isLoading() ? \": Lade neue Daten.\" : \"\"}}\n    </mat-card-title>\n  </mat-card-header>\n  <!-- consider to put the filter in the table header to avoid that it is scrolled out of view-->\n  <!-- show the filter after the values are loaded to avoid loading current data twice -->\n  <mat-card-content *ngIf=\"timeFilterLoaded()\">\n    <metaqs2-datepicker [disabled]=\"isLoading()\" [inputGroup]=\"range\" ></metaqs2-datepicker>\n  </mat-card-content>\n</mat-card>\n<mat-card>\n  <table [ngClass]=\"{'while-loading': isLoading()}\" mat-table [dataSource]=\"recentTypeCount$.value.rows\" class=\"quality-matrix\">\n    <!-- Define columns of table -->\n    <!-- Row Header Column -->\n    <ng-container matColumnDef=\"label-col\" sticky>\n      <th rowspan=\"2\" mat-header-cell *matHeaderCellDef>Quelle</th>\n      <td\n        mat-cell\n        *matCellDef=\"let row\"\n        matTooltip=\"{{row.meta.alt_label}}\"\n        class=\"label-col\"\n      >\n        {{row.meta.label}}\n      </td>\n    </ng-container>\n    <!-- one column for each type -->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_type'\">\n      <th colspan=\"2\" mat-header-cell *matHeaderCellDef matTooltip=\"{{col.label}}\" >\n        {{columnTranslationkey ? (columnTranslationkey + col.label | translate ) : col.label }}\n      </th>\n    </ng-container>\n    <!-- one column for each type for the most current date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_recent'\">\n      <th class=\"recent-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >{{ range.controls.end.value.toLocaleString(DateTime.DATE_SHORT) }}</th>\n      <td class=\"recent-data-cell\" mat-cell *matCellDef=\"let row\">\n        <a [attr.href]=\"openInEditor(row.meta.id, col.id) | async\" target=\"editor_frontend\">{{ row.counts[col.id] ?? 'n/a' }}</a>\n      </td>\n    </ng-container>\n    <!-- one column for each type for the older date-->\n    <ng-container *ngFor=\"let col of recentTypeCount$.value.columns; trackBy:columnIdent\" [matColumnDef]=\"col.id + '_past'\">\n      <th class=\"past-data-cell\" mat-header-cell *matHeaderCellDef matTooltip=\"no tooltip\" >\n        {{ pastTypeCount$.value.rows.length ? range.controls.start.value.toLocaleString(DateTime.DATE_SHORT) : 'no past data' }}\n      </th>\n      <td class=\"past-data-cell\" mat-cell *matCellDef=\"let row;\">\n        <ng-container *ngIf=\"pastTypeCount$.value.rows.length && pastTypeCount(row, col.id) as trend\">\n          <span [ngClass]=\"trend.trend\"> {{ trend.value ?? 'n/a' }}<mat-icon aria-hidden=\"false\" [attr.aria-label]=\"trend.trend\" [fontIcon]=\"trend.trend!\" /></span>\n          <span class=\"cdk-visually-hidden\">{{trend.trend}}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n    <!-- generate actual table -->\n    <tr mat-header-row *matHeaderRowDef=\"['label-col'].concat(typeColumns); sticky:true;\"></tr>\n    <tr mat-header-row *matHeaderRowDef=\"allColumns; sticky: true;\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: ['label-col'].concat(allColumns)\"></tr>\n\n  </table>\n</mat-card>"]}