f1a9549b01
- ExceptionHandler : convertit les violations de contrainte unique PG (23505) en réponse `{ errors: [{ code: 'duplicate', field, message }] }` 422 au lieu d'un 500 avec stack pg-protocol. Extrait le nom de colonne via regex sur le `detail` PG.
- InvoicesController.store + ImportBatchesController.validateDraft : wrap les appels schedulers (Redis side-effect, hors tx) dans try/catch + logger.warn. Si Redis flanche, l'invoice est créée et la requête HTTP retourne 201 normalement — l'utilisateur peut re-déclencher la programmation plus tard. Évite qu'une panne Redis casse le path de saisie.
380 lines
11 KiB
TypeScript
380 lines
11 KiB
TypeScript
import Invoice from '#models/invoice'
|
|
import Plan from '#models/plan'
|
|
import InvoiceTransformer from '#transformers/invoice_transformer'
|
|
import {
|
|
createInvoiceValidator,
|
|
listInvoicesValidator,
|
|
} from '#validators/invoice'
|
|
import type { HttpContext } from '@adonisjs/core/http'
|
|
import { Exception } from '@adonisjs/core/exceptions'
|
|
import db from '@adonisjs/lucid/services/db'
|
|
import { DateTime } from 'luxon'
|
|
import { resolveClient } from '#services/resolve_client'
|
|
import { recordActivity } from '#services/activity_recorder'
|
|
import {
|
|
scheduleRelancesForInvoice,
|
|
cancelFutureRelances,
|
|
} from '#services/relance_scheduler'
|
|
import {
|
|
scheduleCheckinForInvoice,
|
|
cancelCheckinForInvoice,
|
|
} from '#services/checkin_scheduler'
|
|
import logger from '@adonisjs/core/services/logger'
|
|
|
|
const PAGE_SIZE = 50
|
|
|
|
// Priorité d'affichage côté liste : ce qui est actionnable d'abord.
|
|
const STATUS_PRIORITY: Record<string, number> = {
|
|
awaiting_user_confirmation: 0,
|
|
in_relance: 1,
|
|
pending: 2,
|
|
litigation: 3,
|
|
paid: 4,
|
|
cancelled: 5,
|
|
}
|
|
|
|
function requireOrgId(auth: HttpContext['auth']): string {
|
|
const user = auth.getUserOrFail()
|
|
if (!user.organizationId) {
|
|
throw new Exception('Aucune organisation rattachée', { status: 404, code: 'not_found' })
|
|
}
|
|
return user.organizationId
|
|
}
|
|
|
|
function serializeInvoice(i: Invoice) {
|
|
return new InvoiceTransformer(i).toObject()
|
|
}
|
|
|
|
/**
|
|
* Construit la timeline d'une facture en composant les étapes du plan
|
|
* avec l'état courant (V1 simplifié — les RelanceTask viendront plus tard).
|
|
*
|
|
* - étapes dont sendDay <= aujourd'hui : 'past' (envoyées)
|
|
* - étape actuelle (la prochaine future) : 'current'
|
|
* - étapes futures : 'future'
|
|
*/
|
|
function buildTimeline(invoice: Invoice): Array<{
|
|
id: string
|
|
state: 'past' | 'current' | 'future'
|
|
when: string
|
|
what: string
|
|
}> {
|
|
const events: Array<{
|
|
id: string
|
|
state: 'past' | 'current' | 'future'
|
|
when: string
|
|
what: string
|
|
}> = [
|
|
{
|
|
id: `${invoice.id}__issued`,
|
|
state: 'past',
|
|
when: `${formatShortDate(invoice.issueDate)} · facture émise`,
|
|
what: 'Importée',
|
|
},
|
|
]
|
|
|
|
if (
|
|
invoice.plan?.steps?.length &&
|
|
invoice.status !== 'paid' &&
|
|
invoice.status !== 'cancelled'
|
|
) {
|
|
const dueMs = invoice.dueDate.toMillis()
|
|
const nowMs = DateTime.now().toMillis()
|
|
let currentSet = false
|
|
|
|
for (const step of invoice.plan.steps.slice().sort((a, b) => a.order - b.order)) {
|
|
const sendMs = dueMs + step.offsetDays * 24 * 60 * 60 * 1000
|
|
const stepDate = DateTime.fromMillis(sendMs)
|
|
const labelStep = `J${step.offsetDays >= 0 ? '+' : ''}${step.offsetDays} — Étape ${step.order + 1}`
|
|
|
|
let state: 'past' | 'current' | 'future'
|
|
if (sendMs < nowMs) state = 'past'
|
|
else if (!currentSet) {
|
|
state = 'current'
|
|
currentSet = true
|
|
} else state = 'future'
|
|
|
|
events.push({
|
|
id: `${invoice.id}__step_${step.order}`,
|
|
state,
|
|
when: `${formatShortDate(stepDate)} · ${labelStep}`,
|
|
what:
|
|
state === 'past'
|
|
? `Email envoyé · "${step.subject.replace('{{numero}}', invoice.numero)}"`
|
|
: `Email programmé · "${step.subject.replace('{{numero}}', invoice.numero)}"`,
|
|
})
|
|
}
|
|
}
|
|
|
|
if (invoice.status === 'paid' && invoice.paidAt) {
|
|
events.push({
|
|
id: `${invoice.id}__paid`,
|
|
state: 'past',
|
|
when: `${formatShortDate(invoice.paidAt)} · facture encaissée`,
|
|
what: 'Marquée encaissée — relances stoppées',
|
|
})
|
|
}
|
|
|
|
return events
|
|
}
|
|
|
|
function formatShortDate(d: DateTime): string {
|
|
return d.toFormat('dd/LL/yyyy')
|
|
}
|
|
|
|
export default class InvoicesController {
|
|
/**
|
|
* GET /invoices?status=&q=&clientId=&page=
|
|
*/
|
|
async index({ auth, request, response }: HttpContext) {
|
|
const organizationId = requireOrgId(auth)
|
|
const filters = await request.validateUsing(listInvoicesValidator)
|
|
|
|
const query = Invoice.query()
|
|
.where('organization_id', organizationId)
|
|
.preload('client')
|
|
.preload('plan')
|
|
|
|
if (filters.status && filters.status !== 'all') {
|
|
query.where('status', filters.status)
|
|
}
|
|
if (filters.clientId) {
|
|
query.where('client_id', filters.clientId)
|
|
}
|
|
if (filters.q) {
|
|
const q = filters.q.toLowerCase()
|
|
query.where((b) => {
|
|
b.whereILike('numero', `%${q}%`).orWhereExists((sub) => {
|
|
sub
|
|
.from('clients')
|
|
.whereColumn('clients.id', 'invoices.client_id')
|
|
.whereILike('clients.name', `%${q}%`)
|
|
})
|
|
})
|
|
}
|
|
|
|
const invoices = await query.exec()
|
|
|
|
// Tri : actionnable d'abord (status priority), puis échéance croissante.
|
|
invoices.sort((a, b) => {
|
|
const dp = (STATUS_PRIORITY[a.status] ?? 99) - (STATUS_PRIORITY[b.status] ?? 99)
|
|
if (dp !== 0) return dp
|
|
return a.dueDate.toMillis() - b.dueDate.toMillis()
|
|
})
|
|
|
|
// Pagination simple en V1 (cf. backend.md §6 — cursor-based plus tard).
|
|
const page = filters.page ?? 1
|
|
const total = invoices.length
|
|
const sliced = invoices.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE)
|
|
|
|
return response.json({
|
|
data: sliced.map(serializeInvoice),
|
|
meta: { total, page },
|
|
})
|
|
}
|
|
|
|
/**
|
|
* GET /invoices/counts — compteurs par statut pour les chips dashboard.
|
|
*/
|
|
async counts({ auth, response }: HttpContext) {
|
|
const organizationId = requireOrgId(auth)
|
|
|
|
const rows = await db
|
|
.from('invoices')
|
|
.where('organization_id', organizationId)
|
|
.select('status')
|
|
.count('* as count')
|
|
.groupBy('status')
|
|
|
|
const counts = {
|
|
all: 0,
|
|
pending: 0,
|
|
in_relance: 0,
|
|
awaiting_user_confirmation: 0,
|
|
paid: 0,
|
|
litigation: 0,
|
|
cancelled: 0,
|
|
}
|
|
for (const r of rows) {
|
|
const c = Number(r.count)
|
|
counts.all += c
|
|
const s = r.status as keyof typeof counts
|
|
if (s in counts) counts[s] = c
|
|
}
|
|
|
|
return response.json({ data: counts })
|
|
}
|
|
|
|
/**
|
|
* GET /invoices/:id — détail enrichi (client + plan + timeline).
|
|
*/
|
|
async show({ auth, params, response }: HttpContext) {
|
|
const organizationId = requireOrgId(auth)
|
|
|
|
const invoice = await Invoice.query()
|
|
.where('organization_id', organizationId)
|
|
.where('id', params.id)
|
|
.preload('client')
|
|
.preload('plan', (q) => q.preload('steps'))
|
|
.first()
|
|
|
|
if (!invoice) {
|
|
throw new Exception('Facture introuvable', { status: 404, code: 'not_found' })
|
|
}
|
|
|
|
const data = serializeInvoice(invoice)
|
|
return response.json({
|
|
data: {
|
|
...data,
|
|
client: invoice.client && {
|
|
id: invoice.client.id,
|
|
name: invoice.client.name,
|
|
email: invoice.client.email,
|
|
phone: invoice.client.phone,
|
|
address: invoice.client.address,
|
|
siret: invoice.client.siret,
|
|
},
|
|
plan: invoice.plan && {
|
|
id: invoice.plan.id,
|
|
slug: invoice.plan.slug,
|
|
name: invoice.plan.name,
|
|
steps: (invoice.plan.steps ?? [])
|
|
.slice()
|
|
.sort((a, b) => a.order - b.order)
|
|
.map((s) => ({
|
|
id: s.id,
|
|
order: s.order,
|
|
offsetDays: s.offsetDays,
|
|
tone: s.tone,
|
|
subject: s.subject,
|
|
body: s.body,
|
|
requiresManualValidation: s.requiresManualValidation,
|
|
})),
|
|
},
|
|
timeline: buildTimeline(invoice),
|
|
},
|
|
})
|
|
}
|
|
|
|
/**
|
|
* POST /invoices — saisie manuelle.
|
|
*/
|
|
async store({ auth, request, response }: HttpContext) {
|
|
const organizationId = requireOrgId(auth)
|
|
const fields = await request.validateUsing(createInvoiceValidator)
|
|
|
|
const invoice = await db.transaction(async (trx) => {
|
|
const result = await resolveClient(organizationId, fields, trx)
|
|
if ('errorCode' in result) {
|
|
throw new Exception(
|
|
'Email du client requis — Rubis en a besoin pour envoyer les relances.',
|
|
{ status: 422, code: result.errorCode }
|
|
)
|
|
}
|
|
const client = result.client
|
|
|
|
// Vérification plan (s'il est fourni, doit appartenir à l'org).
|
|
let planId: string | null = null
|
|
if (fields.planId) {
|
|
const plan = await Plan.query({ client: trx })
|
|
.where('organization_id', organizationId)
|
|
.where('id', fields.planId)
|
|
.first()
|
|
if (plan) planId = plan.id
|
|
}
|
|
|
|
return Invoice.create(
|
|
{
|
|
organizationId,
|
|
clientId: client.id,
|
|
planId,
|
|
numero: fields.numero,
|
|
amountTtcCents: fields.amountTtcCents,
|
|
issueDate: DateTime.fromISO(fields.issueDate),
|
|
dueDate: DateTime.fromISO(fields.dueDate),
|
|
status: 'pending',
|
|
rubisEarned: 1, // bonus saisie initiale (cf. CLAUDE.md → glossaire)
|
|
pdfStorageKey: null,
|
|
notes: null,
|
|
paidAt: null,
|
|
},
|
|
{ client: trx }
|
|
)
|
|
})
|
|
|
|
await invoice.load('client')
|
|
await invoice.load('plan')
|
|
|
|
// Programme les relances BullMQ si la facture a un plan + le check-in
|
|
// (envoyé pile à dueDate). Hors tx — Redis ne participe pas aux
|
|
// garanties DB. On ne fait pas planter la requête HTTP si Redis est
|
|
// down : la facture est créée, l'utilisateur peut re-déclencher la
|
|
// programmation plus tard.
|
|
try {
|
|
if (invoice.planId) {
|
|
await scheduleRelancesForInvoice(invoice)
|
|
}
|
|
await scheduleCheckinForInvoice(invoice)
|
|
} catch (err) {
|
|
logger.warn({ err, invoiceId: invoice.id }, 'failed to schedule relances/checkin')
|
|
}
|
|
|
|
return response.status(201).json({ data: serializeInvoice(invoice) })
|
|
}
|
|
|
|
/**
|
|
* POST /invoices/:id/mark-paid
|
|
* Marque encaissée + bonus +1 rubis (à la fois sur invoice.rubisEarned
|
|
* et sur organization.rubisCount). Annule toutes les relances futures.
|
|
*/
|
|
async markPaid({ auth, params, response }: HttpContext) {
|
|
const organizationId = requireOrgId(auth)
|
|
|
|
const invoice = await Invoice.query()
|
|
.where('organization_id', organizationId)
|
|
.where('id', params.id)
|
|
.preload('client')
|
|
.preload('plan')
|
|
.first()
|
|
|
|
if (!invoice) {
|
|
throw new Exception('Facture introuvable', { status: 404, code: 'not_found' })
|
|
}
|
|
if (invoice.status === 'paid') {
|
|
// Idempotent : déjà payée, on renvoie l'état courant sans bumper.
|
|
return response.json({ data: serializeInvoice(invoice) })
|
|
}
|
|
|
|
await db.transaction(async (trx) => {
|
|
invoice.useTransaction(trx)
|
|
invoice.status = 'paid'
|
|
invoice.paidAt = DateTime.now()
|
|
invoice.rubisEarned = invoice.rubisEarned + 1
|
|
await invoice.save()
|
|
|
|
// Bump du compteur agrégé sur l'organisation
|
|
await trx
|
|
.from('organizations')
|
|
.where('id', organizationId)
|
|
.increment('rubis_count', 1)
|
|
|
|
// Journal d'activité (cf. dashboard activity feed).
|
|
await recordActivity({
|
|
organizationId,
|
|
kind: 'invoice_paid',
|
|
label: `Facture <b>${invoice.numero}</b> marquée encaissée`,
|
|
meta: { invoiceId: invoice.id, clientId: invoice.clientId },
|
|
trx,
|
|
})
|
|
|
|
// Annule toutes les relances + le check-in programmés pour cette
|
|
// facture (idempotent, BullMQ.remove peut échouer silencieusement
|
|
// si le job a déjà été consommé).
|
|
await cancelFutureRelances(invoice.id, trx)
|
|
await cancelCheckinForInvoice(invoice.id, trx)
|
|
})
|
|
|
|
return response.json({ data: serializeInvoice(invoice) })
|
|
}
|
|
}
|