@gisce/ooui 0.6.15 → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/Graph/processor/graphProcessor.js +12 -1
- package/dist/Graph/processor/graphProcessor.js.map +1 -1
- package/dist/Graph/processor/timerangeHelper.d.ts +33 -0
- package/dist/Graph/processor/timerangeHelper.js +227 -0
- package/dist/Graph/processor/timerangeHelper.js.map +1 -0
- package/package.json +4 -2
- package/src/Graph/processor/graphProcessor.ts +14 -1
- package/src/Graph/processor/timerangeHelper.ts +289 -0
- package/src/spec/domainParser.spec.ts +0 -12
- package/src/spec/graphProcessor.spec.ts +19 -0
- package/src/spec/timerangeHelper.spec.ts +603 -0
|
@@ -30,6 +30,7 @@ var __spread = (this && this.__spread) || function () {
|
|
|
30
30
|
return ar;
|
|
31
31
|
};
|
|
32
32
|
import { getValueAndLabelForField } from "./fieldUtils";
|
|
33
|
+
import { processTimerangeData } from "./timerangeHelper";
|
|
33
34
|
export var labelsForOperator = {
|
|
34
35
|
count: "count",
|
|
35
36
|
"+": "sum",
|
|
@@ -74,6 +75,7 @@ export var processGraphData = function (_a) {
|
|
|
74
75
|
yAxis: yField,
|
|
75
76
|
fields: fields,
|
|
76
77
|
}),
|
|
78
|
+
operator: yField.operator,
|
|
77
79
|
stacked: yField.stacked,
|
|
78
80
|
});
|
|
79
81
|
}
|
|
@@ -103,6 +105,7 @@ export var processGraphData = function (_a) {
|
|
|
103
105
|
x: xLabel || false,
|
|
104
106
|
value: finalValue,
|
|
105
107
|
type: label,
|
|
108
|
+
operator: yField.operator,
|
|
106
109
|
stacked: yField.stacked,
|
|
107
110
|
});
|
|
108
111
|
});
|
|
@@ -148,8 +151,16 @@ export var processGraphData = function (_a) {
|
|
|
148
151
|
else if (adjustedStackedData.some(function (entry) { return entry.x === false; })) {
|
|
149
152
|
adjustedUninformedData = adjustedUninformedData.filter(function (entry) { return entry.x !== false; });
|
|
150
153
|
}
|
|
154
|
+
// If we have a timerange parameter defined in ooui, we must fill the gaps with the desired units and group results too
|
|
155
|
+
var finalData = adjustedUninformedData;
|
|
156
|
+
if (ooui.timerange) {
|
|
157
|
+
finalData = processTimerangeData({
|
|
158
|
+
values: finalData,
|
|
159
|
+
timerange: ooui.timerange,
|
|
160
|
+
});
|
|
161
|
+
}
|
|
151
162
|
return {
|
|
152
|
-
data:
|
|
163
|
+
data: finalData,
|
|
153
164
|
isGroup: isStack || isGroup,
|
|
154
165
|
isStack: isStack,
|
|
155
166
|
};
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"graphProcessor.js","sourceRoot":"","sources":["../../../src/Graph/processor/graphProcessor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;
|
|
1
|
+
{"version":3,"file":"graphProcessor.js","sourceRoot":"","sources":["../../../src/Graph/processor/graphProcessor.ts"],"names":[],"mappings":"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"}
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
export declare function processTimerangeData({ values, timerange, }: {
|
|
2
|
+
values: any[];
|
|
3
|
+
timerange: string;
|
|
4
|
+
}): any[];
|
|
5
|
+
export declare function fillGapsInTimerangeData({ values, timerange, }: {
|
|
6
|
+
values: any[];
|
|
7
|
+
timerange: string;
|
|
8
|
+
}): any[];
|
|
9
|
+
export declare function getMissingConsecutiveDates({ dates, timerange, }: {
|
|
10
|
+
dates: string[];
|
|
11
|
+
timerange: string;
|
|
12
|
+
}): string[];
|
|
13
|
+
export declare function combineValuesForTimerange({ values, timerange, }: {
|
|
14
|
+
values: any[];
|
|
15
|
+
timerange: string;
|
|
16
|
+
}): any[];
|
|
17
|
+
export declare function adjustXValuesForTimeRage({ values, timerange, }: {
|
|
18
|
+
values: any[];
|
|
19
|
+
timerange: string;
|
|
20
|
+
}): any[];
|
|
21
|
+
export declare function convertDateToTimeRangeAdjusted({ date, timerange, }: {
|
|
22
|
+
date: string;
|
|
23
|
+
timerange: string;
|
|
24
|
+
}): string;
|
|
25
|
+
export declare function getDateFormat(date: string): "YYYY-MM-DD" | "YYYY-MM-DD HH:mm:ss";
|
|
26
|
+
export declare function checkDatesConsecutive(dates: string[], unit: "hours" | "days" | "weeks" | "months" | "years"): boolean;
|
|
27
|
+
export declare function getUniqueValuesGroupedBy({ values, groupBy, }: {
|
|
28
|
+
values: any[];
|
|
29
|
+
groupBy: "all" | "type-stacked";
|
|
30
|
+
}): {
|
|
31
|
+
[key: string]: any;
|
|
32
|
+
};
|
|
33
|
+
export declare function getFormatForUnits(units: string): "YYYY-MM-DD HH:mm" | "YYYY-MM-DD" | "YYYY-WW" | "YYYY-MM" | "YYYY";
|
|
@@ -0,0 +1,227 @@
|
|
|
1
|
+
var __assign = (this && this.__assign) || function () {
|
|
2
|
+
__assign = Object.assign || function(t) {
|
|
3
|
+
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
4
|
+
s = arguments[i];
|
|
5
|
+
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
6
|
+
t[p] = s[p];
|
|
7
|
+
}
|
|
8
|
+
return t;
|
|
9
|
+
};
|
|
10
|
+
return __assign.apply(this, arguments);
|
|
11
|
+
};
|
|
12
|
+
import moment from "moment";
|
|
13
|
+
import { getValueForOperator } from "./graphProcessor";
|
|
14
|
+
export function processTimerangeData(_a) {
|
|
15
|
+
var values = _a.values, timerange = _a.timerange;
|
|
16
|
+
var combinedValues = combineValuesForTimerange({
|
|
17
|
+
values: values,
|
|
18
|
+
timerange: timerange,
|
|
19
|
+
});
|
|
20
|
+
// Fill the gaps
|
|
21
|
+
var filledValues = fillGapsInTimerangeData({
|
|
22
|
+
values: combinedValues,
|
|
23
|
+
timerange: timerange,
|
|
24
|
+
});
|
|
25
|
+
return filledValues;
|
|
26
|
+
}
|
|
27
|
+
export function fillGapsInTimerangeData(_a) {
|
|
28
|
+
var values = _a.values, timerange = _a.timerange;
|
|
29
|
+
var finalValues = [];
|
|
30
|
+
var uniqueValues = getUniqueValuesGroupedBy({
|
|
31
|
+
values: values,
|
|
32
|
+
groupBy: "type-stacked",
|
|
33
|
+
});
|
|
34
|
+
var units = timerange + "s";
|
|
35
|
+
Object.keys(uniqueValues).forEach(function (key) {
|
|
36
|
+
var valuesForKey = uniqueValues[key];
|
|
37
|
+
var _loop_1 = function (i) {
|
|
38
|
+
var value = valuesForKey[i];
|
|
39
|
+
finalValues.push(value);
|
|
40
|
+
// If it's the last item
|
|
41
|
+
if (i === valuesForKey.length - 1) {
|
|
42
|
+
return { value: void 0 };
|
|
43
|
+
}
|
|
44
|
+
var date = value.x;
|
|
45
|
+
var nextDate = valuesForKey[i + 1].x;
|
|
46
|
+
if (!checkDatesConsecutive([date, nextDate], units)) {
|
|
47
|
+
var missingDates = getMissingConsecutiveDates({
|
|
48
|
+
dates: [date, nextDate],
|
|
49
|
+
timerange: timerange,
|
|
50
|
+
});
|
|
51
|
+
finalValues = finalValues.concat(missingDates.map(function (stringDate) {
|
|
52
|
+
return {
|
|
53
|
+
x: stringDate,
|
|
54
|
+
value: 0,
|
|
55
|
+
type: value.type,
|
|
56
|
+
stacked: value.stacked,
|
|
57
|
+
};
|
|
58
|
+
}));
|
|
59
|
+
}
|
|
60
|
+
};
|
|
61
|
+
for (var i = 0; i < valuesForKey.length; i++) {
|
|
62
|
+
var state_1 = _loop_1(i);
|
|
63
|
+
if (typeof state_1 === "object")
|
|
64
|
+
return state_1.value;
|
|
65
|
+
}
|
|
66
|
+
});
|
|
67
|
+
var sortedData = finalValues.sort(function (a, b) {
|
|
68
|
+
if (a["x"] < b["x"]) {
|
|
69
|
+
return -1;
|
|
70
|
+
}
|
|
71
|
+
if (a["x"] > b["x"]) {
|
|
72
|
+
return 1;
|
|
73
|
+
}
|
|
74
|
+
return 0;
|
|
75
|
+
});
|
|
76
|
+
return sortedData;
|
|
77
|
+
}
|
|
78
|
+
export function getMissingConsecutiveDates(_a) {
|
|
79
|
+
var dates = _a.dates, timerange = _a.timerange;
|
|
80
|
+
var missingDates = [];
|
|
81
|
+
var units = timerange + "s";
|
|
82
|
+
if (dates.length === 1) {
|
|
83
|
+
return dates;
|
|
84
|
+
}
|
|
85
|
+
var sortedDates = dates.sort(function (a, b) {
|
|
86
|
+
if (a < b) {
|
|
87
|
+
return -1;
|
|
88
|
+
}
|
|
89
|
+
if (a > b) {
|
|
90
|
+
return 1;
|
|
91
|
+
}
|
|
92
|
+
return 0;
|
|
93
|
+
});
|
|
94
|
+
for (var i = 0; i < sortedDates.length - 1; i++) {
|
|
95
|
+
var date1 = sortedDates[i];
|
|
96
|
+
var date2 = sortedDates[i + 1];
|
|
97
|
+
if (!checkDatesConsecutive([date1, date2], units)) {
|
|
98
|
+
var iDate = moment(date1, getFormatForUnits(units)).add(1, units);
|
|
99
|
+
var fDate = moment(date2, getFormatForUnits(units));
|
|
100
|
+
while (iDate.isBefore(fDate)) {
|
|
101
|
+
missingDates.push(iDate.format(getFormatForUnits(units)));
|
|
102
|
+
iDate.add(1, units);
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
return missingDates;
|
|
107
|
+
}
|
|
108
|
+
export function combineValuesForTimerange(_a) {
|
|
109
|
+
var values = _a.values, timerange = _a.timerange;
|
|
110
|
+
var adjustedValues = adjustXValuesForTimeRage({
|
|
111
|
+
values: values,
|
|
112
|
+
timerange: timerange,
|
|
113
|
+
});
|
|
114
|
+
var finalValues = [];
|
|
115
|
+
// group by x, type and stacked
|
|
116
|
+
var uniqueValues = getUniqueValuesGroupedBy({
|
|
117
|
+
values: adjustedValues,
|
|
118
|
+
groupBy: "all",
|
|
119
|
+
});
|
|
120
|
+
Object.keys(uniqueValues).forEach(function (key) {
|
|
121
|
+
var valuesForKey = uniqueValues[key];
|
|
122
|
+
var finalValue = getValueForOperator({
|
|
123
|
+
values: valuesForKey.map(function (entry) { return entry.value; }),
|
|
124
|
+
operator: valuesForKey[0].operator,
|
|
125
|
+
});
|
|
126
|
+
finalValues.push(__assign(__assign({}, valuesForKey[0]), { value: finalValue }));
|
|
127
|
+
});
|
|
128
|
+
return finalValues;
|
|
129
|
+
}
|
|
130
|
+
export function adjustXValuesForTimeRage(_a) {
|
|
131
|
+
var values = _a.values, timerange = _a.timerange;
|
|
132
|
+
return values.map(function (value) {
|
|
133
|
+
return __assign(__assign({}, value), { x: convertDateToTimeRangeAdjusted({
|
|
134
|
+
date: value.x,
|
|
135
|
+
timerange: timerange,
|
|
136
|
+
}) });
|
|
137
|
+
});
|
|
138
|
+
}
|
|
139
|
+
export function convertDateToTimeRangeAdjusted(_a) {
|
|
140
|
+
var date = _a.date, timerange = _a.timerange;
|
|
141
|
+
var format = getDateFormat(date);
|
|
142
|
+
var momentDate = moment(date, format);
|
|
143
|
+
switch (timerange) {
|
|
144
|
+
case "hour": {
|
|
145
|
+
format = "YYYY-MM-DD HH:00";
|
|
146
|
+
break;
|
|
147
|
+
}
|
|
148
|
+
case "day": {
|
|
149
|
+
format = "YYYY-MM-DD";
|
|
150
|
+
break;
|
|
151
|
+
}
|
|
152
|
+
case "week": {
|
|
153
|
+
format = "YYYY-WW";
|
|
154
|
+
break;
|
|
155
|
+
}
|
|
156
|
+
case "month": {
|
|
157
|
+
format = "YYYY-MM";
|
|
158
|
+
break;
|
|
159
|
+
}
|
|
160
|
+
case "year": {
|
|
161
|
+
format = "YYYY";
|
|
162
|
+
break;
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
return momentDate.format(format);
|
|
166
|
+
}
|
|
167
|
+
export function getDateFormat(date) {
|
|
168
|
+
return date.indexOf(":") ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD";
|
|
169
|
+
}
|
|
170
|
+
export function checkDatesConsecutive(dates, unit) {
|
|
171
|
+
var consecutive = false;
|
|
172
|
+
var format = getFormatForUnits(unit);
|
|
173
|
+
if (dates.length === 0) {
|
|
174
|
+
return false;
|
|
175
|
+
}
|
|
176
|
+
if (dates.length === 1) {
|
|
177
|
+
return true;
|
|
178
|
+
}
|
|
179
|
+
for (var i = 0; i < dates.length - 1; i++) {
|
|
180
|
+
var date1 = moment(dates[i], format);
|
|
181
|
+
var date2 = moment(dates[i + 1], format);
|
|
182
|
+
var diff = date2.diff(date1, unit);
|
|
183
|
+
if (Math.abs(diff) === 1) {
|
|
184
|
+
consecutive = true;
|
|
185
|
+
}
|
|
186
|
+
else {
|
|
187
|
+
consecutive = false;
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
return consecutive;
|
|
191
|
+
}
|
|
192
|
+
export function getUniqueValuesGroupedBy(_a) {
|
|
193
|
+
var values = _a.values, groupBy = _a.groupBy;
|
|
194
|
+
var uniqueValues = {};
|
|
195
|
+
values.forEach(function (value) {
|
|
196
|
+
var x = value.x;
|
|
197
|
+
var type = value.type;
|
|
198
|
+
var stacked = value.stacked;
|
|
199
|
+
var uniqueKey = groupBy === "all" ? x + "-" + type + "-" + stacked : type + "-" + stacked;
|
|
200
|
+
if (!uniqueValues[uniqueKey]) {
|
|
201
|
+
uniqueValues[uniqueKey] = [];
|
|
202
|
+
}
|
|
203
|
+
uniqueValues[uniqueKey].push(value);
|
|
204
|
+
});
|
|
205
|
+
return uniqueValues;
|
|
206
|
+
}
|
|
207
|
+
export function getFormatForUnits(units) {
|
|
208
|
+
switch (units) {
|
|
209
|
+
default:
|
|
210
|
+
case "hours": {
|
|
211
|
+
return "YYYY-MM-DD HH:mm";
|
|
212
|
+
}
|
|
213
|
+
case "days": {
|
|
214
|
+
return "YYYY-MM-DD";
|
|
215
|
+
}
|
|
216
|
+
case "weeks": {
|
|
217
|
+
return "YYYY-WW";
|
|
218
|
+
}
|
|
219
|
+
case "months": {
|
|
220
|
+
return "YYYY-MM";
|
|
221
|
+
}
|
|
222
|
+
case "years": {
|
|
223
|
+
return "YYYY";
|
|
224
|
+
}
|
|
225
|
+
}
|
|
226
|
+
}
|
|
227
|
+
//# sourceMappingURL=timerangeHelper.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"timerangeHelper.js","sourceRoot":"","sources":["../../../src/Graph/processor/timerangeHelper.ts"],"names":[],"mappings":"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"}
|
package/package.json
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import { GraphChart, GraphYAxis, Operator } from "..";
|
|
2
2
|
import { getValueAndLabelForField } from "./fieldUtils";
|
|
3
|
+
import { processTimerangeData } from "./timerangeHelper";
|
|
3
4
|
|
|
4
5
|
export type GroupedValues = {
|
|
5
6
|
[key: string]: { label: string; entries: { [key: string]: any }[] };
|
|
@@ -68,6 +69,7 @@ export const processGraphData = ({
|
|
|
68
69
|
yAxis: yField,
|
|
69
70
|
fields,
|
|
70
71
|
}),
|
|
72
|
+
operator: yField.operator,
|
|
71
73
|
stacked: yField.stacked,
|
|
72
74
|
});
|
|
73
75
|
}
|
|
@@ -100,6 +102,7 @@ export const processGraphData = ({
|
|
|
100
102
|
x: xLabel || false,
|
|
101
103
|
value: finalValue,
|
|
102
104
|
type: label,
|
|
105
|
+
operator: yField.operator,
|
|
103
106
|
stacked: yField.stacked,
|
|
104
107
|
});
|
|
105
108
|
});
|
|
@@ -156,8 +159,18 @@ export const processGraphData = ({
|
|
|
156
159
|
);
|
|
157
160
|
}
|
|
158
161
|
|
|
162
|
+
// If we have a timerange parameter defined in ooui, we must fill the gaps with the desired units and group results too
|
|
163
|
+
let finalData = adjustedUninformedData;
|
|
164
|
+
|
|
165
|
+
if (ooui.timerange) {
|
|
166
|
+
finalData = processTimerangeData({
|
|
167
|
+
values: finalData,
|
|
168
|
+
timerange: ooui.timerange!,
|
|
169
|
+
});
|
|
170
|
+
}
|
|
171
|
+
|
|
159
172
|
return {
|
|
160
|
-
data:
|
|
173
|
+
data: finalData,
|
|
161
174
|
isGroup: isStack || isGroup,
|
|
162
175
|
isStack,
|
|
163
176
|
};
|
|
@@ -0,0 +1,289 @@
|
|
|
1
|
+
import moment from "moment";
|
|
2
|
+
import { getValueForOperator } from "./graphProcessor";
|
|
3
|
+
|
|
4
|
+
export function processTimerangeData({
|
|
5
|
+
values,
|
|
6
|
+
timerange,
|
|
7
|
+
}: {
|
|
8
|
+
values: any[];
|
|
9
|
+
timerange: string;
|
|
10
|
+
}) {
|
|
11
|
+
const combinedValues = combineValuesForTimerange({
|
|
12
|
+
values,
|
|
13
|
+
timerange,
|
|
14
|
+
});
|
|
15
|
+
|
|
16
|
+
// Fill the gaps
|
|
17
|
+
const filledValues = fillGapsInTimerangeData({
|
|
18
|
+
values: combinedValues,
|
|
19
|
+
timerange,
|
|
20
|
+
});
|
|
21
|
+
|
|
22
|
+
return filledValues;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
export function fillGapsInTimerangeData({
|
|
26
|
+
values,
|
|
27
|
+
timerange,
|
|
28
|
+
}: {
|
|
29
|
+
values: any[];
|
|
30
|
+
timerange: string;
|
|
31
|
+
}) {
|
|
32
|
+
let finalValues: any[] = [];
|
|
33
|
+
const uniqueValues: { [key: string]: any } = getUniqueValuesGroupedBy({
|
|
34
|
+
values,
|
|
35
|
+
groupBy: "type-stacked",
|
|
36
|
+
});
|
|
37
|
+
const units = `${timerange}s` as any;
|
|
38
|
+
|
|
39
|
+
Object.keys(uniqueValues).forEach((key) => {
|
|
40
|
+
const valuesForKey = uniqueValues[key];
|
|
41
|
+
|
|
42
|
+
for (let i = 0; i < valuesForKey.length; i++) {
|
|
43
|
+
const value = valuesForKey[i];
|
|
44
|
+
|
|
45
|
+
finalValues.push(value);
|
|
46
|
+
|
|
47
|
+
// If it's the last item
|
|
48
|
+
if (i === valuesForKey.length - 1) {
|
|
49
|
+
return;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
const date = value.x;
|
|
53
|
+
const nextDate = valuesForKey[i + 1].x;
|
|
54
|
+
|
|
55
|
+
if (!checkDatesConsecutive([date, nextDate], units)) {
|
|
56
|
+
const missingDates = getMissingConsecutiveDates({
|
|
57
|
+
dates: [date, nextDate],
|
|
58
|
+
timerange,
|
|
59
|
+
});
|
|
60
|
+
finalValues = finalValues.concat(
|
|
61
|
+
missingDates.map((stringDate) => {
|
|
62
|
+
return {
|
|
63
|
+
x: stringDate,
|
|
64
|
+
value: 0,
|
|
65
|
+
type: value.type,
|
|
66
|
+
stacked: value.stacked,
|
|
67
|
+
};
|
|
68
|
+
})
|
|
69
|
+
);
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
const sortedData = finalValues.sort((a, b) => {
|
|
75
|
+
if (a["x"] < b["x"]) {
|
|
76
|
+
return -1;
|
|
77
|
+
}
|
|
78
|
+
if (a["x"] > b["x"]) {
|
|
79
|
+
return 1;
|
|
80
|
+
}
|
|
81
|
+
return 0;
|
|
82
|
+
});
|
|
83
|
+
return sortedData;
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
export function getMissingConsecutiveDates({
|
|
87
|
+
dates,
|
|
88
|
+
timerange,
|
|
89
|
+
}: {
|
|
90
|
+
dates: string[];
|
|
91
|
+
timerange: string;
|
|
92
|
+
}) {
|
|
93
|
+
const missingDates: string[] = [];
|
|
94
|
+
const units = `${timerange}s` as any;
|
|
95
|
+
if (dates.length === 1) {
|
|
96
|
+
return dates;
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
const sortedDates = dates.sort((a, b) => {
|
|
100
|
+
if (a < b) {
|
|
101
|
+
return -1;
|
|
102
|
+
}
|
|
103
|
+
if (a > b) {
|
|
104
|
+
return 1;
|
|
105
|
+
}
|
|
106
|
+
return 0;
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
for (let i = 0; i < sortedDates.length - 1; i++) {
|
|
110
|
+
const date1 = sortedDates[i];
|
|
111
|
+
const date2 = sortedDates[i + 1];
|
|
112
|
+
|
|
113
|
+
if (!checkDatesConsecutive([date1, date2], units)) {
|
|
114
|
+
let iDate = moment(date1, getFormatForUnits(units)).add(1, units);
|
|
115
|
+
let fDate = moment(date2, getFormatForUnits(units));
|
|
116
|
+
|
|
117
|
+
while (iDate.isBefore(fDate)) {
|
|
118
|
+
missingDates.push(iDate.format(getFormatForUnits(units)));
|
|
119
|
+
iDate.add(1, units);
|
|
120
|
+
}
|
|
121
|
+
}
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
return missingDates;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
export function combineValuesForTimerange({
|
|
128
|
+
values,
|
|
129
|
+
timerange,
|
|
130
|
+
}: {
|
|
131
|
+
values: any[];
|
|
132
|
+
timerange: string;
|
|
133
|
+
}) {
|
|
134
|
+
const adjustedValues = adjustXValuesForTimeRage({
|
|
135
|
+
values,
|
|
136
|
+
timerange,
|
|
137
|
+
});
|
|
138
|
+
let finalValues: any[] = [];
|
|
139
|
+
|
|
140
|
+
// group by x, type and stacked
|
|
141
|
+
const uniqueValues: { [key: string]: any } = getUniqueValuesGroupedBy({
|
|
142
|
+
values: adjustedValues,
|
|
143
|
+
groupBy: "all",
|
|
144
|
+
});
|
|
145
|
+
|
|
146
|
+
Object.keys(uniqueValues).forEach((key) => {
|
|
147
|
+
const valuesForKey = uniqueValues[key];
|
|
148
|
+
|
|
149
|
+
const finalValue = getValueForOperator({
|
|
150
|
+
values: valuesForKey.map((entry: any) => entry.value),
|
|
151
|
+
operator: valuesForKey[0].operator,
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
finalValues.push({
|
|
155
|
+
...valuesForKey[0],
|
|
156
|
+
value: finalValue,
|
|
157
|
+
});
|
|
158
|
+
});
|
|
159
|
+
|
|
160
|
+
return finalValues;
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
export function adjustXValuesForTimeRage({
|
|
164
|
+
values,
|
|
165
|
+
timerange,
|
|
166
|
+
}: {
|
|
167
|
+
values: any[];
|
|
168
|
+
timerange: string;
|
|
169
|
+
}) {
|
|
170
|
+
return values.map((value) => {
|
|
171
|
+
return {
|
|
172
|
+
...value,
|
|
173
|
+
x: convertDateToTimeRangeAdjusted({
|
|
174
|
+
date: value.x,
|
|
175
|
+
timerange: timerange,
|
|
176
|
+
}),
|
|
177
|
+
};
|
|
178
|
+
});
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
export function convertDateToTimeRangeAdjusted({
|
|
182
|
+
date,
|
|
183
|
+
timerange,
|
|
184
|
+
}: {
|
|
185
|
+
date: string;
|
|
186
|
+
timerange: string;
|
|
187
|
+
}) {
|
|
188
|
+
let format = getDateFormat(date);
|
|
189
|
+
const momentDate = moment(date, format);
|
|
190
|
+
switch (timerange) {
|
|
191
|
+
case "hour": {
|
|
192
|
+
format = "YYYY-MM-DD HH:00";
|
|
193
|
+
break;
|
|
194
|
+
}
|
|
195
|
+
case "day": {
|
|
196
|
+
format = "YYYY-MM-DD";
|
|
197
|
+
break;
|
|
198
|
+
}
|
|
199
|
+
case "week": {
|
|
200
|
+
format = "YYYY-WW";
|
|
201
|
+
break;
|
|
202
|
+
}
|
|
203
|
+
case "month": {
|
|
204
|
+
format = "YYYY-MM";
|
|
205
|
+
break;
|
|
206
|
+
}
|
|
207
|
+
case "year": {
|
|
208
|
+
format = "YYYY";
|
|
209
|
+
break;
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
return momentDate.format(format);
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
export function getDateFormat(date: string) {
|
|
216
|
+
return date.indexOf(":") ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD";
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
export function checkDatesConsecutive(
|
|
220
|
+
dates: string[],
|
|
221
|
+
unit: "hours" | "days" | "weeks" | "months" | "years"
|
|
222
|
+
) {
|
|
223
|
+
let consecutive = false;
|
|
224
|
+
const format = getFormatForUnits(unit);
|
|
225
|
+
|
|
226
|
+
if (dates.length === 0) {
|
|
227
|
+
return false;
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
if (dates.length === 1) {
|
|
231
|
+
return true;
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
for (let i = 0; i < dates.length - 1; i++) {
|
|
235
|
+
const date1 = moment(dates[i], format);
|
|
236
|
+
const date2 = moment(dates[i + 1], format);
|
|
237
|
+
const diff = date2.diff(date1, unit);
|
|
238
|
+
|
|
239
|
+
if (Math.abs(diff) === 1) {
|
|
240
|
+
consecutive = true;
|
|
241
|
+
} else {
|
|
242
|
+
consecutive = false;
|
|
243
|
+
}
|
|
244
|
+
}
|
|
245
|
+
return consecutive;
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
export function getUniqueValuesGroupedBy({
|
|
249
|
+
values,
|
|
250
|
+
groupBy,
|
|
251
|
+
}: {
|
|
252
|
+
values: any[];
|
|
253
|
+
groupBy: "all" | "type-stacked";
|
|
254
|
+
}) {
|
|
255
|
+
const uniqueValues: { [key: string]: any } = {};
|
|
256
|
+
values.forEach((value) => {
|
|
257
|
+
const x = value.x;
|
|
258
|
+
const type = value.type;
|
|
259
|
+
const stacked = value.stacked;
|
|
260
|
+
const uniqueKey =
|
|
261
|
+
groupBy === "all" ? `${x}-${type}-${stacked}` : `${type}-${stacked}`;
|
|
262
|
+
if (!uniqueValues[uniqueKey]) {
|
|
263
|
+
uniqueValues[uniqueKey] = [];
|
|
264
|
+
}
|
|
265
|
+
uniqueValues[uniqueKey].push(value);
|
|
266
|
+
});
|
|
267
|
+
return uniqueValues;
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
export function getFormatForUnits(units: string) {
|
|
271
|
+
switch (units) {
|
|
272
|
+
default:
|
|
273
|
+
case "hours": {
|
|
274
|
+
return "YYYY-MM-DD HH:mm";
|
|
275
|
+
}
|
|
276
|
+
case "days": {
|
|
277
|
+
return "YYYY-MM-DD";
|
|
278
|
+
}
|
|
279
|
+
case "weeks": {
|
|
280
|
+
return "YYYY-WW";
|
|
281
|
+
}
|
|
282
|
+
case "months": {
|
|
283
|
+
return "YYYY-MM";
|
|
284
|
+
}
|
|
285
|
+
case "years": {
|
|
286
|
+
return "YYYY";
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
}
|
|
@@ -37,16 +37,4 @@ describe("A Domain Parser", () => {
|
|
|
37
37
|
expect(domainForStageId![0][1]).toBe("ilike");
|
|
38
38
|
expect(domainForStageId![0][2]).toBe("backlog");
|
|
39
39
|
});
|
|
40
|
-
|
|
41
|
-
it("should properly transform plain domain", () => {
|
|
42
|
-
const domain = [["partner_id", "=", 3]];
|
|
43
|
-
const test = transformDomainForChildWidget({
|
|
44
|
-
domain: domain,
|
|
45
|
-
widgetFieldName: "bank",
|
|
46
|
-
}) as any;
|
|
47
|
-
expect(test!.length).toBe(1);
|
|
48
|
-
expect(test![0][0]).toBe("partner_id");
|
|
49
|
-
expect(test![0][1]).toBe("=");
|
|
50
|
-
expect(test![0][2]).toBe(3);
|
|
51
|
-
});
|
|
52
40
|
});
|
|
@@ -397,6 +397,25 @@ describe("in processGraphData method", () => {
|
|
|
397
397
|
expect(obj2!.value).toBe(0);
|
|
398
398
|
expect(obj2!.type).toBe("Generació - sortida");
|
|
399
399
|
});
|
|
400
|
+
|
|
401
|
+
it("should do basic test with a timerange for days", () => {
|
|
402
|
+
const { data, isGroup, isStack } = getGraphData(
|
|
403
|
+
`<?xml version="1.0"?>
|
|
404
|
+
<graph type="line" timerange="day">
|
|
405
|
+
<field name="data_alta" axis="x"/>
|
|
406
|
+
<field name="data_alta" operator="count" axis="y"/>
|
|
407
|
+
</graph>
|
|
408
|
+
`,
|
|
409
|
+
"polissa"
|
|
410
|
+
);
|
|
411
|
+
|
|
412
|
+
expect(isGroup).toBe(false);
|
|
413
|
+
expect(isStack).toBe(false);
|
|
414
|
+
|
|
415
|
+
expect(data).toBeTruthy();
|
|
416
|
+
expect(data.length).not.toBe(13);
|
|
417
|
+
expect(data.some((entry) => entry.x === false)).toBeFalsy();
|
|
418
|
+
});
|
|
400
419
|
});
|
|
401
420
|
|
|
402
421
|
function getModelData(model: string) {
|
|
@@ -0,0 +1,603 @@
|
|
|
1
|
+
import {
|
|
2
|
+
checkDatesConsecutive,
|
|
3
|
+
adjustXValuesForTimeRage,
|
|
4
|
+
combineValuesForTimerange,
|
|
5
|
+
fillGapsInTimerangeData,
|
|
6
|
+
getMissingConsecutiveDates,
|
|
7
|
+
} from "../Graph/processor/timerangeHelper";
|
|
8
|
+
|
|
9
|
+
describe("a timerangeHelper", () => {
|
|
10
|
+
describe("in checkDatesConsecutive function", () => {
|
|
11
|
+
describe("with day units", () => {
|
|
12
|
+
it("should return true with only one date", () => {
|
|
13
|
+
const consecutive = checkDatesConsecutive(["2020-01-01"], "days");
|
|
14
|
+
expect(consecutive).toBeTruthy();
|
|
15
|
+
});
|
|
16
|
+
it("should return false with two non consecutive dates", () => {
|
|
17
|
+
const consecutive = checkDatesConsecutive(
|
|
18
|
+
["2020-01-01", "2020-01-05"],
|
|
19
|
+
"days"
|
|
20
|
+
);
|
|
21
|
+
expect(consecutive).toBeFalsy();
|
|
22
|
+
});
|
|
23
|
+
it("should return true with two consecutive dates", () => {
|
|
24
|
+
const consecutive = checkDatesConsecutive(
|
|
25
|
+
["2020-01-01", "2020-01-02"],
|
|
26
|
+
"days"
|
|
27
|
+
);
|
|
28
|
+
expect(consecutive).toBeTruthy();
|
|
29
|
+
});
|
|
30
|
+
it("should return false with three non consecutive dates", () => {
|
|
31
|
+
const consecutive = checkDatesConsecutive(
|
|
32
|
+
["2020-01-01", "2020-01-02", "2020-07-02"],
|
|
33
|
+
"days"
|
|
34
|
+
);
|
|
35
|
+
expect(consecutive).toBeFalsy();
|
|
36
|
+
});
|
|
37
|
+
});
|
|
38
|
+
describe("with hour units", () => {
|
|
39
|
+
it("should return true with only one date", () => {
|
|
40
|
+
const consecutive = checkDatesConsecutive(
|
|
41
|
+
["2020-01-01 18:00"],
|
|
42
|
+
"hours"
|
|
43
|
+
);
|
|
44
|
+
expect(consecutive).toBeTruthy();
|
|
45
|
+
});
|
|
46
|
+
it("should return false with two non consecutive dates", () => {
|
|
47
|
+
const consecutive = checkDatesConsecutive(
|
|
48
|
+
["2020-01-01 18:00", "2020-01-05 05:00"],
|
|
49
|
+
"hours"
|
|
50
|
+
);
|
|
51
|
+
expect(consecutive).toBeFalsy();
|
|
52
|
+
});
|
|
53
|
+
it("should return true with two consecutive dates", () => {
|
|
54
|
+
const consecutive = checkDatesConsecutive(
|
|
55
|
+
["2020-01-01 18:00", "2020-01-01 19:00"],
|
|
56
|
+
"hours"
|
|
57
|
+
);
|
|
58
|
+
expect(consecutive).toBeTruthy();
|
|
59
|
+
});
|
|
60
|
+
it("should return false with three non consecutive dates", () => {
|
|
61
|
+
const consecutive = checkDatesConsecutive(
|
|
62
|
+
["2020-01-01 01:00", "2020-01-01 04:00", "2020-01-02 01:00"],
|
|
63
|
+
"hours"
|
|
64
|
+
);
|
|
65
|
+
expect(consecutive).toBeFalsy();
|
|
66
|
+
});
|
|
67
|
+
});
|
|
68
|
+
describe("with week units", () => {
|
|
69
|
+
it("should return true with only one date", () => {
|
|
70
|
+
const consecutive = checkDatesConsecutive(["2020-01"], "weeks");
|
|
71
|
+
expect(consecutive).toBeTruthy();
|
|
72
|
+
});
|
|
73
|
+
it("should return false with two non consecutive dates", () => {
|
|
74
|
+
const consecutive = checkDatesConsecutive(
|
|
75
|
+
["2020-01", "2020-03"],
|
|
76
|
+
"weeks"
|
|
77
|
+
);
|
|
78
|
+
expect(consecutive).toBeFalsy();
|
|
79
|
+
});
|
|
80
|
+
it("should return true with two consecutive dates", () => {
|
|
81
|
+
const consecutive = checkDatesConsecutive(
|
|
82
|
+
["2020-24", "2020-25"],
|
|
83
|
+
"weeks"
|
|
84
|
+
);
|
|
85
|
+
expect(consecutive).toBeTruthy();
|
|
86
|
+
});
|
|
87
|
+
it("should return false with three non consecutive dates", () => {
|
|
88
|
+
const consecutive = checkDatesConsecutive(
|
|
89
|
+
["2020-01", "2020-02", "2020-04"],
|
|
90
|
+
"weeks"
|
|
91
|
+
);
|
|
92
|
+
expect(consecutive).toBeFalsy();
|
|
93
|
+
});
|
|
94
|
+
});
|
|
95
|
+
});
|
|
96
|
+
describe("in adjustXValuesForTimeRage function", () => {
|
|
97
|
+
it("should transform x values for same hour grouping", () => {
|
|
98
|
+
const values = [
|
|
99
|
+
{
|
|
100
|
+
x: "2022-06-01 15:03:11",
|
|
101
|
+
value: 1,
|
|
102
|
+
},
|
|
103
|
+
{
|
|
104
|
+
x: "2022-06-02 15:03:11",
|
|
105
|
+
value: 2,
|
|
106
|
+
},
|
|
107
|
+
{
|
|
108
|
+
x: "2022-06-03 15:03:11",
|
|
109
|
+
value: 3,
|
|
110
|
+
},
|
|
111
|
+
{
|
|
112
|
+
x: "2022-06-03 15:13:11",
|
|
113
|
+
value: 4,
|
|
114
|
+
},
|
|
115
|
+
{
|
|
116
|
+
x: "2022-06-03 16:13:11",
|
|
117
|
+
value: 5,
|
|
118
|
+
},
|
|
119
|
+
{
|
|
120
|
+
x: "2022-06-03 16:53:11",
|
|
121
|
+
value: 6,
|
|
122
|
+
},
|
|
123
|
+
{
|
|
124
|
+
x: "2022-06-03 16:59:11",
|
|
125
|
+
value: 7,
|
|
126
|
+
},
|
|
127
|
+
];
|
|
128
|
+
const adjustedValues = adjustXValuesForTimeRage({
|
|
129
|
+
values,
|
|
130
|
+
timerange: "hour",
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
expect(adjustedValues.length).toBe(7);
|
|
134
|
+
expect(adjustedValues[0].x).toBe("2022-06-01 15:00");
|
|
135
|
+
expect(adjustedValues[0].value).toBe(1);
|
|
136
|
+
expect(adjustedValues[1].x).toBe("2022-06-02 15:00");
|
|
137
|
+
expect(adjustedValues[1].value).toBe(2);
|
|
138
|
+
expect(adjustedValues[2].x).toBe("2022-06-03 15:00");
|
|
139
|
+
expect(adjustedValues[2].value).toBe(3);
|
|
140
|
+
expect(adjustedValues[3].x).toBe("2022-06-03 15:00");
|
|
141
|
+
expect(adjustedValues[3].value).toBe(4);
|
|
142
|
+
expect(adjustedValues[4].x).toBe("2022-06-03 16:00");
|
|
143
|
+
expect(adjustedValues[4].value).toBe(5);
|
|
144
|
+
expect(adjustedValues[5].x).toBe("2022-06-03 16:00");
|
|
145
|
+
expect(adjustedValues[5].value).toBe(6);
|
|
146
|
+
expect(adjustedValues[6].x).toBe("2022-06-03 16:00");
|
|
147
|
+
expect(adjustedValues[6].value).toBe(7);
|
|
148
|
+
});
|
|
149
|
+
it("should transform x values for same day grouping", () => {
|
|
150
|
+
const values = [
|
|
151
|
+
{
|
|
152
|
+
x: "2022-06-01 15:03:11",
|
|
153
|
+
value: 1,
|
|
154
|
+
},
|
|
155
|
+
{
|
|
156
|
+
x: "2022-06-02 15:03:11",
|
|
157
|
+
value: 2,
|
|
158
|
+
},
|
|
159
|
+
{
|
|
160
|
+
x: "2022-06-03 15:03:11",
|
|
161
|
+
value: 3,
|
|
162
|
+
},
|
|
163
|
+
{
|
|
164
|
+
x: "2022-06-03 15:13:11",
|
|
165
|
+
value: 4,
|
|
166
|
+
},
|
|
167
|
+
{
|
|
168
|
+
x: "2022-06-04 16:13:11",
|
|
169
|
+
value: 5,
|
|
170
|
+
},
|
|
171
|
+
{
|
|
172
|
+
x: "2022-06-04 16:53:11",
|
|
173
|
+
value: 6,
|
|
174
|
+
},
|
|
175
|
+
{
|
|
176
|
+
x: "2022-06-05 16:59:11",
|
|
177
|
+
value: 7,
|
|
178
|
+
},
|
|
179
|
+
];
|
|
180
|
+
const adjustedValues = adjustXValuesForTimeRage({
|
|
181
|
+
values,
|
|
182
|
+
timerange: "day",
|
|
183
|
+
});
|
|
184
|
+
|
|
185
|
+
expect(adjustedValues.length).toBe(7);
|
|
186
|
+
expect(adjustedValues[0].x).toBe("2022-06-01");
|
|
187
|
+
expect(adjustedValues[0].value).toBe(1);
|
|
188
|
+
expect(adjustedValues[1].x).toBe("2022-06-02");
|
|
189
|
+
expect(adjustedValues[1].value).toBe(2);
|
|
190
|
+
expect(adjustedValues[2].x).toBe("2022-06-03");
|
|
191
|
+
expect(adjustedValues[2].value).toBe(3);
|
|
192
|
+
expect(adjustedValues[3].x).toBe("2022-06-03");
|
|
193
|
+
expect(adjustedValues[3].value).toBe(4);
|
|
194
|
+
expect(adjustedValues[4].x).toBe("2022-06-04");
|
|
195
|
+
expect(adjustedValues[4].value).toBe(5);
|
|
196
|
+
expect(adjustedValues[5].x).toBe("2022-06-04");
|
|
197
|
+
expect(adjustedValues[5].value).toBe(6);
|
|
198
|
+
expect(adjustedValues[6].x).toBe("2022-06-05");
|
|
199
|
+
expect(adjustedValues[6].value).toBe(7);
|
|
200
|
+
});
|
|
201
|
+
it("should transform x values for same week grouping", () => {
|
|
202
|
+
const values = [
|
|
203
|
+
{
|
|
204
|
+
x: "2022-06-01 15:03:11",
|
|
205
|
+
value: 1,
|
|
206
|
+
},
|
|
207
|
+
{
|
|
208
|
+
x: "2022-06-02 15:03:11",
|
|
209
|
+
value: 2,
|
|
210
|
+
},
|
|
211
|
+
{
|
|
212
|
+
x: "2022-06-03 15:03:11",
|
|
213
|
+
value: 3,
|
|
214
|
+
},
|
|
215
|
+
{
|
|
216
|
+
x: "2022-06-03 15:13:11",
|
|
217
|
+
value: 4,
|
|
218
|
+
},
|
|
219
|
+
{
|
|
220
|
+
x: "2022-06-04 16:13:11",
|
|
221
|
+
value: 5,
|
|
222
|
+
},
|
|
223
|
+
{
|
|
224
|
+
x: "2022-06-04 16:53:11",
|
|
225
|
+
value: 6,
|
|
226
|
+
},
|
|
227
|
+
{
|
|
228
|
+
x: "2022-06-05 16:59:11",
|
|
229
|
+
value: 7,
|
|
230
|
+
},
|
|
231
|
+
{
|
|
232
|
+
x: "2022-06-15 16:59:11",
|
|
233
|
+
value: 8,
|
|
234
|
+
},
|
|
235
|
+
{
|
|
236
|
+
x: "2022-06-25 16:59:11",
|
|
237
|
+
value: 9,
|
|
238
|
+
},
|
|
239
|
+
];
|
|
240
|
+
const adjustedValues = adjustXValuesForTimeRage({
|
|
241
|
+
values,
|
|
242
|
+
timerange: "week",
|
|
243
|
+
});
|
|
244
|
+
|
|
245
|
+
expect(adjustedValues.length).toBe(9);
|
|
246
|
+
expect(adjustedValues[0].x).toBe("2022-22");
|
|
247
|
+
expect(adjustedValues[0].value).toBe(1);
|
|
248
|
+
expect(adjustedValues[1].x).toBe("2022-22");
|
|
249
|
+
expect(adjustedValues[1].value).toBe(2);
|
|
250
|
+
expect(adjustedValues[2].x).toBe("2022-22");
|
|
251
|
+
expect(adjustedValues[2].value).toBe(3);
|
|
252
|
+
expect(adjustedValues[3].x).toBe("2022-22");
|
|
253
|
+
expect(adjustedValues[3].value).toBe(4);
|
|
254
|
+
expect(adjustedValues[4].x).toBe("2022-22");
|
|
255
|
+
expect(adjustedValues[4].value).toBe(5);
|
|
256
|
+
expect(adjustedValues[5].x).toBe("2022-22");
|
|
257
|
+
expect(adjustedValues[5].value).toBe(6);
|
|
258
|
+
expect(adjustedValues[6].x).toBe("2022-22");
|
|
259
|
+
expect(adjustedValues[6].value).toBe(7);
|
|
260
|
+
expect(adjustedValues[7].x).toBe("2022-24");
|
|
261
|
+
expect(adjustedValues[7].value).toBe(8);
|
|
262
|
+
expect(adjustedValues[8].x).toBe("2022-25");
|
|
263
|
+
expect(adjustedValues[8].value).toBe(9);
|
|
264
|
+
});
|
|
265
|
+
it("should transform x values for same month grouping", () => {
|
|
266
|
+
const values = [
|
|
267
|
+
{
|
|
268
|
+
x: "2022-06-01 15:03:11",
|
|
269
|
+
value: 1,
|
|
270
|
+
},
|
|
271
|
+
{
|
|
272
|
+
x: "2022-06-02 15:03:11",
|
|
273
|
+
value: 2,
|
|
274
|
+
},
|
|
275
|
+
{
|
|
276
|
+
x: "2022-04-03 15:03:11",
|
|
277
|
+
value: 3,
|
|
278
|
+
},
|
|
279
|
+
{
|
|
280
|
+
x: "2022-04-03 15:13:11",
|
|
281
|
+
value: 4,
|
|
282
|
+
},
|
|
283
|
+
{
|
|
284
|
+
x: "2022-05-04 16:13:11",
|
|
285
|
+
value: 5,
|
|
286
|
+
},
|
|
287
|
+
{
|
|
288
|
+
x: "2022-01-04 16:53:11",
|
|
289
|
+
value: 6,
|
|
290
|
+
},
|
|
291
|
+
{
|
|
292
|
+
x: "2022-02-05 16:59:11",
|
|
293
|
+
value: 7,
|
|
294
|
+
},
|
|
295
|
+
{
|
|
296
|
+
x: "2022-02-15 16:59:11",
|
|
297
|
+
value: 8,
|
|
298
|
+
},
|
|
299
|
+
{
|
|
300
|
+
x: "2021-03-25 16:59:11",
|
|
301
|
+
value: 9,
|
|
302
|
+
},
|
|
303
|
+
];
|
|
304
|
+
const adjustedValues = adjustXValuesForTimeRage({
|
|
305
|
+
values,
|
|
306
|
+
timerange: "month",
|
|
307
|
+
});
|
|
308
|
+
|
|
309
|
+
expect(adjustedValues.length).toBe(9);
|
|
310
|
+
expect(adjustedValues[0].x).toBe("2022-06");
|
|
311
|
+
expect(adjustedValues[0].value).toBe(1);
|
|
312
|
+
expect(adjustedValues[1].x).toBe("2022-06");
|
|
313
|
+
expect(adjustedValues[1].value).toBe(2);
|
|
314
|
+
expect(adjustedValues[2].x).toBe("2022-04");
|
|
315
|
+
expect(adjustedValues[2].value).toBe(3);
|
|
316
|
+
expect(adjustedValues[3].x).toBe("2022-04");
|
|
317
|
+
expect(adjustedValues[3].value).toBe(4);
|
|
318
|
+
expect(adjustedValues[4].x).toBe("2022-05");
|
|
319
|
+
expect(adjustedValues[4].value).toBe(5);
|
|
320
|
+
expect(adjustedValues[5].x).toBe("2022-01");
|
|
321
|
+
expect(adjustedValues[5].value).toBe(6);
|
|
322
|
+
expect(adjustedValues[6].x).toBe("2022-02");
|
|
323
|
+
expect(adjustedValues[6].value).toBe(7);
|
|
324
|
+
expect(adjustedValues[7].x).toBe("2022-02");
|
|
325
|
+
expect(adjustedValues[7].value).toBe(8);
|
|
326
|
+
expect(adjustedValues[8].x).toBe("2021-03");
|
|
327
|
+
expect(adjustedValues[8].value).toBe(9);
|
|
328
|
+
});
|
|
329
|
+
it("should transform x values for same year grouping", () => {
|
|
330
|
+
const values = [
|
|
331
|
+
{
|
|
332
|
+
x: "2022-06-01 15:03:11",
|
|
333
|
+
value: 1,
|
|
334
|
+
},
|
|
335
|
+
{
|
|
336
|
+
x: "2022-06-02 15:03:11",
|
|
337
|
+
value: 2,
|
|
338
|
+
},
|
|
339
|
+
{
|
|
340
|
+
x: "2023-04-03 15:03:11",
|
|
341
|
+
value: 3,
|
|
342
|
+
},
|
|
343
|
+
{
|
|
344
|
+
x: "2023-04-03 15:13:11",
|
|
345
|
+
value: 4,
|
|
346
|
+
},
|
|
347
|
+
{
|
|
348
|
+
x: "2020-05-04 16:13:11",
|
|
349
|
+
value: 5,
|
|
350
|
+
},
|
|
351
|
+
{
|
|
352
|
+
x: "2020-01-04 16:53:11",
|
|
353
|
+
value: 6,
|
|
354
|
+
},
|
|
355
|
+
{
|
|
356
|
+
x: "2019-02-05 16:59:11",
|
|
357
|
+
value: 7,
|
|
358
|
+
},
|
|
359
|
+
{
|
|
360
|
+
x: "2018-02-15 16:59:11",
|
|
361
|
+
value: 8,
|
|
362
|
+
},
|
|
363
|
+
{
|
|
364
|
+
x: "2018-03-25 16:59:11",
|
|
365
|
+
value: 9,
|
|
366
|
+
},
|
|
367
|
+
];
|
|
368
|
+
const adjustedValues = adjustXValuesForTimeRage({
|
|
369
|
+
values,
|
|
370
|
+
timerange: "year",
|
|
371
|
+
});
|
|
372
|
+
|
|
373
|
+
expect(adjustedValues.length).toBe(9);
|
|
374
|
+
expect(adjustedValues[0].x).toBe("2022");
|
|
375
|
+
expect(adjustedValues[0].value).toBe(1);
|
|
376
|
+
expect(adjustedValues[1].x).toBe("2022");
|
|
377
|
+
expect(adjustedValues[1].value).toBe(2);
|
|
378
|
+
expect(adjustedValues[2].x).toBe("2023");
|
|
379
|
+
expect(adjustedValues[2].value).toBe(3);
|
|
380
|
+
expect(adjustedValues[3].x).toBe("2023");
|
|
381
|
+
expect(adjustedValues[3].value).toBe(4);
|
|
382
|
+
expect(adjustedValues[4].x).toBe("2020");
|
|
383
|
+
expect(adjustedValues[4].value).toBe(5);
|
|
384
|
+
expect(adjustedValues[5].x).toBe("2020");
|
|
385
|
+
expect(adjustedValues[5].value).toBe(6);
|
|
386
|
+
expect(adjustedValues[6].x).toBe("2019");
|
|
387
|
+
expect(adjustedValues[6].value).toBe(7);
|
|
388
|
+
expect(adjustedValues[7].x).toBe("2018");
|
|
389
|
+
expect(adjustedValues[7].value).toBe(8);
|
|
390
|
+
expect(adjustedValues[8].x).toBe("2018");
|
|
391
|
+
expect(adjustedValues[8].value).toBe(9);
|
|
392
|
+
});
|
|
393
|
+
});
|
|
394
|
+
describe("in combineValuesForTimerange function", () => {
|
|
395
|
+
it("should combine values for same hour grouping", () => {
|
|
396
|
+
const values = [
|
|
397
|
+
{
|
|
398
|
+
x: "2022-06-01 15:03:11",
|
|
399
|
+
value: 1,
|
|
400
|
+
operator: "+",
|
|
401
|
+
},
|
|
402
|
+
{
|
|
403
|
+
x: "2022-06-01 15:03:11",
|
|
404
|
+
value: 2,
|
|
405
|
+
operator: "+",
|
|
406
|
+
},
|
|
407
|
+
{
|
|
408
|
+
x: "2022-06-02 16:03:11",
|
|
409
|
+
value: 3,
|
|
410
|
+
operator: "+",
|
|
411
|
+
},
|
|
412
|
+
{
|
|
413
|
+
x: "2022-06-02 16:53:11",
|
|
414
|
+
value: 4,
|
|
415
|
+
operator: "+",
|
|
416
|
+
},
|
|
417
|
+
{
|
|
418
|
+
x: "2022-06-03 18:03:11",
|
|
419
|
+
value: 5,
|
|
420
|
+
operator: "+",
|
|
421
|
+
},
|
|
422
|
+
];
|
|
423
|
+
const combinedValues = combineValuesForTimerange({
|
|
424
|
+
values,
|
|
425
|
+
timerange: "hour",
|
|
426
|
+
});
|
|
427
|
+
|
|
428
|
+
expect(combinedValues.length).toBe(3);
|
|
429
|
+
expect(combinedValues[0].x).toBe("2022-06-01 15:00");
|
|
430
|
+
expect(combinedValues[0].value).toBe(3);
|
|
431
|
+
expect(combinedValues[1].x).toBe("2022-06-02 16:00");
|
|
432
|
+
expect(combinedValues[1].value).toBe(7);
|
|
433
|
+
expect(combinedValues[2].x).toBe("2022-06-03 18:00");
|
|
434
|
+
expect(combinedValues[2].value).toBe(5);
|
|
435
|
+
});
|
|
436
|
+
it("should combine values for same day grouping with type and stacked", () => {
|
|
437
|
+
const values = [
|
|
438
|
+
{
|
|
439
|
+
x: "2022-06-01 15:03:11",
|
|
440
|
+
value: 1,
|
|
441
|
+
operator: "+",
|
|
442
|
+
type: "Data alta",
|
|
443
|
+
stacked: "sortida",
|
|
444
|
+
},
|
|
445
|
+
{
|
|
446
|
+
x: "2022-06-01 15:03:11",
|
|
447
|
+
value: 2,
|
|
448
|
+
operator: "+",
|
|
449
|
+
type: "Data alta",
|
|
450
|
+
stacked: "sortida",
|
|
451
|
+
},
|
|
452
|
+
{
|
|
453
|
+
x: "2022-06-02 16:03:11",
|
|
454
|
+
value: 3,
|
|
455
|
+
operator: "+",
|
|
456
|
+
type: "Data baixa",
|
|
457
|
+
stacked: "entrada",
|
|
458
|
+
},
|
|
459
|
+
{
|
|
460
|
+
x: "2022-06-02 16:53:11",
|
|
461
|
+
value: 4,
|
|
462
|
+
operator: "+",
|
|
463
|
+
type: "Data alta",
|
|
464
|
+
stacked: "sortida",
|
|
465
|
+
},
|
|
466
|
+
{
|
|
467
|
+
x: "2022-06-03 18:03:11",
|
|
468
|
+
value: 5,
|
|
469
|
+
operator: "+",
|
|
470
|
+
type: "Data alta",
|
|
471
|
+
stacked: "sortida",
|
|
472
|
+
},
|
|
473
|
+
];
|
|
474
|
+
const combinedValues = combineValuesForTimerange({
|
|
475
|
+
values,
|
|
476
|
+
timerange: "day",
|
|
477
|
+
});
|
|
478
|
+
|
|
479
|
+
expect(combinedValues.length).toBe(4);
|
|
480
|
+
expect(combinedValues[0].x).toBe("2022-06-01");
|
|
481
|
+
expect(combinedValues[0].value).toBe(3);
|
|
482
|
+
expect(combinedValues[0].type).toBe("Data alta");
|
|
483
|
+
expect(combinedValues[0].stacked).toBe("sortida");
|
|
484
|
+
|
|
485
|
+
expect(combinedValues[1].x).toBe("2022-06-02");
|
|
486
|
+
expect(combinedValues[1].value).toBe(3);
|
|
487
|
+
expect(combinedValues[1].type).toBe("Data baixa");
|
|
488
|
+
expect(combinedValues[1].stacked).toBe("entrada");
|
|
489
|
+
|
|
490
|
+
expect(combinedValues[2].x).toBe("2022-06-02");
|
|
491
|
+
expect(combinedValues[2].value).toBe(4);
|
|
492
|
+
expect(combinedValues[2].type).toBe("Data alta");
|
|
493
|
+
expect(combinedValues[2].stacked).toBe("sortida");
|
|
494
|
+
|
|
495
|
+
expect(combinedValues[3].x).toBe("2022-06-03");
|
|
496
|
+
expect(combinedValues[3].value).toBe(5);
|
|
497
|
+
expect(combinedValues[3].type).toBe("Data alta");
|
|
498
|
+
expect(combinedValues[3].stacked).toBe("sortida");
|
|
499
|
+
});
|
|
500
|
+
});
|
|
501
|
+
describe("in getMissingConsecutiveDates function", () => {
|
|
502
|
+
it("should return missing consecutive dates by hour", () => {
|
|
503
|
+
const dates = ["2021-01-01 15:00", "2021-01-01 18:00"];
|
|
504
|
+
const missingDates = getMissingConsecutiveDates({
|
|
505
|
+
dates,
|
|
506
|
+
timerange: "hour",
|
|
507
|
+
});
|
|
508
|
+
expect(missingDates.length).toBe(2);
|
|
509
|
+
expect(missingDates[0]).toBe("2021-01-01 16:00");
|
|
510
|
+
expect(missingDates[1]).toBe("2021-01-01 17:00");
|
|
511
|
+
});
|
|
512
|
+
it("should return missing consecutive dates by hour in two different days", () => {
|
|
513
|
+
const dates = ["2021-01-01 23:00", "2021-01-02 05:00"];
|
|
514
|
+
const missingDates = getMissingConsecutiveDates({
|
|
515
|
+
dates,
|
|
516
|
+
timerange: "hour",
|
|
517
|
+
});
|
|
518
|
+
expect(missingDates.length).toBe(5);
|
|
519
|
+
expect(missingDates[0]).toBe("2021-01-02 00:00");
|
|
520
|
+
expect(missingDates[1]).toBe("2021-01-02 01:00");
|
|
521
|
+
expect(missingDates[2]).toBe("2021-01-02 02:00");
|
|
522
|
+
expect(missingDates[3]).toBe("2021-01-02 03:00");
|
|
523
|
+
expect(missingDates[4]).toBe("2021-01-02 04:00");
|
|
524
|
+
});
|
|
525
|
+
it("should return missing consecutive dates by day", () => {
|
|
526
|
+
const dates = ["2021-01-01", "2021-01-15"];
|
|
527
|
+
const missingDates = getMissingConsecutiveDates({
|
|
528
|
+
dates,
|
|
529
|
+
timerange: "day",
|
|
530
|
+
});
|
|
531
|
+
expect(missingDates.length).toBe(13);
|
|
532
|
+
expect(missingDates[0]).toBe("2021-01-02");
|
|
533
|
+
expect(missingDates[12]).toBe("2021-01-14");
|
|
534
|
+
});
|
|
535
|
+
it("should return missing consecutive dates by day different month", () => {
|
|
536
|
+
const dates = ["2021-01-31", "2021-02-02"];
|
|
537
|
+
const missingDates = getMissingConsecutiveDates({
|
|
538
|
+
dates,
|
|
539
|
+
timerange: "day",
|
|
540
|
+
});
|
|
541
|
+
expect(missingDates.length).toBe(1);
|
|
542
|
+
expect(missingDates[0]).toBe("2021-02-01");
|
|
543
|
+
});
|
|
544
|
+
it("should return missing consecutive dates by day different year", () => {
|
|
545
|
+
const dates = ["2021-12-31", "2022-01-02"];
|
|
546
|
+
const missingDates = getMissingConsecutiveDates({
|
|
547
|
+
dates,
|
|
548
|
+
timerange: "day",
|
|
549
|
+
});
|
|
550
|
+
expect(missingDates.length).toBe(1);
|
|
551
|
+
expect(missingDates[0]).toBe("2022-01-01");
|
|
552
|
+
});
|
|
553
|
+
it("should return missing consecutive dates by week", () => {
|
|
554
|
+
const dates = ["2021-50", "2021-52"];
|
|
555
|
+
const missingDates = getMissingConsecutiveDates({
|
|
556
|
+
dates,
|
|
557
|
+
timerange: "week",
|
|
558
|
+
});
|
|
559
|
+
expect(missingDates.length).toBe(1);
|
|
560
|
+
expect(missingDates[0]).toBe("2021-51");
|
|
561
|
+
});
|
|
562
|
+
it("should return missing consecutive dates by week between years", () => {
|
|
563
|
+
const dates = ["2021-52", "2022-02"];
|
|
564
|
+
const missingDates = getMissingConsecutiveDates({
|
|
565
|
+
dates,
|
|
566
|
+
timerange: "week",
|
|
567
|
+
});
|
|
568
|
+
expect(missingDates.length).toBe(1);
|
|
569
|
+
expect(missingDates[0]).toBe("2022-01");
|
|
570
|
+
});
|
|
571
|
+
});
|
|
572
|
+
describe("in fillGapsInTimerangeData function", () => {
|
|
573
|
+
it("should fill gaps in data for hour grouping", () => {
|
|
574
|
+
const values = [
|
|
575
|
+
{
|
|
576
|
+
x: "2022-06-01 15:00",
|
|
577
|
+
value: 1,
|
|
578
|
+
},
|
|
579
|
+
{
|
|
580
|
+
x: "2022-06-01 20:00",
|
|
581
|
+
value: 2,
|
|
582
|
+
},
|
|
583
|
+
];
|
|
584
|
+
const filledValues = fillGapsInTimerangeData({
|
|
585
|
+
values,
|
|
586
|
+
timerange: "hour",
|
|
587
|
+
});
|
|
588
|
+
expect(filledValues.length).toBe(6);
|
|
589
|
+
expect(filledValues[0].x).toBe("2022-06-01 15:00");
|
|
590
|
+
expect(filledValues[0].value).toBe(1);
|
|
591
|
+
expect(filledValues[1].x).toBe("2022-06-01 16:00");
|
|
592
|
+
expect(filledValues[1].value).toBe(0);
|
|
593
|
+
expect(filledValues[2].x).toBe("2022-06-01 17:00");
|
|
594
|
+
expect(filledValues[2].value).toBe(0);
|
|
595
|
+
expect(filledValues[3].x).toBe("2022-06-01 18:00");
|
|
596
|
+
expect(filledValues[3].value).toBe(0);
|
|
597
|
+
expect(filledValues[4].x).toBe("2022-06-01 19:00");
|
|
598
|
+
expect(filledValues[4].value).toBe(0);
|
|
599
|
+
expect(filledValues[5].x).toBe("2022-06-01 20:00");
|
|
600
|
+
expect(filledValues[5].value).toBe(2);
|
|
601
|
+
});
|
|
602
|
+
});
|
|
603
|
+
});
|