@nova-ui/dashboards
Version:
Nova Dashboards is a framework designed to provide feature developers with a common solution for presenting data coming from various sources within a single view, as well as a set of predefined widget visualizations that are 100% configuration-driven and
145 lines • 22.1 kB
JavaScript
// © 2022 SolarWinds Worldwide, LLC. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import { Inject, Injectable, Optional } from "@angular/core";
import isUndefined from "lodash/isUndefined";
import { Subject } from "rxjs";
import { takeUntil } from "rxjs/operators";
import { EventBus, } from "@nova-ui/bits";
import { DATA_SOURCE_DESTROYED, DATA_SOURCE_OUTPUT, } from "../../configurator/types";
import { PizzagnaService } from "../../pizzagna/services/pizzagna.service";
import { DATA_SOURCE_BUSY, DATA_SOURCE_INVOKED, REFRESH, } from "../../services/types";
import { DATA_SOURCE, PizzagnaLayer, PIZZAGNA_EVENT_BUS, } from "../../types";
import * as i0 from "@angular/core";
import * as i1 from "../../pizzagna/services/pizzagna.service";
import * as i2 from "@nova-ui/bits";
export class DataSourceAdapter {
constructor(eventBus, dataSource, pizzagnaService) {
this.eventBus = eventBus;
this.dataSource = dataSource;
this.pizzagnaService = pizzagnaService;
this.destroy$ = new Subject();
if (!this.dataSource) {
return;
}
this.setupRefreshListener();
this.dataSource.outputsSubject
.pipe(takeUntil(this.destroy$))
.subscribe((event) => this.handleDataSourceUpdate(event));
if (this.dataSource.busy) {
this.dataSource.busy
.pipe(takeUntil(this.destroy$))
.subscribe((busy) => {
this.eventBus.getStream(DATA_SOURCE_BUSY).next({
payload: {
componentId: this.componentId,
busy,
},
});
});
}
}
setupRefreshListener() {
this.eventBus
.getStream(REFRESH)
.pipe(takeUntil(this.destroy$))
.subscribe(() => this.handleRefresh());
}
handleRefresh() {
this.eventBus.getStream(DATA_SOURCE_INVOKED).next({});
this.dataSource.applyFilters();
}
handleDataSourceUpdate(value) {
this.lastValue = isUndefined(value?.result) ? value : value?.result;
this.updateOutput(this.lastValue);
this.eventBus
.getStream(DATA_SOURCE_OUTPUT)
.next({ payload: { componentId: this.componentId, ...value } });
}
ngOnDestroy() {
this.updateOutput(undefined);
const destroyedEvent = {
payload: { componentId: this.componentId },
};
this.eventBus.getStream(DATA_SOURCE_DESTROYED).next(destroyedEvent);
const busyEvent = {
payload: { componentId: this.componentId, busy: false },
};
this.eventBus.getStream(DATA_SOURCE_BUSY).next(busyEvent);
this.destroy$.next();
this.destroy$.complete();
}
updateConfiguration(properties) {
if (properties.componentId) {
this.componentId = properties.componentId;
}
this.updateAdapterProperties(properties);
this.updateDataSourceProperties(properties);
if (typeof this.lastValue !== "undefined") {
this.updateOutput(this.lastValue);
}
}
updateAdapterProperties(properties) {
this.propertyPath = properties.propertyPath;
}
updateDataSourceProperties(properties) {
const dataSourceConfiguration = properties?.dataSource?.properties;
if (this.dataSourceConfiguration !== dataSourceConfiguration) {
this.dataSourceConfiguration = dataSourceConfiguration;
const configurableDataSource = this
.dataSource;
if (configurableDataSource?.updateConfiguration) {
configurableDataSource.updateConfiguration(properties.dataSource?.properties);
}
this.eventBus.getStream(REFRESH).next({});
}
// check if this is the first call of updateConfiguration and there is no dataSource configuration present in the incoming properties
// This results in two initial invocations of the data source, and we should eventually remove it. But, currently,
// widgets sometimes rely on it in order to display their initial data.
if (typeof this.dataSourceConfiguration === "undefined" &&
typeof dataSourceConfiguration === "undefined") {
// using a setTimeout here to give configurable data sources time to receive their configurations before they're invoked
setTimeout(() => this.eventBus.getStream(REFRESH).next({}));
}
}
updateOutput(value) {
this.pizzagnaService.setProperty({
pizzagnaKey: PizzagnaLayer.Data,
componentId: this.componentId,
propertyPath: [this.propertyPath],
}, this.processOutput(value));
}
processOutput(value) {
return value;
}
/** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataSourceAdapter, deps: [{ token: PIZZAGNA_EVENT_BUS }, { token: DATA_SOURCE, optional: true }, { token: i1.PizzagnaService }], target: i0.ɵɵFactoryTarget.Injectable }); }
/** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataSourceAdapter }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataSourceAdapter, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: i2.EventBus, decorators: [{
type: Inject,
args: [PIZZAGNA_EVENT_BUS]
}] }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [DATA_SOURCE]
}] }, { type: i1.PizzagnaService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-source-adapter.js","sourceRoot":"","sources":["../../../../../src/lib/components/providers/data-source-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["// © 2022 SolarWinds Worldwide, LLC. All rights reserved.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to\n//  deal in the Software without restriction, including without limitation the\n//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n//  sell copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n\nimport { Inject, Injectable, OnDestroy, Optional } from \"@angular/core\";\nimport isUndefined from \"lodash/isUndefined\";\nimport { Subject } from \"rxjs\";\nimport { takeUntil } from \"rxjs/operators\";\n\nimport {\n    EventBus,\n    IDataSource,\n    IEvent,\n    IFilteringOutputs,\n} from \"@nova-ui/bits\";\n\nimport {\n    IComponentIdPayload,\n    IDataSourceBusyPayload,\n    IDataSourceOutput,\n} from \"./types\";\nimport {\n    DATA_SOURCE_DESTROYED,\n    DATA_SOURCE_OUTPUT,\n} from \"../../configurator/types\";\nimport { PizzagnaService } from \"../../pizzagna/services/pizzagna.service\";\nimport {\n    DATA_SOURCE_BUSY,\n    DATA_SOURCE_INVOKED,\n    REFRESH,\n} from \"../../services/types\";\nimport {\n    DATA_SOURCE,\n    IConfigurable,\n    IProperties,\n    PizzagnaLayer,\n    PIZZAGNA_EVENT_BUS,\n} from \"../../types\";\n\n@Injectable()\nexport class DataSourceAdapter<T extends IFilteringOutputs = IFilteringOutputs>\n    implements IConfigurable, OnDestroy\n{\n    protected componentId: string;\n    protected lastValue: T;\n    protected readonly destroy$ = new Subject<void>();\n    protected dataSourceConfiguration: Record<string, any>;\n\n    private propertyPath: string;\n\n    constructor(\n        @Inject(PIZZAGNA_EVENT_BUS) public eventBus: EventBus<IEvent>,\n        @Optional() @Inject(DATA_SOURCE) public dataSource: IDataSource<T>,\n        protected pizzagnaService: PizzagnaService\n    ) {\n        if (!this.dataSource) {\n            return;\n        }\n        this.setupRefreshListener();\n\n        this.dataSource.outputsSubject\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: T | IDataSourceOutput<T>) =>\n                this.handleDataSourceUpdate(event)\n            );\n\n        if (this.dataSource.busy) {\n            this.dataSource.busy\n                .pipe(takeUntil(this.destroy$))\n                .subscribe((busy: boolean) => {\n                    this.eventBus.getStream(DATA_SOURCE_BUSY).next({\n                        payload: {\n                            componentId: this.componentId,\n                            busy,\n                        } as IDataSourceBusyPayload,\n                    });\n                });\n        }\n    }\n\n    protected setupRefreshListener(): void {\n        this.eventBus\n            .getStream(REFRESH)\n            .pipe(takeUntil(this.destroy$))\n            .subscribe(() => this.handleRefresh());\n    }\n\n    protected handleRefresh(): void {\n        this.eventBus.getStream(DATA_SOURCE_INVOKED).next({});\n        this.dataSource.applyFilters();\n    }\n\n    protected handleDataSourceUpdate(value: T | IDataSourceOutput<T>): void {\n        this.lastValue = isUndefined(value?.result) ? value : value?.result;\n        this.updateOutput(this.lastValue);\n        this.eventBus\n            .getStream(DATA_SOURCE_OUTPUT)\n            .next({ payload: { componentId: this.componentId, ...value } });\n    }\n\n    public ngOnDestroy(): void {\n        this.updateOutput(undefined);\n\n        const destroyedEvent: IEvent<IComponentIdPayload> = {\n            payload: { componentId: this.componentId },\n        };\n        this.eventBus.getStream(DATA_SOURCE_DESTROYED).next(destroyedEvent);\n\n        const busyEvent: IEvent<IDataSourceBusyPayload> = {\n            payload: { componentId: this.componentId, busy: false },\n        };\n        this.eventBus.getStream(DATA_SOURCE_BUSY).next(busyEvent);\n\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    public updateConfiguration(properties: IProperties): void {\n        if (properties.componentId) {\n            this.componentId = properties.componentId;\n        }\n\n        this.updateAdapterProperties(properties);\n        this.updateDataSourceProperties(properties);\n\n        if (typeof this.lastValue !== \"undefined\") {\n            this.updateOutput(this.lastValue);\n        }\n    }\n\n    protected updateAdapterProperties(properties: IProperties): void {\n        this.propertyPath = properties.propertyPath;\n    }\n\n    protected updateDataSourceProperties(properties: IProperties): void {\n        const dataSourceConfiguration = properties?.dataSource?.properties;\n        if (this.dataSourceConfiguration !== dataSourceConfiguration) {\n            this.dataSourceConfiguration = dataSourceConfiguration;\n            const configurableDataSource = this\n                .dataSource as unknown as IConfigurable;\n            if (configurableDataSource?.updateConfiguration) {\n                configurableDataSource.updateConfiguration(\n                    properties.dataSource?.properties\n                );\n            }\n            this.eventBus.getStream(REFRESH).next({});\n        }\n\n        // check if this is the first call of updateConfiguration and there is no dataSource configuration present in the incoming properties\n        // This results in two initial invocations of the data source, and we should eventually remove it. But, currently,\n        // widgets sometimes rely on it in order to display their initial data.\n        if (\n            typeof this.dataSourceConfiguration === \"undefined\" &&\n            typeof dataSourceConfiguration === \"undefined\"\n        ) {\n            // using a setTimeout here to give configurable data sources time to receive their configurations before they're invoked\n            setTimeout(() => this.eventBus.getStream(REFRESH).next({}));\n        }\n    }\n\n    protected updateOutput(value: T | undefined): void {\n        this.pizzagnaService.setProperty(\n            {\n                pizzagnaKey: PizzagnaLayer.Data,\n                componentId: this.componentId,\n                propertyPath: [this.propertyPath],\n            },\n            this.processOutput(value)\n        );\n    }\n\n    protected processOutput(value: T | undefined): T | undefined {\n        return value;\n    }\n}\n"]}