@gisce/ooui 0.6.2 → 0.6.3

package/src/Graph/processor/graphProcessor.ts

@@ -0,0 +1,221 @@
+import { GraphChart, GraphYAxis, Operator } from "..";
+import { getValueAndLabelForField } from "./fieldUtils";
+
+export type GroupedValues = {
+  [key: string]: { label: string; entries: { [key: string]: any }[] };
+};
+
+export const labelsForOperator = {
+  count: "count",
+  "+": "sum",
+  "-": "subtract",
+  "*": "multiply",
+  avg: "average",
+  min: "min",
+  max: "max",
+};
+
+export const processGraphData = ({
+  ooui,
+  values,
+  fields,
+}: {
+  ooui: GraphChart;
+  values: { [key: string]: any }[];
+  fields: { [key: string]: any };
+}) => {
+  const valuesGroupedByX = getValuesGroupedByField({
+    fieldName: ooui.x.name,
+    values,
+    fields,
+  });
+
+  const fieldsData = {
+    xField: ooui.x.name,
+    yFields: [...new Set(ooui.y.map((item) => getYAxisFieldname(item)))],
+    seriesFields:
+      ooui.y.filter((yField) => yField.label).length !== 0
+        ? [...new Set(ooui.y.map((item) => item.label))]
+        : undefined,
+  };
+
+  const data: { [key: string]: any }[] = [];
+
+  ooui.y.forEach((yField) => {
+    Object.keys(valuesGroupedByX).forEach((xValue) => {
+      const xLabel = valuesGroupedByX[xValue].label;
+      const objectsForXValue = valuesGroupedByX[xValue].entries;
+
+      if (yField.label) {
+        const valuesGroupedByYLabel = getValuesGroupedByField({
+          fieldName: yField.label,
+          values: objectsForXValue,
+          fields,
+        });
+
+        Object.keys(valuesGroupedByYLabel).forEach((yUniqueValue) => {
+          const entries = valuesGroupedByYLabel[yUniqueValue].entries;
+          const label = valuesGroupedByYLabel[yUniqueValue].label;
+          const valuesForYField = entries
+            .map((obj) => {
+              return getValueAndLabelForField({
+                fieldName: yField.name,
+                values: obj,
+                fields: fields,
+              });
+            })
+            .map(({ value, label }) => {
+              return label;
+            });
+          const finalValue = getValueForOperator({
+            values: valuesForYField,
+            operator: yField.operator,
+          });
+          data.push({
+            [ooui.x.name]: xLabel || false,
+            [`${yField.name}_${
+              labelsForOperator[yField.operator!]
+            }`]: finalValue,
+            [yField.label!]: label,
+          });
+        });
+      } else {
+        const valuesForYField = objectsForXValue
+          .map((obj) => {
+            return getValueAndLabelForField({
+              fieldName: yField.name,
+              values: obj,
+              fields: fields,
+            });
+          })
+          .map(({ value, label }) => {
+            return label;
+          });
+
+        const finalValue = getValueForOperator({
+          values: valuesForYField,
+          operator: yField.operator,
+        });
+
+        data.push({
+          [ooui.x.name]: xLabel || false,
+          [getYAxisFieldname(yField)]: finalValue,
+        });
+      }
+    });
+  });
+
+  // If we don't have y axis fields with label specified, we need to,
+  // merge the results with the same name key
+  if (ooui.y.filter((yField) => yField.label).length === 0) {
+    const uniqueXkeys = [...new Set(data.map((item) => item[ooui.x.name]))];
+    const processedData = uniqueXkeys.map((key) => {
+      const mergedRecord = {};
+      const valuesForKey = data.filter((item) => item[ooui.x.name] === key);
+      valuesForKey.forEach((item) => {
+        Object.assign(mergedRecord, item);
+      });
+      return mergedRecord as { [key: string]: any };
+    });
+    return { data: processedData, ...fieldsData };
+  }
+
+  return {
+    data,
+    ...fieldsData,
+  };
+};
+
+export function getValueForOperator({
+  operator,
+  values,
+}: {
+  operator: Operator;
+  values: any[];
+}) {
+  switch (operator) {
+    case "count": {
+      return values.length;
+    }
+    case "+": {
+      return roundNumber(
+        values.reduce(function (previousValue: any, currentValue: any) {
+          return previousValue + currentValue;
+        })
+      );
+    }
+    case "-": {
+      return roundNumber(
+        values.reduce(function (previousValue: any, currentValue: any) {
+          return previousValue - currentValue;
+        })
+      );
+    }
+    case "*": {
+      return roundNumber(
+        values.reduce(function (previousValue: any, currentValue: any) {
+          return previousValue * currentValue;
+        })
+      );
+    }
+    case "avg": {
+      const sum = values.reduce((a: any, b: any) => a + b, 0);
+      const avg = sum / values.length || 0;
+      return roundNumber(avg);
+    }
+    case "min": {
+      return Math.min(...values);
+    }
+    case "max": {
+      return Math.max(...values);
+    }
+  }
+}
+
+function roundNumber(num: number) {
+  return Math.round((num + Number.EPSILON) * 100) / 100;
+}
+
+export function getValuesGroupedByField({
+  fieldName,
+  fields,
+  values,
+}: {
+  fieldName: string;
+  values: { [key: string]: any }[];
+  fields: { [key: string]: any };
+}) {
+  const groupedValues: GroupedValues = {};
+
+  values.forEach((entry) => {
+    const { value, label } = getValueAndLabelForField({
+      fields,
+      values: entry,
+      fieldName,
+    });
+
+    if (!groupedValues[value]) {
+      groupedValues[value] = { label, entries: [] };
+    }
+
+    groupedValues[value].entries.push(entry);
+  });
+
+  return groupedValues;
+}
+
+export function getAllObjectsInGroupedValues(grouped: GroupedValues) {
+  let totalObjects: any[] = [];
+  Object.keys(grouped).forEach((key) => {
+    const group = grouped[key];
+    totalObjects = totalObjects.concat(group.entries);
+  });
+  return totalObjects;
+}
+
+export function getYAxisFieldname(y: GraphYAxis) {
+  if (y.operator) {
+    return y.name + "_" + labelsForOperator[y.operator];
+  }
+  return y.name!;
+}

package/src/index.ts

@@ -42,6 +42,8 @@ import {
   GraphType,
   parseGraph,
   Operator,
+  GraphYAxis,
+  GraphXAxis,
 } from "./Graph";
 
 export {
@@ -82,6 +84,8 @@ export {
   DashboardItem,
   Graph,
   GraphAxis,
+  GraphYAxis,
+  GraphXAxis,
   GraphIndicator,
   GraphChart,
   GraphType,

package/src/spec/Graph.spec.ts

@@ -4,6 +4,7 @@ import {
   parseGraph,
   GraphAxis,
   GraphIndicatorField,
+  GraphYAxis,
 } from "..";
 
 describe("A Graph", () => {
@@ -28,7 +29,7 @@ describe("A Graph", () => {
     `;
 
     const graph = parseGraph(xml) as GraphChart;
-    const y: GraphAxis = graph.y[0];
+    const y: GraphYAxis = graph.y[0];
 
     expect(graph.type).toBe("line");
     expect(graph.x).toBeDefined();
@@ -37,7 +38,6 @@ describe("A Graph", () => {
     expect(y.name).toBe("data_alta");
     expect(graph.x.axis).toBe("x");
     expect(y.axis).toBe("y");
-    expect(graph.x?.operator).toBeUndefined();
     expect(y.operator).toBe("+");
   });
   it("should parse a basic XML title and type indicator field", () => {

package/src/spec/graphProcessor.spec.ts

@@ -0,0 +1,250 @@
+import models from "./mockData/graphs";
+import {
+  getAllObjectsInGroupedValues,
+  getValuesGroupedByField,
+  processGraphData,
+} from "../Graph/processor/graphProcessor";
+import { GraphChart, parseGraph } from "../Graph";
+
+describe("in getValuesGroupedByField method", () => {
+  it("should properly group a lectura values for field 'name' - char", () => {
+    const lecturaModel = models.find((m) => m.key === "lectura");
+    expect(lecturaModel).toBeDefined();
+    if (!lecturaModel) {
+      throw new Error("Model not found");
+    }
+    const lecturaValues = lecturaModel.data;
+    const lecturaFields = lecturaModel.fields;
+
+    const grouped = getValuesGroupedByField({
+      fieldName: "name",
+      values: lecturaValues as any,
+      fields: lecturaFields as any,
+    });
+
+    expect(getAllObjectsInGroupedValues(grouped).length).toBe(23);
+    expect(Object.keys(grouped).length).toBe(12);
+    expect(grouped["2020-09-30"].label).toBe("2020-09-30");
+    expect(grouped["2020-09-30"].entries.length).toBe(1);
+    expect(grouped["2020-09-30"].entries[0].name).toBe("2020-09-30");
+    expect(grouped["2020-07-31"].entries.length).toBe(6);
+    expect(grouped["2020-07-08"].entries.length).toBe(4);
+    expect(grouped["2020-05-31"].entries.length).toBe(2);
+    expect(grouped["2015-10-31"].entries.length).toBe(1);
+  });
+  it("should properly group a lectura values for field 'comptador' - many2one", () => {
+    const lecturaModel = models.find((m) => m.key === "lectura");
+    expect(lecturaModel).toBeDefined();
+    if (!lecturaModel) {
+      throw new Error("Model not found");
+    }
+    const lecturaValues = lecturaModel.data;
+    const lecturaFields = lecturaModel.fields;
+
+    const grouped = getValuesGroupedByField({
+      fieldName: "comptador",
+      values: lecturaValues as any,
+      fields: lecturaFields as any,
+    });
+
+    expect(getAllObjectsInGroupedValues(grouped).length).toBe(23);
+    expect(Object.keys(grouped).length).toBe(5);
+    expect(Object.keys(grouped).toString()).toBe("1,3,13,14,15");
+    expect(grouped["1"].label).toBe("B63011077");
+    expect(grouped["3"].label).toBe("42553686");
+    expect(grouped["13"].label).toBe("1234567898");
+    expect(grouped["1"].entries.length).toBe(5);
+    expect(grouped["3"].entries.length).toBe(1);
+    expect(grouped["13"].entries.length).toBe(6);
+  });
+  it("should properly group a lectura values for field 'motiu_ajust' - selection", () => {
+    const lecturaModel = models.find((m) => m.key === "lectura");
+    expect(lecturaModel).toBeDefined();
+    if (!lecturaModel) {
+      throw new Error("Model not found");
+    }
+    const lecturaValues = lecturaModel.data;
+    const lecturaFields = lecturaModel.fields;
+
+    const grouped = getValuesGroupedByField({
+      fieldName: "motiu_ajust",
+      values: lecturaValues as any,
+      fields: lecturaFields as any,
+    });
+
+    expect(getAllObjectsInGroupedValues(grouped).length).toBe(23);
+    expect(Object.keys(grouped).length).toBe(2);
+    expect(Object.keys(grouped).toString()).toBe("false,01");
+    expect(grouped["false"].label).toBeUndefined();
+    expect(grouped["false"].entries.length).toBe(21);
+    expect(grouped["01"].label).toBe("Verificación equipo de medida");
+    expect(grouped["01"].entries.length).toBe(2);
+  });
+  it("should properly throw an error if the field is not found", () => {
+    const lecturaModel = models.find((m) => m.key === "lectura");
+    expect(lecturaModel).toBeDefined();
+    if (!lecturaModel) {
+      throw new Error("Model not found");
+    }
+    const lecturaValues = lecturaModel.data;
+    const lecturaFields = lecturaModel.fields;
+
+    const test = () => {
+      getValuesGroupedByField({
+        fieldName: "data_alta",
+        values: lecturaValues as any,
+        fields: lecturaFields as any,
+      });
+
+      expect(test).toThrowError();
+    };
+  });
+});
+
+describe("in processGraphData method", () => {
+  it("should do basic test with one y axis", () => {
+    const parsedGraph = parseGraph(`<?xml version="1.0"?>
+    <graph type="pie">
+      <field name="llista_preu" axis="x"/>
+      <field name="llista_preu" operator="count" axis="y"/>
+    </graph>
+    `) as GraphChart;
+    const model = models.find((m) => m.key === "polissa");
+    expect(model).toBeDefined();
+    if (!model) {
+      throw new Error("Model not found");
+    }
+    const values = model.data;
+    const fields = model.fields;
+
+    const { data } = processGraphData({
+      ooui: parsedGraph,
+      values: values as any,
+      fields: fields as any,
+    });
+
+    expect(data.length).toBe(6);
+    expect(
+      data.find(
+        (d) =>
+          d.llista_preu === "TARIFAS ELECTRICIDAD (EUR)" &&
+          d.llista_preu_count === 8
+      )
+    ).toBeTruthy();
+    expect(
+      data.find(
+        (d) => d.llista_preu === "Adeu (CHF)" && d.llista_preu_count === 4
+      )
+    ).toBeTruthy();
+    expect(
+      data.find(
+        (d) =>
+          d.llista_preu === "Hola bipartit (EUR)" && d.llista_preu_count === 5
+      )
+    ).toBeTruthy();
+    expect(
+      data.find(
+        (d) =>
+          d.llista_preu === "Mucha potencia (EUR)" && d.llista_preu_count === 1
+      )
+    ).toBeTruthy();
+
+    expect(
+      data.find(
+        (d) => d.llista_preu === "Hola (EUR)" && d.llista_preu_count === 13
+      )
+    ).toBeTruthy();
+
+    expect(
+      data.find((d) => d.llista_preu === false && d.llista_preu_count === 2)
+    ).toBeTruthy();
+
+    expect(
+      data.find((d) => d.llista_preu === "random" && d.llista_preu_count === 15)
+    ).toBeUndefined();
+
+    expect(data).toBeTruthy();
+  });
+  it("should do basic test with two y axis", () => {
+    const parsedGraph = parseGraph(`<?xml version="1.0"?>
+    <graph type="bar">
+      <field name="name" axis="x" />
+      <field name="consum" operator="+" axis="y"/>
+      <field name="ajust" operator="+" axis="y" />
+    </graph>
+    `) as GraphChart;
+
+    const model = models.find((m) => m.key === "lectura");
+    expect(model).toBeDefined();
+    if (!model) {
+      throw new Error("Model not found");
+    }
+    const values = model.data;
+    const fields = model.fields;
+
+    const { data, xField, yFields, seriesFields } = processGraphData({
+      ooui: parsedGraph,
+      values: values as any,
+      fields: fields as any,
+    });
+
+    expect(xField).toBe("name");
+    expect(yFields!.length).toBe(2);
+    expect(yFields![0]).toBe("consum_sum");
+    expect(yFields![1]).toBe("ajust_sum");
+    expect(seriesFields).toBeUndefined();
+
+    expect(data.length).toBe(12);
+    expect(data.find((d) => d.name === "2020-09-30")).toBeTruthy();
+    const obj1 = data.find((d) => d.name === "2020-09-30")!;
+    expect(obj1.consum_sum).toBe(0);
+    expect(obj1.ajust_sum).toBe(0);
+    expect(data.find((d) => d.name === "2020-06-30")).toBeTruthy();
+    const obj2 = data.find((d) => d.name === "2020-06-30")!;
+    expect(obj2.consum_sum).toBe(150);
+    expect(obj2.ajust_sum).toBe(0);
+    expect(data.find((d) => d.name === "2016-04-04")).toBeTruthy();
+    const obj3 = data.find((d) => d.name === "2016-04-04")!;
+    expect(obj3.consum_sum).toBe(15);
+    expect(obj3.ajust_sum).toBe(15);
+  });
+  it("should do basic test with one y axis with label", () => {
+    const parsedGraph = parseGraph(`<?xml version="1.0"?>
+    <graph type="bar">
+      <field name="name" axis="x" />
+      <field name="consum" operator="+" label="periode" axis="y"/>
+    </graph>
+    `) as GraphChart;
+
+    const model = models.find((m) => m.key === "lectura");
+    expect(model).toBeDefined();
+    if (!model) {
+      throw new Error("Model not found");
+    }
+    const values = model.data;
+    const fields = model.fields;
+
+    const { data, xField, yFields, seriesFields } = processGraphData({
+      ooui: parsedGraph,
+      values: values as any,
+      fields: fields as any,
+    });
+
+    expect(xField).toBe("name");
+    expect(yFields!.length).toBe(1);
+    expect(yFields![0]).toBe("consum_sum");
+    expect(seriesFields!.length).toBe(1);
+    expect(seriesFields![0]).toBe("periode");
+
+    expect(data.length).toBe(15);
+    expect(data.find((d) => d.name === "2020-09-30")).toBeTruthy();
+    const obj1 = data.find((d) => d.name === "2020-09-30")!;
+    expect(obj1.consum_sum).toBe(0);
+    expect(obj1.periode).toBe("2.0A (P1)");
+    const obj2 = data.filter((d) => d.name === "2020-07-31")!;
+    expect(obj2.length).toBe(3);
+    expect(obj2.map((e) => e.periode).toString()).toBe(
+      "2.0A (P1),2.0DHA (P1),2.0DHA (P2)"
+    );
+  });
+});