oro-sdk 2.1.4-dev1.0

package/src/services/diagnosis.ts

@@ -0,0 +1,144 @@
+import {
+    Drug,
+    TreatmentPlan,
+    TreatmentPlans,
+    TreatmentPlansRequest,
+    TreatmentPlansResponse,
+    Uuid,
+} from '..'
+import { Diagnosis, Treatment, DiagnosisRequest, TreatmentRequest, TreatmentAndDrugPrescriptionUpdateRequest } from '../models/diagnosis'
+import { APIService } from './api'
+
+export class DiagnosisService {
+    constructor(private api: APIService, private baseURL: string) {}
+
+    public getDiagnoses(): Promise<Diagnosis[]> {
+        return this.api.get<Diagnosis[]>(`${this.baseURL}/v1/diagnoses`)
+    }
+
+    /**
+     * Get a diagnosis by uuid that belongs to your practice
+     * @param uuidDiagnosis the uuid of the diagnosis
+     * @returns a diagnosis
+     */
+    public getDiagnosisByUuid(uuidDiagnosis: Uuid): Promise<Diagnosis> {
+        return this.api.get<Diagnosis>(
+            `${this.baseURL}/v1/diagnoses/${uuidDiagnosis}`
+        )
+    }
+
+    public createDiagnosis(diagnosis: DiagnosisRequest): Promise<Diagnosis> {
+        return this.api.post<Diagnosis>(
+            `${this.baseURL}/v1/diagnoses`,
+            diagnosis
+        )
+    }
+
+    public updateDiagnosis(
+        uuid: string,
+        diagnosis: DiagnosisRequest
+    ): Promise<Diagnosis> {
+        return this.api.put<Diagnosis>(
+            `${this.baseURL}/v1/diagnoses/${uuid}`,
+            diagnosis
+        )
+    }
+
+    public getTreatmentsFromDiagnosisUuid(
+        diagnosisUuid: Uuid
+    ): Promise<Treatment[]> {
+        return this.api.get<Treatment[]>(
+            `${this.baseURL}/v1/diagnoses/${diagnosisUuid}/treatments`
+        )
+    }
+
+    /**
+     * This function returns treatment plans associated to a consult
+     * @param uuidConsult the consult uuid to fetch
+     * @returns an array of TreatmentPlan
+     */
+    public getTreatmentPlansFromConsultUuid(
+        uuidConsult: Uuid
+    ): Promise<TreatmentPlan[]> {
+        return this.api.get<TreatmentPlan[]>(
+            `${this.baseURL}/v1/treatment-plans/`,
+            { params: { uuidConsult } }
+        )
+    }
+
+    /**
+     * creates a new treatment for the diagnosis specified
+     * @param diagnosisUuid uuid of the diagnosis that is linked to the treatment
+     * @param treatmentRequest the treatment to be inserted
+     */
+    public createTreatment(diagnosisUuid: string, treatmentRequest: TreatmentRequest) {
+        return this.api.post<Treatment>(
+            `${this.baseURL}/v1/diagnoses/${diagnosisUuid}/treatments`,
+            treatmentRequest
+        )
+    }
+
+    /**
+     * This function returns populated treatment plans associated to a consult
+     * @param uuidConsult the consult uuid to fetch
+     * @returns a TreatmentPlans object
+     */
+    public getTreatmentPlansPopulatedFromConsultUuid(
+        uuidConsult: Uuid
+    ): Promise<TreatmentPlans> {
+        return this.api.get<TreatmentPlans>(
+            `${this.baseURL}/v1/treatment-plans/`,
+            { params: { uuidConsult, populated: true } }
+        )
+    }
+
+    public postPlans(
+        plans: TreatmentPlansRequest
+    ): Promise<TreatmentPlansResponse> {
+        return this.api.post<TreatmentPlansResponse>(
+            `${this.baseURL}/v1/treatment-plans`,
+            plans
+        )
+    }
+
+    public updateTreatmentPlan(
+        uuidPlan: string,
+        uuidConsult: string,
+        diagnosisRequest: DiagnosisRequest,
+        plan: TreatmentAndDrugPrescriptionUpdateRequest
+    ): Promise<TreatmentPlan> {
+        return this.api.put<TreatmentPlan>(
+            `${this.baseURL}/v1/treatment-plans/${uuidPlan}`,
+            {
+                uuidConsult,
+                diagnosis: diagnosisRequest,
+                plan
+            }
+        )
+    }
+
+    public acceptTreatmentPlan(
+        uuidPlan: string,
+        uuidConsult: string
+    ): Promise<TreatmentPlan> {
+        return this.api.put<TreatmentPlan>(
+            `${this.baseURL}/v1/treatment-plans/${uuidPlan}/accept`,
+            { uuidConsult }
+        )
+    }
+
+    /**
+     * retrieves all the drugs of the specified practice
+     * @param uuidPractice
+     */
+    public async getAllDrugs(
+        uuidPractice: string
+    ): Promise<Drug[] | undefined> {
+        const res = await this.api.get<{foundDrugs: Drug[]}>(
+            `${this.baseURL}/v1/drugs/practice/${uuidPractice}`,
+        )
+        if(res && res.foundDrugs)
+            return res.foundDrugs
+        return undefined
+    }
+}

package/src/services/external/clinia.ts

@@ -0,0 +1,133 @@
+import { AxiosService } from ".."
+
+export type FacetFilter = 'type:PHARMACY' | 'type:CLINIC'
+
+export interface CliniaResponse<T> {
+    facets: any
+    meta: {
+        query: string
+        page: number
+        numPages: number
+        perPage: number
+        total: number
+    }
+    records: T[]
+}
+
+export interface PlaceData {
+    id: string // The Clinia Id of the resource.
+    documentType: string // Type of document. This will always be set to health_facility.
+    type: string // The type of the resource. Possible Place types are detailed here.
+    name: string // The name of the resource.
+    address: AddressData // The address of the resource.
+    geoPoint: GeoPointData // The coordinates of the resource. Useful to locate resource on a map.
+    distance: number // The distance (in meters) the is from the location used to filter the query.
+    onlineBookingUrl: string // The url for the online booking system of the resource.
+    openingHours: Map<string, Array<IntervalData>> // The opening hours of the resource. This object has integers from 1 to 7 as keys, representing days of the week from Monday to Sunday as per ISO 8601.
+    phones: Array<PhoneData> // Phones associated with this resource.
+    socials: Array<SocialData> // The social links of the resource. Can be a website or a social media link.
+    note: string // Special notes on the resource.
+    services: Array<string> // The services offered by the resource.
+    owner: string // The owner of the resource in the Clinia ecosystem.
+}
+
+export interface AddressData {
+    streetAddress: string //	Street number plus route name.
+    suiteNumber: string //	Suite, door, appartment number.
+    postalCode: string //	Postal code.
+    neighborhood: string //	Neighborhood.
+    locality: string //	Locality.
+    place: string //	City.
+    region: string //	Name of the region.
+    regionCode: string //	ISO 3166-2 region code.
+    country: string //	Name of the country.
+    countryCode: string //	ISO 3166 country code
+}
+
+export interface PhoneData {
+    number: string //The phone number.
+    extension: string //The extension of the phone number.
+    countryCode: string //The country code associated with this phone number.
+    type:
+        | 'MAIN'
+        | 'ALTERNATE'
+        | 'RECEPTION'
+        | 'FAX'
+        | 'TEXT_TELEPHONE_TTY'
+        | 'INFO'
+        | 'OTHER' //The type of phone.
+    isTollFree: boolean //If the number is toll free or not.
+}
+
+export interface IntervalData {
+    start: string //	Start time of the time interval. Format is HH:mm.
+    end: string //	End time of the time interval. Format is HH:mm.
+}
+
+export interface GeoPointData {
+    lat: number //	Latitude
+    lng: number //	Longitude
+}
+
+export interface SocialData {
+    url: string //	Url representing the link.
+    type: string // Type of link.
+}
+
+export class CliniaService {
+    private api: AxiosService
+
+    constructor(private url: string, apiKey: string, private locale?: string) {
+        this.api = new AxiosService({ headers: { 'X-Clinia-API-Key': apiKey } })
+    }
+
+    public placeSearch(searchOptions: {
+        locale?: string
+        query?: string
+        facetFilters?: FacetFilter[]
+        location?: string
+        aroundLatLng?: string
+        page?: number
+    }) {
+        const { locale, ...data } = searchOptions
+
+        return this.api.post<CliniaResponse<PlaceData>>(
+            `${this.url}/search/v1/indexes/health_facility/query`,
+            data,
+            {
+                params: { locale: locale ?? this.locale },
+            }
+        )
+    }
+
+    public placeMatch(
+        searchOptions: {
+            locale?: string
+            name?: string
+            address?: string
+            postalCode?: string
+            place?: string
+            region?: string
+            country?: string
+        },
+        type?: string
+    ) {
+        const { locale, ...data } = searchOptions
+
+        let request = this.api.post<PlaceData[]>(
+            `${this.url}/search/v1/matches`,
+            data,
+            {
+                params: { locale: locale ?? this.locale },
+            }
+        )
+
+        if (type) {
+            request = request.then((places) =>
+                places.filter((place) => place.type === type)
+            )
+        }
+
+        return request
+    }
+}

package/src/services/external/index.ts

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

package/src/services/guard.ts

@@ -0,0 +1,228 @@
+import { APIService } from './api'
+import type { AxiosAuthRefreshRequestConfig } from 'axios-auth-refresh'
+import {
+    AuthTokenRequest,
+    AuthTokenResponse,
+    AuthRecoverRequest,
+    IdentityCreateRequest,
+    IdentityUpdateRequest,
+    IdentityResponse,
+    QRCodeRequest,
+    QRCodeResponse,
+    Uuid,
+    WhoAmIResponse,
+    Base64String,
+    AuthenticationFailed,
+    IdentityCreationFailed,
+    AuthenticationBadRequest,
+    AuthenticationServerError,
+    IdentityCreationBadRequest,
+    IdentityCreationConflict,
+    Tokens
+} from '../models'
+import { AxiosError } from 'axios'
+
+export interface GuardRequestConfig extends AxiosAuthRefreshRequestConfig {
+    useRefreshToken : boolean
+}
+export class GuardService {
+    private identityCache: Record<string, IdentityResponse>
+    private whoAmICache: Record<string, WhoAmIResponse>
+
+    constructor(private api: APIService, private baseURL: string) {
+        this.api.setAuthRefreshFn(this.authRefresh.bind(this))
+        this.identityCache = {}
+        this.whoAmICache = {}
+    }
+
+    /**
+     * Will replace access and refresh tokens with `tokens`
+     * 
+     * Note: 
+     * ```typescript
+     * setTokens({accessToken: undefined, refreshToken: 'aTokenValue'}) // will erase accessToken and set refreshToken with 'aTokenValue'
+     * setTokens({refreshToken: 'aTokenValue'}) // will keep actual value of accessToken and set refreshToken with 'aTokenValue'
+     * 
+     * ```
+     * @param tokens
+     */
+    public setTokens(tokens: Tokens) {
+        this.api.setTokens({...this.api.getTokens() , ...tokens })
+    }
+
+    /**
+     * Allow to retrieve an access token and a refresh token in order
+     * to do authenticated request afterward
+     *
+     * @param req The credentials required to get an access token
+     * @returns AuthTokenResponse
+     */
+    public async authToken(req: AuthTokenRequest): Promise<AuthTokenResponse> {
+        let resp : AuthTokenResponse
+
+        try {
+            let config: AxiosAuthRefreshRequestConfig = {
+                skipAuthRefresh: true
+            }
+
+            resp = await this.api.post<AuthTokenResponse>(`${this.baseURL}/v1/auth/token`, req, config)
+
+            this.api.setTokens({
+                accessToken: resp.accessToken,
+                refreshToken: resp.refreshToken
+            })
+        } catch(e) {
+            if((e as any).isAxiosError){
+                const code = (e as AxiosError).response?.status
+                switch (code) {
+                    case 400:
+                        throw new AuthenticationBadRequest()
+                    case 500:
+                        throw new AuthenticationServerError()
+                    case 401:
+                    default:
+                        throw new AuthenticationFailed()
+                }
+            }
+            throw new AuthenticationFailed()
+
+        }
+        return resp
+    }
+
+    /**
+     * Get new access and refresh token
+     *
+     * @returns AuthTokenResponse
+     */
+    public async authRefresh(refreshToken?: string): Promise<AuthTokenResponse> {
+        let config: GuardRequestConfig = {
+            skipAuthRefresh: true,
+            useRefreshToken: true
+        }
+        return this.api.put<AuthTokenResponse>(`${this.baseURL}/v1/auth/token`, null, config)
+    }
+
+
+    /**
+     * Call guard to overwrite existing refresh token cookie
+     *
+     * @returns void
+     */
+    public async authLogout(): Promise<void> {
+        return this.api.get<void>(`${this.baseURL}/v1/auth/logout`)
+    }
+
+
+    /**
+     * Call guard to attempt account recovery
+     *
+     * @param req The email address / practice of the account to recover
+     * @returns void
+     */
+    public async authRecover(req: AuthRecoverRequest): Promise<void> {
+        return this.api.post<void>(`${this.baseURL}/v1/auth/recover`, req)
+    }
+
+
+    /**
+     * Allow to create a new identity. The identity will then need to be confirmed
+     * via an email link
+     *
+     * @param req the information about the new identity to create
+     * @returns IdentityResponse
+     */
+    public async identityCreate(req: IdentityCreateRequest): Promise<IdentityResponse> {
+        let resp : IdentityResponse
+
+        try {
+            resp = await this.api.post<IdentityResponse>(`${this.baseURL}/v1/identities`, req)
+            this.api.setTokens({
+                refreshToken: resp.refreshToken
+            })
+        } catch (e) {
+            if((e as any).isAxiosError){
+                const code = (e as AxiosError).response?.status
+                switch (code) {
+                    case 400:
+                        throw new IdentityCreationBadRequest()
+                    case 409:
+                        throw new IdentityCreationConflict()
+                    case 500:
+                    default:
+                        throw new IdentityCreationFailed()
+                }
+            }
+            throw new IdentityCreationFailed()
+        }
+        return resp
+    }
+
+
+    /**
+     * Retrieve an identity. Will return public fields only when requested
+     * without authentication
+     *
+     * @param identityID Unique id of the identity to retrieve
+     * @returns IdentityResponse
+     */
+    public async identityGet(
+        identityID: Uuid
+    ): Promise<IdentityResponse> {
+        const tokens = this.api.getTokens()
+        const cacheKey = (tokens.accessToken ?? '') + (tokens.refreshToken ?? '') + identityID
+
+        if (!tokens.accessToken || !this.identityCache[cacheKey]) {
+            this.identityCache[cacheKey] = await this.api.get<IdentityResponse>(
+                `${this.baseURL}/v1/identities/${identityID}`
+            )
+        }
+        return this.identityCache[cacheKey]
+    }
+
+
+    /**
+     * Get information about the current authenticated user
+     *
+     * @param refreshCache if true it will refresh the whoAmI cache (default: false)
+     * @returns WhoAmIResponse
+     */
+    public async whoAmI(refreshCache: boolean = false): Promise<WhoAmIResponse> {
+        const cacheKey = this.api.getTokens().accessToken ?? ''
+        if (!this.whoAmICache[cacheKey] || refreshCache) {
+            this.whoAmICache[cacheKey] = await this.api.get<WhoAmIResponse>(`${this.baseURL}/v1/auth/whoami`)
+        }
+        return this.whoAmICache[cacheKey]
+    }
+
+    /**
+     * Update an existing identity
+     *
+     * @param identityID unique id of identity to update
+     * @param req update request
+     * @returns IdentityResponse
+     */
+    public async identityUpdate(
+        identityID: Uuid,
+        req: IdentityUpdateRequest
+    ): Promise<IdentityResponse> {
+        return this.api.put<IdentityResponse>(`${this.baseURL}/v1/identities/${identityID}`, req)
+    }
+
+    /**
+     * Return base64 data representing a QR code that the
+     * current identity need in order to use MFA
+     *
+     * @param identityID unique id of the identity
+     * @param password the identity password (already hashed and in base64)
+     * @returns QRCodeResponse
+     */
+    public async identityMFAQRCode(
+        identityID: Uuid,
+        password: Base64String
+    ): Promise<QRCodeResponse> {
+        const req: QRCodeRequest = { password }
+        return this.api.post<QRCodeResponse>(`${this.baseURL}/v1/identities/${identityID}/mfa`, req, { headers: { 'Accept': 'application/json' } })
+    }
+}
+

package/src/services/index.ts

@@ -0,0 +1,10 @@
+export * from './axios'
+export * from './api'
+export * from './consult'
+export * from './diagnosis'
+export * from './guard'
+export * from './practice'
+export * from './teller'
+export * from './vault'
+export * from './workflow'
+export * from './external'