oro-sdk 2.1.4-dev1

package/src/helpers/client.ts

@@ -0,0 +1,199 @@
+import {
+    PopulatedWorkflowData,
+    MetadataCategory,
+    SelectedAnswersData,
+} from '../models'
+import { PersonalInformations } from '../models/client'
+
+const personalMetaToPrefix = {
+    [MetadataCategory.Personal]: 'you',
+    [MetadataCategory.ChildPersonal]: 'child',
+    [MetadataCategory.OtherPersonal]: 'other',
+}
+
+/**
+ * This function extract PersonalInformations from data input object coming from workflow
+ * @param data extracted from WorkflowData
+ * @returns PersonalInformations of a patient
+ */
+export function identificationToPersonalInformations(
+    data: any,
+    category:
+        | MetadataCategory.Personal
+        | MetadataCategory.ChildPersonal
+        | MetadataCategory.OtherPersonal
+): PersonalInformations {
+    const prefix = personalMetaToPrefix[category]
+
+    return {
+        birthday: data[`${prefix}Birthday`],
+        firstname: data[`${prefix}Firstname`],
+        gender: data[`${prefix}Gender`],
+        name: data[`${prefix}Name`],
+        phone: data[`${prefix}Phone`],
+        zip: data[`${prefix}Zip`],
+        hid: data[`${prefix}HID`] ?? data[`${prefix}ID`], // This is done for backward compatibility (historically youID was used)
+        pharmacy: data[`${prefix}Pharmacy`],
+        address: data[`${prefix}Address`],
+    }
+}
+
+export function toActualObject(data: PopulatedWorkflowData) {
+    const ret: any = {}
+
+    Object.entries(data.fields).forEach(([key, field]) => {
+        ret[key] = field.displayedAnswer ? field.displayedAnswer : field.answer
+    })
+
+    return ret
+}
+
+/**
+ * This function update a PopulatedWorkflowData with PersonalInformations
+ * @param infos the personal informations
+ * @param data  the PopulatedWorkflowData
+ * @returns an updated PopulatedWorkflowData
+ */
+export function updatePersonalIntoPopulatedWorkflowData(
+    infos: PersonalInformations,
+    data: PopulatedWorkflowData,
+    category:
+        | MetadataCategory.Personal
+        | MetadataCategory.ChildPersonal
+        | MetadataCategory.OtherPersonal
+) {
+    const prefix = personalMetaToPrefix[category]
+
+    const ret = JSON.parse(JSON.stringify(data)) // deep copy PopulatedWorkflowData
+
+    if (infos.birthday && ret.fields[`${prefix}Birthday`])
+        ret.fields[`${prefix}Birthday`].answer = infos.birthday
+    if (infos.firstname && ret.fields[`${prefix}Firstname`])
+        ret.fields[`${prefix}Firstname`].answer = infos.firstname
+    if (infos.gender && ret.fields[`${prefix}Gender`])
+        ret.fields[`${prefix}Gender`].answer = infos.gender
+    if (infos.name && ret.fields[`${prefix}Name`])
+        ret.fields[`${prefix}Name`].answer = infos.name
+    if (infos.phone && ret.fields[`${prefix}Phone`])
+        ret.fields[`${prefix}Phone`].answer = infos.phone
+    if (infos.zip && ret.fields[`${prefix}Zip`])
+        ret.fields[`${prefix}Zip`].answer = infos.zip
+    if (infos.hid) {
+        if (ret.fields[`${prefix}HID`]) {
+            ret.fields[`${prefix}HID`].answer = infos.hid
+        } else if (ret.fields[`${prefix}ID`]) {
+            // This is done for backward compatibility (historically youID was used)
+            ret.fields[`${prefix}ID`].answer = infos.hid
+        } else {
+            // If does not exist create it
+            ret.fields[`${prefix}HID`] = { kind: 'text', answer: infos.hid }
+        }
+    }
+
+    return ret
+}
+
+/**
+ * This function extract an ISO 3166-1 alpha-2 country and subdivision code from data input object coming from workflow
+ * @param answers answers from the WorkflowData
+ * @returns an ISO 3166 alpha-2 code or undefined
+ */
+export function extractISOLocalityForConsult(
+    answers?: SelectedAnswersData
+): string | undefined {
+    if (!answers) {
+        return undefined
+    }
+
+    const arrAnswersWithLocality = answers
+        .flatMap((currentAnswerPage) => {
+            const arrCountryFields = Object.keys(currentAnswerPage)
+                .filter(
+                    (workflowFieldName) =>
+                        workflowFieldName.indexOf('Country') !== -1
+                )
+                .flat()
+            const arrProvinceFields = Object.keys(currentAnswerPage)
+                .filter(
+                    (workflowFieldName) =>
+                        workflowFieldName.indexOf('Province') !== -1
+                )
+                .flat()
+            const arrConsultLocalFields = Object.keys(currentAnswerPage)
+                .filter(
+                    (workflowFieldName) =>
+                        workflowFieldName.indexOf('Locality') !== -1
+                )
+                .flat()
+            //returning the actual selected values, skipping if their IDs are more complex than a string
+            return [
+                ...arrCountryFields.map(
+                    (currentFieldName) =>
+                        (typeof currentAnswerPage[currentFieldName] === 'string'
+                            ? currentAnswerPage[currentFieldName]
+                            : undefined) as string
+                ),
+                ...arrProvinceFields.map(
+                    (currentFieldName) =>
+                        (typeof currentAnswerPage[currentFieldName] === 'string'
+                            ? currentAnswerPage[currentFieldName]
+                            : undefined) as string
+                ),
+                ...arrConsultLocalFields.map(
+                    (currentFieldName) =>
+                        (typeof currentAnswerPage[currentFieldName] === 'string'
+                            ? currentAnswerPage[currentFieldName]
+                            : undefined) as string
+                ),
+            ]
+        })
+        .filter((item) => item !== undefined)
+
+    const arrSelectedLocality = arrAnswersWithLocality.filter(
+        (currentSelectedLocality) =>
+            currentSelectedLocality.startsWith('isoLocalityConsult')
+    )
+    if (!arrSelectedLocality || arrSelectedLocality.length === 0) {
+        console.log('no locality found in ' + arrSelectedLocality)
+        return undefined
+    }
+    //to allow enforcing of an order, we will allow the following pattern in the isoLocalityConsult field name
+    //     isoLocalityConsult-QC-CA and isoLocalityConsult_1-QC-CA
+    // or generally: isoLocalityConsult-<isoValue> or isoLocalityConsult_<priority>-<isoValue>
+    const allowedLocalityPatterns = /isoLocalityConsult(?:_(?<indexPriority>\d*))?-(?<isoValue>[a-zA-Z0-9]{2}-[a-zA-Z0-9]{1,3})/
+    const finalLocality = arrSelectedLocality.reduce<string | undefined>(
+        (finalLocality, currentSelectedLocality) => {
+            const extractedSelected = allowedLocalityPatterns.exec(
+                currentSelectedLocality
+            )
+            const [, indexSelectedPriority, isoSelectedValue] =
+                extractedSelected ?? []
+            if (!finalLocality) {
+                return isoSelectedValue
+            }
+
+            const extractedFinal = allowedLocalityPatterns.exec(finalLocality)
+            const [, indexFinalPriority, isoFinalValue] = extractedFinal ?? []
+            //we only keep the old value if there's priority used
+            // and the new value is of lower priority
+            if (
+                !indexSelectedPriority ||
+                (indexFinalPriority &&
+                    indexFinalPriority > indexSelectedPriority)
+            ) {
+                return isoFinalValue
+            }
+
+            return isoSelectedValue
+        },
+        undefined
+    )
+
+    console.log('Picking locality ' + finalLocality)
+    return finalLocality
+}
+
+const sessionPrivateKeyPrefix = 'sess-pkey'
+export function sessionStorePrivateKeyName(id: string): string {
+    return sessionPrivateKeyPrefix + id
+}

package/src/helpers/index.ts

@@ -0,0 +1,4 @@
+export * from './client'
+export * from './workflow'
+export * from './patient-registration'
+export * from './vault-grants'

package/src/helpers/patient-registration.ts

@@ -0,0 +1,490 @@
+import {
+    Consult,
+    ConsultationImageMeta,
+    getImagesFromIndexDb,
+    getWorkflowDataByCategory,
+    filterTriggeredAnsweredWithKind,
+    MedicalStatus,
+    OroClient,
+    PersonalMeta,
+    Practitioner,
+    RegisterPatientOutput,
+} from '..'
+import {
+    ConsultationMeta,
+    ConsultRequest,
+    DocumentType,
+    IndexKey,
+    MedicalMeta,
+    MetadataCategory,
+    PreferenceMeta,
+    RawConsultationMeta,
+    Uuid,
+    VaultIndex,
+    WorkflowData,
+} from '../models'
+
+const MAX_RETRIES = 15
+
+export async function registerPatient(
+    patientUuid: Uuid,
+    consultRequest: ConsultRequest,
+    workflow: WorkflowData,
+    oroClient: OroClient,
+    masterKey?: Uuid,
+    recoveryQA?: {
+        recoverySecurityQuestions: string[]
+        recoverySecurityAnswers: string[]
+    }
+): Promise<RegisterPatientOutput> {
+    let consult: Consult | undefined = undefined
+    let lockboxUuid: Uuid | undefined = undefined
+    let practitionerAdmin: Uuid | undefined = undefined
+    let retry = MAX_RETRIES
+    let isExistingPatient = false
+
+    for (; retry > 0; retry--) {
+        try {
+            // Wait a bit each retry (we also want the first one to wait)
+            await new Promise((resolve) => setTimeout(resolve, 2000))
+
+            // Retrieving practitioners
+            if (!practitionerAdmin)
+                practitionerAdmin = (
+                    await oroClient.practiceClient.practiceGetFromUuid(
+                        consultRequest.uuidPractice
+                    )
+                ).uuidAdmin
+
+            let practitioners: Practitioner[] = await oroClient.practiceClient
+                .practiceGetPractitioners(consultRequest.uuidPractice)
+                .catch((err) => {
+                    console.log(`Error retrieving practitioners`, err)
+                    return []
+                })
+
+            // Creating consult
+            if (!consult) {
+                consult = await getOrCreatePatientConsultationUuid(
+                    consultRequest,
+                    oroClient
+                )
+            }
+
+            // Creating lockbox
+            if (!lockboxUuid)
+                lockboxUuid = await getOrCreatePatientLockbox(oroClient)
+
+            isExistingPatient = await patientConsultExists(
+                consult,
+                lockboxUuid,
+                oroClient
+            ).catch((err) => {
+                console.error(`Error when retrieving existing consults ${err}`)
+                return false
+            })
+            await oroClient
+                .grantLockbox(practitionerAdmin, lockboxUuid)
+                .catch((err) => {
+                    console.error(
+                        `Error while granting lockbox to practitioner admin ${practitionerAdmin}`,
+                        err
+                    )
+                    // if we cannot grant to the admin, then the registration will fail
+                    throw err
+                })
+
+            // Patient Grant to practice
+            let grantPromises = practitioners
+                .filter(
+                    (practitioner) => practitioner.uuid !== practitionerAdmin
+                )
+                .map(async (practitioner) => {
+                    return oroClient
+                        .grantLockbox(practitioner.uuid, lockboxUuid!)
+                        .catch((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
+                            if (retry <= 1) return
+                            else throw err
+                        })
+                })
+
+            await storePatientData(
+                consult.uuid,
+                consultRequest.isoLanguageRequired,
+                lockboxUuid,
+                workflow,
+                oroClient
+            )
+
+            // the index will identify in which lockbox a consultation live
+            let consultIndex: VaultIndex = {
+                [IndexKey.ConsultationLockbox]: [
+                    {
+                        grant: {
+                            lockboxUuid,
+                            lockboxOwnerUuid: patientUuid,
+                        },
+                        consultationId: consult.uuid,
+                    },
+                ],
+            }
+
+            let consultIndexPromises = practitioners.map(async (practitioner) => {
+                return oroClient
+                    .vaultIndexAdd(consultIndex, practitioner.uuid)
+                    .catch((err) => {
+                        console.error(
+                            `Error while adding to the practitioner's index ${practitioner.uuid}`,
+                            err
+                        )
+                        /// it's acceptable to continue registration
+                        return
+                    })
+            })
+
+
+            //DEPRECATED: REMOVE ME : BEGIN /////////////////////////////////////////
+
+            let deprecatedConsultIndex: VaultIndex = {
+                [IndexKey.Consultation]: [
+                    {
+                        grant: {
+                            lockboxUuid,
+                            lockboxOwnerUuid: patientUuid,
+                        },
+                        consultationId: consult.uuid,
+                    },
+                ],
+            }
+
+            let deprecatedConsultIndexPromises = practitioners.map(async (practitioner) => {
+                return oroClient
+                    .vaultIndexAdd(deprecatedConsultIndex, practitioner.uuid)
+                    .catch((err) => {
+                        console.error(
+                            `Error while adding to the practitioner's index ${practitioner.uuid}`,
+                            err
+                        )
+                        /// it's acceptable to continue registration
+                        return
+                    })
+            })
+
+            //DEPRECATED: REMOVE ME : END /////////////////////////////////////////
+
+
+            if (masterKey && !isExistingPatient) {
+                // generate and store recovery payload
+                await oroClient
+                    .updateMasterKey(patientUuid, masterKey, lockboxUuid)
+                    .catch((err) => {
+                        console.error(`Error while updating master key`, err)
+                        /// it's acceptable to continue registration
+                        return
+                    })
+            } else {
+                // we did not set the master key so we do not return it
+                masterKey = undefined
+            }
+
+            if (recoveryQA && !isExistingPatient)
+                // Patient security question recovery threshold is 2 answers
+                await oroClient
+                    .updateSecurityQuestions(
+                        patientUuid,
+                        recoveryQA.recoverySecurityQuestions,
+                        recoveryQA.recoverySecurityAnswers,
+                        2
+                    )
+                    .catch((err) => {
+                        console.error(
+                            `Error while updating security questions`,
+                            err
+                        )
+                        /// it's acceptable to continue registration
+                        return
+                    })
+
+            await Promise.all([...grantPromises, ...consultIndexPromises, ...deprecatedConsultIndexPromises])
+
+            // Deem the consultation as ready
+            await oroClient.consultClient.updateConsultByUUID(consult.uuid, {
+                statusMedical: MedicalStatus.New,
+            })
+
+            // if we got through the complete flow, the registration succeeded
+            break
+        } catch (err) {
+            console.error(
+                `Error occured during registration, retrying... Retries remaining: ${retry}`
+            )
+            continue
+        }
+    }
+
+    if (retry <= 0) {
+        console.error('registration failed: MAX_RETRIES reached')
+        throw 'RegistrationFailed'
+    }
+
+    console.log('Successfully Registered')
+    await oroClient.cleanIndex()
+    return {
+        masterKey,
+        consultationId: consult!.uuid,
+        lockboxUuid: lockboxUuid!,
+    }
+}
+
+/**
+ * Returns whether the consultation creation is for an existing patient (ignores data from the current consultation)
+ *
+ * @param currentConsultation
+ */
+async function patientConsultExists(
+    currentConsultation: Consult,
+    lockboxUuid: Uuid,
+    oroClient: OroClient
+): Promise<boolean> {
+    let publicMetadata: ConsultationMeta = {
+        category: MetadataCategory.Consultation,
+        documentType: DocumentType.PopulatedWorkflowData,
+    }
+    let manifest = await oroClient.vaultClient.lockboxMetadataGet(
+        lockboxUuid,
+        ['consultationId'],
+        [],
+        publicMetadata
+    )
+    return (
+        manifest[0].findIndex(
+            (v: { consultationId: Uuid }) =>
+                v.consultationId != null &&
+                v.consultationId !== currentConsultation.uuid
+        ) !== -1
+    )
+}
+
+/**
+ * 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
+ * @returns the lockbox Uuid
+ */
+async function getOrCreatePatientLockbox(oroClient: OroClient): Promise<Uuid> {
+    let grants = await oroClient.getGrants(undefined, true)
+    if (grants.length > 0) {
+        console.log(
+            'The grant has already been created, skipping lockbox create step'
+        )
+        return grants[0].lockboxUuid!
+    } else
+        return (
+            await oroClient.vaultClient.lockboxCreate().catch((err) => {
+                console.error('Error while creating lockbox', err)
+                throw err
+            })
+        ).lockboxUuid
+}
+
+/**
+ * Store all patient related information into his/her lockbox
+ * @param consultationId The consultation id
+ * @param isoLanguage the prefered language of communication (ISO 639-3 https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes)
+ * @param lockboxUuid the lockbox uuid to store data in
+ * @param workflow the workflow used to extract informations
+ * @param oroClient an oroClient instance
+ * @returns
+ */
+async function storePatientData(
+    consultationId: Uuid,
+    isoLanguage: string,
+    lockboxUuid: Uuid,
+    workflow: WorkflowData,
+    oroClient: OroClient
+): Promise<(Uuid | void)[]> {
+    // Create and store registration data
+    return Promise.all([
+        storeImageAliases(
+            consultationId,
+            lockboxUuid,
+            workflow,
+            oroClient
+        ).catch((err) => {
+            console.error('[SDK] Some errors happened during image upload', err)
+        }),
+        // Storing Raw data first
+        oroClient.getOrInsertJsonData<RawConsultationMeta>(
+            lockboxUuid,
+            workflow,
+            {
+                category: MetadataCategory.Raw,
+                contentType: 'application/json',
+                consultationId,
+            },
+            {}
+        ),
+        getWorkflowDataByCategory(workflow, MetadataCategory.Consultation).then(
+            (data) =>
+                oroClient.getOrInsertJsonData<ConsultationMeta>(
+                    lockboxUuid,
+                    data,
+                    {
+                        category: MetadataCategory.Consultation,
+                        documentType: DocumentType.PopulatedWorkflowData,
+                        consultationId, // TODO: deprecated. Will finally only be in privateMetadata
+                    },
+                    { consultationId }
+                )
+        ),
+        getWorkflowDataByCategory(workflow, MetadataCategory.Medical).then(
+            (data) =>
+                oroClient.getOrInsertJsonData<MedicalMeta>(
+                    lockboxUuid,
+                    data,
+                    {
+                        category: MetadataCategory.Medical,
+                        documentType: DocumentType.PopulatedWorkflowData,
+                        consultationIds: [consultationId!],
+                    },
+                    {}
+                )
+        ),
+        extractAndStorePersonalWorkflowData(
+            workflow,
+            lockboxUuid,
+            consultationId,
+            MetadataCategory.Personal,
+            oroClient
+        ),
+        extractAndStorePersonalWorkflowData(
+            workflow,
+            lockboxUuid,
+            consultationId,
+            MetadataCategory.ChildPersonal,
+            oroClient
+        ),
+        extractAndStorePersonalWorkflowData(
+            workflow,
+            lockboxUuid,
+            consultationId,
+            MetadataCategory.OtherPersonal,
+            oroClient
+        ),
+        oroClient.getOrInsertJsonData<PreferenceMeta>(
+            lockboxUuid,
+            { isoLanguage },
+            {
+                category: MetadataCategory.Preference,
+                contentType: 'application/json',
+            },
+            {}
+        ),
+    ]).then((dataUuids) => dataUuids.flat())
+}
+
+async function storeImageAliases(
+    consultationId: Uuid,
+    lockboxUuid: Uuid,
+    workflow: WorkflowData,
+    oroClient: OroClient
+): Promise<(Uuid | void)[]> {
+    const images = await getImagesFromIndexDb(
+        (await filterTriggeredAnsweredWithKind(workflow, 'images-alias')).flat()
+    )
+
+    const nonNullImages = images.filter((img) => !!img)
+
+    if (images.length !== nonNullImages.length) {
+        console.error(
+            '[SDK] Some images have not been found, they have been skipped.'
+        )
+    }
+
+    let promises = nonNullImages.map((image) => {
+        return oroClient.getOrInsertJsonData<ConsultationImageMeta>(
+            lockboxUuid,
+            image,
+            {
+                category: MetadataCategory.Consultation,
+                documentType: DocumentType.ImageAlias,
+                consultationId,
+                idbId: image.idbId as string,
+            },
+            {}
+        )
+    })
+    return Promise.all(promises)
+}
+
+/**
+ * Extracts the workflow MetadataCategory for Personal, ChildPersonal and OtherPersonal
+ * then stores it in the vault
+ *
+ * @param workflow
+ * @param lockboxUuid
+ * @param category
+ * @returns The data uuid
+ */
+export async function extractAndStorePersonalWorkflowData(
+    workflow: WorkflowData,
+    lockboxUuid: Uuid,
+    consultationId: Uuid,
+    category:
+        | MetadataCategory.Personal
+        | MetadataCategory.ChildPersonal
+        | MetadataCategory.OtherPersonal,
+    oroClient: OroClient
+): Promise<Uuid | void> {
+    return getWorkflowDataByCategory(
+        workflow,
+        (category as unknown) as MetadataCategory
+    ).then((data) => {
+        if (Object.keys(data.fields).length === 0) return
+        return oroClient.getOrInsertJsonData<PersonalMeta>(
+            lockboxUuid,
+            data,
+            {
+                category,
+                documentType: DocumentType.PopulatedWorkflowData,
+                consultationIds: [consultationId],
+            },
+            {}
+        )
+    })
+}