Resolve "Can't send email when the gmail was left open and the pc went to sleep for a while"

Closes #16 (closed)

javascript/src/iframe/viamapi-iframe.js

@@ -215,32 +215,24 @@ const handleIdentityLogin = (identity, uuid, token) => {
   setKeyForUUID(uuid, publicKey);
 };
 
-function executeRestfulFunction(type, that, fn, ...args) {
+async function executeRestfulFunction(type, that, fn, ...args) {
   const { currentlyAuthenticatedIdentity, viamApi, currentlyLoadedIdentity } = window;
+  const response = await fn.apply(that, args);
 
-  return new Penpal.Promise(executeResult => {
-    fn.apply(that, args).then((response) => {
-      const identity = currentlyAuthenticatedIdentity || currentlyLoadedIdentity;
-
-      if (type === "private" && identity && response.data.code === "400" && response.data.status === "Bad session") {
-        viamApi.identityLogin("previousaddeddevice")
-          .then((response) => {
-            if (response.data.code === "200") {
-              const uuid = response.data.data["Uuid"];
-              const token = response.data.data["Session"];
-              handleIdentityLogin(identity, uuid, token);
-              // TODO: Previously there was fn.apply(null, args) where null is probably wrong context for fn.apply()
-              fn.apply(that, args).then(({data}) => executeResult(data));
-            } else {
-              executeResult(response.data);
-            }
-          })
-          .catch(console.warn);
-      } else {
-        executeResult(response.data);
-      }
-    });
-  });
+  const identity = currentlyAuthenticatedIdentity || currentlyLoadedIdentity;
+  const badSession = type === "private" && identity && response.data.code === "400" &&
+    response.data.status === "Bad session";
+
+  if (!badSession) return response.data;
+
+  const loginResponse = await viamApi.identityLogin("previousaddeddevice");
+  if (loginResponse.data.code !== "200") return loginResponse.data;
+
+  const uuid = loginResponse.data.data["Uuid"];
+  const token = loginResponse.data.data["Session"];
+  handleIdentityLogin(identity, uuid, token);
+  const { data } = await fn.apply(that, args);
+  return data;
 }
 
 window.executeRestfulFunction = executeRestfulFunction;
@@ -1101,17 +1093,17 @@ connection.promise.then(parent => {
     }
   }
 
-  var anynomousDeviceKeyEventsProcessing = false;
-  var maxDeviceKeyAnonymousEventTime = 0;
+  let anynomousDeviceKeyEventsProcessing = false;
+  let maxDeviceKeyAnonymousEventTime = 0;
 
-  var eventsDeviceEventsProcessing = false;
-  var maxDeviceKeyEventTime = 0;
+  let eventsDeviceEventsProcessing = false;
+  let maxDeviceKeyEventTime = 0;
 
-  var eventsEntityEventsProcessing = false;
-  var maxEntityEventTime = 0;
+  let eventsEntityEventsProcessing = false;
+  let maxEntityEventTime = 0;
 
-  var identityLoadedEvent = false;
-  var identityAuthenticatedEvent = false;
+  let identityLoadedEvent = false;
+  let identityAuthenticatedEvent = false;
 
   setInterval(async function () {
     if (window.currentlyAuthenticatedIdentity) {
@@ -1170,155 +1162,136 @@ connection.promise.then(parent => {
     }
   }, 50);
 
-  setInterval(function() {
+  setInterval(async function() {
     if (window.currentlyLoadedIdentity && !anynomousDeviceKeyEventsProcessing && !window.currentlyAuthenticatedIdentity) {
       anynomousDeviceKeyEventsProcessing = true;
-      executeRestfulFunction("public", viamAnonymousApi, viamAnonymousApi.eventGetNewEventsWithoutSession, "devicekey").then(async executeResult => {
-        if(executeResult.code === "200") {
-          var eventsLen = executeResult.data.length;
-          let changedMaxDeviceKeyAnonymousEventTime = false;
-          for (var i = 0; i < eventsLen; i++) {
-            var event = executeResult.data[i];
-            switch (event.type) {
-              case "Authenticated" : {
-                const uuid = event.payloads[0];
-                const token = event.payloads[1];
-                handleIdentityLogin(window.currentlyLoadedIdentity, uuid, token);
-                const identityToStore = window.currentlyAuthenticatedIdentity;
-                event.payloads = [{fromQRCode: true}];
-                setIdentityInLocalStorage(identityToStore).then(() => {
-                  getProfileData(identityToStore).then(() => {
-                    parent.onEvent(event);
-                  });
-                });
-                break;
-              }
-
-              case "QRCodeUpdated" : {
-                var actionID = event["actionID"];
-                var QrCode = event["payloads"][1];
+      const executeResult = await executeRestfulFunction("public", viamAnonymousApi, viamAnonymousApi.eventGetNewEventsWithoutSession, "devicekey");
+      if(executeResult.code === "200") {
+        const eventsLen = executeResult.data.length;
+        let changedMaxDeviceKeyAnonymousEventTime = false;
+        for (let i = 0; i < eventsLen; i++) {
+          const event = executeResult.data[i];
+          switch (event.type) {
+            case "Authenticated" : {
+              const uuid = event.payloads[0];
+              const token = event.payloads[1];
+              handleIdentityLogin(window.currentlyLoadedIdentity, uuid, token);
+              const identityToStore = window.currentlyAuthenticatedIdentity;
+              event.payloads = [{fromQRCode: true}];
+              await setIdentityInLocalStorage(identityToStore);
+              await getProfileData(identityToStore);
+              parent.onEvent(event);
+              break;
+            }
 
-                var eventCopy = JSON.parse(JSON.stringify(event));
+            case "QRCodeUpdated" : {
+              const actionID = event["actionID"];
+              const QrCode = event["payloads"][1];
 
-                QRCode.toDataURL(actionID + "," + QrCode, function (err, url) {
-                  eventCopy["payloads"].push(url);
-                  parent.onEvent(eventCopy)
-                });
-                break
-              }
+              const eventCopy = JSON.parse(JSON.stringify(event));
 
-              case "KeyDeleted" : {
-                const authenticationPublicKey = localStorage.getItem("authenticatedIdentity");
-                clearPinCodeTtl(authenticationPublicKey);
-                localStorage.removeItem("uuid");
-                localStorage.removeItem("token");
-                localStorage.removeItem("authenticatedIdentity");
-                delete window.loadedIdentities[authenticationPublicKey];
-                window.currentlyLoadedIdentity = null;
-                window.currentlyAuthenticatedIdentity = null;
-                window.lastTimeGetProfile = 0;
+              QRCode.toDataURL(actionID + "," + QrCode, function (err, url) {
+                eventCopy["payloads"].push(url);
+                parent.onEvent(eventCopy);
+              });
+              break;
+            }
 
-                destroyIdentityFromLocalStorage(authenticationPublicKey);
-                break
-              }
+            case "KeyDeleted" : {
+              const authenticationPublicKey = localStorage.getItem("authenticatedIdentity");
+              clearPinCodeTtl(authenticationPublicKey);
+              localStorage.removeItem("uuid");
+              localStorage.removeItem("token");
+              localStorage.removeItem("authenticatedIdentity");
+              delete window.loadedIdentities[authenticationPublicKey];
+              window.currentlyLoadedIdentity = null;
+              window.currentlyAuthenticatedIdentity = null;
+              window.lastTimeGetProfile = 0;
+
+              destroyIdentityFromLocalStorage(authenticationPublicKey);
+              break;
+            }
 
-              default : {
-                parent.onEvent(event)
-              }
+            default : {
+              parent.onEvent(event);
             }
-            changedMaxDeviceKeyAnonymousEventTime = true;
-            maxDeviceKeyAnonymousEventTime = Math.max(maxDeviceKeyAnonymousEventTime, event.stamp)
           }
+          changedMaxDeviceKeyAnonymousEventTime = true;
+          maxDeviceKeyAnonymousEventTime = Math.max(maxDeviceKeyAnonymousEventTime, event.stamp);
+        }
 
-          if(changedMaxDeviceKeyAnonymousEventTime) {
-            executeRestfulFunction("public", viamAnonymousApi, viamAnonymousApi.eventUpdateLastViewedWithoutSession,
-              "devicekey", maxDeviceKeyAnonymousEventTime.toString()).then(() => {
-              anynomousDeviceKeyEventsProcessing = false;
-            });
-          } else {
-            anynomousDeviceKeyEventsProcessing = false;
-          }
-        } else {
-          anynomousDeviceKeyEventsProcessing = false;
+        if(changedMaxDeviceKeyAnonymousEventTime) {
+          await executeRestfulFunction("public", viamAnonymousApi, viamAnonymousApi.eventUpdateLastViewedWithoutSession,
+            "devicekey", maxDeviceKeyAnonymousEventTime.toString());
         }
-      });
+      }
+      anynomousDeviceKeyEventsProcessing = false;
     }
 
     if (window.currentlyAuthenticatedIdentity != null && eventsDeviceEventsProcessing === false) {
       eventsDeviceEventsProcessing = true;
-      executeRestfulFunction("private", viamApi, viamApi.eventGetNewEvents, "devicekey").then(executeResult => {
-        if(executeResult.code === "200") {
-          var eventsLen = executeResult.data.length;
-          const changedMaxDeviceKeyEventTime = false;
-          for(var i = 0; i < eventsLen; i++) {
-            var event = executeResult.data[i];
-            if(event.type === "QRCodeUpdated") {
-              var actionID = event["actionID"];
-              var QrCode = event["payloads"][1];
-
-              var eventCopy = JSON.parse(JSON.stringify(event));
+      const executeResult = await executeRestfulFunction("private", viamApi, viamApi.eventGetNewEvents, "devicekey");
+      if (executeResult.code === "200") {
+        const eventsLen = executeResult.data.length;
+        const changedMaxDeviceKeyEventTime = false;
+        for (let i = 0; i < eventsLen; i++) {
+          const event = executeResult.data[i];
+          if (event.type === "QRCodeUpdated") {
+            const actionID = event["actionID"];
+            const QrCode = event["payloads"][1];
+
+            const eventCopy = JSON.parse(JSON.stringify(event));
 
-              QRCode.toDataURL(actionID + "," + QrCode, function (err, url) {
-                eventCopy["payloads"].push(url);
-                parent.onEvent(eventCopy)
-              })
-            } else {
-              parent.onEvent(event)
-            }
-            maxDeviceKeyEventTime = Math.max(maxDeviceKeyEventTime, event.stamp)
-          }
-          if(changedMaxDeviceKeyEventTime) {
-            executeRestfulFunction("private", viamApi, viamApi.eventUpdateLastViewed, "devicekey",
-              maxDeviceKeyEventTime.toString()).then(executeResult1 => {
-              eventsDeviceEventsProcessing = false
-            })
+            QRCode.toDataURL(actionID + "," + QrCode, function (err, url) {
+              eventCopy["payloads"].push(url);
+              parent.onEvent(eventCopy);
+            });
           } else {
-            eventsDeviceEventsProcessing = false
+            parent.onEvent(event);
           }
-        } else {
-          eventsDeviceEventsProcessing = false
+          maxDeviceKeyEventTime = Math.max(maxDeviceKeyEventTime, event.stamp);
         }
-      });
+        if(changedMaxDeviceKeyEventTime) {
+          await executeRestfulFunction("private", viamApi, viamApi.eventUpdateLastViewed, "devicekey",
+            maxDeviceKeyEventTime.toString());
+        }
+      }
+      eventsDeviceEventsProcessing = false;
     }
 
     if (window.currentlyAuthenticatedIdentity != null && eventsEntityEventsProcessing === false) {
       eventsEntityEventsProcessing = true;
-      executeRestfulFunction("private", viamApi, viamApi.eventGetNewEvents, "entity").then(executeResult => {
-        if(executeResult.code === "200") {
-          var eventsLen = executeResult.data.length;
-          let changedMaxEntityEventTime = false;
-          for(var i = 0; i < eventsLen; i++) {
-            event = executeResult.data[i];
-            if(event.type === "QRCodeUpdated") {
-              var actionID = event["actionID"];
-              var QrCode = event["payloads"][1];
-
-              var eventCopy = JSON.parse(JSON.stringify(event));
+      const executeResult = await executeRestfulFunction("private", viamApi, viamApi.eventGetNewEvents, "entity");
 
-              QRCode.toDataURL(actionID + "," + QrCode, function (err, url) {
-                eventCopy["payloads"].push(url);
-                parent.onEvent(eventCopy)
-              });
+      if (executeResult.code === "200") {
+        const eventsLen = executeResult.data.length;
+        let changedMaxEntityEventTime = false;
+        for (let i = 0; i < eventsLen; i++) {
+          const event = executeResult.data[i];
+          if (event.type === "QRCodeUpdated") {
+            const actionID = event["actionID"];
+            const QrCode = event["payloads"][1];
 
-              continue
-            }
+            const eventCopy = JSON.parse(JSON.stringify(event));
 
-            parent.onEvent(event);
-            changedMaxEntityEventTime = true;
-            maxEntityEventTime = Math.max(maxEntityEventTime, event.stamp)
-          }
-          if(changedMaxEntityEventTime) {
-            executeRestfulFunction("private", viamApi, viamApi.eventUpdateLastViewed, "entity",
-              maxEntityEventTime.toString()).then(executeResult1 => {
-              eventsEntityEventsProcessing = false
-            })
-          } else {
-            eventsEntityEventsProcessing = false
+            QRCode.toDataURL(actionID + "," + QrCode, function (err, url) {
+              eventCopy["payloads"].push(url);
+              parent.onEvent(eventCopy);
+            });
+
+            continue;
           }
-        } else {
-          eventsEntityEventsProcessing = false
+
+          parent.onEvent(event);
+          changedMaxEntityEventTime = true;
+          maxEntityEventTime = Math.max(maxEntityEventTime, event.stamp);
         }
-      });
+        if(changedMaxEntityEventTime) {
+          await executeRestfulFunction("private", viamApi, viamApi.eventUpdateLastViewed, "entity",
+            maxEntityEventTime.toString());
+        }
+      }
+      eventsEntityEventsProcessing = false;
     }
   }, 1000);
 });