135 lines
5.4 KiB
TypeScript
135 lines
5.4 KiB
TypeScript
import type { Request, Response } from 'express'
|
|
import { z } from 'zod'
|
|
import { VOCABULARIO, type MotivoNoCompra } from '../config/vocabulario.js'
|
|
import { prisma } from '../services/prisma.js'
|
|
import { crmLocal, esIdLocal } from '../services/crm-local.service.js'
|
|
import * as auditoria from '../services/auditoria.service.js'
|
|
|
|
/** Categorías del dropdown "Motivo No Compra" (vocabulario CRM FRASA) */
|
|
export const MOTIVOS_NO_COMPRA = VOCABULARIO.MOTIVOS_NO_COMPRA
|
|
|
|
/**
|
|
* Subcategorías por categoría, tomadas del catálogo del tablero de referencia
|
|
* "Motivos No Compra" del workspace CRM FRASA. NOTA: 'Mesualidad' y 'Cambo de
|
|
* Planes' llevan las faltas de ortografía originales del catálogo del cliente.
|
|
*/
|
|
export const SUBCATEGORIAS_NO_COMPRA: Record<MotivoNoCompra, readonly string[]> = VOCABULARIO.SUBCATEGORIAS
|
|
|
|
const perderSchema = z.object({
|
|
motivo: z.enum(MOTIVOS_NO_COMPRA),
|
|
comentario: z.string().optional(),
|
|
})
|
|
|
|
/**
|
|
* Marca una oportunidad como perdida (etapa 'Perdido' + motivo/submotivo en la
|
|
* fila local) y encola el DESCARTE. SIEMPRE local.
|
|
*/
|
|
export async function perderOportunidadEndpoint(req: Request, res: Response): Promise<void> {
|
|
const body = perderSchema.parse(req.body)
|
|
const mondayItemId = String(req.params['mondayItemId'])
|
|
await crmLocal.descartar(mondayItemId, body.motivo, {
|
|
fuente: 'oportunidad',
|
|
comentario: body.comentario,
|
|
usuarioId: req.usuarioToken?.sub,
|
|
sombra: !esIdLocal(mondayItemId),
|
|
})
|
|
res.json({ mondayItemId, etapa: 'Perdido', motivo: body.motivo, motivoItemId: null })
|
|
auditoria.registrar(req.usuarioToken?.sub ?? 'sistema', 'PERDER_OPORTUNIDAD', 'oportunidad', mondayItemId, body.motivo)
|
|
}
|
|
|
|
// ---------- Cambio de etapa desde Mi día ----------
|
|
|
|
/**
|
|
* Etapas del funnel que el asesor puede mover desde los botones de
|
|
* "Mis oportunidades" (vocabulario canónico del CRM — el frontend las manda
|
|
* tal cual).
|
|
*/
|
|
export const ETAPAS_OPORTUNIDAD_PERMITIDAS = VOCABULARIO.FASES_OPORTUNIDAD
|
|
|
|
const cambiarEtapaSchema = z.object({
|
|
etapa: z.enum(ETAPAS_OPORTUNIDAD_PERMITIDAS),
|
|
// En 'Agendo Cita' puede setear la fecha de la cita
|
|
fecha: z.string().optional(),
|
|
})
|
|
|
|
/**
|
|
* Estatus de inventario que un apartado nunca debe pisar: la unidad ya se
|
|
* vendió, se escrituró o no está a la venta (BLOQUEADO).
|
|
*/
|
|
export const STATUS_NO_BLOQUEABLES = ['VENDIDO', 'ESCRITURADO', 'BLOQUEADO']
|
|
|
|
/**
|
|
* Unidad asignada a la oportunidad, leída de su `datosJson` (la deja el alta de
|
|
* clientes / la afluencia) o, si no está ahí, de la cotización más reciente
|
|
* ligada a ella (`Cotizacion.mondayItemId`): el vendedor cotiza y después
|
|
* aparta, así que la unidad cotizada ES la que se está apartando.
|
|
*/
|
|
async function unidadDeOportunidad(itemId: string, datosJson: string | null): Promise<string | null> {
|
|
if (datosJson) {
|
|
try {
|
|
const datos = JSON.parse(datosJson) as Record<string, unknown>
|
|
if (typeof datos['unidadCodigo'] === 'string' && datos['unidadCodigo'].trim() !== '') {
|
|
return datos['unidadCodigo'].trim()
|
|
}
|
|
} catch { /* datosJson inválido: se ignora */ }
|
|
}
|
|
const cotizacion = await prisma.cotizacion.findFirst({
|
|
where: { mondayItemId: itemId },
|
|
orderBy: { createdAt: 'desc' },
|
|
select: { unidadCodigo: true },
|
|
})
|
|
const codigo = cotizacion?.unidadCodigo.trim()
|
|
return codigo !== undefined && codigo !== '' ? codigo : null
|
|
}
|
|
|
|
/**
|
|
* Cambio de etapa local: guarda la etapa en la fila local y encola
|
|
* CAMBIO_ETAPA. En 'Aparto' crea además el apartado local (crmLocal.apartar),
|
|
* dejando la unidad apartada en su `datosJson`.
|
|
* Devuelve el unidadCodigo de la oportunidad si existe (para bloquear la unidad).
|
|
*/
|
|
async function cambiarEtapaLocal(
|
|
itemId: string,
|
|
etapa: (typeof ETAPAS_OPORTUNIDAD_PERMITIDAS)[number],
|
|
fecha: string | undefined,
|
|
usuarioId: string | undefined,
|
|
): Promise<string | null> {
|
|
if (etapa === 'Aparto') {
|
|
const captura = await prisma.leadCaptura.findUnique({ where: { leadId: itemId } })
|
|
const unidadCodigo = await unidadDeOportunidad(itemId, captura?.datosJson ?? null)
|
|
await crmLocal.apartar(itemId, usuarioId, {
|
|
...(unidadCodigo !== null ? { unidadCodigo } : {}),
|
|
})
|
|
return unidadCodigo
|
|
}
|
|
await crmLocal.cambiarEstado(itemId, etapa, 'OPORTUNIDADES', {
|
|
fecha,
|
|
usuarioId,
|
|
sombra: !esIdLocal(itemId),
|
|
})
|
|
return null
|
|
}
|
|
|
|
/** POST /api/oportunidades/:itemId/etapa { etapa, fecha? } */
|
|
export async function cambiarEtapaOportunidadEndpoint(req: Request, res: Response): Promise<void> {
|
|
const body = cambiarEtapaSchema.parse(req.body)
|
|
const itemId = String(req.params['itemId'])
|
|
const unidadCodigo = await cambiarEtapaLocal(itemId, body.etapa, body.fecha, req.usuarioToken?.sub)
|
|
// Bloquear la unidad del inventario local si la oportunidad tiene una asignada.
|
|
// Nunca se degrada una unidad ya VENDIDA/ESCRITURADA/BLOQUEADA: el apartado
|
|
// solo bloquea inventario vendible.
|
|
if (body.etapa === 'Aparto' && unidadCodigo !== null) {
|
|
try {
|
|
await prisma.unidad.updateMany({
|
|
where: { codigo: unidadCodigo, status: { notIn: STATUS_NO_BLOQUEABLES } },
|
|
data: { status: 'APARTADO' },
|
|
})
|
|
} catch (err) {
|
|
// eslint-disable-next-line no-console
|
|
console.error(`No se pudo bloquear la unidad ${unidadCodigo} de la oportunidad ${itemId}:`, err)
|
|
}
|
|
}
|
|
res.json({ itemId, etapa: body.etapa, ...(body.fecha !== undefined ? { fecha: body.fecha } : {}) })
|
|
auditoria.registrar(req.usuarioToken?.sub ?? 'sistema', 'CAMBIAR_ETAPA', 'oportunidad', itemId, body.etapa)
|
|
}
|