Implement CSV download

client/components/container.js

@@ -4,12 +4,14 @@ import m from "mithril";
 import * as components from "../components";
 import * as store from "../store";
 import * as expression from "../../common/expression";
-import * as funcCache from "../../common/func-cache";
+import memoize from "../../common/memoize";
+
+const memoizedParse = memoize(expression.parse);
 
 const component = {
   view: vnode => {
     if (vnode.attrs.filter) {
-      const filter = funcCache.get(expression.parse, vnode.attrs.filter);
+      const filter = memoizedParse(vnode.attrs.filter);
       if (!store.evaluateExpression(filter, vnode.attrs.device)) return;
     }
 

client/components/device-faults.js

@@ -26,7 +26,7 @@ const component = {
         m("td", f["code"]),
         m("td", f["message"]),
         m("td", f["retries"]),
-        m("td", f["timestamp"]),
+        m("td", new Date(f["timestamp"]).toLocaleString()),
         m(
           "td",
           m(

client/components/overview-dot.js

@@ -3,8 +3,10 @@
 import m from "mithril";
 import config from "../config";
 import * as store from "../store";
-import * as funcCache from "../../common/func-cache";
 import * as expression from "../../common/expression";
+import memoize from "../../common/memoize";
+
+const memoizedParse = memoize(expression.parse);
 
 const CHARTS = config.ui.overview.charts;
 
@@ -13,7 +15,7 @@ const component = {
     const device = vnode.attrs.device;
     const chart = CHARTS[vnode.attrs.chart];
     for (let slice of Object.values(chart.slices)) {
-      const filter = funcCache.get(expression.parse, slice.filter);
+      const filter = memoizedParse(slice.filter);
       if (store.evaluateExpression(filter, device)) {
         const dot = m(
           "svg",

client/components/parameter-list.js

@@ -2,47 +2,29 @@
 
 import m from "mithril";
 import * as components from "../components";
-import * as store from "../store";
-import * as funcCache from "../../common/func-cache";
-import * as expression from "../../common/expression";
+import memoize from "../../common/memoize";
 
-const parseParameter = funcCache.getter(p => {
-  p = expression.parse(p);
-  if (Array.isArray(p) && p[0] === "PARAM") p = p[1];
-  return p;
-});
+const getChildAttrs = memoize((attrs, device) =>
+  Object.assign({}, attrs, { device: device })
+);
 
 const component = {
-  oninit: vnode => {
-    vnode.state.parameters = Object.values(vnode.attrs.parameters).map(
-      parameter =>
-        Object.assign({}, parameter, {
-          parameter: parseParameter(parameter.parameter)
-        })
-    );
-  },
   view: vnode => {
     const device = vnode.attrs.device;
 
-    const rows = [];
-    for (let parameter of vnode.state.parameters) {
-      let p = store.evaluateExpression(parameter.parameter, device);
-
-      if (!(p in device)) continue;
-      rows.push(
+    const rows = Object.values(vnode.attrs.parameters).map(parameter =>
+      m(
+        "tr",
+        m("th", parameter.label),
         m(
-          "tr",
-          m("th", parameter.label),
+          "td",
           m(
-            "td",
-            m(
-              components.get(parameter.type || "parameter"),
-              Object.assign({}, parameter, { device: device, parameter: p })
-            )
+            components.get(parameter.type || "parameter"),
+            getChildAttrs(parameter, device)
           )
         )
-      );
-    }
+      )
+    );
 
     return m("table.parameter-list", rows);
   }

client/components/parameter-table.js

@@ -5,21 +5,18 @@ import * as components from "../components";
 import * as taskQueue from "../task-queue";
 import * as store from "../store";
 import * as expression from "../../common/expression";
-import * as funcCache from "../../common/func-cache";
-
-const parseParameter = funcCache.getter(p => {
-  p = expression.parse(p);
-  if (Array.isArray(p) && p[0] === "PARAM") p = p[1];
-  return p;
-});
+import * as expressionParser from "../../common/expression-parser";
 
 const component = {
   oninit: vnode => {
-    vnode.state.object = parseParameter(vnode.attrs.parameter);
+    let obj = expression.parse(vnode.attrs.parameter);
+    if (!Array.isArray(obj) || !obj[0] === "PARAM")
+      throw new Error("Object must be a parameter path");
+    vnode.state.object = obj[1];
     vnode.state.parameters = Object.values(vnode.attrs.childParameters).map(
       parameter => {
         return Object.assign({}, parameter, {
-          parameter: parseParameter(parameter.parameter)
+          parameter: expression.parse(parameter.parameter)
         });
       }
     );
@@ -46,22 +43,24 @@ const component = {
 
     const rows = [];
     for (let i of instances) {
-      const row = parameters.map(p =>
-        m(
+      const row = parameters.map(p => {
+        const param = expressionParser.map(p.parameter, e => {
+          if (Array.isArray(e) && e[0] === "PARAM")
+            return ["PARAM", ["||", i, ".", e[1]]];
+          return e;
+        });
+        return m(
           "td",
           m(
             components.get(p.type || "parameter"),
             Object.assign({}, p, {
               device: device,
-              parameter: `${i}.${store.evaluateExpression(
-                p.parameter,
-                device
-              )}`,
+              parameter: expressionParser.stringify(param),
               label: ""
             })
           )
-        )
-      );
+        );
+      });
 
       if (device[i].writable === true)
         row.push(

client/components/parameter.js

@@ -2,19 +2,53 @@
 
 import m from "mithril";
 import * as taskQueue from "../task-queue";
+import * as store from "../store";
+import * as expression from "../../common/expression";
+import memoize from "../../common/memoize";
+
+const memoizedParse = memoize(expression.parse);
+
+const evaluateParam = memoize((exp, obj, now) => {
+  let timestamp = now;
+  let params = new Set();
+  let value = expression.evaluate(
+    memoizedParse(exp),
+    obj,
+    now,
+    e => {
+      if (Array.isArray(e)) {
+        if (e[0] === "PARAM") {
+          params.add(e[1]);
+          if (!Array.isArray(e[1])) {
+            let p = obj[e[1]];
+            if (p && p.valueTimestamp)
+              timestamp = Math.min(timestamp, p.valueTimestamp);
+          }
+        }
+        if (e[0] === "FUNC" && e[1] === "DATE_STRING" && !Array.isArray(e[2]))
+          return new Date(e[2]).toLocaleString();
+      }
+      return e;
+    }
+  );
+
+  let parameter = params.size === 1 ? params.values().next().value : null;
+  if (Array.isArray(parameter)) parameter = null;
+  return { value, timestamp, parameter };
+});
 
 const component = {
   view: vnode => {
     const device = vnode.attrs.device;
-    const parameter = vnode.attrs.parameter;
-    const param = device[parameter];
-    if (!param || !param.value) return m("span.na", "N/A");
-    let value = param.value[0];
-    if (param.value[1] === "xsd:dateTime")
-      value = new Date(value).toLocaleString();
+
+    let { value, timestamp, parameter } = evaluateParam(
+      vnode.attrs.parameter,
+      vnode.attrs.device,
+      store.getTimestamp()
+    );
 
     let edit;
-    if (param.writable)
+    if (device[parameter] && device[parameter].writable)
       edit = m(
         "button",
         {
@@ -23,19 +57,20 @@ const component = {
             taskQueue.stageSpv({
               name: "setParameterValues",
               device: device["DeviceID.ID"].value[0],
-              parameterValues: [[parameter, param.value[0], param.value[1]]]
+              parameterValues: [
+                [
+                  parameter,
+                  device[parameter].value[0],
+                  device[parameter].value[1]
+                ]
+              ]
             });
           }
         },
         "✎"
       );
 
-    return m(
-      "span.parameter-value",
-      { title: param.valueTimestamp },
-      value,
-      edit
-    );
+    return m("span.parameter-value", { title: timestamp }, value, edit);
   }
 };
 

client/components/summon-button.js

@@ -4,21 +4,12 @@ import m from "mithril";
 import * as taskQueue from "../task-queue";
 import * as store from "../store";
 import * as notifications from "../notifications";
-import * as funcCache from "../../common/func-cache";
 import * as expression from "../../common/expression";
+import memoize from "../../common/memoize";
 
-const parseParameter = funcCache.getter(p => {
-  p = expression.parse(p);
-  if (Array.isArray(p) && p[0] === "PARAM") p = p[1];
-  return p;
-});
+const memoizedParse = memoize(expression.parse);
 
 const component = {
-  oninit: vnode => {
-    vnode.state.parameters = Object.values(vnode.attrs.parameters).map(
-      parameter => parseParameter(parameter)
-    );
-  },
   view: vnode => {
     const device = vnode.attrs.device;
 
@@ -28,9 +19,14 @@ const component = {
         title: "Initiate session and refresh basic parameters",
         onclick: e => {
           e.target.disabled = true;
-          const params = vnode.state.parameters.map(p =>
-            store.evaluateExpression(p, device)
-          );
+          const params = Object.values(vnode.attrs.parameters)
+            .map(p => {
+              const exp = memoizedParse(p);
+              if (!Array.isArray(exp) || !exp[0] == "PARAM") return null;
+              return store.evaluateExpression(exp[1], device);
+            })
+            .filter(exp => !!exp);
+
           const task = {
             name: "getParameterValues",
             parameterNames: params,