Add presets page

server/db.js

@@ -83,6 +83,8 @@ function query(resource, filter, options, callback) {
             docs = docs.map(d => mongodbFunctions.flattenFault(d));
           else if (resource === "tasks")
             docs = docs.map(d => mongodbFunctions.flattenTask(d));
+          else if (resource === "presets")
+            docs = docs.map(d => mongodbFunctions.flattenPreset(d));
           return resolve(docs);
         });
       else
@@ -94,6 +96,8 @@ function query(resource, filter, options, callback) {
               doc = mongodbFunctions.flattenFault(doc);
             else if (resource === "tasks")
               doc = mongodbFunctions.flattenTask(doc);
+            else if (resource === "presets")
+              doc = mongodbFunctions.flattenPreset(doc);
             callback(doc);
           },
           err => {

server/mongodb-functions.js

@@ -356,6 +356,98 @@ function flattenTask(task) {
   return t;
 }
 
+function mongoQueryToFilter(query) {
+  let expressions = [];
+  function recursive(_query) {
+    for (let [k, v] of Object.entries(_query))
+      if (k[0] == "$") {
+        if (k == "$and") for (let vv of Object.values(v)) recursive(vv);
+        else throw new Error(`Operator ${k} not supported`);
+      } else if (k == "_tags") {
+        if (typeof v === "object") {
+          if (Array.isArray(v)) throw new Error(`Invalid type`);
+
+          for (let [kk, vv] of Object.entries(v))
+            if (kk == "$ne")
+              expressions.push(["IS NULL", ["PARAM", `Tags.${vv}`]]);
+            else throw new Error(`Operator ${kk} not supported`);
+        } else {
+          expressions.push(["IS NOT NULL", ["PARAM", `Tags.${v}`]]);
+        }
+      } else if (typeof v === "object") {
+        if (Array.isArray(v)) throw new Error(`Invalid type`);
+
+        for (let [kk, vv] of Object.entries(v)) {
+          let op;
+          switch (kk) {
+            case "$eq":
+              op = "=";
+              break;
+            case "$ne":
+              op = "<>";
+              break;
+            case "$lt":
+              op = "<";
+              break;
+            case "$lte":
+              op = "<=";
+              break;
+            case "$gt":
+              op = ">";
+              break;
+            case "$gte":
+              op = ">=";
+              break;
+            default:
+              throw new Error(`Operator ${kk} not supported`);
+          }
+          expressions.push([op, ["PARAM", k], vv]);
+        }
+      } else {
+        expressions.push(["=", ["PARAM", k], v]);
+      }
+  }
+  recursive(query);
+
+  if (expressions.length > 1) return ["AND"].concat(expressions);
+
+  if (expressions.length == 1) return expressions[0];
+
+  return expressions;
+}
+
+function flattenPreset(preset) {
+  let p = Object.assign({}, preset);
+  if (p.precondition) {
+    p.precondition = mongoQueryToFilter(JSON.parse(p.precondition));
+    p.precondition = p.precondition.length
+      ? expression.stringify(p.precondition)
+      : "";
+  }
+
+  if (p.events) {
+    let e = [];
+    for (let [k, v] of Object.entries(p.events)) e.push(v ? k : `-${k}`);
+    p.events = e.join(", ");
+  }
+
+  let provision = p.configurations[0];
+  if (
+    p.configurations.length != 1 ||
+    provision.type != "provision" ||
+    !provision.name ||
+    !provision.name.length
+  )
+    throw new Error("Invalid preset provision");
+  p.provision = provision.name;
+  p.provision_args =
+    provision.args && provision.args.length
+      ? `"${provision.args.join('" "')}"`
+      : "";
+  delete p.configurations;
+  return p;
+}
+
 exports.processDeviceFilter = processDeviceFilter;
 exports.processTasksFilter = processTasksFilter;
 exports.processFaultsFilter = processFaultsFilter;
@@ -365,3 +457,4 @@ exports.processDeviceSort = processDeviceSort;
 exports.flattenDevice = flattenDevice;
 exports.flattenFault = flattenFault;
 exports.flattenTask = flattenTask;
+exports.flattenPreset = flattenPreset;

server/server.js

@@ -26,7 +26,14 @@ function getPermissionSets(roles) {
       p = Object.assign({}, p);
       for (let [k, v] of Object.entries(p)) {
         p[k] = v = Object.assign({}, v);
-        if (["devices", "faults", "files"].includes(k))
+        if (
+          [
+            "devices",
+            "faults",
+            "presets",
+            "files"
+          ].includes(k)
+        )
           if (v.filter == null || v.filter === "") v.filter = true;
           else {
             v.filter = expression.parse(v.filter);