oro-sdk 2.10.1 → 2.12.0

package/dist/oro-sdk.cjs.development.js

@@ -1541,112 +1541,139 @@ function fillWorkflowFromPopulatedWorkflow(workflow, populatedWorkflow) {
 }
 
 var MAX_RETRIES = 15;
+/**
+ * Completes a registration for a user retrying the complete flow a maximum of 15 times
+ *
+ * @description The order of importance when registering:
+ * Creates a consultation if none exist
+ * Retrieves or create's a lockbox if none exist
+ * Grants the lockbox (if new) to all practitioners in the practice
+ * Stores or fetches the patient data (without images)
+ * Indexes the lockbox to the consult for all practitioners (done after inserting since index can be rebuilt from grants)
+ * Stores the image data - done last since the majority of failure cases occur here
+ * Creates the recovery payloads if they don't exist
+ *
+ * @param patientUuid
+ * @param consultRequest
+ * @param workflow
+ * @param oroClient
+ * @param masterKey
+ * @param recoveryQA
+ * @returns the successful registration
+ */
+
 function registerPatient(_x, _x2, _x3, _x4, _x5, _x6) {
   return _registerPatient.apply(this, arguments);
 }
 /**
- * Returns whether the consultation creation is for an existing patient (ignores data from the current consultation)
- *
- * @param currentConsultation
+ * Creates a consultation if one has not been created and fails to be retrieved by the payment intent
+ * @param consult
+ * @param oroClient
+ * @returns the consult Uuid
  */
 
 function _registerPatient() {
-  _registerPatient = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(patientUuid, consultRequest, workflow, oroClient, masterKey, recoveryQA) {
-    var consult, lockboxUuid, practitionerAdmin, retry, isExistingPatient, _ret;
+  _registerPatient = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(patientUuid, consultRequest, workflow, oroClient, masterKey, recoveryQA) {
+    var consult, lockboxUuid, practitionerAdmin, retry, identity, errorsThrown, _ret;
 
-    return runtime_1.wrap(function _callee5$(_context5) {
+    return runtime_1.wrap(function _callee4$(_context4) {
       while (1) {
-        switch (_context5.prev = _context5.next) {
+        switch (_context4.prev = _context4.next) {
           case 0:
             consult = undefined;
             lockboxUuid = undefined;
             practitionerAdmin = undefined;
             retry = MAX_RETRIES;
-            isExistingPatient = false;
+            identity = undefined;
+            errorsThrown = [];
 
-          case 5:
+          case 6:
             if (!(retry > 0)) {
-              _context5.next = 20;
+              _context4.next = 22;
               break;
             }
 
-            _context5.prev = 6;
-            return _context5.delegateYield( /*#__PURE__*/runtime_1.mark(function _callee4() {
-              var _consultIndex, _deprecatedConsultInd;
+            _context4.prev = 7;
+            return _context4.delegateYield( /*#__PURE__*/runtime_1.mark(function _callee3() {
+              var _consultIndex, _identity, _identity2;
 
-              var practitioners, grantPromises, consultIndex, consultIndexPromises, deprecatedConsultIndex, deprecatedConsultIndexPromises;
-              return runtime_1.wrap(function _callee4$(_context4) {
+              var practitioners, grantPromises, consultIndex, consultIndexPromises;
+              return runtime_1.wrap(function _callee3$(_context3) {
                 while (1) {
-                  switch (_context4.prev = _context4.next) {
+                  switch (_context3.prev = _context3.next) {
                     case 0:
-                      _context4.next = 2;
+                      _context3.next = 2;
                       return new Promise(function (resolve) {
                         return setTimeout(resolve, 2000);
                       });
 
                     case 2:
                       if (practitionerAdmin) {
-                        _context4.next = 6;
+                        _context3.next = 6;
                         break;
                       }
 
-                      _context4.next = 5;
+                      _context3.next = 5;
                       return oroClient.practiceClient.practiceGetFromUuid(consultRequest.uuidPractice);
 
                     case 5:
-                      practitionerAdmin = _context4.sent.uuidAdmin;
+                      practitionerAdmin = _context3.sent.uuidAdmin;
 
                     case 6:
-                      _context4.next = 8;
+                      _context3.next = 8;
                       return oroClient.practiceClient.practiceGetPractitioners(consultRequest.uuidPractice)["catch"](function (err) {
                         console.log("Error retrieving practitioners", err);
                         return [];
                       });
 
                     case 8:
-                      practitioners = _context4.sent;
+                      practitioners = _context3.sent;
 
                       if (consult) {
-                        _context4.next = 13;
+                        _context3.next = 13;
                         break;
                       }
 
-                      _context4.next = 12;
+                      _context3.next = 12;
                       return getOrCreatePatientConsultationUuid(consultRequest, oroClient);
 
                     case 12:
-                      consult = _context4.sent;
+                      consult = _context3.sent;
 
                     case 13:
                       if (lockboxUuid) {
-                        _context4.next = 17;
+                        _context3.next = 17;
                         break;
                       }
 
-                      _context4.next = 16;
+                      _context3.next = 16;
                       return getOrCreatePatientLockbox(oroClient);
 
                     case 16:
-                      lockboxUuid = _context4.sent;
+                      lockboxUuid = _context3.sent;
 
                     case 17:
-                      _context4.next = 19;
-                      return patientConsultExists(consult, lockboxUuid, oroClient)["catch"](function (err) {
-                        console.error("Error when retrieving existing consults " + err);
-                        return false;
-                      });
+                      if (identity) {
+                        _context3.next = 21;
+                        break;
+                      }
+
+                      _context3.next = 20;
+                      return oroClient.guardClient.identityGet(patientUuid);
 
-                    case 19:
-                      isExistingPatient = _context4.sent;
-                      _context4.next = 22;
+                    case 20:
+                      identity = _context3.sent;
+
+                    case 21:
+                      _context3.next = 23;
                       return oroClient.grantLockbox(practitionerAdmin, lockboxUuid)["catch"](function (err) {
                         console.error("Error while granting lockbox to practitioner admin " + practitionerAdmin, err); // if we cannot grant to the admin, then the registration will fail
 
                         // if we cannot grant to the admin, then the registration will fail
-                        throw err;
+                        errorsThrown.push(err);
                       });
 
-                    case 22:
+                    case 23:
                       // Patient Grant to practice
                       grantPromises = practitioners.filter(function (practitioner) {
                         return practitioner.uuid !== practitionerAdmin;
@@ -1657,10 +1684,11 @@ function _registerPatient() {
                               switch (_context.prev = _context.next) {
                                 case 0:
                                   return _context.abrupt("return", oroClient.grantLockbox(practitioner.uuid, lockboxUuid)["catch"](function (err) {
-                                    console.error("Error while granting lockbox to practitioner", err); // Acceptable to continue as admin has already been granted, but we should still try to retry
+                                    console.error("Error while granting lockbox to practitioner", err); // Acceptable to continue as admin has already been granted, but we should still retry until the last retry remains
 
-                                    // Acceptable to continue as admin has already been granted, but we should still try to retry
-                                    if (retry <= 1) return;else throw err;
+                                    // Acceptable to continue as admin has already been granted, but we should still retry until the last retry remains
+                                    if (retry <= 1) return;
+                                    errorsThrown.push(err);
                                   }));
 
                                 case 1:
@@ -1671,22 +1699,18 @@ function _registerPatient() {
                           }, _callee);
                         }));
 
-                        return function (_x27) {
+                        return function (_x24) {
                           return _ref.apply(this, arguments);
                         };
                       }());
-                      _context4.next = 25;
-                      return storePatientData(consult.uuid, consultRequest.isoLanguageRequired, lockboxUuid, workflow, oroClient);
-
-                    case 25:
-                      // the index will identify in which lockbox a consultation live
                       consultIndex = (_consultIndex = {}, _consultIndex[initApis.IndexKey.ConsultationLockbox] = [{
                         grant: {
                           lockboxUuid: lockboxUuid,
                           lockboxOwnerUuid: patientUuid
                         },
                         consultationId: consult.uuid
-                      }], _consultIndex);
+                      }], _consultIndex); // the index will identify in which lockbox a consultation resides
+
                       consultIndexPromises = practitioners.map( /*#__PURE__*/function () {
                         var _ref2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(practitioner) {
                           return runtime_1.wrap(function _callee2$(_context2) {
@@ -1694,10 +1718,10 @@ function _registerPatient() {
                               switch (_context2.prev = _context2.next) {
                                 case 0:
                                   return _context2.abrupt("return", oroClient.vaultIndexAdd(consultIndex, practitioner.uuid)["catch"](function (err) {
-                                    console.error("Error while adding to the practitioner's index " + practitioner.uuid, err); /// it's acceptable to continue registration
+                                    console.error("[SDK: registration] Error while adding to the practitioner's index " + practitioner.uuid, err); // Acceptable to continue as the index can be rebuilt, but we should still retry until the last retry remains
 
-                                    /// it's acceptable to continue registration
-                                    return;
+                                    // Acceptable to continue as the index can be rebuilt, but we should still retry until the last retry remains
+                                    if (retry <= 1) return;else errorsThrown.push(err);
                                   }));
 
                                 case 1:
@@ -1708,198 +1732,156 @@ function _registerPatient() {
                           }, _callee2);
                         }));
 
-                        return function (_x28) {
+                        return function (_x25) {
                           return _ref2.apply(this, arguments);
                         };
-                      }()); //DEPRECATED: REMOVE ME : BEGIN /////////////////////////////////////////
-
-                      deprecatedConsultIndex = (_deprecatedConsultInd = {}, _deprecatedConsultInd[initApis.IndexKey.Consultation] = [{
-                        grant: {
-                          lockboxUuid: lockboxUuid,
-                          lockboxOwnerUuid: patientUuid
-                        },
-                        consultationId: consult.uuid
-                      }], _deprecatedConsultInd);
-                      deprecatedConsultIndexPromises = practitioners.map( /*#__PURE__*/function () {
-                        var _ref3 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(practitioner) {
-                          return runtime_1.wrap(function _callee3$(_context3) {
-                            while (1) {
-                              switch (_context3.prev = _context3.next) {
-                                case 0:
-                                  return _context3.abrupt("return", oroClient.vaultIndexAdd(deprecatedConsultIndex, practitioner.uuid)["catch"](function (err) {
-                                    console.error("Error while adding to the practitioner's index " + practitioner.uuid, err); /// it's acceptable to continue registration
-
-                                    /// it's acceptable to continue registration
-                                    return;
-                                  }));
+                      }());
+                      _context3.next = 28;
+                      return storeImageAliases(consult.uuid, lockboxUuid, workflow, oroClient)["catch"](function (err) {
+                        console.error('[SDK: registration] Some errors happened during image upload', err); // Acceptable to continue as images can be requested during the consultation, but we should still retry until the last retry remains
 
-                                case 1:
-                                case "end":
-                                  return _context3.stop();
-                              }
-                            }
-                          }, _callee3);
-                        }));
+                        // Acceptable to continue as images can be requested during the consultation, but we should still retry until the last retry remains
+                        if (retry <= 1) return;else errorsThrown.push(err);
+                      });
 
-                        return function (_x29) {
-                          return _ref3.apply(this, arguments);
-                        };
-                      }()); //DEPRECATED: REMOVE ME : END /////////////////////////////////////////
+                    case 28:
+                      _context3.next = 30;
+                      return storePatientData(consult.uuid, consultRequest.isoLanguageRequired, lockboxUuid, workflow, oroClient)["catch"](function (err) {
+                        console.error('[SDK: registration] Some errors happened during patient data upload', err);
+                        errorsThrown.push(err);
+                      });
 
-                      if (!(masterKey && !isExistingPatient)) {
-                        _context4.next = 34;
+                    case 30:
+                      if (!(masterKey && !((_identity = identity) != null && _identity.recoveryMasterKey))) {
+                        _context3.next = 36;
                         break;
                       }
 
-                      _context4.next = 32;
+                      _context3.next = 33;
                       return oroClient.updateMasterKey(patientUuid, masterKey, lockboxUuid)["catch"](function (err) {
-                        console.error("Error while updating master key", err); /// it's acceptable to continue registration
+                        console.error("[SDK: registration] Error while updating master key", err); /// it's acceptable to continue registration (return old identity)
 
-                        /// it's acceptable to continue registration
-                        return;
+                        /// it's acceptable to continue registration (return old identity)
+                        if (retry <= 1) return;
+                        errorsThrown.push(err);
+                        return identity;
                       });
 
-                    case 32:
-                      _context4.next = 35;
+                    case 33:
+                      identity = _context3.sent;
+                      _context3.next = 37;
                       break;
 
-                    case 34:
+                    case 36:
                       // we did not set the master key so we do not return it
                       masterKey = undefined;
 
-                    case 35:
-                      if (!(recoveryQA && !isExistingPatient)) {
-                        _context4.next = 38;
+                    case 37:
+                      if (!(recoveryQA && !((_identity2 = identity) != null && _identity2.recoverySecurityQuestions))) {
+                        _context3.next = 41;
                         break;
                       }
 
-                      _context4.next = 38;
+                      _context3.next = 40;
                       return oroClient.updateSecurityQuestions(patientUuid, recoveryQA.recoverySecurityQuestions, recoveryQA.recoverySecurityAnswers, 2)["catch"](function (err) {
-                        console.error("Error while updating security questions", err); /// it's acceptable to continue registration
+                        console.error("[SDK: registration] Error while updating security questions", err); /// it's acceptable to continue registration (return old identity)
 
-                        /// it's acceptable to continue registration
-                        return;
+                        /// it's acceptable to continue registration (return old identity)
+                        if (retry <= 1) return;
+                        errorsThrown.push(err);
+                        return identity;
                       });
 
-                    case 38:
-                      _context4.next = 40;
-                      return Promise.all([].concat(grantPromises, consultIndexPromises, deprecatedConsultIndexPromises));
-
                     case 40:
-                      _context4.next = 42;
+                      identity = _context3.sent;
+
+                    case 41:
+                      _context3.next = 43;
+                      return Promise.all([].concat(grantPromises, consultIndexPromises));
+
+                    case 43:
+                      if (!(errorsThrown.length > 0)) {
+                        _context3.next = 45;
+                        break;
+                      }
+
+                      throw errorsThrown;
+
+                    case 45:
+                      _context3.next = 47;
                       return oroClient.consultClient.updateConsultByUUID(consult.uuid, {
                         statusMedical: initApis.MedicalStatus.New
                       });
 
-                    case 42:
-                      return _context4.abrupt("return", "break");
+                    case 47:
+                      return _context3.abrupt("return", "break");
 
-                    case 43:
+                    case 48:
                     case "end":
-                      return _context4.stop();
+                      return _context3.stop();
                   }
                 }
-              }, _callee4);
-            })(), "t0", 8);
+              }, _callee3);
+            })(), "t0", 9);
 
-          case 8:
-            _ret = _context5.t0;
+          case 9:
+            _ret = _context4.t0;
 
             if (!(_ret === "break")) {
-              _context5.next = 11;
+              _context4.next = 12;
               break;
             }
 
-            return _context5.abrupt("break", 20);
+            return _context4.abrupt("break", 22);
 
-          case 11:
-            _context5.next = 17;
+          case 12:
+            _context4.next = 19;
             break;
 
-          case 13:
-            _context5.prev = 13;
-            _context5.t1 = _context5["catch"](6);
-            console.error("Error occured during registration, retrying... Retries remaining: " + retry);
-            return _context5.abrupt("continue", 17);
+          case 14:
+            _context4.prev = 14;
+            _context4.t1 = _context4["catch"](7);
+            console.error("[SDK] Error occured during registration: " + _context4.t1 + ", retrying... Retries remaining: " + retry);
+            errorsThrown = [];
+            return _context4.abrupt("continue", 19);
 
-          case 17:
+          case 19:
             retry--;
-            _context5.next = 5;
+            _context4.next = 6;
             break;
 
-          case 20:
+          case 22:
             if (!(retry <= 0)) {
-              _context5.next = 23;
+              _context4.next = 25;
               break;
             }
 
-            console.error('registration failed: MAX_RETRIES reached');
+            console.error('[SDK] registration failed: MAX_RETRIES reached');
             throw 'RegistrationFailed';
 
-          case 23:
+          case 25:
             console.log('Successfully Registered');
-            _context5.next = 26;
+            _context4.next = 28;
             return oroClient.cleanIndex();
 
-          case 26:
-            return _context5.abrupt("return", {
+          case 28:
+            return _context4.abrupt("return", {
               masterKey: masterKey,
               consultationId: consult.uuid,
               lockboxUuid: lockboxUuid
             });
 
-          case 27:
+          case 29:
           case "end":
-            return _context5.stop();
+            return _context4.stop();
         }
       }
-    }, _callee5, null, [[6, 13]]);
+    }, _callee4, null, [[7, 14]]);
   }));
   return _registerPatient.apply(this, arguments);
 }
 
-function patientConsultExists(_x7, _x8, _x9) {
-  return _patientConsultExists.apply(this, arguments);
-}
-/**
- * Creates a consultation if one has not been created and fails to be retrieved by the payment intent
- * @param consult
- * @param oroClient
- * @returns the consult Uuid
- */
-
-
-function _patientConsultExists() {
-  _patientConsultExists = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(currentConsultation, lockboxUuid, oroClient) {
-    var publicMetadata, manifest;
-    return runtime_1.wrap(function _callee6$(_context6) {
-      while (1) {
-        switch (_context6.prev = _context6.next) {
-          case 0:
-            publicMetadata = {
-              category: initApis.MetadataCategory.Consultation,
-              documentType: initApis.DocumentType.PopulatedWorkflowData
-            };
-            _context6.next = 3;
-            return oroClient.vaultClient.lockboxMetadataGet(lockboxUuid, ['consultationId'], [], publicMetadata);
-
-          case 3:
-            manifest = _context6.sent;
-            return _context6.abrupt("return", manifest[0].findIndex(function (v) {
-              return v.consultationId != null && v.consultationId !== currentConsultation.uuid;
-            }) !== -1);
-
-          case 5:
-          case "end":
-            return _context6.stop();
-        }
-      }
-    }, _callee6);
-  }));
-  return _patientConsultExists.apply(this, arguments);
-}
-
-function getOrCreatePatientConsultationUuid(_x10, _x11) {
+function getOrCreatePatientConsultationUuid(_x7, _x8) {
   return _getOrCreatePatientConsultationUuid.apply(this, arguments);
 }
 /**
@@ -1910,49 +1892,49 @@ function getOrCreatePatientConsultationUuid(_x10, _x11) {
 
 
 function _getOrCreatePatientConsultationUuid() {
-  _getOrCreatePatientConsultationUuid = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(consult, oroClient) {
+  _getOrCreatePatientConsultationUuid = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(consult, oroClient) {
     var payment;
-    return runtime_1.wrap(function _callee7$(_context7) {
+    return runtime_1.wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context7.prev = _context7.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
-            _context7.next = 2;
+            _context5.next = 2;
             return oroClient.practiceClient.practiceGetPayment(consult.uuidPractice, consult.idStripeInvoiceOrPaymentIntent);
 
           case 2:
-            payment = _context7.sent;
+            payment = _context5.sent;
 
             if (!(payment && payment.uuidConsult)) {
-              _context7.next = 7;
+              _context5.next = 7;
               break;
             }
 
-            return _context7.abrupt("return", oroClient.consultClient.getConsultByUUID(payment.uuidConsult)["catch"](function (err) {
+            return _context5.abrupt("return", oroClient.consultClient.getConsultByUUID(payment.uuidConsult)["catch"](function (err) {
               console.error('Error while retrieving consult', err);
               throw err;
             }));
 
           case 7:
-            _context7.next = 9;
+            _context5.next = 9;
             return oroClient.consultClient.consultCreate(consult)["catch"](function (err) {
               console.error('Error while creating consult', err);
               throw err;
             });
 
           case 9:
-            return _context7.abrupt("return", _context7.sent);
+            return _context5.abrupt("return", _context5.sent);
 
           case 10:
           case "end":
-            return _context7.stop();
+            return _context5.stop();
         }
       }
-    }, _callee7);
+    }, _callee5);
   }));
   return _getOrCreatePatientConsultationUuid.apply(this, arguments);
 }
 
-function getOrCreatePatientLockbox(_x12) {
+function getOrCreatePatientLockbox(_x9) {
   return _getOrCreatePatientLockbox.apply(this, arguments);
 }
 /**
@@ -1967,59 +1949,57 @@ function getOrCreatePatientLockbox(_x12) {
 
 
 function _getOrCreatePatientLockbox() {
-  _getOrCreatePatientLockbox = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(oroClient) {
+  _getOrCreatePatientLockbox = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(oroClient) {
     var grants;
-    return runtime_1.wrap(function _callee8$(_context8) {
+    return runtime_1.wrap(function _callee6$(_context6) {
       while (1) {
-        switch (_context8.prev = _context8.next) {
+        switch (_context6.prev = _context6.next) {
           case 0:
-            _context8.next = 2;
+            _context6.next = 2;
             return oroClient.getGrants(undefined, true);
 
           case 2:
-            grants = _context8.sent;
+            grants = _context6.sent;
 
             if (!(grants.length > 0)) {
-              _context8.next = 8;
+              _context6.next = 8;
               break;
             }
 
             console.log('The grant has already been created, skipping lockbox create step');
-            return _context8.abrupt("return", grants[0].lockboxUuid);
+            return _context6.abrupt("return", grants[0].lockboxUuid);
 
           case 8:
-            _context8.next = 10;
+            _context6.next = 10;
             return oroClient.vaultClient.lockboxCreate()["catch"](function (err) {
               console.error('Error while creating lockbox', err);
               throw err;
             });
 
           case 10:
-            return _context8.abrupt("return", _context8.sent.lockboxUuid);
+            return _context6.abrupt("return", _context6.sent.lockboxUuid);
 
           case 11:
           case "end":
-            return _context8.stop();
+            return _context6.stop();
         }
       }
-    }, _callee8);
+    }, _callee6);
   }));
   return _getOrCreatePatientLockbox.apply(this, arguments);
 }
 
-function storePatientData(_x13, _x14, _x15, _x16, _x17) {
+function storePatientData(_x10, _x11, _x12, _x13, _x14) {
   return _storePatientData.apply(this, arguments);
 }
 
 function _storePatientData() {
-  _storePatientData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(consultationId, isoLanguage, lockboxUuid, workflow, oroClient) {
-    return runtime_1.wrap(function _callee9$(_context9) {
+  _storePatientData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(consultationId, isoLanguage, lockboxUuid, workflow, oroClient) {
+    return runtime_1.wrap(function _callee7$(_context7) {
       while (1) {
-        switch (_context9.prev = _context9.next) {
+        switch (_context7.prev = _context7.next) {
           case 0:
-            return _context9.abrupt("return", Promise.all([storeImageAliases(consultationId, lockboxUuid, workflow, oroClient)["catch"](function (err) {
-              console.error('[SDK] Some errors happened during image upload', err);
-            }), // Storing Raw data first
+            return _context7.abrupt("return", Promise.all([// Storing Raw data first
             oroClient.getOrInsertJsonData(lockboxUuid, workflow, {
               category: initApis.MetadataCategory.Raw,
               contentType: 'application/json',
@@ -2049,15 +2029,15 @@ function _storePatientData() {
 
           case 1:
           case "end":
-            return _context9.stop();
+            return _context7.stop();
         }
       }
-    }, _callee9);
+    }, _callee7);
   }));
   return _storePatientData.apply(this, arguments);
 }
 
-function storeImageAliases(_x18, _x19, _x20, _x21) {
+function storeImageAliases(_x15, _x16, _x17, _x18) {
   return _storeImageAliases.apply(this, arguments);
 }
 /**
@@ -2072,23 +2052,23 @@ function storeImageAliases(_x18, _x19, _x20, _x21) {
 
 
 function _storeImageAliases() {
-  _storeImageAliases = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(consultationId, lockboxUuid, workflow, oroClient) {
+  _storeImageAliases = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(consultationId, lockboxUuid, workflow, oroClient) {
     var images, nonNullImages, promises;
-    return runtime_1.wrap(function _callee10$(_context10) {
+    return runtime_1.wrap(function _callee8$(_context8) {
       while (1) {
-        switch (_context10.prev = _context10.next) {
+        switch (_context8.prev = _context8.next) {
           case 0:
-            _context10.t0 = getImagesFromIndexDb;
-            _context10.next = 3;
+            _context8.t0 = getImagesFromIndexDb;
+            _context8.next = 3;
             return filterTriggeredAnsweredWithKind(workflow, 'images-alias');
 
           case 3:
-            _context10.t1 = _context10.sent.flat();
-            _context10.next = 6;
-            return (0, _context10.t0)(_context10.t1);
+            _context8.t1 = _context8.sent.flat();
+            _context8.next = 6;
+            return (0, _context8.t0)(_context8.t1);
 
           case 6:
-            images = _context10.sent;
+            images = _context8.sent;
             nonNullImages = images.filter(function (img) {
               return !!img;
             });
@@ -2105,29 +2085,29 @@ function _storeImageAliases() {
                 idbId: image.idbId
               }, {});
             });
-            return _context10.abrupt("return", Promise.all(promises));
+            return _context8.abrupt("return", Promise.all(promises));
 
           case 11:
           case "end":
-            return _context10.stop();
+            return _context8.stop();
         }
       }
-    }, _callee10);
+    }, _callee8);
   }));
   return _storeImageAliases.apply(this, arguments);
 }
 
-function extractAndStorePersonalWorkflowData(_x22, _x23, _x24, _x25, _x26) {
+function extractAndStorePersonalWorkflowData(_x19, _x20, _x21, _x22, _x23) {
   return _extractAndStorePersonalWorkflowData.apply(this, arguments);
 }
 
 function _extractAndStorePersonalWorkflowData() {
-  _extractAndStorePersonalWorkflowData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(workflow, lockboxUuid, consultationId, category, oroClient) {
-    return runtime_1.wrap(function _callee11$(_context11) {
+  _extractAndStorePersonalWorkflowData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(workflow, lockboxUuid, consultationId, category, oroClient) {
+    return runtime_1.wrap(function _callee9$(_context9) {
       while (1) {
-        switch (_context11.prev = _context11.next) {
+        switch (_context9.prev = _context9.next) {
           case 0:
-            return _context11.abrupt("return", getWorkflowDataByCategory(workflow, category).then(function (data) {
+            return _context9.abrupt("return", getWorkflowDataByCategory(workflow, category).then(function (data) {
               if (Object.keys(data.fields).length === 0) return;
               return oroClient.getOrInsertJsonData(lockboxUuid, data, {
                 category: category,
@@ -2138,10 +2118,10 @@ function _extractAndStorePersonalWorkflowData() {
 
           case 1:
           case "end":
-            return _context11.stop();
+            return _context9.stop();
         }
       }
-    }, _callee11);
+    }, _callee9);
   }));
   return _extractAndStorePersonalWorkflowData.apply(this, arguments);
 }