VPS 4 Builder
675 lines
27 KiB
JavaScript
675 lines
27 KiB
JavaScript
'use strict'
|
|
|
|
const Cotacao = require('../models/Cotacao')
|
|
const Pedido = require('../models/Pedido')
|
|
const Produto = require('../models/Produto')
|
|
const Promotion = require('../models/Promotion')
|
|
const CotacaoFlashPromo = require('../models/CotacaoFlashPromo')
|
|
const Notification = require('../models/Notification')
|
|
const { queryOne: dbQueryOne, query: dbQuery } = require('../database/postgres')
|
|
|
|
// Notifica o WA-Inbox que um agente foi atribuído a um pedido (best-effort)
|
|
async function notifyNwAssignAgent(pedidoId, accountId) {
|
|
if (!accountId) return
|
|
try {
|
|
const cfgRows = await dbQuery(`SELECT key, value FROM plugin_configs WHERE plugin_id='newwhats'`)
|
|
const cfg = {}
|
|
for (const r of cfgRows) cfg[r.key] = r.value
|
|
if (!cfg.newwhats_url || !cfg.integration_key) return
|
|
|
|
// Busca chat_id vinculado ao pedido e dados do account
|
|
const pedido = await dbQueryOne('SELECT chat_id FROM pedidos WHERE id=$1', [pedidoId])
|
|
const account = await dbQueryOne('SELECT id, name FROM accounts WHERE id=$1', [accountId])
|
|
if (!pedido?.chat_id || !account) return
|
|
|
|
await fetch(`${cfg.newwhats_url}/api/ext/v1/protocol/assign-agent`, {
|
|
method: 'PATCH',
|
|
headers: { 'Content-Type': 'application/json', 'x-nw-key': cfg.integration_key },
|
|
body: JSON.stringify({ chatId: pedido.chat_id, agentId: String(account.id), agentName: account.name }),
|
|
})
|
|
} catch { /* best-effort: nunca bloqueia o fluxo principal */ }
|
|
}
|
|
|
|
// Aplica preço promocional se existir (PROMO-03)
|
|
async function resolverPreco(produtoId, tenantId) {
|
|
const prod = await Produto.findById(produtoId)
|
|
if (!prod) return null
|
|
return {
|
|
preco_unitario: Number(prod.preco),
|
|
preco_promocional: prod.preco_promocional ? Number(prod.preco_promocional) : null,
|
|
nome_produto: prod.nome,
|
|
sku: prod.sku,
|
|
}
|
|
}
|
|
|
|
// Desconto por volume PJ (PROMO-05): >10 itens = 3%, >30 = 5%, >50 = 8%
|
|
function descontoPorVolume(tipo, quantidade) {
|
|
if (tipo !== 'PJ') return 0
|
|
if (quantidade >= 50) return 8
|
|
if (quantidade >= 30) return 5
|
|
if (quantidade >= 10) return 3
|
|
return 0
|
|
}
|
|
|
|
const cotacaoController = {
|
|
// ── Área do cliente ───────────────────────────────────────
|
|
|
|
async minhas(req, res) {
|
|
try {
|
|
const rows = await Cotacao.listByUser(req.user.id, req.tenant.id)
|
|
res.json(rows)
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao listar cotações' })
|
|
}
|
|
},
|
|
|
|
async getCotacao(req, res) {
|
|
try {
|
|
const cotacao = await Cotacao.findById(req.params.id)
|
|
if (!cotacao) return res.status(404).json({ error: 'Cotação não encontrada' })
|
|
const itens = await Cotacao.listItens(req.params.id)
|
|
res.json({ ...cotacao, itens })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao buscar cotação' })
|
|
}
|
|
},
|
|
|
|
async criarOuObterRascunho(req, res) {
|
|
try {
|
|
const tenantId = req.tenant.id
|
|
const userId = req.user.id
|
|
|
|
// Busca rascunho aberto do usuário
|
|
const [rascunho] = await Cotacao.listByUser(userId, tenantId)
|
|
.then(rows => rows.filter(r => r.status === 'rascunho'))
|
|
|
|
if (rascunho) {
|
|
const itens = await Cotacao.listItens(rascunho.id)
|
|
return res.json({ ...rascunho, itens })
|
|
}
|
|
|
|
const nova = await Cotacao.create({ tenant_id: tenantId, user_id: userId })
|
|
res.status(201).json({ ...nova, itens: [] })
|
|
} catch (err) {
|
|
console.error('[cotacao.rascunho]', err.message)
|
|
res.status(500).json({ error: 'Erro ao criar carrinho' })
|
|
}
|
|
},
|
|
|
|
async addItem(req, res) {
|
|
try {
|
|
const { cotacao_id, produto_id, quantidade } = req.body
|
|
if (!cotacao_id || !produto_id || !quantidade) {
|
|
return res.status(400).json({ error: 'cotacao_id, produto_id e quantidade são obrigatórios' })
|
|
}
|
|
const cotacao = await Cotacao.findById(cotacao_id)
|
|
if (!cotacao) return res.status(404).json({ error: 'Cotação não encontrada' })
|
|
|
|
const info = await resolverPreco(produto_id, req.tenant.id)
|
|
if (!info) return res.status(404).json({ error: 'Produto não encontrado' })
|
|
|
|
const desconto_pct = descontoPorVolume(cotacao.cliente_tipo, quantidade)
|
|
|
|
const item = await Cotacao.addItem({
|
|
cotacao_id,
|
|
produto_id,
|
|
...info,
|
|
quantidade,
|
|
desconto_pct,
|
|
})
|
|
await Cotacao.recalcTotal(cotacao_id)
|
|
res.status(201).json(item)
|
|
} catch (err) {
|
|
console.error('[cotacao.addItem]', err.message)
|
|
res.status(500).json({ error: 'Erro ao adicionar item' })
|
|
}
|
|
},
|
|
|
|
async removeItem(req, res) {
|
|
try {
|
|
await Cotacao.removeItem(req.params.itemId)
|
|
await Cotacao.recalcTotal(req.params.cotacaoId)
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao remover item' })
|
|
}
|
|
},
|
|
|
|
async updateItemObs(req, res) {
|
|
try {
|
|
const { itemId } = req.params
|
|
const { observacao } = req.body
|
|
await Cotacao.updateItemObs(itemId, observacao)
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao salvar observação' })
|
|
}
|
|
},
|
|
|
|
async salvar(req, res) {
|
|
try {
|
|
const { id } = req.params
|
|
await Cotacao.update(id, { ...(await Cotacao.findById(id)), status: 'salva' })
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao salvar cotação' })
|
|
}
|
|
},
|
|
|
|
async finalizar(req, res) {
|
|
try {
|
|
const { id } = req.params
|
|
const { forma_pagto, endereco_id, tipo_entrega, observacao, endereco } = req.body
|
|
|
|
if (!forma_pagto) return res.status(400).json({ error: 'forma_pagto é obrigatória' })
|
|
|
|
const cotacao = await Cotacao.findById(id)
|
|
if (!cotacao) return res.status(404).json({ error: 'Cotação não encontrada' })
|
|
if (cotacao.status === 'finalizada') return res.status(409).json({ error: 'Cotação já finalizada' })
|
|
|
|
await Cotacao.update(id, { ...cotacao, forma_pagto })
|
|
const pedido = await Cotacao.toOrder(id, { endereco_id, tipo_entrega, observacao })
|
|
|
|
// Endereço inline (sem endereco_id salvo)
|
|
if (endereco && tipo_entrega === 'entrega') {
|
|
await Pedido.updateAddressInline(pedido.id, endereco)
|
|
}
|
|
|
|
// Pagamento na entrega → aguarda aprovação financeira
|
|
if (forma_pagto === 'na_entrega') {
|
|
const { execute } = require('../database/postgres')
|
|
await execute(
|
|
`UPDATE pedidos SET financeiro_status='pendente', updated_at=NOW() WHERE id=$1`,
|
|
[pedido.id]
|
|
)
|
|
}
|
|
|
|
res.status(201).json(pedido)
|
|
} catch (err) {
|
|
console.error('[cotacao.finalizar]', err.message)
|
|
res.status(500).json({ error: 'Erro ao finalizar cotação' })
|
|
}
|
|
},
|
|
|
|
// ── Admin — financeiro ────────────────────────────────────
|
|
|
|
async listFinanceiro(req, res) {
|
|
try {
|
|
const { limit, offset } = req.query
|
|
const rows = await Pedido.listFinanceiro(req.tenant.id, { limit, offset })
|
|
res.json(rows)
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao listar pendências financeiras' })
|
|
}
|
|
},
|
|
|
|
async financeiroDecisao(req, res) {
|
|
try {
|
|
const { id } = req.params
|
|
const { acao, obs } = req.body
|
|
if (!['aprovar', 'rejeitar'].includes(acao)) {
|
|
return res.status(400).json({ error: 'acao deve ser aprovar ou rejeitar' })
|
|
}
|
|
const pedido = await Pedido.findById(id)
|
|
if (!pedido) return res.status(404).json({ error: 'Pedido não encontrado' })
|
|
if (pedido.financeiro_status !== 'pendente') {
|
|
return res.status(409).json({ error: 'Pedido já foi avaliado pelo financeiro' })
|
|
}
|
|
await Pedido.financeiroDecisao(id, { acao, obs })
|
|
res.json({ ok: true, acao })
|
|
} catch (err) {
|
|
console.error('[cotacao.financeiroDecisao]', err.message)
|
|
res.status(500).json({ error: 'Erro ao processar decisão financeira' })
|
|
}
|
|
},
|
|
|
|
// ── Admin — pedidos ───────────────────────────────────────
|
|
|
|
async listPedidos(req, res) {
|
|
try {
|
|
const { status, limit, offset } = req.query
|
|
const rows = await Pedido.listAdmin(req.tenant.id, { status, limit, offset })
|
|
res.json(rows)
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao listar pedidos' })
|
|
}
|
|
},
|
|
|
|
async getPedido(req, res) {
|
|
try {
|
|
const pedido = await Pedido.findById(req.params.id)
|
|
if (!pedido) return res.status(404).json({ error: 'Pedido não encontrado' })
|
|
const [itens, historico_responsaveis] = await Promise.all([
|
|
Pedido.listItens(req.params.id),
|
|
Pedido.findHistorico(req.params.id),
|
|
])
|
|
res.json({ ...pedido, itens, historico_responsaveis })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao buscar pedido' })
|
|
}
|
|
},
|
|
|
|
async updateStatusPedido(req, res) {
|
|
try {
|
|
const { status, responsavel_entrega } = req.body
|
|
const statusValidos = ['aguardando','separacao','embalagem','auditoria','fiscal','expedicao','entregue','cancelado']
|
|
if (!statusValidos.includes(status)) return res.status(400).json({ error: 'Status inválido' })
|
|
|
|
const { expedidor_id } = req.body
|
|
const accountId = expedidor_id
|
|
? parseInt(expedidor_id)
|
|
: (req.admin?.id || req.teamAccount?.accountId || null)
|
|
if (status === 'entregue') {
|
|
await Pedido.marcarEntregue(req.params.id, responsavel_entrega || null, accountId)
|
|
} else {
|
|
await Pedido.updateStatus(req.params.id, status, accountId)
|
|
}
|
|
|
|
// Notificação interna para o usuário (user_id) que fez o pedido
|
|
const STATUS_NOTIF = {
|
|
separacao: { title: '📦 Pedido em separação', message: (p) => `Seu pedido ${p.protocolo || '#'+p.id} está sendo preparado.` },
|
|
embalagem: { title: '📦 Pedido em embalagem', message: (p) => `Seu pedido ${p.protocolo || '#'+p.id} está sendo embalado.` },
|
|
expedicao: { title: '🚚 Pedido saiu para entrega', message: (p) => `Seu pedido ${p.protocolo || '#'+p.id} saiu para entrega. Fique de olho!` },
|
|
entregue: { title: '✅ Pedido marcado como entregue', message: (p) => `Seu pedido ${p.protocolo || '#'+p.id} foi marcado como entregue. Se não recebeu, entre em contato.` },
|
|
cancelado: { title: '❌ Pedido cancelado', message: (p) => `Seu pedido ${p.protocolo || '#'+p.id} foi cancelado. Fale conosco se precisar de ajuda.` },
|
|
auditoria: { title: '🔍 Pedido em auditoria', message: (p) => `Seu pedido ${p.protocolo || '#'+p.id} está em verificação final.` },
|
|
fiscal: { title: '🧾 Pedido em processamento fiscal', message: (p) => `Seu pedido ${p.protocolo || '#'+p.id} está na etapa fiscal.` },
|
|
}
|
|
if (STATUS_NOTIF[status]) {
|
|
setImmediate(async () => {
|
|
try {
|
|
const pedido = await Pedido.findById(req.params.id)
|
|
if (!pedido?.user_id) return
|
|
const userRow = await dbQueryOne('SELECT cpf FROM users WHERE id = $1', [pedido.user_id])
|
|
if (!userRow?.cpf) return
|
|
const notif = STATUS_NOTIF[status]
|
|
await Notification.create({
|
|
user_cpf: userRow.cpf.replace(/\D/g, ''),
|
|
title: notif.title,
|
|
message: notif.message(pedido),
|
|
type: status === 'cancelado' ? 'error' : status === 'entregue' ? 'success' : 'info',
|
|
})
|
|
} catch { /* silent */ }
|
|
})
|
|
}
|
|
|
|
// WPP-08 — notifica cliente por WhatsApp em mudanças de status relevantes
|
|
const STATUS_MSG = {
|
|
separacao: (p) => `📦 *Pedido #${p.id}${p.protocolo ? ` (${p.protocolo})` : ''} em separação!*\nEstamos preparando seu pedido. Em breve está pronto! 😊`,
|
|
expedicao: (p) => `🚚 *Pedido #${p.id}${p.protocolo ? ` (${p.protocolo})` : ''} saiu para entrega!*\nEm breve chegará até você. Qualquer dúvida, fale conosco! 🛵`,
|
|
entregue: (p) => `✅ *Pedido #${p.id} entregue com sucesso!*\nObrigado pela confiança! Ficamos felizes em servir você. ⭐`,
|
|
cancelado: (p) => `❌ *Pedido #${p.id} cancelado.*\nPrecisa de ajuda? Fale conosco aqui pelo WhatsApp.`,
|
|
}
|
|
if (STATUS_MSG[status]) {
|
|
setImmediate(async () => {
|
|
try {
|
|
const pedido = await Pedido.findById(req.params.id)
|
|
if (!pedido?.cliente_id) return
|
|
const { query: dbQuery } = require('../database/postgres')
|
|
const tels = await dbQuery(
|
|
`SELECT numero FROM cliente_telefones WHERE cliente_id = $1 AND aceita_whatsapp = true ORDER BY principal DESC LIMIT 1`,
|
|
[pedido.cliente_id]
|
|
)
|
|
if (!tels.length) return
|
|
const numero = tels[0].numero.replace(/\D/g, '')
|
|
const msg = STATUS_MSG[status](pedido)
|
|
const apiUrl = process.env.NEWWHATS_API_URL
|
|
if (!apiUrl) return
|
|
await fetch(`${apiUrl}/send`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${process.env.NEWWHATS_API_KEY || ''}` },
|
|
body: JSON.stringify({ phone: `55${numero}`, message: msg }),
|
|
}).catch(() => {})
|
|
} catch { /* silent — notificação não deve travar o fluxo */ }
|
|
})
|
|
}
|
|
|
|
// Notifica WA-Inbox (best-effort)
|
|
if (accountId) setImmediate(() => notifyNwAssignAgent(req.params.id, accountId))
|
|
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
console.error('[pedido.updateStatus]', err.message)
|
|
res.status(500).json({ error: 'Erro ao atualizar status' })
|
|
}
|
|
},
|
|
|
|
// EMB-02 — registra embalador; aceita embalador_id (account FK) ou texto legado
|
|
async marcarEmbalado(req, res) {
|
|
try {
|
|
const { embalador, embalador_id } = req.body
|
|
if (!embalador && !embalador_id) return res.status(400).json({ error: 'embalador ou embalador_id é obrigatório' })
|
|
// accountId: preferência para embalador_id explícito, depois token do colaborador logado
|
|
const accountId = embalador_id
|
|
? parseInt(embalador_id)
|
|
: (req.admin?.id || req.teamAccount?.accountId || null)
|
|
await Pedido.marcarEmbalado(req.params.id, embalador || null, accountId)
|
|
if (accountId) setImmediate(() => notifyNwAssignAgent(req.params.id, accountId))
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao registrar embalagem' })
|
|
}
|
|
},
|
|
|
|
// Lista colaboradores disponíveis para uma função operacional. A regra é
|
|
// direta: o colaborador aparece se está vinculado (team_members) a um setor
|
|
// cujo nome bate com a função. Cada função aceita variações de nome para
|
|
// tolerar grafias comuns ("Separação"/"Separacao"/"Separar"). Setor é a fonte
|
|
// da verdade — gerenciado em /admin-v2/equipe; nada para configurar em Settings.
|
|
async colaboradoresDisponiveis(req, res) {
|
|
try {
|
|
const SETOR_POR_FUNCAO = {
|
|
separador: ['separação','separacao','separar','separador'],
|
|
embalador: ['embalagem','embalador','embalar'],
|
|
auditor: ['auditoria','auditor','auditar'],
|
|
fiscal: ['fiscal','fiscalização','fiscalizacao'],
|
|
expedidor: ['expedição','expedicao','entrega','expedidor','motoboy','entregador'],
|
|
}
|
|
const funcao = String(req.query.funcao || '').toLowerCase()
|
|
const aliases = SETOR_POR_FUNCAO[funcao]
|
|
if (!aliases) {
|
|
return res.status(400).json({ error: 'Função inválida', funcoes_validas: Object.keys(SETOR_POR_FUNCAO) })
|
|
}
|
|
const tenantId = req.tenant.id
|
|
|
|
// Coluna de FK no pedido para contar pedidos ativos por colaborador
|
|
const FK = {
|
|
separador: 'separador_id', embalador: 'embalador_id',
|
|
auditor: 'auditor_id', fiscal: 'fiscal_id',
|
|
expedidor: 'expedidor_id',
|
|
}[funcao]
|
|
|
|
// Match case-insensitive contra os aliases do setor.
|
|
// DISTINCT ON evita duplicar colaborador que esteja em mais de um setor compatível.
|
|
const colaboradores = await dbQuery(`
|
|
SELECT DISTINCT ON (a.id)
|
|
a.id, a.name, a.email, a.role, a.availability, a.avatar_url, a.phone_connected,
|
|
COALESCE(BOOL_OR(tm.on_duty) OVER (PARTITION BY a.id), FALSE) AS on_duty,
|
|
s.name AS sector_match,
|
|
(SELECT COUNT(*)::int
|
|
FROM pedidos p
|
|
WHERE p.tenant_id = $1
|
|
AND p.${FK} = a.id
|
|
AND p.status NOT IN ('entregue','cancelado')) AS pedidos_ativos,
|
|
(SELECT MAX(created_at)
|
|
FROM pedidos p
|
|
WHERE p.tenant_id = $1
|
|
AND p.${FK} = a.id) AS ultimo_pedido_em
|
|
FROM accounts a
|
|
JOIN team_members tm ON tm.account_id = a.id
|
|
JOIN sectors s ON s.id = tm.sector_id
|
|
WHERE a.tenant_id = $1
|
|
AND a.active = TRUE
|
|
AND s.active = TRUE
|
|
AND LOWER(s.name) = ANY($2::text[])
|
|
ORDER BY a.id, a.name
|
|
`, [tenantId, aliases])
|
|
|
|
// Reordena no Node (simples e legível) — disponível primeiro, depois ocupado, offline por último.
|
|
colaboradores.sort((x, y) => {
|
|
const r = (a) => a.availability === 'online' ? 0 : a.availability === 'busy' ? 1 : 2
|
|
const d = r(x) - r(y)
|
|
return d !== 0 ? d : x.name.localeCompare(y.name)
|
|
})
|
|
|
|
res.json({
|
|
configurado: true,
|
|
setores_aceitos: aliases,
|
|
colaboradores,
|
|
})
|
|
} catch (err) {
|
|
console.error('[colaboradoresDisponiveis]', err.message)
|
|
res.status(500).json({ error: 'Erro ao listar colaboradores' })
|
|
}
|
|
},
|
|
|
|
// Endpoint genérico para registrar separador/auditor/fiscal num pedido.
|
|
// Embalagem (mudança de status) usa marcarEmbalado; expedição usa marcarEntregue.
|
|
async setResponsavelEtapa(req, res) {
|
|
try {
|
|
const FUNCOES_VALIDAS = ['separador','auditor','fiscal']
|
|
const funcao = String(req.params.funcao || '').toLowerCase()
|
|
if (!FUNCOES_VALIDAS.includes(funcao)) {
|
|
return res.status(400).json({ error: 'Função inválida' })
|
|
}
|
|
const accountId = req.body.account_id ? parseInt(req.body.account_id) : null
|
|
if (!accountId) return res.status(400).json({ error: 'account_id é obrigatório' })
|
|
|
|
// Valida que o colaborador pertence ao tenant antes de gravar
|
|
const acc = await dbQueryOne(
|
|
`SELECT id FROM accounts WHERE id=$1 AND tenant_id=$2 AND active=TRUE`,
|
|
[accountId, req.tenant.id]
|
|
)
|
|
if (!acc) return res.status(404).json({ error: 'Colaborador não encontrado' })
|
|
|
|
await Pedido.setResponsavel(req.params.id, funcao, accountId)
|
|
setImmediate(() => notifyNwAssignAgent(req.params.id, accountId))
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
console.error('[setResponsavelEtapa]', err.message)
|
|
res.status(500).json({ error: 'Erro ao atribuir responsável' })
|
|
}
|
|
},
|
|
|
|
// Registra cupom fiscal emitido externamente (PDV/ECF).
|
|
// Aceita em qualquer fase pós-pagamento — validação leve para não bloquear
|
|
// workflow real do operador. Pode ser sobrescrito (re-emissão por erro).
|
|
async registrarCupomFiscal(req, res) {
|
|
try {
|
|
const id = req.params.id
|
|
const { numero, chave } = req.body || {}
|
|
|
|
const num = String(numero || '').trim()
|
|
const chave44 = String(chave || '').replace(/\D/g, '')
|
|
|
|
if (!num && !chave44) {
|
|
return res.status(400).json({ error: 'Informe o número do cupom ou a chave de acesso (44 dígitos).' })
|
|
}
|
|
if (chave44 && chave44.length !== 44) {
|
|
return res.status(400).json({ error: 'Chave de acesso NFC-e deve ter 44 dígitos.' })
|
|
}
|
|
|
|
const pedido = await Pedido.findById(id)
|
|
if (!pedido) return res.status(404).json({ error: 'Pedido não encontrado' })
|
|
if (pedido.tenant_id !== req.tenant.id) return res.status(403).json({ error: 'Acesso negado' })
|
|
if (['cancelado'].includes(pedido.status)) {
|
|
return res.status(409).json({ error: 'Pedido cancelado — não é possível emitir cupom.' })
|
|
}
|
|
|
|
const accountId = req.admin?.id || req.teamAccount?.accountId || null
|
|
await Pedido.registrarCupom(id, { numero: num || null, chave: chave44 || null, accountId })
|
|
|
|
const atualizado = await Pedido.findById(id)
|
|
res.json({
|
|
ok: true,
|
|
cupom_numero: atualizado.cupom_numero,
|
|
cupom_chave: atualizado.cupom_chave,
|
|
cupom_emitido_em: atualizado.cupom_emitido_em,
|
|
cupom_emitido_por: atualizado.cupom_emitido_por,
|
|
cupom_emitido_por_nome: atualizado.cupom_emitido_por_nome,
|
|
})
|
|
} catch (err) {
|
|
console.error('[registrarCupomFiscal]', err.message)
|
|
res.status(500).json({ error: 'Erro ao registrar cupom fiscal' })
|
|
}
|
|
},
|
|
|
|
async atribuirEquipe(req, res) {
|
|
try {
|
|
await Pedido.atribuirEquipe(req.params.id, req.body.equipe_id)
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao atribuir equipe' })
|
|
}
|
|
},
|
|
|
|
async marcarItemSeparado(req, res) {
|
|
try {
|
|
await Pedido.marcarItemSeparado(req.params.itemId, req.body.separado !== false)
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao marcar item' })
|
|
}
|
|
},
|
|
|
|
async setAlertaItem(req, res) {
|
|
try {
|
|
const { tipo, obs, foto } = req.body
|
|
const TIPOS = ['falta', 'marca_diferente', 'substituicao']
|
|
if (!TIPOS.includes(tipo)) return res.status(400).json({ error: 'tipo inválido: falta | marca_diferente | substituicao' })
|
|
await Pedido.setAlertaItem(req.params.itemId, { tipo, obs, foto })
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao salvar alerta' })
|
|
}
|
|
},
|
|
|
|
async limparAlertaItem(req, res) {
|
|
try {
|
|
await Pedido.limparAlertaItem(req.params.itemId)
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao limpar alerta' })
|
|
}
|
|
},
|
|
|
|
async confirmarAlertaItem(req, res) {
|
|
try {
|
|
await Pedido.confirmarAlertaItem(req.params.itemId)
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao confirmar alerta' })
|
|
}
|
|
},
|
|
|
|
// DASH-04 — notificações internas de novos pedidos
|
|
async notificacoes(req, res) {
|
|
try {
|
|
const minutes = Math.min(Number(req.query.minutes) || 1440, 10080) // max 7 dias
|
|
const rows = await Pedido.notificacoes(req.tenant.id, minutes)
|
|
res.json(rows)
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao buscar notificações' })
|
|
}
|
|
},
|
|
|
|
async contadores(req, res) {
|
|
try {
|
|
const dados = await Pedido.contadores(req.tenant.id)
|
|
// Promoções ativas (PROMO-09)
|
|
const promos = await Promotion.findAllActive(req.tenant.id)
|
|
res.json({ ...dados, promocoes_ativas: promos.length })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao buscar contadores' })
|
|
}
|
|
},
|
|
|
|
// PROMO-10 — Flash promo ativa para o checkout da cotação
|
|
async getFlashPromo(req, res) {
|
|
try {
|
|
const promo = await CotacaoFlashPromo.getActive(req.tenant?.id ?? 1)
|
|
res.json(promo ?? null)
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao buscar flash promo' })
|
|
}
|
|
},
|
|
|
|
async createFlashPromo(req, res) {
|
|
try {
|
|
const { produto_id, discount_pct, label, duration_minutes } = req.body
|
|
if (!discount_pct || !duration_minutes) {
|
|
return res.status(400).json({ error: 'discount_pct e duration_minutes são obrigatórios' })
|
|
}
|
|
const result = await CotacaoFlashPromo.create({
|
|
tenantId: req.tenant?.id ?? 1,
|
|
produtoId: produto_id || null,
|
|
discount_pct,
|
|
label,
|
|
duration_minutes,
|
|
})
|
|
res.status(201).json(result)
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao criar flash promo' })
|
|
}
|
|
},
|
|
|
|
async cancelFlashPromo(req, res) {
|
|
try {
|
|
await CotacaoFlashPromo.cancel(req.params.id)
|
|
res.json({ ok: true })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao cancelar flash promo' })
|
|
}
|
|
},
|
|
|
|
// FUT-04/05 — Ranking de equipes e relatório de performance
|
|
async rankingEquipes(req, res) {
|
|
try {
|
|
const { query } = require('../database/postgres')
|
|
const { from, to } = req.query
|
|
const params = [req.tenant.id]
|
|
let where = 'WHERE p.tenant_id = $1'
|
|
if (from) { params.push(from); where += ` AND DATE(p.created_at) >= $${params.length}` }
|
|
if (to) { params.push(to); where += ` AND DATE(p.created_at) <= $${params.length}` }
|
|
|
|
const ranking = await query(
|
|
`SELECT
|
|
p.equipe_id,
|
|
COUNT(*) FILTER (WHERE p.status = 'entregue') AS pedidos_entregues,
|
|
COUNT(*) FILTER (WHERE p.status NOT IN ('cancelado','aguardando')) AS pedidos_processados,
|
|
ROUND(AVG(EXTRACT(EPOCH FROM (p.entregue_em - p.created_at))/3600)::NUMERIC, 1) AS media_horas_entrega,
|
|
COUNT(*) FILTER (WHERE p.embalador IS NOT NULL) AS pedidos_embalados,
|
|
MIN(p.created_at)::DATE AS primeiro_pedido,
|
|
MAX(p.created_at)::DATE AS ultimo_pedido
|
|
FROM pedidos p
|
|
${where}
|
|
AND p.equipe_id IS NOT NULL
|
|
GROUP BY p.equipe_id
|
|
ORDER BY pedidos_entregues DESC`,
|
|
params
|
|
)
|
|
res.json(ranking)
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao buscar ranking' })
|
|
}
|
|
},
|
|
|
|
async relatorioSetor(req, res) {
|
|
try {
|
|
const { query } = require('../database/postgres')
|
|
const { from, to } = req.query
|
|
const params = [req.tenant.id]
|
|
let where = 'WHERE tenant_id = $1'
|
|
if (from) { params.push(from); where += ` AND DATE(created_at) >= $${params.length}` }
|
|
if (to) { params.push(to); where += ` AND DATE(created_at) <= $${params.length}` }
|
|
|
|
const [volumeStatus, volumeDia, top_total] = await Promise.all([
|
|
query(
|
|
`SELECT status, COUNT(*) AS total, SUM(total) AS receita
|
|
FROM pedidos ${where} GROUP BY status ORDER BY total DESC`,
|
|
params
|
|
),
|
|
query(
|
|
`SELECT DATE(created_at) AS dia, COUNT(*) AS pedidos, SUM(total) AS receita
|
|
FROM pedidos ${where} GROUP BY DATE(created_at) ORDER BY dia DESC LIMIT 30`,
|
|
params
|
|
),
|
|
query(
|
|
`SELECT cl.nome AS cliente, COUNT(*) AS pedidos, SUM(p.total) AS gasto
|
|
FROM pedidos p
|
|
LEFT JOIN clientes cl ON cl.id = p.cliente_id
|
|
${where} AND p.status = 'entregue'
|
|
GROUP BY cl.nome ORDER BY gasto DESC LIMIT 10`,
|
|
params
|
|
),
|
|
])
|
|
|
|
res.json({ volume_por_status: volumeStatus, volume_por_dia: volumeDia, top_clientes: top_total })
|
|
} catch (err) {
|
|
res.status(500).json({ error: 'Erro ao buscar relatório' })
|
|
}
|
|
},
|
|
}
|
|
|
|
module.exports = cotacaoController
|