File

libs/core/src/lib/abstract-services/dataset.service.ts

Index

Properties
Methods

Properties

Public datasetIds
Type : string[]
Default value : []
Public datasetIdsChanged
Type : EventEmitter<string[]>
Default value : new EventEmitter()
Public datasetOptions
Type : Map<string | T>
Default value : new Map()

Methods

Public Async addDataset
addDataset(internalId: string, options?: T)

Adds the dataset to the selection

Parameters :
Name Type Optional
internalId string No
options T Yes
Returns : Promise<boolean>

Successfull added the dataset.

Protected Abstract createStyles
createStyles(internalId: string)
Parameters :
Name Type Optional
internalId string No
Returns : T
Public hasDataset
hasDataset(id: string)
Parameters :
Name Type Optional
id string No
Returns : boolean
Public hasDatasets
hasDatasets()
Returns : boolean
Protected Abstract loadState
loadState()
Returns : void
Public removeAllDatasets
removeAllDatasets()
Returns : void
Public removeDataset
removeDataset(internalId: string)
Parameters :
Name Type Optional
internalId string No
Returns : void
Protected Abstract saveState
saveState()
Returns : void
Public updateDatasetOptions
updateDatasetOptions(options: T, internalId: string)
Parameters :
Name Type Optional
options T No
internalId string No
Returns : void
import { EventEmitter } from '@angular/core';

import { DatasetOptions } from '../model/internal/options';

export abstract class DatasetService<T extends DatasetOptions | DatasetOptions[]> {

    public datasetIds: string[] = [];

    public datasetOptions: Map<string, T> = new Map();

    public datasetIdsChanged: EventEmitter<string[]> = new EventEmitter();

    /**
     * Adds the dataset to the selection
     *
     * @param internalId
     * @param [options]
     * @returns Successfull added the dataset.
     */
    public async addDataset(internalId: string, options?: T): Promise<boolean> {
        if (this.datasetIds.indexOf(internalId) < 0) {
            this.datasetIds.push(internalId);
            if (options) {
                this.datasetOptions.set(internalId, options);
            } else {
                this.datasetOptions.set(internalId, this.createStyles(internalId));
            }
            this.saveState();
        } else if (options instanceof Array) {
            const temp = (this.datasetOptions.get(internalId) as DatasetOptions[]);
            options.forEach((e) => temp.push(e));
            this.saveState();
        }
        this.datasetIdsChanged.emit(this.datasetIds);
        return true;
    }

    public removeAllDatasets() {
        this.datasetIds.length = 0;
        this.datasetOptions.clear();
        this.datasetIdsChanged.emit(this.datasetIds);
        this.saveState();
    }

    public removeDataset(internalId: string) {
        const datasetIdx = this.datasetIds.indexOf(internalId);
        if (datasetIdx > -1) {
            this.datasetIds.splice(datasetIdx, 1);
            this.datasetOptions.delete(internalId);
        }
        this.datasetIdsChanged.emit(this.datasetIds);
        this.saveState();
    }

    public hasDatasets(): boolean {
        return this.datasetIds.length > 0;
    }

    public hasDataset(id: string): boolean {
        return this.datasetIds.indexOf(id) >= 0;
    }

    public updateDatasetOptions(options: T, internalId: string) {
        this.datasetOptions.set(internalId, options);
        this.saveState();
    }

    protected abstract createStyles(internalId: string): T;

    protected abstract saveState(): void;

    protected abstract loadState(): void;

}

result-matching ""

    No results matching ""