oro-sdk 2.1.4-dev1

package/src/models/workflow.ts

@@ -0,0 +1,142 @@
+export interface IndexedData<T> {
+    [key: string]: T
+}
+
+export type SelectedAnswerData = string | string[]
+export type SelectedAnswersData = IndexedData<SelectedAnswerData>[]
+
+export interface ChoiceInputData {
+    text: string
+    className?: string
+    order?: number
+}
+
+export interface RadioInputIconOptionsData {
+    variant: 'icon'
+    icon: string
+}
+
+export interface RadioInputData extends ChoiceInputData {
+    options?: RadioInputIconOptionsData
+}
+
+export interface RadioCardInputData extends RadioInputData {
+    bodyText: string
+}
+export interface EntryData {
+    id?: number
+    label?: string
+    summaryLabel?: string
+    summaryHidden?: boolean
+    className?: string
+    triggers?: string[]
+}
+
+export enum MetadataCategory { //these are generic metadata categories
+    ChildPersonal = 'ChildPersonal',
+    Consultation = 'Consultation',
+    DataRetrieval = 'DataRetrieval',
+    Followup = 'Followup',
+    Recovery = 'Recovery',
+    Medical = 'Medical',
+    OtherPersonal = 'OtherPersonal',
+    Personal = 'Personal',
+    Preference = 'Preference',
+    Prescription = 'Prescription',
+    Raw = 'Raw',
+}
+
+export interface GenericQuestionData<T, A = IndexedData<ChoiceInputData>>
+    extends EntryData {
+    kind: T
+    metaCategory: MetadataCategory
+    answers?: A
+    formValidation?: any[] // use yup-ast expressions
+    placeholder?: string
+    defaultValue?: any
+    value?: string
+}
+
+export interface GroupedGenericQuestionData<
+    T,
+    A = IndexedData<ChoiceInputData>
+> extends GenericQuestionData<T, A> {
+    inline?: boolean
+    inlineLabel?: boolean
+    order?: number
+}
+
+export type QuestionData =
+    | GenericQuestionData<'title' | 'paragraph' | 'checkbox', void>
+    | GenericQuestionData<
+          | 'text'
+          | 'date'
+          | 'number'
+          | 'images'
+          | 'images-alias'
+          | 'body-parts'
+          | 'pharmacy-picker'
+          | 'place-address'
+      >
+    | GenericQuestionData<
+          'checkbox-group' | 'select' | 'multiple',
+          IndexedData<ChoiceInputData>
+      >
+    | GroupedGenericQuestionData<'radio', IndexedData<RadioInputData>>
+    | GroupedGenericQuestionData<'radio-card', IndexedData<RadioCardInputData>>
+
+export interface FieldData {
+    type: 'field'
+    className?: string
+    id: string
+}
+
+export interface FieldGroupData {
+    type: 'field-group'
+    className?: string
+    fieldsAndGroups: (FieldData | FieldGroupData)[]
+    name?: string
+    inline?: boolean
+    fullWidth?: boolean
+}
+
+export interface WorkflowPageData {
+    className?: string
+    groups?: FieldGroupData[]
+    highlightMsg?: string
+    questions: IndexedData<QuestionData>
+    title?: string
+    triggers?: string[]
+}
+
+export interface WorkflowData {
+    createdAt: string
+    culDeSacs: EntryData[]
+    id: string
+    locale?: string
+    pages: WorkflowPageData[]
+    summaryImageFieldName?: string // this field is used to show the consult summary image
+    summarySymptomsFieldName?: string // this field is used to show the consult summary symptoms
+    selectedAnswers?: SelectedAnswersData
+}
+
+/**
+ * This interface describes a workflow prepared and ready to be sent to vault
+ */
+export interface WorkflowUploadedImage {
+    idbId?: string
+    name: string
+    imageData?: string
+}
+export interface PopulatedWorkflowField {
+    answer: SelectedAnswerData | WorkflowUploadedImage[] // Actual answer from the workflow
+    displayedAnswer?: any // This answer is to be used only when it's impossible to get data from workflow
+    kind: string // If we don't store question. We will need that field to at least know the field type
+}
+
+export interface PopulatedWorkflowData {
+    workflowId: string // The workflow id to refer
+    workflowCreatedAt: string // The workflow version
+    locale?: string
+    fields: Record<string, PopulatedWorkflowField> // key corresponds to the QuestionData key in the workflow
+}

package/src/sdk-revision/client.ts

@@ -0,0 +1,62 @@
+import { IndexKey, OroClient, Uuid, VaultIndex } from "..";
+import { Grant, MetadataCategory, IndexConsultLockbox } from "../models";
+
+/**
+ * @name filterGrantsWithLockboxMetadata
+ * @description searches for the applied filters in the vault index
+ * @param oroClient
+ * @param filter: the metadata filter applied to each the lockboxes
+ * @param vaultIndex: the index to which the filter will be applied 
+ * @param forceRefresh
+ * @returns the filtered grants
+ */
+export async function filterGrantsWithLockboxMetadata(oroClient: OroClient, filter?: { consultationId: Uuid}, vaultIndex?: VaultIndex, forceRefresh = false): Promise<Grant[]> {
+    if (!vaultIndex || forceRefresh) {
+        vaultIndex = await buildLegacyVaultIndex(oroClient)
+    }
+    if (vaultIndex[IndexKey.Consultation] && filter) {
+        let indexConsults = (vaultIndex[IndexKey.Consultation]??[])
+            .filter((consultGrant: {consultationId: Uuid}) => consultGrant.consultationId === filter.consultationId)
+            .map((consultGrant: {consultationId: Uuid, grant: Grant}) => consultGrant.grant as Grant)
+        return indexConsults as Grant[]
+    } else {
+        // No grants exist and the index has already been built
+        return []
+    }
+}
+
+/** Finds all grants for the logged user
+ *  requests a list of unique consultation ids for each lockbox the user has access to
+ *  builds and sets the index of consultations
+ * @param oroClient
+ * @returns the constructed vaultIndex
+ */
+export async function buildLegacyVaultIndex(oroClient: OroClient): Promise<VaultIndex> {
+    let grants = await oroClient.getGrants()
+    let consultGrants: IndexConsultLockbox[] = []
+    for (let grant of grants) {
+        let consults = (await oroClient.vaultClient
+        .lockboxMetadataGet(
+            grant.lockboxUuid!,
+            ['consultationId'],
+            [],
+            { category: MetadataCategory.Consultation },
+        ))[0] as Uuid[]
+
+        consultGrants = [...consultGrants, ...consults.map((consult: any) => ({
+                ...consult,
+                grant: {
+                    lockboxOwnerUuid:
+                        grant.lockboxOwnerUuid,
+                    lockboxUuid: grant.lockboxUuid,
+                },
+            }))]
+    }
+
+    let vaultIndex = {
+        [IndexKey.Consultation]: consultGrants
+    }
+    oroClient.setVaultIndex(vaultIndex)
+    console.info('[sdk:index] Successfully Built Vault Index')
+    return vaultIndex
+}

package/src/sdk-revision/index.ts

@@ -0,0 +1 @@
+export * from './client'

package/src/services/api.ts

@@ -0,0 +1,77 @@
+import type { AxiosRequestConfig } from 'axios'
+import createAuthRefreshInterceptor from 'axios-auth-refresh'
+import { AuthRefreshFunc, Tokens } from '../models'
+import { AxiosService } from './axios'
+import { GuardRequestConfig } from './guard'
+
+
+export class APIService extends AxiosService {
+    private authRefreshFn?: AuthRefreshFunc
+
+    constructor(
+        config?: AxiosRequestConfig,
+        private tokenRefreshFailureCallback?: (err: Error) => void
+    ) {
+        super(config)
+        const self = this
+
+        this.axios.interceptors.request.use(
+            config => {
+                const token = (config as GuardRequestConfig).useRefreshToken
+                    ? self.getTokens().refreshToken
+                    : self.getTokens().accessToken
+
+                config.headers = {
+                    ...config.headers,
+                    Authorization: `Bearer ${token}`,
+                }
+                return config;
+            },
+            error => {
+                Promise.reject(error)
+            }
+        );
+
+        createAuthRefreshInterceptor(this.axios, async function (failedRequest) {
+            if (self.authRefreshFn) {
+                try {
+                    let tokenResp = await self.authRefreshFn(self.getTokens().refreshToken)
+                    self.setTokens({
+                        accessToken: tokenResp.accessToken,
+                        refreshToken: tokenResp.refreshToken
+                    })
+                    failedRequest.response.config.headers['Authorization'] = `Bearer ${self.getTokens().accessToken}`
+                    return Promise.resolve()
+                    
+                } catch (e) {
+                    console.error('an error occured while refreshing tokens (notifying callback)', e)
+                    if (self.tokenRefreshFailureCallback)
+                    self.tokenRefreshFailureCallback(failedRequest)
+                    return Promise.resolve() // We keep it like that. Otherwise, it seems to break the api service will it is not needed
+                    // return Promise.reject(e) 
+                }
+            }
+            console.error('The request could not refresh the token (authRefreshFn was not set)', failedRequest)
+            return Promise.resolve() // We keep it like that. Otherwise, it seems to break the api service will it is not needed
+            // return Promise.reject(failedRequest)
+
+        }, { statusCodes: [401, 403] })
+    }
+
+    public setAuthRefreshFn(fn: AuthRefreshFunc) {
+        this.authRefreshFn = fn
+    }
+
+    public setTokens(tokens: Tokens) {
+        localStorage.setItem('tokens', JSON.stringify(tokens))
+    }
+
+    public getTokens(): Tokens {
+        let tokens : Tokens = {}
+        const item = localStorage.getItem('tokens')
+        if (item) {
+            tokens = JSON.parse(item)
+        }
+        return tokens
+    }
+}

package/src/services/axios.ts

@@ -0,0 +1,91 @@
+import type { AxiosRequestConfig } from 'axios'
+import axios, { AxiosInstance } from 'axios'
+
+
+export class AxiosService {
+    protected axios: AxiosInstance
+
+    constructor(
+        config?: AxiosRequestConfig
+    ) {
+        if (!config) config = {}
+
+        this.axios = axios.create(config)
+    }
+
+    protected async apiRequest(config: AxiosRequestConfig, url: string, data?: any) {
+        if (!config.headers) config.headers = {}
+
+        config.headers['Content-Type'] = 'application/json'
+
+        return this.axios({
+            ...config,
+            url,
+            data: data,
+        }).then((res) => {
+            return res.data
+        })
+    }
+
+    protected async apiRequestHeader(config: AxiosRequestConfig, url: string, headerToRetrieve?: string, data?: any,) {
+        if (!config.headers) config.headers = {}
+
+        config.headers['Content-Type'] = 'application/json'
+
+        return this.axios({
+            ...config,
+            url,
+            data: data,
+        }).then((res) => {
+            if (headerToRetrieve) {
+                return res.headers[headerToRetrieve] ?? res.headers[headerToRetrieve.toLowerCase()]
+            }
+
+            return res.headers
+        })
+    }
+
+    public get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T> {
+        return this.apiRequest({ ...config, method: 'get' }, url)
+    }
+
+    public deleteRequest<T = any>(
+        url: string,
+        config?: AxiosRequestConfig
+    ): Promise<T> {
+        return this.apiRequest({ ...config, method: 'delete' }, url)
+    }
+
+    public post<T = any>(
+        url: string,
+        data?: any,
+        config?: AxiosRequestConfig
+    ): Promise<T> {
+        return this.apiRequest({ ...config, method: 'post' }, url, data)
+    }
+
+    public put<T = any>(
+        url: string,
+        data: any,
+        config?: AxiosRequestConfig
+    ): Promise<T> {
+        return this.apiRequest({ ...config, method: 'put' }, url, data)
+    }
+
+    public patch<T = any>(
+        url: string,
+        data: any,
+        config?: AxiosRequestConfig
+    ): Promise<T> {
+        return this.apiRequest({ ...config, method: 'patch' }, url, data)
+    }
+
+    public head<T = any>(
+        url: string,
+        config?: AxiosRequestConfig,
+        headerToRetrieve?: string,
+        data?: any
+    ): Promise<T> {
+        return this.apiRequestHeader({ ...config, method: 'head' }, url, headerToRetrieve, data)
+    }
+}

package/src/services/consult.ts

@@ -0,0 +1,265 @@
+import { APIService } from './api'
+import {
+    Uuid,
+    Consult,
+    ConsultRequest,
+    MedicalStatus,
+    ConsultTransmission,
+    TransmissionKind,
+    TransmissionStatus,
+} from '../models'
+// import FormData from "form-data"
+
+export class ConsultService {
+    constructor(private api: APIService, private baseURL: string) {}
+
+    public consultCreate(c: ConsultRequest): Promise<Consult> {
+        return this.api.post<Consult>(`${this.baseURL}/v1/consults`, c)
+    }
+
+    /**
+     * This function returns the number of consults using parameters
+     * @param uuidPractice the practice uuid
+     * @param uuidRequester the requester uuid
+     * @param statusesMedical an array containing MedicalStatus to include
+     * @param statusesExclude an array containing MedicalStatus to exclude
+     * @param shortId a shortId matcher (will match all consult with a shortId starting with this `shortId`)
+     * @param columnToSortTo the list of columns separated by commas, to sort to (in order of sorting)
+     * @param orderToSortTo the type of sorting to do ('asc' for ascending or 'desc' for descending)
+     * @param perPage the number of item to retrieve per "page"
+     * @param indexPage the actual index of the page to retrieve (0 based: 0 is the first items)
+     * @param filterAssignedDoctor the uuid of the doctor for which to filter with
+     * @param filterCurrentPractitioner the uuid of the current assistant assigned to filter with
+     * @param filterIsoLocality the of isoLocality to filter with
+     * @returns a number of consult
+     */
+    public countConsults(
+        uuidPractice?: Uuid,
+        uuidRequester?: Uuid,
+        statusesMedical?: MedicalStatus[],
+        statusesExclude?: MedicalStatus[],
+        shortId?: string,
+        columnToSortTo?: string[],
+        orderToSortTo?: string[],
+        perPage?: number,
+        indexPage?: number,
+        filterAssignedDoctor?: string,
+        filterCurrentPractitioner?: string,
+        filterIsoLocality?: string[]
+    ): Promise<number> {
+        return this.api
+            .head<any>(
+                `${this.baseURL}/v1/consults`,
+                {
+                    params: {
+                        uuidPractice,
+                        uuidRequester,
+                        statusesMedical,
+                        statusesExclude,
+                        shortId,
+                        perPage,
+                        page: indexPage,
+                        sortColumns: columnToSortTo,
+                        orderColumns: orderToSortTo,
+                        filterAssignedDoctor,
+                        filterCurrentPractitioner,
+                        filterIsoLocality,
+                    },
+                },
+                'Content-Range'
+            )
+            .then((resContentRange) => {
+                if (
+                    !resContentRange ||
+                    (typeof resContentRange !== 'string' &&
+                        typeof resContentRange !== 'number')
+                ) {
+                    return 0
+                }
+
+                if (typeof resContentRange === 'number') {
+                    return resContentRange
+                }
+
+                return parseInt(resContentRange)
+            })
+    }
+
+    /**
+     * This function get consults using parameters
+     * @param uuidPractice the practice uuid
+     * @param uuidRequester the requester uuid
+     * @param statusesMedical an array containing MedicalStatus to include
+     * @param statusesExclude an array containing MedicalStatus to exclude
+     * @param shortId a shortId matcher (will match all consult with a shortId starting with this `shortId`)
+     * @param columnToSortTo the list of columns separated by commas, to sort to (in order of sorting)
+     * @param orderToSortTo the type of sorting to do ('asc' for ascending or 'desc' for descending)
+     * @param perPage the number of item to retrieve per "page"
+     * @param indexPage the actual index of the page to retrieve (0 based: 0 is the first items)
+     * @param filterAssignedDoctor the uuid of the doctor for which to filter with
+     * @param filterCurrentPractitioner the uuid of the current assistant assigned to filter with
+     * @param filterIsoLocality the of isoLocality to filter with
+     * @returns a list of consult
+     */
+    public getConsults(
+        uuidPractice?: Uuid,
+        uuidRequester?: Uuid,
+        statusesMedical?: MedicalStatus[],
+        statusesExclude?: MedicalStatus[],
+        shortId?: string,
+        columnToSortTo?: string[],
+        orderToSortTo?: string[],
+        perPage?: number,
+        indexPage?: number,
+        filterAssignedDoctor?: string,
+        filterCurrentPractitioner?: string,
+        filterIsoLocality?: string[]
+    ): Promise<Consult[]> {
+        return this.api.get<Consult[]>(`${this.baseURL}/v1/consults`, {
+            params: {
+                uuidPractice,
+                uuidRequester,
+                statusesMedical,
+                statusesExclude,
+                shortId,
+                perPage,
+                page: indexPage,
+                sortColumns: columnToSortTo,
+                orderColumns: orderToSortTo,
+                filterAssignedDoctor,
+                filterCurrentPractitioner,
+                filterIsoLocality,
+            },
+        })
+    }
+
+    public getConsultByUUID(
+        uuidConsult: Uuid,
+        uuidPractice?: Uuid
+    ): Promise<Consult> {
+        return this.api.get<Consult>(
+            `${this.baseURL}/v1/consults/${uuidConsult}`,
+            { params: { uuidPractice } }
+        )
+    }
+
+    public updateConsultByUUID(
+        uuidConsult: Uuid,
+        consult: {
+            statusMedical?: MedicalStatus
+            uuidAssignedDoctor?: Uuid
+            neverExpires?: boolean
+        },
+        uuidPractice?: Uuid,
+        uuidRequester?: Uuid
+    ): Promise<Consult> {
+        return this.api.put<Consult>(
+            `${this.baseURL}/v1/consults/${uuidConsult}`,
+            consult,
+            {
+                params: {
+                    uuidPractice,
+                    uuidRequester,
+                },
+            }
+        )
+    }
+
+    public getConsultFaxStatuses(
+        uuidConsult: string
+    ): Promise<ConsultTransmission[]> {
+        return this.api.get<ConsultTransmission[]>(
+            `${this.baseURL}/v1/consults/${uuidConsult}/transmissions`,
+            {
+                params: {
+                    kind: TransmissionKind.Fax,
+                },
+            }
+        )
+    }
+
+    public postConsultTransmission(
+        uuidConsult: string,
+        nameDriver: string = 'Documo',
+        addressOrPhoneToSendTo?: string,
+        file?: File,
+        nameReceiver?: string,
+        txtTransmissionTitle?: string,
+        txtTransmissionNotes?: string
+        // numTry ?: number,
+        // delay ?: number,
+    ): Promise<ConsultTransmission> {
+        let data = new FormData()
+
+        data.append('nameDriverReceiver', nameDriver)
+        if (addressOrPhoneToSendTo) {
+            data.append('addressReceiver', addressOrPhoneToSendTo)
+        }
+        if (file) {
+            data.append('file', file)
+        }
+        if (nameReceiver) {
+            data.append('nameReceiver', nameReceiver)
+        }
+        if (txtTransmissionTitle) {
+            data.append('txtTransmissionTitle', txtTransmissionTitle)
+        }
+        if (txtTransmissionNotes) {
+            data.append('txtTransmissionNotes', txtTransmissionNotes)
+        }
+
+        return this.api.post<ConsultTransmission>(
+            `${this.baseURL}/v1/consults/${uuidConsult}/transmissions`,
+            data,
+            {
+                headers: { 'Content-Type': 'multipart/form-data;' },
+            }
+        )
+    }
+
+    public postConsultFax(
+        uuidConsult: string,
+        addressReceiver: string,
+        file: File
+    ): Promise<ConsultTransmission> {
+        return this.postConsultTransmission(
+            uuidConsult,
+            'Documo',
+            addressReceiver,
+            file
+        )
+    }
+
+    public postConsultEmail(
+        uuidConsult: string,
+        file: File
+    ): Promise<ConsultTransmission> {
+        return this.postConsultTransmission(
+            uuidConsult,
+            'Pharmacierge',
+            undefined,
+            file
+        )
+    }
+
+    public retryConsultFax(
+        uuidConsult: string,
+        transmissionId: string
+    ): Promise<ConsultTransmission> {
+        return this.api.put<ConsultTransmission>(
+            `${this.baseURL}/v1/consults/${uuidConsult}/transmissions/${transmissionId}`,
+            { status: TransmissionStatus.Retrying }
+        )
+    }
+
+    public updateConsultTransmissionStatus(
+        transmissionId: string,
+        uuidConsult: string,
+        newStatus: TransmissionStatus
+    ): Promise<ConsultTransmission> {
+        return this.api.put<ConsultTransmission>(
+            `${this.baseURL}/v1/consults/${uuidConsult}/transmissions/${transmissionId}`,
+            { status: newStatus }
+        )
+    }
+}