@sis-cc/dotstatsuite-components 17.1.0 → 17.3.0

package/src/rules2/src/refineTimePeriod.js

@@ -0,0 +1,122 @@
+import * as R from 'ramda';
+import * as dateFns from 'date-fns';
+import { getLocale, dateWithoutTZ } from '../../rules/src/date';
+
+const computeDisplayFreq = (start, duration) => {
+  const startMinute = dateFns.startOfMinute(start);
+  const startHour = dateFns.startOfHour(start);
+  const startDay = dateFns.startOfDay(start);
+  if (!dateFns.isEqual(start, startMinute) || duration === 'S') {
+    return 'S';
+  }
+  else if (!dateFns.isEqual(start, startHour) || !dateFns.isEqual(start, startDay)
+    || duration === 'H' || duration === 'm') {
+    return 'm';
+  }
+  else if (!dateFns.isFirstDayOfMonth(start) || duration === 'D') {
+    return 'D';
+  }
+  else if (dateFns.getMonth(start) !== 0 || duration === 'M') {
+    return 'M';
+  }
+  return 'Y';
+};
+
+const getAdder = (duration) => {
+  if (duration === 'S')
+    return dateFns.addSeconds;
+  if (duration === 'm')
+    return dateFns.addMinutes;
+  if (duration === 'H')
+    return dateFns.addHours;
+  if (duration === 'D')
+    return dateFns.addDays;
+  if (duration === 'M')
+    return dateFns.addMonths;
+  return dateFns.addYears;
+};
+
+const getFormat = (freqDisplay) => {
+  if (freqDisplay === 'Y')
+    return 'YYYY';
+  if (freqDisplay === 'D')
+    return 'YYYY-MM-DD';
+  if (freqDisplay === 'H' || freqDisplay === 'm') {
+    return 'HH:mm';
+  }
+  if (freqDisplay === 'S') {
+    return 'HH:mm:ss';
+  }
+  return 'MMM';
+}
+
+const getEndDate = (start, mult, duration) => {
+  const adder = getAdder(duration);
+  let endDate = adder(start, Number(mult));
+  const startTZ = start.getTimezoneOffset();
+  const endTZ = endDate.getTimezoneOffset();
+  if (startTZ !== endTZ) {
+    endDate = dateFns.addMinutes(endDate, (Math.abs(endTZ) - Math.abs(startTZ)));
+  }
+  return dateFns.subSeconds(endDate, 1);
+};
+
+const computeName = (start, end, freqDisplay, locale) => {
+  const opts = { locale: getLocale(locale) };
+  const isSameDay = dateFns.isSameDay(start, end);
+  const isSameYear = dateFns.isSameYear(start, end);
+  if (freqDisplay === 'H' || freqDisplay === 'm' || freqDisplay === 'S') {
+    const dayFormat = getFormat('D');
+    const timeFormat = getFormat(freqDisplay);
+    if (isSameDay)
+      return `${dateFns.format(start, dayFormat, opts)} ${dateFns.format(start, timeFormat, opts)} - ${dateFns.format(end, timeFormat, opts)}`;
+    return `${dateFns.format(start, `${dayFormat} ${timeFormat}`, opts)} - ${dateFns.format(end, `${dayFormat} ${timeFormat}`, opts)}`;
+  }
+  if (freqDisplay === 'D' || freqDisplay === 'Y') {
+    const format = getFormat(freqDisplay);
+    return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
+  }
+  const yearFormat = getFormat('Y');
+  const monthFormat = getFormat('M');
+  if (isSameYear && locale === 'fr') {
+    return `${dateFns.format(start, monthFormat, opts)} - ${dateFns.format(end, monthFormat, opts)} ${dateFns.format(start, yearFormat, opts)}`;
+  }
+  const format = locale === 'fr' ? `${monthFormat} ${yearFormat}` : `${yearFormat}-${monthFormat}`;
+  return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
+};
+
+export const getStartDate = (start) => {
+  if (!R.includes('T', start) && !R.endsWith('Z', start)) {
+    return new Date(start);
+  }
+  const date = new Date(start);
+  return dateFns.addMinutes(date, -date.getTimezoneOffset());
+};
+
+export const refineTimePeriod = (timePeriod, { locale }) => {
+  const { id } = timePeriod;
+  const split = R.split('/', id);
+  if (R.length(split) !== 2) {
+    const start = getStartDate(R.prop('start', timePeriod));
+    const end = getStartDate(R.prop('end', timePeriod))
+    return ({ ...timePeriod, start: start.toISOString(), end: end.toISOString() });
+  }
+  const [start, range] = split;
+  const startDate = getStartDate(start);
+  const match = R.match(/^P(T?)(\d+)([YMDHS])$/, range);
+  if (R.isEmpty(match) || !dateFns.isValid(startDate)) {
+    return timePeriod;
+  }
+  const [timeIndicator, mult, _duration] = R.tail(match);
+  const duration = !R.isEmpty(timeIndicator) && _duration === 'M' ? 'm' : _duration;
+  const endDate = getEndDate(startDate, mult, duration);
+  const freqDisplay = computeDisplayFreq(start, duration);
+  const name = computeName(dateWithoutTZ(startDate), dateWithoutTZ(endDate), freqDisplay, locale);
+  return ({
+    ...timePeriod,
+    id,
+    name,
+    start: startDate.toISOString(),
+    end: endDate.toISOString()
+  })
+};

package/src/rules2/src/table/getLayout.js

@@ -59,6 +59,9 @@ export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted) =
           if (R.has(id, conceptIds)) {
             return acc;
           }
+          if (!R.has(id, indexedDimensions)) {
+            return acc;
+          }
           return R.append(R.prop(id, indexedDimensions), acc);
         },
         [],

package/test/getOneValueDimensions.test.js

@@ -13,20 +13,23 @@ describe('getOneValueDimensions tests', () => {
     ];
 
     const dimensions = [
-      { id: 'd0', values: [{ id: 'v' }] },
-      { id: 'd1', values: [{ id: 'v' }] },
-      { id: 'd2', display: false, values: [{ id: 'v' }] },
-      { id: 'd3', values: [{ id: 'v', display: false }] },
-      { id: 'd4', values: [{ id: '_T' }] },
-      { id: 'd5', values: [{ id: 'v0' }, { id: 'v1' }] },
+      { id: 'd0', header: true, values: [{ id: 'v' }] },
+      { id: 'd1', header: true, values: [{ id: 'v' }] },
+      { id: 'd2', header: true, display: false, values: [{ id: 'v' }] },
+      { id: 'd3', header: true, values: [{ id: 'v', display: false }] },
+      { id: 'd4', header: true, values: [{ id: '_T' }] },
+      { id: 'd5', header: true, values: [{ id: 'v0' }, { id: 'v1' }] },
+      { id: 'd6', header: false, values: [{ id: 'v0' }] },
+      { id: 'd7', header: false, values: [{ id: 'v0' }, { id: 'v1' }] },
     ];
 
     expect(getOneValueDimensions(dimensions, attributes)).to.deep.equal([
-      { id: 'd0', values: [{ id: 'v' }], attrValues: { a1: { id: 'a1', header: true, values: [{ id: 'v' }], relationship: ['d0'], value: { id: 'v' } } } },
-      { id: 'd1', values: [{ id: 'v' }], attrValues: {} },
-      { id: 'd2', values: [{ id: 'v' }], display: false, attrValues: {} },
-      { id: 'd3', values: [{ id: 'v', display: false }], attrValues: {} },
-      { id: 'd4', values: [{ id: '_T' }], attrValues: {} },
+      { id: 'd0', header: true, values: [{ id: 'v' }], attrValues: { a1: { id: 'a1', header: true, values: [{ id: 'v' }], relationship: ['d0'], value: { id: 'v' } } } },
+      { id: 'd1', header: true, values: [{ id: 'v' }], attrValues: {} },
+      { id: 'd2', header: true, values: [{ id: 'v' }], display: false, attrValues: {} },
+      { id: 'd3', header: true, values: [{ id: 'v', display: false }], attrValues: {} },
+      { id: 'd4', header: true, values: [{ id: '_T' }], attrValues: {} },
+      { id: 'd5', header: true, values: [{ id: 'v0' }, { id: 'v1' }], attrValues: {} },
     ])
   });
 });

package/test/parseAttributes.test.js

@@ -12,19 +12,19 @@ const attributes = [
 const customAttributes = {};
 
 const dimensions = [
-  { id: 'd1', values: [{ id: 'v0' }] },
-  { id: 'd2', values: [{ id: 'v0' }] },
-  { id: 'd3', values: [{ id: 'v0' }] },
-  { id: 'd4', values: [{ id: 'v0' }, { id: 'v1' }] },
-  { id: 'd5', values: [{ id: 'v0' }, { id: 'v1' }] },
-  { id: 'd6', values: [{ id: 'v0' }, { id: 'v1' }] },
+  { id: 'd1', header: true, values: [{ id: 'v0' }] },
+  { id: 'd2', header: true, values: [{ id: 'v0' }] },
+  { id: 'd3', header: true, values: [{ id: 'v0' }] },
+  { id: 'd4', header: false, values: [{ id: 'v0' }, { id: 'v1' }] },
+  { id: 'd5', header: false, values: [{ id: 'v0' }, { id: 'v1' }] },
+  { id: 'd6', header: false, values: [{ id: 'v0' }, { id: 'v1' }] },
 ];
 
 describe('parseAttributes test', () => {
   it('complete case', () => {
     expect(parseAttributes(attributes, dimensions, customAttributes)).to.deep.equal([
       { id: 'a6', index: 0, relationship: [], series: true, values: [{ id: 'a6v1' }] },
-      { id: 'a8', index: 1, relationship: ['d1'], header: true,values: [{ id: 'a8v1' }] },
+      { id: 'a8', index: 1, relationship: ['d1'], header: true, values: [{ id: 'a8v1' }] },
       { id: 'a9', index: 2, relationship: ['d4'], series: true, values: [{ id: 'a9v1' }] },
       { id: 'a10', index: 3, relationship: ['d1', 'd2'], header: true, values: [{ id: 'a10v1' }] },
       { id: 'a11', index: 4, relationship: ['d4'], series: true, values: [{ id: 'a11v1' }] },

package/test/parseCombinations.test.js

@@ -17,12 +17,12 @@ describe('parseCombinations tests', () => {
     ];
 
     const dimensions = [
-      { id: 'DIM1', values: [{ id: 'v1' }] },
-      { id: 'DIM2', values: [{ id: 'v1' }] },
-      { id: 'DIM3', values: [{ id: 'v1' }, { id: 'v2' }] },
-      { id: 'DIM4', values: [{ id: 'v1' }, { id: 'v2' }] },
-      { id: 'DIM5', values: [{ id: '_Z' }, { id: 'v2', display: false }] },
-      { id: 'DIM6', values: [{ id: 'v1', display: false }, { id: 'v2', display: false }] }
+      { id: 'DIM1',  header: true, values: [{ id: 'v1' }] },
+      { id: 'DIM2',  header: true, values: [{ id: 'v1' }] },
+      { id: 'DIM3',  header: false, values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'DIM4',  header: false, values: [{ id: 'v1' }, { id: 'v2' }] },
+      { id: 'DIM5',  header: false, values: [{ id: '_Z' }, { id: 'v2', display: false }] },
+      { id: 'DIM6',  header: false, values: [{ id: 'v1', display: false }, { id: 'v2', display: false }] }
     ];
 
     const attributes = [