viamapi-iframe.js

          ]);
          parent.onEvent(event);
          identityAuthenticatedEvent = true;
        }
      } else {
        const authenticationPublicKey = localStorage.getItem(
          "authenticatedIdentity"
        );

        if (authenticationPublicKey) {
          const result = await loadIdentityInternal(
            authenticationPublicKey,
            "00000000"
          );
          if (result.code !== "200") {
            const event = createEvent(
              "CanNotGetPincodeForAuthenticatedIdentity",
              "IdentityNotLoaded",
              [authenticationPublicKey]
            );
            parent.onEvent(event);
            clearPinCodeTtl(authenticationPublicKey);
            window.currentlyAuthenticatedIdentity = null;
          }
        }

        identityAuthenticatedEvent = false;
        window.currentlyLoadedIdentity = null;
      }
    }

    if (window.currentlyLoadedIdentity) {
      const pinCode = getPincode(
        window.currentlyLoadedIdentity.authentication.publicKey
      );
      if (!pinCode) {
        if (!identityLoadedEvent) {
          const result = await loadIdentityInternal(
            window.currentlyLoadedIdentity.authentication.publicKey,
            "00000000"
          );
          if (window.currentlyLoadedIdentity && result.code !== "200") {
            const event = createEvent(
              "CanNotLoadPincodeForLoadedIdentity",
              "IdentityNotLoaded",
              [window.currentlyLoadedIdentity.authentication.publicKey]
            );
            parent.onEvent(event);
            identityLoadedEvent = true;
          }
        }
      } else {
        identityLoadedEvent = false;
      }
    }

    if (window.currentlyAuthenticatedIdentity) {
      const now = new Date().getTime();
      if (now - window.lastTimeGetProfile > 30000) {
        getProfileData(window.currentlyAuthenticatedIdentity);
        window.lastTimeGetProfile = now;
      }
    }

    const currentLocalStorageUUID = localStorage.getItem("uuid");
    const currentLocalStorageToken = localStorage.getItem("token");
    const currentLocalStorageIdentity = localStorage.getItem(
      "authenticatedIdentity"
    );
    if (
      (!currentLocalStorageUUID && previousLocalStorageUUID) ||
      (!currentLocalStorageToken && previousLocalStorageToken) ||
      (!currentLocalStorageIdentity && previousLocalStorageIdentity)
    ) {
      previousLocalStorageUUID = null;
      previousLocalStorageToken = null;
      previousLocalStorageIdentity = null;

      destroyAuthentication();

      const event = createEvent("", "LogoutExternal");
      parent.onEvent(event);
    } else {
      previousLocalStorageUUID = currentLocalStorageUUID;
      previousLocalStorageToken = currentLocalStorageToken;
      previousLocalStorageIdentity = currentLocalStorageIdentity;
    }
  }, 50);

  const getNewEventsWithoutSession = async () => {
    anynomousDeviceKeyEventsProcessing = true;
    try {
      const executeResult = await executeRestfulFunction(
        "public",
        viamAnonymousApi,
        viamAnonymousApi.eventGetNewEventsWithoutSession,
        null,
        "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 "DeviceConfirmed": {
              await setIdentityInLocalStorage(window.currentlyLoadedIdentity);
              parent.onEvent(event);
              break;
            }

            case "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);
              });
              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);
            }
          }
          changedMaxDeviceKeyAnonymousEventTime = true;
          maxDeviceKeyAnonymousEventTime = Math.max(
            maxDeviceKeyAnonymousEventTime,
            event.stamp
          );
        }

        if (changedMaxDeviceKeyAnonymousEventTime) {
          await executeRestfulFunction(
            "public",
            viamAnonymousApi,
            viamAnonymousApi.eventUpdateLastViewedWithoutSession,
            null,
            "devicekey",
            maxDeviceKeyAnonymousEventTime.toString()
          );
        }
      }
    } catch (e) {
      console.warn(e);
    }
    anynomousDeviceKeyEventsProcessing = false;
  };

  const getNewDeviceEvents = async () => {
    eventsDeviceEventsProcessing = true;
    try {
      const executeResult = await executeRestfulFunction(
        "private",
        viamApi,
        viamApi.eventGetNewEvents,
        null,
        "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) {
          await executeRestfulFunction(
            "private",
            viamApi,
            viamApi.eventUpdateLastViewed,
            null,
            "devicekey",
            maxDeviceKeyEventTime.toString()
          );
        }
      }
    } catch (e) {
      console.warn(e);
    }
    eventsDeviceEventsProcessing = false;
  };

  const getNewEntityEvents = async () => {
    eventsEntityEventsProcessing = true;
    try {
      const executeResult = await executeRestfulFunction(
        "private",
        viamApi,
        viamApi.eventGetNewEvents,
        null,
        "entity"
      );

      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];

            const eventCopy = JSON.parse(JSON.stringify(event));

            QRCode.toDataURL(actionID + "," + QrCode, function(err, url) {
              eventCopy["payloads"].push(url);
              parent.onEvent(eventCopy);
            });

            continue;
          }

          parent.onEvent(event);
          changedMaxEntityEventTime = true;
          maxEntityEventTime = Math.max(maxEntityEventTime, event.stamp);
        }
        if (changedMaxEntityEventTime) {
          await executeRestfulFunction(
            "private",
            viamApi,
            viamApi.eventUpdateLastViewed,
            null,
            "entity",
            maxEntityEventTime.toString()
          );
        }
      }
    } catch (e) {
      console.warn(e);
    }
    eventsEntityEventsProcessing = false;
  };

  setInterval(() => {
    if (
      window.currentlyLoadedIdentity &&
      !anynomousDeviceKeyEventsProcessing &&
      !window.currentlyAuthenticatedIdentity
    ) {
      getNewEventsWithoutSession();
    }

    if (window.currentlyAuthenticatedIdentity) {
      // These functions has to be executed at the same time.
      !eventsDeviceEventsProcessing && getNewDeviceEvents();
      !eventsEntityEventsProcessing && getNewEntityEvents();
    }
  }, 1000);
});