oro-sdk 2.1.4-dev1.0 → 2.2.1

package/src/models/workflow.ts

@@ -1,142 +0,0 @@
-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/services/api.ts

@@ -1,77 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,265 +0,0 @@
-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 }
-        )
-    }
-}