oro-sdk 3.21.2 → 3.23.0

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "3.21.2",
+    "version": "3.23.0",
     "main": "dist/index.js",
     "typings": "dist/index.d.ts",
     "files": [
@@ -54,7 +54,7 @@
         "form-data": "^4.0.0",
         "formdata-node": "^4.3.1",
         "idb-keyval": "^5.0.6",
-        "oro-sdk-apis": "1.54.2",
+        "oro-sdk-apis": "1.55.0",
         "oro-toolbox": "0.0.6",
         "uuid": "^8.3.2"
     }

package/src/client.ts

@@ -285,6 +285,7 @@ export class OroClient {
      * @param workflow
      * @param recoveryQA
      * @param indexSearch create search index for the consultation if true
+     * @param onProgress callback that is called whenever a new step of patient registration is executed. Note: progress ranges from 0 to 1, and descriptionKey is a description of the progress as a key so the app would use it to translate the description
      * @returns
      */
     public async registerPatient(
@@ -295,10 +296,11 @@ export class OroClient {
             recoverySecurityQuestions: string[]
             recoverySecurityAnswers: string[]
         },
-        indexSearch: boolean = true
+        indexSearch: boolean = true,
+        onProgress?: (progress: number, descriptionKey: string) => void
     ): Promise<RegisterPatientOutput> {
         if (!this.rsa) throw IncompleteAuthentication
-        return registerPatient(patientUuid, consult, workflow, this, this.toolbox.uuid(), recoveryQA, indexSearch)
+        return registerPatient(patientUuid, consult, workflow, this, this.toolbox.uuid(), recoveryQA, indexSearch, onProgress)
     }
 
     /**
@@ -1513,4 +1515,4 @@ export class OroClient {
 
         return updatedIdentity
     }
-}
+}

package/src/helpers/patient-registration.ts

@@ -51,6 +51,7 @@ const MAX_RETRIES = 15
  * @param masterKey
  * @param recoveryQA
  * @param indexSearch create search index for the consultation if true
+ * @param onProgress callback that is called whenever a new step of patient registration is executed. Note: progress ranges from 0 to 1, and descriptionKey is a description of the progress as a key so the app would use it to translate the description
  * @returns the successful registration
  */
 export async function registerPatient(
@@ -63,7 +64,8 @@ export async function registerPatient(
         recoverySecurityQuestions: string[]
         recoverySecurityAnswers: string[]
     },
-    indexSearch: boolean = true
+    indexSearch: boolean = true,
+    onProgress?: (progress: number, descriptionKey: string, extraInfo?: { storedImagesNum?: number, totalImagesNum?: number }) => void
 ): Promise<RegisterPatientOutput> {
     let consult: Consult | undefined = undefined
     let lockboxUuid: Uuid | undefined = undefined
@@ -71,9 +73,16 @@ export async function registerPatient(
     let retry = MAX_RETRIES
     let identity: IdentityResponse | undefined = undefined
     let errorsThrown: Error[] = []
+    const stepsTotalNum = 9
+    let currentStep: number
 
     for (; retry > 0; retry--) {
         try {
+            currentStep = 0
+
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'retrieve_practitioners')
+
+
             // Wait a bit each retry (we also want the first one to wait)
             await new Promise((resolve) => setTimeout(resolve, 2000))
 
@@ -90,11 +99,15 @@ export async function registerPatient(
                 })
 
             // Creating consult
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'create_consult')
+
             if (!consult) {
                 consult = await getOrCreatePatientConsultationUuid(consultRequest, oroClient)
             }
 
             // Creating lockbox
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'create_lockbox')
+
             if (!lockboxUuid) lockboxUuid = await getOrCreatePatientLockbox(oroClient)
 
             if (!identity) identity = await oroClient.guardClient.identityGet(patientUuid)
@@ -106,6 +119,8 @@ export async function registerPatient(
             })
 
             // Patient Grant to practice
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'grant_patient')
+
             let grantPromises = practitioners
                 .filter((practitioner) => practitioner.uuid !== practitionerAdmin)
                 .map(async (practitioner) => {
@@ -142,12 +157,25 @@ export async function registerPatient(
                 })
             })
 
-            await storeImageAliases(consult.uuid, lockboxUuid, workflow, oroClient).catch((err) => {
+            await storeImageAliases(
+                consult.uuid,
+                lockboxUuid,
+                workflow,
+                oroClient,
+                onProgress? {
+                    onProgress,
+                    currentStep,
+                    stepsTotalNum
+                } : undefined
+            ).catch((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
                 if (retry <= 1) return
                 else errorsThrown.push(err)
             })
+            ++currentStep
+
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'store_patient_data')
 
             await storePatientData(
                 consult.uuid,
@@ -160,6 +188,8 @@ export async function registerPatient(
                 errorsThrown.push(err)
             })
 
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'set_masterkey')
+
             if (masterKey && !identity?.recoveryMasterKey) {
                 // generate and store recovery payload and updates the identity
                 identity = await oroClient.updateMasterKey(patientUuid, masterKey, lockboxUuid).catch((err) => {
@@ -174,6 +204,8 @@ export async function registerPatient(
                 masterKey = undefined
             }
 
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'set_security_questions')
+
             if (recoveryQA && !identity?.recoverySecurityQuestions)
                 // Patient security question recovery threshold is 2 answers and updates the identity
                 identity = await oroClient
@@ -194,6 +226,8 @@ export async function registerPatient(
             await Promise.all([...grantPromises, ...consultIndexPromises])
 
 
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'search_indexing')
+
             if (indexSearch) {
                 await buildConsultSearchIndex(consult, workflow, oroClient).catch((err) => {
                     console.error(
@@ -213,6 +247,8 @@ export async function registerPatient(
             })
 
             // if we got through the complete flow, the registration succeeded
+            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'success')
+
             break
         } catch (err) {
             console.error(`[SDK] Error occured during registration: ${err}, retrying... Retries remaining: ${retry}`)
@@ -374,7 +410,12 @@ async function storeImageAliases(
     consultationId: Uuid,
     lockboxUuid: Uuid,
     workflow: WorkflowData,
-    oroClient: OroClient
+    oroClient: OroClient,
+    progress?: {
+        currentStep: number;
+        stepsTotalNum: number;
+        onProgress: (progress: number, descriptionKey: string, extraInfo?: { storedImagesNum?: number; totalImagesNum?: number }) => void;
+    }
 ): Promise<(Uuid | void)[]> {
     const images = await getImagesFromIndexDb((await filterTriggeredAnsweredWithKind(workflow, 'images-alias')).flat())
 
@@ -384,6 +425,11 @@ async function storeImageAliases(
         console.error('[SDK] Some images have not been found, they have been skipped.')
     }
 
+    let storedImagesNum = 0
+    let totalImagesNum = nonNullImages.length
+    if (progress)
+        progress.onProgress(progress.currentStep/progress.stepsTotalNum, 'store_images', {storedImagesNum, totalImagesNum})
+
     let promises = nonNullImages.map((image) => {
         return oroClient.getOrInsertJsonData<ConsultationImageMeta>(
             lockboxUuid,
@@ -395,7 +441,20 @@ async function storeImageAliases(
                 idbId: image.idbId as string,
             },
             {}
-        )
+        ).then(() => {
+            if (progress) {
+                ++storedImagesNum
+                let progressStepValue = Math.round((((progress.currentStep + 1)/progress.stepsTotalNum) - (progress.currentStep/progress.stepsTotalNum)) * 100) / 100
+                progress.onProgress(
+                    (progress.currentStep/progress.stepsTotalNum) + (progressStepValue * (storedImagesNum/totalImagesNum)),
+                    'store_images',
+                    {
+                        storedImagesNum,
+                        totalImagesNum
+                    })
+            }
+
+        })
     })
     return Promise.all(promises)
 }