libs/core/src/lib/presenting/dataset-presenter.component.ts
Abstract superclass for all components, which will present datasets.
Properties |
|
Methods |
|
Inputs |
Outputs |
constructor(iterableDiffers: IterableDiffers, servicesConnector: HelgolandServicesConnector, datasetIdResolver: InternalIdHandler, timeSrvc: Time, translateService: TranslateService, timezoneSrvc: TimezoneService)
|
|||||||||||||||||||||
Parameters :
|
Private datasetIdsDiffer |
Type : IterableDiffer<string>
|
Private langChangeSubscription |
Type : Subscription
|
Protected oldDatasetOptions |
Type : Map<string | T>
|
Protected oldPresenterOptions |
Type : U
|
Private selectedDatasetIdsDiffer |
Type : IterableDiffer<string>
|
Protected timespan |
Type : Timespan
|
Private timezoneSubscription |
Type : Subscription
|
Protected Abstract addDataset |
addDataset(id: string, url: string)
|
Returns :
void
|
Protected addDatasetByInternalId | ||||||
addDatasetByInternalId(internalId: string)
|
||||||
Parameters :
Returns :
void
|
Protected Abstract datasetOptionsChanged |
datasetOptionsChanged(internalId: string, options: T, firstChange: boolean)
|
Returns :
void
|
Public ngDoCheck |
ngDoCheck()
|
Returns :
void
|
Public ngOnChanges | ||||||
ngOnChanges(changes: SimpleChanges)
|
||||||
Parameters :
Returns :
void
|
Public ngOnDestroy |
ngOnDestroy()
|
Returns :
void
|
Protected Abstract onLanguageChanged | ||||||
onLanguageChanged(langChangeEvent: LangChangeEvent)
|
||||||
Parameters :
Returns :
void
|
Protected Abstract onTimezoneChanged | ||||||
onTimezoneChanged(timezone: string)
|
||||||
Parameters :
Returns :
void
|
Protected Abstract presenterOptionsChanged | ||||||
presenterOptionsChanged(options: U)
|
||||||
Parameters :
Returns :
void
|
Public Abstract reloadDataForDatasets | ||||||
reloadDataForDatasets(datasets: string[])
|
||||||
Parameters :
Returns :
void
|
Protected Abstract removeDataset | ||||||
removeDataset(internalId: string)
|
||||||
Parameters :
Returns :
void
|
Protected Abstract removeSelectedId | ||||||
removeSelectedId(internalId: string)
|
||||||
Parameters :
Returns :
void
|
Protected Abstract setSelectedId | ||||||
setSelectedId(internalId: string)
|
||||||
Parameters :
Returns :
void
|
Protected Abstract timeIntervalChanges |
timeIntervalChanges()
|
Returns :
void
|
Protected Abstract onResize |
onResize()
|
Inherited from
ResizableComponent
|
Defined in
ResizableComponent:10
|
Returns :
void
|
datasetIds | |
Type : string[]
|
|
Default value : []
|
|
List of presented dataset ids. |
datasetOptions | |
Type : Map<string | T>
|
|
The corresponding dataset options. |
presenterOptions | |
Type : U
|
|
Options for general presentation of the data. |
reloadForDatasets | |
Type : string[]
|
|
List of datasets for which a reload should be triggered, when the Array is set to new value. |
selectedDatasetIds | |
Type : string[]
|
|
Default value : []
|
|
List of presented selected dataset ids. |
timeInterval | |
Type : TimeInterval
|
|
The time interval in which the data should presented. |
dataLoaded | |
Type : EventEmitter<Set<string>>
|
|
Event, which triggers list of datasets where data is currently loaded. |
onContentLoading | |
Type : EventEmitter<boolean>
|
|
Event flag, while there is data loaded in the component. |
onDatasetSelected | |
Type : EventEmitter<string[]>
|
|
Event with a list of selected datasets. |
onMessageThrown | |
Type : EventEmitter<PresenterMessage>
|
|
Event, when there occured a message in the component. |
onTimespanChanged | |
Type : EventEmitter<Timespan>
|
|
Event when the timespan in the presentation is adjusted. |
import {
DoCheck,
EventEmitter,
Input,
IterableDiffer,
IterableDiffers,
OnChanges,
OnDestroy,
Output,
SimpleChanges,
} from '@angular/core';
import { LangChangeEvent, TranslateService } from '@ngx-translate/core';
import { Subscription } from 'rxjs';
import { HelgolandServicesConnector } from '../api-communication/helgoland-services-connector';
import { InternalIdHandler } from '../dataset-api/internal-id-handler.service';
import { DatasetOptions } from '../model/internal/options';
import { ResizableComponent } from '../model/internal/ResizableComponent';
import { TimeInterval, Timespan } from '../model/internal/timeInterval';
import { Time } from '../time/time.service';
import { TimezoneService } from './../time/timezone.service';
import { PresenterMessage } from './presenter-message';
const equal = require('deep-equal');
export interface PresenterOptions { }
/**
* Abstract superclass for all components, which will present datasets.
*/
export abstract class DatasetPresenterComponent<T extends DatasetOptions | DatasetOptions[], U extends PresenterOptions>
extends ResizableComponent implements OnChanges, DoCheck, OnDestroy {
/**
* List of presented dataset ids.
*/
@Input()
public datasetIds: string[] = [];
/**
* List of presented selected dataset ids.
*/
@Input()
public selectedDatasetIds: string[] = [];
/**
* The time interval in which the data should presented.
*/
@Input()
public timeInterval: TimeInterval;
/**
* The corresponding dataset options.
*/
@Input()
public datasetOptions: Map<string, T>;
protected oldDatasetOptions: Map<string, T>;
/**
* Options for general presentation of the data.
*/
@Input()
public presenterOptions: U;
protected oldPresenterOptions: U;
/**
* List of datasets for which a reload should be triggered, when the Array is set to new value.
*/
@Input()
public reloadForDatasets: string[];
/**
* Event with a list of selected datasets.
*/
@Output()
public onDatasetSelected: EventEmitter<string[]> = new EventEmitter();
/**
* Event when the timespan in the presentation is adjusted.
*/
@Output()
public onTimespanChanged: EventEmitter<Timespan> = new EventEmitter();
/**
* Event, when there occured a message in the component.
*/
@Output()
public onMessageThrown: EventEmitter<PresenterMessage> = new EventEmitter();
/**
* Event flag, while there is data loaded in the component.
*/
@Output()
public onContentLoading: EventEmitter<boolean> = new EventEmitter();
/**
* Event, which triggers list of datasets where data is currently loaded.
*/
@Output()
public dataLoaded: EventEmitter<Set<string>> = new EventEmitter();
protected timespan: Timespan;
private datasetIdsDiffer: IterableDiffer<string>;
private selectedDatasetIdsDiffer: IterableDiffer<string>;
private langChangeSubscription: Subscription;
private timezoneSubscription: Subscription;
constructor(
protected iterableDiffers: IterableDiffers,
protected servicesConnector: HelgolandServicesConnector,
protected datasetIdResolver: InternalIdHandler,
protected timeSrvc: Time,
protected translateService: TranslateService,
protected timezoneSrvc: TimezoneService
) {
super();
this.datasetIdsDiffer = this.iterableDiffers.find([]).create();
this.selectedDatasetIdsDiffer = this.iterableDiffers.find([]).create();
this.langChangeSubscription = this.translateService.onLangChange.subscribe((langChangeEvent: LangChangeEvent) => this.onLanguageChanged(langChangeEvent));
this.timezoneSubscription = this.timezoneSrvc.timezoneChange.subscribe((tz: string) => this.onTimezoneChanged(tz));
}
public ngOnChanges(changes: SimpleChanges): void {
if (changes.timeInterval && this.timeInterval) {
this.timespan = this.timeSrvc.createTimespanOfInterval(this.timeInterval);
this.timeIntervalChanges();
}
if (changes.reloadForDatasets && this.reloadForDatasets && this.reloadDataForDatasets.length > 0) {
this.reloadDataForDatasets(this.reloadForDatasets);
}
}
public ngOnDestroy(): void {
this.langChangeSubscription.unsubscribe();
this.timezoneSubscription.unsubscribe();
}
public ngDoCheck(): void {
const datasetIdsChanges = this.datasetIdsDiffer.diff(this.datasetIds);
if (datasetIdsChanges) {
datasetIdsChanges.forEachAddedItem((addedItem) => {
this.addDatasetByInternalId(addedItem.item);
});
datasetIdsChanges.forEachRemovedItem((removedItem) => {
this.removeDataset(removedItem.item);
});
}
const selectedDatasetIdsChanges = this.selectedDatasetIdsDiffer.diff(this.selectedDatasetIds);
if (selectedDatasetIdsChanges) {
selectedDatasetIdsChanges.forEachAddedItem((addedItem) => {
this.setSelectedId(addedItem.item);
});
selectedDatasetIdsChanges.forEachRemovedItem((removedItem) => {
this.removeSelectedId(removedItem.item);
});
}
if (!equal(this.oldPresenterOptions, this.presenterOptions)) {
this.oldPresenterOptions = Object.assign({}, this.presenterOptions);
const options = Object.assign({}, this.presenterOptions);
this.presenterOptionsChanged(options);
}
if (this.datasetOptions) {
const firstChange = this.oldDatasetOptions === undefined;
if (firstChange) { this.oldDatasetOptions = new Map(); }
this.datasetOptions.forEach((value, key) => {
if (!equal(value, this.oldDatasetOptions.get(key))) {
this.oldDatasetOptions.set(key, Object.assign({}, this.datasetOptions.get(key)));
this.datasetOptionsChanged(key, value, firstChange);
}
});
}
}
public abstract reloadDataForDatasets(datasets: string[]): void;
protected addDatasetByInternalId(internalId: string) {
const internalIdObj = this.datasetIdResolver.resolveInternalId(internalId);
this.addDataset(internalIdObj.id, internalIdObj.url);
}
protected abstract onLanguageChanged(langChangeEvent: LangChangeEvent): void;
protected abstract onTimezoneChanged(timezone: string): void;
protected abstract timeIntervalChanges(): void;
protected abstract addDataset(id: string, url: string): void;
protected abstract removeDataset(internalId: string): void;
protected abstract setSelectedId(internalId: string): void;
protected abstract removeSelectedId(internalId: string): void;
protected abstract presenterOptionsChanged(options: U): void;
protected abstract datasetOptionsChanged(internalId: string, options: T, firstChange: boolean): void;
}