viamapi-iframe.js

          })
        }

        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
  ) {
    const event = createEvent("", "NotAuthenticated");
    parent.onEvent(event);
    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);

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