oro-sdk 2.1.4-dev1.0

package/src/helpers/vault-grants.ts

@@ -0,0 +1,51 @@
+import { CryptoRSA, uuidParse} from "oro-toolbox"
+import { EncryptedIndexEntry, Grant, IndexConsultLockbox } from ".."
+
+/**
+ * Decrypts and returns the encrypted grants
+ * If something went wrong during decryption, that grant will be removed from the list
+ *
+ * @param encryptedGrants: an array of encrypted grants
+ * @param rsaKey: the rsa key used to decrypt the encrypted grants
+ * @returns an array of grants
+ */
+export function decryptGrants(encryptedGrants: Grant[], rsaKey: CryptoRSA): Grant[] {
+    return encryptedGrants
+        .map(grant => {
+            if (grant.encryptedLockbox && !grant.lockboxUuid) {
+                try {
+                    grant.lockboxUuid = uuidParse(
+                        rsaKey.base64DecryptToBytes(grant.encryptedLockbox)
+                    )
+                } catch (e) {
+                    console.error('[sdk:index] The grant could not be decrypted or was not a valid UUID: ', e)
+                }
+            }
+            return grant
+        })
+        .filter(grant => grant.lockboxUuid)
+}
+
+/**
+ * Decrypts the encrypted consult lockboxes and returns their grants
+ * If something went wrong during decryption, that grant will be removed from the list
+ *
+ * @param encryptedConsultLockboxes: an array of encrypted entries
+ * @param rsaKey: the rsa key used to decrypt the encrypted entries
+ * @returns an array of grants
+ */
+export function decryptConsultLockboxGrants(encryptedConsultLockboxes: EncryptedIndexEntry[], rsaKey: CryptoRSA): Grant[] {
+    return encryptedConsultLockboxes
+        .map(encryptedConsultLockboxes => {
+            try {
+                return [true, (rsaKey.base64DecryptToJson(
+                    encryptedConsultLockboxes.encryptedIndexEntry
+                ) as IndexConsultLockbox).grant]
+            } catch(e) {
+                console.error('[sdk:index] The consult lockbox grant could not be decrypted: ', e)
+                return [false, undefined] // if decryption fails, we want to ignore the grant but not fail the call
+            }
+        })
+        .filter(grantsTuple => grantsTuple[0])
+        .map(grantTuples => grantTuples[1] as Grant)
+}

package/src/helpers/workflow.ts

@@ -0,0 +1,261 @@
+import { getMany } from 'idb-keyval'
+import {
+    MetadataCategory,
+    PopulatedWorkflowData,
+    PopulatedWorkflowField,
+    QuestionData,
+    SelectedAnswerData,
+    SelectedAnswersData,
+    WorkflowAnswersMissingError,
+    WorkflowData,
+    WorkflowPageData,
+    WorkflowUploadedImage,
+} from '../models'
+
+export async function filterTriggeredAnsweredWithKind(
+    workflowData: WorkflowData,
+    kind:
+        | 'text'
+        | 'date'
+        | 'number'
+        | 'images'
+        | 'images-alias'
+        | 'body-parts'
+        | 'pharmacy-picker'
+): Promise<SelectedAnswerData[]> {
+    if (!workflowData.selectedAnswers) throw WorkflowAnswersMissingError
+
+    // Flattens the list of answered questions
+    let flattenedAnswers = flattenSelectedAnswers(workflowData.selectedAnswers)
+    // Generates a list of applicable questions
+    let triggeredQuestionsWithKind = Object.fromEntries(
+        workflowData.pages
+            .map((a) => {
+                return Object.entries(a.questions).filter(
+                    ([_, question]) =>
+                        isTriggered(
+                            question.triggers || [],
+                            flattenedAnswers
+                        ) && question.kind === kind
+                )
+            })
+            .flat()
+    )
+
+    const samePageAnswers = workflowData.selectedAnswers.reduce((prev, cur) => {
+        return { ...prev, ...cur }
+    }, {})
+
+    const res = Object.keys(triggeredQuestionsWithKind).map(
+        (questionFieldName) => {
+            return samePageAnswers[questionFieldName]
+        }
+    )
+
+    return res
+}
+
+/**
+ * Filters and Populates the `selectedAnswers` from the workflow by
+ * Cross-referencing the `MetaCategory` of the answer's respective question
+ * Populates the fields labels and values that are of radio, dropdown and checkbox types
+ *
+ * @param workflowData
+ * @param category
+ * @returns An array of record key, value pairs
+ */
+export async function getWorkflowDataByCategory(
+    workflowData: WorkflowData,
+    category: MetadataCategory
+): Promise<PopulatedWorkflowData> {
+    if (!workflowData.selectedAnswers) throw WorkflowAnswersMissingError
+
+    // Flattens the list of answered questions
+    let flattenedAnswers = flattenSelectedAnswers(workflowData.selectedAnswers)
+    // Generates a list of applicable questions
+    let triggeredQuestions = Object.fromEntries(
+        workflowData.pages
+            .map((a) => {
+                return Object.entries(a.questions).filter(([_, question]) =>
+                    isTriggered(question.triggers || [], flattenedAnswers)
+                )
+            })
+            .flat()
+    )
+
+    const fields: Record<string, PopulatedWorkflowField> = {}
+
+    // Generates the answers of the specified category and adds the appropriate values if any are missing
+    return Promise.all(
+        workflowData.selectedAnswers
+            .map((e) => Object.entries(e))
+            .flat()
+            .filter(
+                ([k, v]) =>
+                    triggeredQuestions[k] &&
+                    triggeredQuestions[k]['metaCategory'] === category
+            )
+            .map(([k, v]) => {
+                return populateWorkflowField(triggeredQuestions[k], v).then(
+                    (populatedValue) => {
+                        fields[k] = populatedValue
+                    }
+                )
+            })
+    )
+        .then(() => {
+            const ret: PopulatedWorkflowData = {
+                workflowCreatedAt: workflowData.createdAt,
+                workflowId: workflowData.id,
+                locale: workflowData.locale,
+                fields,
+            }
+            return ret
+        })
+        .catch((err) => {
+            console.error(
+                `Error while extracting ${category} data from workflow`,
+                err
+            )
+            throw err
+        })
+}
+
+export async function getImagesFromIndexDb(
+    answer: SelectedAnswerData
+): Promise<WorkflowUploadedImage[]> {
+    return await getMany<WorkflowUploadedImage>(
+        (answer as any[]).map((v) => v.id ?? v) as string[]
+    )
+}
+
+/**
+ * (If applicable) Based on the question kind, and the answer type this function will add and replace the appropriate fields to the
+ * field values if they are radio, dropdown and checkbox fields
+ *
+ *
+ * @param question
+ * @param answerValue
+ * @returns
+ */
+async function populateWorkflowField(
+    question: QuestionData,
+    answerValue: SelectedAnswerData
+): Promise<PopulatedWorkflowField> {
+    let answer: any
+    let displayedAnswer: string | string[] | undefined = undefined
+
+    switch (question.kind) {
+        case 'radio':
+        case 'radio-card':
+        case 'select':
+            if (question.answers) {
+                displayedAnswer = question.answers[answerValue as string].text
+            }
+
+            answer = answerValue
+            break
+        case 'multiple':
+        case 'checkbox-group':
+            displayedAnswer = (answerValue as string[]).map((value) => {
+                if (question.answers) {
+                    return question.answers[value].text
+                }
+
+                throw new WorkflowAnswersMissingError()
+            })
+
+            answer = answerValue
+            break
+        case 'images':
+            answer = await getImagesFromIndexDb(answerValue).then((images) =>
+                images.map((image) => {
+                    const { name, imageData } = image
+
+                    return { name, imageData }
+                })
+            )
+            break
+        default:
+            answer = answerValue
+    }
+
+    return Promise.resolve({
+        answer,
+        displayedAnswer,
+        kind: question.kind,
+    })
+}
+
+export function isTriggered(triggers: string[], answers: string[]): boolean {
+    for (let trigger of triggers) {
+        if (!answers.includes(trigger)) {
+            return false
+        }
+    }
+    return true
+}
+
+export function flattenSelectedAnswers(answers: SelectedAnswersData) {
+    const linearAnswers: SelectedAnswerData[] = []
+
+    for (const answer of answers) {
+        linearAnswers.push(...Object.values(answer))
+    }
+
+    return linearAnswers.flat(1)
+}
+
+/**
+ * This function helps you to get a valid workflow selectedAnswers structure
+ * @param workflow the workflow data to use to initialize selectedAnswers
+ * @param useDefault use workflow default values or not (this is used to avoid having unset values to appear in summaries)
+ * @returns a valid selectedAnswers structure
+ */
+export function getInitialisedSelectedAnswers(
+    workflow: WorkflowData,
+    useDefault: boolean = true
+) {
+    return workflow.pages.map((page) => {
+        const ret: any = {}
+        for (const [id, question] of Object.entries(page.questions)) {
+            if (question.kind === 'body-parts') {
+                ret[id] = useDefault ? [] : undefined
+            } else {
+                ret[id] =
+                    useDefault && question.defaultValue
+                        ? question.defaultValue
+                        : undefined
+            }
+        }
+        return ret
+    })
+}
+
+export function fillWorkflowFromPopulatedWorkflow(
+    workflow: WorkflowData,
+    populatedWorkflow: PopulatedWorkflowData
+) {
+    const filledWorkflow = JSON.parse(JSON.stringify(workflow))
+
+    if (!filledWorkflow.selectedAnswers) {
+        filledWorkflow.selectedAnswers = getInitialisedSelectedAnswers(
+            filledWorkflow,
+            false
+        )
+    }
+
+    filledWorkflow.pages.forEach((page: WorkflowPageData, pageIdx: number) => {
+        const ret: any = {}
+        for (const [id] of Object.entries(page.questions)) {
+            if (populatedWorkflow.fields[id]) {
+                if (filledWorkflow.selectedAnswers)
+                    filledWorkflow.selectedAnswers[pageIdx][
+                        id
+                    ] = populatedWorkflow.fields[id].answer as string | string[]
+            }
+        }
+    })
+
+    return filledWorkflow
+}

package/src/index.ts

@@ -0,0 +1,61 @@
+import {
+    APIService,
+    TellerService,
+    VaultService,
+    GuardService,
+    PracticeService,
+    ConsultService,
+    WorkflowService,
+    DiagnosisService,
+} from './services'
+import { OroClient } from './client'
+import * as OroToolboxNamespace from 'oro-toolbox'
+
+export type OroToolbox = typeof OroToolboxNamespace
+
+export let wasmPath = 'node_modules/oro-toolbox'
+
+const init = (
+    toolbox: OroToolbox,
+    tellerBaseURL: string,
+    vaultBaseURL: string,
+    guardBaseURL: string,
+    practiceBaseURL: string,
+    consultBaseURL: string,
+    workflowBaseURL: string,
+    diagnosisBaseUrl: string,
+    authenticationCallback?: (err: Error) => void,
+) => {
+    const apiService = new APIService(undefined, authenticationCallback)
+    const tellerService = new TellerService(apiService, tellerBaseURL)
+    const practiceService = new PracticeService(
+        toolbox,
+        apiService,
+        practiceBaseURL
+    )
+    const consultService = new ConsultService(apiService, consultBaseURL)
+    const vaultService = new VaultService(apiService, vaultBaseURL)
+    const guardService = new GuardService(apiService, guardBaseURL)
+    const workflowService = new WorkflowService(apiService, workflowBaseURL)
+    const diagnosisService = new DiagnosisService(apiService, diagnosisBaseUrl)
+    const client = new OroClient(
+        toolbox,
+        tellerService,
+        vaultService,
+        guardService,
+        practiceService,
+        consultService,
+        workflowService,
+        diagnosisService,
+        authenticationCallback
+    )
+
+    return client
+}
+
+export { OroClient } from './client'
+export * from './models'
+export * from './helpers'
+export * from './services'
+export { OroToolboxNamespace }
+export default init

package/src/models/client.ts

@@ -0,0 +1,33 @@
+import { PlaceData } from '../services/external/clinia'
+import { Uuid } from './shared'
+
+export interface PersonalInformations {
+    birthday?: string
+    firstname?: string
+    gender?: string
+    name?: string
+    phone?: string
+    zip?: string
+    hid?: string // Social Insurance Number
+    pharmacy?: PlaceData
+    address?: string
+}
+
+export interface UserPreference {
+    isoLanguage: string // Should comply to ISO 639-3 https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes
+}
+
+export interface RegisterPatientOutput {
+    masterKey?: Uuid
+    consultationId: Uuid
+    lockboxUuid: Uuid
+}
+
+export interface RecoveryData {
+    masterKey: string // The master key used to decrypt the recoveryMasterKey from IdentityResponse
+}
+
+export interface LocalEncryptedData  {
+    encryptedKey: string
+    encryptedData: string
+}

package/src/models/consult.ts

@@ -0,0 +1,110 @@
+export enum AssistantType {
+    MedicalSecretary = 'MedicalSecretary',
+    Nurse = 'Nurse',
+    Specialist = 'Specialist',
+    Administrative = 'Administrative',
+    Other = 'Other',
+}
+
+export interface ConsultAssignedAssistant {
+    id?: number ///optional for insertion
+    uuidConsult: string
+    uuidAssistant: string
+    type: AssistantType
+    tagSpecialty?: string
+    duuidCurrentTaskDescription?: string
+}
+
+export enum TransmissionKind {
+    Fax = 'Fax',
+    Email = 'Email',
+    SMS = 'SMS',
+    EncryptedEmail = 'EncryptedEmail',
+    Logs = 'Logs',
+    API = 'API',
+    Other = 'Other',
+}
+
+export enum TransmissionStatus {
+    Preparing = 'Preparing',
+    Sending = 'Sending',
+    Sent = 'Sent',
+    Retrying = 'Retrying',
+    Failed = 'Failed',
+    DriverError = 'DriverError',
+    TimedOut = 'TimedOut',
+    ReceiverNotExist = 'ReceiverNotExist',
+    ReceiverNotAnswering = 'ReceiverNotAnswering',
+    ReceiverIncompatible = 'ReceiverIncompatible',
+}
+
+export interface ConsultTransmission {
+    id: number
+    uuidConsult: string
+    kind: TransmissionKind
+    status: TransmissionStatus
+    nameDriverReceiver: string
+    addressReceiver: string
+    idDriverForTransmission: string
+    txtLastDriverMessage: string
+    numTry: number
+    numTryLeft: number
+    delay: number
+    tsFirstTry: string
+    tsLastStatusUpdate: string
+    keyWebhookSecret: string
+}
+
+export enum FeeStatus {
+    NoFee = 'NoFee',
+    Pending = 'Pending',
+    Paid = 'Paid',
+    Reimbursed = 'Reimbursed',
+    Cancelled = 'Cancelled',
+    Contested = 'Contested',
+}
+
+export enum MedicalStatus {
+    Creating = 'Creating',
+    New = 'New',
+    ToAnswer = 'ToAnswer',
+    Answered = 'Answered',
+    Closed = 'Closed',
+    Reopened = 'Reopened',
+    Archived = 'Archived',
+}
+
+export enum TaskStatus {
+    None = 'None',
+    ToDo = 'ToDo',
+    InProgress = 'InProgress',
+    Blocked = 'Blocked',
+    Done = 'Done',
+}
+
+export interface ConsultRequest {
+    uuidPractice: string
+    tagSpecialtyRequired: string
+    idStripeInvoiceOrPaymentIntent: string
+    isoLocalityRequired?: string
+    isoLanguageRequired: string
+}
+export interface Consult {
+    uuid: string
+    uuidPracticeAdmin: string
+    uuidPractice: string
+    tagSpecialtyRequired: string
+    isoLanguageRequired: string
+    idPracticePayment: number
+    statusFee?: FeeStatus
+    isoLocalityRequired: string
+    statusMedical?: MedicalStatus
+    uuidAssignedDoctor: string
+    uuidCurrentAssigned: string
+    statusTask?: TaskStatus
+    hasTransmissions?: boolean
+    assignedAssistant?: ConsultAssignedAssistant[]
+    shortId?: string
+    createdAt?: string
+    expiresAt?: string
+}

package/src/models/diagnosis.ts

@@ -0,0 +1,141 @@
+export enum DiagnosisType {
+    Generic = 'Generic',
+    Private = 'Private',
+    Instance = 'Instance',
+}
+
+export interface DiagnosisRequest {
+    uuid?: string
+    name: string
+    description: string
+    type: DiagnosisType
+    parentUuid?: string
+    language: string
+    tags?: string[]
+    urlMultimedia?: string
+}
+
+export interface Diagnosis extends DiagnosisRequest {
+    uuid: string
+    uuidPractice: string
+    uuidPractitioner?: string
+    createdAt: string
+}
+
+export interface TreatmentRequest {
+    uuid?: string
+    uuidDiagnosis?: string
+    name: string
+    description: string
+    urlMultimedia?: string
+}
+
+export interface Treatment extends TreatmentRequest {
+    uuid: string
+    uuidDiagnosis: string
+    createdAt: string
+}
+
+export enum DrugType {
+    Generic = 'Generic',
+    Instance = 'Instance',
+}
+
+export interface DrugRequest {
+    name: string // name of the drug
+    description: string // Description of the drug
+    type: DrugType // Entry type
+    language: string // drug locale
+    sideEffects: string // Side effects of the drug
+    imageUrl?: string // Image URL to the drug
+    parentUuid?: string // (optional) parent uuid of the drug. In case of DrugType.Instance
+    uuid?: string // uuid of the drug (will be used as parentUuid in case of creation of new drug)
+}
+
+export interface Drug extends DrugRequest {
+    uuid: string
+    uuidPractice: string
+    uuidPractitioner?: string
+    createdAt: string
+}
+
+export interface PrescriptionRequest {
+    uuid?: string
+    uuidTreatment?: string
+    uuidDrug?: string
+    quantity: string
+    sig: string
+    renewal: string
+}
+
+export interface Prescription extends PrescriptionRequest {
+    uuid: string
+    uuidTreatment: string
+    createdAt: string
+}
+
+export enum PlanStatus {
+    Pending = 'Pending',
+    Accepted = 'Accepted',
+    Rejected = 'Rejected',
+}
+
+export interface TreatmentPlan {
+    uuid: string
+    uuidConsult: string
+    uuidDiagnosis: string
+    uuidTreatment?: string
+    status: PlanStatus
+}
+
+export interface DrugPrescription {
+    prescription: Prescription
+    drug: Drug
+}
+
+export interface TreatmentAndDrugPrescription {
+    treatment?: Treatment
+    prescriptionsAndDrugs?: DrugPrescription[]
+    status: PlanStatus
+    uuidTreatmentPlan: string
+}
+export interface TreatmentPlans {
+    uuidConsult: string
+    diagnosis: Diagnosis
+    plans?: TreatmentAndDrugPrescription[]
+}
+
+export interface DrugPrescriptionRequest {
+    prescription: PrescriptionRequest
+    drug: DrugRequest
+}
+
+export interface TreatmentAndDrugPrescriptionRequest {
+    trackingId: string
+    treatment: TreatmentRequest
+    prescriptionsAndDrugs?: DrugPrescriptionRequest[]
+}
+
+export interface TreatmentPlansRequest {
+    uuidConsult: string
+    diagnosis: DiagnosisRequest
+    plans?: TreatmentAndDrugPrescriptionRequest[]
+}
+
+export interface TreatmentAndDrugPrescriptionUpdateRequest {
+    treatment: Treatment
+    prescriptionsAndDrugs?: DrugPrescriptionRequest[]
+}
+
+export interface TreatmentPlanUpdateRequest extends TreatmentPlansRequest {
+    uuidConsult: string
+    diagnosis: DiagnosisRequest
+    plan: TreatmentAndDrugPrescriptionUpdateRequest
+}
+
+export interface TreatmentPlansResponseEntry {
+    trackingId?: string // can be undefined if treatmentPlan does not contain a treatment
+    treatmentPlan: TreatmentPlan
+}
+
+export interface TreatmentPlansResponse extends Array<TreatmentPlansResponseEntry> {}

package/src/models/error.ts

@@ -0,0 +1,13 @@
+export class IncompleteAuthentication extends Error { }
+export class MissingGrant extends Error { }
+export class MissingLockbox extends Error { }
+export class MissingLockboxOwner extends Error { }
+export class IndexBuildError extends Error { }
+export class AssociatedLockboxNotFound extends Error { }
+export class WorkflowAnswersMissingError extends Error { }
+export class AuthenticationFailed extends Error { }
+export class AuthenticationBadRequest extends Error { }
+export class AuthenticationServerError extends Error { }
+export class IdentityCreationFailed extends Error { }
+export class IdentityCreationBadRequest extends Error { }
+export class IdentityCreationConflict extends Error { }