@codetectonics/mantle 0.0.2 → 0.0.4

package/esm2015/lib/services/chart.service.js

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { ObjectService } from './object.service';
+import { COLUMN_CHART } from '../config/charts/column-chart.data';
+import { GANTT_CHART } from '../config/charts/gantt-chart.data';
+import { PIE_CHART } from '../config/charts/pie-chart.data';
+import { PROGRESS_BAR_CHART } from '../config/charts/progress-bar-chart.data';
+import { SPLINE_CHART } from '../config/charts/spline-chart.data';
+import * as i0 from "@angular/core";
+import * as i1 from "./object.service";
+export class ChartService {
+    constructor(objectService) {
+        this.objectService = objectService;
+    }
+    mergeChartConfig(chartConfig, domainConfig, widgetConfig) {
+        let config = this.objectService.deepMerge(chartConfig, domainConfig);
+        if (widgetConfig) {
+            config = this.objectService.deepMerge(config, widgetConfig);
+        }
+        return config;
+    }
+    columnChart(domainConfig, widgetConfig) {
+        return this.mergeChartConfig(COLUMN_CHART, domainConfig, widgetConfig);
+    }
+    ganttChart(domainConfig, widgetConfig) {
+        return this.mergeChartConfig(GANTT_CHART, domainConfig, widgetConfig);
+    }
+    pieChart(domainConfig, widgetConfig) {
+        return this.mergeChartConfig(PIE_CHART, domainConfig, widgetConfig);
+    }
+    progressBarChart(domainConfig, widgetConfig) {
+        return this.mergeChartConfig(PROGRESS_BAR_CHART, domainConfig, widgetConfig);
+    }
+    splineChart(domainConfig, widgetConfig) {
+        return this.mergeChartConfig(SPLINE_CHART, domainConfig, widgetConfig);
+    }
+}
+ChartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartService, deps: [{ token: i1.ObjectService }], target: i0.ɵɵFactoryTarget.Injectable });
+ChartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ObjectService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/confirmation.service.js

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { MatDialog, MatDialogConfig } from "@angular/material/dialog";
+import { DeleteConfirmationDialogComponent } from '../components/widgets/delete-confirmation-dialog/delete-confirmation-dialog.component';
+import { SaveConfirmationDialogComponent } from '../components/widgets/save-confirmation-dialog/save-confirmation-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class ConfirmationService {
+    constructor(dialog) {
+        this.dialog = dialog;
+    }
+    confirmSave(onConfirmation, configData = {}) {
+        const dialogConfig = new MatDialogConfig();
+        dialogConfig.data = configData;
+        dialogConfig.minWidth = '400px';
+        dialogConfig.maxWidth = '80%';
+        dialogConfig.position = { right: '8px', bottom: '8px' };
+        dialogConfig.autoFocus = false;
+        dialogConfig.panelClass = 'confirmation-dialog';
+        let dialogRef = this.dialog.open(SaveConfirmationDialogComponent, dialogConfig);
+        dialogRef.afterClosed().subscribe(onConfirmation);
+    }
+    confirmDeletion(onConfirmation, configData = {}) {
+        const dialogConfig = new MatDialogConfig();
+        dialogConfig.data = configData;
+        dialogConfig.minWidth = '400px';
+        dialogConfig.maxWidth = '80%';
+        dialogConfig.position = { right: '8px', bottom: '8px' };
+        dialogConfig.autoFocus = false;
+        let dialogRef = this.dialog.open(DeleteConfirmationDialogComponent, dialogConfig);
+        dialogRef.afterClosed().subscribe((res) => {
+            if (!res || !res.confirmed)
+                return;
+            onConfirmation(res.deletionAction);
+        });
+    }
+}
+ConfirmationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfirmationService, deps: [{ token: i1.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfirmationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfirmationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfirmationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/current-user.service.js

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import { tap, retryWhen, delay } from 'rxjs/operators';
+import { AngularTokenService } from 'angular-token';
+import * as moment from 'moment';
+import { ArrayService } from './array.service';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-token";
+import * as i2 from "@angular/router";
+import * as i3 from "./array.service";
+export class CurrentUserService {
+    constructor(tokenService, router, arrayService) {
+        this.tokenService = tokenService;
+        this.router = router;
+        this.arrayService = arrayService;
+        this.sessionData = new BehaviorSubject({});
+        this.sessionData.next(this.getSessionData());
+        this.sessionData.subscribe((sessionData) => {
+            if (sessionData)
+                localStorage.setItem('sessionData', JSON.stringify(sessionData));
+            else
+                localStorage.removeItem("sessionData");
+        });
+    }
+    signIn(signInData, onSuccess, onFailure) {
+        this.tokenService.signIn(signInData).subscribe((response) => {
+            this.sessionData.next(response.data);
+            this.setLatestPasswordCheckTime();
+            if (onSuccess)
+                onSuccess(response);
+        }, (response) => {
+            if (onFailure)
+                onFailure(response);
+        });
+    }
+    validateToken(onValid, onInvalid) {
+        this.tokenService.validateToken().pipe(retryWhen(errors => errors.pipe(delay(1000), tap(response => {
+            if (!response.status.toString().startsWith('5')) {
+                throw response;
+            }
+        })))).subscribe((response) => {
+            this.sessionData.next(response.data);
+            if (onValid)
+                onValid(response);
+        }, (response) => {
+            if (onInvalid)
+                onInvalid(response);
+            this.signOut();
+        });
+    }
+    updatePassword(updatePasswordData, onSuccess, onFailure) {
+        this.tokenService.updatePassword(updatePasswordData).subscribe((response) => {
+            if (onSuccess)
+                onSuccess(response);
+        }, (response) => {
+            if (onFailure)
+                onFailure(response);
+        });
+    }
+    resetPassword(resetPasswordData, onSuccess, onFailure) {
+        this.tokenService.resetPassword(resetPasswordData).subscribe((response) => {
+            if (onSuccess)
+                onSuccess(response);
+        }, (response) => {
+            if (onFailure)
+                onFailure(response);
+        });
+    }
+    signOut(callback) {
+        this.tokenService.signOut().subscribe((response) => {
+            if (callback)
+                callback();
+            this.clearSessionData();
+            this.router.navigateByUrl('sign-in');
+        }, (response) => {
+            if (callback)
+                callback();
+            this.clearSessionData();
+            this.router.navigateByUrl('sign-in');
+        });
+    }
+    isSignedIn() {
+        return this.tokenService.userSignedIn();
+    }
+    getSessionData() {
+        return JSON.parse(localStorage.getItem('sessionData')) || {};
+    }
+    clearSessionData() {
+        this.sessionData.next(undefined);
+    }
+    getId() {
+        return this.getSessionData().id;
+    }
+    changePassword() {
+        this.router.navigateByUrl('change-password');
+    }
+    getPermissions() {
+        return this.getSessionData().permissions || [];
+    }
+    hasFeatureAccess(feature, action = 'Read') {
+        return this.arrayService.hasItemWithAttributes(this.getPermissions(), { feature: feature, action: action });
+    }
+    setLatestPasswordCheckTime() {
+        let now = moment().format('YYYY-MM-DD HH:mm:ss');
+        localStorage.setItem('latestPasswordCheckTime', now);
+    }
+    getLatestPasswordCheckTime() {
+        return localStorage.getItem('latestPasswordCheckTime');
+    }
+}
+CurrentUserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CurrentUserService, deps: [{ token: i1.AngularTokenService }, { token: i2.Router }, { token: i3.ArrayService }], target: i0.ɵɵFactoryTarget.Injectable });
+CurrentUserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CurrentUserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CurrentUserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AngularTokenService }, { type: i2.Router }, { type: i3.ArrayService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"current-user.service.js","sourceRoot":"","sources":["../../../../../projects/mantle/src/lib/services/current-user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { BehaviorSubject } from 'rxjs';\nimport { tap, retryWhen, delay } from 'rxjs/operators';\nimport { AngularTokenService, ResetPasswordData, SignInData, UpdatePasswordData } from 'angular-token';\nimport * as moment from 'moment';\nimport { ArrayService } from './array.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class CurrentUserService {\n\n  public sessionData: BehaviorSubject<any> = new BehaviorSubject<any>({});\n\n  constructor(protected tokenService: AngularTokenService, protected router: Router,\n              protected arrayService: ArrayService) {\n    this.sessionData.next(this.getSessionData());\n    this.sessionData.subscribe((sessionData: any) => {\n      if (sessionData) localStorage.setItem('sessionData', JSON.stringify(sessionData));\n      else localStorage.removeItem(\"sessionData\");\n    });\n  }\n\n  signIn(signInData: SignInData, onSuccess?: (res: any) => void, onFailure?: (res: any) => void) {\n    this.tokenService.signIn(signInData).subscribe(\n      (response: any) => {\n        this.sessionData.next(response.data);\n        this.setLatestPasswordCheckTime();\n        if (onSuccess) onSuccess(response);\n      },\n      (response: any) => {\n        if (onFailure) onFailure(response);\n      }\n    );\n  }\n\n  validateToken(onValid?: (res: any) => void, onInvalid?: (res: any) => void) {\n    this.tokenService.validateToken().pipe(\n      retryWhen(errors =>\n        errors.pipe(\n          delay(1000),\n          tap(response => {\n            if (!response.status.toString().startsWith('5')) {\n              throw response;\n            }\n          })\n        )\n      )\n    ).subscribe(\n      (response: any) => {\n        this.sessionData.next(response.data);\n        if (onValid) onValid(response);\n      },\n      (response: any) => {\n        if (onInvalid) onInvalid(response);\n        this.signOut();\n      }\n    );\n  }\n\n  updatePassword(updatePasswordData: UpdatePasswordData, onSuccess?: (res: any) => void, onFailure?: (res: any) => void) {\n    this.tokenService.updatePassword(updatePasswordData).subscribe(\n      (response: any) => {\n        if (onSuccess) onSuccess(response);\n      },\n      (response: any) => {\n        if (onFailure) onFailure(response);\n      }\n    );\n  }\n\n  resetPassword(resetPasswordData: ResetPasswordData, onSuccess?: (res: any) => void, onFailure?: (res: any) => void) {\n    this.tokenService.resetPassword(resetPasswordData).subscribe(\n      (response: any) => {\n        if (onSuccess) onSuccess(response);\n      },\n      (response: any) => {\n        if (onFailure) onFailure(response);\n      }\n    );\n  }\n\n  signOut(callback?: () => void) {\n    this.tokenService.signOut().subscribe(\n      (response: any) => {\n        if (callback) callback();\n        this.clearSessionData();\n        this.router.navigateByUrl('sign-in');\n      },\n      (response: any) => {\n        if (callback) callback();\n        this.clearSessionData();\n        this.router.navigateByUrl('sign-in');\n      }\n    );\n  }\n\n  isSignedIn() {\n    return this.tokenService.userSignedIn();\n  }\n\n  getSessionData() {\n    return JSON.parse(localStorage.getItem('sessionData')!) || {};\n  }\n\n  clearSessionData() {\n    this.sessionData.next(undefined);\n  }\n\n  getId() {\n    return this.getSessionData().id;\n  }\n\n  changePassword() {\n    this.router.navigateByUrl('change-password');\n  }\n\n  getPermissions() {\n    return this.getSessionData().permissions || [];\n  }\n\n  public hasFeatureAccess(feature: string, action: string = 'Read') {\n    return this.arrayService.hasItemWithAttributes(\n      this.getPermissions(), { feature: feature, action: action }\n    );\n  }\n\n  setLatestPasswordCheckTime() {\n    let now = moment().format('YYYY-MM-DD HH:mm:ss');\n    localStorage.setItem('latestPasswordCheckTime', now);\n  }\n\n  getLatestPasswordCheckTime() {\n    return localStorage.getItem('latestPasswordCheckTime');\n  }\n\n}\n"]}

package/esm2015/lib/services/dynamic-form.service.js

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class DynamicFormField {
+    constructor(options) {
+        this.label = options.label;
+        this.attr = options.attr;
+        this.type = options.type;
+        this.options = options.options || {};
+        this.default = options.default;
+        this.required = !!options.required;
+        this.disabled = !!options.disabled;
+        this.hidden = !!options.hidden;
+    }
+}
+export class DynamicFormService {
+    constructor() { }
+    toFormGroup(data = {}, formGroup = new FormGroup({})) {
+        Object.keys(data).forEach(attr => {
+            let formControl = new FormControl(data[attr] || undefined);
+            formGroup.addControl(attr, formControl);
+        });
+        return formGroup;
+    }
+    generateFormInitData(fields) {
+        return fields.reduce((result, field) => {
+            result[field.attr] = field.default;
+            return result;
+        }, {});
+    }
+    transformFormValue(formValue) {
+        formValue = Object.assign({}, formValue);
+        Object.keys(formValue).forEach((key) => {
+            if (Array.isArray(formValue[key])) {
+                formValue[key] = formValue[key].map((nestedFormValue) => {
+                    return this.transformFormValue(nestedFormValue);
+                });
+            }
+            else if (formValue[key] && formValue[key].hasOwnProperty('signed_id')) {
+                formValue[key] = formValue[key].signed_id;
+            }
+            if (key.startsWith('dynamic_attributes.')) {
+                formValue['dynamic_attributes'] || (formValue['dynamic_attributes'] = {});
+                formValue['dynamic_attributes'][key] = formValue[key];
+                delete formValue[key];
+            }
+        });
+        return formValue;
+    }
+}
+DynamicFormService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicFormService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/feature-config.service.js

@@ -0,0 +1,240 @@
+import { EventEmitter } from '@angular/core';
+import { MatDialogConfig } from "@angular/material/dialog";
+import { finalize } from 'rxjs/operators';
+import { DialogDetailsComponent } from '../components/details/dialog-details/dialog-details.component';
+import { DialogFormComponent } from '../components/form/dialog-form/dialog-form.component';
+export class FeatureConfigService {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.sessionData = {};
+        this.webRtcEvents = new EventEmitter();
+        this.listContentChangeEvents = new EventEmitter();
+        this.isCommitInProgress = false;
+        this.webApiBaseUrl = (_a = config.webApi) === null || _a === void 0 ? void 0 : _a.baseUrl;
+        this.webApiService = (_b = config.webApi) === null || _b === void 0 ? void 0 : _b.service;
+        this.webRtcChannel = (_c = config.webRtc) === null || _c === void 0 ? void 0 : _c.channel;
+        this.webRtcService = (_d = config.webRtc) === null || _d === void 0 ? void 0 : _d.service;
+        this.feature = (_e = config.authorisation) === null || _e === void 0 ? void 0 : _e.feature;
+        this.currentUserService = (_f = config.authorisation) === null || _f === void 0 ? void 0 : _f.service;
+        (_g = this.currentUserService) === null || _g === void 0 ? void 0 : _g.sessionData.subscribe(sessionData => { this.sessionData = sessionData; });
+        this.router = (_h = config.routing) === null || _h === void 0 ? void 0 : _h.service;
+        this.dialog = (_j = config.dialog) === null || _j === void 0 ? void 0 : _j.service;
+        this.confirmationService = (_k = config.confirmation) === null || _k === void 0 ? void 0 : _k.service;
+        this.onInit();
+    }
+    onInit() { }
+    // Override this method in your domain-service if you would like to use it.
+    noun() {
+        return '';
+    }
+    /*
+     * PARENT COMPONENT
+     */
+    setParentComponent(parentComponent) {
+        this.parentComponent = parentComponent;
+    }
+    refreshParentComponent() {
+        this.parentComponent.loadData();
+    }
+    /*
+     * WEB API INTERFACE
+     */
+    getList(params, headers = {}) {
+        return this.webApiService.get(this.webApiBaseUrl, params.toHttpParams(), headers);
+    }
+    get(id, params = {}, headers = {}) {
+        return this.webApiService.get(`${this.webApiBaseUrl}/${id}`, params, headers);
+    }
+    getNew(params = {}, headers = {}) {
+        return this.webApiService.get(`${this.webApiBaseUrl}/new`, params, headers);
+    }
+    create(params, headers = {}) {
+        this.isCommitInProgress = true;
+        let observable = this.webApiService.create(this.webApiBaseUrl, params, headers);
+        return observable.pipe(finalize(() => {
+            this.isCommitInProgress = false;
+        }));
+    }
+    getEdit(id, params = {}, headers = {}) {
+        return this.webApiService.get(`${this.webApiBaseUrl}/${id}/edit`, params, headers);
+    }
+    update(id, params, headers = {}) {
+        this.isCommitInProgress = true;
+        let observable = this.webApiService.update(`${this.webApiBaseUrl}/${id}`, params, headers);
+        return observable.pipe(finalize(() => {
+            this.isCommitInProgress = false;
+        }));
+    }
+    destroy(id, params = {}, headers = {}) {
+        this.isCommitInProgress = true;
+        return this.webApiService.destroy(`${this.webApiBaseUrl}/${id}`, params, headers).pipe(finalize(() => {
+            this.isCommitInProgress = false;
+        }));
+    }
+    downloadList(format, filename, params = {}, headers = {}) {
+        return this.webApiService.download(`${this.webApiBaseUrl}.${format}`, filename, params, headers);
+    }
+    download(id, format, filename, params = {}, headers = {}) {
+        return this.webApiService.download(`${this.webApiBaseUrl}/${id}.${format}`, filename, params, headers);
+    }
+    /*
+     * WEB RTC INTERFACE
+     */
+    connectWebRtc() {
+        var _a;
+        this.webRtcConnection = (_a = this.webRtcService) === null || _a === void 0 ? void 0 : _a.connect();
+        this.webRtcConnection.subscribe({ channel: this.webRtcChannel }, {
+            received: (data) => {
+                this.webRtcEvents.emit(data);
+            }
+        });
+    }
+    disconnectWebRtc() {
+        if (this.webRtcConnection)
+            this.webRtcConnection.disconnect();
+    }
+    /*
+     * AUTHORISATION
+     */
+    canRead() {
+        if (!this.feature)
+            return true;
+        return this.currentUserService.hasFeatureAccess(this.feature, 'Read');
+    }
+    canWrite() {
+        if (!this.feature)
+            return true;
+        return this.currentUserService.hasFeatureAccess(this.feature, 'Write');
+    }
+    authorise(action) {
+        if (action == 'Write')
+            return this.canWrite();
+        else
+            return this.canRead();
+    }
+    /*
+     * ROUTING
+     */
+    openRoute(route) {
+        this.router.navigateByUrl(route);
+    }
+    /*
+     * DIALOG
+     */
+    openDetailDialog(detailPageService, title, record) {
+        const dialogConfig = new MatDialogConfig();
+        dialogConfig.data = {
+            detailPageService: detailPageService,
+            title: title,
+            id: record.id
+        };
+        dialogConfig.width = '80%';
+        dialogConfig.autoFocus = false;
+        let dialogRef = this.dialog.open(DialogDetailsComponent, dialogConfig);
+        dialogRef.afterClosed().subscribe((response) => {
+            if (response)
+                this.listContentChangeEvents.emit();
+        });
+    }
+    openFormDialog(formPageService, title, record = {}, initData = {}) {
+        const dialogConfig = new MatDialogConfig();
+        dialogConfig.data = {
+            formPageService: formPageService,
+            title: title,
+            id: record.id,
+            initData: initData
+        };
+        dialogConfig.width = '80%';
+        dialogConfig.autoFocus = false;
+        let dialogRef = this.dialog.open(DialogFormComponent, dialogConfig);
+        dialogRef.afterClosed().subscribe((response) => {
+            if (response)
+                this.listContentChangeEvents.emit();
+        });
+    }
+    /*
+     * DETAILS PAGE CONFIG
+     */
+    // Override this method in you domain-service if you would like to use it.
+    onDetailContentLoaded(content) { }
+    // Override this method in your domain-service if you would like to use it.
+    detailPageExportOptions() {
+        return [];
+    }
+    // Override this method in your domain-service if you would like to use it.
+    detailPageSectionActions(sectionSlug) {
+        return [];
+    }
+    // Override this method in your domain-service if you would like to use it.
+    additionalDetailPageButtons(record) {
+        return [];
+    }
+    deletionOptions() {
+        return {
+            message: `Do you want to delete this ${this.noun()}?`,
+            buttons: [
+                {
+                    label: 'Delete',
+                    onClick: (id) => {
+                        return this.destroy(id);
+                    }
+                }
+            ]
+        };
+    }
+    delete(id, onDeleteConfirmed, onSuccess, onFailure) {
+        this.confirmationService.confirmDeletion((deletionAction) => {
+            onDeleteConfirmed();
+            deletionAction(id).subscribe(res => {
+                this.onDeleteSuccess(res);
+                onSuccess(res);
+            }, res => {
+                this.onDeleteFailure(res.error);
+                onFailure(res.error);
+            });
+        }, this.deletionOptions());
+    }
+    // Override this method in you domain-service if you would like to use it.
+    onDeleteSuccess(response) { }
+    // Override this method in you domain-service if you would like to use it.
+    onDeleteFailure(response) { }
+    /*
+     * FORM PAGE CONFIG
+     */
+    // Override this method in you domain-service if you would like to use it.
+    onFormContentLoaded(content) { }
+    // Override this method in you domain-service if you would like to use it.
+    onFormValueChanged(pageContent, formValue) { }
+    ;
+    // Override this method in you domain-service if you would like to use it.
+    additionalFormPageButtons(record) {
+        return [];
+    }
+    save(id, value, onSuccess, onFailure) {
+        this.beforeSave(value);
+        let responseObservable = id ? this.update(id, value) : this.create(value);
+        responseObservable.subscribe(res => {
+            this.onSaveSuccess(res);
+            onSuccess(res);
+        }, res => {
+            this.onSaveFailure(res.error);
+            onFailure(res.error);
+        });
+    }
+    // Override this method in you domain-service if you would like to use it.
+    beforeSave(value) { }
+    // Override this method in you domain-service if you would like to use it.
+    onSaveSuccess(response) { }
+    // Override this method in you domain-service if you would like to use it.
+    onSaveFailure(response) { }
+    /*
+     *  LIST PAGE CONFIG
+     */
+    listPageExportOptions() {
+        return [];
+    }
+    listPageBulkExportOptions() {
+        return [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-config.service.js","sourceRoot":"","sources":["../../../../../projects/mantle/src/lib/services/feature-config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from '@angular/core';\nimport { MatDialog, MatDialogConfig } from \"@angular/material/dialog\";\nimport { Router } from '@angular/router';\nimport { Observable } from 'rxjs';\nimport { finalize } from 'rxjs/operators';\nimport { AuthorisableFeatureService } from '../services/interfaces/authorisable-feature.service';\nimport { ConfirmationService } from '../services/confirmation.service';\nimport { CurrentUserService } from '../services/current-user.service';\nimport { DetailPageService } from '../services/interfaces/detail-page.service';\nimport { FormPageService } from '../services/interfaces/form-page.service';\nimport { WebApiCrudAdapter } from '../services/adapters/web-api-crud.adapter';\nimport { WebsocketAdapter } from '../services/adapters/websocket.adapter';\nimport { WebApiService } from '../services/web-api.service';\nimport { WebsocketService } from '../services/websocket.service';\nimport { DetailPageButton } from '../services/interfaces/detail-page.service';\nimport { DetailPageExportOption } from '../services/interfaces/detail-page.service';\nimport { DialogDetailsComponent } from '../components/details/dialog-details/dialog-details.component';\nimport { DialogFormComponent } from '../components/form/dialog-form/dialog-form.component';\nimport { DynamicDetailsContent } from '../data-structures/dynamic-layout.structure';\nimport { DynamicFormContent } from '../data-structures/dynamic-layout.structure';\nimport { FormPageButton } from '../services/interfaces/form-page.service';\nimport { ListPageBulkExportOption } from '../services/interfaces/list-page.service';\nimport { ListPageExportOption } from '../services/interfaces/list-page.service';\nimport { WebApiDeleteResponse } from '../services/adapters/web-api-crud.adapter';\nimport { WebApiDetailsResponse } from '../services/adapters/web-api-crud.adapter';\nimport { WebApiFormResponse } from '../services/adapters/web-api-crud.adapter';\nimport { WebApiListRequest } from '../services/adapters/web-api-crud.adapter';\nimport { WebApiListResponse } from '../services/adapters/web-api-crud.adapter';\nimport { WebApiSaveResponse } from '../services/adapters/web-api-crud.adapter';\n\nexport class FeatureConfigService implements WebApiCrudAdapter, WebsocketAdapter, AuthorisableFeatureService {\n\n  private parentComponent: any;\n  protected webApiBaseUrl: string;\n  protected webApiService: WebApiService;\n  private webRtcChannel: string;\n  protected webRtcService: WebsocketService;\n  protected feature: string;\n  protected currentUserService: CurrentUserService;\n  protected sessionData: any = {};\n  protected router: Router;\n  protected dialog: MatDialog;\n  protected confirmationService: ConfirmationService;\n\n  private webRtcConnection: any;\n  public webRtcEvents: EventEmitter<any> = new EventEmitter<any>();\n\n  public listContentChangeEvents: EventEmitter<any> = new EventEmitter<any>();\n\n  public isCommitInProgress: boolean = false;\n\n  constructor(config: any) {\n    this.webApiBaseUrl = config.webApi?.baseUrl;\n    this.webApiService = config.webApi?.service;\n    this.webRtcChannel = config.webRtc?.channel;\n    this.webRtcService = config.webRtc?.service;\n    this.feature = config.authorisation?.feature;\n    this.currentUserService = config.authorisation?.service;\n    this.currentUserService?.sessionData.subscribe(sessionData => { this.sessionData = sessionData; });\n    this.router = config.routing?.service;\n    this.dialog = config.dialog?.service;\n    this.confirmationService = config.confirmation?.service;\n    this.onInit();\n  }\n\n  onInit() { }\n\n  // Override this method in your domain-service if you would like to use it.\n  noun(): string {\n    return '';\n  }\n\n  /*\n   * PARENT COMPONENT\n   */\n\n  setParentComponent(parentComponent: any): void {\n    this.parentComponent = parentComponent;\n  }\n\n  refreshParentComponent() {\n    this.parentComponent.loadData();\n  }\n\n  /*\n   * WEB API INTERFACE\n   */\n\n  getList(params: WebApiListRequest, headers: any = {}): Observable<WebApiListResponse> {\n    return this.webApiService.get(this.webApiBaseUrl, params.toHttpParams(), headers) as Observable<WebApiListResponse>;\n  }\n\n  get(id: string, params: any = {}, headers: any = {}): Observable<WebApiDetailsResponse> {\n    return this.webApiService.get(`${this.webApiBaseUrl}/${id}`, params, headers) as Observable<WebApiDetailsResponse>;\n  }\n\n  getNew(params: any = {}, headers: any = {}): Observable<WebApiFormResponse> {\n    return this.webApiService.get(`${this.webApiBaseUrl}/new`, params, headers) as Observable<WebApiFormResponse>;\n  }\n\n  create(params: any, headers: any = {}): Observable<WebApiSaveResponse> {\n    this.isCommitInProgress = true;\n    let observable = this.webApiService.create(this.webApiBaseUrl, params, headers) as Observable<WebApiSaveResponse>;\n    return observable.pipe(\n      finalize(() => {\n        this.isCommitInProgress = false;\n      })\n    );\n  }\n\n  getEdit(id: string, params: any = {}, headers: any = {}): Observable<WebApiFormResponse> {\n    return this.webApiService.get(`${this.webApiBaseUrl}/${id}/edit`, params, headers) as Observable<WebApiFormResponse>;\n  }\n\n  update(id: string, params: any, headers: any = {}): Observable<WebApiSaveResponse> {\n    this.isCommitInProgress = true;\n    let observable = this.webApiService.update(`${this.webApiBaseUrl}/${id}`, params, headers) as Observable<WebApiSaveResponse>;\n    return observable.pipe(\n      finalize(() => {\n        this.isCommitInProgress = false;\n      })\n    );\n  }\n\n  destroy(id: string, params: any = {}, headers: any = {}): Observable<any> {\n    this.isCommitInProgress = true;\n    return this.webApiService.destroy(`${this.webApiBaseUrl}/${id}`, params, headers).pipe(\n      finalize(() => {\n        this.isCommitInProgress = false;\n      })\n    );\n  }\n\n  downloadList(format: string, filename: string, params: any = {}, headers: any = {}): Observable<any> {\n    return this.webApiService.download(`${this.webApiBaseUrl}.${format}`, filename, params, headers);\n  }\n\n  download(id: string, format: string, filename: string, params: any = {}, headers: any = {}): Observable<any> {\n    return this.webApiService.download(`${this.webApiBaseUrl}/${id}.${format}`, filename, params, headers);\n  }\n\n  /*\n   * WEB RTC INTERFACE\n   */\n\n  connectWebRtc(): void {\n    this.webRtcConnection = this.webRtcService?.connect();\n    this.webRtcConnection.subscribe({ channel: this.webRtcChannel }, {\n      received: (data: any) => {\n        this.webRtcEvents.emit(data);\n      }\n    });\n  }\n\n  disconnectWebRtc() {\n    if (this.webRtcConnection) this.webRtcConnection.disconnect();\n  }\n\n  /*\n   * AUTHORISATION\n   */\n\n  canRead(): boolean {\n    if (!this.feature) return true;\n    return this.currentUserService.hasFeatureAccess(this.feature, 'Read');\n  }\n\n  canWrite(): boolean {\n    if (!this.feature) return true;\n    return this.currentUserService.hasFeatureAccess(this.feature, 'Write');\n  }\n\n  authorise(action: string): boolean {\n    if (action == 'Write') return this.canWrite();\n    else return this.canRead();\n  }\n\n  /*\n   * ROUTING\n   */\n\n  openRoute(route: string) {\n    this.router.navigateByUrl(route);\n  }\n\n  /*\n   * DIALOG\n   */\n\n  openDetailDialog(detailPageService: DetailPageService, title: string, record: any) {\n    const dialogConfig = new MatDialogConfig();\n    dialogConfig.data = {\n      detailPageService: detailPageService,\n      title: title,\n      id: record.id\n    };\n    dialogConfig.width = '80%';\n    dialogConfig.autoFocus = false;\n\n    let dialogRef = this.dialog.open(DialogDetailsComponent, dialogConfig);\n\n    dialogRef.afterClosed().subscribe((response: any) => {\n      if (response) this.listContentChangeEvents.emit();\n    });\n  }\n\n  openFormDialog(formPageService: FormPageService, title: string, record: any = {}, initData: any = {}) {\n    const dialogConfig = new MatDialogConfig();\n    dialogConfig.data = {\n      formPageService: formPageService,\n      title: title,\n      id: record.id,\n      initData: initData\n    };\n    dialogConfig.width = '80%';\n    dialogConfig.autoFocus = false;\n\n    let dialogRef = this.dialog.open(DialogFormComponent, dialogConfig);\n\n    dialogRef.afterClosed().subscribe((response: any) => {\n      if (response) this.listContentChangeEvents.emit();\n    });\n  }\n\n  /*\n   * DETAILS PAGE CONFIG\n   */\n\n  // Override this method in you domain-service if you would like to use it.\n  onDetailContentLoaded(content: DynamicDetailsContent) { }\n\n  // Override this method in your domain-service if you would like to use it.\n  detailPageExportOptions(): DetailPageExportOption[] {\n    return [];\n  }\n\n  // Override this method in your domain-service if you would like to use it.\n  detailPageSectionActions(sectionSlug: string): any[] {\n    return [];\n  }\n\n  // Override this method in your domain-service if you would like to use it.\n  additionalDetailPageButtons(record: any): DetailPageButton[] {\n    return [];\n  }\n\n  deletionOptions(): any {\n    return {\n      message: `Do you want to delete this ${this.noun()}?`,\n      buttons: [\n        {\n          label: 'Delete',\n          onClick: (id: string) => {\n            return this.destroy(id);\n          }\n        }\n      ]\n    }\n  }\n\n  delete(id: string, onDeleteConfirmed: () => void, onSuccess: (response: WebApiDeleteResponse) => void, onFailure: (response: WebApiDeleteResponse) => void) {\n    this.confirmationService.confirmDeletion(\n      (deletionAction: (id: string) => Observable<any>) => {\n        onDeleteConfirmed();\n\n        deletionAction(id).subscribe(\n          res => {\n            this.onDeleteSuccess(res);\n            onSuccess(res);\n          },\n          res => {\n            this.onDeleteFailure(res.error);\n            onFailure(res.error);\n          }\n        );\n      },\n      this.deletionOptions()\n    );\n  }\n\n  // Override this method in you domain-service if you would like to use it.\n  onDeleteSuccess(response: WebApiSaveResponse) { }\n\n  // Override this method in you domain-service if you would like to use it.\n  onDeleteFailure(response: WebApiSaveResponse) { }\n\n  /*\n   * FORM PAGE CONFIG\n   */\n\n  // Override this method in you domain-service if you would like to use it.\n  onFormContentLoaded(content: DynamicFormContent) { }\n\n  // Override this method in you domain-service if you would like to use it.\n  onFormValueChanged(pageContent: DynamicFormContent, formValue: any) { };\n\n  // Override this method in you domain-service if you would like to use it.\n  additionalFormPageButtons(record: any): FormPageButton[] {\n    return [];\n  }\n\n  save(id: string | undefined, value: any, onSuccess: (response: WebApiSaveResponse) => void, onFailure: (response: WebApiSaveResponse) => void) {\n    this.beforeSave(value);\n\n    let responseObservable = id ? this.update(id, value) : this.create(value);\n\n    responseObservable.subscribe(\n      res => {\n        this.onSaveSuccess(res);\n        onSuccess(res);\n      },\n      res => {\n        this.onSaveFailure(res.error);\n        onFailure(res.error);\n      }\n    );\n  }\n\n  // Override this method in you domain-service if you would like to use it.\n  beforeSave(value: any) { }\n\n  // Override this method in you domain-service if you would like to use it.\n  onSaveSuccess(response: WebApiSaveResponse) { }\n\n  // Override this method in you domain-service if you would like to use it.\n  onSaveFailure(response: WebApiSaveResponse) { }\n\n  /*\n   *  LIST PAGE CONFIG\n   */\n\n  listPageExportOptions(): ListPageExportOption[] {\n    return [];\n  }\n\n  listPageBulkExportOptions(): ListPageBulkExportOption[] {\n    return [];\n  }\n}\n"]}

package/esm2015/lib/services/interfaces/authorisable-feature.service.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaXNhYmxlLWZlYXR1cmUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21hbnRsZS9zcmMvbGliL3NlcnZpY2VzL2ludGVyZmFjZXMvYXV0aG9yaXNhYmxlLWZlYXR1cmUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBBdXRob3Jpc2FibGVGZWF0dXJlU2VydmljZSB7XG5cbiAgY2FuUmVhZCgpOiBib29sZWFuO1xuICBjYW5Xcml0ZSgpOiBib29sZWFuO1xuICBhdXRob3Jpc2UoYWN0aW9uOiBzdHJpbmcpOiBib29sZWFuO1xuXG59XG4iXX0=

package/esm2015/lib/services/interfaces/dashboard-page.service.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGFzaGJvYXJkLXBhZ2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21hbnRsZS9zcmMvbGliL3NlcnZpY2VzL2ludGVyZmFjZXMvZGFzaGJvYXJkLXBhZ2Uuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgRHluYW1pY0xheW91dEdyaWREaW1lbnNpb25zIH0gZnJvbSAnLi4vLi4vZGF0YS1zdHJ1Y3R1cmVzL2R5bmFtaWMtbGF5b3V0LnN0cnVjdHVyZSc7XG5pbXBvcnQgeyBTY3JlZW5TaXplTWFwIH0gZnJvbSAnLi4vLi4vbW9kZWxzL3NjcmVlbi1zaXplLW1hcC5tb2RlbCc7XG5pbXBvcnQgeyBEYXNoYm9hcmRXaWRnZXRTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvaW50ZXJmYWNlcy9kYXNoYm9hcmQtd2lkZ2V0LnNlcnZpY2UnXG5cbmV4cG9ydCBpbnRlcmZhY2UgRGFzaGJvYXJkUGFnZVNlY3Rpb24ge1xuXG4gIHNlY3Rpb25TbHVnOiBzdHJpbmc7XG4gIHNlY3Rpb25EaW1lbnNpb25zOiBTY3JlZW5TaXplTWFwPER5bmFtaWNMYXlvdXRHcmlkRGltZW5zaW9ucz47XG4gIGRhc2hib2FyZFdpZGdldFNlcnZpY2VzOiBEYXNoYm9hcmRXaWRnZXRTZXJ2aWNlW107XG5cbn1cblxuZXhwb3J0IGludGVyZmFjZSBEYXNoYm9hcmRQYWdlU2VydmljZSB7XG5cbiAgZ2V0V2lkZ2V0SXRlbXMocGFyYW1zOiBhbnkpOiBPYnNlcnZhYmxlPGFueT47XG4gIGRhc2hib2FyZFNlY3Rpb25zKCk6IERhc2hib2FyZFBhZ2VTZWN0aW9uW107XG5cbn1cbiJdfQ==

package/esm2015/lib/services/interfaces/dashboard-widget.service.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGFzaGJvYXJkLXdpZGdldC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWFudGxlL3NyYy9saWIvc2VydmljZXMvaW50ZXJmYWNlcy9kYXNoYm9hcmQtd2lkZ2V0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tIFwicnhqc1wiO1xuaW1wb3J0IHsgRHluYW1pY0Zvcm1GaWVsZCB9IGZyb20gJy4uLy4uL3NlcnZpY2VzL2R5bmFtaWMtZm9ybS5zZXJ2aWNlJztcbmltcG9ydCB7IER5bmFtaWNMYXlvdXRHcmlkQ2VsbERpbWVuc2lvbnMsIER5bmFtaWNMYXlvdXRHcmlkRGltZW5zaW9ucyB9IGZyb20gJy4uLy4uL2RhdGEtc3RydWN0dXJlcy9keW5hbWljLWxheW91dC5zdHJ1Y3R1cmUnO1xuaW1wb3J0IHsgU2NyZWVuU2l6ZU1hcCB9IGZyb20gJy4uLy4uL21vZGVscy9zY3JlZW4tc2l6ZS1tYXAubW9kZWwnO1xuXG5leHBvcnQgaW50ZXJmYWNlIERhc2hib2FyZFdpZGdldEl0ZW1Db25maWcge1xuXG4gIGxhYmVsOiBzdHJpbmc7XG4gIHNsdWc6IHN0cmluZztcbiAgdHlwZTogc3RyaW5nO1xuICBzaXplOiBTY3JlZW5TaXplTWFwPER5bmFtaWNMYXlvdXRHcmlkQ2VsbERpbWVuc2lvbnM+O1xuICBjb25maWd1cmF0aW9uOiBhbnk7XG5cbn1cblxuZXhwb3J0IGludGVyZmFjZSBXaWRnZXRFeHBvcnRPcHRpb24ge1xuXG4gIGxhYmVsOiBzdHJpbmc7XG4gIGV4cG9ydChwYXJhbXM6IGFueSk6IE9ic2VydmFibGU8YW55PjtcblxufVxuXG5leHBvcnQgaW50ZXJmYWNlIERhc2hib2FyZFdpZGdldEJ1dHRvbiB7XG5cbiAgbGFiZWw6IHN0cmluZztcbiAgY29sb3I/OiAncHJpbWFyeScgfCAnYWNjZW50JyB8ICd3YXJuJztcbiAgc3R5bGluZz86IGFueTtcbiAgZGlzYWJsZWQ6IGJvb2xlYW47XG4gIG9uQ2xpY2s6IChkYXRhPzogYW55KSA9PiB2b2lkO1xuXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGFzaGJvYXJkV2lkZ2V0U2VydmljZSB7XG5cbiAgc2x1Zzogc3RyaW5nO1xuICBpY29uOiBzdHJpbmc7XG4gIHNob3dNZW51QnV0dG9uOiBib29sZWFuO1xuICB3aWRnZXREaW1lbnNpb25zOiBTY3JlZW5TaXplTWFwPER5bmFtaWNMYXlvdXRHcmlkRGltZW5zaW9ucz47XG5cbiAgd2lkZ2V0U2l6ZSgpOiBTY3JlZW5TaXplTWFwPER5bmFtaWNMYXlvdXRHcmlkQ2VsbERpbWVuc2lvbnM+O1xuICB3aWRnZXRJdGVtc0NvbmZpZygpOiBEYXNoYm9hcmRXaWRnZXRJdGVtQ29uZmlnW107XG4gIHdpZGdldEV4cG9ydE9wdGlvbnMoKTogV2lkZ2V0RXhwb3J0T3B0aW9uW107XG4gIGFkZGl0aW9uYWxXaWRnZXRCdXR0b25zKHdpZGdldENvbmZpZz86IGFueSk6IERhc2hib2FyZFdpZGdldEJ1dHRvbltdO1xuICB3aWRnZXRTZWFyY2hGaWVsZHMoKTogRHluYW1pY0Zvcm1GaWVsZFtdO1xuICBkZWZhdWx0T3B0aW9ucygpOiBhbnk7XG5cbn1cbiJdfQ==

package/esm2015/lib/services/interfaces/detail-page.service.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/interfaces/export-page.service.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LXBhZ2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21hbnRsZS9zcmMvbGliL3NlcnZpY2VzL2ludGVyZmFjZXMvZXhwb3J0LXBhZ2Uuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgV2ViQXBpRm9ybVJlc3BvbnNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvYWRhcHRlcnMvd2ViLWFwaS1jcnVkLmFkYXB0ZXInO1xuXG5leHBvcnQgaW50ZXJmYWNlIEV4cG9ydFBhZ2VTZXJ2aWNlIHtcblxuICBnZXROZXcoKTogT2JzZXJ2YWJsZTxXZWJBcGlGb3JtUmVzcG9uc2U+O1xuICBleHBvcnQocGFyYW1zOiBhbnkpOiBPYnNlcnZhYmxlPGFueT47XG5cbn1cbiJdfQ==