Async/await let's go!

lib/ui/api-functions.ts

@@ -11,144 +11,110 @@ import {
   deleteDevice
 } from "../api-functions";
 
-function deleteFault(id): Promise<void> {
+async function deleteFault(id): Promise<void> {
   const deviceId = id.split(":", 1)[0];
   const channel = id.slice(deviceId.length + 1);
-  return new Promise((resolve, reject) => {
-    Promise.all([
-      db.deleteFault(id),
-      channel.startsWith("task_")
-        ? db.deleteTask(new ObjectID(channel.slice(5)))
-        : null
-    ])
-      .then(() => {
-        del(`${deviceId}_tasks_faults_operations`, err => {
-          err ? reject(err) : resolve();
-        });
-      })
-      .catch(reject);
-  });
+
+  await Promise.all([
+    db.deleteFault(id),
+    channel.startsWith("task_")
+      ? db.deleteTask(new ObjectID(channel.slice(5)))
+      : null
+  ]);
+
+  await del(`${deviceId}_tasks_faults_operations`);
 }
 
-export function deleteResource(resource, id): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let promise;
+export async function deleteResource(resource, id): Promise<void> {
+  switch (resource) {
+    case "devices":
+      await deleteDevice(id);
+      break;
 
-    switch (resource) {
-      case "devices":
-        promise = new Promise((res, rej) => {
-          deleteDevice(id, err => {
-            if (err) return void rej(err);
-            res();
-          });
-        });
-        break;
+    case "files":
+      await db.deleteFile(id);
+      break;
 
-      case "files":
-        promise = db.deleteFile(id);
-        break;
+    case "faults":
+      await deleteFault(id);
+      break;
 
-      case "faults":
-        promise = deleteFault(id);
-        break;
+    case "provisions":
+      await db.deleteProvision(id);
+      break;
 
-      case "provisions":
-        promise = db.deleteProvision(id);
-        break;
+    case "presets":
+      await db.deletePreset(id);
+      break;
 
-      case "presets":
-        promise = db.deletePreset(id);
-        break;
+    case "virtualParameters":
+      await db.deleteVirtualParameter(id);
+      break;
 
-      case "virtualParameters":
-        promise = db.deleteVirtualParameter(id);
-        break;
+    case "config":
+      await db.deleteConfig(id);
+      break;
 
-      case "config":
-        promise = db.deleteConfig(id);
-        break;
+    case "permissions":
+      await db.deletePermission(id);
+      break;
 
-      case "permissions":
-        promise = db.deletePermission(id);
-        break;
+    case "users":
+      await db.deleteUser(id);
+      break;
+  }
 
-      case "users":
-        promise = db.deleteUser(id);
-        break;
-    }
-
-    promise
-      .then(() => {
-        del("presets_hash", err => {
-          if (err) return void reject(err);
-          resolve();
-        });
-      })
-      .catch(reject);
-  });
+  await del("presets_hash");
 }
 
-export function postTasks(
+export async function postTasks(
   deviceId,
   tasks,
   timeout
 ): Promise<{ connectionRequest: string; tasks: any[] }> {
-  return new Promise((resolve, reject) => {
-    for (const task of tasks) task.device = deviceId;
+  for (const task of tasks) task.device = deviceId;
 
-    insertTasks(tasks, err => {
-      if (err) return void reject(err);
-      const statuses = tasks.map(t => {
-        return { _id: t._id, status: "pending" };
-      });
-      del(`${deviceId}_tasks_faults_operations`, err => {
-        if (err) return void reject(err);
-        connectionRequest(deviceId, err => {
-          if (err) {
-            return void resolve({
-              connectionRequest: err.message,
-              tasks: statuses
-            });
-          }
-
-          const sample = tasks[tasks.length - 1];
-
-          // Waiting for session to finish or timeout
-          watchTask(deviceId, sample._id, timeout, err => {
-            if (err) return void reject(err);
-
-            const promises2 = [];
-            for (const s of statuses) {
-              promises2.push(db.query("tasks", ["=", ["PARAM", "_id"], s._id]));
-              promises2.push(
-                db.query("faults", [
-                  "=",
-                  ["PARAM", "_id"],
-                  `${deviceId}:task_${s._id}`
-                ])
-              );
-            }
-
-            Promise.all(promises2)
-              .then(res => {
-                for (const [i, r] of statuses.entries()) {
-                  if (res[i * 2].length === 0) {
-                    r.status = "done";
-                  } else if (res[i * 2 + 1].length === 1) {
-                    r.status = "fault";
-                    r.fault = res[i * 2 + 1][0];
-                  }
-                  db.deleteTask(r._id);
-                }
-
-                resolve({ connectionRequest: "OK", tasks: statuses });
-              })
-              .catch(reject);
-          });
-        });
-      });
-    });
+  tasks = await insertTasks(tasks);
+  const statuses = tasks.map(t => {
+    return { _id: t._id, status: "pending" };
   });
+
+  await del(`${deviceId}_tasks_faults_operations`);
+
+  try {
+    await connectionRequest(deviceId);
+  } catch (err) {
+    return {
+      connectionRequest: err.message,
+      tasks: statuses
+    };
+  }
+
+  const sample = tasks[tasks.length - 1];
+
+  // Waiting for session to finish or timeout
+  await watchTask(deviceId, sample._id, timeout);
+
+  const promises = [];
+  for (const s of statuses) {
+    promises.push(db.query("tasks", ["=", ["PARAM", "_id"], s._id]));
+    promises.push(
+      db.query("faults", ["=", ["PARAM", "_id"], `${deviceId}:task_${s._id}`])
+    );
+  }
+
+  const res = await Promise.all(promises);
+  for (const [i, r] of statuses.entries()) {
+    if (res[i * 2].length === 0) {
+      r.status = "done";
+    } else if (res[i * 2 + 1].length === 1) {
+      r.status = "fault";
+      r.fault = res[i * 2 + 1][0];
+    }
+    db.deleteTask(r._id);
+  }
+
+  return { connectionRequest: "OK", tasks: statuses };
 }
 
 interface PingResponse {
@@ -184,35 +150,24 @@ export function ping(host): Promise<PingResponse> {
   });
 }
 
-export function putResource(resource, id, data): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let promise;
+export async function putResource(resource, id, data): Promise<void> {
+  if (resource === "presets") {
+    await db.putPreset(id, data);
+  } else if (resource === "provisions") {
+    await db.putProvision(id, data);
+  } else if (resource === "virtualParameters") {
+    await db.putVirtualParameter(id, data);
+  } else if (resource === "config") {
+    await db.putConfig(id, data);
+  } else if (resource === "permissions") {
+    await db.putPermission(id, data);
+  } else if (resource === "users") {
+    delete data.password;
+    delete data.salt;
+    await db.putUser(id, data);
+  }
 
-    if (resource === "presets") {
-      promise = db.putPreset(id, data);
-    } else if (resource === "provisions") {
-      promise = db.putProvision(id, data);
-    } else if (resource === "virtualParameters") {
-      promise = db.putVirtualParameter(id, data);
-    } else if (resource === "config") {
-      promise = db.putConfig(id, data);
-    } else if (resource === "permissions") {
-      promise = db.putPermission(id, data);
-    } else if (resource === "users") {
-      delete data.password;
-      delete data.salt;
-      promise = db.putUser(id, data);
-    }
-
-    promise
-      .then(() => {
-        del("presets_hash", err => {
-          if (err) return void reject(err);
-          resolve();
-        });
-      })
-      .catch(reject);
-  });
+  await del("presets_hash");
 }
 
 export function authSimple(snapshot, username, password): Promise<string[]> {

lib/ui/api.ts

@@ -546,16 +546,7 @@ router.put("/users/:id/password", async (ctx, next) => {
   const password = await hashPassword(newPassword, salt);
   await db.putUser(username, { password, salt });
 
-  function delCache(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      del("presets_hash", err => {
-        if (err) return void reject(err);
-        resolve();
-      });
-    });
-  }
-
-  await delCache();
+  await del("presets_hash");
 
   logger.accessInfo(log);
   ctx.body = "";