pha-hermes 1.15.0 → 1.16.0

package/src/api/liphe_legacy/contract_request/contractRequestClient.ts

@@ -0,0 +1,128 @@
+import { AxiosInstance } from 'axios'
+import { Workorder } from '../../../models'
+
+export interface LipheContractRequest {
+    id: number
+    name: string
+    po_number: string | null
+    level: string
+    deadline: string
+    from: string
+    by: string
+    by_value: string
+    date: Date
+    email_request: string
+    type_of_request: string
+    status: string
+    is_deleted: number
+    created_at: Date
+    updated_at: Date
+    created_by: string
+    updated_by: string
+    community_id: number
+    agency_id: number
+    contract_id: number
+    job_id: number
+    start_date: Date
+    end_date: Date
+    department_id: number | null
+    job: LipheJob
+    community: LipheCommunity
+}
+
+interface LipheJob {
+    id: number
+    code_nethris: number
+    translations: LipheJobTranslation[]
+}
+
+interface LipheJobTranslation {
+    id: number
+    translatable_type: string
+    translatable_id: number
+    column: string
+    content: string
+    locale: string
+    created_at: Date
+    updated_at: Date
+}
+
+interface LipheCommunity {
+    id: number
+    name: string
+    region: LipheRegion
+    contact: LipheContact
+}
+
+interface LipheRegion {
+    id: number
+    translations: LipheRegionTranslation[]
+}
+
+interface LipheRegionTranslation {
+    id: number
+    translatable_type: string
+    translatable_id: number
+    column: string
+    content: string
+    locale: string
+    created_at: Date
+    updated_at: Date
+}
+
+interface LipheContact {
+    id: number
+    address: string
+    address_city: string
+    address_zip: string
+    address_country: string
+    address_state: string
+    phone: string
+}
+
+export class ContractRequestClient {
+    private axiosInstance: AxiosInstance
+
+    constructor(axiosInstance: AxiosInstance) {
+        this.axiosInstance = axiosInstance
+    }
+
+    async fetchAllContractRequests(
+        agencyId: number,
+        from?: Date,
+        to?: Date,
+        page: number = 1,
+        page_size: number = 10
+    ): Promise<Workorder[]> {
+        const url = `v2/contract-request/agency/${agencyId}`
+        const params = new URLSearchParams()
+
+        if (from) {
+            params.append('from', from.toISOString().split('T')[0] + ' 00:00:00')
+        }
+        if (to) {
+            params.append('to', to.toISOString().split('T')[0] + ' 23:59:59')
+        }
+        params.append('page', page.toString())
+        params.append('page_size', page_size.toString())
+
+        const response = await this.axiosInstance.get<LipheContractRequest[]>(url, { params })
+
+        const workorders: Workorder[] = []
+
+        for (const request of response.data) {
+            workorders.push({
+                id: request.id.toString(),
+                name: request.name,
+                region: request.community.region.translations[0].content,
+                establishmentName: request.community.name,
+                establishmentId: request.community.id.toString(),
+                role: request.job.translations.map(t => t.content).join(' / '),
+                startDate: request.start_date,
+                endDate: request.end_date
+            })
+        }
+
+        return workorders
+    }
+}

package/src/api/liphe_legacy/contract_request_period/contractRequestPeriodClient.ts

@@ -0,0 +1,233 @@
+import { AxiosInstance } from 'axios'
+import { Agency, Period, Workorder } from '../../../models'
+import { LipheContractRequest } from '../contract_request/contractRequestClient'
+import { LipheAssignment } from '../assignment/assignmentClient'
+interface LipheContractRequestPeriods {
+    message: string
+    status: boolean
+    data: LipheContractRequestPeriodData[]
+    meta: {
+        current_page: number
+        from: number
+        last_page: number
+        path: string
+        per_page: number
+        to: number
+        total: number
+    }
+}
+
+interface LipheContractRequestPeriod {
+    message: string
+    status: boolean
+    data: LipheContractRequestPeriodData
+    meta: {
+        current_page: number
+        from: number
+        last_page: number
+        path: string
+        per_page: number
+        to: number
+        total: number
+    }
+}
+
+interface LipheContractRequestPeriodData {
+    id: number
+    contract_request_id: number
+    start_date: Date
+    end_date: Date
+    shift: 'morning' | 'afternoon' | 'evening' | 'night'
+    start_time: Date
+    end_time: Date
+    departement_id: number
+    note: string
+    assignment_id: number
+    assignment_parent_id: number | null
+    created_at: Date
+    updated_at: Date
+    contract_request: LipheContractRequest
+    department: string | null
+    assignment: LipheAssignment
+    assigned_employee_details: UserDetails
+    assignment_employee: any
+}
+
+interface UserDetails {
+    id: number
+    name: string
+    email: string | null
+}
+
+export class ContractRequestPeriodClient {
+    private axiosInstance: AxiosInstance
+
+    constructor(axiosInstance: AxiosInstance) {
+        this.axiosInstance = axiosInstance
+    }
+
+    async fetchAllContractRequestPeriods(
+        agencyId: Agency,
+        from?: Date,
+        to?: Date,
+        page: number = 1,
+        activeAssignationsOnly: boolean = true,
+        assignedPractitionerId?: string
+    ): Promise<Workorder[]> {
+        const url = `v2/contract-request-periods/agency/${agencyId}`
+        const params = new URLSearchParams()
+        const periods: Workorder[] = []
+        let nextPage = true
+
+        if (from) {
+            params.append('from', from.toISOString().split('T')[0] + ' 00:00:00')
+        }
+        if (to) {
+            params.append('to', to.toISOString().split('T')[0] + ' 23:59:59')
+        }
+        if (page) {
+            params.append('page', page.toString())
+        }
+        if (activeAssignationsOnly) {
+            params.append('active_assignations_only', activeAssignationsOnly ? '1' : '0')
+        }
+
+        if (assignedPractitionerId) {
+            params.append('assigned_employee_id', assignedPractitionerId)
+        }
+
+        while (nextPage) {
+            params.set('page', page.toString())
+
+            const response = await this.axiosInstance.get<LipheContractRequestPeriods>(url, {
+                params
+            })
+
+            for (const period of response.data.data) {
+                periods.push({
+                    id: period.id.toString(),
+                    name: period.id.toString(),
+                    establishmentId: period.contract_request.community.id.toString(),
+                    region: period.contract_request.community.contact.address_state,
+                    establishmentName: period.contract_request.community.name,
+                    role: this.getRole(period),
+                    practitionerId: period.assignment.selected_client.id,
+                    startDate: new Date(period.start_date),
+                    endDate: new Date(period.end_date),
+                    createdAt: new Date(period.created_at),
+                    updatedAt: new Date(period.updated_at)
+                })
+            }
+
+            nextPage = page < response.data.meta.last_page
+            page++
+        }
+
+        return periods
+    }
+
+    async fetchContractRequestPeriod(workorderId: string) {
+        const url = `v2/contract-request-periods/${workorderId}`
+        const params = new URLSearchParams()
+        const response = await this.axiosInstance.get<LipheContractRequestPeriod>(url, { params })
+
+        return response.data.data
+    }
+
+    async getPayPeriodDatesForPayPeriodId(payPeriodId: string): Promise<Period[]> {
+        const period = await this.fetchContractRequestPeriod(payPeriodId)
+        const payPeriods: {
+            payPeriodId: string
+            startDate: string
+            endDate: string
+            workorderId: string
+        }[] = []
+
+        const firstPayPeriodDate = this.getPayPeriodDayBeforeStartDate(
+            new Date(period.assignment.selected_client.agency.date_first_periode_paie),
+            new Date(period.start_date)
+        )
+
+        const lastPayPeriodDate = this.getLastDayOfPayPeriod(
+            new Date(firstPayPeriodDate),
+            new Date(period.end_date)
+        )
+
+        // Calculate the number of weeks between lastPayPeriodDate and firstPayPeriodDate
+        const weeksBetween = this.calculateWeeksBetween(firstPayPeriodDate, lastPayPeriodDate)
+
+        for (let i = 0; i < weeksBetween; i++) {
+            const tempDate = new Date(firstPayPeriodDate)
+
+            const startDate = new Date(tempDate.setDate(tempDate.getDate() + 7 * i))
+            const endDate = new Date(tempDate.setDate(tempDate.getDate() + 6))
+
+            payPeriods.push({
+                payPeriodId: '',
+                startDate: startDate.toISOString().split('T')[0],
+                endDate: endDate.toISOString().split('T')[0],
+                workorderId: payPeriodId
+            })
+        }
+
+        return payPeriods as unknown as Period[]
+    }
+
+    private getRole(period: LipheContractRequestPeriodData) {
+        if (period.contract_request.job.translations.length === 0) {
+            return ''
+        }
+
+        if (period.contract_request.job.translations.length > 1) {
+            const roleTranslation = period.contract_request.job.translations.find(
+                (translation: any) => translation.locale === 'en'
+            )
+            return roleTranslation?.content
+        } else {
+            return period.contract_request.job.translations[0].content
+        }
+    }
+
+    /**
+     * Calculates the pay period day of week that comes before the start date
+     * @param firstPayPeriodDate The first pay period date from the agency
+     * @param startDate The start date to find the pay period before
+     * @returns The day of week (0-6, where 0 is Sunday) of the pay period before start_date
+     */
+    private getPayPeriodDayBeforeStartDate(firstPayPeriodDate: Date, startDate: Date): Date {
+        const payPeriodDayOfWeek = firstPayPeriodDate.getDay()
+
+        // Calculate the most recent pay period date that falls before start_date
+        const tempDate = new Date(startDate)
+
+        // Go back one week at a time until we find a date that matches the pay period day of week
+        while (tempDate.getDay() !== payPeriodDayOfWeek) {
+            tempDate.setDate(tempDate.getDate() - 1)
+        }
+
+        // If the calculated date is not before start_date, go back another week
+        if (tempDate >= startDate) {
+            tempDate.setDate(tempDate.getDate() - 7)
+        }
+
+        return tempDate
+    }
+
+    private getLastDayOfPayPeriod(firstPayPeriodDate: Date, endDate: Date): Date {
+        const tempDate = new Date(firstPayPeriodDate)
+
+        // Go back one week at a time until we find a date that matches the pay period day of week
+        while (endDate > tempDate) {
+            tempDate.setDate(tempDate.getDate() + 7)
+        }
+
+        return tempDate
+    }
+
+    private calculateWeeksBetween(startDate: Date, endDate: Date): number {
+        const diffTime = Math.abs(endDate.getTime() - startDate.getTime())
+        const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24))
+        const weeks = Math.floor(diffDays / 7)
+        return weeks
+    }
+}

package/src/api/{lipheApiClient.ts → liphe_legacy/lipheApiClient.ts}

@@ -1,14 +1,22 @@
 import axios, { AxiosInstance } from 'axios'
-import { LipheAuthenticator } from './liphe1.0/auth/authClient'
-import { LiphePractitionerClient } from './liphe1.0/practitioner/practitionerClient'
+import { LipheAuthenticator } from './auth/authClient'
+import { LiphePractitionerClient } from './practitioner/practitionerClient'
+import { ContractRequestPeriodClient } from './contract_request_period/contractRequestPeriodClient'
+import axiosRetry from 'axios-retry'
 
 export class LipheApiClient {
     private instance: LipheApiClient | undefined = undefined
     private axiosInstance: AxiosInstance = axios.create()
     private authenticator: LipheAuthenticator
     public practitionerClient: LiphePractitionerClient
+    public contractRequestPeriodClient: ContractRequestPeriodClient
 
-    constructor(baseUrl: string, email: string, password: string, type: string = 'user') {
+    constructor(
+        baseUrl: string,
+        email: string,
+        password: string,
+        type: 'user' | 'client' = 'user'
+    ) {
         this.axiosInstance.defaults.baseURL = baseUrl
 
         this.authenticator = new LipheAuthenticator(
@@ -18,7 +26,19 @@ export class LipheApiClient {
             password,
             type
         )
+
+        axiosRetry(this.axiosInstance, {
+            retries: 10,
+            retryDelay: retryCount => {
+                return Math.min(1000 * Math.pow(2, retryCount - 1), 30000)
+            },
+            onRetry: (retryCount, error) => {
+                console.log(`Retry attempt ${retryCount} failed: ${error.message}`)
+            }
+        })
+
         this.practitionerClient = new LiphePractitionerClient(this.axiosInstance)
+        this.contractRequestPeriodClient = new ContractRequestPeriodClient(this.axiosInstance)
     }
     async init() {
         await this.authenticator.initializeAuth()

package/src/api/{liphe1.0 → liphe_legacy}/practitioner/practitionerClient.ts

@@ -1,6 +1,7 @@
 import type { AxiosInstance } from 'axios'
+import { Practitioner } from '../../../models'
 
-export interface LiphePractitioner {
+interface LiphePractitioner {
     id: number
     firstname: string
     lastname: string
@@ -14,13 +15,13 @@ export class LiphePractitionerClient {
     constructor(axiosInstance: AxiosInstance) {
         this.axios = axiosInstance
     }
-    async fetchAllPractitioners(agencyId: number = 1): Promise<LiphePractitioner[]> {
+    async fetchAllPractitioners(agencyId: number = 1): Promise<Practitioner[]> {
         let practitioners: LiphePractitioner[] = []
         let page = 1
         let nextPage = true
 
         while (nextPage) {
-            const response = await this.axios.get('/v2/employees', {
+            const response = await this.axios.get('v2/employees', {
                 params: {
                     agency_id: agencyId,
                     page
@@ -30,6 +31,7 @@ export class LiphePractitionerClient {
             if (!data?.data || !Array.isArray(data.data)) {
                 throw new Error('Unexpected responses.')
             }
+
             const pagePractitioners = data.data.map(
                 (p: any): LiphePractitioner => ({
                     id: p.id,
@@ -44,6 +46,12 @@ export class LiphePractitionerClient {
             nextPage = Boolean(data.next_page_url)
             page++
         }
-        return practitioners
+        return practitioners.map(p => ({
+            id: String(p.id),
+            firstName: p.firstname,
+            lastName: p.lastname,
+            email: p.email,
+            staffId: String(p.id)
+        }))
     }
 }

package/src/api/{apiClient.ts → salesforce/apiClient.ts}

@@ -2,10 +2,10 @@ import axios, { AxiosInstance } from 'axios'
 import { SFAuthenticator } from './auth/auth'
 import { SFTimesheetClient } from './timesheet/timesheetClient'
 import { SFPractitionerClient } from './practitioner/practitionerClient'
-import { Role } from '../models'
+import { Role } from '../../models'
 import { SFWorkorderClient } from './workorder/workorderClient'
 import { SFPayPeriodClient } from './payperiod/payperiodClient'
-import { SFExpenseClient } from './expenses/expenseClient'
+import { SFExpenseClient } from '../expenses/expenseClient'
 
 export const SF_API_VERSION: string = 'v57.0'
 

package/src/api/{payperiod → salesforce/payperiod}/payperiodClient.ts

@@ -1,13 +1,6 @@
 import { AxiosInstance } from 'axios'
 import { SF_API_VERSION } from '../apiClient'
-
-export interface Period {
-    payPeriodId: string
-    startDate: Date
-    endDate: Date
-    timesheetId?: string
-    workorderId?: string
-}
+import { Period } from '../../../models'
 
 export class SFPayPeriodClient {
     private axiosInstance: AxiosInstance

package/src/api/{practitioner → salesforce/practitioner}/practitionerClient.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios'
-import { Practitioner } from '../../models'
+import { Practitioner } from '../../../models'
 import { SF_API_VERSION } from '../apiClient'
 
 export class SFPractitionerClient {

package/src/api/{timesheet → salesforce/timesheet}/timesheetClient.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios'
-import { TimesheetDayEntry } from '../../models'
+import { TimesheetDayEntry } from '../../../models'
 import { SF_API_VERSION } from '../apiClient'
 import FormData from 'form-data'
 

package/src/api/{workorder → salesforce/workorder}/workorderClient.ts

@@ -1,6 +1,6 @@
 import { AxiosInstance } from 'axios'
 import { SF_API_VERSION } from '../apiClient'
-import { Workorder } from '../../models'
+import { Workorder } from '../../../models'
 
 export class SFWorkorderClient {
     private axiosInstance: AxiosInstance

package/src/index.ts

@@ -1,9 +1,14 @@
-export { SFApiClient } from './api/apiClient'
-export { SFPractitionerClient } from './api/practitioner/practitionerClient'
-export { SFTimesheetClient } from './api/timesheet/timesheetClient'
-export { SFAuthenticator } from './api/auth/auth'
-export { Practitioner, Role, TimesheetDayEntry, Workorder } from './models'
-export { LipheApiClient } from './api/lipheApiClient'
-export { LipheAuthenticator } from './api/liphe1.0/auth/authClient'
-export { LiphePractitionerClient } from './api/liphe1.0/practitioner/practitionerClient'
+// Salesforce API
+export { SFApiClient } from './api/salesforce/apiClient'
+export { SFPractitionerClient } from './api/salesforce/practitioner/practitionerClient'
+export { SFTimesheetClient } from './api/salesforce/timesheet/timesheetClient'
+export { SFAuthenticator } from './api/salesforce/auth/auth'
+
+// Liphe API
+export { LipheApiClient } from './api/liphe_legacy/lipheApiClient'
+export { LipheAuthenticator } from './api/liphe_legacy/auth/authClient'
+export { LiphePractitionerClient } from './api/liphe_legacy/practitioner/practitionerClient'
 export { SFExpenseClient } from './api/expenses/expenseClient'
+
+// Common Models
+export { Practitioner, Role, TimesheetDayEntry, Workorder, Agency, Period } from './models'

package/src/models/index.ts

@@ -1,21 +1,16 @@
-export interface Role {
-    label: string
-    value: string
-}
-
-export interface Workorder {
-    id: string
-    name: string
-    region: string
-    establishmentName: string
-    establishmentId: string
-    role: string
-    practitionerId: string
-    startDate: Date
-    endDate: Date
-    createdAt: Date
-    updatedAt: Date
+export enum Agency {
+    CHCA = "7",
+    CodeBleu = "5",
+    NordikOntario = "6",
+    PHA = "8",
+    PremierSoin = "1",
+    PremierSoinNordik = "3",
+    SolutionNursing = "4",
+    SolutionsStaffing = "9",
+    Transport = "2",
+    SSI = "99"
 }
 
 export * from './timesheet'
-export * from './practitioner'
+export * from './user'
+export * from './workorder'

package/src/models/{practitioner.ts → user.ts}

@@ -5,3 +5,8 @@ export interface Practitioner {
     email: string
     staffId: string
 }
+
+export interface Role {
+    label: string
+    value: string
+}

package/src/models/workorder.ts

@@ -0,0 +1,21 @@
+export interface Period {
+    payPeriodId: string
+    startDate: Date
+    endDate: Date
+    timesheetId?: string
+    workorderId?: string
+}
+
+export interface Workorder {
+    id: string
+    name: string
+    region: string
+    establishmentName: string
+    establishmentId: string
+    role: string
+    practitionerId?: string
+    startDate: Date
+    endDate: Date
+    createdAt?: Date
+    updatedAt?: Date
+}

package/dist/api/liphe1.0/practitioner/practitionerClient.d.ts

@@ -1,13 +0,0 @@
-import type { AxiosInstance } from 'axios';
-export interface LiphePractitioner {
-    id: number;
-    firstname: string;
-    lastname: string;
-    email: string;
-    communicationMode?: number;
-}
-export declare class LiphePractitionerClient {
-    private axios;
-    constructor(axiosInstance: AxiosInstance);
-    fetchAllPractitioners(agencyId?: number): Promise<LiphePractitioner[]>;
-}

package/src/api/.env

@@ -1,5 +0,0 @@
-I THINK THIS ONE IS WRONG
-SF_CLIENT_ID=3MVG9TZvGM_0NqB09H2fPRxeiDEsovly3D10kwNjOYJNTwBhMc5JHQgCdaSM.2N1V04tb_Tuyj_qktBPNueQd
-SF_CLIENT_SECRET=6F4D40003CF5B156A2AD2BFAD384E74AA9FFFD574E8753EAC485E3C478C50F9F
-GRANT_TYPE=client_credentials
-SALESFORCE_URL=https://do0000000d247eaa--phealth.sandbox.my.salesforce.com