Rapports de Dépenses

// Lister tous les rapports de l'entreprise
const { data: reports, pagination } = await client.expenseReports.list({
  page: 1,
  limit: 20,
});

// Rapports d'un employé
const { data: empReports } = await client.expenseReports.listForEmployée(employéeId, {
  limit: 10,
});

// Mes rapports
const myReports = await client.expenseReports.getMine({ status: 'draft' });

// Rapports en attente d'approbation
const pendingApprovals = await client.expenseReports.getPendingApprovals();

const report = await client.expenseReports.getById(reportId);
console.log(report.name, report.status, report.totalAmount);

const report = await client.expenseReports.create({
  name: 'Dépenses de voyage T1',
  description: 'Voyages d\'affaires janvier-mars',
});

const updated = await client.expenseReports.update(reportId, {
  name: 'Dépenses de voyage T1 (Modifie)',
});

await client.expenseReports.delete(reportId);

const submitted = await client.expenseReports.submit(reportId);

const approved = await client.expenseReports.approve(reportId, {
  comment: 'Tout est en ordre, approuvé.',
});

const rejected = await client.expenseReports.reject(reportId, {
  reason: 'Reçus manquants pour l\'hotel.',
});

const returned = await client.expenseReports.requestChanges(reportId, {
  comment: 'Veuillez joindre le reçu d\'inscription à la conference.',
});

const recalled = await client.expenseReports.recall(reportId, {
  reason: 'Je dois ajouter d\'autres dépenses.',
});

const reimbursed = await client.expenseReports.reimburse(reportId, {
  paymentMethod: 'bank_transfer',
});

const planned = await client.expenseReports.planReimbursement(reportId, {
  scheduledDate: '2025-04-15',
  paymentMethod: 'bank_transfer',
});

const comment = await client.expenseReports.addComment(reportId, {
  content: 'Veuillez vérifiér les frais d\'hotel à la ligne 3.',
});

const timeline = await client.expenseReports.getTimeline(reportId);
for (const entry of timeline) {
  console.log(`${entry.type}: ${entry.description} à ${entry.createdAt}`);
}

const auditLog = await client.expenseReports.getAuditLog(reportId);
for (const entry of auditLog) {
  console.log(`${entry.action} par ${entry.userId} à ${entry.timestamp}`);
}

await client.expenseReports.assignLedgerAccount(reportId, {
  ledgerAccountId: 500,
});

await client.expenseReports.assignExpenseLedgerAccount(reportId, expenseId, {
  ledgerAccountId: 501,
});

const summary = await client.expenseReports.getSummary();

const blob = await client.expenseReports.export({
  format: 'xlsx',
  startDate: '2025-01-01',
  endDate: '2025-03-31',
});

// Suppression en masse
const deleteResult = await client.expenseReports.bulkDelete({
  reportIds: [1, 2, 3],
});

// Soumission en masse
const submitResult = await client.expenseReports.bulkSubmit({
  reportIds: [4, 5, 6],
});

// Rappel en masse
const recallResult = await client.expenseReports.bulkRecall({
  reportIds: [7, 8],
});

await client.expenseReportExpenses.add(reportId, { expenseId: 456 });

await client.expenseReportExpenses.addBatch(reportId, {
  expenseIds: [456, 457, 458],
});

await client.expenseReportExpenses.edit(reportId, expenseId, {
  categoryId: 15,
  notes: 'Catégorie mise à jour',
});

await client.expenseReportExpenses.remove(reportId, expenseId);

await client.expenseReportExpenses.replace(reportId, ancienExpenseId, {
  newExpenseId: 999,
  categoryId: 15,
});

const result = await client.expenseReportExpenses.bulkAssignCategory(reportId, {
  expenseIds: [1, 2, 3],
  categoryId: 20,
});

const result = await client.expenseReportExpenses.bulkRemove(reportId, {
  expenseIds: [10, 11, 12],
});

await client.expenseReportExpenses.addForEmployée(employéeId, reportId, {
  expenseId: 456,
});

await client.expenseReportExpenses.removeForEmployée(employéeId, reportId, expenseId);

// Rembourser un rapport
await client.expenseReportPayments.reimburse(reportId);

// Remboursement partiel
await client.expenseReportPayments.partialReimburse(reportId, {
  amount: 150.00,
  paymentMethod: 'bank_transfer',
});

// Planifier le remboursement
await client.expenseReportPayments.planReimbursement(reportId, {
  scheduledDate: '2025-05-01',
  paymentMethod: 'cheque',
});