@codihaus/odp-app-hr 0.1.0

package/app/composables/use-hr-api.ts

@@ -0,0 +1,210 @@
+export function useHrApi() {
+    const { $api } = useNuxtApp()
+
+    function unwrap<T>(res: T | { data: T }): T {
+        return (res && typeof res === 'object' && 'data' in res) ? (res as any).data : res
+    }
+
+    async function getSettings() {
+        return unwrap(await $api<HrSettings | { data: HrSettings }>('/hr/settings'))
+    }
+
+    async function patchSettings(body: Partial<HrSettings>) {
+        return unwrap(await $api<HrSettings | { data: HrSettings }>('/hr/settings', { method: 'PATCH', body }))
+    }
+
+    async function getFields(collection: string) {
+        return unwrap(await $api<any[] | { data: any[] }>(`/hr/fields/${collection}`))
+    }
+
+    // People CRUD
+
+    async function listPeople(query?: Record<string, string>) {
+        const res = await $api<any>('/hr/people', { query })
+        return { data: unwrap(res.data ?? res), meta: res.meta ?? null }
+    }
+
+    async function getPerson(id: string) {
+        return unwrap(await $api<Person | { data: Person }>(`/hr/people/${id}`))
+    }
+
+    async function createPerson(body: Partial<Person>) {
+        return unwrap(await $api<Person | { data: Person }>('/hr/people', { method: 'POST', body }))
+    }
+
+    async function updatePerson(id: string, body: Partial<Person>) {
+        return unwrap(await $api<Person | { data: Person }>(`/hr/people/${id}`, { method: 'PATCH', body }))
+    }
+
+    async function deletePerson(id: string) {
+        await $api(`/hr/people/${id}`, { method: 'DELETE' })
+    }
+
+    // Notes
+
+    async function listNotes(personId: string) {
+        return unwrap(await $api<HrNote[] | { data: HrNote[] }>(`/hr/people/${personId}/notes`))
+    }
+
+    async function createNote(personId: string, body: string) {
+        return unwrap(await $api<HrNote | { data: HrNote }>(`/hr/people/${personId}/notes`, {
+            method: 'POST',
+            body: { body },
+        }))
+    }
+
+    async function deleteNote(personId: string, noteId: string) {
+        await $api(`/hr/people/${personId}/notes/${noteId}`, { method: 'DELETE' })
+    }
+
+    // Leave
+
+    async function listLeaveTypes() {
+        return unwrap(await $api<any[] | { data: any[] }>(`/hr/settings/leave-types`))
+    }
+
+    async function createLeaveRequest(personId: string, body: any) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/leave-requests`, {
+            method: 'POST',
+            body,
+        }))
+    }
+
+    // Contract
+
+    async function getContract(personId: string) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/contracts`))
+    }
+
+    async function updateContract(personId: string, body: any) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/contracts`, {
+            method: 'PATCH',
+            body,
+        }))
+    }
+
+    // Compensation
+
+    async function getCompensation(personId: string) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/compensations`))
+    }
+
+    async function updateCompensation(personId: string, body: any) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/compensations`, {
+            method: 'PATCH',
+            body,
+        }))
+    }
+
+    // Insurance
+
+    async function getInsurance(personId: string) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/insurances`))
+    }
+
+    async function updateInsurance(personId: string, body: any) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/insurances`, {
+            method: 'PATCH',
+            body,
+        }))
+    }
+
+    // Assets
+
+    async function listAssets(personId: string) {
+        return unwrap(await $api<any[] | { data: any[] }>(`/hr/people/${personId}/assets`))
+    }
+
+    async function createAsset(personId: string, body: any) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/assets`, {
+            method: 'POST',
+            body,
+        }))
+    }
+
+    async function updateAsset(personId: string, assetId: string | number, body: any) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/assets/${assetId}`, {
+            method: 'PATCH',
+            body,
+        }))
+    }
+
+    async function deleteAsset(personId: string, assetId: string | number) {
+        await $api(`/hr/people/${personId}/assets/${assetId}`, { method: 'DELETE' })
+    }
+
+    // Departments
+
+    async function listDepartments() {
+        return unwrap(await $api<any[] | { data: any[] }>('/hr/departments'))
+    }
+
+    async function createDepartment(body: any) {
+        return unwrap(await $api<any | { data: any }>('/hr/departments', {
+            method: 'POST',
+            body,
+        }))
+    }
+
+    async function updateDepartment(id: number, body: any) {
+        return unwrap(await $api<any | { data: any }>(`/hr/departments/${id}`, {
+            method: 'PATCH',
+            body,
+        }))
+    }
+
+    async function deleteDepartment(id: number) {
+        await $api(`/hr/departments/${id}`, { method: 'DELETE' })
+    }
+
+    // Documents
+
+    async function listDocuments(personId: string) {
+        return unwrap(await $api<any[] | { data: any[] }>(`/hr/people/${personId}/documents`))
+    }
+
+    async function generateDocument(personId: string, templateId: number | string) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/documents`, {
+            method: 'POST',
+            body: { type: 'generate', template_id: templateId },
+        }))
+    }
+
+    async function deleteDocument(personId: string, docId: number | string) {
+        await $api(`/hr/people/${personId}/documents/${docId}`, { method: 'DELETE' })
+    }
+
+    // Provisioning
+
+    async function getProvisioningStatus(personId: string) {
+        return unwrap(await $api<ProvisioningStatus[] | { data: ProvisioningStatus[] }>(`/hr/people/${personId}/provisioning`))
+    }
+
+    async function triggerProvisioning(personId: string, action: 'create' | 'disable' | 'enable') {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/provisioning`, {
+            method: 'POST',
+            body: { action },
+        }))
+    }
+
+    async function retryProvisioning(personId: string, logId: string) {
+        return unwrap(await $api<any | { data: any }>(`/hr/people/${personId}/provisioning/${logId}/retry`, {
+            method: 'POST',
+        }))
+    }
+
+    return {
+        unwrap,
+        getSettings, patchSettings, getFields,
+        listPeople, getPerson, createPerson, updatePerson, deletePerson,
+        listNotes, createNote, deleteNote,
+        listLeaveTypes, createLeaveRequest,
+        getContract, updateContract,
+        getCompensation, updateCompensation,
+        getInsurance, updateInsurance,
+        listAssets, createAsset, updateAsset, deleteAsset,
+        listDepartments, createDepartment, updateDepartment, deleteDepartment,
+        listDocuments, generateDocument, deleteDocument,
+        getProvisioningStatus, triggerProvisioning, retryProvisioning,
+    }
+}

package/app/composables/use-hr-field-registry.ts

@@ -0,0 +1,76 @@
+const INTERFACE_NORMALIZE: Record<string, string> = {
+    'select-dropdown': 'select',
+}
+
+// FormRoot renders fields in a 24-col @container grid. Field.vue hard-codes
+// `col-span-full` and only honors `meta.options.ui.base`, so the DB `width`
+// (half/full) is otherwise ignored. Map it to a responsive col-span here so
+// half-width fields sit two-per-row on wide containers and stack on narrow.
+const WIDTH_COLSPAN: Record<string, string> = {
+    'half': '@xl:col-span-12',
+    'half-left': '@xl:col-span-12',
+    'half-right': '@xl:col-span-12',
+}
+
+function normalizeField(field: Field): Field {
+    if (!field.meta) return field
+    let meta = field.meta
+    const iface = meta.interface
+    if (iface && INTERFACE_NORMALIZE[iface]) {
+        meta = { ...meta, interface: INTERFACE_NORMALIZE[iface] }
+    }
+    const colspan = WIDTH_COLSPAN[meta.width ?? 'full']
+    if (colspan && !meta.options?.ui?.base) {
+        meta = {
+            ...meta,
+            options: {
+                ...(meta.options ?? {}),
+                ui: { ...(meta.options?.ui ?? {}), base: colspan },
+            },
+        }
+    }
+    return meta === field.meta ? field : { ...field, meta }
+}
+
+export function useHrFieldRegistry(collections: string[]) {
+    const api = useHrApi()
+    const registry = ref<Record<string, Field[]>>({})
+    const loading = ref(false)
+
+    async function fetchAll() {
+        loading.value = true
+        try {
+            const results = await Promise.all(
+                collections.map(c => api.getFields(c).then(fields => ({ c, fields })))
+            )
+            results.forEach(({ c, fields }) => {
+                registry.value[c] = (fields ?? []).map(normalizeField)
+            })
+        } finally {
+            loading.value = false
+        }
+    }
+
+    function getField(collection: string, key: string): Field | null {
+        return registry.value[collection]?.find(f => f.field === key) ?? null
+    }
+
+    function pickFields(collection: string, names: string[]): Field[] {
+        const result: Field[] = []
+        let sortIndex = 0
+        for (const name of names) {
+            const f = getField(collection, name)
+            if (f) {
+                result.push({ ...f, meta: { ...f.meta!, sort: sortIndex } })
+                sortIndex++
+            }
+        }
+        return result
+    }
+
+    function isReady(collection: string): boolean {
+        return collection in registry.value
+    }
+
+    return { registry, loading, fetchAll, getField, pickFields, isReady }
+}

package/app/composables/use-hr-policies.ts

@@ -0,0 +1,66 @@
+import type { Policy, PolicyKey, PolicyParams } from "../../shared/types"
+
+export function useHrPolicies() {
+    const policies = useState<Policy[]>('hr:policies', () => [])
+    const isPending = ref(false)
+
+    async function fetchPolicies(): Promise<void> {
+        isPending.value = true
+        try {
+            const { useHrApi } = await import('./use-hr-api')
+            const api = useHrApi()
+            const res = await $fetch<{ data: Policy[] } | Policy[]>('/api/hr/policies')
+            policies.value = api.unwrap(res) as Policy[]
+        } finally {
+            isPending.value = false
+        }
+    }
+
+    function getPolicy(key: PolicyKey): Policy | undefined {
+        return policies.value.find(p => p.key === key)
+    }
+
+    async function togglePolicy(key: PolicyKey, enabled: boolean): Promise<void> {
+        const policy = getPolicy(key)
+        if (!policy) return
+        isPending.value = true
+        try {
+            const res = await $fetch<{ data: Policy } | Policy>(`/api/hr/policies/${policy.id}`, {
+                method: 'PATCH',
+                body: { enabled },
+            })
+            const idx = policies.value.findIndex(p => p.key === key)
+            if (idx >= 0) {
+                const { useHrApi } = await import('./use-hr-api')
+                const api = useHrApi()
+                policies.value[idx] = api.unwrap(res) as Policy
+            }
+        } finally {
+            isPending.value = false
+        }
+    }
+
+    async function updatePolicyParams(key: PolicyKey, params: PolicyParams): Promise<void> {
+        const policy = getPolicy(key)
+        if (!policy) return
+        isPending.value = true
+        try {
+            const res = await $fetch<{ data: Policy } | Policy>(`/api/hr/policies/${policy.id}`, {
+                method: 'PATCH',
+                body: { params },
+            })
+            const idx = policies.value.findIndex(p => p.key === key)
+            if (idx >= 0) {
+                const { useHrApi } = await import('./use-hr-api')
+                const api = useHrApi()
+                policies.value[idx] = api.unwrap(res) as Policy
+            }
+        } finally {
+            isPending.value = false
+        }
+    }
+
+    onMounted(fetchPolicies)
+
+    return { policies, getPolicy, togglePolicy, updatePolicyParams, isPending }
+}

package/app/composables/use-hr-settings.ts

@@ -0,0 +1,118 @@
+import type { LifecycleStage } from "../../shared/types/person"
+import type { LeaveType, EmploymentType, HrGeneralSettings } from "../../shared/types/settings"
+import { LIFECYCLE_STAGES } from "../../shared/types/person"
+
+export function useHrSettings() {
+    const leaveTypes = useState<LeaveType[]>('hr:leave-types', () => [])
+    const employmentTypes = useState<EmploymentType[]>('hr:employment-types', () => [])
+    const general = useState<HrGeneralSettings>('hr:general-settings', () => ({
+        company_name: '',
+        fiscal_year_start_month: 1,
+        default_currency: 'VND',
+    }))
+    const lifecycleLabels = useState<Record<LifecycleStage, string>>(
+        'hr:lifecycle-labels',
+        () => Object.fromEntries(LIFECYCLE_STAGES.map(s => [s, s])) as Record<LifecycleStage, string>,
+    )
+    const isPending = ref(false)
+
+    function unwrap<T>(res: T | { data: T }): T {
+        return (res && typeof res === 'object' && 'data' in res) ? (res as any).data : res
+    }
+
+    async function fetchSettings(): Promise<void> {
+        const res = await $fetch<HrGeneralSettings | { data: HrGeneralSettings }>('/api/hr/settings')
+        const data = unwrap(res)
+        if (data) Object.assign(general.value, data)
+    }
+
+    async function save(payload: Partial<HrGeneralSettings>): Promise<void> {
+        isPending.value = true
+        try {
+            const res = await $fetch<HrGeneralSettings | { data: HrGeneralSettings }>('/api/hr/settings', {
+                method: 'PATCH',
+                body: payload,
+            })
+            const data = unwrap(res)
+            if (data) Object.assign(general.value, data)
+        } finally {
+            isPending.value = false
+        }
+    }
+
+    async function fetchLeaveTypes(): Promise<void> {
+        const res = await $fetch<LeaveType[] | { data: LeaveType[] }>('/api/hr/settings/leave-types')
+        leaveTypes.value = unwrap(res) as LeaveType[]
+    }
+
+    async function addLeaveType(input: Omit<LeaveType, 'id' | 'is_archived'>): Promise<void> {
+        const res = await $fetch<LeaveType | { data: LeaveType }>('/api/hr/settings/leave-types', {
+            method: 'POST',
+            body: input,
+        })
+        leaveTypes.value.push(unwrap(res) as LeaveType)
+    }
+
+    async function updateLeaveType(id: string | number, patch: Partial<LeaveType>): Promise<void> {
+        const res = await $fetch<LeaveType | { data: LeaveType }>(`/api/hr/settings/leave-types/${id}`, {
+            method: 'PATCH',
+            body: patch,
+        })
+        const updated = unwrap(res) as LeaveType
+        const idx = leaveTypes.value.findIndex(t => t.id === id)
+        if (idx >= 0) leaveTypes.value[idx] = updated
+    }
+
+    async function archiveLeaveType(id: string | number): Promise<void> {
+        await updateLeaveType(id, { status: 'archived' } as any)
+    }
+
+    async function fetchEmploymentTypes(): Promise<void> {
+        const res = await $fetch<EmploymentType[] | { data: EmploymentType[] }>('/api/hr/settings/employment-types')
+        employmentTypes.value = unwrap(res) as EmploymentType[]
+    }
+
+    async function addEmploymentType(input: Omit<EmploymentType, 'id' | 'is_archived'>): Promise<void> {
+        const res = await $fetch<EmploymentType | { data: EmploymentType }>('/api/hr/settings/employment-types', {
+            method: 'POST',
+            body: input,
+        })
+        employmentTypes.value.push(unwrap(res) as EmploymentType)
+    }
+
+    async function updateEmploymentType(id: string | number, patch: Partial<EmploymentType>): Promise<void> {
+        const res = await $fetch<EmploymentType | { data: EmploymentType }>(`/api/hr/settings/employment-types/${id}`, {
+            method: 'PATCH',
+            body: patch,
+        })
+        const updated = unwrap(res) as EmploymentType
+        const idx = employmentTypes.value.findIndex(t => t.id === id)
+        if (idx >= 0) employmentTypes.value[idx] = updated
+    }
+
+    async function archiveEmploymentType(id: string | number): Promise<void> {
+        await $fetch(`/api/hr/settings/employment-types/${id}`, { method: 'DELETE' })
+        const idx = employmentTypes.value.findIndex(t => t.id === id)
+        if (idx >= 0) employmentTypes.value[idx] = { ...employmentTypes.value[idx]!, is_archived: true }
+    }
+
+    function setStageLabel(stage: LifecycleStage, label: string): void {
+        lifecycleLabels.value[stage] = label
+    }
+
+    onMounted(async () => {
+        await Promise.all([fetchSettings(), fetchLeaveTypes(), fetchEmploymentTypes()])
+    })
+
+    return {
+        leaveTypes,
+        employmentTypes,
+        general,
+        lifecycleLabels,
+        isPending,
+        save,
+        addLeaveType, updateLeaveType, archiveLeaveType,
+        addEmploymentType, updateEmploymentType, archiveEmploymentType,
+        setStageLabel,
+    }
+}

package/app/composables/use-leave.ts

@@ -0,0 +1,71 @@
+export function useLeave() {
+    const leaveRequests = useState<LeaveRequest[]>('leave.requests', () => [])
+    const loading = useState('leave.loading', () => false)
+
+    const pendingLeave = computed(() => leaveRequests.value.filter(r => r.status?.toLowerCase() === 'pending'))
+    const approvedLeave = computed(() => leaveRequests.value.filter(r => r.status?.toLowerCase() === 'approved'))
+    const rejectedLeave = computed(() => leaveRequests.value.filter(r => r.status?.toLowerCase() === 'rejected'))
+    const totalDaysUsed = computed(() => approvedLeave.value.reduce((sum, r) => sum + (r.days_count ?? r.days ?? 0), 0))
+    const pendingCount = computed(() => pendingLeave.value.length)
+
+    const stats = computed(() => ({
+        pending: pendingLeave.value.length,
+        approved: approvedLeave.value.length,
+        rejected: rejectedLeave.value.length,
+        totalDays: totalDaysUsed.value,
+    }))
+
+    const { unwrap } = useHrApi()
+
+    async function fetchRequests(params?: Record<string, string>) {
+        loading.value = true
+        try {
+            const res = await $fetch<any>('/api/hr/leave/requests', { query: params })
+            leaveRequests.value = unwrap(res?.data ?? res) ?? []
+        }
+        finally {
+            loading.value = false
+        }
+    }
+
+    async function setStatus(id: string | number, status: LeaveRequest['status'], rejectReason?: string) {
+        const { unwrap: u } = useHrApi()
+        await $fetch(`/api/hr/leave/requests/${id}`, {
+            method: 'PATCH',
+            body: { status, reject_reason: rejectReason },
+        })
+        const idx = leaveRequests.value.findIndex(r => String(r.id) === String(id))
+        if (idx >= 0) {
+            leaveRequests.value[idx] = { ...leaveRequests.value[idx]!, status }
+        }
+    }
+
+    async function createRequest(personId: string | number, payload: {
+        leave_type_id: number
+        start_date: string
+        end_date: string
+        reason?: string
+    }) {
+        const res = await $fetch<any>(`/api/hr/people/${personId}/leave-requests`, {
+            method: 'POST',
+            body: payload,
+        })
+        const created: LeaveRequest = unwrap(res?.data ?? res)
+        leaveRequests.value = [created, ...leaveRequests.value]
+        return created
+    }
+
+    return {
+        leaveRequests,
+        loading,
+        pendingLeave,
+        approvedLeave,
+        rejectedLeave,
+        totalDaysUsed,
+        pendingCount,
+        stats,
+        fetchRequests,
+        setStatus,
+        createRequest,
+    }
+}

package/app/composables/use-offboarding.ts

@@ -0,0 +1,49 @@
+export function useOffboarding() {
+    const { $api } = useNuxtApp()
+    const unwrap = (r: any) => (r && typeof r === 'object' && 'data' in r ? r.data : r)
+    // Shared signal so the Off-boarding tab re-fetches after an action fired
+    // from elsewhere (e.g. the Initiate modal in the detail navbar) even when
+    // the route doesn't change.
+    const refreshKey = useState('hr:offboarding:refresh', () => 0)
+
+    async function fetchForPerson(personId: string | number): Promise<Offboarding | null> {
+        return unwrap(await $api<any>(`/hr/people/${personId}/offboarding`))
+    }
+    async function listForPerson(personId: string | number): Promise<Offboarding[]> {
+        return unwrap(await $api<any>(`/hr/people/${personId}/offboarding/cases`)) ?? []
+    }
+    async function list(): Promise<Offboarding[]> {
+        return unwrap(await $api<any>(`/hr/offboarding`)) ?? []
+    }
+    async function get(id: string | number): Promise<Offboarding> {
+        return unwrap(await $api<any>(`/hr/offboarding/${id}`))
+    }
+    async function initiate(personId: string | number, body: Partial<Offboarding>): Promise<Offboarding> {
+        const created = unwrap(await $api<any>(`/hr/people/${personId}/offboarding`, { method: 'POST', body }))
+        refreshKey.value++
+        return created
+    }
+    async function updateCase(id: string | number, body: Partial<Offboarding>): Promise<Offboarding> {
+        return unwrap(await $api<any>(`/hr/offboarding/${id}`, { method: 'PATCH', body }))
+    }
+    async function updateTask(id: string | number, taskId: string | number, body: Partial<OffboardingTask>) {
+        return $api<any>(`/hr/offboarding/${id}/tasks/${taskId}`, { method: 'PATCH', body })
+    }
+    async function returnAssets(id: string | number) {
+        return unwrap(await $api<any>(`/hr/offboarding/${id}/return-assets`, { method: 'POST' }))
+    }
+    async function deprovision(id: string | number) {
+        return unwrap(await $api<any>(`/hr/offboarding/${id}/deprovision`, { method: 'POST' }))
+    }
+    async function getSettlement(id: string | number): Promise<OffboardingSettlement> {
+        return unwrap(await $api<any>(`/hr/offboarding/${id}/settlement`))
+    }
+    async function finalize(id: string | number): Promise<Offboarding> {
+        return unwrap(await $api<any>(`/hr/offboarding/${id}/finalize`, { method: 'POST' }))
+    }
+    async function cancel(id: string | number): Promise<Offboarding> {
+        return unwrap(await $api<any>(`/hr/offboarding/${id}/cancel`, { method: 'POST' }))
+    }
+
+    return { refreshKey, fetchForPerson, listForPerson, list, get, initiate, updateCase, updateTask, returnAssets, deprovision, getSettlement, finalize, cancel }
+}