Merge data comparison feature

@@ -55,6 +55,7 @@
               "node_modules/flot/src/plugins/jquery.flot.pie.js",
               "node_modules/flot/src/plugins/jquery.flot.pie.js",
               "node_modules/flot/src/plugins/jquery.flot.crosshair.js",
               "node_modules/flot/src/plugins/jquery.flot.crosshair.js",
               "node_modules/flot/src/plugins/jquery.flot.stack.js",
               "node_modules/flot/src/plugins/jquery.flot.stack.js",
+              "node_modules/flot/src/plugins/jquery.flot.symbol.js",
               "node_modules/flot.curvedlines/curvedLines.js",
               "node_modules/flot.curvedlines/curvedLines.js",
               "node_modules/tinycolor2/dist/tinycolor-min.js",
               "node_modules/tinycolor2/dist/tinycolor-min.js",
               "node_modules/tooltipster/dist/js/tooltipster.bundle.min.js",
               "node_modules/tooltipster/dist/js/tooltipster.bundle.min.js",

@@ -17,12 +17,15 @@
 import { Observable } from 'rxjs';
 import { Observable } from 'rxjs';
 import { EntityId } from '@app/shared/models/id/entity-id';
 import { EntityId } from '@app/shared/models/id/entity-id';
 import {
 import {
-  WidgetActionDescriptor,
-  widgetType,
+  DataSet,
+  Datasource,
+  DatasourceData,
+  DatasourceType,
+  KeyInfo,
   LegendConfig,
   LegendConfig,
   LegendData,
   LegendData,
-  Datasource,
-  DatasourceData, DataSet, DatasourceType, KeyInfo
+  WidgetActionDescriptor,
+  widgetType
 } from '@shared/models/widget.models';
 } from '@shared/models/widget.models';
 import { TimeService } from '../services/time.service';
 import { TimeService } from '../services/time.service';
 import { DeviceService } from '../http/device.service';
 import { DeviceService } from '../http/device.service';
@@ -36,10 +39,8 @@ import { DatasourceService } from '@core/api/datasource.service';
 import { RafService } from '@core/services/raf.service';
 import { RafService } from '@core/services/raf.service';
 import { EntityAliases } from '@shared/models/alias.models';
 import { EntityAliases } from '@shared/models/alias.models';
 import { EntityInfo } from '@app/shared/models/entity.models';
 import { EntityInfo } from '@app/shared/models/entity.models';
-import { Type } from '@angular/core';
-import { AssetService } from '@core/http/asset.service';
-import { DialogService } from '@core/services/dialog.service';
 import { IDashboardComponent } from '@home/models/dashboard-component.models';
 import { IDashboardComponent } from '@home/models/dashboard-component.models';
+import * as moment_ from 'moment';
 
 
 export interface TimewindowFunctions {
 export interface TimewindowFunctions {
   onUpdateTimewindow: (startTimeMs: number, endTimeMs: number, interval?: number) => void;
   onUpdateTimewindow: (startTimeMs: number, endTimeMs: number, interval?: number) => void;
@@ -200,6 +201,8 @@ export interface WidgetSubscriptionOptions {
   timeWindowConfig?: Timewindow;
   timeWindowConfig?: Timewindow;
   dashboardTimewindow?: Timewindow;
   dashboardTimewindow?: Timewindow;
   legendConfig?: LegendConfig;
   legendConfig?: LegendConfig;
+  comparisonEnabled?: boolean;
+  timeForComparison?: moment_.unitOfTime.DurationConstructor;
   decimals?: number;
   decimals?: number;
   units?: string;
   units?: string;
   callbacks?: WidgetSubscriptionCallbacks;
   callbacks?: WidgetSubscriptionCallbacks;
@@ -227,6 +230,7 @@ export interface IWidgetSubscription {
   hiddenData?: Array<{data: DataSet}>;
   hiddenData?: Array<{data: DataSet}>;
   timeWindowConfig?: Timewindow;
   timeWindowConfig?: Timewindow;
   timeWindow?: WidgetTimewindow;
   timeWindow?: WidgetTimewindow;
+  comparisonTimeWindow?: WidgetTimewindow;
 
 
   alarms?: Array<AlarmInfo>;
   alarms?: Array<AlarmInfo>;
   alarmSource?: Datasource;
   alarmSource?: Datasource;

@@ -22,6 +22,7 @@ import {
   WidgetSubscriptionOptions
   WidgetSubscriptionOptions
 } from '@core/api/widget-api.models';
 } from '@core/api/widget-api.models';
 import {
 import {
+  DataKey,
   DataSet,
   DataSet,
   DataSetHolder,
   DataSetHolder,
   Datasource,
   Datasource,
@@ -36,6 +37,7 @@ import {
 import { HttpErrorResponse } from '@angular/common/http';
 import { HttpErrorResponse } from '@angular/common/http';
 import {
 import {
   createSubscriptionTimewindow,
   createSubscriptionTimewindow,
+  createTimewindowForComparison,
   SubscriptionTimewindow,
   SubscriptionTimewindow,
   Timewindow,
   Timewindow,
   toHistoryTimewindow,
   toHistoryTimewindow,
@@ -52,6 +54,9 @@ import * as deepEqual from 'deep-equal';
 import { EntityId } from '@app/shared/models/id/entity-id';
 import { EntityId } from '@app/shared/models/id/entity-id';
 import { DataKeyType } from '@shared/models/telemetry/telemetry.models';
 import { DataKeyType } from '@shared/models/telemetry/telemetry.models';
 import { entityFields } from '@shared/models/entity.models';
 import { entityFields } from '@shared/models/entity.models';
+import * as moment_ from 'moment';
+
+const moment = moment_;
 
 
 export class WidgetSubscription implements IWidgetSubscription {
 export class WidgetSubscription implements IWidgetSubscription {
 
 
@@ -77,6 +82,10 @@ export class WidgetSubscription implements IWidgetSubscription {
   stateData: boolean;
   stateData: boolean;
   decimals: number;
   decimals: number;
   units: string;
   units: string;
+  comparisonEnabled: boolean;
+  timeForComparison: moment_.unitOfTime.DurationConstructor;
+  comparisonTimeWindow: WidgetTimewindow;
+  timewindowForComparison: SubscriptionTimewindow;
 
 
   alarms: Array<AlarmInfo>;
   alarms: Array<AlarmInfo>;
   alarmSource: Datasource;
   alarmSource: Datasource;
@@ -204,6 +213,13 @@ export class WidgetSubscription implements IWidgetSubscription {
       }
       }
 
 
       this.subscriptionTimewindow = null;
       this.subscriptionTimewindow = null;
+      this.comparisonEnabled = options.comparisonEnabled;
+      if (this.comparisonEnabled) {
+        this.timeForComparison = options.timeForComparison;
+
+        this.comparisonTimeWindow = {};
+        this.timewindowForComparison = null;
+      }
 
 
       this.units = options.units || '';
       this.units = options.units || '';
       this.decimals = isDefined(options.decimals) ? options.decimals : 2;
       this.decimals = isDefined(options.decimals) ? options.decimals : 2;
@@ -345,11 +361,23 @@ export class WidgetSubscription implements IWidgetSubscription {
   }
   }
 
 
   private configureData() {
   private configureData() {
+    const additionalDatasources: Datasource[] = [];
     let dataIndex = 0;
     let dataIndex = 0;
+    let additionalKeysNumber = 0;
     this.datasources.forEach((datasource) => {
     this.datasources.forEach((datasource) => {
+      const additionalDataKeys: DataKey[] = [];
+      let datasourceAdditionalKeysNumber = 0;
       datasource.dataKeys.forEach((dataKey) => {
       datasource.dataKeys.forEach((dataKey) => {
         dataKey.hidden = false;
         dataKey.hidden = false;
         dataKey.pattern = dataKey.label;
         dataKey.pattern = dataKey.label;
+        if (this.comparisonEnabled && dataKey.settings.comparisonSettings && dataKey.settings.comparisonSettings.showValuesForComparison) {
+          datasourceAdditionalKeysNumber++;
+          additionalKeysNumber++;
+          const additionalDataKey = this.ctx.utils.createAdditionalDataKey(dataKey, datasource,
+            this.timeForComparison, this.datasources, additionalKeysNumber);
+          dataKey.settings.comparisonSettings.color = additionalDataKey.color;
+          additionalDataKeys.push(additionalDataKey);
+        }
         const datasourceData: DatasourceData = {
         const datasourceData: DatasourceData = {
           datasource,
           datasource,
           dataKey,
           dataKey,
@@ -379,7 +407,43 @@ export class WidgetSubscription implements IWidgetSubscription {
           this.legendData.data.push(legendKeyData);
           this.legendData.data.push(legendKeyData);
         }
         }
       });
       });
+      if (datasourceAdditionalKeysNumber > 0) {
+        const additionalDatasource: Datasource = deepClone(datasource);
+        additionalDatasource.dataKeys = additionalDataKeys;
+        additionalDatasource.isAdditional = true;
+        additionalDatasources.push(additionalDatasource);
+      }
+    });
+
+    additionalDatasources.forEach((additionalDatasource) => {
+      additionalDatasource.dataKeys.forEach((additionalDataKey) => {
+        const additionalDatasourceData: DatasourceData = {
+          datasource: additionalDatasource,
+          dataKey: additionalDataKey,
+          data: []
+        };
+        this.data.push(additionalDatasourceData);
+        this.hiddenData.push({data: []});
+        if (this.displayLegend) {
+          const additionalLegendKey: LegendKey = {
+            dataKey: additionalDataKey,
+            dataIndex: dataIndex++
+          };
+          this.legendData.keys.push(additionalLegendKey);
+          const additionalLegendKeyData: LegendKeyData = {
+            min: null,
+            max: null,
+            avg: null,
+            total: null,
+            hidden: false
+          };
+          this.legendData.data.push(additionalLegendKeyData);
+        }
+      });
     });
     });
+
+    this.datasources = this.datasources.concat(additionalDatasources);
+
     if (this.displayLegend) {
     if (this.displayLegend) {
       this.legendData.keys = this.legendData.keys.sort((key1, key2) => key1.dataKey.label.localeCompare(key2.dataKey.label));
       this.legendData.keys = this.legendData.keys.sort((key1, key2) => key1.dataKey.label.localeCompare(key2.dataKey.label));
     }
     }
@@ -678,6 +742,9 @@ export class WidgetSubscription implements IWidgetSubscription {
       this.notifyDataLoading();
       this.notifyDataLoading();
       if (this.type === widgetType.timeseries && this.timeWindowConfig) {
       if (this.type === widgetType.timeseries && this.timeWindowConfig) {
         this.updateRealtimeSubscription();
         this.updateRealtimeSubscription();
+        if (this.comparisonEnabled) {
+          this.updateSubscriptionForComparison();
+        }
         if (this.subscriptionTimewindow.fixedWindow) {
         if (this.subscriptionTimewindow.fixedWindow) {
           this.onDataUpdated();
           this.onDataUpdated();
         }
         }
@@ -702,6 +769,17 @@ export class WidgetSubscription implements IWidgetSubscription {
           datasourceIndex: index
           datasourceIndex: index
         };
         };
 
 
+        if (this.comparisonEnabled && datasource.isAdditional) {
+          listener.subscriptionTimewindow = this.timewindowForComparison;
+          listener.updateRealtimeSubscription = () => {
+            this.subscriptionTimewindow = this.updateSubscriptionForComparison();
+            return this.subscriptionTimewindow;
+          };
+          listener.setRealtimeSubscription = () => {
+            this.updateSubscriptionForComparison();
+          };
+        }
+
         let entityFieldKey = false;
         let entityFieldKey = false;
 
 
         for (let a = 0; a < datasource.dataKeys.length; a++) {
         for (let a = 0; a < datasource.dataKeys.length; a++) {
@@ -842,7 +920,7 @@ export class WidgetSubscription implements IWidgetSubscription {
   private updateTimewindow() {
   private updateTimewindow() {
     this.timeWindow.interval = this.subscriptionTimewindow.aggregation.interval || 1000;
     this.timeWindow.interval = this.subscriptionTimewindow.aggregation.interval || 1000;
     if (this.subscriptionTimewindow.realtimeWindowMs) {
     if (this.subscriptionTimewindow.realtimeWindowMs) {
-      this.timeWindow.maxTime = Date.now() + this.timeWindow.stDiff;
+      this.timeWindow.maxTime = moment().valueOf() + this.timeWindow.stDiff;
       this.timeWindow.minTime = this.timeWindow.maxTime - this.subscriptionTimewindow.realtimeWindowMs;
       this.timeWindow.minTime = this.timeWindow.maxTime - this.subscriptionTimewindow.realtimeWindowMs;
     } else if (this.subscriptionTimewindow.fixedWindow) {
     } else if (this.subscriptionTimewindow.fixedWindow) {
       this.timeWindow.maxTime = this.subscriptionTimewindow.fixedWindow.endTimeMs;
       this.timeWindow.maxTime = this.subscriptionTimewindow.fixedWindow.endTimeMs;
@@ -862,6 +940,26 @@ export class WidgetSubscription implements IWidgetSubscription {
     return this.subscriptionTimewindow;
     return this.subscriptionTimewindow;
   }
   }
 
 
+  private updateComparisonTimewindow() {
+    this.comparisonTimeWindow.interval = this.timewindowForComparison.aggregation.interval || 1000;
+    if (this.timewindowForComparison.realtimeWindowMs) {
+      this.comparisonTimeWindow.maxTime = moment(this.timeWindow.maxTime).subtract(1, this.timeForComparison).valueOf();
+      this.comparisonTimeWindow.minTime = this.comparisonTimeWindow.maxTime - this.timewindowForComparison.realtimeWindowMs;
+    } else if (this.timewindowForComparison.fixedWindow) {
+      this.comparisonTimeWindow.maxTime = this.timewindowForComparison.fixedWindow.endTimeMs;
+      this.comparisonTimeWindow.minTime = this.timewindowForComparison.fixedWindow.startTimeMs;
+    }
+  }
+
+  private updateSubscriptionForComparison() {
+    if (!this.subscriptionTimewindow) {
+      this.subscriptionTimewindow = this.updateRealtimeSubscription();
+    }
+    this.timewindowForComparison = createTimewindowForComparison(this.subscriptionTimewindow, this.timeForComparison);
+    this.updateComparisonTimewindow();
+    return this.timewindowForComparison;
+  }
+
   private dataUpdated(sourceData: DataSetHolder, datasourceIndex: number, dataKeyIndex: number, detectChanges: boolean) {
   private dataUpdated(sourceData: DataSetHolder, datasourceIndex: number, dataKeyIndex: number, detectChanges: boolean) {
     for (let x = 0; x < this.datasourceListeners.length; x++) {
     for (let x = 0; x < this.datasourceListeners.length; x++) {
       this.datasources[x].dataReceived = this.datasources[x].dataReceived === true;
       this.datasources[x].dataReceived = this.datasources[x].dataReceived === true;
@@ -892,6 +990,9 @@ export class WidgetSubscription implements IWidgetSubscription {
     if (update) {
     if (update) {
       if (this.subscriptionTimewindow && this.subscriptionTimewindow.realtimeWindowMs) {
       if (this.subscriptionTimewindow && this.subscriptionTimewindow.realtimeWindowMs) {
         this.updateTimewindow();
         this.updateTimewindow();
+        if (this.timewindowForComparison && this.timewindowForComparison.realtimeWindowMs) {
+          this.updateComparisonTimewindow();
+        }
       }
       }
       currentData.data = sourceData.data;
       currentData.data = sourceData.data;
       if (this.caulculateLegendData) {
       if (this.caulculateLegendData) {

@@ -359,6 +359,26 @@ export class UtilsService {
     return dataKey;
     return dataKey;
   }
   }
 
 
+  public createAdditionalDataKey(dataKey: DataKey, datasource: Datasource, timeUnit: string,
+                                 datasources: Datasource[], additionalKeysNumber: number): DataKey {
+    const additionalDataKey = deepClone(dataKey);
+    if (dataKey.settings.comparisonSettings.comparisonValuesLabel) {
+      additionalDataKey.label = this.createLabelFromDatasource(datasource, dataKey.settings.comparisonSettings.comparisonValuesLabel);
+    } else {
+      additionalDataKey.label = dataKey.label + ' ' + this.translate.instant('legend.comparison-time-ago.'+timeUnit);
+    }
+    additionalDataKey.pattern = additionalDataKey.label;
+    if (dataKey.settings.comparisonSettings.color) {
+      additionalDataKey.color = dataKey.settings.comparisonSettings.color;
+    } else {
+      const index = datasources.map((_datasource) => datasource.dataKeys.length)
+        .reduce((previousValue, currentValue) => previousValue + currentValue, 0);
+      additionalDataKey.color = this.getMaterialColor(index + additionalKeysNumber);
+    }
+    additionalDataKey._hash = Math.random();
+    return additionalDataKey;
+  }
+
   public createLabelFromDatasource(datasource: Datasource, pattern: string) {
   public createLabelFromDatasource(datasource: Datasource, pattern: string) {
     let label = pattern;
     let label = pattern;
     if (!datasource) {
     if (!datasource) {

@@ -17,7 +17,8 @@
 // tslint:disable-next-line:no-reference
 // tslint:disable-next-line:no-reference
 /// <reference path="../../../../../../../src/typings/jquery.flot.typings.d.ts" />
 /// <reference path="../../../../../../../src/typings/jquery.flot.typings.d.ts" />
 
 
-import { JsonSettingsSchema, DataKey, DatasourceData } from '@shared/models/widget.models';
+import { JsonSettingsSchema, DataKey, DatasourceData, Datasource } from '@shared/models/widget.models';
+import * as moment_ from 'moment';
 
 
 export declare type ChartType = 'line' | 'pie' | 'bar' | 'state' | 'graph';
 export declare type ChartType = 'line' | 'pie' | 'bar' | 'state' | 'graph';
 
 
@@ -29,6 +30,7 @@ export declare type TbFlotTicksFormatterFunction = (t: number, a?: TbFlotPlotAxi
 
 
 export interface TbFlotSeries extends DatasourceData, JQueryPlotSeriesOptions {
 export interface TbFlotSeries extends DatasourceData, JQueryPlotSeriesOptions {
   dataKey: TbFlotDataKey;
   dataKey: TbFlotDataKey;
+  xaxisIndex?: number;
   yaxisIndex?: number;
   yaxisIndex?: number;
   yaxis?: number;
   yaxis?: number;
 }
 }
@@ -50,6 +52,7 @@ export interface TbFlotAxisOptions extends JQueryPlotAxisOptions {
 }
 }
 
 
 export interface TbFlotPlotDataSeries extends JQueryPlotDataSeries {
 export interface TbFlotPlotDataSeries extends JQueryPlotDataSeries {
+  datasource?: Datasource;
   dataKey?: TbFlotDataKey;
   dataKey?: TbFlotDataKey;
   percent?: number;
   percent?: number;
 }
 }
@@ -93,6 +96,12 @@ export interface TbFlotXAxisSettings {
   color: boolean;
   color: boolean;
 }
 }
 
 
+export interface TbFlotSecondXAxisSettings {
+  axisPosition: TbFlotXAxisPosition;
+  showLabels: boolean;
+  title: string;
+}
+
 export interface TbFlotYAxisSettings {
 export interface TbFlotYAxisSettings {
   min: number;
   min: number;
   max: number;
   max: number;
@@ -112,16 +121,23 @@ export interface TbFlotBaseSettings {
   tooltipIndividual: boolean;
   tooltipIndividual: boolean;
   tooltipCumulative: boolean;
   tooltipCumulative: boolean;
   tooltipValueFormatter: string;
   tooltipValueFormatter: string;
+  hideZeros: boolean;
   grid: TbFlotGridSettings;
   grid: TbFlotGridSettings;
   xaxis: TbFlotXAxisSettings;
   xaxis: TbFlotXAxisSettings;
   yaxis: TbFlotYAxisSettings;
   yaxis: TbFlotYAxisSettings;
 }
 }
 
 
-export interface TbFlotGraphSettings extends TbFlotBaseSettings {
+export interface TbFlotComparisonSettings {
+  comparisonEnabled: boolean;
+  timeForComparison: moment_.unitOfTime.DurationConstructor;
+  xaxisSecond: TbFlotSecondXAxisSettings;
+}
+
+export interface TbFlotGraphSettings extends TbFlotBaseSettings, TbFlotComparisonSettings {
   smoothLines: boolean;
   smoothLines: boolean;
 }
 }
 
 
-export interface TbFlotBarSettings extends TbFlotBaseSettings {
+export interface TbFlotBarSettings extends TbFlotBaseSettings, TbFlotComparisonSettings {
   defaultBarWidth: number;
   defaultBarWidth: number;
 }
 }
 
 
@@ -140,11 +156,17 @@ export interface TbFlotPieSettings {
 }
 }
 
 
 export declare type TbFlotYAxisPosition = 'left' | 'right';
 export declare type TbFlotYAxisPosition = 'left' | 'right';
+export declare type TbFlotXAxisPosition = 'top' | 'bottom';
 
 
 export interface TbFlotKeySettings {
 export interface TbFlotKeySettings {
+  excludeFromStacking: boolean;
   showLines: boolean;
   showLines: boolean;
   fillLines: boolean;
   fillLines: boolean;
   showPoints: boolean;
   showPoints: boolean;
+  showPointShape: string;
+  pointShapeFormatter: string;
+  showPointsLineWidth: number;
+  showPointsRadius: number;
   lineWidth: number;
   lineWidth: number;
   tooltipValueFormatter: string;
   tooltipValueFormatter: string;
   showSeparateAxis: boolean;
   showSeparateAxis: boolean;
@@ -218,6 +240,11 @@ export function flotSettingsSchema(chartType: ChartType): JsonSettingsSchema {
     type: 'string',
     type: 'string',
     default: ''
     default: ''
   };
   };
+  properties.hideZeros = {
+    title: 'Hide zero/false values from tooltip',
+    type: 'boolean',
+    default: false
+  };
 
 
   properties.grid = {
   properties.grid = {
     title: 'Grid settings',
     title: 'Grid settings',
@@ -345,6 +372,7 @@ export function flotSettingsSchema(chartType: ChartType): JsonSettingsSchema {
     key: 'tooltipValueFormatter',
     key: 'tooltipValueFormatter',
     type: 'javascript'
     type: 'javascript'
   });
   });
+  schema.form.push('hideZeros');
   schema.form.push({
   schema.form.push({
     key: 'grid',
     key: 'grid',
     items: [
     items: [
@@ -395,9 +423,112 @@ export function flotSettingsSchema(chartType: ChartType): JsonSettingsSchema {
       }
       }
     ]
     ]
   });
   });
+  if (chartType === 'graph' || chartType === 'bar') {
+    schema.groupInfoes = [{
+      formIndex: 0,
+      GroupTitle: 'Common Settings'
+    }];
+    schema.form = [schema.form];
+    schema.schema.properties = {...schema.schema.properties, ...chartSettingsSchemaForComparison.schema.properties};
+    schema.schema.required = schema.schema.required.concat(chartSettingsSchemaForComparison.schema.required);
+    schema.form.push(chartSettingsSchemaForComparison.form);
+    schema.groupInfoes.push({
+      formIndex: schema.groupInfoes.length,
+      GroupTitle:'Comparison Settings'
+    });
+  }
   return schema;
   return schema;
 }
 }
 
 
+const chartSettingsSchemaForComparison: JsonSettingsSchema = {
+  schema: {
+    title: 'Comparison Settings',
+    type: 'object',
+    properties: {
+      comparisonEnabled: {
+        title: 'Enable comparison',
+        type: 'boolean',
+        default: false
+      },
+      timeForComparison: {
+        title: 'Time to show historical data',
+        type: 'string',
+        default: 'months'
+      },
+      xaxisSecond: {
+        title: 'Second X axis',
+        type: 'object',
+        properties: {
+          axisPosition: {
+            title: 'Axis position',
+            type: 'string',
+            default: 'top'
+          },
+          showLabels: {
+            title: 'Show labels',
+            type: 'boolean',
+            default: true
+          },
+          title: {
+            title: 'Axis title',
+            type: 'string',
+            default: null
+          }
+        }
+      }
+    },
+    required: []
+  },
+  form: [
+    'comparisonEnabled',
+    {
+      key: 'timeForComparison',
+      type: 'rc-select',
+      multiple: false,
+      items: [
+        {
+          value: 'days',
+          label: 'Day ago'
+        },
+        {
+          value: 'weeks',
+          label: 'Week ago'
+        },
+        {
+          value: 'months',
+          label: 'Month ago (default)'
+        },
+        {
+          value: 'years',
+          label: 'Year ago'
+        }
+      ]
+    },
+    {
+      key: 'xaxisSecond',
+      items: [
+        {
+          key: 'xaxisSecond.axisPosition',
+          type: 'rc-select',
+          multiple: false,
+          items: [
+            {
+              value: 'top',
+              label: 'Top (default)'
+            },
+            {
+              value: 'bottom',
+              label: 'Bottom'
+            }
+          ]
+        },
+        'xaxisSecond.showLabels',
+        'xaxisSecond.title',
+      ]
+    }
+  ]
+};
+
 export const flotPieSettingsSchema: JsonSettingsSchema = {
 export const flotPieSettingsSchema: JsonSettingsSchema = {
     schema: {
     schema: {
       type: 'object',
       type: 'object',
@@ -481,12 +612,17 @@ export const flotPieSettingsSchema: JsonSettingsSchema = {
     ]
     ]
 };
 };
 
 
-export function flotDatakeySettingsSchema(defaultShowLines: boolean): JsonSettingsSchema {
-  return {
+export function flotDatakeySettingsSchema(defaultShowLines: boolean, chartType: ChartType): JsonSettingsSchema {
+  const schema: JsonSettingsSchema = {
     schema: {
     schema: {
       type: 'object',
       type: 'object',
       title: 'DataKeySettings',
       title: 'DataKeySettings',
       properties: {
       properties: {
+        excludeFromStacking: {
+          title: 'Exclude from stacking(available in "Stacking" mode)',
+          type: 'boolean',
+          default: false
+        },
         showLines: {
         showLines: {
           title: 'Show lines',
           title: 'Show lines',
           type: 'boolean',
           type: 'boolean',
@@ -502,10 +638,29 @@ export function flotDatakeySettingsSchema(defaultShowLines: boolean): JsonSettin
           type: 'boolean',
           type: 'boolean',
           default: false
           default: false
         },
         },
-        lineWidth: {
-          title: 'Line width',
+        showPointShape: {
+          title: 'Select point shape:',
+          type: 'string',
+          default: 'circle'
+        },
+        pointShapeFormatter: {
+          title: 'Point shape format function, f(ctx, x, y, radius, shadow)',
+          type: 'string',
+          default: 'var size = radius * Math.sqrt(Math.PI) / 2;\n' +
+            'ctx.moveTo(x - size, y - size);\n' +
+            'ctx.lineTo(x + size, y + size);\n' +
+            'ctx.moveTo(x - size, y + size);\n' +
+            'ctx.lineTo(x + size, y - size);'
+        },
+        showPointsLineWidth: {
+          title: 'Line width of points',
           type: 'number',
           type: 'number',
-          default: null
+          default: 5
+        },
+        showPointsRadius: {
+          title: 'Radius of points',
+          type: 'number',
+          default: 3
         },
         },
         tooltipValueFormatter: {
         tooltipValueFormatter: {
           title: 'Tooltip value format function, f(value)',
           title: 'Tooltip value format function, f(value)',
@@ -556,10 +711,48 @@ export function flotDatakeySettingsSchema(defaultShowLines: boolean): JsonSettin
       required: ['showLines', 'fillLines', 'showPoints']
       required: ['showLines', 'fillLines', 'showPoints']
     },
     },
     form: [
     form: [
+      'excludeFromStacking',
       'showLines',
       'showLines',
       'fillLines',
       'fillLines',
       'showPoints',
       'showPoints',
       {
       {
+        key: 'showPointShape',
+        type: 'rc-select',
+        multiple: false,
+        items: [
+          {
+            value: 'circle',
+            label: 'Circle'
+          },
+          {
+            value: 'cross',
+            label: 'Cross'
+          },
+          {
+            value: 'diamond',
+            label: 'Diamond'
+          },
+          {
+            value: 'square',
+            label: 'Square'
+          },
+          {
+            value: 'triangle',
+            label: 'Triangle'
+          },
+          {
+            value: 'custom',
+            label: 'Custom function'
+          }
+        ]
+      },
+      {
+        key: 'pointShapeFormatter',
+        type: 'javascript'
+      },
+      'showPointsLineWidth',
+      'showPointsRadius',
+      {
         key: 'tooltipValueFormatter',
         key: 'tooltipValueFormatter',
         type: 'javascript'
         type: 'javascript'
       },
       },
@@ -590,4 +783,43 @@ export function flotDatakeySettingsSchema(defaultShowLines: boolean): JsonSettin
       }
       }
     ]
     ]
   };
   };
+
+  const properties = schema.schema.properties;
+  if (chartType === 'graph' || chartType === 'bar') {
+    properties.comparisonSettings = {
+      title: 'Comparison Settings',
+      type: 'object',
+      properties: {
+        showValuesForComparison: {
+          title: 'Show historical values for comparison',
+          type: 'boolean',
+          default: true
+        },
+        comparisonValuesLabel: {
+          title: 'Historical values label',
+          type: 'string',
+          default: ''
+        },
+        color: {
+          title: 'Color',
+          type: 'string',
+          default: ''
+        }
+      },
+      required: ['showValuesForComparison']
+    };
+    schema.form.push({
+      key: 'comparisonSettings',
+      items: [
+        'comparisonSettings.showValuesForComparison',
+        'comparisonSettings.comparisonValuesLabel',
+        {
+          key: 'comparisonSettings.color',
+          type: 'color'
+        }
+      ]
+    });
+  }
+
+  return schema;
 }
 }

@@ -41,6 +41,7 @@ import * as tinycolor_ from 'tinycolor2';
 import { AggregationType } from '@shared/models/time/time.models';
 import { AggregationType } from '@shared/models/time/time.models';
 import { CancelAnimationFrame } from '@core/services/raf.service';
 import { CancelAnimationFrame } from '@core/services/raf.service';
 import Timeout = NodeJS.Timeout;
 import Timeout = NodeJS.Timeout;
+import { UtilsService } from '@core/services/utils.service';
 
 
 const tinycolor = tinycolor_;
 const tinycolor = tinycolor_;
 const moment = moment_;
 const moment = moment_;
@@ -56,6 +57,7 @@ export class TbFlot {
   private readonly yAxisTickFormatter: TbFlotTicksFormatterFunction;
   private readonly yAxisTickFormatter: TbFlotTicksFormatterFunction;
   private ticksFormatterFunction: TbFlotTicksFormatterFunction;
   private ticksFormatterFunction: TbFlotTicksFormatterFunction;
   private readonly yaxis: TbFlotAxisOptions;
   private readonly yaxis: TbFlotAxisOptions;
+  private readonly xaxis: TbFlotAxisOptions;
   private yaxes: Array<TbFlotAxisOptions>;
   private yaxes: Array<TbFlotAxisOptions>;
 
 
   private readonly options: JQueryPlotOptions;
   private readonly options: JQueryPlotOptions;
@@ -66,6 +68,7 @@ export class TbFlot {
   private readonly trackDecimals: number;
   private readonly trackDecimals: number;
   private readonly tooltipIndividual: boolean;
   private readonly tooltipIndividual: boolean;
   private readonly tooltipCumulative: boolean;
   private readonly tooltipCumulative: boolean;
+  private readonly hideZeros: boolean;
 
 
   private readonly defaultBarWidth: number;
   private readonly defaultBarWidth: number;
 
 
@@ -106,13 +109,14 @@ export class TbFlot {
     return flotSettingsSchema(chartType);
     return flotSettingsSchema(chartType);
   }
   }
 
 
-  static datakeySettingsSchema(defaultShowLines: boolean): JsonSettingsSchema {
-    return flotDatakeySettingsSchema(defaultShowLines);
+  static datakeySettingsSchema(defaultShowLines: boolean, chartType: ChartType): JsonSettingsSchema {
+    return flotDatakeySettingsSchema(defaultShowLines, chartType);
   }
   }
 
 
   constructor(private ctx: WidgetContext, private readonly chartType: ChartType) {
   constructor(private ctx: WidgetContext, private readonly chartType: ChartType) {
     this.chartType = this.chartType || 'line';
     this.chartType = this.chartType || 'line';
     this.settings = ctx.settings as TbFlotSettings;
     this.settings = ctx.settings as TbFlotSettings;
+    const utils = this.ctx.$injector.get(UtilsService);
     this.tooltip = $('#flot-series-tooltip');
     this.tooltip = $('#flot-series-tooltip');
     if (this.tooltip.length === 0) {
     if (this.tooltip.length === 0) {
       this.tooltip = this.createTooltipElement();
       this.tooltip = this.createTooltipElement();
@@ -123,6 +127,7 @@ export class TbFlot {
     this.tooltipIndividual = this.chartType === 'pie' || (isDefined(this.settings.tooltipIndividual)
     this.tooltipIndividual = this.chartType === 'pie' || (isDefined(this.settings.tooltipIndividual)
       ? this.settings.tooltipIndividual : false);
       ? this.settings.tooltipIndividual : false);
     this.tooltipCumulative = isDefined(this.settings.tooltipCumulative) ? this.settings.tooltipCumulative : false;
     this.tooltipCumulative = isDefined(this.settings.tooltipCumulative) ? this.settings.tooltipCumulative : false;
+    this.hideZeros = isDefined(this.settings.hideZeros) ? this.settings.hideZeros : false;
 
 
     const font = {
     const font = {
       color: this.settings.fontColor || '#545454',
       color: this.settings.fontColor || '#545454',
@@ -147,7 +152,8 @@ export class TbFlot {
     };
     };
 
 
     if (this.chartType === 'line' || this.chartType === 'bar' || this.chartType === 'state') {
     if (this.chartType === 'line' || this.chartType === 'bar' || this.chartType === 'state') {
-      this.options.xaxis = {
+      this.options.xaxes = [];
+      this.xaxis = {
         mode: 'time',
         mode: 'time',
         timezone: 'browser',
         timezone: 'browser',
         font: deepClone(font),
         font: deepClone(font),
@@ -158,16 +164,11 @@ export class TbFlot {
         labelFont: deepClone(font)
         labelFont: deepClone(font)
       };
       };
       if (this.settings.xaxis) {
       if (this.settings.xaxis) {
-        if (this.settings.xaxis.showLabels === false) {
-          this.options.xaxis.tickFormatter = () => {
-            return '';
-          };
-        }
-        this.options.xaxis.font.color = this.settings.xaxis.color || this.options.xaxis.font.color;
-        this.options.xaxis.label = this.settings.xaxis.title || null;
-        this.options.xaxis.labelFont.color = this.options.xaxis.font.color;
-        this.options.xaxis.labelFont.size = this.options.xaxis.font.size + 2;
-        this.options.xaxis.labelFont.weight = 'bold';
+        this.xaxis.font.color = this.settings.xaxis.color || this.xaxis.font.color;
+        this.xaxis.label = utils.customTranslation(this.settings.xaxis.title, this.settings.xaxis.title) || null;
+        this.xaxis.labelFont.color = this.xaxis.font.color;
+        this.xaxis.labelFont.size = this.xaxis.font.size + 2;
+        this.xaxis.labelFont.weight = 'bold';
       }
       }
 
 
       this.yAxisTickFormatter = this.formatYAxisTicks.bind(this);
       this.yAxisTickFormatter = this.formatYAxisTicks.bind(this);
@@ -178,7 +179,7 @@ export class TbFlot {
         this.yaxis.font.color = this.settings.yaxis.color || this.yaxis.font.color;
         this.yaxis.font.color = this.settings.yaxis.color || this.yaxis.font.color;
         this.yaxis.min = isDefined(this.settings.yaxis.min) ? this.settings.yaxis.min : null;
         this.yaxis.min = isDefined(this.settings.yaxis.min) ? this.settings.yaxis.min : null;
         this.yaxis.max = isDefined(this.settings.yaxis.max) ? this.settings.yaxis.max : null;
         this.yaxis.max = isDefined(this.settings.yaxis.max) ? this.settings.yaxis.max : null;
-        this.yaxis.label = this.settings.yaxis.title || null;
+        this.yaxis.label = utils.customTranslation(this.settings.yaxis.title, this.settings.yaxis.title) || null;
         this.yaxis.labelFont.color = this.yaxis.font.color;
         this.yaxis.labelFont.color = this.yaxis.font.color;
         this.yaxis.labelFont.size = this.yaxis.font.size + 2;
         this.yaxis.labelFont.size = this.yaxis.font.size + 2;
         this.yaxis.labelFont.weight = 'bold';
         this.yaxis.labelFont.weight = 'bold';
@@ -212,7 +213,7 @@ export class TbFlot {
         this. options.grid.borderWidth = isDefined(this.settings.grid.outlineWidth) ?
         this. options.grid.borderWidth = isDefined(this.settings.grid.outlineWidth) ?
           this.settings.grid.outlineWidth : 1;
           this.settings.grid.outlineWidth : 1;
         if (this.settings.grid.verticalLines === false) {
         if (this.settings.grid.verticalLines === false) {
-          this.options.xaxis.tickLength = 0;
+          this.xaxis.tickLength = 0;
         }
         }
         if (this.settings.grid.horizontalLines === false) {
         if (this.settings.grid.horizontalLines === false) {
           this.yaxis.tickLength = 0;
           this.yaxis.tickLength = 0;
@@ -225,14 +226,41 @@ export class TbFlot {
         }
         }
       }
       }
 
 
+      this.options.xaxes[0] = deepClone(this.xaxis);
+      if (this.settings.xaxis && this.settings.xaxis.showLabels === false) {
+        this.options.xaxes[0].tickFormatter = () => {
+          return '';
+        };
+      }
+
+      if (this.settings.comparisonEnabled) {
+        const xaxis = deepClone(this.xaxis);
+        xaxis.position = 'top';
+        if (this.settings.xaxisSecond) {
+          if (this.settings.xaxisSecond.showLabels === false) {
+            xaxis.tickFormatter = () => {
+              return '';
+            };
+          }
+          xaxis.label = utils.customTranslation(this.settings.xaxisSecond.title, this.settings.xaxisSecond.title) || null;
+          xaxis.position = this.settings.xaxisSecond.axisPosition;
+        }
+        xaxis.tickLength = 0;
+        this.options.xaxes.push(xaxis);
+
+        this.options.series = {
+          stack: false
+        };
+      } else {
+        this.options.series = {
+          stack: this.settings.stack === true
+        };
+      }
+
       this.options.crosshair = {
       this.options.crosshair = {
         mode: 'x'
         mode: 'x'
       };
       };
 
 
-      this.options.series = {
-        stack: this.settings.stack === true
-      };
-
       if (this.chartType === 'line' && this.settings.smoothLines) {
       if (this.chartType === 'line' && this.settings.smoothLines) {
         this.options.series.curvedLines = {
         this.options.series.curvedLines = {
           active: true,
           active: true,
@@ -339,6 +367,13 @@ export class TbFlot {
       series.lines = {
       series.lines = {
         fill: keySettings.fillLines === true
         fill: keySettings.fillLines === true
       };
       };
+
+      if (this.settings.stack && !this.settings.comparisonEnabled) {
+        series.stack = !keySettings.excludeFromStacking;
+      } else {
+        series.stack = false;
+      }
+
       if (this.chartType === 'line' || this.chartType === 'state') {
       if (this.chartType === 'line' || this.chartType === 'state') {
         series.lines.show = keySettings.showLines !== false;
         series.lines.show = keySettings.showLines !== false;
       } else {
       } else {
@@ -353,8 +388,16 @@ export class TbFlot {
       };
       };
       if (keySettings.showPoints === true) {
       if (keySettings.showPoints === true) {
         series.points.show = true;
         series.points.show = true;
-        series.points.lineWidth = 5;
-        series.points.radius = 3;
+        series.points.lineWidth = isDefined(keySettings.showPointsLineWidth) ? keySettings.showPointsLineWidth : 5;
+        series.points.radius = isDefined(keySettings.showPointsRadius) ? keySettings.showPointsRadius : 3;
+        series.points.symbol = isDefined(keySettings.showPointShape) ? keySettings.showPointShape : 'circle';
+        if (series.points.symbol === 'custom' && keySettings.pointShapeFormatter) {
+          try {
+            series.points.symbol = new Function('ctx, x, y, radius, shadow', keySettings.pointShapeFormatter);
+          } catch (e) {
+            series.points.symbol = 'circle';
+          }
+        }
       }
       }
       if (this.chartType === 'line' && this.settings.smoothLines && !series.points.show) {
       if (this.chartType === 'line' && this.settings.smoothLines && !series.points.show) {
         series.curvedLines = {
         series.curvedLines = {
@@ -367,6 +410,14 @@ export class TbFlot {
 
 
       series.highlightColor = lineColor.toRgbString();
       series.highlightColor = lineColor.toRgbString();
 
 
+      if (series.datasource.isAdditional) {
+        series.xaxisIndex = 1;
+        series.xaxis = 2;
+      } else {
+        series.xaxisIndex = 0;
+        series.xaxis = 1;
+      }
+
       if (this.yaxis) {
       if (this.yaxis) {
         const units = series.dataKey.units && series.dataKey.units.length ? series.dataKey.units : this.trackUnits;
         const units = series.dataKey.units && series.dataKey.units.length ? series.dataKey.units : this.trackUnits;
         let yaxis: TbFlotAxisOptions;
         let yaxis: TbFlotAxisOptions;
@@ -384,7 +435,7 @@ export class TbFlot {
         series.yaxisIndex = this.yaxes.indexOf(yaxis);
         series.yaxisIndex = this.yaxes.indexOf(yaxis);
         series.yaxis = series.yaxisIndex + 1;
         series.yaxis = series.yaxisIndex + 1;
         yaxis.keysInfo[i] = {hidden: false};
         yaxis.keysInfo[i] = {hidden: false};
-        yaxis.hidden = false;
+        yaxis.show = true;
       }
       }
     }
     }
     this.options.colors = colors;
     this.options.colors = colors;
@@ -398,8 +449,12 @@ export class TbFlot {
           this.options.series.bars.barWidth = this.subscription.timeWindow.interval * 0.6;
           this.options.series.bars.barWidth = this.subscription.timeWindow.interval * 0.6;
         }
         }
       }
       }
-      this.options.xaxis.min = this.subscription.timeWindow.minTime;
-      this.options.xaxis.max = this.subscription.timeWindow.maxTime;
+      this.options.xaxes[0].min = this.subscription.timeWindow.minTime;
+      this.options.xaxes[0].max = this.subscription.timeWindow.maxTime;
+      if (this.settings.comparisonEnabled) {
+        this.options.xaxes[1].min = this.subscription.comparisonTimeWindow.minTime;
+        this.options.xaxes[1].max = this.subscription.comparisonTimeWindow.maxTime;
+      }
     }
     }
 
 
     this.checkMouseEvents();
     this.checkMouseEvents();
@@ -469,8 +524,12 @@ export class TbFlot {
             }
             }
           }
           }
 
 
-          this.options.xaxis.min = this.subscription.timeWindow.minTime;
-          this.options.xaxis.max = this.subscription.timeWindow.maxTime;
+          this.options.xaxes[0].min = this.subscription.timeWindow.minTime;
+          this.options.xaxes[0].max = this.subscription.timeWindow.maxTime;
+          if (this.settings.comparisonEnabled) {
+            this.options.xaxes[1].min = this.subscription.comparisonTimeWindow.minTime;
+            this.options.xaxes[1].max = this.subscription.comparisonTimeWindow.maxTime;
+          }
           if (this.chartType === 'bar') {
           if (this.chartType === 'bar') {
             if (this.subscription.timeWindowConfig.aggregation &&
             if (this.subscription.timeWindowConfig.aggregation &&
               this.subscription.timeWindowConfig.aggregation.type === AggregationType.NONE) {
               this.subscription.timeWindowConfig.aggregation.type === AggregationType.NONE) {
@@ -485,6 +544,10 @@ export class TbFlot {
           } else {
           } else {
             this.plot.getOptions().xaxes[0].min = this.subscription.timeWindow.minTime;
             this.plot.getOptions().xaxes[0].min = this.subscription.timeWindow.minTime;
             this.plot.getOptions().xaxes[0].max = this.subscription.timeWindow.maxTime;
             this.plot.getOptions().xaxes[0].max = this.subscription.timeWindow.maxTime;
+            if (this.settings.comparisonEnabled) {
+              this.plot.getOptions().xaxes[1].min = this.subscription.comparisonTimeWindow.minTime;
+              this.plot.getOptions().xaxes[1].max = this.subscription.comparisonTimeWindow.maxTime;
+            }
             if (this.chartType === 'bar') {
             if (this.chartType === 'bar') {
               if (this.subscription.timeWindowConfig.aggregation &&
               if (this.subscription.timeWindowConfig.aggregation &&
                 this.subscription.timeWindowConfig.aggregation.type === AggregationType.NONE) {
                 this.subscription.timeWindowConfig.aggregation.type === AggregationType.NONE) {
@@ -653,7 +716,7 @@ export class TbFlot {
     divElement.css({
     divElement.css({
       display: 'flex',
       display: 'flex',
       alignItems: 'center',
       alignItems: 'center',
-      justifyContent: 'flex-start'
+      justifyContent: 'space-between'
     });
     });
     const lineSpan = $('<span></span>');
     const lineSpan = $('<span></span>');
     lineSpan.css({
     lineSpan.css({
@@ -734,57 +797,98 @@ export class TbFlot {
     return divElement.prop('outerHTML');
     return divElement.prop('outerHTML');
   }
   }
 
 
-  private formatChartTooltip(hoverInfo: TbFlotHoverInfo, seriesIndex: number): string {
+  private formatChartTooltip(hoverInfo: TbFlotHoverInfo[], seriesIndex: number): string {
     let content = '';
     let content = '';
-    const timestamp = parseInt(hoverInfo.time, 10);
-    const date = moment(timestamp).format('YYYY-MM-DD HH:mm:ss');
-    const dateDiv = $(`<div>${date}</div>`);
-    dateDiv.css({
-      display: 'flex',
-      alignItems: 'center',
-      justifyContent: 'center',
-      padding: '4px',
-      fontWeight: '700'
-    });
-    content += dateDiv.prop('outerHTML');
     if (this.tooltipIndividual) {
     if (this.tooltipIndividual) {
-      const found = hoverInfo.seriesHover.find((seriesHover) => {
-        return seriesHover.index === seriesIndex;
-      });
-      if (found) {
-        content += this.seriesInfoDivFromInfo(found, seriesIndex);
+      let seriesHoverArray: TbFlotSeriesHoverInfo[];
+      if (hoverInfo[1] && hoverInfo[1].seriesHover.length) {
+        seriesHoverArray = hoverInfo[0].seriesHover.concat(hoverInfo[1].seriesHover);
+      } else {
+        seriesHoverArray = hoverInfo[0].seriesHover;
       }
       }
-    } else {
-      const seriesDiv = $('<div></div>');
-      seriesDiv.css({
-        display: 'flex',
-        flexDirection: 'row'
+      const found = seriesHoverArray.filter((seriesHover) => {
+        return seriesHover.index === seriesIndex;
       });
       });
-      const maxRows = 15;
-      const columns = Math.ceil(hoverInfo.seriesHover.length / maxRows);
-      let columnsContent = '';
-      for (let c = 0; c < columns; c++) {
-        const columnDiv = $('<div></div>');
-        columnDiv.css({
+      if (found && found.length) {
+        let timestamp: number;
+        if (!isNumber(hoverInfo[0].time) || (found[0].time < hoverInfo[0].time)) {
+          timestamp = parseInt(hoverInfo[1].time, 10);
+        } else {
+          timestamp = parseInt(hoverInfo[0].time, 10);
+        }
+        const date = moment(timestamp).format('YYYY-MM-DD HH:mm:ss');
+        const dateDiv = $('<div>' + date + '</div>');
+        dateDiv.css({
           display: 'flex',
           display: 'flex',
-          flexDirection: 'column'
+          alignItems: 'center',
+          justifyContent: 'center',
+          padding: '4px',
+          fontWeight: '700'
         });
         });
-        let columnContent = '';
-        for (let i = c * maxRows; i < (c + 1) * maxRows; i++) {
-          if (i === hoverInfo.seriesHover.length) {
-            break;
+        content += dateDiv.prop('outerHTML');
+        content += this.seriesInfoDivFromInfo(found[0], seriesIndex);
+      }
+    } else {
+      let maxRows: number;
+      if (hoverInfo[1] && hoverInfo[1].seriesHover.length) {
+        maxRows = 5;
+      } else {
+        maxRows = 15;
+      }
+      let columns = 0;
+      if (hoverInfo[1] && (hoverInfo[1].seriesHover.length > hoverInfo[0].seriesHover.length)) {
+        columns = Math.ceil(hoverInfo[1].seriesHover.length / maxRows);
+      } else {
+        columns = Math.ceil(hoverInfo[0].seriesHover.length / maxRows);
+      }
+      hoverInfo.forEach((hoverData) => {
+        if (isNumber(hoverData.time)) {
+          let columnsContent = '';
+          const timestamp = parseInt(hoverData.time, 10);
+          const date = moment(timestamp).format('YYYY-MM-DD HH:mm:ss');
+          const dateDiv = $('<div>' + date + '</div>');
+          dateDiv.css({
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            padding: '4px',
+            fontWeight: '700'
+          });
+          content += dateDiv.prop('outerHTML');
+
+          const seriesDiv = $('<div></div>');
+          seriesDiv.css({
+            display: 'flex',
+            flexDirection: 'row'
+          });
+          for (let c = 0; c < columns; c++) {
+            const columnDiv = $('<div></div>');
+            columnDiv.css({
+              display: 'flex',
+              flexDirection: 'column',
+              flex: '1'
+            });
+            let columnContent = '';
+            for (let i = c*maxRows; i < (c+1)*maxRows; i++) {
+              if (i >= hoverData.seriesHover.length) {
+                break;
+              }
+              const seriesHoverInfo = hoverData.seriesHover[i];
+              columnContent += this.seriesInfoDivFromInfo(seriesHoverInfo, seriesIndex);
+            }
+            columnDiv.html(columnContent);
+
+            if (columnContent) {
+              if (c > 0) {
+                columnsContent += '<span style="min-width: 20px;"></span>';
+              }
+              columnsContent += columnDiv.prop('outerHTML');
+            }
           }
           }
-          const seriesHoverInfo = hoverInfo.seriesHover[i];
-          columnContent += this.seriesInfoDivFromInfo(seriesHoverInfo, seriesIndex);
-        }
-        columnDiv.html(columnContent);
-        if (c > 0) {
-          columnsContent += '<span style="width: 20px;"></span>';
+          seriesDiv.html(columnsContent);
+          content += seriesDiv.prop('outerHTML');
         }
         }
-        columnsContent += columnDiv.prop('outerHTML');
-      }
-      seriesDiv.html(columnsContent);
-      content += seriesDiv.prop('outerHTML');
+      });
     }
     }
     return content;
     return content;
   }
   }
@@ -848,16 +952,21 @@ export class TbFlot {
       const pageY = pos.pageY;
       const pageY = pos.pageY;
 
 
       let tooltipHtml;
       let tooltipHtml;
-      let hoverInfo: TbFlotHoverInfo;
+      let hoverInfo: TbFlotHoverInfo[];
 
 
       if (this.chartType === 'pie') {
       if (this.chartType === 'pie') {
         tooltipHtml = this.formatPieTooltip(item);
         tooltipHtml = this.formatPieTooltip(item);
       } else {
       } else {
         hoverInfo = this.getHoverInfo(this.plot.getData(), pos);
         hoverInfo = this.getHoverInfo(this.plot.getData(), pos);
-        if (isNumber(hoverInfo.time)) {
-          hoverInfo.seriesHover.sort((a, b) => {
+        if (isNumber(hoverInfo[0].time) || (hoverInfo[1] && isNumber(hoverInfo[1].time))) {
+          hoverInfo[0].seriesHover.sort((a, b) => {
             return b.value - a.value;
             return b.value - a.value;
           });
           });
+          if (hoverInfo[1] && hoverInfo[1].seriesHover.length) {
+            hoverInfo[1].seriesHover.sort((a, b) => {
+              return b.value - a.value;
+            });
+          }
           tooltipHtml = this.formatChartTooltip(hoverInfo, item ? item.seriesIndex : -1);
           tooltipHtml = this.formatChartTooltip(hoverInfo, item ? item.seriesIndex : -1);
         }
         }
       }
       }
@@ -883,8 +992,10 @@ export class TbFlot {
           left
           left
         });
         });
         if (multipleModeTooltip) {
         if (multipleModeTooltip) {
-          hoverInfo.seriesHover.forEach((seriesHoverInfo) => {
-            this.plot.highlight(seriesHoverInfo.index, seriesHoverInfo.hoverIndex);
+          hoverInfo.forEach((hoverData) => {
+            hoverData.seriesHover.forEach((seriesHoverInfo) => {
+              this.plot.highlight(seriesHoverInfo.index, seriesHoverInfo.hoverIndex);
+            });
           });
           });
         }
         }
       }
       }
@@ -927,7 +1038,7 @@ export class TbFlot {
     this.isMouseInteraction = false;
     this.isMouseInteraction = false;
   }
   }
 
 
-  private getHoverInfo(seriesList: TbFlotPlotDataSeries[], pos: JQueryPlotPoint): TbFlotHoverInfo {
+  private getHoverInfo(seriesList: TbFlotPlotDataSeries[], pos: JQueryPlotPoint): TbFlotHoverInfo[] {
     let i: number;
     let i: number;
     let series: TbFlotPlotDataSeries;
     let series: TbFlotPlotDataSeries;
     let hoverIndex: number;
     let hoverIndex: number;
@@ -935,19 +1046,40 @@ export class TbFlot {
     let minDistance: number;
     let minDistance: number;
     let pointTime: any;
     let pointTime: any;
     let minTime: any;
     let minTime: any;
+    let minTimeHistorical: any;
+    let hoverData: TbFlotSeriesHoverInfo;
     let value: any;
     let value: any;
     let lastValue: any;
     let lastValue: any;
-    const results: TbFlotHoverInfo = {
+    let minDistanceHistorical: number;
+    const results: TbFlotHoverInfo[] = [{
       seriesHover: []
       seriesHover: []
-    };
+    }];
+    if (this.settings.comparisonEnabled) {
+      results.push({
+        seriesHover: []
+      });
+    }
     for (i = 0; i < seriesList.length; i++) {
     for (i = 0; i < seriesList.length; i++) {
       series = seriesList[i];
       series = seriesList[i];
-      hoverIndex = this.findHoverIndexFromData(pos.x, series);
+      let posx: number;
+      if (series.datasource.isAdditional) {
+        posx = pos.x2;
+      } else {
+        posx = pos.x;
+      }
+      hoverIndex = this.findHoverIndexFromData(posx, series);
       if (series.data[hoverIndex] && series.data[hoverIndex][0]) {
       if (series.data[hoverIndex] && series.data[hoverIndex][0]) {
-        hoverDistance = pos.x - series.data[hoverIndex][0];
+        hoverDistance = posx - series.data[hoverIndex][0];
         pointTime = series.data[hoverIndex][0];
         pointTime = series.data[hoverIndex][0];
 
 
-        if (!minDistance
+        if (series.datasource.isAdditional) {
+          if (!minDistanceHistorical
+            || (hoverDistance >= 0 && (hoverDistance < minDistanceHistorical || minDistanceHistorical < 0))
+            || (hoverDistance < 0 && hoverDistance > minDistanceHistorical)) {
+            minDistanceHistorical = hoverDistance;
+            minTimeHistorical = pointTime;
+          }
+        } else if (!minDistance
           || (hoverDistance >= 0 && (hoverDistance < minDistance || minDistance < 0))
           || (hoverDistance >= 0 && (hoverDistance < minDistance || minDistance < 0))
           || (hoverDistance < 0 && hoverDistance > minDistance)) {
           || (hoverDistance < 0 && hoverDistance > minDistance)) {
           minDistance = hoverDistance;
           minDistance = hoverDistance;
@@ -964,23 +1096,33 @@ export class TbFlot {
           value = series.data[hoverIndex][1];
           value = series.data[hoverIndex][1];
         }
         }
         if (series.stack || (series.curvedLines && series.curvedLines.apply)) {
         if (series.stack || (series.curvedLines && series.curvedLines.apply)) {
-          hoverIndex = this.findHoverIndexFromDataPoints(pos.x, series, hoverIndex);
+          hoverIndex = this.findHoverIndexFromDataPoints(posx, series, hoverIndex);
+        }
+        if (!this.hideZeros || value) {
+          hoverData = {
+            value,
+            hoverIndex,
+            color: series.dataKey.color,
+            label: series.dataKey.label,
+            units: series.dataKey.units,
+            decimals: series.dataKey.decimals,
+            tooltipValueFormatFunction: series.dataKey.tooltipValueFormatFunction,
+            time: pointTime,
+            distance: hoverDistance,
+            index: i
+          };
+          if (series.datasource.isAdditional) {
+            results[1].seriesHover.push(hoverData);
+          } else {
+            results[0].seriesHover.push(hoverData);
+          }
         }
         }
-        results.seriesHover.push({
-          value,
-          hoverIndex,
-          color: series.dataKey.color,
-          label: series.dataKey.label,
-          units: series.dataKey.units,
-          decimals: series.dataKey.decimals,
-          tooltipValueFormatFunction: series.dataKey.tooltipValueFormatFunction,
-          time: pointTime,
-          distance: hoverDistance,
-          index: i
-        });
       }
       }
     }
     }
-    results.time = minTime;
+    if (results[1] && results[1].seriesHover.length) {
+      results[1].time = minTimeHistorical;
+    }
+    results[0].time = minTime;
     return results;
     return results;
   }
   }
 
 

@@ -23,7 +23,7 @@ import {
   Datasource,
   Datasource,
   DatasourceType,
   DatasourceType,
   datasourceTypeTranslationMap,
   datasourceTypeTranslationMap,
-  defaultLegendConfig,
+  defaultLegendConfig, GroupInfo, JsonSchema,
   widgetType
   widgetType
 } from '@shared/models/widget.models';
 } from '@shared/models/widget.models';
 import {
 import {
@@ -60,11 +60,11 @@ import { WidgetActionsData } from './action/manage-widget-actions.component.mode
 import { DashboardState } from '@shared/models/dashboard.models';
 import { DashboardState } from '@shared/models/dashboard.models';
 import { entityFields } from '@shared/models/entity.models';
 import { entityFields } from '@shared/models/entity.models';
 
 
-const emptySettingsSchema = {
+const emptySettingsSchema: JsonSchema = {
   type: 'object',
   type: 'object',
   properties: {}
   properties: {}
 };
 };
-const emptySettingsGroupInfoes = [];
+const emptySettingsGroupInfoes: GroupInfo[] = [];
 const defaultSettingsForm = [
 const defaultSettingsForm = [
   '*'
   '*'
 ];
 ];
@@ -594,7 +594,7 @@ export class WidgetConfigComponent extends PageComponent implements OnInit, Cont
   }
   }
 
 
   public displayAdvanced(): boolean {
   public displayAdvanced(): boolean {
-    return this.modelValue && this.modelValue.settingsSchema && this.modelValue.settingsSchema.schema;
+    return !!this.modelValue && !!this.modelValue.settingsSchema && !!this.modelValue.settingsSchema.schema;
   }
   }
 
 
   public removeDatasource(index: number) {
   public removeDatasource(index: number) {

@@ -44,7 +44,7 @@ import {
   Widget,
   Widget,
   WidgetActionDescriptor,
   WidgetActionDescriptor,
   widgetActionSources,
   widgetActionSources,
-  WidgetActionType,
+  WidgetActionType, WidgetComparisonSettings,
   WidgetResource,
   WidgetResource,
   widgetType,
   widgetType,
   WidgetTypeParameters
   WidgetTypeParameters
@@ -847,9 +847,12 @@ export class WidgetComponent extends PageComponent implements OnInit, AfterViewI
     const createSubscriptionSubject = new ReplaySubject();
     const createSubscriptionSubject = new ReplaySubject();
     let options: WidgetSubscriptionOptions;
     let options: WidgetSubscriptionOptions;
     if (this.widget.type !== widgetType.rpc && this.widget.type !== widgetType.static) {
     if (this.widget.type !== widgetType.rpc && this.widget.type !== widgetType.static) {
+      const comparisonSettings: WidgetComparisonSettings = this.widgetContext.settings;
       options = {
       options = {
         type: this.widget.type,
         type: this.widget.type,
-        stateData: this.typeParameters.stateData
+        stateData: this.typeParameters.stateData,
+        comparisonEnabled: comparisonSettings.comparisonEnabled,
+        timeForComparison: comparisonSettings.timeForComparison
       };
       };
       if (this.widget.type === widgetType.alarm) {
       if (this.widget.type === widgetType.alarm) {
         options.alarmSource = deepClone(this.widget.config.alarmSource);
         options.alarmSource = deepClone(this.widget.config.alarmSource);

@@ -27,7 +27,7 @@ import {
   widgetType,
   widgetType,
   WidgetTypeDescriptor,
   WidgetTypeDescriptor,
   WidgetTypeParameters,
   WidgetTypeParameters,
-  Widget
+  Widget, JsonSettingsSchema
 } from '@shared/models/widget.models';
 } from '@shared/models/widget.models';
 import { Timewindow, WidgetTimewindow } from '@shared/models/time/time.models';
 import { Timewindow, WidgetTimewindow } from '@shared/models/time/time.models';
 import {
 import {
@@ -243,8 +243,8 @@ export interface WidgetConfigComponentData {
   typeParameters: WidgetTypeParameters;
   typeParameters: WidgetTypeParameters;
   actionSources: {[actionSourceId: string]: WidgetActionSource};
   actionSources: {[actionSourceId: string]: WidgetActionSource};
   isDataEnabled: boolean;
   isDataEnabled: boolean;
-  settingsSchema: any;
-  dataKeySettingsSchema: any;
+  settingsSchema: JsonSettingsSchema;
+  dataKeySettingsSchema: JsonSettingsSchema;
 }
 }
 
 
 export const MissingWidgetType: WidgetInfo = {
 export const MissingWidgetType: WidgetInfo = {

@@ -15,9 +15,8 @@
 ///
 ///
 
 
 
 
-export interface JsonFormComponentData {
+import { JsonSettingsSchema } from '@shared/models/widget.models';
+
+export interface JsonFormComponentData extends JsonSettingsSchema {
   model?: any;
   model?: any;
-  schema?: any;
-  form?: any;
-  groupInfoes?: any[];
 }
 }

@@ -42,6 +42,7 @@ import * as ReactDOM from 'react-dom';
 import ReactSchemaForm from './react/json-form-react';
 import ReactSchemaForm from './react/json-form-react';
 import JsonFormUtils from './react/json-form-utils';
 import JsonFormUtils from './react/json-form-utils';
 import { JsonFormComponentData } from './json-form-component.models';
 import { JsonFormComponentData } from './json-form-component.models';
+import { GroupInfo } from '@shared/models/widget.models';
 
 
 const tinycolor = tinycolor_;
 const tinycolor = tinycolor_;
 
 
@@ -94,7 +95,7 @@ export class JsonFormComponent implements OnInit, ControlValueAccessor, Validato
   model: any;
   model: any;
   schema: any;
   schema: any;
   form: any;
   form: any;
-  groupInfoes: any[];
+  groupInfoes: GroupInfo[];
 
 
   isModelValid = true;
   isModelValid = true;
 
 

@@ -32,10 +32,11 @@ import ThingsboardImage from './json-form-image';
 import ThingsboardCheckbox from './json-form-checkbox';
 import ThingsboardCheckbox from './json-form-checkbox';
 import ThingsboardHelp from './json-form-help';
 import ThingsboardHelp from './json-form-help';
 import ThingsboardFieldSet from './json-form-fieldset';
 import ThingsboardFieldSet from './json-form-fieldset';
-import { JsonFormProps, GroupInfo, JsonFormData, onChangeFn, OnColorClickFn } from './json-form.models';
+import { JsonFormProps, JsonFormData, onChangeFn, OnColorClickFn } from './json-form.models';
 
 
 import _ from 'lodash';
 import _ from 'lodash';
 import * as tinycolor_ from 'tinycolor2';
 import * as tinycolor_ from 'tinycolor2';
+import { GroupInfo } from '@shared/models/widget.models';
 const tinycolor = tinycolor_;
 const tinycolor = tinycolor_;
 
 
 class ThingsboardSchemaForm extends React.Component<JsonFormProps, any> {
 class ThingsboardSchemaForm extends React.Component<JsonFormProps, any> {

@@ -19,6 +19,7 @@ import * as equal from 'deep-equal';
 import ObjectPath from 'objectpath';
 import ObjectPath from 'objectpath';
 import * as React from 'react';
 import * as React from 'react';
 import * as tinycolor_ from 'tinycolor2';
 import * as tinycolor_ from 'tinycolor2';
+import { GroupInfo } from '@shared/models/widget.models';
 
 
 const tinycolor = tinycolor_;
 const tinycolor = tinycolor_;
 
 
@@ -45,11 +46,6 @@ export interface DefaultsFormOptions {
   ignore?: {[key: string]: boolean};
   ignore?: {[key: string]: boolean};
 }
 }
 
 
-export interface GroupInfo {
-  formIndex: number;
-  GroupTitle: string;
-}
-
 export type onChangeFn = (key: (string | number)[], val: any, forceUpdate?: boolean) => void;
 export type onChangeFn = (key: (string | number)[], val: any, forceUpdate?: boolean) => void;
 export type OnColorClickFn = (key: (string | number)[], val: tinycolor.ColorFormats.RGBA,
 export type OnColorClickFn = (key: (string | number)[], val: tinycolor.ColorFormats.RGBA,
                               colorSelectedFn: (color: tinycolor.ColorFormats.RGBA) => void) => void;
                               colorSelectedFn: (color: tinycolor.ColorFormats.RGBA) => void) => void;

@@ -16,6 +16,9 @@
 
 
 import { TimeService } from '@core/services/time.service';
 import { TimeService } from '@core/services/time.service';
 import { deepClone, isDefined, isUndefined } from '@app/core/utils';
 import { deepClone, isDefined, isUndefined } from '@app/core/utils';
+import * as moment_ from 'moment';
+
+const moment = moment_;
 
 
 export const SECOND = 1000;
 export const SECOND = 1000;
 export const MINUTE = 60 * SECOND;
 export const MINUTE = 60 * SECOND;
@@ -289,6 +292,31 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num
   return subscriptionTimewindow;
   return subscriptionTimewindow;
 }
 }
 
 
+export function createTimewindowForComparison(subscriptionTimewindow: SubscriptionTimewindow,
+                                              timeUnit: moment_.unitOfTime.DurationConstructor): SubscriptionTimewindow {
+  const timewindowForComparison: SubscriptionTimewindow = {
+    fixedWindow: null,
+    realtimeWindowMs: null,
+    aggregation: subscriptionTimewindow.aggregation
+  };
+
+  if (subscriptionTimewindow.realtimeWindowMs) {
+    timewindowForComparison.startTs = moment(subscriptionTimewindow.startTs).subtract(1, timeUnit).valueOf();
+    timewindowForComparison.realtimeWindowMs = subscriptionTimewindow.realtimeWindowMs;
+  } else if (subscriptionTimewindow.fixedWindow) {
+    const timeInterval = subscriptionTimewindow.fixedWindow.endTimeMs - subscriptionTimewindow.fixedWindow.startTimeMs;
+    const endTimeMs = moment(subscriptionTimewindow.fixedWindow.endTimeMs).subtract(1, timeUnit).valueOf();
+
+    timewindowForComparison.startTs = endTimeMs - timeInterval;
+    timewindowForComparison.fixedWindow = {
+      startTimeMs: timewindowForComparison.startTs,
+      endTimeMs
+    };
+  }
+
+  return timewindowForComparison;
+}
+
 export function cloneSelectedTimewindow(timewindow: Timewindow): Timewindow {
 export function cloneSelectedTimewindow(timewindow: Timewindow): Timewindow {
   const cloned: Timewindow = {};
   const cloned: Timewindow = {};
   if (isDefined(timewindow.selectedTab)) {
   if (isDefined(timewindow.selectedTab)) {

@@ -20,9 +20,9 @@ import { WidgetTypeId } from '@shared/models/id/widget-type-id';
 import { Timewindow } from '@shared/models/time/time.models';
 import { Timewindow } from '@shared/models/time/time.models';
 import { EntityType } from '@shared/models/entity-type.models';
 import { EntityType } from '@shared/models/entity-type.models';
 import { AlarmSearchStatus } from '@shared/models/alarm.models';
 import { AlarmSearchStatus } from '@shared/models/alarm.models';
-import { Data } from '@angular/router';
 import { DataKeyType } from './telemetry/telemetry.models';
 import { DataKeyType } from './telemetry/telemetry.models';
 import { EntityId } from '@shared/models/id/entity-id';
 import { EntityId } from '@shared/models/id/entity-id';
+import * as moment_ from 'moment';
 
 
 export enum widgetType {
 export enum widgetType {
   timeseries = 'timeseries',
   timeseries = 'timeseries',
@@ -261,6 +261,7 @@ export interface Datasource {
   entityLabel?: string;
   entityLabel?: string;
   entityDescription?: string;
   entityDescription?: string;
   generated?: boolean;
   generated?: boolean;
+  isAdditional?: boolean;
   [key: string]: any;
   [key: string]: any;
 }
 }
 
 
@@ -331,6 +332,11 @@ export interface WidgetActionDescriptor extends CustomActionDescriptor {
   stateEntityParamName?: string;
   stateEntityParamName?: string;
 }
 }
 
 
+export interface WidgetComparisonSettings {
+  comparisonEnabled?: boolean;
+  timeForComparison?: moment_.unitOfTime.DurationConstructor;
+}
+
 export interface WidgetConfig {
 export interface WidgetConfig {
   title?: string;
   title?: string;
   titleIcon?: string;
   titleIcon?: string;
@@ -382,14 +388,22 @@ export interface Widget {
   config: WidgetConfig;
   config: WidgetConfig;
 }
 }
 
 
+export interface GroupInfo {
+  formIndex: number;
+  GroupTitle: string;
+}
+
+export interface JsonSchema {
+  type: string;
+  title?: string;
+  properties: {[key: string]: any};
+  required?: string[];
+}
+
 export interface JsonSettingsSchema {
 export interface JsonSettingsSchema {
-  schema?: {
-    type: string;
-    title: string;
-    properties: {[key: string]: any};
-    required?: string[];
-  };
+  schema?: JsonSchema;
   form?: any[];
   form?: any[];
+  groupInfoes?: GroupInfo[]
 }
 }
 
 
 export interface WidgetPosition {
 export interface WidgetPosition {

@@ -24,6 +24,7 @@ interface JQueryPlot extends jquery.flot.plot {
 interface JQueryPlotPoint extends jquery.flot.point {
 interface JQueryPlotPoint extends jquery.flot.point {
   pageX: number;
   pageX: number;
   pageY: number;
   pageY: number;
+  x2: number;
 }
 }
 
 
 interface JQueryPlotDataSeries extends jquery.flot.dataSeries, JQueryPlotSeriesOptions {
 interface JQueryPlotDataSeries extends jquery.flot.dataSeries, JQueryPlotSeriesOptions {