@ekyc_qoobiss/qbs-ect-cmp 3.6.29 → 3.6.31

package/dist/cjs/{TranslationUtils-b918ffb1.js → TranslationUtils-05fc03bc.js}

@@ -2,6 +2,15 @@
 
 const index = require('./index-41696e0e.js');
 
+exports.OrderStatuses = void 0;
+(function (OrderStatuses) {
+  OrderStatuses[OrderStatuses["Capturing"] = 0] = "Capturing";
+  OrderStatuses[OrderStatuses["FinishedCapturing"] = 1] = "FinishedCapturing";
+  OrderStatuses[OrderStatuses["Waiting"] = 2] = "Waiting";
+  OrderStatuses[OrderStatuses["NotFound"] = 3] = "NotFound";
+  OrderStatuses[OrderStatuses["Aborted"] = 4] = "Aborted";
+})(exports.OrderStatuses || (exports.OrderStatuses = {}));
+
 const appendToMap = (map, propName, value) => {
     const items = map.get(propName);
     if (!items) {
@@ -253,6 +262,7 @@ class ApiUrls {
     this.AddLog = this.uriEnv + 'validation/logs/add';
     this.AddStep = this.uriEnv + 'validation/logs/step';
     this.AbortRequest = this.uriEnv + 'validation/identity/abort';
+    this.Translations = this.uriEnv + 'validation/translations/get';
   }
 }
 
@@ -301,7 +311,264 @@ onChange('phoneValidation', value => {
   sessionStorage.setItem(SessionKeys.PhoneValidationKey, String(value));
 });
 
+exports.FlowSteps = void 0;
+(function (FlowSteps) {
+  FlowSteps[FlowSteps["ComponentLoaded"] = 'component-loaded'] = "ComponentLoaded";
+  FlowSteps[FlowSteps["MobileRedirect"] = 'mobile-redirect'] = "MobileRedirect";
+  FlowSteps[FlowSteps["Landing"] = 'landing'] = "Landing";
+  FlowSteps[FlowSteps["Agreements"] = 'agreements'] = "Agreements";
+  FlowSteps[FlowSteps["OtpSend"] = 'otp-send'] = "OtpSend";
+  FlowSteps[FlowSteps["OtpCheck"] = 'otp-check'] = "OtpCheck";
+  FlowSteps[FlowSteps["CiFront"] = 'ci-front'] = "CiFront";
+  FlowSteps[FlowSteps["CiFrontHowTo"] = 'ci-front-how-to'] = "CiFrontHowTo";
+  FlowSteps[FlowSteps["CiFrontCapture"] = 'ci-front-capture'] = "CiFrontCapture";
+  FlowSteps[FlowSteps["CiBack"] = 'ci-back'] = "CiBack";
+  FlowSteps[FlowSteps["CiBackHowTo"] = 'ci-back-how-to'] = "CiBackHowTo";
+  FlowSteps[FlowSteps["CiBackCapture"] = 'ci-back-capture'] = "CiBackCapture";
+  FlowSteps[FlowSteps["CiTilt"] = 'ci-tilt'] = "CiTilt";
+  FlowSteps[FlowSteps["CiError"] = 'ci-error'] = "CiError";
+  FlowSteps[FlowSteps["SelfieHowTo"] = 'selfie-how-to'] = "SelfieHowTo";
+  FlowSteps[FlowSteps["SelfieTilt"] = 'selfie-tilt'] = "SelfieTilt";
+  FlowSteps[FlowSteps["SelfieCapture"] = 'selfie-capture'] = "SelfieCapture";
+  FlowSteps[FlowSteps["Selfie"] = 'selfie'] = "Selfie";
+  FlowSteps[FlowSteps["SelfieError"] = 'selfie-error'] = "SelfieError";
+  FlowSteps[FlowSteps["End"] = 'end'] = "End";
+  FlowSteps[FlowSteps["CameraError"] = 'camera-error'] = "CameraError";
+})(exports.FlowSteps || (exports.FlowSteps = {}));
+exports.FlowMoments = void 0;
+(function (FlowMoments) {
+  FlowMoments[FlowMoments["Initialized"] = 'initialized'] = "Initialized";
+  FlowMoments[FlowMoments["Finalized"] = 'finalized'] = "Finalized";
+  FlowMoments[FlowMoments["None"] = 'none'] = "None";
+})(exports.FlowMoments || (exports.FlowMoments = {}));
+
+class ApiCall {
+  constructor() {
+    this.serviceErrors = ['Service Unavailable', 'Unauthorized'];
+    this.toBase64 = (file) => new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = error => reject(error);
+    });
+    this.urls = new ApiUrls();
+  }
+  // private async http2<T>(method: string, url: string, data: string): Promise<T> {
+  //   return new Promise((resolve, reject) => {
+  //     var xhr = new XMLHttpRequest();
+  //     xhr.open(method, url);
+  //     xhr.onload = function () {
+  //       if (xhr.status >= 200 && xhr.status < 300) {
+  //         resolve(xhr.response);
+  //       } else {
+  //         reject({
+  //           status: xhr.status,
+  //           statusText: xhr.statusText,
+  //         });
+  //       }
+  //     };
+  //     xhr.onerror = function () {
+  //       reject({
+  //         status: xhr.status,
+  //         statusText: xhr.statusText,
+  //       });
+  //     };
+  //     xhr.send(data);
+  //   });
+  // }
+  async http(request) {
+    const response = await fetch(request);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    try {
+      // may error if there is no body
+      return await response.json();
+    }
+    catch (ex) {
+      throw new Error('No json found in response ' + ex);
+    }
+  }
+  async post(url, data, withRetry = true) {
+    var request = new Request(state.apiBaseUrl + url, {
+      method: 'POST',
+      body: data,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'IDKYC-TOKEN ' + state.token,
+      },
+    });
+    try {
+      return await this.http(request);
+    }
+    catch (ex) {
+      if (!withRetry || this.serviceErrors.includes(ex.message)) {
+        throw ex;
+      }
+      this.AddLog('Error in post ', ex);
+      try {
+        var request2 = new Request(state.apiBaseUrl + url, {
+          method: 'POST',
+          body: data,
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'IDKYC-TOKEN ' + state.token,
+          },
+        });
+        return await this.http(request2);
+      }
+      catch (ex2) {
+        this.AddLog('Error in post ', ex2);
+        var request3 = new Request(state.apiBaseUrl + url, {
+          method: 'POST',
+          body: data,
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'IDKYC-TOKEN ' + state.token,
+          },
+        });
+        return await this.http(request3);
+      }
+    }
+  }
+  async get(url, withRetry = true) {
+    var request = new Request(state.apiBaseUrl + url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'IDKYC-TOKEN ' + state.token,
+      },
+    });
+    try {
+      return await this.http(request);
+    }
+    catch (ex) {
+      if (!withRetry || this.serviceErrors.includes(ex.message)) {
+        throw ex;
+      }
+      this.AddLog('Error in get ', ex);
+      try {
+        var request2 = new Request(state.apiBaseUrl + url, {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'IDKYC-TOKEN ' + state.token,
+          },
+        });
+        return await this.http(request2);
+      }
+      catch (ex2) {
+        this.AddLog('Error in get ', ex2);
+        var request3 = new Request(state.apiBaseUrl + url, {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'IDKYC-TOKEN ' + state.token,
+          },
+        });
+        return await this.http(request3);
+      }
+    }
+  }
+  async SendOTPCode(requestId, phoneNumber) {
+    let data = { requestId: requestId, phone: phoneNumber };
+    let jsonResp = await this.post(this.urls.OtpSend, JSON.stringify(data));
+    return jsonResp.sent;
+  }
+  async CheckOTPCode(requestId, otpCode) {
+    let data = { requestId: requestId, otp: otpCode };
+    let jsonResp = await this.post(this.urls.OtpCheck, JSON.stringify(data));
+    return jsonResp.valid;
+  }
+  async AddIdentificationRequest(deviceInfo, version) {
+    if (state.debug)
+      console.log('Calling identity request with store:' + JSON.stringify(state));
+    let data = {
+      requestId: state.requestId,
+      clientDeviceInfo: JSON.stringify(deviceInfo),
+      redirectId: state.redirectId,
+      phoneNumber: state.phoneNumber,
+      version: version,
+    };
+    let jsonResp = await this.post(this.urls.IdentityInsert, JSON.stringify(data));
+    if (state.requestId == '') {
+      state.requestId = jsonResp.requestId;
+    }
+    state.hasIdBack = jsonResp.hasIdBack;
+    state.hasIdTilt = jsonResp.hasIdTilt;
+    state.hasSelfieGesture = jsonResp.hasSelfieGesture;
+    state.agreementsValidation = jsonResp.agreementsValidation;
+    state.phoneValidation = jsonResp.phoneValidation;
+    state.phoneNumber = jsonResp.phoneNumber;
+    return true;
+  }
+  async UploadFileForRequestB64(requestId, type, file) {
+    let data = {
+      requestId: requestId,
+      type: type,
+      data: await this.toBase64(file),
+    };
+    let respJson = await this.post(this.urls.UploadCapture, JSON.stringify(data));
+    if (!state.hasIdBack && type == 'IdFront') {
+      return respJson.isValid;
+    }
+    if (state.hasIdBack && type == 'IdBack') {
+      return respJson.isValid;
+    }
+    if (type == 'Selfie') {
+      return respJson.isValid;
+    }
+    return true;
+  }
+  async GetAgreement(agreementType) {
+    let resp = await this.get(this.urls.GetAgreement + '?type=' + agreementType + '&requestId=' + state.requestId);
+    return resp.htmlText;
+  }
+  async GenerateAgreement(agreementType) {
+    let data = { requestId: state.requestId, documentType: agreementType };
+    let resp = await this.post(this.urls.GenerateAgreement, JSON.stringify(data));
+    return resp.generation;
+  }
+  async GetStatus(requestId) {
+    let resp = await this.get(this.urls.GetStatus + '?orderId=' + requestId);
+    return exports.OrderStatuses[resp.status];
+  }
+  async SendLink(link, phoneNumber) {
+    let data = { requestId: state.requestId, link: link, phoneNumber: phoneNumber };
+    let resp = await this.post(this.urls.SendLink, JSON.stringify(data));
+    return resp.sent;
+  }
+  async AddLog(error, context) {
+    try {
+      let data = {
+        requestId: state.requestId,
+        action: exports.FlowStatus[state.flowStatus],
+        message: JSON.stringify({ error, context }),
+      };
+      let result = await this.post(this.urls.AddLog, JSON.stringify(data), false);
+      return result.saved;
+    }
+    catch (_a) { }
+  }
+  async AddStep(step, moment) {
+    let data = { requestId: state.requestId, redirectId: state.redirectId, step: exports.FlowSteps[step], moment: exports.FlowMoments[moment], timestamp: new Date().toISOString() };
+    let result = await this.post(this.urls.AddStep, JSON.stringify(data));
+    return result.saved;
+  }
+  async AbortRequest() {
+    let result = await this.post(this.urls.AbortRequest, JSON.stringify({ requestId: state.requestId }));
+    return result.saved;
+  }
+  async GetTranslations(langIso) {
+    let result = await this.get(this.urls.Translations + '?langIso=' + langIso);
+    return result;
+  }
+}
+
 class TranslationsController {
+  constructor() {
+    this.apiCall = new ApiCall();
+  }
   async getValues() {
     if (this.values) {
       return this.values;
@@ -312,33 +579,31 @@ class TranslationsController {
     }
   }
   getLocale(element = document.body) {
-    const closestElement = element.closest('[lang]');
-    return closestElement ? closestElement.lang : state.langIso;
+    if (state.langIso && state.langIso != '') {
+      return state.langIso;
+    }
+    else {
+      const closestElement = element.closest('[lang]');
+      return closestElement ? closestElement.lang : 'ro';
+    }
   }
   async fetchTranslations() {
     const locale = this.getLocale();
-    const existingTranslations = JSON.parse(sessionStorage.getItem(`i18n.${locale}`));
-    if (existingTranslations && Object.keys(existingTranslations).length > 0) {
-      return existingTranslations;
-    }
-    else {
-      try {
-        const result = await fetch(`/i18n/${locale}.json`);
-        if (result.ok) {
-          const data = await result.json();
-          sessionStorage.setItem(`i18n.${locale}`, JSON.stringify(data));
-          return data;
-        }
-      }
-      catch (exception) {
-        console.error(`Error loading locale: ${locale}`, exception);
+    try {
+      const result = this.apiCall.GetTranslations(locale);
+      if (result) {
+        return result;
       }
     }
+    catch (exception) {
+      console.error(`Error loading locale: ${locale}`, exception);
+      return null;
+    }
   }
 }
 const Translations = new TranslationsController();
 
-exports.ApiUrls = ApiUrls;
+exports.ApiCall = ApiCall;
 exports.IdCaptureValues = IdCaptureValues;
 exports.SelfieCaptureValues = SelfieCaptureValues;
 exports.SessionKeys = SessionKeys;