oro-sdk 5.3.2 → 5.3.5

package/package.json

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

package/src/client.ts

@@ -46,7 +46,13 @@ import {
 } from 'oro-sdk-apis'
 import * as OroToolbox from 'oro-toolbox'
 import { CryptoRSA } from 'oro-toolbox'
-import { decryptConsultLockboxGrants, decryptGrants, registerPatient, sessionStorePrivateKeyName } from './helpers'
+import {
+    createRefill,
+    decryptConsultLockboxGrants,
+    decryptGrants,
+    registerPatient,
+    sessionStorePrivateKeyName,
+} from './helpers'
 import {
     AssociatedLockboxNotFound,
     IncompleteAuthentication,
@@ -88,7 +94,7 @@ export class OroClient {
         public workflowClient: WorkflowService,
         public diagnosisClient: DiagnosisService,
         private authenticationCallback?: (err: Error) => void
-    ) {}
+    ) { }
 
     /**
      * clears the vaultIndex and cached metadata grants
@@ -312,6 +318,21 @@ export class OroClient {
         )
     }
 
+    /**
+     * Creates and stores all relevant refill data
+     * - New consultation is created
+     * - Stores refill workflow data in the lockbox
+     * - Updates the consult to new
+     *
+     * @param consult
+     * @param populatedRefillWorkflow
+     * @returns
+     */
+    public async createRefill(consult: ConsultRequest, populatedRefillWorkflow: WorkflowData): Promise<void> {
+        if (!this.rsa) throw IncompleteAuthentication
+        return createRefill(consult, populatedRefillWorkflow, this)
+    }
+
     /**
      * Fetches all grants, and consultations that exist in each lockbox
      * Then updates the index for the current user with the lockbox consult relationship
@@ -386,18 +407,18 @@ export class OroClient {
                         }))
                         .map(
                             (e: IndexConsultLockbox) =>
-                                ({
-                                    uuid: e.uuid,
-                                    timestamp: e.timestamp,
-                                    uniqueHash: e.uniqueHash,
-                                    encryptedIndexEntry: CryptoRSA.jsonWithPubEncryptToBase64(
-                                        {
-                                            consultationId: e.consultationId,
-                                            grant: e.grant,
-                                        },
-                                        rsaPub
-                                    ),
-                                } as EncryptedIndexEntry)
+                            ({
+                                uuid: e.uuid,
+                                timestamp: e.timestamp,
+                                uniqueHash: e.uniqueHash,
+                                encryptedIndexEntry: CryptoRSA.jsonWithPubEncryptToBase64(
+                                    {
+                                        consultationId: e.consultationId,
+                                        grant: e.grant,
+                                    },
+                                    rsaPub
+                                ),
+                            } as EncryptedIndexEntry)
                         )
                     break
             }
@@ -532,7 +553,7 @@ export class OroClient {
         documentType: DocumentType,
         lockboxOwnerUuid?: Uuid,
         previousDataUuid?: Uuid,
-        withNotification: boolean = false
+        options: { withNotification?: boolean } = { withNotification: false }
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
 
@@ -551,7 +572,7 @@ export class OroClient {
             },
             lockboxOwnerUuid,
             previousDataUuid,
-            withNotification
+            options
         )
     }
 
@@ -564,7 +585,7 @@ export class OroClient {
      * @param privateMeta the metadata that will be secured in the vault
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      * @param previousDataUuid if it's a revision of existing data, specify the previous data uuid
-     * @param withNotification if the insertion of data requires notification
+     * @param options if the insertion of data requires email notification
      * @returns the data uuid
      */
     public async createJsonData<T extends Metadata>(
@@ -574,7 +595,7 @@ export class OroClient {
         privateMeta?: { [val: string]: any },
         lockboxOwnerUuid?: Uuid,
         previousDataUuid?: Uuid,
-        withNotification: boolean = false
+        options: { withNotification?: boolean } = { withNotification: false }
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
 
@@ -587,7 +608,7 @@ export class OroClient {
             publicMetadata: meta,
             privateMetadata: encryptedPrivateMeta,
         }
-        if (withNotification)
+        if (options.withNotification)
             return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
         else return this.vaultClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
@@ -599,7 +620,7 @@ export class OroClient {
      * @param publicMetadata the public Metadata
      * @param privateMetadata the private Metadata
      * @param forceReplace set true when the insertion of data requires to replace the data when it exists already
-     * @param withNotification if the insertion of data requires notification
+     * @param options if the insertion of data requires email notification
      * @returns the data uuid
      */
     public async getOrInsertJsonData<M extends Metadata>(
@@ -607,11 +628,10 @@ export class OroClient {
         data: any,
         publicMetadata: M,
         privateMetadata: Metadata,
-        forceReplace: boolean = false,
-        withNotification: boolean = false
+        options: { withNotification?: boolean, forceReplace?: boolean } = { withNotification: false, forceReplace: false }
     ): Promise<Uuid> {
         let manifest = await this.vaultClient.lockboxManifestGet(lockboxUuid, publicMetadata)
-        if (!forceReplace && manifest.length > 0) {
+        if (!options.forceReplace && manifest.length > 0) {
             console.log(`The data for ${JSON.stringify(publicMetadata)} already exist`)
             return manifest[0].dataUuid
         } else
@@ -622,8 +642,9 @@ export class OroClient {
                     publicMetadata,
                     privateMetadata,
                     undefined,
-                    forceReplace && manifest.length > 0 ? manifest[0].dataUuid : undefined, // if forceReplace and data already exist, then replace data. Otherwise insert it
-                    withNotification
+                    // if forceReplace and data already exist, then replace data. Otherwise insert it
+                    options.forceReplace && manifest.length > 0 ? manifest[0].dataUuid : undefined,
+                    { withNotification: options.withNotification }
                 ).catch((err) => {
                     console.error(`Error while upserting data ${JSON.stringify(publicMetadata)} data`, err)
                     throw err
@@ -650,7 +671,7 @@ export class OroClient {
         privateMeta: { [val: string]: any },
         lockboxOwnerUuid?: Uuid,
         previousDataUuid?: Uuid,
-        withNotification: boolean = false
+        options: { withNotification?: boolean } = { withNotification: false }
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
         let symmetricEncryptor = await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)
@@ -662,7 +683,7 @@ export class OroClient {
             publicMetadata: meta,
             privateMetadata: encryptedPrivateMeta,
         }
-        if (withNotification)
+        if (options.withNotification)
             return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
         else return this.vaultClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
@@ -811,9 +832,9 @@ export class OroClient {
     public async getPersonalInformationsFromConsultId(
         consultationId: Uuid,
         category: MetadataCategory.Personal | MetadataCategory.ChildPersonal | MetadataCategory.OtherPersonal,
-        forceRefresh = false
+        options: { forceRefresh: boolean } = { forceRefresh: false }
     ): Promise<LocalizedData<PopulatedWorkflowData>[]> {
-        return this.getMetaCategoryFromConsultId(consultationId, category, forceRefresh)
+        return this.getMetaCategoryFromConsultId(consultationId, category, options)
     }
 
     /**
@@ -826,15 +847,15 @@ export class OroClient {
      */
     public async getMedicalDataFromConsultId(
         consultationId: Uuid,
-        forceRefresh = false
+        options: { forceRefresh: boolean } = { forceRefresh: false }
     ): Promise<LocalizedData<PopulatedWorkflowData>[]> {
-        return this.getMetaCategoryFromConsultId(consultationId, MetadataCategory.Medical, forceRefresh)
+        return this.getMetaCategoryFromConsultId(consultationId, MetadataCategory.Medical, options)
     }
 
     private async getMetaCategoryFromConsultId(
         consultationId: Uuid,
         category: MetadataCategory,
-        forceRefresh = false
+        options: { forceRefresh: boolean } = { forceRefresh: false }
     ): Promise<LocalizedData<PopulatedWorkflowData>[]> {
         let grants = await this.getGrants({ consultationId })
         let workflowData: LocalizedData<PopulatedWorkflowData>[] = []
@@ -848,7 +869,7 @@ export class OroClient {
                 },
                 true,
                 grant.lockboxOwnerUuid,
-                forceRefresh
+                options
             )
 
             // TODO: find another solution for backwards compatibility (those without the metadata consultationIds)
@@ -863,7 +884,7 @@ export class OroClient {
                         },
                         true,
                         grant.lockboxOwnerUuid,
-                        forceRefresh
+                        options
                     )
                 ).filter((entry) => !entry.metadata.consultationIds) // Keep only entries without associated consultationIds
             }
@@ -966,7 +987,7 @@ export class OroClient {
         filter: Metadata,
         expandPrivateMetadata: boolean,
         lockboxOwnerUuid?: Uuid,
-        forceRefresh: boolean = false
+        options: { forceRefresh: boolean } = { forceRefresh: false }
     ): Promise<LockboxManifest> {
         let manifestKey = JSON.stringify({
             lockboxUuid,
@@ -974,7 +995,7 @@ export class OroClient {
             expandPrivateMetadata,
             lockboxOwnerUuid,
         })
-        if (!forceRefresh && this.cachedManifest[manifestKey]) return this.cachedManifest[manifestKey]
+        if (!options.forceRefresh && this.cachedManifest[manifestKey]) return this.cachedManifest[manifestKey]
 
         return this.vaultClient.lockboxManifestGet(lockboxUuid, filter, lockboxOwnerUuid).then((manifest) => {
             return Promise.all(
@@ -1075,11 +1096,10 @@ export class OroClient {
         const identificationDataUuid = (
             await this.getLockboxManifest(
                 lockboxUuid,
-
                 filter,
                 false,
                 grant.lockboxOwnerUuid,
-                true
+                { forceRefresh: true }
             )
         )[0].dataUuid
 
@@ -1232,7 +1252,7 @@ export class OroClient {
      */
     public async getPatientConsultationData(
         consultationId: Uuid,
-        forceRefresh: boolean = false
+        options: { forceRefresh: boolean } = { forceRefresh: false }
     ): Promise<PopulatedWorkflowData[]> {
         //TODO: make use of getPatientDocumentsList instead of doing it manually here
         return Promise.all(
@@ -1247,7 +1267,7 @@ export class OroClient {
                         },
                         true,
                         grant.lockboxOwnerUuid,
-                        forceRefresh
+                        options
                     ).then((manifest) =>
                         Promise.all(
                             manifest.map((e) =>
@@ -1352,7 +1372,7 @@ export class OroClient {
                         { ...filters, consultationId },
                         expandPrivateMetadata,
                         grant.lockboxOwnerUuid,
-                        true
+                        { forceRefresh: true }
                     ).then((manifest) =>
                         Promise.all(
                             manifest.map(async (entry): Promise<Document> => {
@@ -1533,7 +1553,7 @@ export class OroClient {
                 contentType: 'application/json',
             },
             {},
-            true
+            { forceReplace: true }
         )
 
         return updatedIdentity

package/src/helpers/consult.ts

@@ -0,0 +1,29 @@
+import { Consult, ConsultRequest } from 'oro-sdk-apis'
+import { OroClient } from '..'
+
+/**
+ * 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
+ */
+export async function getOrCreatePatientConsultationUuid(
+    consult: ConsultRequest,
+    oroClient: OroClient
+): Promise<Consult> {
+    let payment = await oroClient.practiceClient.practiceGetPayment(
+        consult.uuidPractice,
+        consult.idStripeInvoiceOrPaymentIntent
+    )
+    if (payment && payment.uuidConsult) {
+        return oroClient.consultClient.getConsultByUUID(payment.uuidConsult).catch((err) => {
+            console.error('Error while retrieving consult', err)
+            throw err
+        })
+    } else {
+        return await oroClient.consultClient.consultCreate(consult).catch((err) => {
+            console.error('Error while creating consult', err)
+            throw err
+        })
+    }
+}

package/src/helpers/index.ts

@@ -2,3 +2,4 @@ export * from './client'
 export * from './workflow'
 export * from './patient-registration'
 export * from './vault-grants'
+export * from './prescription-refill'

package/src/helpers/patient-registration.ts

@@ -29,6 +29,7 @@ import {
     RegisterPatientOutput,
     toActualObject,
 } from '..'
+import { getOrCreatePatientConsultationUuid } from './consult'
 
 const MAX_RETRIES = 15
 
@@ -167,10 +168,10 @@ export async function registerPatient(
                 oroClient,
                 onProgress
                     ? {
-                          onProgress,
-                          currentStep,
-                          stepsTotalNum,
-                      }
+                        onProgress,
+                        currentStep,
+                        stepsTotalNum,
+                    }
                     : undefined
             ).catch((err) => {
                 console.error('[SDK: registration] Some errors happened during image upload', err)
@@ -275,30 +276,6 @@ export async function registerPatient(
     }
 }
 
-/**
- * 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
- */
-async function getOrCreatePatientConsultationUuid(consult: ConsultRequest, oroClient: OroClient): Promise<Consult> {
-    let payment = await oroClient.practiceClient.practiceGetPayment(
-        consult.uuidPractice,
-        consult.idStripeInvoiceOrPaymentIntent
-    )
-    if (payment && payment.uuidConsult) {
-        return oroClient.consultClient.getConsultByUUID(payment.uuidConsult).catch((err) => {
-            console.error('Error while retrieving consult', err)
-            throw err
-        })
-    } else {
-        return await oroClient.consultClient.consultCreate(consult).catch((err) => {
-            console.error('Error while creating consult', err)
-            throw err
-        })
-    }
-}
-
 /**
  * Creates a new lockbox for the patient if they do not have any, otherwise, use the first (and only one)
  * @param oroClient
@@ -362,8 +339,8 @@ async function storePatientData(
                     consultationId, // TODO: deprecated. Will finally only be in privateMetadata
                 },
                 { consultationId },
-                false,
-                true // the only data that needs to include an email notification
+                { withNotification: true },
+                // the only data that needs to include an email notification
             )
         ),
         getWorkflowDataByCategory(workflow, MetadataCategory.Medical).then((data) =>
@@ -462,11 +439,11 @@ async function storeImageAliases(
                         Math.round(
                             ((progress.currentStep + 1) / progress.stepsTotalNum -
                                 progress.currentStep / progress.stepsTotalNum) *
-                                100
+                            100
                         ) / 100
                     progress.onProgress(
                         progress.currentStep / progress.stepsTotalNum +
-                            progressStepValue * (storedImagesNum / totalImagesNum),
+                        progressStepValue * (storedImagesNum / totalImagesNum),
                         'store_images',
                         {
                             storedImagesNum,

package/src/helpers/prescription-refill.ts

@@ -0,0 +1,177 @@
+import {
+    Consult,
+    ConsultRequest,
+    DocumentType,
+    MedicalStatus,
+    MetadataCategory,
+    PlaceData,
+    SelectedAnswersData,
+    Uuid,
+    WorkflowData,
+} from 'oro-sdk-apis'
+import { OroClient } from '..'
+import { getOrCreatePatientConsultationUuid } from './consult'
+
+const MAX_RETRIES = 15
+/**
+ * Placeholder while the workflow interpreter for the refill flows is complete
+ *
+ * Creates a fake workflow in which the workflow data will reside
+ *
+ * @param isTreatmentWorking the value from the `is treatment working` question
+ * @param hasSideEffects the value from the `does the treatment have side effects` question
+ * @param deliveryAddress the provided delivery address
+ * @param pharmacy
+ * @returns a workflow
+ */
+export function getRefillAnswersAsWorkflow(
+    isTreatmentWorking: string,
+    hasSideEffects: string,
+    deliveryAddress?: string,
+    pharmacy?: PlaceData
+): WorkflowData {
+    let selectedAnswers: SelectedAnswersData = [
+        {
+            ['isTreatmentWorking']: isTreatmentWorking,
+        },
+        {
+            ['hasSideEffects']: hasSideEffects,
+        },
+    ]
+
+    if (deliveryAddress) selectedAnswers.push({ ['deliveryAddress']: deliveryAddress })
+    if (pharmacy) selectedAnswers.push({ ['pharmacy']: JSON.stringify(pharmacy) })
+
+    return {
+        id: '32573a20-6f1d-49be-9ad3-b87c58074979',
+        createdAt: '2022-10-03T00:00:00.000Z',
+        culDeSacs: [],
+        hidePlanRules: [],
+        pages: [
+            {
+                title: 'Prescription Refill',
+                groups: [
+                    {
+                        type: 'field-group',
+                        fieldsAndGroups: [
+                            {
+                                type: 'field',
+                                id: 'isTreatmentWorking',
+                            },
+                            {
+                                type: 'field',
+                                id: 'hasSideEffects',
+                            },
+                            {
+                                type: 'field',
+                                id: 'youPharmacy',
+                            },
+                            {
+                                type: 'field',
+                                id: 'youAddress',
+                            },
+                        ],
+                    },
+                ],
+                questions: {
+                    isTreatmentWorking: {
+                        label: 'Is the treatment working for you?',
+                        kind: 'radio',
+                        inline: true,
+                        inlineLabel: false,
+                        metaCategory: MetadataCategory.Refill,
+                        answers: {
+                            '73bec6eb-0310-4787-af3c-ac9c291737b2': {
+                                text: 'Yes',
+                            },
+                            'e193951f-986f-4db3-bede-903045a1804a': {
+                                text: 'No',
+                            },
+                        },
+                    },
+                    hasSideEffects: {
+                        label: 'Are there any side effects',
+                        kind: 'radio',
+                        inline: true,
+                        inlineLabel: false,
+                        metaCategory: MetadataCategory.Refill,
+                        answers: {
+                            '1b87ad22-d316-4fac-9c7f-8f4ccb841aed': {
+                                text: 'Yes',
+                            },
+                            'ab7f5a41-c351-4f5d-a568-e38f9f200e9a': {
+                                text: 'No',
+                            },
+                        },
+                    },
+                    youPharmacy: {
+                        kind: 'online-pharmacy-picker',
+                        label: 'Which pharmacy do you want the prescription sent to?',
+                        metaCategory: MetadataCategory.Refill,
+                        minorLabel: ' (Optional)',
+                        summaryLabel: 'Your pharmacy',
+                    },
+                    youAddress: {
+                        kind: 'place-address',
+                        label: 'Address',
+                        metaCategory: MetadataCategory.Refill,
+                    },
+                },
+            },
+        ],
+        locale: 'en',
+        selectedAnswers,
+    }
+}
+
+/**
+ * Complete refill flow, creates a consult, stores refill data and updates consultation status
+ * @param consultRequest
+ * @param populatedRefillWorkflow the refill workflow data
+ * @param oroClient
+ */
+export async function createRefill(
+    consultRequest: ConsultRequest,
+    populatedRefillWorkflow: WorkflowData,
+    oroClient: OroClient
+) {
+    let retry = MAX_RETRIES
+    let errorsThrown: Error[] = []
+
+    let newConsult: Consult | undefined
+    let lockboxUuid: Uuid | undefined
+
+    for (; retry > 0; retry--) {
+        try {
+            if (!newConsult) newConsult = await getOrCreatePatientConsultationUuid(consultRequest, oroClient)
+
+            if (!lockboxUuid) lockboxUuid = (await oroClient.getGrants())[0].lockboxUuid
+
+            await oroClient
+                .getOrInsertJsonData(
+                    lockboxUuid!,
+                    populatedRefillWorkflow,
+                    {
+                        category: MetadataCategory.Refill,
+                        documentType: DocumentType.PopulatedWorkflowData,
+                        consultationIds: [newConsult.uuid],
+                    },
+                    {},
+                    { withNotification: true }
+                )
+                .catch((err) => {
+                    console.error('[SDK: prescription refill] Some errors happened during refill data upload', err)
+                    errorsThrown.push(err)
+                })
+
+            if (errorsThrown.length > 0) throw errorsThrown
+            await oroClient.consultClient.updateConsultByUUID(newConsult.uuid, {
+                statusMedical: MedicalStatus.New,
+            })
+        } catch (err) {
+            console.error(`[SDK] Error occured during refill: ${err}, retrying... Retries remaining: ${retry}`)
+            errorsThrown = []
+            continue
+        }
+    }
+}