400 lines
16 KiB
TypeScript
400 lines
16 KiB
TypeScript
import type { Pool } from 'pg';
|
|
|
|
// Mapeo: impuesto de la declaración → reglas para matchear obligaciones del
|
|
// contribuyente. `include` son substrings que DEBE contener el nombre de la
|
|
// obligación; `exclude` son substrings que NO debe contener. El exclude
|
|
// resuelve ambigüedades como "IVA" matcheando "Declaración de proveedores
|
|
// de IVA" (DIOT) — cuando subes pago de IVA normal, NO debe cerrar DIOT.
|
|
const IMPUESTO_A_OBLIGACION_KEYWORDS: Record<string, { include: string[]; exclude: string[] }> = {
|
|
IVA: { include: ['iva'], exclude: ['diot', 'proveedores de iva', 'informativa'] },
|
|
ISR: { include: ['isr'], exclude: ['retenciones', 'asimilados a salarios'] },
|
|
IEPS: { include: ['ieps'], exclude: [] },
|
|
SUELDOS: { include: ['sueldos', 'salarios', 'nómina'], exclude: [] },
|
|
DIOT: { include: ['diot', 'proveedores de iva'], exclude: [] },
|
|
OTRO: { include: [], exclude: [] },
|
|
};
|
|
|
|
/**
|
|
* After uploading a declaration, find matching obligations for the contribuyente
|
|
* and mark them as completed for the period. Also resolve the ob-* alerts.
|
|
*
|
|
* Guarda `declaracion_id` en `obligacion_periodos` para que la UI pueda
|
|
* mostrar "Completada via Declaración #123" y permitir cross-link. Si la
|
|
* declaración se borra, el FK pasa a NULL (ON DELETE SET NULL) y el
|
|
* periodo sigue marcado completado — el usuario decidirá si re-abrirlo
|
|
* manualmente.
|
|
*/
|
|
async function completarObligacionesPorDeclaracion(
|
|
pool: Pool,
|
|
contribuyenteId: string,
|
|
impuestos: string[],
|
|
periodo: string,
|
|
/** UUID del usuario que subió la declaración (obligacion_periodos.completada_por es uuid). */
|
|
completadaPor: string,
|
|
declaracionId: number,
|
|
/** Periodicidad de la declaración. Si no se provee, se asume 'mensual'. */
|
|
periodicidad: string = 'mensual',
|
|
): Promise<number> {
|
|
// Get active obligations for this contribuyente (incluye frecuencia para filtrar)
|
|
const { rows: obligaciones } = await pool.query<{ id: string; nombre: string; frecuencia: string | null }>(
|
|
`SELECT id, nombre, frecuencia FROM obligaciones_contribuyente WHERE contribuyente_id = $1 AND activa = true`,
|
|
[contribuyenteId],
|
|
);
|
|
|
|
let count = 0;
|
|
|
|
for (const impuesto of impuestos) {
|
|
const rules = IMPUESTO_A_OBLIGACION_KEYWORDS[impuesto];
|
|
if (!rules || rules.include.length === 0) continue;
|
|
|
|
for (const ob of obligaciones) {
|
|
const nombreLower = ob.nombre.toLowerCase();
|
|
const matches = rules.include.some(kw => nombreLower.includes(kw))
|
|
&& !rules.exclude.some(kw => nombreLower.includes(kw));
|
|
if (!matches) continue;
|
|
|
|
// Filtro por periodicidad/frecuencia: una declaración mensual no debe
|
|
// cerrar obligaciones anuales del mismo impuesto (ej. ISR mensual no
|
|
// cubre "Declaración anual de ISR"). Si la obligación tiene frecuencia
|
|
// explícita y no coincide con la periodicidad de la declaración, skip.
|
|
// `eventual` obligaciones no se tocan automáticamente.
|
|
const obFrec = (ob.frecuencia || '').toLowerCase();
|
|
if (obFrec === 'eventual') continue;
|
|
if (obFrec && obFrec !== periodicidad.toLowerCase()) continue;
|
|
|
|
// Mark obligation as completed for this period, with FK a la declaración
|
|
await pool.query(`
|
|
INSERT INTO obligacion_periodos (obligacion_id, periodo, completada, completada_at, completada_por, notas, declaracion_id)
|
|
VALUES ($1, $2, true, now(), $3, $4, $5)
|
|
ON CONFLICT (obligacion_id, periodo)
|
|
DO UPDATE SET completada = true, completada_at = now(), completada_por = $3, declaracion_id = $5
|
|
`, [ob.id, periodo, completadaPor, `Declaración ${impuesto} subida`, declaracionId]);
|
|
|
|
// Resolve the ob-* alert for this obligation+period
|
|
await pool.query(
|
|
`UPDATE alertas SET resuelta = true WHERE tipo = $1 AND resuelta = false`,
|
|
[`ob-${ob.id}-${periodo}`],
|
|
);
|
|
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Declaraciones provisionales: PDF subido por el contador con la declaración
|
|
* presentada al SAT + opcionalmente comprobante de pago. Al subir, se marcan
|
|
* como resueltas las alertas correspondientes en la tabla `alertas` del tenant.
|
|
*
|
|
* El método legacy "marcar como realizado" desde /alertas sigue funcionando
|
|
* para usuarios que no quieran subir el documento. Esta automatización es
|
|
* adicional, no reemplaza.
|
|
*/
|
|
|
|
export type Impuesto = 'IVA' | 'ISR' | 'IEPS' | 'SUELDOS' | 'DIOT' | 'OTRO';
|
|
|
|
export type Periodicidad = 'mensual' | 'bimestral' | 'trimestral' | 'semestral' | 'anual';
|
|
|
|
export interface DeclaracionRow {
|
|
id: number;
|
|
año: number;
|
|
mes: number;
|
|
tipo: 'normal' | 'complementaria';
|
|
periodicidad: Periodicidad;
|
|
impuestos: string[];
|
|
montoPago: number | null;
|
|
pdfFilename: string | null;
|
|
ligaPagoFilename: string | null;
|
|
pdfPagoFilename: string | null;
|
|
pagadoAt: string | null;
|
|
creadoPor: string | null;
|
|
notas: string | null;
|
|
createdAt: string;
|
|
updatedAt: string;
|
|
tieneLigaPago: boolean;
|
|
tienePagoPdf: boolean;
|
|
}
|
|
|
|
// Mapeo Impuesto → prefijo de tipo de alerta (debe coincidir con
|
|
// EVENTO_A_ALERTA en alertas-manuales.service.ts).
|
|
const IMPUESTO_A_PREFIJO_DECL: Record<string, string[]> = {
|
|
IVA: ['decl-iva'],
|
|
ISR: ['decl-isr'],
|
|
IEPS: ['decl-ieps'],
|
|
SUELDOS: ['decl-sueldos'],
|
|
DIOT: ['diot'],
|
|
OTRO: [],
|
|
};
|
|
const IMPUESTO_A_PREFIJO_PAGO: Record<string, string[]> = {
|
|
IVA: ['pago-iva'],
|
|
ISR: ['pago-isr'],
|
|
IEPS: ['pago-ieps'],
|
|
SUELDOS: [], // sueldos solo es declaración informativa, no tiene pago provisional
|
|
DIOT: [],
|
|
OTRO: [],
|
|
};
|
|
|
|
/**
|
|
* Marca como resueltas las alertas cuyo `tipo` empieza con cualquiera de los
|
|
* prefijos dados Y cuyo `fecha_vencimiento` cae en el mes/año dados.
|
|
* Idempotente: re-llamar no crea efectos secundarios extra.
|
|
*/
|
|
async function resolverAlertasPorPeriodo(
|
|
pool: Pool,
|
|
prefijos: string[],
|
|
año: number,
|
|
mes: number,
|
|
): Promise<number> {
|
|
if (prefijos.length === 0) return 0;
|
|
// El tipo es `prefijo-YYYY-MM-DD`. Buscar por LIKE prefijo-año-mes-%
|
|
const mesStr = String(mes).padStart(2, '0');
|
|
const conditions = prefijos.map((_, i) => `tipo LIKE $${i + 1}`).join(' OR ');
|
|
const params = prefijos.map(p => `${p}-${año}-${mesStr}-%`);
|
|
const { rowCount } = await pool.query(
|
|
`UPDATE alertas SET resuelta = true
|
|
WHERE (${conditions}) AND resuelta = false`,
|
|
params,
|
|
);
|
|
return rowCount ?? 0;
|
|
}
|
|
|
|
function rowToDeclaracion(r: any): DeclaracionRow {
|
|
return {
|
|
id: r.id,
|
|
año: r.año,
|
|
mes: r.mes,
|
|
tipo: r.tipo,
|
|
periodicidad: r.periodicidad || 'mensual',
|
|
impuestos: r.impuestos || [],
|
|
montoPago: r.monto_pago != null ? Number(r.monto_pago) : null,
|
|
pdfFilename: r.pdf_filename,
|
|
ligaPagoFilename: r.pdf_liga_pago_filename,
|
|
pdfPagoFilename: r.pdf_pago_filename,
|
|
pagadoAt: r.pagado_at?.toISOString() ?? null,
|
|
creadoPor: r.creado_por,
|
|
notas: r.notas,
|
|
createdAt: r.created_at.toISOString(),
|
|
updatedAt: r.updated_at.toISOString(),
|
|
tieneLigaPago: !!r.pdf_liga_pago_filename,
|
|
tienePagoPdf: !!r.pdf_pago_filename,
|
|
};
|
|
}
|
|
|
|
export async function listDeclaraciones(
|
|
pool: Pool,
|
|
fechaDesde?: string,
|
|
fechaHasta?: string,
|
|
contribuyenteId?: string | null,
|
|
): Promise<DeclaracionRow[]> {
|
|
const conditions: string[] = [];
|
|
const params: unknown[] = [];
|
|
|
|
if (fechaDesde) {
|
|
params.push(fechaDesde);
|
|
conditions.push(`created_at >= $${params.length}::date`);
|
|
}
|
|
if (fechaHasta) {
|
|
params.push(fechaHasta);
|
|
conditions.push(`created_at < ($${params.length}::date + interval '1 day')`);
|
|
}
|
|
if (contribuyenteId) {
|
|
// Sanitize UUID (hex + hyphens only)
|
|
const safe = contribuyenteId.replace(/[^a-f0-9-]/gi, '');
|
|
if (safe) {
|
|
params.push(safe);
|
|
conditions.push(`contribuyente_id = $${params.length}`);
|
|
}
|
|
}
|
|
|
|
const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
|
|
|
|
const { rows } = await pool.query(
|
|
`SELECT id, año, mes, tipo, periodicidad, impuestos, monto_pago, pdf_filename,
|
|
pdf_liga_pago_filename, pdf_pago_filename, pagado_at, creado_por, notas,
|
|
created_at, updated_at
|
|
FROM declaraciones_provisionales
|
|
${where}
|
|
ORDER BY created_at DESC, año DESC, mes DESC`,
|
|
params,
|
|
);
|
|
return rows.map(rowToDeclaracion);
|
|
}
|
|
|
|
export async function createDeclaracion(
|
|
pool: Pool,
|
|
data: {
|
|
año: number;
|
|
mes: number;
|
|
tipo: 'normal' | 'complementaria';
|
|
periodicidad?: Periodicidad;
|
|
impuestos: string[];
|
|
montoPago?: number | null;
|
|
pdfBase64: string; // PDF de la declaración (base64)
|
|
pdfFilename: string;
|
|
ligaPagoBase64?: string; // PDF de la liga de pago (opcional, base64)
|
|
ligaPagoFilename?: string;
|
|
notas?: string;
|
|
/** Email del usuario (para declaraciones_provisionales.creado_por VARCHAR). */
|
|
creadoPor: string;
|
|
/** UUID del usuario (para obligacion_periodos.completada_por UUID). Opcional. */
|
|
creadoPorUserId?: string;
|
|
contribuyenteId?: string;
|
|
},
|
|
): Promise<{ declaracion: DeclaracionRow; alertasResueltas: number }> {
|
|
const buf = Buffer.from(data.pdfBase64, 'base64');
|
|
const ligaBuf = data.ligaPagoBase64 ? Buffer.from(data.ligaPagoBase64, 'base64') : null;
|
|
const periodicidad = data.periodicidad || 'mensual';
|
|
const montoPago = data.montoPago ?? null;
|
|
// If monto_pago is exactly 0, auto-mark as paid (no payment receipt needed)
|
|
const pagadoAt = montoPago === 0 ? new Date() : null;
|
|
|
|
try {
|
|
const { rows } = await pool.query(
|
|
`INSERT INTO declaraciones_provisionales
|
|
(año, mes, tipo, periodicidad, impuestos, monto_pago, pdf_declaracion, pdf_filename,
|
|
pdf_liga_pago, pdf_liga_pago_filename, notas, creado_por, pagado_at, contribuyente_id)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
|
|
RETURNING id, año, mes, tipo, periodicidad, impuestos, monto_pago, pdf_filename,
|
|
pdf_liga_pago_filename, pdf_pago_filename, pagado_at, creado_por, notas,
|
|
created_at, updated_at`,
|
|
[data.año, data.mes, data.tipo, periodicidad, data.impuestos, montoPago,
|
|
buf, data.pdfFilename, ligaBuf, data.ligaPagoFilename ?? null,
|
|
data.notas ?? null, data.creadoPor, pagadoAt, data.contribuyenteId ?? null],
|
|
);
|
|
|
|
const declaracion = rowToDeclaracion(rows[0]);
|
|
|
|
// Auto-resolver alertas. Reglas:
|
|
// - tipo='normal': resuelve alertas de declaración (decl-*) del mes.
|
|
// El pago se resuelve por separado al subir comprobante.
|
|
// - tipo='complementaria': sustituye a la normal en términos de
|
|
// obligación de pago — al subirla se resuelven AMBAS (decl-* y
|
|
// pago-*) porque el cliente pagará usando la complementaria,
|
|
// no la normal. La alerta de declaración ya estaría resuelta
|
|
// si la normal se subió antes; el resolver es idempotente.
|
|
const prefijosDecl = data.impuestos.flatMap(i => IMPUESTO_A_PREFIJO_DECL[i] || []);
|
|
let alertasResueltas = await resolverAlertasPorPeriodo(pool, prefijosDecl, data.año, data.mes);
|
|
if (data.tipo === 'complementaria' || montoPago === 0) {
|
|
// complementaria: sustituye normal para pago → resolver ambas
|
|
// monto 0: nada que pagar → resolver alertas de pago también
|
|
const prefijosPago = data.impuestos.flatMap(i => IMPUESTO_A_PREFIJO_PAGO[i] || []);
|
|
alertasResueltas += await resolverAlertasPorPeriodo(pool, prefijosPago, data.año, data.mes);
|
|
}
|
|
|
|
// Auto-complete obligaciones del contribuyente SOLO si la declaración
|
|
// también cubre el pago (complementaria sustituye a la normal para el
|
|
// pago; monto=0 significa "nada que pagar"). Una declaración normal con
|
|
// monto>0 solo presenta el acuse — la obligación de pago sigue abierta
|
|
// y se marca completada hasta que se suba el comprobante via
|
|
// `uploadComprobantePago`. Esto mantiene las alertas `pago-*` y `ob-*`
|
|
// visibles hasta que realmente se cierre el ciclo.
|
|
const cubrePago = data.tipo === 'complementaria' || montoPago === 0;
|
|
if (data.contribuyenteId && cubrePago) {
|
|
if (!data.creadoPorUserId) {
|
|
console.warn('[createDeclaracion] Sin creadoPorUserId — no se auto-completan obligaciones del contribuyente');
|
|
} else {
|
|
const periodo = `${data.año}-${String(data.mes).padStart(2, '0')}`;
|
|
alertasResueltas += await completarObligacionesPorDeclaracion(
|
|
pool, data.contribuyenteId, data.impuestos, periodo, data.creadoPorUserId, declaracion.id, periodicidad,
|
|
);
|
|
}
|
|
}
|
|
|
|
return { declaracion, alertasResueltas };
|
|
} catch (err: any) {
|
|
if (err?.code === '23505') {
|
|
throw new Error(`Ya existe una declaración tipo "normal" para ${data.mes}/${data.año}. Solo se permite una normal por mes; agrega una complementaria si necesitas corregirla.`);
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
export async function uploadComprobantePago(
|
|
pool: Pool,
|
|
id: number,
|
|
data: {
|
|
pdfBase64: string;
|
|
pdfFilename: string;
|
|
/** UUID del usuario que sube el comprobante (para obligacion_periodos.completada_por). */
|
|
uploadedByUserId?: string;
|
|
},
|
|
): Promise<{ declaracion: DeclaracionRow; alertasResueltas: number }> {
|
|
const buf = Buffer.from(data.pdfBase64, 'base64');
|
|
|
|
const { rows } = await pool.query(
|
|
`UPDATE declaraciones_provisionales
|
|
SET pdf_pago = $1, pdf_pago_filename = $2, pagado_at = NOW(), updated_at = NOW()
|
|
WHERE id = $3
|
|
RETURNING id, año, mes, tipo, periodicidad, impuestos, pdf_filename, pdf_liga_pago_filename,
|
|
pdf_pago_filename, pagado_at, creado_por, notas, created_at, updated_at,
|
|
contribuyente_id`,
|
|
[buf, data.pdfFilename, id],
|
|
);
|
|
|
|
if (rows.length === 0) throw new Error('Declaración no encontrada');
|
|
const row = rows[0];
|
|
const declaracion = rowToDeclaracion(row);
|
|
|
|
// Auto-resolver alertas de pago para los impuestos del periodo
|
|
const prefijosPago = declaracion.impuestos.flatMap(i => IMPUESTO_A_PREFIJO_PAGO[i] || []);
|
|
let alertasResueltas = await resolverAlertasPorPeriodo(pool, prefijosPago, declaracion.año, declaracion.mes);
|
|
|
|
// Al subirse el comprobante de pago, la obligación ahora SÍ está completada
|
|
// (declaración + pago). Marcar `obligacion_periodos.completada=true` y
|
|
// resolver los `ob-*` alerts. Requires contribuyenteId (guardado en la
|
|
// declaración) y userId (del caller).
|
|
if (row.contribuyente_id && data.uploadedByUserId) {
|
|
const periodo = `${declaracion.año}-${String(declaracion.mes).padStart(2, '0')}`;
|
|
const periodicidad = row.periodicidad || 'mensual';
|
|
alertasResueltas += await completarObligacionesPorDeclaracion(
|
|
pool, row.contribuyente_id, declaracion.impuestos, periodo, data.uploadedByUserId, declaracion.id, periodicidad,
|
|
);
|
|
}
|
|
|
|
return { declaracion, alertasResueltas };
|
|
}
|
|
|
|
export async function deleteDeclaracion(pool: Pool, id: number): Promise<void> {
|
|
const { rowCount } = await pool.query(
|
|
`DELETE FROM declaraciones_provisionales WHERE id = $1`,
|
|
[id],
|
|
);
|
|
if (rowCount === 0) throw new Error('Declaración no encontrada');
|
|
}
|
|
|
|
/**
|
|
* Cleanup: borra declaraciones con created_at < hoy - 5 años. Cumple con
|
|
* el plazo de retención del Art. 30 del CFF (contabilidad por 5 años).
|
|
* Llamado por cron diario. Idempotente: si no hay viejas, no-op.
|
|
*
|
|
* Se ejecuta por-tenant (caller pasa el pool). Returns { deleted } para log.
|
|
*/
|
|
export async function purgeDeclaracionesAntiguas(pool: Pool): Promise<{ deleted: number }> {
|
|
const { rowCount } = await pool.query(
|
|
`DELETE FROM declaraciones_provisionales
|
|
WHERE created_at < NOW() - INTERVAL '5 years'`,
|
|
);
|
|
return { deleted: rowCount ?? 0 };
|
|
}
|
|
|
|
export async function getDeclaracionPdf(
|
|
pool: Pool,
|
|
id: number,
|
|
variant: 'declaracion' | 'liga' | 'pago',
|
|
): Promise<{ buffer: Buffer; filename: string } | null> {
|
|
const col =
|
|
variant === 'declaracion' ? 'pdf_declaracion' :
|
|
variant === 'liga' ? 'pdf_liga_pago' : 'pdf_pago';
|
|
const colName =
|
|
variant === 'declaracion' ? 'pdf_filename' :
|
|
variant === 'liga' ? 'pdf_liga_pago_filename' : 'pdf_pago_filename';
|
|
const { rows } = await pool.query(
|
|
`SELECT ${col} as data, ${colName} as filename FROM declaraciones_provisionales WHERE id = $1`,
|
|
[id],
|
|
);
|
|
if (rows.length === 0 || !rows[0].data) return null;
|
|
return { buffer: Buffer.from(rows[0].data), filename: rows[0].filename || `declaracion-${id}.pdf` };
|
|
}
|