@schneideress/dashboardframework 0.0.1

package/esm2015/lib/ra-dashboard-area/ra.dashboard.area.js

@@ -0,0 +1,258 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Input, Component, NgZone } from '@angular/core';
+import { RaDashboardService } from '../ra.dashboard.service';
+import { RADashboardEventBus } from '../ra.dashbard.event.bus';
+import { RAEvent } from '../ra.event.enum';
+import { GridsterConfigDefaultSettings } from '../ra.gridster.config';
+export class RADashboardArea {
+    /**
+     * @param {?} dashboardService
+     * @param {?} ngZone
+     */
+    constructor(dashboardService, ngZone) {
+        this.dashboardService = dashboardService;
+        this.ngZone = ngZone;
+        this.widgetList = Array();
+        this.gridheight = 300;
+        this.widgetHeight = 20;
+        this.widgetWidth = 50;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        /**
+         * To override default configuration values to the gridster control
+         * @type {?}
+         */
+        let areaContext = this;
+        this.options = GridsterConfigDefaultSettings;
+        this.options.itemChangeCallback = (/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            areaContext.setAreaHeight();
+        });
+    }
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    ngOnChanges(changes) {
+        if (changes.raDashboardEventBus && changes.raDashboardEventBus.currentValue != changes.raDashboardEventBus.previousValue) {
+            this.conifgAddClick = this.raDashboardEventBus.subscribe(RAEvent.ConfigAddClick).subscribe((/**
+             * @param {?} e
+             * @return {?}
+             */
+            (e) => {
+                this.ngZone.run((/**
+                 * @return {?}
+                 */
+                () => {
+                    this.addWidget(e);
+                }));
+            }));
+        }
+        if (this.raDashboardEventBus && this.userDashboardId && this.areaKey) {
+            this.loadWidgets(this.userDashboardId, this.areaKey);
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.conifgAddClick.unsubscribe();
+    }
+    /**
+     * To retrieve widgets based on userDashboardid and area name
+     * @param {?} userDashboarId
+     * @param {?} areaKey
+     * @return {?}
+     */
+    loadWidgets(userDashboarId, areaKey) {
+        /** @type {?} */
+        let widgetInfo = (/** @type {?} */ ({
+            dashboardId: userDashboarId.toString(),
+            dashboardAreaKey: areaKey
+        }));
+        /** @type {?} */
+        let widgets = this.dashboardService.getWidgetsByDashboardArea(widgetInfo, this.appConfig).subscribe((/**
+         * @param {?} widgets
+         * @return {?}
+         */
+        widgets => {
+            if (widgets)
+                this.widgetList = this.mapObjectListToGridsterItemList(widgets);
+        }));
+    }
+    /**
+     * To set Area(Gridster) height dynamically as widgets are added/removed
+     * @return {?}
+     */
+    setAreaHeight() {
+        /** @type {?} */
+        let areaScrollHeight = 0;
+        /** @type {?} */
+        let areaHeight = 0;
+        this.widgetList.forEach((/**
+         * @param {?} t
+         * @return {?}
+         */
+        (t) => {
+            /** @type {?} */
+            let currentHeight = t.y + t.rows;
+            if (currentHeight > areaScrollHeight) {
+                areaScrollHeight = currentHeight;
+            }
+        }));
+        areaHeight = areaScrollHeight * this.options.api.getCurrentRowHeight() + 2;
+        if (areaHeight < 300) {
+            areaHeight = 300;
+        }
+        this.gridheight = areaHeight;
+    }
+    /**
+     * To map IwidgetInfo object to gridsterItem
+     * @param {?} widget
+     * @return {?}
+     */
+    mapObjectsToGridsterItem(widget) {
+        /** @type {?} */
+        let gridsterItem = (/** @type {?} */ ({
+            cols: widget.width,
+            rows: widget.height,
+            x: widget.position_x,
+            y: widget.position_y,
+            widgetInfo: widget
+        }));
+        return gridsterItem;
+    }
+    /**
+     * @param {?} widgetList
+     * @return {?}
+     */
+    mapObjectListToGridsterItemList(widgetList) {
+        /** @type {?} */
+        let widgetArray = Array();
+        widgetList.forEach((/**
+         * @param {?} widget
+         * @return {?}
+         */
+        widget => {
+            widgetArray.push(this.mapObjectsToGridsterItem(widget));
+        }));
+        return widgetArray;
+    }
+    /**
+     * To remove a widget instance from dashboard and to save info in database
+     * @param {?} widgetInstanceId
+     * @return {?}
+     */
+    deleteWidget(widgetInstanceId) {
+        /** @type {?} */
+        let widget = this.widgetList.filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            return item.widgetInfo.widgetInstanceId === widgetInstanceId;
+        }));
+        if (widget.length > 0) {
+            this.widgetList.splice(this.widgetList.indexOf(widget[0]), 1);
+            this.setAreaHeight();
+        }
+    }
+    /**
+     * To add widget instance to the database with the next available position and to make changes in
+     * dashboard area.
+     * @param {?} data
+     * @return {?}
+     */
+    addWidget(data) {
+        /** @type {?} */
+        let widgetid = data.widgetId;
+        data.height = this.widgetHeight;
+        data.width = this.widgetWidth;
+        data.position_x = 0;
+        data.position_y = 0;
+        /** @type {?} */
+        let gridsterItem = this.mapObjectsToGridsterItem(data);
+        gridsterItem = this.options.api.getFirstPossiblePosition(gridsterItem);
+        data.position_x = gridsterItem.x;
+        data.position_y = gridsterItem.y;
+        data.dashboardAreaKey = this.areaKey;
+        data.dashboardId = this.userDashboardId;
+        this.dashboardService.addWidget(data, this.appConfig).subscribe((/**
+         * @param {?} widget
+         * @return {?}
+         */
+        widget => {
+            gridsterItem = this.mapObjectsToGridsterItem(widget);
+            this.widgetList.push(gridsterItem);
+            this.setAreaHeight();
+        }));
+    }
+}
+RADashboardArea.decorators = [
+    { type: Component, args: [{
+                selector: 'ra-dashboard-area',
+                template: "<div #gridWrapper class=\"wrap gridster\" [style.height.px]=\"gridheight\">\r\n<!-- <div #gridWrapper class=\"wrap gridster\"> -->\r\n  <gridster [options]=\"options\" style=\"height:100%;\">\r\n    <gridster-item [item]=\"item\" *ngFor=\"let item of widgetList\">\r\n      <ra-widget-container [app-config]=\"appConfig\" [event-bus]=\"raDashboardEventBus\" (widgetDeleted)=\"deleteWidget($event)\" [data]=\"item\"\r\n        [global-filter]=\"globalFilter\" [widget-instance-id]=\"item.widgetInstanceId\"></ra-widget-container>\r\n    </gridster-item>\r\n  </gridster>\r\n</div>\r\n",
+                styles: ["gridster{width:inherit;background:#f1f1f1;border:1px solid #ccc;resize:height;display:flex;min-height:300px}gridster-item{border:1px solid #ccc;background:#fff!important}.dvheader{width:100%;height:35px;background:#000;color:#fff;padding:7px 3px 5px 6px;text-transform:uppercase}"]
+            }] }
+];
+/** @nocollapse */
+RADashboardArea.ctorParameters = () => [
+    { type: RaDashboardService },
+    { type: NgZone }
+];
+RADashboardArea.propDecorators = {
+    userDashboardId: [{ type: Input, args: ['user-dashboard-id',] }],
+    areaKey: [{ type: Input, args: ['area-key',] }],
+    globalFilter: [{ type: Input, args: ['global-filter',] }],
+    raDashboardEventBus: [{ type: Input, args: ['event-bus',] }],
+    widgetHeight: [{ type: Input, args: ['widget-height',] }],
+    widgetWidth: [{ type: Input, args: ['widget-width',] }],
+    appConfig: [{ type: Input, args: ['app-config',] }]
+};
+if (false) {
+    /** @type {?} */
+    RADashboardArea.prototype.widgetList;
+    /** @type {?} */
+    RADashboardArea.prototype.options;
+    /** @type {?} */
+    RADashboardArea.prototype.gridheight;
+    /**
+     * @type {?}
+     * @private
+     */
+    RADashboardArea.prototype.conifgAddClick;
+    /** @type {?} */
+    RADashboardArea.prototype.userDashboardId;
+    /** @type {?} */
+    RADashboardArea.prototype.areaKey;
+    /** @type {?} */
+    RADashboardArea.prototype.globalFilter;
+    /** @type {?} */
+    RADashboardArea.prototype.raDashboardEventBus;
+    /** @type {?} */
+    RADashboardArea.prototype.widgetHeight;
+    /** @type {?} */
+    RADashboardArea.prototype.widgetWidth;
+    /** @type {?} */
+    RADashboardArea.prototype.appConfig;
+    /**
+     * @type {?}
+     * @private
+     */
+    RADashboardArea.prototype.dashboardService;
+    /**
+     * @type {?}
+     * @private
+     */
+    RADashboardArea.prototype.ngZone;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ra.dashboard.area.js","sourceRoot":"ng://@schneideress/dashboardframework/","sources":["lib/ra-dashboard-area/ra.dashboard.area.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, OnInit, Component, OnChanges, SimpleChanges, NgZone, OnDestroy } from '@angular/core';\r\n\r\nimport { GridsterConfig, GridsterItem } from '../../gridster/index';\r\nimport { RaDashboardService } from '../ra.dashboard.service';\r\nimport { RADashboardEventBus } from '../ra.dashbard.event.bus';\r\nimport { RAEvent } from '../ra.event.enum';\r\nimport { GridsterConfigDefaultSettings } from '../ra.gridster.config';\r\nimport { IWidgetInfo, IAppConfig } from '@schneideress/widgetframework';\r\n\r\n\r\n@Component({\r\n  selector: 'ra-dashboard-area',\r\n  templateUrl: './ra.dashboard.area.html',\r\n  styleUrls: ['./ra.dashboard.area.css']\r\n})\r\nexport class RADashboardArea implements OnInit, OnChanges, OnDestroy {\r\n\r\n  public widgetList = Array<GridsterItem>();\r\n  public options: GridsterConfig;\r\n  public gridheight: number = 300;\r\n\r\n  private conifgAddClick: any;\r\n\r\n  @Input('user-dashboard-id') userDashboardId: number;\r\n  @Input('area-key') areaKey: string;\r\n  @Input('global-filter') globalFilter: any;\r\n  @Input('event-bus') raDashboardEventBus: RADashboardEventBus;\r\n  @Input('widget-height') widgetHeight: number = 20;\r\n  @Input('widget-width') widgetWidth: number = 50;\r\n  @Input('app-config') appConfig: IAppConfig;\r\n\r\n  constructor(private dashboardService: RaDashboardService,\r\n    private ngZone: NgZone) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    /**To override default configuration values to the gridster control */\r\n    let areaContext = this;\r\n    this.options = GridsterConfigDefaultSettings;\r\n    this.options.itemChangeCallback = function (item: any) {\r\n      areaContext.setAreaHeight();\r\n    }\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes.raDashboardEventBus && changes.raDashboardEventBus.currentValue != changes.raDashboardEventBus.previousValue) {\r\n      this.conifgAddClick = this.raDashboardEventBus.subscribe(RAEvent.ConfigAddClick).subscribe((e) => {\r\n        this.ngZone.run(() => {\r\n          this.addWidget(e);\r\n        });\r\n      });\r\n    }\r\n    if (this.raDashboardEventBus && this.userDashboardId && this.areaKey) {\r\n      this.loadWidgets(this.userDashboardId, this.areaKey);\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.conifgAddClick.unsubscribe();\r\n  }\r\n\r\n  /** To retrieve widgets based on userDashboardid and area name */\r\n  loadWidgets(userDashboarId: number, areaKey: string) {\r\n    let widgetInfo = <IWidgetInfo>{\r\n      dashboardId: userDashboarId.toString(),\r\n      dashboardAreaKey: areaKey\r\n    }\r\n    let widgets = this.dashboardService.getWidgetsByDashboardArea(widgetInfo, this.appConfig).subscribe(widgets => {\r\n      if (widgets)\r\n        this.widgetList = this.mapObjectListToGridsterItemList(widgets);\r\n    });\r\n  }\r\n\r\n  /** To set Area(Gridster) height dynamically as widgets are added/removed */\r\n  setAreaHeight() {\r\n    let areaScrollHeight = 0;\r\n    let areaHeight = 0;\r\n    this.widgetList.forEach((t) => {\r\n      let currentHeight = t.y + t.rows;\r\n      if (currentHeight > areaScrollHeight) {\r\n        areaScrollHeight = currentHeight;\r\n      }\r\n    });\r\n    areaHeight = areaScrollHeight * this.options.api.getCurrentRowHeight() + 2;\r\n    if (areaHeight < 300) {\r\n      areaHeight = 300;\r\n    }\r\n    this.gridheight = areaHeight;\r\n  }\r\n\r\n  /**To map IwidgetInfo object to gridsterItem */\r\n  mapObjectsToGridsterItem(widget: IWidgetInfo) {\r\n    let gridsterItem = <GridsterItem>{\r\n      cols: widget.width,\r\n      rows: widget.height,\r\n      x: widget.position_x,\r\n      y: widget.position_y,\r\n      widgetInfo: widget\r\n    }\r\n    return gridsterItem;\r\n  }\r\n\r\n  mapObjectListToGridsterItemList(widgetList: Array<IWidgetInfo>) {\r\n    let widgetArray = Array<GridsterItem>();\r\n    widgetList.forEach(widget => {\r\n      widgetArray.push(this.mapObjectsToGridsterItem(widget));\r\n    });\r\n    return widgetArray;\r\n  }\r\n\r\n  /** To remove a widget instance from dashboard and to save info in database */\r\n  deleteWidget(widgetInstanceId: any) {\r\n    let widget = this.widgetList.filter(function (item) {\r\n      return item.widgetInfo.widgetInstanceId === widgetInstanceId;\r\n    });\r\n    if (widget.length > 0) {\r\n      this.widgetList.splice(this.widgetList.indexOf(widget[0]), 1);\r\n      this.setAreaHeight();\r\n    }\r\n  }\r\n\r\n  /**To add widget instance to the database with the next available position and to make changes in\r\n   * dashboard area.\r\n   */\r\n  addWidget(data: any) {\r\n    let widgetid = data.widgetId;\r\n    data.height = this.widgetHeight;\r\n    data.width = this.widgetWidth;\r\n    data.position_x = 0;\r\n    data.position_y = 0;\r\n    let gridsterItem = this.mapObjectsToGridsterItem(data);\r\n    gridsterItem = this.options.api.getFirstPossiblePosition(gridsterItem);\r\n    data.position_x = gridsterItem.x;\r\n    data.position_y = gridsterItem.y;\r\n    data.dashboardAreaKey = this.areaKey;\r\n    data.dashboardId = this.userDashboardId;\r\n    this.dashboardService.addWidget(data, this.appConfig).subscribe(widget => {\r\n      gridsterItem = this.mapObjectsToGridsterItem(widget);\r\n      this.widgetList.push(gridsterItem);\r\n      this.setAreaHeight();\r\n    });\r\n  }\r\n\r\n}"]}

package/esm2015/lib/ra-widget-container/ra.widget.container.component.js

@@ -0,0 +1,216 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input, ViewChild, ElementRef, EventEmitter, Output } from '@angular/core';
+import { RaDashboardService } from './../ra.dashboard.service';
+import { RADashboardEventBus } from '../ra.dashbard.event.bus';
+import { RAEvent, RAEventKey } from '../ra.event.enum';
+export class RAWidgetContainer {
+    /**
+     * @param {?} dashboardService
+     */
+    constructor(dashboardService) {
+        this.dashboardService = dashboardService;
+        this.isIEOrEdge = /msie\s|trident\/|edge\//i.test(window.navigator.userAgent);
+        this.widgetDeleted = new EventEmitter();
+    }
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    ngOnChanges(changes) {
+        if (changes.raDashboardEventBus && changes.raDashboardEventBus.currentValue != changes.raDashboardEventBus.previousValue) {
+            this.configChanged = this.raDashboardEventBus.subscribeWithKey(RAEvent.ConfigChanged, RAEventKey.WidgetInstanceId, this.data.widgetInfo.widgetInstanceId.toString()).subscribe((/**
+             * @param {?} e
+             * @return {?}
+             */
+            (e) => {
+                this.configChangeEventHandler(e);
+            }));
+        }
+        if (this.widgetElement && changes.globalFilter.currentValue != changes.globalFilter.previousValue) {
+            this.refreshWidget(this.data.widgetInfo);
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        setTimeout((/**
+         * @return {?}
+         */
+        () => {
+            this.loadWidget(this.data.widgetInfo);
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.configChanged.unsubscribe();
+    }
+    /**
+     * To Edit current widget configuration
+     * @return {?}
+     */
+    editWidget() {
+        this.raDashboardEventBus.publish(RAEvent.WidgetEditClicked, this.data.widgetInfo);
+    }
+    /**
+     * To Delete current widget from DOM
+     * @return {?}
+     */
+    deleteWidget() {
+        this.dashboardService.deleteWidget(this.data.widgetInfo, this.appConfig).subscribe((/**
+         * @param {?} status
+         * @return {?}
+         */
+        status => {
+            /** @type {?} */
+            let response = status;
+            if (true) {
+                this.widgetDeleted.emit(this.data.widgetInfo.widgetInstanceId);
+            }
+        }));
+    }
+    /**
+     * To Move or change position if current widget container
+     * @param {?} widgetInfo
+     * @return {?}
+     */
+    moveWidget(widgetInfo) {
+        this.dashboardService.moveWidget(widgetInfo);
+    }
+    /**
+     * To Copy Current widget with same configuration
+     * @param {?} widgetInfo
+     * @return {?}
+     */
+    copyWidget(widgetInfo) {
+        this.dashboardService.copyWidget(widgetInfo);
+    }
+    /**
+     * To Collapse current widget
+     * @param {?} widgetInfo
+     * @return {?}
+     */
+    collapse(widgetInfo) {
+        this.dashboardService.collapse(widgetInfo);
+    }
+    /**
+     * @param {?} config
+     * @return {?}
+     */
+    configChangeEventHandler(config) {
+        console.log('in config change config');
+        console.log(config);
+        this.data.widgetInfo.widgetConfigInfo.config = config;
+        this.refreshWidget(this.data.widgetInfo);
+        this.updateWidget(this.data.widgetInfo);
+    }
+    /**
+     * @param {?} widgetInfo
+     * @return {?}
+     */
+    updateWidget(widgetInfo) {
+        this.dashboardService.updateWidget(widgetInfo, this.appConfig);
+    }
+    /**
+     * To load external custom element to the widget container
+     * @param {?} widgetInfo
+     * @return {?}
+     */
+    loadWidget(widgetInfo) {
+        /** @type {?} */
+        let widgetConfigFilter = (/** @type {?} */ ({
+            config: widgetInfo.widgetConfigInfo.config,
+            globalFilter: this.globalFilter
+        }));
+        /** @type {?} */
+        let widgetCOntainer = this;
+        this.dashboardService.loadExternalScript(widgetInfo.scriptUrl, (/**
+         * @return {?}
+         */
+        () => {
+            this.widgetElement = document.createElement(widgetInfo.customTag);
+            this.ctlWidget.nativeElement.appendChild(this.widgetElement);
+            setTimeout((/**
+             * @return {?}
+             */
+            () => {
+                widgetCOntainer.widgetElement.loadContent(widgetConfigFilter, this.appConfig);
+            }), 2000);
+        }));
+    }
+    /**
+     * To refresh widget on input config changes
+     * @param {?} widgetInfo
+     * @return {?}
+     */
+    refreshWidget(widgetInfo) {
+        /** @type {?} */
+        let widgetConfigFilter = (/** @type {?} */ ({
+            config: widgetInfo.widgetConfigInfo.config,
+            globalFilter: this.globalFilter
+        }));
+        this.widgetElement.loadContent(widgetConfigFilter, this.appConfig);
+    }
+}
+RAWidgetContainer.decorators = [
+    { type: Component, args: [{
+                selector: 'ra-widget-container',
+                template: "<div class=\"wc-wrapper\">\r\n  <div class=\"wcheader\">\r\n    <div class=\"col-md-12 wc-mover\">\r\n      <div class=\"row\">\r\n        <div class=\"col-md-11 float-left\" style=\"width:96%;\">{{data.widgetInfo.title?data.widgetInfo.title:\"Title\"}}\r\n        </div>\r\n        <div class=\"col-md-1\">\r\n          <div class=\"float-right\">\r\n            <div class=\"dropdown\">\r\n              <div class=\"dropbtn\"> <i class=\"fal fa-cog\"></i></div>\r\n              <div class=\"dropdown-content\">\r\n                <a (click)=\"editWidget()\">Edit</a>\r\n                <a (click)=\"copyWidget(data)\">Copy</a>\r\n                <a (click)=\"moveWidget(data)\">Move</a>\r\n                <a (click)=\"collapse(data)\">Collapse</a>\r\n                <hr class=\"hr\" style=\"\">\r\n                <a (click)=\"deleteWidget()\">Delete</a>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"wcBody\">\r\n    <div class=\"wcBodyBorder\" #ctlWidget></div>\r\n  </div>\r\n</div>\r\n",
+                styles: [".wcheader{width:100%;height:26px;background:#fff;color:#3dcd58;padding:7px 7px 0 6px;font-family:\"Arial Rounded MT\";border-bottom:1px solid;border-color:#fff;font-size:16px}.wc-mover{cursor:all-scroll}.wcBody{padding:8px}.wcBodyBorder{border:1px dashed #e6e2e2}.sp_icon{float:left;margin:0 15% 0 0}.dropbtn{cursor:pointer;color:#42b4e6}.dropdown{display:none;position:relative}.dropdown-content{display:none;position:absolute;right:0;background-color:#f9f9f9;min-width:100px;box-shadow:0 8px 16px 8px rgba(0,0,0,.2);z-index:1;font-size:12px;font-family:\"Arial Rounded MT\"}.dropdown-content a{color:#000;padding:5px 16px;text-decoration:none;display:block;cursor:pointer}.dropdown-content a:hover{background-color:#f1f1f1}.dropdown:hover .dropdown-content,.wc-wrapper:hover .dropdown{display:block}.dropdown:hover .dropbtn{color:#2b7797}.hr{border:0;border-top:1px solid rgba(0,0,0,.1)}"]
+            }] }
+];
+/** @nocollapse */
+RAWidgetContainer.ctorParameters = () => [
+    { type: RaDashboardService }
+];
+RAWidgetContainer.propDecorators = {
+    ctlWidget: [{ type: ViewChild, args: ['ctlWidget', { static: false },] }],
+    widgetInstanceId: [{ type: Input, args: ['widget-instance-id',] }],
+    globalFilter: [{ type: Input, args: ['global-filter',] }],
+    data: [{ type: Input, args: ['data',] }],
+    raDashboardEventBus: [{ type: Input, args: ['event-bus',] }],
+    appConfig: [{ type: Input, args: ['app-config',] }],
+    widgetDeleted: [{ type: Output }]
+};
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    RAWidgetContainer.prototype.widgetElement;
+    /**
+     * @type {?}
+     * @private
+     */
+    RAWidgetContainer.prototype.configChanged;
+    /**
+     * @type {?}
+     * @private
+     */
+    RAWidgetContainer.prototype.isIEOrEdge;
+    /** @type {?} */
+    RAWidgetContainer.prototype.ctlWidget;
+    /** @type {?} */
+    RAWidgetContainer.prototype.widgetInstanceId;
+    /** @type {?} */
+    RAWidgetContainer.prototype.globalFilter;
+    /** @type {?} */
+    RAWidgetContainer.prototype.data;
+    /** @type {?} */
+    RAWidgetContainer.prototype.raDashboardEventBus;
+    /** @type {?} */
+    RAWidgetContainer.prototype.appConfig;
+    /** @type {?} */
+    RAWidgetContainer.prototype.widgetDeleted;
+    /**
+     * @type {?}
+     * @private
+     */
+    RAWidgetContainer.prototype.dashboardService;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ra.widget.container.component.js","sourceRoot":"ng://@schneideress/dashboardframework/","sources":["lib/ra-widget-container/ra.widget.container.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, ViewChild, ElementRef, EventEmitter, Output, OnChanges, SimpleChanges, AfterViewInit, SimpleChange, OnDestroy } from '@angular/core';\r\nimport { RaDashboardService } from './../ra.dashboard.service';\r\nimport { RADashboardEventBus } from '../ra.dashbard.event.bus';\r\nimport { RAEvent, RAEventKey } from '../ra.event.enum';\r\nimport { IAppConfig, IWidgetConfigFilter } from '@schneideress/widgetframework';\r\n\r\n\r\n@Component({\r\n  selector: 'ra-widget-container',\r\n  templateUrl: './ra.widget.container.component.html',\r\n  styleUrls: ['./ra.widget.container.component.css']\r\n})\r\nexport class RAWidgetContainer implements OnChanges, AfterViewInit, OnDestroy {\r\n\r\n  private widgetElement: any;\r\n  private configChanged: any;\r\n  private isIEOrEdge = /msie\\s|trident\\/|edge\\//i.test(window.navigator.userAgent);\r\n\r\n  @ViewChild('ctlWidget', { static: false }) ctlWidget: ElementRef;\r\n\r\n  @Input('widget-instance-id') widgetInstanceId: number;\r\n  @Input('global-filter') globalFilter: any;\r\n  @Input('data') data: any;\r\n  @Input('event-bus') raDashboardEventBus: RADashboardEventBus;\r\n  @Input('app-config') appConfig: IAppConfig;\r\n\r\n  @Output() widgetDeleted = new EventEmitter<string>();\r\n\r\n  constructor(private dashboardService: RaDashboardService) {\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes.raDashboardEventBus && changes.raDashboardEventBus.currentValue != changes.raDashboardEventBus.previousValue) {\r\n      this.configChanged = this.raDashboardEventBus.subscribeWithKey(RAEvent.ConfigChanged, RAEventKey.WidgetInstanceId, this.data.widgetInfo.widgetInstanceId.toString()).subscribe((e) => {\r\n        this.configChangeEventHandler(e);\r\n      });\r\n    }\r\n    if (this.widgetElement && changes.globalFilter.currentValue != changes.globalFilter.previousValue) {\r\n      this.refreshWidget(this.data.widgetInfo);\r\n    }\r\n\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    setTimeout(() => {\r\n      this.loadWidget(this.data.widgetInfo);\r\n    });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.configChanged.unsubscribe();\r\n  }\r\n\r\n\r\n  /** To Edit current widget configuration*/\r\n  public editWidget() {\r\n    this.raDashboardEventBus.publish(RAEvent.WidgetEditClicked, this.data.widgetInfo);\r\n  }\r\n\r\n  /** To Delete current widget from DOM*/\r\n  public deleteWidget() {\r\n    this.dashboardService.deleteWidget(this.data.widgetInfo, this.appConfig).subscribe(status => {\r\n      let response = status;\r\n      if (true) {  \r\n        this.widgetDeleted.emit(this.data.widgetInfo.widgetInstanceId);\r\n      }\r\n    });\r\n  }\r\n\r\n  /** To Move or change position if current widget container*/\r\n  public moveWidget(widgetInfo: any) {\r\n    this.dashboardService.moveWidget(widgetInfo);\r\n  }\r\n\r\n  /** To Copy Current widget with same configuration*/\r\n  public copyWidget(widgetInfo: any) {\r\n    this.dashboardService.copyWidget(widgetInfo);\r\n  }\r\n\r\n  /** To Collapse current widget*/\r\n  public collapse(widgetInfo: any) {\r\n    this.dashboardService.collapse(widgetInfo);\r\n  }\r\n\r\n  public configChangeEventHandler(config) {\r\n    console.log('in config change config');\r\n    console.log(config);\r\n    \r\n    \r\n    this.data.widgetInfo.widgetConfigInfo.config = config;\r\n    this.refreshWidget(this.data.widgetInfo);\r\n    this.updateWidget(this.data.widgetInfo);\r\n  }\r\n\r\n  updateWidget(widgetInfo: any) {\r\n    this.dashboardService.updateWidget(widgetInfo, this.appConfig);\r\n  }\r\n\r\n  /**  To load external custom element to the widget container*/\r\n  loadWidget(widgetInfo: any) {\r\n    let widgetConfigFilter = <IWidgetConfigFilter>{\r\n      config: widgetInfo.widgetConfigInfo.config,\r\n      globalFilter: this.globalFilter\r\n    }\r\n\r\n    let widgetCOntainer = this;\r\n    this.dashboardService.loadExternalScript(widgetInfo.scriptUrl, () => {\r\n      this.widgetElement = document.createElement(widgetInfo.customTag);\r\n      this.ctlWidget.nativeElement.appendChild(this.widgetElement);\r\n      setTimeout(() => {\r\n        widgetCOntainer.widgetElement.loadContent(widgetConfigFilter, this.appConfig);\r\n      }, 2000);\r\n    });\r\n  }\r\n\r\n  /** To refresh widget on input config changes */\r\n  refreshWidget(widgetInfo: any) {\r\n    let widgetConfigFilter = <IWidgetConfigFilter>{\r\n      config: widgetInfo.widgetConfigInfo.config,\r\n      globalFilter: this.globalFilter\r\n    }\r\n    this.widgetElement.loadContent(widgetConfigFilter, this.appConfig);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/ra.base.dashboard.filter.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Input } from '@angular/core';
+/**
+ * @abstract
+ */
+export class RaBaseDashboardFilter {
+    constructor() {
+        this.getAllFilterConfig = (/**
+         * @param {?} async
+         * @return {?}
+         */
+        (async) => {
+            return this.getFilterConfig();
+        });
+    }
+}
+RaBaseDashboardFilter.propDecorators = {
+    getAllFilterConfig: [{ type: Input }]
+};
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    RaBaseDashboardFilter.prototype.getAllFilterConfig;
+    /**
+     * @abstract
+     * @return {?}
+     */
+    RaBaseDashboardFilter.prototype.getFilterConfig = function () { };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmEuYmFzZS5kYXNoYm9hcmQuZmlsdGVyLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNjaG5laWRlcmVzcy9kYXNoYm9hcmRmcmFtZXdvcmsvIiwic291cmNlcyI6WyJsaWIvcmEuYmFzZS5kYXNoYm9hcmQuZmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7O0FBQ3RDLE1BQU0sT0FBZ0IscUJBQXFCO0lBQTNDO1FBRW1CLHVCQUFrQjs7OztRQUFHLENBQUMsS0FBSyxFQUFFLEVBQUU7WUFDOUMsT0FBTyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDaEMsQ0FBQyxFQUFBO0lBSUgsQ0FBQzs7O2lDQU5FLEtBQUs7Ozs7Ozs7SUFBTixtREFFQzs7Ozs7SUFDRCxrRUFBZ0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgUmFCYXNlRGFzaGJvYXJkRmlsdGVyIHtcclxuXHJcbiAgQElucHV0KCkgcHJpdmF0ZSBnZXRBbGxGaWx0ZXJDb25maWcgPSAoYXN5bmMpID0+IHtcclxuICAgIHJldHVybiB0aGlzLmdldEZpbHRlckNvbmZpZygpO1xyXG4gIH1cclxuICBhYnN0cmFjdCBnZXRGaWx0ZXJDb25maWcoKTogYW55O1xyXG5cclxuXHJcbn0iXX0=

package/esm2015/lib/ra.base.dashboard.template.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Input } from '@angular/core';
+/**
+ * @abstract
+ */
+export class RaBaseDashboardTemplate {
+    /**
+     * @param {?} ngZone
+     */
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        this.initialize = (/**
+         * @param {?} eventBus
+         * @param {?} userDashboardId
+         * @param {?} appConfig
+         * @return {?}
+         */
+        (eventBus, userDashboardId, appConfig) => {
+            this.ngZone.run((/**
+             * @return {?}
+             */
+            () => {
+                this.userDashboardId = userDashboardId;
+                this.appConfig = appConfig;
+                this.raDashboardEventBus = eventBus;
+            }));
+            this.init();
+        });
+    }
+}
+RaBaseDashboardTemplate.propDecorators = {
+    dashboardId: [{ type: Input, args: ['dashboard-id',] }],
+    globalFilter: [{ type: Input, args: ['global-filter',] }],
+    initialize: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    RaBaseDashboardTemplate.prototype.userDashboardId;
+    /** @type {?} */
+    RaBaseDashboardTemplate.prototype.raDashboardEventBus;
+    /** @type {?} */
+    RaBaseDashboardTemplate.prototype.appConfig;
+    /** @type {?} */
+    RaBaseDashboardTemplate.prototype.dashboardId;
+    /** @type {?} */
+    RaBaseDashboardTemplate.prototype.globalFilter;
+    /** @type {?} */
+    RaBaseDashboardTemplate.prototype.initialize;
+    /**
+     * @type {?}
+     * @private
+     */
+    RaBaseDashboardTemplate.prototype.ngZone;
+    /**
+     * @abstract
+     * @return {?}
+     */
+    RaBaseDashboardTemplate.prototype.init = function () { };
+}
+//# sourceMappingURL=data:application/json;base64,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