import { API_BASE_URL, request, type ApiResponse } from "./request";
import type { PageResult } from "./purchase";
import type { DictData, DeptSimple } from "./crm";

export interface SimpleOption { id: number; name: string; code?: string; parentId?: number; status?: number }
export interface HrmAttachment { id: number; name?: string; url?: string; path?: string; size?: number }
export interface UserOption { id: number; nickname?: string; username?: string; deptId?: number; deptName?: string }
export interface EmployeeSimple { id: number; employeeNo: string; name: string; deptId?: number; deptName?: string; postId?: number; postIds?: number[]; postName?: string; employeeStatus?: number }
export interface Employee {
  id?: number; deptId?: number; deptName?: string; postId?: number; postName?: string;
  roleIds?: number[]; roleNames?: string; employeeNo?: string; name?: string; gender?: number; birthday?: string; phone?: string;
  email?: string; idCard?: string; nation?: string; marriageStatus?: string; age?: number; education?: string;
  politicalStatus?: string; hireDate?: string; regularDate?: string; leaveDate?: string; employeeStatus?: number;
  annualLeaveBalance?: number; sickLeaveBalance?: number; salaryStructureId?: number; baseSalary?: number; bankName?: string; bankAccount?: string;
  address?: string; remark?: string; createTime?: string;
}
export interface EmployeeContract {
  id?: number; parentId?: number; parentNo?: string; isCurrent?: boolean; contractNo?: string; employeeId?: number;
  employeeName?: string; employeeNo?: string; deptName?: string; contractType?: number; contractTermType?: number;
  signCompany?: string; signDate?: string; startDate?: string; endDate?: string; probationStartDate?: string;
  probationEndDate?: string; probationSalary?: number; regularSalary?: number; terminateStatus?: number;
  terminateDate?: string; terminateReason?: string; status?: number; blobIds?: number[]; attachmentList?: HrmAttachment[];
  remark?: string; createTime?: string;
}
export interface Leave {
  id?: number; userId?: number; userName?: string; deptId?: number; deptName?: string; leaveType?: number; startTime?: string;
  endTime?: string; duration?: number; reason?: string; status?: number; processInstanceId?: string;
  blobIds?: number[]; attachmentList?: HrmAttachment[]; remark?: string; createTime?: string;
}
export interface Transfer {
  id?: number; no?: string; userId?: number; userName?: string; currentDeptId?: number; currentDeptName?: string;
  currentPostId?: number; currentPostName?: string; targetDeptId?: number; targetDeptName?: string;
  targetPostId?: number; targetPostName?: string; transferType?: number; effectiveDate?: string; reason?: string;
  status?: number; processInstanceId?: string; blobIds?: number[]; attachmentList?: HrmAttachment[];
  remark?: string; createTime?: string;
}
export interface Resignation {
  id?: number; no?: string; userId?: number; userName?: string; deptId?: number; deptName?: string;
  resignationType?: number; resignationTypeName?: string; expectedDate?: string; actualDate?: string;
  reason?: string; handoverUserId?: number; handoverUserName?: string; handoverStatus?: number;
  handoverStatusName?: string; handoverRemark?: string; status?: number; statusName?: string;
  processInstanceId?: string; blobIds?: number[]; attachmentList?: HrmAttachment[]; remark?: string; createTime?: string;
}
export interface Overtime {
  id?: number; no?: string; userId?: number; employeeId?: number; employeeName?: string; employeeNo?: string;
  deptId?: number; deptName?: string; postName?: string; overtimeDate?: string; startTime?: string; endTime?: string;
  duration?: number; overtimeType?: number; overtimeTypeName?: string; crossDay?: boolean; mealDeduction?: boolean;
  mealDeductionHours?: number; reason?: string; relatedType?: number; relatedCode?: string; workContent?: string;
  status?: number; statusName?: string; processInstanceId?: string; createTime?: string;
}
export interface ApproveProcess { key: string; name: string }
export interface AttendanceRule {
  id?: number; name?: string; deptId?: number; deptName?: string; workStartTime?: string; workEndTime?: string;
  lateAllowMinutes?: number; earlyAllowMinutes?: number; overtimeThreshold?: number; status?: number; remark?: string;
  locationName?: string; locationAddress?: string; longitude?: number; latitude?: number; radiusMeters?: number;
  locationRequired?: boolean; coordinateSystem?: "WGS84"; effectiveStartDate?: string; effectiveEndDate?: string;
}
export interface AttendanceRecord {
  id?: number; userId?: number; userName?: string; deptId?: number; deptName?: string; phone?: string; date?: string;
  clockInTime?: string; clockOutTime?: string; clockInType?: number; clockInTypeName?: string; clockOutType?: number;
  clockOutTypeName?: string; workHours?: number; overtimeHours?: number; location?: string; dataSource?: number;
  leaveFlag?: boolean; leaveHours?: number; leaveTypes?: string;
  dataSourceName?: string; remark?: string; createTime?: string;
}
export interface AttendanceClockable {
  clockIn?: boolean; clockOut?: boolean; nextAction?: "in" | "out" | "none"; message?: string;
}
export interface AttendanceMyStatus {
  userId?: number; employeeId?: number; employeeName?: string; deptId?: number; deptName?: string;
  date?: string; serverTime?: string; workDay?: boolean; restDayReason?: string | null;
  onLeave?: boolean; leaveHours?: number; leaveTypeNames?: string;
  rule?: AttendanceRule | null; record?: AttendanceRecord | null; clockable?: AttendanceClockable;
}
export interface AttendanceClockRequest {
  longitude?: number; latitude?: number; accuracy?: number; coordinateSystem?: "WGS84";
}
export interface AttendanceClockResponse {
  record: AttendanceRecord;
  locationName?: string;
  distanceMeters?: number;
  radiusMeters?: number;
  withinRange?: boolean;
}

const header = (accessToken: string) => ({ Authorization: `Bearer ${accessToken}` });
function query(params: Record<string, string | number | boolean | undefined>) {
  const content = Object.entries(params).filter(([, value]) => value !== undefined && value !== "")
    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
  return content ? `?${content}` : "";
}

export function getHrmDicts(token: string) { return request<DictData[]>("/system/dict-data/simple-list", { header: header(token) }); }
export function getHrmDeptList(token: string) { return request<DeptSimple[]>("/system/dept/simple-list", { header: header(token) }); }
export function getHrmPostList(token: string) { return request<SimpleOption[]>("/system/post/simple-list", { header: header(token) }); }
export function getHrmRoleList(token: string) { return request<SimpleOption[]>("/system/role/simple-list", { header: header(token) }); }
export function getHrmUserList(token: string) { return request<UserOption[]>("/system/user/simple-list", { header: header(token) }); }
export function getEmployeeSimpleList(token: string) { return request<EmployeeSimple[]>("/hrm/employee/simple-list", { header: header(token) }); }
export function getSalaryStructureList(token: string) { return request<SimpleOption[]>(`/hrm/salary/structure/list${query({ status: 0 })}`, { header: header(token) }); }
export function getAutoApprovalPolicy(token: string) { return request<boolean>("/bpm/process-auto-approve/ui-policy", { header: header(token) }); }
export function getAttendanceMyStatus(token: string, date?: string) { return request<AttendanceMyStatus>(`/hrm/attendance/record/my-status${query({ date })}`, { header: header(token) }); }
export function clockIn(token: string, data: AttendanceClockRequest) { return request<AttendanceClockResponse>("/hrm/attendance/record/clock-in", { method: "POST", data, header: header(token) }); }
export function clockOut(token: string, data: AttendanceClockRequest) { return request<AttendanceClockResponse>("/hrm/attendance/record/clock-out", { method: "POST", data, header: header(token) }); }

export function uploadHrmFile(token: string, filePath: string) {
  return new Promise<HrmAttachment>((resolve, reject) => {
    uni.uploadFile({
      url: `${API_BASE_URL}/system/storage-blob/upload`,
      filePath,
      name: "files",
      header: header(token),
      formData: { directory: "hrm" },
      success: response => {
        try {
          const result = JSON.parse(response.data) as ApiResponse<HrmAttachment[]>;
          if (result.code === 0 && result.data?.[0]) resolve(result.data[0]);
          else reject(new Error(result.msg || "文件上传失败"));
        } catch {
          reject(new Error("文件上传响应解析失败"));
        }
      },
      fail: () => reject(new Error("文件上传失败，请检查网络后重试"))
    });
  });
}

export function chooseHrmFiles(count = 10): Promise<Array<{ path: string; name?: string }>> {
  return new Promise((resolve, reject) => {
    const complete = (files: Array<{ path: string; name?: string }>) => resolve(files.filter(item => Boolean(item.path)));
    // #ifdef MP-WEIXIN
    uni.chooseMessageFile({ count, type: "file", success: result => complete((result.tempFiles || []).map(item => ({ path: item.path, name: item.name }))), fail: reject });
    // #endif
    // #ifndef MP-WEIXIN
    uni.chooseFile({ count, success: result => complete((result.tempFiles || []).map(item => ({ path: item.path, name: item.name }))), fail: reject });
    // #endif
  });
}

export function getEmployeePage(token: string, params: { pageNo: number; pageSize: number; name?: string; employeeNo?: string; employeeStatus?: number }) { return request<PageResult<Employee>>(`/hrm/employee/page${query(params)}`, { header: header(token) }); }
export function getEmployee(token: string, id: number) { return request<Employee>(`/hrm/employee/get${query({ id })}`, { header: header(token) }); }
export function createEmployee(token: string, data: Employee) { return request<number>("/hrm/employee/create", { method: "POST", data, header: header(token) }); }
export function updateEmployee(token: string, data: Employee) { return request<boolean>("/hrm/employee/update", { method: "PUT", data, header: header(token) }); }
export function deleteEmployee(token: string, id: number) { return request<boolean>(`/hrm/employee/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }

export function getContractPage(token: string, params: { pageNo: number; pageSize: number; contractNo?: string; employeeId?: number; status?: number }) { return request<PageResult<EmployeeContract>>(`/hrm/employee-contract/page${query(params)}`, { header: header(token) }); }
export function getContract(token: string, id: number) { return request<EmployeeContract>(`/hrm/employee-contract/get${query({ id })}`, { header: header(token) }); }
export function createContract(token: string, data: EmployeeContract) { return request<number>("/hrm/employee-contract/create", { method: "POST", data, header: header(token) }); }
export function updateContract(token: string, data: EmployeeContract) { return request<boolean>("/hrm/employee-contract/update", { method: "PUT", data, header: header(token) }); }
export function terminateContract(token: string, data: { id: number; terminateStatus: number; terminateDate: string; terminateReason: string }) { return request<boolean>("/hrm/employee-contract/terminate", { method: "PUT", data, header: header(token) }); }
export function deleteContract(token: string, id: number) { return request<boolean>(`/hrm/employee-contract/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }

export function getLeavePage(token: string, params: { pageNo: number; pageSize: number; userId?: number; leaveType?: number; status?: number }) { return request<PageResult<Leave>>(`/hrm/leave/page${query(params)}`, { header: header(token) }); }
export function getLeave(token: string, id: number) { return request<Leave>(`/hrm/leave/get${query({ id })}`, { header: header(token) }); }
export function createLeave(token: string, data: Leave) { return request<number>("/hrm/leave/create", { method: "POST", data, header: header(token) }); }
export function updateLeave(token: string, data: Leave) { return request<boolean>("/hrm/leave/update", { method: "PUT", data, header: header(token) }); }
export function deleteLeave(token: string, id: number) { return request<boolean>(`/hrm/leave/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function submitLeave(token: string, id: number, processDefinitionKey: string) { return request<boolean>(`/hrm/leave/submit${query({ id, processDefinitionKey })}`, { method: "POST", header: header(token) }); }
export function getLeaveProcesses(token: string) { return request<ApproveProcess[]>("/hrm/leave/approve-process-definition-list", { header: header(token) }); }

export function getTransferPage(token: string, params: { pageNo: number; pageSize: number; userId?: number; transferType?: number; status?: number }) { return request<PageResult<Transfer>>(`/hrm/transfer/page${query(params)}`, { header: header(token) }); }
export function getTransfer(token: string, id: number) { return request<Transfer>(`/hrm/transfer/get${query({ id })}`, { header: header(token) }); }
export function createTransfer(token: string, data: Transfer) { return request<number>("/hrm/transfer/create", { method: "POST", data, header: header(token) }); }
export function updateTransfer(token: string, data: Transfer) { return request<boolean>("/hrm/transfer/update", { method: "PUT", data, header: header(token) }); }
export function deleteTransfer(token: string, id: number) { return request<boolean>(`/hrm/transfer/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function submitTransfer(token: string, id: number, processDefinitionKey: string) { return request<boolean>(`/hrm/transfer/submit${query({ id, processDefinitionKey })}`, { method: "POST", header: header(token) }); }
export function getTransferProcesses(token: string) { return request<ApproveProcess[]>("/hrm/transfer/approve-process-definition-list", { header: header(token) }); }

export function getResignationPage(token: string, params: { pageNo: number; pageSize: number; userId?: number; resignationType?: number; status?: number }) { return request<PageResult<Resignation>>(`/hrm/resignation/page${query(params)}`, { header: header(token) }); }
export function getResignation(token: string, id: number) { return request<Resignation>(`/hrm/resignation/get${query({ id })}`, { header: header(token) }); }
export function createResignation(token: string, data: Resignation) { return request<number>("/hrm/resignation/create", { method: "POST", data, header: header(token) }); }
export function updateResignation(token: string, data: Resignation) { return request<boolean>("/hrm/resignation/update", { method: "PUT", data, header: header(token) }); }
export function deleteResignation(token: string, id: number) { return request<boolean>(`/hrm/resignation/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function submitResignation(token: string, id: number, processDefinitionKey: string) { return request<boolean>(`/hrm/resignation/submit${query({ id, processDefinitionKey })}`, { method: "POST", header: header(token) }); }
export function getResignationProcesses(token: string) { return request<ApproveProcess[]>("/hrm/resignation/approve-process-definition-list", { header: header(token) }); }
export function updateResignationHandover(token: string, data: { id: number; handoverStatus: number }) { return request<boolean>("/hrm/resignation/handover", { method: "PUT", data, header: header(token) }); }

export function getOvertimePage(token: string, params: { pageNo: number; pageSize: number; userId?: number; overtimeType?: number; status?: number }) { return request<PageResult<Overtime>>(`/hrm/overtime/page${query(params)}`, { header: header(token) }); }
export function getOvertime(token: string, id: number) { return request<Overtime>(`/hrm/overtime/get${query({ id })}`, { header: header(token) }); }
export function getCurrentOvertimeApplicant(token: string) { return request<Partial<Overtime>>("/hrm/overtime/current-applicant", { header: header(token) }); }
export function createOvertime(token: string, data: Overtime) { return request<number>("/hrm/overtime/create", { method: "POST", data, header: header(token) }); }
export function updateOvertime(token: string, data: Overtime) { return request<boolean>("/hrm/overtime/update", { method: "PUT", data, header: header(token) }); }
export function deleteOvertime(token: string, id: number) { return request<boolean>(`/hrm/overtime/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function submitOvertime(token: string, id: number, processDefinitionKey: string) { return request<boolean>(`/hrm/overtime/submit${query({ id, processDefinitionKey })}`, { method: "POST", header: header(token) }); }
export function cancelOvertime(token: string, id: number) { return request<boolean>(`/hrm/overtime/cancel${query({ id })}`, { method: "POST", header: header(token) }); }
export function getOvertimeProcesses(token: string) { return request<ApproveProcess[]>("/hrm/overtime/approve-process-definition-list", { header: header(token) }); }

// HRM management modules
export interface HrmRow { id?: number; [key: string]: unknown }
export interface Shift extends HrmRow { name?: string; startTime?: string; endTime?: string; workHours?: number; crossDay?: boolean; color?: string; status?: number; remark?: string }
export interface Holiday extends HrmRow { name?: string; startDate?: string; endDate?: string; type?: number; typeName?: string; isLegal?: number; remark?: string }
export interface AttendanceSummary extends HrmRow { userId?: number; userName?: string; deptId?: number; deptName?: string; yearMonth?: string; workDays?: number; actualDays?: number; lateCount?: number; earlyCount?: number; absentCount?: number; overtimeHours?: number; leaveHours?: number; remark?: string }
export interface AttendanceException extends HrmRow { userId?: number; userName?: string; deptName?: string; date?: string; exceptionType?: number; exceptionTypeName?: string; reason?: string; blobIds?: number[]; attachmentList?: HrmAttachment[]; status?: number; processInstanceId?: string; remark?: string; createTime?: string }
export interface EmployeeSchedule extends HrmRow { employeeId?: number; employeeName?: string; employeeNo?: string; date?: string; shiftId?: number; shiftName?: string; shiftColor?: string; remark?: string }
export interface SalaryStructure extends HrmRow { name?: string; overtimePayRatio?: number; restDayOvertimePayRatio?: number; legalHolidayOvertimePayRatio?: number; status?: number; remark?: string }
export interface SocialSecurityScheme extends HrmRow { name?: string; effectiveDate?: string; pensionCompanyRatio?: number; pensionPersonalRatio?: number; medicalCompanyRatio?: number; medicalPersonalRatio?: number; unemploymentCompanyRatio?: number; unemploymentPersonalRatio?: number; workInjuryRatio?: number; maternityRatio?: number; seriousIllnessCompanyRatio?: number; seriousIllnessPersonalRatio?: number; longTermCareCompanyRatio?: number; longTermCarePersonalRatio?: number; housingFundCompanyRatio?: number; housingFundPersonalRatio?: number; status?: number; remark?: string }
export interface TaxRateConfig extends HrmRow { name?: string; effectiveDate?: string; level?: number; minAmount?: number; maxAmount?: number; taxRate?: number; quickDeduction?: number }
export interface LeaveTypeConfig extends HrmRow { leaveType?: number; name?: string; deductionRatio?: number; remark?: string; status?: number }
export interface EmployeeSocialSecurity extends HrmRow { userId?: number; userName?: string; deptName?: string; socialSecuritySchemeId?: number; schemeName?: string; socialSecurityBase?: number; housingFundBase?: number; effectiveDate?: string; status?: number; remark?: string }
export interface SalaryCalculation extends HrmRow { no?: string; period?: string; userId?: number; userName?: string; deptId?: number; deptName?: string; baseSalary?: number; postSalary?: number; senioritySalary?: number; performanceSalary?: number; fullAttendanceBonus?: number; overtimePay?: number; mealAllowance?: number; transportAllowance?: number; otherAllowance?: number; socialSecurityDeduction?: number; housingFundDeduction?: number; taxDeduction?: number; otherDeduction?: number; leaveDeduction?: number; actualSalary?: number; workDays?: number; actualDays?: number; overtimeHours?: number; totalWorkHours?: number; status?: number; statusName?: string; remark?: string; createTime?: string }
export interface SalaryPayment extends HrmRow { no?: string; period?: string; totalAmount?: number; totalCount?: number; paymentMethod?: number; paymentTime?: string; status?: number; blobIds?: number[]; attachmentList?: HrmAttachment[]; remark?: string; createTime?: string }
export interface SalaryPaymentDetail extends SalaryCalculation { paymentId?: number; calculationId?: number; paymentTime?: string }

export function getShiftPage(token: string, params: Record<string, unknown>) { return request<PageResult<Shift>>(`/hrm/shift/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function getShiftList(token: string) { return request<Shift[]>("/hrm/shift/list", { header: header(token) }); }
export function getShift(token: string, id: number) { return request<Shift>(`/hrm/shift/get${query({ id })}`, { header: header(token) }); }
export function createShift(token: string, data: Shift) { return request<number>("/hrm/shift/create", { method: "POST", data: data as Record<string, unknown>, header: header(token) }); }
export function updateShift(token: string, data: Shift) { return request<boolean>("/hrm/shift/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function deleteShift(token: string, id: number) { return request<boolean>(`/hrm/shift/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getEmployeeScheduleList(token: string, params: { yearMonth: string; deptId?: number; employeeId?: number }) { return request<EmployeeSchedule[]>(`/hrm/employee-schedule/list${query(params)}`, { header: header(token) }); }
export function saveEmployeeSchedule(token: string, data: Array<{ employeeId: number; date: string; shiftId?: number | null; remark?: string }>) { return request<boolean>("/hrm/employee-schedule/save", { method: "POST", data: data as unknown as Record<string, unknown>, header: header(token) }); }

export function getAttendanceRulePage(token: string, params: Record<string, unknown>) { return request<PageResult<AttendanceRule>>(`/hrm/attendance/rule/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function getAttendanceRule(token: string, id: number) { return request<AttendanceRule>(`/hrm/attendance/rule/get${query({ id })}`, { header: header(token) }); }
export function createAttendanceRule(token: string, data: AttendanceRule) { return request<number>("/hrm/attendance/rule/create", { method: "POST", data: data as unknown as Record<string, unknown>, header: header(token) }); }
export function updateAttendanceRule(token: string, data: AttendanceRule) { return request<boolean>("/hrm/attendance/rule/update", { method: "PUT", data: data as unknown as Record<string, unknown>, header: header(token) }); }
export function deleteAttendanceRule(token: string, id: number) { return request<boolean>(`/hrm/attendance/rule/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getAttendanceRecordPage(token: string, params: Record<string, unknown>) { return request<PageResult<AttendanceRecord>>(`/hrm/attendance/record/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function getHolidayPage(token: string, params: Record<string, unknown>) { return request<PageResult<Holiday>>(`/hrm/attendance/holiday/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function getHoliday(token: string, id: number) { return request<Holiday>(`/hrm/attendance/holiday/get${query({ id })}`, { header: header(token) }); }
export function createHoliday(token: string, data: Holiday) { return request<number>("/hrm/attendance/holiday/create", { method: "POST", data: data as Record<string, unknown>, header: header(token) }); }
export function updateHoliday(token: string, data: Holiday) { return request<boolean>("/hrm/attendance/holiday/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function deleteHoliday(token: string, id: number) { return request<boolean>(`/hrm/attendance/holiday/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getAttendanceSummaryPage(token: string, params: Record<string, unknown>) { return request<PageResult<AttendanceSummary>>(`/hrm/attendance/summary/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function generateAttendanceSummary(token: string, params: { yearMonth: string; deptId?: number; userId?: number }) { return request<boolean>(`/hrm/attendance/summary/generate${query(params)}`, { method: "POST", header: header(token) }); }
export function getAttendanceExceptionPage(token: string, params: Record<string, unknown>) { return request<PageResult<AttendanceException>>(`/hrm/attendance/exception/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function getAttendanceException(token: string, id: number) { return request<AttendanceException>(`/hrm/attendance/exception/get${query({ id })}`, { header: header(token) }); }
export function createAttendanceException(token: string, data: AttendanceException) { return request<number>("/hrm/attendance/exception/create", { method: "POST", data: data as Record<string, unknown>, header: header(token) }); }
export function submitAttendanceException(token: string, id: number, processDefinitionKey: string) { return request<boolean>(`/hrm/attendance/exception/submit${query({ id, processDefinitionKey })}`, { method: "POST", header: header(token) }); }
export function getAttendanceExceptionProcesses(token: string) { return request<ApproveProcess[]>("/hrm/attendance/exception/approve-process-list", { header: header(token) }); }

export function getSalaryStructureRows(token: string, params: { name?: string; status?: number } = {}) { return request<SalaryStructure[]>(`/hrm/salary/structure/list${query(params)}`, { header: header(token) }); }
export function createSalaryStructure(token: string, data: SalaryStructure) { return request<number>("/hrm/salary/structure/create", { method: "POST", data: data as Record<string, unknown>, header: header(token) }); }
export function updateSalaryStructure(token: string, data: SalaryStructure) { return request<boolean>("/hrm/salary/structure/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function deleteSalaryStructure(token: string, id: number) { return request<boolean>(`/hrm/salary/structure/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getSocialSecuritySchemeList(token: string, params: { name?: string; status?: number } = {}) { return request<SocialSecurityScheme[]>(`/hrm/salary/social-security-scheme/list${query(params)}`, { header: header(token) }); }
export function createSocialSecurityScheme(token: string, data: SocialSecurityScheme) { return request<number>("/hrm/salary/social-security-scheme/create", { method: "POST", data: data as Record<string, unknown>, header: header(token) }); }
export function updateSocialSecurityScheme(token: string, data: SocialSecurityScheme) { return request<boolean>("/hrm/salary/social-security-scheme/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function deleteSocialSecurityScheme(token: string, id: number) { return request<boolean>(`/hrm/salary/social-security-scheme/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getTaxRateConfigList(token: string) { return request<TaxRateConfig[]>("/hrm/salary/tax-rate-config/list", { header: header(token) }); }
export function createTaxRateConfigList(token: string, data: TaxRateConfig[]) { return request<number>("/hrm/salary/tax-rate-config/create-list", { method: "POST", data: data as unknown as Record<string, unknown>, header: header(token) }); }
export function updateTaxRateConfig(token: string, data: TaxRateConfig) { return request<boolean>("/hrm/salary/tax-rate-config/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function deleteTaxRateConfig(token: string, id: number) { return request<boolean>(`/hrm/salary/tax-rate-config/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getLeaveTypeConfigList(token: string) { return request<LeaveTypeConfig[]>("/hrm/leave-type-config/list", { header: header(token) }); }
export function createLeaveTypeConfig(token: string, data: LeaveTypeConfig) { return request<number>("/hrm/leave-type-config/create", { method: "POST", data: data as Record<string, unknown>, header: header(token) }); }
export function updateLeaveTypeConfig(token: string, data: LeaveTypeConfig) { return request<boolean>("/hrm/leave-type-config/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function deleteLeaveTypeConfig(token: string, id: number) { return request<boolean>(`/hrm/leave-type-config/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getEmployeeSocialSecurityPage(token: string, params: Record<string, unknown>) { return request<PageResult<EmployeeSocialSecurity>>(`/hrm/salary/employee-social-security/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function getEmployeeSocialSecurityHistory(token: string, userId: number) { return request<EmployeeSocialSecurity[]>(`/hrm/salary/employee-social-security/list-by-user${query({ userId })}`, { header: header(token) }); }
export function createEmployeeSocialSecurity(token: string, data: EmployeeSocialSecurity) { return request<number>("/hrm/salary/employee-social-security/create", { method: "POST", data: data as Record<string, unknown>, header: header(token) }); }
export function updateEmployeeSocialSecurity(token: string, data: EmployeeSocialSecurity) { return request<boolean>("/hrm/salary/employee-social-security/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function deleteEmployeeSocialSecurity(token: string, id: number) { return request<boolean>(`/hrm/salary/employee-social-security/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getSalaryCalculationPage(token: string, params: Record<string, unknown>) { return request<PageResult<SalaryCalculation>>(`/hrm/salary/calculation/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function calculateSalary(token: string, params: { period: string; deptId?: number }) { return request<boolean>(`/hrm/salary/calculation/calculate${query(params)}`, { method: "POST", header: header(token) }); }
export function updateSalaryCalculation(token: string, data: SalaryCalculation) { return request<boolean>("/hrm/salary/calculation/update", { method: "PUT", data: data as Record<string, unknown>, header: header(token) }); }
export function confirmSalary(token: string, ids: number[]) { return request<boolean>("/hrm/salary/calculation/confirm", { method: "POST", data: { ids }, header: header(token) }); }
export function revokeSalary(token: string, ids: number[]) { return request<boolean>("/hrm/salary/calculation/revoke", { method: "POST", data: { ids }, header: header(token) }); }
export function deleteSalaryCalculation(token: string, id: number) { return request<boolean>(`/hrm/salary/calculation/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }
export function getSalaryPaymentPage(token: string, params: Record<string, unknown>) { return request<PageResult<SalaryPayment>>(`/hrm/salary/payment/page${query(params as Record<string, string | number | boolean | undefined>)}`, { header: header(token) }); }
export function getSalaryPaymentDetails(token: string, paymentId: number) { return request<SalaryPaymentDetail[]>(`/hrm/salary/payment/detail/list${query({ paymentId })}`, { header: header(token) }); }
export function generateSalaryPayment(token: string, period: string) { return request<number>(`/hrm/salary/payment/generate${query({ period })}`, { method: "POST", header: header(token) }); }
export function paySalary(token: string, id: number) { return request<boolean>(`/hrm/salary/payment/pay${query({ id })}`, { method: "POST", header: header(token) }); }
export function paySalaryDetails(token: string, detailIds: number[]) { return request<boolean>("/hrm/salary/payment/pay-detail", { method: "POST", data: { detailIds }, header: header(token) }); }
export function revokeSalaryPaymentDetails(token: string, detailIds: number[]) { return request<boolean>("/hrm/salary/payment/revoke-detail", { method: "POST", data: { detailIds }, header: header(token) }); }
export function deleteSalaryPayment(token: string, id: number) { return request<boolean>(`/hrm/salary/payment/delete${query({ id })}`, { method: "DELETE", header: header(token) }); }