@codihaus/odp-app-hr 0.1.0

package/app/composables/use-people.ts

@@ -0,0 +1,149 @@
+// Shared state — only 1 fetch at a time
+let initialFetch: Promise<void> | null = null
+
+export function usePeople() {
+    const api = useHrApi()
+    const { t } = useI18n()
+    const toast = useToast()
+
+    const people = useState<Person[]>('hr_people', () => [])
+    const loading = ref(false)
+    const searchQuery = ref('')
+    const stageFilter = ref<string>('all')
+    const departmentFilter = ref<number | null>(null)
+    const meta = ref<{ total_count?: number; filter_count?: number }>({})
+
+    async function fetchPeople(force = false) {
+        if (initialFetch && !force) return initialFetch
+        loading.value = true
+        initialFetch = (async () => {
+            try {
+                const res = await api.listPeople({})
+                people.value = Array.isArray(res.data) ? res.data : []
+                meta.value = res.meta ?? {}
+            }
+            finally {
+                loading.value = false
+                initialFetch = null
+            }
+        })()
+        return initialFetch
+    }
+
+    // Derived: talent-stage people (talent, interviewing, offer)
+    const talents = computed(() =>
+        people.value.filter(p => ['talent', 'interviewing', 'offer'].includes(p.stage))
+    )
+
+    // Derived: employee-stage people (probation, active, resigned)
+    const EMPLOYEE_STAGES = ['probation', 'active', 'resigned']
+
+    const employees = computed(() =>
+        people.value.filter(p => EMPLOYEE_STAGES.includes(p.stage))
+    )
+
+    const activeEmployees = computed(() =>
+        people.value.filter(p => p.stage === 'active')
+    )
+
+    const expiringContracts = computed(() => {
+        const today = new Date()
+        const in30days = new Date(today)
+        in30days.setDate(today.getDate() + 30)
+        return employees.value.filter(p => {
+            if (!p.contract?.end_date) return false
+            const end = new Date(p.contract.end_date)
+            return end >= today && end <= in30days
+        })
+    })
+
+    function getPerson(id: string): Person | undefined {
+        return people.value.find(p => p.id === id)
+    }
+
+    async function createPerson(input: Partial<Person>): Promise<Person> {
+        const person = await api.createPerson(input)
+        await fetchPeople()
+        return person
+    }
+
+    async function updatePerson(id: string, patch: Partial<Person>): Promise<Person> {
+        const person = await api.updatePerson(id, patch)
+        const idx = people.value.findIndex(p => p.id === id)
+        if (idx >= 0) people.value[idx] = person
+        return person
+    }
+
+    async function deletePerson(id: string): Promise<void> {
+        await api.deletePerson(id)
+        people.value = people.value.filter(p => p.id !== id)
+    }
+
+    async function refreshPerson(id: string): Promise<void> {
+        const person = await api.getPerson(id)
+        const idx = people.value.findIndex(p => p.id === id)
+        if (idx >= 0) people.value[idx] = person
+    }
+
+    // Phase 4: confirm hire → re-fetch person (now stage=probation) then redirect to employee profile
+    async function confirmHire(personId: string): Promise<void> {
+        await refreshPerson(personId)
+        await navigateTo(`/hr/employees/${personId}`)
+    }
+
+    // Hire a talent: any stage → probation (creates employee_id, fires provisioning hook), then redirect
+    async function hire(personId: string, opts: { reason?: string; start_date?: string } = {}): Promise<void> {
+        await $fetch(`/api/hr/people/${personId}/transition`, {
+            method: 'POST',
+            body: { to: 'probation', reason: opts.reason ?? '', start_date: opts.start_date || undefined },
+        })
+        await refreshPerson(personId)
+        toast.add({ title: t('hr.toast.hired'), color: 'success' })
+        await navigateTo(`/hr/employees/${personId}`)
+    }
+
+    // Phase 5: stage actions for employees
+    async function confirmProbation(personId: string): Promise<void> {
+        await $fetch(`/api/hr/people/${personId}/transition`, {
+            method: 'POST',
+            body: { to: 'active', reason: '' },
+        })
+        await refreshPerson(personId)
+        toast.add({ title: t('hr.toast.confirmed'), color: 'success' })
+    }
+
+    // confirmResign removed — resignation is now handled by the Off-boarding flow
+    // (composables/use-offboarding.ts → POST /hr/people/:id/offboarding + finalize).
+
+    async function reactivate(personId: string): Promise<void> {
+        await $fetch(`/api/hr/people/${personId}/transition`, {
+            method: 'POST',
+            body: { to: 'active', reason: 'Reactivated' },
+        })
+        await refreshPerson(personId)
+        toast.add({ title: t('hr.toast.reactivated'), color: 'success' })
+    }
+
+    return {
+        people,
+        loading,
+        meta,
+        searchQuery,
+        stageFilter,
+        departmentFilter,
+        talents,
+        employees,
+        activeEmployees,
+        expiringContracts,
+        fetchPeople,
+        getPerson,
+        createPerson,
+        updatePerson,
+        deletePerson,
+        refreshPerson,
+        confirmHire,
+        hire,
+        confirmProbation,
+        reactivate,
+    }
+}

package/app/composables/use-providers.ts

@@ -0,0 +1,44 @@
+export function useProviders() {
+    const providers = useState<HrProvider[]>('hr:providers', () => [])
+    const isPending = ref(false)
+
+    async function fetchProviders() {
+        isPending.value = true
+        try {
+            const res = await $fetch<any>('/api/hr/providers')
+            providers.value = Array.isArray(res) ? res : (res?.data ?? [])
+        }
+        finally {
+            isPending.value = false
+        }
+    }
+
+    async function addProvider(payload: Omit<HrProvider, 'id' | 'date_created' | 'date_updated'>) {
+        const res = await $fetch<any>('/api/hr/providers', { method: 'POST', body: payload })
+        const created: HrProvider = res?.data ?? res
+        providers.value = [...providers.value, created]
+        return created
+    }
+
+    async function updateProvider(id: string, payload: Partial<HrProvider>) {
+        const res = await $fetch<any>(`/api/hr/providers/${id}`, { method: 'PATCH', body: payload })
+        const updated: HrProvider = res?.data ?? res
+        const idx = providers.value.findIndex(p => p.id === id)
+        if (idx >= 0) providers.value[idx] = updated
+        return updated
+    }
+
+    async function deleteProvider(id: string) {
+        await $fetch(`/api/hr/providers/${id}`, { method: 'DELETE' })
+        providers.value = providers.value.filter(p => p.id !== id)
+    }
+
+    async function testConnection(id: string): Promise<{ success: boolean; message: string }> {
+        const res = await $fetch<{ success: boolean; message: string }>(`/api/hr/providers/${id}/test`, { method: 'POST' })
+        return res
+    }
+
+    onMounted(fetchProviders)
+
+    return { providers, isPending, fetchProviders, addProvider, updateProvider, deleteProvider, testConnection }
+}

package/app/composables/use-recruitment-workflow.ts

@@ -0,0 +1,173 @@
+import type {
+    WorkflowDef,
+    WorkflowInstanceFull,
+    WorkflowStep,
+    WorkflowInstanceStep,
+    WorkflowAction,
+} from '@odp/workflow/shared/types'
+
+export interface RecruitmentPipeline {
+    id: string
+    name: string
+    description: string | null
+    steps: WorkflowStep[]
+}
+
+export interface PipelineProgress {
+    instance: WorkflowInstanceFull
+    steps: WorkflowStep[]
+    instanceSteps: WorkflowInstanceStep[]
+    currentStepId: string | null
+    actions: WorkflowAction[]
+    isCompleted: boolean
+    isRejected: boolean
+}
+
+export function useRecruitmentWorkflow() {
+    const { $api } = useNuxtApp()
+
+    async function getAvailablePipelines(): Promise<RecruitmentPipeline[]> {
+        const res = await $api<{ data: WorkflowDef[] }>('/workflows', {
+            params: {
+                filter: JSON.stringify({
+                    collection: { _eq: 'hr_applications' },
+                    status: { _eq: 'active' },
+                    trigger_event: { _eq: 'manual' },
+                }),
+            },
+        })
+        const workflows = res.data ?? res ?? []
+        const arr = Array.isArray(workflows) ? workflows : []
+
+        const pipelines: RecruitmentPipeline[] = []
+        for (const wf of arr) {
+            const full = await $api<{ data: any }>(`/workflows/${encodeURIComponent(wf.id)}`)
+            const data = full.data ?? full
+            pipelines.push({
+                id: wf.id,
+                name: wf.name,
+                description: wf.description,
+                steps: data.steps ?? [],
+            })
+        }
+        return pipelines
+    }
+
+    function guessInterviewType(stepName: string): string {
+        const lower = stepName.toLowerCase()
+        if (lower.includes('screen') || lower.includes('hr')) return 'Screening'
+        if (lower.includes('techni') || lower.includes('code') || lower.includes('coding')) return 'Technical'
+        if (lower.includes('cultur') || lower.includes('fit') || lower.includes('behav')) return 'Culture'
+        if (lower.includes('final') || lower.includes('manager') || lower.includes('director')) return 'Final'
+        return 'Other'
+    }
+
+    async function createInterviewsForSteps(
+        personId: string | number,
+        appId: number,
+        steps: WorkflowStep[],
+    ): Promise<void> {
+        const approvalSteps = steps
+            .filter(s => s.type === 'approval')
+            .sort((a, b) => a.sort_order - b.sort_order)
+
+        for (const step of approvalSteps) {
+            await $api(
+                `/hr/people/${personId}/applications/${appId}/interviews`,
+                {
+                    method: 'POST',
+                    body: {
+                        type: guessInterviewType(step.name),
+                        label: step.name,
+                        status: 'Scheduled',
+                        workflow_step_id: step.id,
+                    },
+                },
+            )
+        }
+    }
+
+    async function startPipeline(
+        personId: string | number,
+        appId: number,
+        workflowId: string,
+    ): Promise<WorkflowInstanceFull> {
+        const res = await $api<{ data: any }>('/workflow-instances', {
+            method: 'POST',
+            body: {
+                workflow_id: workflowId,
+                collection: 'hr_applications',
+                item_id: String(appId),
+            },
+        })
+        const created = res.data ?? res
+
+        await $api(`/hr/people/${personId}/applications/${appId}`, {
+            method: 'PATCH',
+            body: { workflow_instance_id: created.id },
+        })
+
+        const fullRes = await $api<{ data: WorkflowInstanceFull }>(
+            `/workflow-instances/${encodeURIComponent(created.id)}`,
+        )
+        const instance = fullRes.data ?? fullRes as any as WorkflowInstanceFull
+
+        const steps: WorkflowStep[] = instance.workflow_steps ?? []
+        if (steps.length) {
+            await createInterviewsForSteps(personId, appId, steps)
+        }
+
+        return instance
+    }
+
+    async function loadInstance(instanceId: string): Promise<PipelineProgress | null> {
+        try {
+            const res = await $api<{ data: WorkflowInstanceFull }>(
+                `/workflow-instances/${encodeURIComponent(instanceId)}`,
+            )
+            const inst = res.data ?? res as any as WorkflowInstanceFull
+            return {
+                instance: inst,
+                steps: inst.workflow_steps ?? [],
+                instanceSteps: inst.instance_steps ?? [],
+                currentStepId: inst.current_step_id,
+                actions: inst.actions ?? [],
+                isCompleted: inst.status === 'completed',
+                isRejected: inst.status === 'rejected',
+            }
+        }
+        catch {
+            return null
+        }
+    }
+
+    async function approveStep(instanceId: string, stepId: string, comment?: string): Promise<void> {
+        await $api(
+            `/workflow-instances/${encodeURIComponent(instanceId)}/steps/${encodeURIComponent(stepId)}/approve`,
+            { method: 'POST', body: { comment } },
+        )
+    }
+
+    async function rejectStep(instanceId: string, stepId: string, comment: string): Promise<void> {
+        await $api(
+            `/workflow-instances/${encodeURIComponent(instanceId)}/steps/${encodeURIComponent(stepId)}/reject`,
+            { method: 'POST', body: { comment } },
+        )
+    }
+
+    async function cancelWorkflow(instanceId: string, comment?: string): Promise<void> {
+        await $api(
+            `/workflow-instances/${encodeURIComponent(instanceId)}/cancel`,
+            { method: 'POST', body: { comment } },
+        )
+    }
+
+    return {
+        getAvailablePipelines,
+        startPipeline,
+        loadInstance,
+        approveStep,
+        rejectStep,
+        cancelWorkflow,
+    }
+}

package/app/composables/use-templates.ts

@@ -0,0 +1,44 @@
+export function useTemplates() {
+    const templates = useState<any[]>('hr:templates', () => [])
+
+    async function fetchTemplates(includeArchived = false) {
+        const qs = includeArchived ? '?include_archived=1' : ''
+        const res = await $fetch<any>(`/api/hr/documents/templates${qs}`)
+        templates.value = Array.isArray(res) ? res : (res?.data ?? [])
+    }
+
+    async function saveTemplate(id: string | undefined, payload: Record<string, any>) {
+        if (id) {
+            const res = await $fetch<any>(`/api/hr/documents/templates/${id}`, {
+                method: 'PATCH',
+                body: payload,
+            })
+            const updated = res?.data ?? res
+            const idx = templates.value.findIndex((t: any) => t.id === id)
+            if (idx >= 0) templates.value[idx] = updated
+            return updated
+        }
+        else {
+            const res = await $fetch<any>('/api/hr/documents/templates', {
+                method: 'POST',
+                body: payload,
+            })
+            const created = res?.data ?? res
+            templates.value.push(created)
+            return created
+        }
+    }
+
+    async function archiveTemplate(id: string) {
+        await $fetch(`/api/hr/documents/templates/${id}`, { method: 'DELETE' })
+        const idx = templates.value.findIndex((t: any) => t.id === id)
+        if (idx >= 0) templates.value[idx] = { ...templates.value[idx], is_archived: true }
+    }
+
+    return {
+        templates,
+        fetchTemplates,
+        saveTemplate,
+        archiveTemplate,
+    }
+}

package/app/composables/use-triggers.ts

@@ -0,0 +1,26 @@
+export function useTriggers() {
+    const triggers = useState<any[]>('hr:triggers', () => [])
+
+    async function fetchTriggers() {
+        const res = await $fetch<any>('/api/hr/documents/triggers')
+        triggers.value = Array.isArray(res) ? res : (res?.data ?? [])
+    }
+
+    async function updateTrigger(id: string, payload: { auto_generate?: boolean, template_ids?: string[] }) {
+        const res = await $fetch<any>(`/api/hr/documents/triggers/${id}`, {
+            method: 'PATCH',
+            body: payload,
+        })
+        const idx = triggers.value.findIndex((t: any) => t.id === id)
+        if (idx >= 0) {
+            triggers.value[idx] = { ...triggers.value[idx], ...payload }
+        }
+        return res
+    }
+
+    return {
+        triggers,
+        fetchTriggers,
+        updateTrigger,
+    }
+}

package/app/config/column-renderers.ts

@@ -0,0 +1,4 @@
+// Column renderers for HR module list views.
+// Populated incrementally per phase.
+// Phase 2: employee list columns
+// Phase 5: employee detail columns

package/app/config/form-layouts.ts

@@ -0,0 +1,193 @@
+import type { HrFormLayout, HrInfoLayout } from '../../shared/types/form-layout'
+
+export const TALENT_FORM_LAYOUT: HrFormLayout = [
+    {
+        title: 'Identity',
+        columns: 2,
+        fields: [
+            { key: 'first_name', type: 'input', required: true, colspan: 1 },
+            { key: 'last_name', type: 'input', required: true, colspan: 1 },
+            { key: 'email', type: 'email', colspan: 1 },
+            { key: 'phone', type: 'phone', colspan: 1 },
+            { key: 'date_of_birth', type: 'date', colspan: 1 },
+            {
+                key: 'gender',
+                type: 'select',
+                colspan: 1,
+                options: [
+                    { value: 'male', label: 'Male' },
+                    { value: 'female', label: 'Female' },
+                    { value: 'other', label: 'Other' },
+                ],
+            },
+            { key: 'nationality', type: 'input', colspan: 1 },
+            { key: 'id_number', type: 'input', colspan: 1 },
+        ],
+    },
+    {
+        title: 'Recruitment',
+        columns: 2,
+        fields: [
+            { key: 'desired_position', type: 'input', colspan: 2 },
+            { key: 'source', type: 'input', colspan: 1 },
+            { key: 'department_id', type: 'select', colspan: 1 },
+        ],
+    },
+]
+
+// Phase 4: Hire form layout (for hire-form-modal.vue)
+export const HIRE_FORM_LAYOUT = {
+    sections: [
+        {
+            key: 'auto_ids',
+            label: 'Auto-generated IDs',
+            fields: ['employee_id', 'contract_number'],
+            readonly: true,
+        },
+        {
+            key: 'position',
+            label: 'Position',
+            fields: ['job_title', 'department', 'employment_type_id'],
+        },
+        {
+            key: 'contract',
+            label: 'Contract',
+            fields: ['start_date', 'contract_type', 'probation_months'],
+        },
+    ],
+} as const
+
+export const TALENT_INFO_LAYOUT: HrInfoLayout = [
+    {
+        title: 'Identity',
+        rows: [
+            { label: 'Full Name', key: 'display_name' },
+            { label: 'Email', key: 'email' },
+            { label: 'Phone', key: 'phone' },
+            { label: 'Date of Birth', key: 'date_of_birth', format: 'date' },
+            { label: 'Gender', key: 'gender' },
+            { label: 'Nationality', key: 'nationality' },
+            { label: 'ID Number', key: 'id_number' },
+        ],
+    },
+    {
+        title: 'Recruitment',
+        rows: [
+            { label: 'Desired Position', key: 'desired_position' },
+            { label: 'Source', key: 'source' },
+            { label: 'Department', key: 'department_id' },
+        ],
+    },
+]
+
+// Phase 5: Employee Management layouts
+
+export const EMPLOYEE_FORM_LAYOUT = {
+    sections: [
+        {
+            key: 'identity',
+            label: 'employees.sections.identity',
+            fields: [
+                { key: 'first_name', type: 'text', required: true },
+                { key: 'last_name', type: 'text', required: true },
+                { key: 'email', type: 'email', required: true },
+                { key: 'phone', type: 'phone' },
+                { key: 'date_of_birth', type: 'date' },
+            ],
+        },
+        {
+            key: 'employment',
+            label: 'employees.sections.employment',
+            fields: [
+                { key: 'employee_id', type: 'text', readonly: true },
+                { key: 'department_id', type: 'relation', collection: 'hr_departments' },
+                { key: 'job_title', type: 'text' },
+                { key: 'employment_type_id', type: 'relation', collection: 'hr_employment_types' },
+                { key: 'start_date', type: 'date' },
+                { key: 'manager_id', type: 'relation', collection: 'hr_people' },
+            ],
+        },
+        {
+            key: 'emergency',
+            label: 'employees.sections.emergency',
+            fields: [
+                { key: 'emergency_contact_name', type: 'text' },
+                { key: 'emergency_contact_phone', type: 'phone' },
+                { key: 'emergency_contact_relation', type: 'text' },
+            ],
+        },
+    ],
+} as const
+
+export const CONTRACT_LAYOUT = {
+    sections: [
+        {
+            key: 'contract_details',
+            label: 'contract.sections.details',
+            fields: [
+                { key: 'contract_type', type: 'select', options: ['Indefinite', 'Definite'], required: true },
+                { key: 'contract_number', type: 'text', required: true },
+                { key: 'start_date', type: 'date', required: true },
+                { key: 'end_date', type: 'date', conditional: (form: any) => form.contract_type === 'Definite' },
+                { key: 'probation_end', type: 'date', readonly: true },
+                { key: 'renewal_count', type: 'number', min: 0 },
+            ],
+        },
+    ],
+} as const
+
+export const COMPENSATION_LAYOUT = {
+    sections: [
+        {
+            key: 'salary',
+            label: 'compensation.sections.salary',
+            fields: [
+                { key: 'base_salary', type: 'currency', required: true },
+                { key: 'currency', type: 'select', source: 'settings.currency' },
+                { key: 'pay_frequency', type: 'select', options: ['Monthly', 'Bi-weekly', 'Weekly'] },
+                { key: 'bonus_target', type: 'percentage' },
+            ],
+        },
+        {
+            key: 'bank',
+            label: 'compensation.sections.bank',
+            fields: [
+                { key: 'bank_name', type: 'text' },
+                { key: 'bank_account_number', type: 'text' },
+            ],
+        },
+        {
+            key: 'allowances',
+            label: 'compensation.sections.allowances',
+            type: 'dynamic_list',
+            itemFields: [
+                { key: 'name', type: 'text', required: true },
+                { key: 'amount', type: 'currency', required: true },
+                { key: 'type', type: 'select', options: ['Fixed', 'Percentage'] },
+            ],
+        },
+    ],
+} as const
+
+export const INSURANCE_LAYOUT = {
+    sections: [
+        {
+            key: 'insurance_ids',
+            label: 'insurance.sections.ids',
+            fields: [
+                { key: 'social_insurance_number', type: 'text' },
+                { key: 'health_insurance_number', type: 'text' },
+                { key: 'insurance_contribution_rate', type: 'percentage' },
+            ],
+        },
+        {
+            key: 'tax',
+            label: 'insurance.sections.tax',
+            fields: [
+                { key: 'tax_id', type: 'text' },
+                { key: 'dependents_count', type: 'number', min: 0 },
+                { key: 'personal_deduction', type: 'currency' },
+            ],
+        },
+    ],
+} as const