viamapi-iframe.js

        if(success === false) {
          result({"data" : "",
            "code" : "400",
            "status" : "Identity not authenticated"
          })
        }

        executeRestfulFunction("private", viamApi, viamApi.identityHasSession, null).then(executeResult => {
          result(executeResult);
        });
      });
    },
    marketingSignUpIdentificator(identificator, reference) {
      return new Penpal.Promise(result => {
        viamApi.setIdentity("marketingapppublickey");

        executeRestfulFunction("public", viamApi, viamApi.marketingSignUpIdentificator, null, identificator, reference).then(executeResult => {
          viamApi.setIdentity("");
          viamApi.setSessionData("", "");
          result(executeResult);
        });
      });
    },
    marketingGetIdentificatorProfile(identificator, pincode) {
      return new Penpal.Promise(result => {
        viamApi.setIdentity("marketingapppublickey");

        executeRestfulFunction("public", viamApi, viamApi.marketingGetIdentificatorProfile, null, identificator, pincode).then(executeResult => {
          viamApi.setIdentity("");
          viamApi.setSessionData("", "");
          result(executeResult);
        });
      });
    },
    marketingExecuteEventForIdentificator(identificator, pincode, event) {
      return new Penpal.Promise(result => {
        viamApi.setIdentity("marketingapppublickey");

        executeRestfulFunction("public", viamApi, viamApi.marketingExecuteEventForIdentificator, null, identificator, pincode, event).then(executeResult => {
          viamApi.setIdentity("");
          viamApi.setSessionData("", "");
          result(executeResult);
        });
      });
    },
    getCurrentlyAuthenticatedIdentity() {
      const { publicKey, x509Certificate } = window.currentlyAuthenticatedIdentity.authentication;

      return encodeResponse(
        "200",
        {
          authentication: {
            publicKey,
            x509Certificate
          }
        },
        "Currently authenticated identity"
      );
    },
    stringToUtf8ByteArray(str) {
      if (typeof str !== 'string') {
        str = str.toString()
      }
      let res = Buffer.from(str,'utf-8');
      return new Penpal.Promise(result => {
        result(res)
      })
    },
    utf8ByteArrayToString(ba) {
      if (!Buffer.isBuffer(ba)) {
        ba = Buffer.from(ba)
      }
      let res = ba.toString('utf-8');
      return new Penpal.Promise(result => {
        result(res)
      })
    },
    stringToUtf8Base64(str) {
      if (!Buffer.isBuffer(str)) {
        if (typeof str !== 'string') {
          str = str.toString()
        }
        str = Buffer.from(str, 'utf-8')
      }
      let res = str.toString('base64');
      return new Penpal.Promise(result => {
        result(res)
      })
    },
    utf8Base64ToString(strBase64) {
      if (!Buffer.isBuffer(strBase64)) {
        if (typeof strBase64 !== 'string') {
          strBase64 = strBase64.toString()
        }
        strBase64 = Buffer.from(strBase64, 'base64')
      }
      let res = strBase64.toString('utf-8');
      return new Penpal.Promise(result => {
        result(res)
      })
    },
    base64ToByteArray(strBase64) {
      if (typeof strBase64 !== 'string') {
        strBase64 = strBase64.toString()
      }
      let res = Buffer.from(strBase64, 'base64');
      return new Penpal.Promise(result => {
        result(res)
      })
    },
    byteArrayToBase64(ba) {
      if (!Buffer.isBuffer(ba)) {
        ba = Buffer.from(ba)
      }
      let res = ba.toString('base64');
      return new Penpal.Promise(result => {
        result(res)
      })
    },

    // Collabora APIs
    collaboraDiscovery() {
      return collaboraApi.discovery().then(apps => apps);
    },

    // WOPI
    getPassports: async fileId => {
      const authenticationPublicKey = localStorage.getItem("authenticatedIdentity");

      if (
        !authenticationPublicKey ||
        !window.loadedIdentities[authenticationPublicKey] ||
        !extendPinCodeTtl(authenticationPublicKey)
      ) {
        return encodeResponse("400", "", "Identity not authenticated");
      }

      const response = await wopiAPI.getPassports(fileId);
      return response.data;
    },

    wopiPutFile: async (path, accessToken, file) => {
      const authenticationPublicKey = localStorage.getItem("authenticatedIdentity");

      if (
        !authenticationPublicKey ||
        !window.loadedIdentities[authenticationPublicKey] ||
        !extendPinCodeTtl(authenticationPublicKey)
      ) {
        return encodeResponse("400", "", "Identity not authenticated");
      }

      const response = await wopiAPI.putDocument(path, accessToken, file);
      return response.data;
    }
  }
});

connection.promise.then(parent => {
  iframeParent = parent;

  if (!navigator.cookieEnabled) {
    console.warn("Cookie disabled. Can't start library.");
    return;
  }

  window.addEventListener('storage', event => {
    if (event.key === "authenticatedIdentity" && event.newValue === null) {
      const publicKey = window.currentlyAuthenticatedIdentity.authentication.publicKey;
      window.currentlyLoadedIdentity = null;
      window.currentlyAuthenticatedIdentity = null;
      const event = createEvent("LogoutFromAnotherTab", "Logout", [publicKey]);
      parent.onEvent(event);
    }
  });

  const identities = localStorage.getItem("identities");

  console.log("Library loaded at: " + new Date().toISOString());

  if (identities === "" || identities === null) {
    localStorage.setItem("identities", JSON.stringify({}));
  }

  if (
    localStorage.getItem("uuid") === null ||
    localStorage.getItem("token") === null ||
    localStorage.getItem("authenticatedIdentity") === null
  ) {
    localStorage.removeItem("uuid");
    localStorage.removeItem("token");
    localStorage.removeItem("authenticatedIdentity");
  } else {
    const authenticationPublicKey = localStorage.getItem("authenticatedIdentity");
    const pinCode = getPincode(authenticationPublicKey);

    if (pinCode === "" || pinCode === null) {
      loadIdentityInternal(authenticationPublicKey, "00000000").then(result => {
        if (result.code !== "200") {
          const event = createEvent(
            "CanNotGetPincodeForAuthenticatedIdentity",
            "IdentityNotLoaded",
            [authenticationPublicKey]
          );
          parent.onEvent(event);
        }
      });
    } else {
      loadIdentityInternal(authenticationPublicKey, pinCode).then(result => {
        if (result.code !== "200") {
          const event = createEvent(
            "CanNotLoadIdentity",
            "ErrorDuringLoadingIdentity",
            [authenticationPublicKey]
          );
          parent.onEvent(event);
        }
      });
    }
  }

  let anynomousDeviceKeyEventsProcessing = false;
  let maxDeviceKeyAnonymousEventTime = 0;

  let eventsDeviceEventsProcessing = false;
  let maxDeviceKeyEventTime = 0;

  let eventsEntityEventsProcessing = false;
  let maxEntityEventTime = 0;

  let identityLoadedEvent = false;
  let identityAuthenticatedEvent = false;

  setInterval(async function () {
    if (window.currentlyAuthenticatedIdentity) {
      const { authentication } = window.currentlyAuthenticatedIdentity;
      const pinCode = getPincode(authentication.publicKey);
      if (pinCode) {
        const identity = await getIdentityFromLocalStorage(authentication.publicKey, pinCode, false);

        window.currentlyLoadedIdentity = identity;

        if (!identityAuthenticatedEvent && identity) {
          const event = createEvent("IdentityAuthenticated", "Authenticated", [identity.authentication.publicKey]);
          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;
      }
    }
  }, 50);

  setInterval(async () => {
    if (window.currentlyLoadedIdentity && !anynomousDeviceKeyEventsProcessing && !window.currentlyAuthenticatedIdentity) {
      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 "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;
              }

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

    if (window.currentlyAuthenticatedIdentity != null && eventsDeviceEventsProcessing === false) {
      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;
    }

    if (window.currentlyAuthenticatedIdentity != null && eventsEntityEventsProcessing === false) {
      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;
    }
  }, 1000);
});