gustavosantos/COMERCIAL-GTI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
248bd4c550095bf34a85071935602c7f263b326f
COMERCIAL-GTI/docs/superpowers/plans/2026-08-01-campaign-outreach-port.md
T
Gustavo 3ce12381d5 Add implementation plan for campaign outreach subsystem port 
11-task TDD plan covering schema migration, campaign store, candidate
selection/queue, health metrics, send worker, scheduler, HTTP routes and
the Campanhas UI tab.
2026-08-01 10:08:07 -03:00

2279 lines
94 KiB
Markdown
Raw Blame History

# Campanhas de Outreach (GTI Comercial) Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Portar a metodologia de campanhas de outreach da Máquina Comercial Pessoal (fila com preview/aprovação, variantes A/B/C, escalonamento semanal de limite, pausa automática por saúde, classificação de estágio, agendamento) para a GTI Comercial, adaptada ao envio via Z-PRO (canal não-oficial, texto livre) e a um catálogo dinâmico (operador escolhe produto/segmentos/mensagens pela tela, em vez de um catálogo fixo em código).
**Architecture:** Novo diretório `src/outreach/campaign-*.mjs`, paralelo aos módulos existentes `run.mjs`/`scheduler.mjs` (nenhum dos dois é modificado). Uma migração de schema nova (v8) adiciona as tabelas de campanha. Uma rota nova (`src/server/routes/campaigns.mjs`) expõe tudo via HTTP. Uma aba nova no front-end (`public/js/campanhas.js`) consome essas rotas. O envio em si usa `zproClient.sendText` (síncrono: ou resolve `enviado` ou lança erro, sem estado intermediário de "reservado" — diferente da Pessoal, que precisa desse estado por causa da entrega assíncrona incerta do Baileys; aqui não é necessário).
**Tech Stack:** Node.js (`node:sqlite` via `DatabaseSync`), `node:test`/`node:assert`, HTML/CSS/JS vanilla (sem framework), mesmo padrão de módulos IIFE do front-end existente (`Tratamento`).
## Global Constraints
- Não modificar `src/outreach/run.mjs`, `src/outreach/scheduler.mjs`, `src/server/routes/outreach.mjs`, `public/js/app.js` (além do ponto de wiring da nova aba), nem qualquer arquivo com trabalho não commitado alheio a esta feature — o repositório tem WIP substancial em andamento que não deve ser tocado ou conflitado.
- Vocabulário de status segue o idioma português já usado em todo o resto do schema da GTI Comercial (`enviado`/`erro` em `outreach_sends`, não `aceito`/`pendente`/`desconhecido` como na Pessoal). Campanha: `rascunho|rodando|pausado|concluido`. Fila: `preview|approved|cancelled|sent|error`.
- Variantes A/B/C só existem no canal não-oficial (`zproClient.sendText`) — o canal oficial (WABA) não aceita texto livre, então não há como variar template.
- `outreach_sends` recebe `origem='automatico'` para envios de campanha (mesma convenção do `run.mjs`, não um valor `'campanha'` novo) — a atribuição de um envio a uma campanha é feita pelo JOIN via `outreach_campaign_queue.outreach_send_id`, não por um valor de `origem` dedicado.
- Prevenção de contato duplicado com o `runOutreachBatch` existente: um lead com `outreach_sends.status='enviado'` para o mesmo produto (seja por `lead_id` ou por `numero`, cobrindo tanto envio automático quanto manual) nunca entra na fila de campanha para aquele produto.
- Cada task abaixo tem teste próprio (`node --test tests/<arquivo>.test.mjs`) e termina com commit.
---
### Task 1: Migração de schema (v8) — tabelas de campanha
**Files:**
- Modify: `src/db.mjs` (array `MIGRATIONS`, adicionar 8º elemento)
- Test: `tests/db.test.mjs` (adicionar um teste ao arquivo existente)
**Interfaces:**
- Produces: tabelas `outreach_campaigns`, `outreach_campaign_variants`, `outreach_campaign_queue`, `outreach_lead_states`, `outreach_stage_events`, `outreach_appointments`, `outreach_opt_out`, todas acessíveis via `db.prepare(...)` após `openDb()`/`migrate()`.
- [ ] **Step 1: Escrever o teste que falha**
Adicionar ao final de `tests/db.test.mjs`:
```js
test('migracao v8 cria as tabelas de campanha de outreach', () => {
const db = openDb(':memory:');
const tabelas = db.prepare(
`SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'outreach_%'`
).all().map((r) => r.name);
for (const nome of [
'outreach_campaigns', 'outreach_campaign_variants', 'outreach_campaign_queue',
'outreach_lead_states', 'outreach_stage_events', 'outreach_appointments', 'outreach_opt_out'
]) {
assert.ok(tabelas.includes(nome), `tabela ${nome} deveria existir`);
}
db.prepare(`INSERT INTO outreach_campaigns (nome, produto, segmentos_json) VALUES ('Teste', 'ERP', '["oficinas"]')`).run();
const campanha = db.prepare('SELECT * FROM outreach_campaigns').get();
assert.equal(campanha.status, 'rascunho');
assert.equal(campanha.limite_diario_atual, 10);
db.close();
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/db.test.mjs`
Expected: FAIL — `no such table: outreach_campaigns`
- [ ] **Step 3: Adicionar a migração v8**
Em `src/db.mjs`, adicionar como último elemento do array `MIGRATIONS` (depois do comentário `// v7 — ...` e sua string, antes do `];` que fecha o array):
```js
// v8 — campanhas de outreach com catalogo dinamico (a Comercial tem 57
// segmentos e 4 produtos, catalogo fixo em codigo nao cabe nessa escala:
// o operador cria a campanha pela tela). Roda ao lado do runOutreachBatch
// existente (run.mjs) sem substitui-lo. outreach_opt_out e novo aqui (nao
// existia antes): uma fila que recontata o mesmo lead ao longo de semanas
// precisa checar quem ja pediu pra parar.
`
CREATE TABLE outreach_campaigns (
id INTEGER PRIMARY KEY,
nome TEXT NOT NULL,
produto TEXT NOT NULL,
segmentos_json TEXT NOT NULL DEFAULT '[]',
status TEXT NOT NULL DEFAULT 'rascunho',
pause_reason TEXT,
limite_diario_atual INTEGER NOT NULL DEFAULT 10,
limite_diario_teto INTEGER NOT NULL DEFAULT 80,
semana_iniciada_em TEXT,
created_at TEXT NOT NULL DEFAULT (datetime('now')),
updated_at TEXT NOT NULL DEFAULT (datetime('now'))
);
CREATE TABLE outreach_campaign_variants (
id INTEGER PRIMARY KEY,
campaign_id INTEGER NOT NULL REFERENCES outreach_campaigns(id),
code TEXT NOT NULL,
mensagem TEXT NOT NULL,
ativo INTEGER NOT NULL DEFAULT 1
);
CREATE INDEX idx_campaign_variants_campaign ON outreach_campaign_variants(campaign_id);
CREATE TABLE outreach_campaign_queue (
id INTEGER PRIMARY KEY,
campaign_id INTEGER NOT NULL REFERENCES outreach_campaigns(id),
lead_id INTEGER NOT NULL REFERENCES leads(id),
variant_id INTEGER NOT NULL REFERENCES outreach_campaign_variants(id),
segmento TEXT NOT NULL DEFAULT '',
numero TEXT NOT NULL,
rendered_message TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'preview',
cancel_reason TEXT,
outreach_send_id INTEGER REFERENCES outreach_sends(id),
created_at TEXT NOT NULL DEFAULT (datetime('now')),
updated_at TEXT NOT NULL DEFAULT (datetime('now'))
);
CREATE INDEX idx_campaign_queue_campaign_status ON outreach_campaign_queue(campaign_id, status);
CREATE INDEX idx_campaign_queue_lead ON outreach_campaign_queue(lead_id);
CREATE TABLE outreach_lead_states (
lead_id INTEGER PRIMARY KEY REFERENCES leads(id),
stage TEXT NOT NULL,
updated_at TEXT NOT NULL DEFAULT (datetime('now'))
);
CREATE TABLE outreach_stage_events (
id INTEGER PRIMARY KEY,
lead_id INTEGER NOT NULL REFERENCES leads(id),
campaign_id INTEGER REFERENCES outreach_campaigns(id),
stage TEXT NOT NULL,
note TEXT,
created_at TEXT NOT NULL DEFAULT (datetime('now'))
);
CREATE INDEX idx_stage_events_lead ON outreach_stage_events(lead_id);
CREATE TABLE outreach_appointments (
id INTEGER PRIMARY KEY,
lead_id INTEGER NOT NULL REFERENCES leads(id),
kind TEXT NOT NULL,
scheduled_at TEXT,
note TEXT,
created_at TEXT NOT NULL DEFAULT (datetime('now'))
);
CREATE INDEX idx_appointments_lead ON outreach_appointments(lead_id);
CREATE TABLE outreach_opt_out (
numero TEXT PRIMARY KEY,
motivo TEXT,
created_at TEXT NOT NULL DEFAULT (datetime('now'))
);
`
```
- [ ] **Step 4: Rodar e confirmar que passa**
Run: `node --test tests/db.test.mjs`
Expected: PASS
- [ ] **Step 5: Rodar a suite inteira (garantir que a migracao nao quebrou nada)**
Run: `node --test tests/*.test.mjs`
Expected: todos os testes existentes continuam passando
- [ ] **Step 6: Commit**
```bash
git add src/db.mjs tests/db.test.mjs
git commit -m "Add campaign outreach schema (migration v8)"
```
---
### Task 2: `campaign-store.mjs` — CRUD de campanha, variantes, opt-out, escalonamento
**Files:**
- Create: `src/outreach/campaign-store.mjs`
- Test: `tests/campaign-store.test.mjs`
**Interfaces:**
- Consumes: `transaction(db, fn)` de `../db.mjs` (já existe).
- Produces: `createCampaign(db, {nome, produto, segmentos, variantes, limiteDiarioInicial, limiteDiarioTeto}) -> campanha`, `getCampaign(db, id) -> campanha|null` (com `.segmentos` array e `.variants` array), `listCampaigns(db) -> campanha[]`, `listVariants(db, campaignId) -> variant[]`, `setCampaignStatus(db, campaignId, status, pauseReason) -> campanha`, `resumeCampaign(db, campaignId) -> campanha`, `escalateWeeklyLimits(db, now) -> number`, `isOptedOut(db, numero) -> boolean`, `addOptOut(db, numero, motivo) -> void`, `removeOptOut(db, numero) -> void`. Essas assinaturas são usadas por `campaign-queue.mjs`, `campaign-worker.mjs` e `routes/campaigns.mjs` nas próximas tasks.
- [ ] **Step 1: Escrever os testes que falham**
Criar `tests/campaign-store.test.mjs`:
```js
import test from 'node:test';
import assert from 'node:assert/strict';
import { openDb } from '../src/db.mjs';
import {
createCampaign, getCampaign, listCampaigns, setCampaignStatus, resumeCampaign,
escalateWeeklyLimits, isOptedOut, addOptOut, removeOptOut
} from '../src/outreach/campaign-store.mjs';
function campanhaBase(overrides = {}) {
return {
nome: 'ERP oficinas',
produto: 'ERP',
segmentos: ['oficinas_mecanicas', 'autopecas'],
variantes: [{ code: 'A', mensagem: 'Ola {empresa}' }, { code: 'B', mensagem: 'Oi {empresa}' }],
...overrides
};
}
test('createCampaign grava campanha, segmentos e variantes', () => {
const db = openDb(':memory:');
const campanha = createCampaign(db, campanhaBase());
assert.equal(campanha.status, 'rascunho');
assert.equal(campanha.produto, 'ERP');
assert.deepEqual(campanha.segmentos, ['oficinas_mecanicas', 'autopecas']);
assert.equal(campanha.variants.length, 2);
assert.equal(campanha.variants[0].code, 'A');
db.close();
});
test('listCampaigns retorna mais recente primeiro', () => {
const db = openDb(':memory:');
createCampaign(db, campanhaBase({ nome: 'Primeira' }));
createCampaign(db, campanhaBase({ nome: 'Segunda' }));
const campanhas = listCampaigns(db);
assert.equal(campanhas.length, 2);
assert.equal(campanhas[0].nome, 'Segunda');
db.close();
});
test('setCampaignStatus pausa e resumeCampaign retoma limpando o motivo', () => {
const db = openDb(':memory:');
const campanha = createCampaign(db, campanhaBase());
setCampaignStatus(db, campanha.id, 'rodando');
const pausada = setCampaignStatus(db, campanha.id, 'pausado', 'high_failure_rate');
assert.equal(pausada.status, 'pausado');
assert.equal(pausada.pause_reason, 'high_failure_rate');
const retomada = resumeCampaign(db, campanha.id);
assert.equal(retomada.status, 'rodando');
assert.equal(retomada.pause_reason, null);
db.close();
});
test('resumeCampaign nao faz nada se a campanha nao estiver pausada', () => {
const db = openDb(':memory:');
const campanha = createCampaign(db, campanhaBase());
const resultado = resumeCampaign(db, campanha.id);
assert.equal(resultado.status, 'rascunho');
db.close();
});
test('escalateWeeklyLimits dobra o limite apos 7 dias rodando, respeitando o teto', () => {
const db = openDb(':memory:');
const campanha = createCampaign(db, campanhaBase({ limiteDiarioInicial: 10, limiteDiarioTeto: 15 }));
setCampaignStatus(db, campanha.id, 'rodando');
db.prepare(`UPDATE outreach_campaigns SET semana_iniciada_em = datetime('now', '-8 days') WHERE id = ?`).run(campanha.id);
const escaladas = escalateWeeklyLimits(db);
assert.equal(escaladas, 1);
const atualizada = getCampaign(db, campanha.id);
assert.equal(atualizada.limite_diario_atual, 15); // dobraria pra 20, mas o teto e 15
db.close();
});
test('escalateWeeklyLimits nao avanca campanha pausada nem antes de 7 dias', () => {
const db = openDb(':memory:');
const rodando = createCampaign(db, campanhaBase({ nome: 'Rodando ha pouco' }));
setCampaignStatus(db, rodando.id, 'rodando');
db.prepare(`UPDATE outreach_campaigns SET semana_iniciada_em = datetime('now', '-2 days') WHERE id = ?`).run(rodando.id);
const pausada = createCampaign(db, campanhaBase({ nome: 'Pausada' }));
setCampaignStatus(db, pausada.id, 'rodando');
setCampaignStatus(db, pausada.id, 'pausado', 'manual');
db.prepare(`UPDATE outreach_campaigns SET semana_iniciada_em = datetime('now', '-10 days') WHERE id = ?`).run(pausada.id);
const escaladas = escalateWeeklyLimits(db);
assert.equal(escaladas, 0);
db.close();
});
test('opt-out: addOptOut bloqueia, removeOptOut libera', () => {
const db = openDb(':memory:');
assert.equal(isOptedOut(db, '5511999990001'), false);
addOptOut(db, '5511999990001', 'pediu pra parar');
assert.equal(isOptedOut(db, '5511999990001'), true);
removeOptOut(db, '5511999990001');
assert.equal(isOptedOut(db, '5511999990001'), false);
db.close();
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/campaign-store.test.mjs`
Expected: FAIL — `Cannot find module '../src/outreach/campaign-store.mjs'`
- [ ] **Step 3: Implementar**
Criar `src/outreach/campaign-store.mjs`:
```js
import { transaction } from '../db.mjs';
export function createCampaign(db, {
nome, produto, segmentos, variantes, limiteDiarioInicial = 10, limiteDiarioTeto = 80
}) {
return transaction(db, () => {
const result = db.prepare(
`INSERT INTO outreach_campaigns
(nome, produto, segmentos_json, limite_diario_atual, limite_diario_teto)
VALUES (?, ?, ?, ?, ?)`
).run(nome, produto, JSON.stringify(segmentos || []), limiteDiarioInicial, limiteDiarioTeto);
const campaignId = Number(result.lastInsertRowid);
const insertVariant = db.prepare(
`INSERT INTO outreach_campaign_variants (campaign_id, code, mensagem) VALUES (?, ?, ?)`
);
for (const variante of variantes) {
insertVariant.run(campaignId, variante.code, variante.mensagem);
}
return getCampaign(db, campaignId);
});
}
export function getCampaign(db, id) {
const row = db.prepare('SELECT * FROM outreach_campaigns WHERE id = ?').get(id);
if (!row) return null;
return {
...row,
segmentos: JSON.parse(row.segmentos_json || '[]'),
variants: listVariants(db, id)
};
}
export function listCampaigns(db) {
return db.prepare('SELECT * FROM outreach_campaigns ORDER BY id DESC').all()
.map((row) => ({ ...row, segmentos: JSON.parse(row.segmentos_json || '[]') }));
}
export function listVariants(db, campaignId) {
return db.prepare(
'SELECT * FROM outreach_campaign_variants WHERE campaign_id = ? AND ativo = 1 ORDER BY code'
).all(campaignId);
}
// status: 'rascunho' -> 'rodando' -> 'pausado' <-> 'rodando' -> 'concluido'.
// pause_reason so fica setado quando o novo status e 'pausado'.
export function setCampaignStatus(db, campaignId, status, pauseReason = null) {
db.prepare(
`UPDATE outreach_campaigns SET status = ?, pause_reason = ?, updated_at = datetime('now') WHERE id = ?`
).run(status, status === 'pausado' ? pauseReason : null, campaignId);
return getCampaign(db, campaignId);
}
// So avanca campanha que estiver de fato pausada — retomar uma campanha em
// rascunho, por exemplo, deveria usar setCampaignStatus(db, id, 'rodando').
export function resumeCampaign(db, campaignId) {
db.prepare(
`UPDATE outreach_campaigns SET status = 'rodando', pause_reason = NULL, updated_at = datetime('now')
WHERE id = ? AND status = 'pausado'`
).run(campaignId);
return getCampaign(db, campaignId);
}
// Escalonamento semanal: dobra o limite diario a cada 7 dias corridos rodando
// sem pausa desde semana_iniciada_em, ate o teto da campanha. So campanhas com
// status='rodando' avancam — uma pausada fica congelada ate o operador retomar.
export function escalateWeeklyLimits(db, now = new Date()) {
const campaigns = db.prepare(
`SELECT id, limite_diario_atual, limite_diario_teto, semana_iniciada_em
FROM outreach_campaigns WHERE status = 'rodando'`
).all();
let escaladas = 0;
for (const campaign of campaigns) {
if (!campaign.semana_iniciada_em) continue;
const dias = (now.getTime() - new Date(campaign.semana_iniciada_em.replace(' ', 'T') + 'Z').getTime()) / 86400000;
if (dias < 7) continue;
const novoLimite = Math.min(campaign.limite_diario_teto, campaign.limite_diario_atual * 2);
if (novoLimite === campaign.limite_diario_atual) continue;
db.prepare(
`UPDATE outreach_campaigns
SET limite_diario_atual = ?, semana_iniciada_em = datetime('now'), updated_at = datetime('now')
WHERE id = ?`
).run(novoLimite, campaign.id);
escaladas += 1;
}
return escaladas;
}
export function isOptedOut(db, numero) {
return Boolean(db.prepare('SELECT 1 FROM outreach_opt_out WHERE numero = ?').get(numero));
}
export function addOptOut(db, numero, motivo = null) {
db.prepare(
`INSERT INTO outreach_opt_out (numero, motivo) VALUES (?, ?)
ON CONFLICT(numero) DO UPDATE SET motivo = excluded.motivo`
).run(numero, motivo);
}
export function removeOptOut(db, numero) {
db.prepare('DELETE FROM outreach_opt_out WHERE numero = ?').run(numero);
}
```
Nota sobre `escalateWeeklyLimits`: `datetime('now')` do SQLite grava `"YYYY-MM-DD HH:MM:SS"` (sem `T`/`Z`); `.replace(' ', 'T') + 'Z'` converte pra um formato que `new Date(...)` do JS interpreta corretamente como UTC.
- [ ] **Step 4: Rodar e confirmar que passa**
Run: `node --test tests/campaign-store.test.mjs`
Expected: PASS (7 testes)
- [ ] **Step 5: Commit**
```bash
git add src/outreach/campaign-store.mjs tests/campaign-store.test.mjs
git commit -m "Add campaign-store: CRUD, opt-out and weekly limit escalation"
```
---
### Task 3: `campaign-messages.mjs` — seleção determinística de variante + render
**Files:**
- Create: `src/outreach/campaign-messages.mjs`
- Test: `tests/campaign-messages.test.mjs`
**Interfaces:**
- Consumes: `renderTemplate(mensagem, lead)` de `./templates.mjs` (já existe, faz substituição de `{empresa}`/`{cidade}`/`{produto}`/`{segmento}`).
- Produces: `variantForLead(variants, leadId) -> variant`, `renderCampaignMessage(variant, lead) -> string`. Usadas por `campaign-queue.mjs` (Task 4).
- [ ] **Step 1: Escrever o teste que falha**
Criar `tests/campaign-messages.test.mjs`:
```js
import test from 'node:test';
import assert from 'node:assert/strict';
import { variantForLead, renderCampaignMessage } from '../src/outreach/campaign-messages.mjs';
const variants = [{ id: 1, code: 'A', mensagem: 'Ola A' }, { id: 2, code: 'B', mensagem: 'Ola B' }, { id: 3, code: 'C', mensagem: 'Ola C' }];
test('variantForLead e deterministico (mesmo lead sempre cai na mesma variante)', () => {
const primeira = variantForLead(variants, 42);
const segunda = variantForLead(variants, 42);
assert.equal(primeira.code, segunda.code);
});
test('variantForLead distribui entre variantes diferentes conforme o id', () => {
assert.equal(variantForLead(variants, 0).code, 'A');
assert.equal(variantForLead(variants, 1).code, 'B');
assert.equal(variantForLead(variants, 2).code, 'C');
assert.equal(variantForLead(variants, 3).code, 'A');
});
test('variantForLead lanca erro sem variantes ativas', () => {
assert.throws(() => variantForLead([], 1), /sem variantes/);
});
test('renderCampaignMessage substitui variaveis do lead', () => {
const texto = renderCampaignMessage({ mensagem: 'Ola {empresa}, sobre {produto}' }, { empresa: 'Oficina do Ze', produto: 'ERP' });
assert.equal(texto, 'Ola Oficina do Ze, sobre ERP');
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/campaign-messages.test.mjs`
Expected: FAIL — módulo não existe
- [ ] **Step 3: Implementar**
Criar `src/outreach/campaign-messages.mjs`:
```js
import { renderTemplate } from './templates.mjs';
// Distribuicao deterministica por lead_id % variantes.length: o mesmo lead
// sempre cai na mesma variante mesmo que a fila seja regenerada depois, sem
// precisar guardar nenhum estado extra so pra isso.
export function variantForLead(variants, leadId) {
if (!variants.length) throw new Error('campanha sem variantes ativas');
const index = Number(leadId) % variants.length;
return variants[index];
}
export function renderCampaignMessage(variant, lead) {
return renderTemplate(variant.mensagem, lead);
}
```
- [ ] **Step 4: Rodar e confirmar que passa**
Run: `node --test tests/campaign-messages.test.mjs`
Expected: PASS (4 testes)
- [ ] **Step 5: Commit**
```bash
git add src/outreach/campaign-messages.mjs tests/campaign-messages.test.mjs
git commit -m "Add deterministic variant selection and message rendering"
```
---
### Task 4: `campaign-queue.mjs` — seleção de candidatos, geração de fila, aprovação
**Files:**
- Create: `src/outreach/campaign-queue.mjs`
- Test: `tests/campaign-queue.test.mjs`
**Interfaces:**
- Consumes: `getCampaign` de `./campaign-store.mjs` (Task 2), `variantForLead`/`renderCampaignMessage` de `./campaign-messages.mjs` (Task 3).
- Produces: `generateCampaignQueue(db, campaignId, {quantidade}) -> {candidatosEncontrados, adicionadosNaFila}`, `listQueue(db, campaignId, status|null) -> row[]`, `approveQueueRows(db, campaignId, queueIds) -> number`, `cancelQueueRows(db, campaignId, queueIds, reason) -> number`. Usadas por `routes/campaigns.mjs` (Task 8) e por `campaign-worker.mjs` indiretamente (via as linhas que essas funções produzem na tabela).
- [ ] **Step 1: Escrever os testes que falham**
Criar `tests/campaign-queue.test.mjs`:
```js
import test from 'node:test';
import assert from 'node:assert/strict';
import { openDb, createLeadInserter } from '../src/db.mjs';
import { createCampaign } from '../src/outreach/campaign-store.mjs';
import { generateCampaignQueue, listQueue, approveQueueRows, cancelQueueRows } from '../src/outreach/campaign-queue.mjs';
function inserirLead(db, overrides = {}) {
const inserir = createLeadInserter(db);
const dedup = overrides.dedup_key || `lead-${Math.random()}`;
inserir({
dedup_key: dedup, empresa: 'Oficina Teste', legal_name: '', whatsapp: '5511999990001',
ddd: '11', email: '', cidade: 'SP', uf: 'SP', segmento: 'oficinas_mecanicas', segmento_label: '',
interesse: '', cnpj: '', cnae: '', endereco: '', website: '', pains_json: '[]', origem: 'teste',
telefone_valido: 1, cnpj_valido: 0, empresa_valida: 1, score: 80, classificacao: 'bom',
motivo_classificacao: '', score_qualidade: 80, score_comercial: 80, prioridade: 1,
produto_principal: 'ERP', produtos_json: '[]', capture_run_id: null, captured_at: null, exported_at: null,
...overrides
});
return db.prepare('SELECT * FROM leads WHERE dedup_key = ?').get(dedup);
}
function campanhaComVariantes(db, overrides = {}) {
return createCampaign(db, {
nome: 'ERP oficinas', produto: 'ERP', segmentos: ['oficinas_mecanicas'],
variantes: [{ code: 'A', mensagem: 'Ola {empresa}' }],
...overrides
});
}
test('generateCampaignQueue cria linhas preview so para leads do produto/segmento certos', () => {
const db = openDb(':memory:');
inserirLead(db, { dedup_key: 'l1', whatsapp: '5511999990001' });
inserirLead(db, { dedup_key: 'l2', segmento: 'outro_segmento', whatsapp: '5511999990002' });
const campanha = campanhaComVariantes(db);
const resultado = generateCampaignQueue(db, campanha.id);
assert.equal(resultado.candidatosEncontrados, 1);
assert.equal(resultado.adicionadosNaFila, 1);
const fila = listQueue(db, campanha.id);
assert.equal(fila.length, 1);
assert.equal(fila[0].status, 'preview');
assert.equal(fila[0].rendered_message, 'Ola Oficina Teste');
db.close();
});
test('generateCampaignQueue exclui lead com envio ja enviado para o mesmo produto (por lead_id)', () => {
const db = openDb(':memory:');
const lead = inserirLead(db);
db.prepare(
`INSERT INTO outreach_sends (lead_id, produto, numero, mensagem_enviada, status) VALUES (?, 'ERP', ?, 'oi', 'enviado')`
).run(lead.id, lead.whatsapp);
const campanha = campanhaComVariantes(db);
const resultado = generateCampaignQueue(db, campanha.id);
assert.equal(resultado.candidatosEncontrados, 0);
db.close();
});
test('generateCampaignQueue exclui numero com envio manual ja enviado (sem lead_id) para o mesmo produto', () => {
const db = openDb(':memory:');
inserirLead(db, { whatsapp: '5511999990009' });
db.prepare(
`INSERT INTO outreach_sends (lead_id, produto, numero, mensagem_enviada, status, origem)
VALUES (NULL, 'ERP', '5511999990009', 'oi', 'enviado', 'manual')`
).run();
const campanha = campanhaComVariantes(db);
const resultado = generateCampaignQueue(db, campanha.id);
assert.equal(resultado.candidatosEncontrados, 0);
db.close();
});
test('generateCampaignQueue exclui numero em opt-out', () => {
const db = openDb(':memory:');
inserirLead(db, { whatsapp: '5511999990001' });
db.prepare(`INSERT INTO outreach_opt_out (numero) VALUES ('5511999990001')`).run();
const campanha = campanhaComVariantes(db);
const resultado = generateCampaignQueue(db, campanha.id);
assert.equal(resultado.candidatosEncontrados, 0);
db.close();
});
test('generateCampaignQueue nao duplica lead ja na fila (preview/approved/sent) de outra campanha do mesmo produto', () => {
const db = openDb(':memory:');
inserirLead(db, { dedup_key: 'unico', whatsapp: '5511999990001' });
const campanha1 = campanhaComVariantes(db, { nome: 'Campanha 1' });
generateCampaignQueue(db, campanha1.id);
const campanha2 = campanhaComVariantes(db, { nome: 'Campanha 2' });
const resultado = generateCampaignQueue(db, campanha2.id);
assert.equal(resultado.candidatosEncontrados, 0);
db.close();
});
test('generateCampaignQueue respeita o parametro quantidade', () => {
const db = openDb(':memory:');
for (let i = 0; i < 5; i += 1) {
inserirLead(db, { dedup_key: `lead-${i}`, whatsapp: `551199999000${i}` });
}
const campanha = campanhaComVariantes(db);
const resultado = generateCampaignQueue(db, campanha.id, { quantidade: 3 });
assert.equal(resultado.adicionadosNaFila, 3);
db.close();
});
test('approveQueueRows so aprova linhas em preview da campanha certa', () => {
const db = openDb(':memory:');
inserirLead(db, { whatsapp: '5511999990001' });
const campanha = campanhaComVariantes(db);
generateCampaignQueue(db, campanha.id);
const [linha] = listQueue(db, campanha.id);
const total = approveQueueRows(db, campanha.id, [linha.id]);
assert.equal(total, 1);
assert.equal(listQueue(db, campanha.id, 'approved').length, 1);
});
test('cancelQueueRows cancela e registra motivo', () => {
const db = openDb(':memory:');
inserirLead(db, { whatsapp: '5511999990001' });
const campanha = campanhaComVariantes(db);
generateCampaignQueue(db, campanha.id);
const [linha] = listQueue(db, campanha.id);
const total = cancelQueueRows(db, campanha.id, [linha.id], 'nao interessa');
assert.equal(total, 1);
const cancelada = listQueue(db, campanha.id, 'cancelled')[0];
assert.equal(cancelada.cancel_reason, 'nao interessa');
});
test('approveQueueRows/cancelQueueRows com lista vazia nao lanca erro', () => {
const db = openDb(':memory:');
const campanha = campanhaComVariantes(db);
assert.equal(approveQueueRows(db, campanha.id, []), 0);
assert.equal(cancelQueueRows(db, campanha.id, []), 0);
db.close();
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/campaign-queue.test.mjs`
Expected: FAIL — módulo não existe
- [ ] **Step 3: Implementar**
Criar `src/outreach/campaign-queue.mjs`:
```js
import { getCampaign } from './campaign-store.mjs';
import { variantForLead, renderCampaignMessage } from './campaign-messages.mjs';
const ACTIVE_QUEUE_STATUSES = "'preview','approved','sent'";
function candidateQuery() {
return `
SELECT leads.id, leads.empresa, leads.whatsapp, leads.segmento, leads.cidade, leads.uf,
leads.segmento_label, leads.prioridade, leads.score
FROM leads
WHERE leads.produto_principal = ?
AND leads.segmento = ?
AND leads.telefone_valido = 1
AND leads.whatsapp != ''
AND NOT EXISTS (
SELECT 1 FROM outreach_sends
WHERE outreach_sends.produto = ? AND outreach_sends.status = 'enviado'
AND (outreach_sends.lead_id = leads.id OR outreach_sends.numero = leads.whatsapp)
)
AND NOT EXISTS (
SELECT 1 FROM outreach_campaign_queue q
JOIN outreach_campaigns c ON c.id = q.campaign_id
WHERE q.lead_id = leads.id AND c.produto = ? AND q.status IN (${ACTIVE_QUEUE_STATUSES})
)
AND NOT EXISTS (SELECT 1 FROM outreach_opt_out WHERE numero = leads.whatsapp)
ORDER BY leads.prioridade ASC, leads.score DESC, leads.id ASC`;
}
// Gera ate `quantidade` linhas novas de fila (status 'preview') para a
// campanha, buscando candidatos em todos os segmentos configurados. Nao e
// limitado ao limite diario de envio (isso so controla a VELOCIDADE de envio
// do worker) — o operador pode gerar e revisar um lote maior do que vai
// enviar hoje.
export function generateCampaignQueue(db, campaignId, { quantidade = 50 } = {}) {
const campaign = getCampaign(db, campaignId);
if (!campaign) throw new Error('campanha nao encontrada');
if (!campaign.variants.length) throw new Error('campanha sem variantes ativas');
if (!campaign.segmentos.length) throw new Error('campanha sem segmentos configurados');
const statement = db.prepare(candidateQuery());
const candidatos = campaign.segmentos
.flatMap((segmento) => statement.all(campaign.produto, segmento, campaign.produto, campaign.produto))
.sort((a, b) => a.prioridade - b.prioridade || b.score - a.score || a.id - b.id)
.slice(0, quantidade);
const insert = db.prepare(
`INSERT INTO outreach_campaign_queue
(campaign_id, lead_id, variant_id, segmento, numero, rendered_message, status)
VALUES (?, ?, ?, ?, ?, ?, 'preview')`
);
let adicionados = 0;
for (const lead of candidatos) {
const variant = variantForLead(campaign.variants, lead.id);
const renderedMessage = renderCampaignMessage(variant, lead);
insert.run(campaignId, lead.id, variant.id, lead.segmento, lead.whatsapp, renderedMessage);
adicionados += 1;
}
return { candidatosEncontrados: candidatos.length, adicionadosNaFila: adicionados };
}
export function listQueue(db, campaignId, status = null) {
if (status) {
return db.prepare(
'SELECT * FROM outreach_campaign_queue WHERE campaign_id = ? AND status = ? ORDER BY id'
).all(campaignId, status);
}
return db.prepare(
'SELECT * FROM outreach_campaign_queue WHERE campaign_id = ? ORDER BY id'
).all(campaignId);
}
export function approveQueueRows(db, campaignId, queueIds) {
if (!queueIds.length) return 0;
const placeholders = queueIds.map(() => '?').join(', ');
return db.prepare(
`UPDATE outreach_campaign_queue SET status = 'approved', updated_at = datetime('now')
WHERE campaign_id = ? AND status = 'preview' AND id IN (${placeholders})`
).run(campaignId, ...queueIds).changes;
}
export function cancelQueueRows(db, campaignId, queueIds, reason = 'operador') {
if (!queueIds.length) return 0;
const placeholders = queueIds.map(() => '?').join(', ');
return db.prepare(
`UPDATE outreach_campaign_queue SET status = 'cancelled', cancel_reason = ?, updated_at = datetime('now')
WHERE campaign_id = ? AND status IN ('preview','approved') AND id IN (${placeholders})`
).run(reason, campaignId, ...queueIds).changes;
}
```
- [ ] **Step 4: Rodar e confirmar que passa**
Run: `node --test tests/campaign-queue.test.mjs`
Expected: PASS (9 testes)
- [ ] **Step 5: Commit**
```bash
git add src/outreach/campaign-queue.mjs tests/campaign-queue.test.mjs
git commit -m "Add campaign candidate selection, queue generation and approval"
```
---
### Task 5: `campaign-metrics.mjs` — saúde/auto-pausa e comparação de variantes
**Files:**
- Create: `src/outreach/campaign-metrics.mjs`
- Test: `tests/campaign-metrics.test.mjs`
**Interfaces:**
- Produces: `evaluateCampaignHealth(db, campaignId, now) -> {pause: boolean, reason: string|null}`, `variantStats(db, campaignId) -> [{code, enviados, respostas, taxaResposta, elegivelParaComparacao}]`. Usadas por `campaign-worker.mjs` (Task 6) e `routes/campaigns.mjs` (Task 8).
- [ ] **Step 1: Escrever os testes que falham**
Criar `tests/campaign-metrics.test.mjs`:
```js
import test from 'node:test';
import assert from 'node:assert/strict';
import { openDb, createLeadInserter } from '../src/db.mjs';
import { createCampaign, setCampaignStatus } from '../src/outreach/campaign-store.mjs';
import { evaluateCampaignHealth, variantStats } from '../src/outreach/campaign-metrics.mjs';
function inserirLead(db, dedup) {
const inserir = createLeadInserter(db);
inserir({
dedup_key: dedup, empresa: 'E', legal_name: '', whatsapp: `55119999${dedup.padStart(5, '0')}`,
ddd: '11', email: '', cidade: '', uf: '', segmento: 'x', segmento_label: '', interesse: '',
cnpj: '', cnae: '', endereco: '', website: '', pains_json: '[]', origem: 't', telefone_valido: 1,
cnpj_valido: 0, empresa_valida: 1, score: 50, classificacao: 'bom', motivo_classificacao: '',
score_qualidade: 50, score_comercial: 50, prioridade: 1, produto_principal: 'ERP',
produtos_json: '[]', capture_run_id: null, captured_at: null, exported_at: null
});
return db.prepare('SELECT id, whatsapp FROM leads WHERE dedup_key = ?').get(dedup);
}
function campanhaRodando(db) {
const campanha = createCampaign(db, {
nome: 'C', produto: 'ERP', segmentos: ['x'], variantes: [{ code: 'A', mensagem: 'oi' }]
});
setCampaignStatus(db, campanha.id, 'rodando');
return campanha;
}
function simularEnvio(db, campanhaId, variantId, leadId, numero, status) {
const sendId = db.prepare(
`INSERT INTO outreach_sends (lead_id, produto, numero, mensagem_enviada, status) VALUES (?, 'ERP', ?, 'oi', ?)`
).run(leadId, numero, status).lastInsertRowid;
db.prepare(
`INSERT INTO outreach_campaign_queue (campaign_id, lead_id, variant_id, numero, rendered_message, status, outreach_send_id)
VALUES (?, ?, ?, ?, 'oi', ?, ?)`
).run(campanhaId, leadId, variantId, numero, status === 'erro' ? 'error' : 'sent', sendId);
}
test('evaluateCampaignHealth nao pausa campanha saudavel', () => {
const db = openDb(':memory:');
const campanha = campanhaRodando(db);
const variant = db.prepare('SELECT id FROM outreach_campaign_variants WHERE campaign_id = ?').get(campanha.id);
for (let i = 0; i < 10; i += 1) {
const lead = inserirLead(db, `l${i}`);
simularEnvio(db, campanha.id, variant.id, lead.id, lead.whatsapp, 'enviado');
}
const resultado = evaluateCampaignHealth(db, campanha.id);
assert.equal(resultado.pause, false);
db.close();
});
test('evaluateCampaignHealth pausa por high_failure_rate quando erro > 10% com 10+ tentativas', () => {
const db = openDb(':memory:');
const campanha = campanhaRodando(db);
const variant = db.prepare('SELECT id FROM outreach_campaign_variants WHERE campaign_id = ?').get(campanha.id);
for (let i = 0; i < 8; i += 1) {
const lead = inserirLead(db, `ok${i}`);
simularEnvio(db, campanha.id, variant.id, lead.id, lead.whatsapp, 'enviado');
}
for (let i = 0; i < 2; i += 1) {
const lead = inserirLead(db, `err${i}`);
simularEnvio(db, campanha.id, variant.id, lead.id, lead.whatsapp, 'erro');
}
const resultado = evaluateCampaignHealth(db, campanha.id);
assert.equal(resultado.pause, true);
assert.equal(resultado.reason, 'high_failure_rate');
const atualizada = db.prepare('SELECT status FROM outreach_campaigns WHERE id = ?').get(campanha.id);
assert.equal(atualizada.status, 'pausado');
db.close();
});
test('evaluateCampaignHealth nao pausa por falha com menos de 10 tentativas no dia', () => {
const db = openDb(':memory:');
const campanha = campanhaRodando(db);
const variant = db.prepare('SELECT id FROM outreach_campaign_variants WHERE campaign_id = ?').get(campanha.id);
const lead = inserirLead(db, 'so1');
simularEnvio(db, campanha.id, variant.id, lead.id, lead.whatsapp, 'erro');
const resultado = evaluateCampaignHealth(db, campanha.id);
assert.equal(resultado.pause, false);
db.close();
});
test('evaluateCampaignHealth pausa por high_negative_rate quando >10% dos 20+ contatados estao em sem_interesse/opt_out', () => {
const db = openDb(':memory:');
const campanha = campanhaRodando(db);
const variant = db.prepare('SELECT id FROM outreach_campaign_variants WHERE campaign_id = ?').get(campanha.id);
for (let i = 0; i < 20; i += 1) {
const lead = inserirLead(db, `neg${i}`);
simularEnvio(db, campanha.id, variant.id, lead.id, lead.whatsapp, 'enviado');
if (i < 3) {
db.prepare(`INSERT INTO outreach_lead_states (lead_id, stage) VALUES (?, 'sem_interesse')`).run(lead.id);
}
}
const resultado = evaluateCampaignHealth(db, campanha.id);
assert.equal(resultado.pause, true);
assert.equal(resultado.reason, 'high_negative_rate');
db.close();
});
test('evaluateCampaignHealth pausa por low_reply_rate quando <5% dos 50+ contatados responderam', () => {
const db = openDb(':memory:');
const campanha = campanhaRodando(db);
const variant = db.prepare('SELECT id FROM outreach_campaign_variants WHERE campaign_id = ?').get(campanha.id);
for (let i = 0; i < 50; i += 1) {
const lead = inserirLead(db, `rep${i}`);
simularEnvio(db, campanha.id, variant.id, lead.id, lead.whatsapp, 'enviado');
}
const resultado = evaluateCampaignHealth(db, campanha.id);
assert.equal(resultado.pause, true);
assert.equal(resultado.reason, 'low_reply_rate');
db.close();
});
test('evaluateCampaignHealth em campanha ja pausada nao faz nada', () => {
const db = openDb(':memory:');
const campanha = campanhaRodando(db);
setCampaignStatus(db, campanha.id, 'pausado', 'manual');
const resultado = evaluateCampaignHealth(db, campanha.id);
assert.equal(resultado.pause, false);
db.close();
});
test('variantStats calcula taxa de resposta e elegibilidade (limiar 40 envios)', () => {
const db = openDb(':memory:');
const campanha = campanhaRodando(db);
const variant = db.prepare('SELECT id FROM outreach_campaign_variants WHERE campaign_id = ?').get(campanha.id);
for (let i = 0; i < 5; i += 1) {
const lead = inserirLead(db, `v${i}`);
simularEnvio(db, campanha.id, variant.id, lead.id, lead.whatsapp, 'enviado');
if (i < 1) {
db.prepare(`INSERT INTO outreach_stage_events (lead_id, campaign_id, stage) VALUES (?, ?, 'interessado')`).run(lead.id, campanha.id);
}
}
const stats = variantStats(db, campanha.id);
assert.equal(stats.length, 1);
assert.equal(stats[0].enviados, 5);
assert.equal(stats[0].respostas, 1);
assert.equal(stats[0].taxaResposta, 0.2);
assert.equal(stats[0].elegivelParaComparacao, false);
db.close();
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/campaign-metrics.test.mjs`
Expected: FAIL — módulo não existe
- [ ] **Step 3: Implementar**
Criar `src/outreach/campaign-metrics.mjs`:
```js
function dateKey(date) {
const y = date.getFullYear();
const m = String(date.getMonth() + 1).padStart(2, '0');
const d = String(date.getDate()).padStart(2, '0');
return `${y}-${m}-${d}`;
}
function applyPause(db, campaignId, reason) {
db.prepare(
`UPDATE outreach_campaigns SET status = 'pausado', pause_reason = ?, updated_at = datetime('now')
WHERE id = ? AND status = 'rodando'`
).run(reason, campaignId);
}
// Mesmos 3 criterios e limiares numericos da Maquina Pessoal (10 tentativas/
// 10% erro, 20 contatos/10% negativo+opt-out, 50 contatos/5% resposta),
// adaptados as tabelas da Comercial via JOIN por outreach_campaign_queue
// (nao por um valor de origem dedicado).
export function evaluateCampaignHealth(db, campaignId, now = new Date()) {
const campaign = db.prepare('SELECT status FROM outreach_campaigns WHERE id = ?').get(campaignId);
if (!campaign || campaign.status !== 'rodando') return { pause: false, reason: null };
const todayKey = dateKey(now);
const attemptsToday = Number(db.prepare(
`SELECT COUNT(*) AS total
FROM outreach_campaign_queue q
JOIN outreach_sends s ON s.id = q.outreach_send_id
WHERE q.campaign_id = ? AND date(s.sent_at, 'localtime') = ?`
).get(campaignId, todayKey).total);
if (attemptsToday >= 10) {
const failureCount = Number(db.prepare(
`SELECT COUNT(*) AS total
FROM outreach_campaign_queue q
JOIN outreach_sends s ON s.id = q.outreach_send_id
WHERE q.campaign_id = ? AND s.status = 'erro' AND date(s.sent_at, 'localtime') = ?`
).get(campaignId, todayKey).total);
if (failureCount / attemptsToday > 0.10) {
applyPause(db, campaignId, 'high_failure_rate');
return { pause: true, reason: 'high_failure_rate' };
}
}
const contacts = Number(db.prepare(
`SELECT COUNT(*) AS total FROM outreach_campaign_queue WHERE campaign_id = ? AND status IN ('sent','error')`
).get(campaignId).total);
if (contacts >= 20) {
const negativeCount = Number(db.prepare(
`SELECT COUNT(DISTINCT q.lead_id) AS total
FROM outreach_campaign_queue q
JOIN outreach_lead_states ls ON ls.lead_id = q.lead_id
WHERE q.campaign_id = ? AND q.status IN ('sent','error')
AND ls.stage IN ('sem_interesse', 'opt_out')`
).get(campaignId).total);
if (negativeCount / contacts > 0.10) {
applyPause(db, campaignId, 'high_negative_rate');
return { pause: true, reason: 'high_negative_rate' };
}
}
if (contacts >= 50) {
const respondedCount = Number(db.prepare(
`SELECT COUNT(DISTINCT q.lead_id) AS total
FROM outreach_campaign_queue q
JOIN outreach_stage_events se ON se.lead_id = q.lead_id AND se.campaign_id = q.campaign_id
WHERE q.campaign_id = ? AND q.status IN ('sent','error')`
).get(campaignId).total);
if (respondedCount / contacts < 0.05) {
applyPause(db, campaignId, 'low_reply_rate');
return { pause: true, reason: 'low_reply_rate' };
}
}
return { pause: false, reason: null };
}
// Numero de leads distintos com resposta por variante, via subquery
// correlacionada (nao um JOIN direto) para nao contar duplicado quando um
// lead tem mais de um outreach_stage_events.
export function variantStats(db, campaignId) {
const rows = db.prepare(
`SELECT v.id AS variant_id, v.code,
COUNT(*) AS enviados,
(SELECT COUNT(DISTINCT q2.lead_id)
FROM outreach_campaign_queue q2
JOIN outreach_stage_events se ON se.lead_id = q2.lead_id AND se.campaign_id = q2.campaign_id
WHERE q2.campaign_id = q.campaign_id AND q2.variant_id = v.id AND q2.status IN ('sent','error')
) AS respostas
FROM outreach_campaign_queue q
JOIN outreach_campaign_variants v ON v.id = q.variant_id
WHERE q.campaign_id = ? AND q.status IN ('sent','error')
GROUP BY v.id, v.code`
).all(campaignId);
return rows.map((row) => ({
code: row.code,
enviados: row.enviados,
respostas: row.respostas,
taxaResposta: row.enviados > 0 ? row.respostas / row.enviados : 0,
elegivelParaComparacao: row.enviados >= 40
}));
}
```
- [ ] **Step 4: Rodar e confirmar que passa**
Run: `node --test tests/campaign-metrics.test.mjs`
Expected: PASS (7 testes)
- [ ] **Step 5: Commit**
```bash
git add src/outreach/campaign-metrics.mjs tests/campaign-metrics.test.mjs
git commit -m "Add campaign health auto-pause and variant comparison stats"
```
---
### Task 6: `campaign-worker.mjs` — envio das linhas aprovadas
**Files:**
- Create: `src/outreach/campaign-worker.mjs`
- Test: `tests/campaign-worker.test.mjs`
**Interfaces:**
- Consumes: `isOptedOut` de `./campaign-store.mjs` (Task 2), `evaluateCampaignHealth` de `./campaign-metrics.mjs` (Task 5), `createZproClient` de `./zpro-client.mjs` (já existe).
- Produces: `runCampaignQueue({db, zproClient, now, log}) -> {enviados, erros, pulados}`. Usada por `campaign-scheduler.mjs` (Task 7).
- [ ] **Step 1: Escrever os testes que falham**
Criar `tests/campaign-worker.test.mjs`:
```js
import test from 'node:test';
import assert from 'node:assert/strict';
import { openDb, createLeadInserter } from '../src/db.mjs';
import { createCampaign, setCampaignStatus, addOptOut } from '../src/outreach/campaign-store.mjs';
import { generateCampaignQueue, listQueue, approveQueueRows } from '../src/outreach/campaign-queue.mjs';
import { runCampaignQueue } from '../src/outreach/campaign-worker.mjs';
function inserirLead(db, dedup, whatsapp) {
const inserir = createLeadInserter(db);
inserir({
dedup_key: dedup, empresa: 'Empresa', legal_name: '', whatsapp, ddd: '11', email: '',
cidade: '', uf: '', segmento: 'x', segmento_label: '', interesse: '', cnpj: '', cnae: '',
endereco: '', website: '', pains_json: '[]', origem: 't', telefone_valido: 1, cnpj_valido: 0,
empresa_valida: 1, score: 50, classificacao: 'bom', motivo_classificacao: '', score_qualidade: 50,
score_comercial: 50, prioridade: 1, produto_principal: 'ERP', produtos_json: '[]',
capture_run_id: null, captured_at: null, exported_at: null
});
}
function campanhaAprovada(db, quantidadeLeads = 1) {
for (let i = 0; i < quantidadeLeads; i += 1) {
inserirLead(db, `lead-${i}`, `551199999000${i}`);
}
const campanha = createCampaign(db, {
nome: 'C', produto: 'ERP', segmentos: ['x'], variantes: [{ code: 'A', mensagem: 'Ola {empresa}' }],
limiteDiarioInicial: 10
});
setCampaignStatus(db, campanha.id, 'rodando');
generateCampaignQueue(db, campanha.id);
const fila = listQueue(db, campanha.id, 'preview');
approveQueueRows(db, campanha.id, fila.map((r) => r.id));
return campanha;
}
function fakeZproClient(overrides = {}) {
const enviados = [];
return {
enviados,
sendText: async (args) => { enviados.push(args); return { data: { ticketId: 999 } }; },
...overrides
};
}
test('runCampaignQueue envia linhas aprovadas via sendText e marca sent', async () => {
const db = openDb(':memory:');
const campanha = campanhaAprovada(db);
const zproClient = fakeZproClient();
const resumo = await runCampaignQueue({ db, zproClient });
assert.equal(resumo.enviados, 1);
assert.equal(zproClient.enviados.length, 1);
assert.equal(zproClient.enviados[0].message, 'Ola Empresa');
const fila = listQueue(db, campanha.id, 'sent');
assert.equal(fila.length, 1);
assert.ok(fila[0].outreach_send_id);
const send = db.prepare('SELECT * FROM outreach_sends WHERE id = ?').get(fila[0].outreach_send_id);
assert.equal(send.status, 'enviado');
assert.equal(send.origem, 'automatico');
db.close();
});
test('runCampaignQueue registra erro quando o Z-PRO falha, sem travar o restante', async () => {
const db = openDb(':memory:');
const campanha = campanhaAprovada(db, 2);
let chamada = 0;
const zproClient = fakeZproClient({
sendText: async (args) => {
chamada += 1;
if (chamada === 1) throw new Error('Z-PRO falhou');
return { data: { ticketId: 1 } };
}
});
const resumo = await runCampaignQueue({ db, zproClient });
assert.equal(resumo.enviados, 1);
assert.equal(resumo.erros, 1);
const erro = listQueue(db, campanha.id, 'error')[0];
const send = db.prepare('SELECT * FROM outreach_sends WHERE id = ?').get(erro.outreach_send_id);
assert.equal(send.status, 'erro');
db.close();
});
test('runCampaignQueue respeita o limite diario da campanha', async () => {
const db = openDb(':memory:');
for (let i = 0; i < 3; i += 1) inserirLead(db, `l${i}`, `551199999000${i}`);
const campanha = createCampaign(db, {
nome: 'C', produto: 'ERP', segmentos: ['x'], variantes: [{ code: 'A', mensagem: 'oi' }],
limiteDiarioInicial: 1
});
setCampaignStatus(db, campanha.id, 'rodando');
generateCampaignQueue(db, campanha.id);
approveQueueRows(db, campanha.id, listQueue(db, campanha.id, 'preview').map((r) => r.id));
const zproClient = fakeZproClient();
const resumo = await runCampaignQueue({ db, zproClient });
assert.equal(resumo.enviados, 1);
assert.equal(zproClient.enviados.length, 1);
assert.equal(listQueue(db, campanha.id, 'approved').length, 2);
db.close();
});
test('runCampaignQueue pula e cancela linha de numero que entrou em opt-out depois da fila gerada', async () => {
const db = openDb(':memory:');
const campanha = campanhaAprovada(db);
addOptOut(db, '5511999990000', 'pediu pra parar');
db.prepare(`UPDATE outreach_campaign_queue SET numero = '5511999990000' WHERE campaign_id = ?`).run(campanha.id);
const zproClient = fakeZproClient();
const resumo = await runCampaignQueue({ db, zproClient });
assert.equal(resumo.pulados, 1);
assert.equal(zproClient.enviados.length, 0);
const cancelada = listQueue(db, campanha.id, 'cancelled')[0];
assert.equal(cancelada.cancel_reason, 'opt_out');
db.close();
});
test('runCampaignQueue so processa campanhas com status rodando', async () => {
const db = openDb(':memory:');
inserirLead(db, 'l1', '5511999990001');
const campanha = createCampaign(db, {
nome: 'C', produto: 'ERP', segmentos: ['x'], variantes: [{ code: 'A', mensagem: 'oi' }]
});
generateCampaignQueue(db, campanha.id);
approveQueueRows(db, campanha.id, listQueue(db, campanha.id, 'preview').map((r) => r.id));
// campanha continua em 'rascunho' — nunca foi iniciada
const zproClient = fakeZproClient();
const resumo = await runCampaignQueue({ db, zproClient });
assert.equal(resumo.enviados, 0);
assert.equal(zproClient.enviados.length, 0);
db.close();
});
test('runCampaignQueue interrompe a campanha quando a saude aciona auto-pausa', async () => {
const db = openDb(':memory:');
const campanha = campanhaAprovada(db, 10);
db.prepare(`UPDATE outreach_campaigns SET limite_diario_atual = 10 WHERE id = ?`).run(campanha.id);
let chamada = 0;
const zproClient = fakeZproClient({
sendText: async () => {
chamada += 1;
if (chamada <= 8) return { data: { ticketId: chamada } };
throw new Error('falha simulada');
}
});
await runCampaignQueue({ db, zproClient });
const atualizada = db.prepare('SELECT status FROM outreach_campaigns WHERE id = ?').get(campanha.id);
// 10 tentativas, 2 erros = 20% > 10% -> deveria pausar antes de esgotar a fila
assert.equal(atualizada.status, 'pausado');
db.close();
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/campaign-worker.test.mjs`
Expected: FAIL — módulo não existe
- [ ] **Step 3: Implementar**
Criar `src/outreach/campaign-worker.mjs`:
```js
import { createZproClient } from './zpro-client.mjs';
import { isOptedOut } from './campaign-store.mjs';
import { evaluateCampaignHealth } from './campaign-metrics.mjs';
function todayAttempts(db, campaignId) {
return Number(db.prepare(
`SELECT COUNT(*) AS total
FROM outreach_campaign_queue q
JOIN outreach_sends s ON s.id = q.outreach_send_id
WHERE q.campaign_id = ? AND date(s.sent_at, 'localtime') = date('now', 'localtime')`
).get(campaignId).total);
}
// Diferente da Maquina Pessoal (que reserva o envio antes de mandar, porque a
// entrega via Baileys e assincrona/incerta), aqui o envio via Z-PRO
// (zproClient.sendText) e sincrono: ou resolve (aceito pelo Z-PRO) ou lanca
// erro. Por isso o resultado ja e gravado direto como 'enviado'/'erro', sem
// um estado intermediario "reservado" nem logica de recuperacao pos-crash.
export async function runCampaignQueue({ db, zproClient, now = new Date(), log = () => {} }) {
const client = zproClient || createZproClient(db);
const summary = { enviados: 0, erros: 0, pulados: 0 };
const campaigns = db.prepare(`SELECT id FROM outreach_campaigns WHERE status = 'rodando'`).all();
for (const { id: campaignId } of campaigns) {
const campaign = db.prepare('SELECT * FROM outreach_campaigns WHERE id = ?').get(campaignId);
let attemptsToday = todayAttempts(db, campaignId);
while (attemptsToday < campaign.limite_diario_atual) {
const row = db.prepare(
`SELECT * FROM outreach_campaign_queue
WHERE campaign_id = ? AND status = 'approved'
ORDER BY id ASC LIMIT 1`
).get(campaignId);
if (!row) break;
if (isOptedOut(db, row.numero)) {
db.prepare(
`UPDATE outreach_campaign_queue SET status = 'cancelled', cancel_reason = 'opt_out', updated_at = datetime('now') WHERE id = ?`
).run(row.id);
summary.pulados += 1;
continue;
}
const jaEnviado = db.prepare(
`SELECT 1 FROM outreach_sends WHERE produto = ? AND status = 'enviado'
AND (lead_id = ? OR numero = ?) LIMIT 1`
).get(campaign.produto, row.lead_id, row.numero);
if (jaEnviado) {
db.prepare(
`UPDATE outreach_campaign_queue SET status = 'cancelled', cancel_reason = 'ja_contatado', updated_at = datetime('now') WHERE id = ?`
).run(row.id);
summary.pulados += 1;
continue;
}
const externalKey = `campanha-${campaignId}-${row.id}`;
const insert = db.prepare(
`INSERT INTO outreach_sends (lead_id, produto, numero, mensagem_enviada, status, erro, zpro_ticket_id, canal, origem)
VALUES (?, ?, ?, ?, ?, ?, ?, 'nao_oficial', 'automatico')`
);
let sendId;
let queueStatus;
try {
const resposta = await client.sendText({ number: row.numero, message: row.rendered_message, externalKey });
const ticketId = resposta?.data?.ticketId ? String(resposta.data.ticketId) : null;
sendId = Number(insert.run(row.lead_id, campaign.produto, row.numero, row.rendered_message, 'enviado', null, ticketId).lastInsertRowid);
queueStatus = 'sent';
summary.enviados += 1;
} catch (error) {
sendId = Number(insert.run(row.lead_id, campaign.produto, row.numero, row.rendered_message, 'erro', String(error.message || error), null).lastInsertRowid);
queueStatus = 'error';
summary.erros += 1;
log(`campanha #${campaignId}: envio falhou (fila #${row.id}): ${error.message}`);
}
db.prepare(
`UPDATE outreach_campaign_queue SET status = ?, outreach_send_id = ?, updated_at = datetime('now') WHERE id = ?`
).run(queueStatus, sendId, row.id);
attemptsToday += 1;
const health = evaluateCampaignHealth(db, campaignId, now);
if (health.pause) {
log(`campanha #${campaignId}: pausada automaticamente (${health.reason})`);
break;
}
}
}
return summary;
}
```
- [ ] **Step 4: Rodar e confirmar que passa**
Run: `node --test tests/campaign-worker.test.mjs`
Expected: PASS (6 testes)
- [ ] **Step 5: Rodar a suite inteira**
Run: `node --test tests/*.test.mjs`
Expected: todos os testes passam
- [ ] **Step 6: Commit**
```bash
git add src/outreach/campaign-worker.mjs tests/campaign-worker.test.mjs
git commit -m "Add campaign send worker with daily limit and health auto-pause"
```
---
### Task 7: `campaign-scheduler.mjs` — timer + wiring no boot do servidor
**Files:**
- Create: `src/outreach/campaign-scheduler.mjs`
- Modify: `scripts/servidor.mjs`
- Test: `tests/campaign-scheduler.test.mjs`
**Interfaces:**
- Consumes: `runCampaignQueue` de `./campaign-worker.mjs` (Task 6), `escalateWeeklyLimits` de `./campaign-store.mjs` (Task 2).
- Produces: `startCampaignScheduler({db, log}) -> stopFn`.
- [ ] **Step 1: Escrever o teste que falha**
Criar `tests/campaign-scheduler.test.mjs`:
```js
import test from 'node:test';
import assert from 'node:assert/strict';
import { openDb } from '../src/db.mjs';
import { startCampaignScheduler } from '../src/outreach/campaign-scheduler.mjs';
test('startCampaignScheduler retorna funcao de parada que limpa os timers sem lancar erro', () => {
const db = openDb(':memory:');
const stop = startCampaignScheduler({ db, log: () => {} });
assert.equal(typeof stop, 'function');
assert.doesNotThrow(() => stop());
db.close();
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/campaign-scheduler.test.mjs`
Expected: FAIL — módulo não existe
- [ ] **Step 3: Implementar**
Criar `src/outreach/campaign-scheduler.mjs`:
```js
import { runCampaignQueue } from './campaign-worker.mjs';
import { escalateWeeklyLimits } from './campaign-store.mjs';
const CICLO_MS = 20 * 60 * 1000;
// Timer interno separado do scheduler.mjs existente (run.mjs/runOutreachBatch)
// — mesmo padrao (setInterval com .unref(), primeiro ciclo antecipado pouco
// depois do boot), rodando ao lado sem interferir um no outro.
export function startCampaignScheduler({ db, log = () => {} }) {
const ciclo = () => {
escalateWeeklyLimits(db);
runCampaignQueue({ db, log }).catch((error) => {
log(`campanhas: erro inesperado no ciclo automatico: ${error.message}`);
});
};
const primeiro = setTimeout(ciclo, 45 * 1000);
primeiro.unref();
const timer = setInterval(ciclo, CICLO_MS);
timer.unref();
return () => {
clearTimeout(primeiro);
clearInterval(timer);
};
}
```
- [ ] **Step 4: Rodar e confirmar que passa**
Run: `node --test tests/campaign-scheduler.test.mjs`
Expected: PASS
- [ ] **Step 5: Ligar no boot do servidor**
Em `scripts/servidor.mjs`, adicionar o import junto aos demais (depois de `import { startOutreachScheduler } from '../src/outreach/scheduler.mjs';`):
```js
import { startCampaignScheduler } from '../src/outreach/campaign-scheduler.mjs';
```
E logo depois de `startOutreachScheduler({ db, log });`:
```js
startCampaignScheduler({ db, log });
```
- [ ] **Step 6: Rodar a suite inteira**
Run: `node --test tests/*.test.mjs`
Expected: todos os testes passam (o boot do servidor em si não tem teste automatizado — verificação manual: `npm start` sobe sem erro)
- [ ] **Step 7: Commit**
```bash
git add src/outreach/campaign-scheduler.mjs scripts/servidor.mjs tests/campaign-scheduler.test.mjs
git commit -m "Wire campaign scheduler into server boot"
```
---
### Task 8: Rotas HTTP (`src/server/routes/campaigns.mjs`)
**Files:**
- Create: `src/server/routes/campaigns.mjs`
- Modify: `src/server/index.mjs`
- Test: `tests/campaign-routes.test.mjs`
**Interfaces:**
- Consumes: tudo das Tasks 2, 4, 5 (`campaign-store.mjs`, `campaign-queue.mjs`, `campaign-metrics.mjs`).
- Produces: `registerCampaignRoutes(router, {db})`, registrada em `createAppServer`.
- [ ] **Step 1: Escrever os testes que falham**
Criar `tests/campaign-routes.test.mjs`:
```js
import test from 'node:test';
import assert from 'node:assert/strict';
import { openDb, createLeadInserter } from '../src/db.mjs';
import { createRouter } from '../src/server/router.mjs';
import { registerCampaignRoutes } from '../src/server/routes/campaigns.mjs';
function setupRouter(db) {
const router = createRouter();
registerCampaignRoutes(router, { db });
return router;
}
function fakeJson() {
const calls = [];
return { json: (status, data) => calls.push({ status, data }), calls };
}
function inserirLead(db, dedup, produto = 'ERP', segmento = 'oficinas') {
const inserir = createLeadInserter(db);
inserir({
dedup_key: dedup, empresa: 'Empresa', legal_name: '', whatsapp: `551199990${dedup}`, ddd: '11',
email: '', cidade: '', uf: '', segmento, segmento_label: '', interesse: '', cnpj: '', cnae: '',
endereco: '', website: '', pains_json: '[]', origem: 't', telefone_valido: 1, cnpj_valido: 0,
empresa_valida: 1, score: 50, classificacao: 'bom', motivo_classificacao: '', score_qualidade: 50,
score_comercial: 50, prioridade: 1, produto_principal: produto, produtos_json: '[]',
capture_run_id: null, captured_at: null, exported_at: null
});
}
test('POST /api/campaigns cria campanha com segmentos e variantes', async () => {
const db = openDb(':memory:');
const router = setupRouter(db);
const { handler } = router.match('POST', '/api/campaigns');
const { json, calls } = fakeJson();
await handler(null, null, { json, body: {
nome: 'ERP oficinas', produto: 'ERP', segmentos: ['oficinas'],
variantes: [{ mensagem: 'Ola {empresa}' }]
} });
assert.equal(calls[0].status, 200);
assert.equal(calls[0].data.produto, 'ERP');
assert.equal(calls[0].data.variants.length, 1);
db.close();
});
test('POST /api/campaigns rejeita sem segmentos', async () => {
const db = openDb(':memory:');
const router = setupRouter(db);
const { handler } = router.match('POST', '/api/campaigns');
const { json, calls } = fakeJson();
await handler(null, null, { json, body: { nome: 'X', produto: 'ERP', segmentos: [], variantes: [{ mensagem: 'oi' }] } });
assert.equal(calls[0].status, 400);
db.close();
});
test('GET /api/campaigns/segmentos lista segmentos distintos do produto com contagem', async () => {
const db = openDb(':memory:');
inserirLead(db, '1', 'ERP', 'oficinas');
inserirLead(db, '2', 'ERP', 'oficinas');
inserirLead(db, '3', 'ERP', 'padarias');
inserirLead(db, '4', 'G-Chat', 'padarias');
const router = setupRouter(db);
const { handler } = router.match('GET', '/api/campaigns/segmentos');
const { json, calls } = fakeJson();
await handler(null, null, { json, query: new URLSearchParams({ produto: 'ERP' }) });
assert.equal(calls[0].status, 200);
const segmentos = calls[0].data.segmentos;
assert.equal(segmentos.find((s) => s.value === 'oficinas').total, 2);
assert.equal(segmentos.find((s) => s.value === 'padarias').total, 1);
db.close();
});
test('fluxo completo: criar campanha, gerar fila, aprovar e checar saude', async () => {
const db = openDb(':memory:');
inserirLead(db, '1', 'ERP', 'oficinas');
const router = setupRouter(db);
const criar = router.match('POST', '/api/campaigns');
const respCriar = fakeJson();
await criar.handler(null, null, { json: respCriar.json, body: {
nome: 'C', produto: 'ERP', segmentos: ['oficinas'], variantes: [{ mensagem: 'Ola {empresa}' }]
} });
const campaignId = respCriar.calls[0].data.id;
const gerarFila = router.match('POST', `/api/campaigns/${campaignId}/gerar-fila`);
const respFila = fakeJson();
await gerarFila.handler(null, null, { json: respFila.json, params: { id: String(campaignId) }, body: {} });
assert.equal(respFila.calls[0].data.adicionadosNaFila, 1);
const listarFila = router.match('GET', `/api/campaigns/${campaignId}/fila`);
const respLista = fakeJson();
await listarFila.handler(null, null, { json: respLista.json, params: { id: String(campaignId) }, query: new URLSearchParams() });
const queueId = respLista.calls[0].data.fila[0].id;
const aprovar = router.match('POST', `/api/campaigns/${campaignId}/fila/aprovar`);
const respAprovar = fakeJson();
await aprovar.handler(null, null, { json: respAprovar.json, params: { id: String(campaignId) }, body: { queueIds: [queueId] } });
assert.equal(respAprovar.calls[0].data.aprovados, 1);
const saude = router.match('GET', `/api/campaigns/${campaignId}/saude`);
const respSaude = fakeJson();
await saude.handler(null, null, { json: respSaude.json, params: { id: String(campaignId) } });
assert.equal(respSaude.calls[0].data.pause, false);
db.close();
});
test('POST /api/campaigns/leads/:leadId/estagio grava estagio atual e historico', async () => {
const db = openDb(':memory:');
inserirLead(db, '1');
const lead = db.prepare('SELECT id FROM leads LIMIT 1').get();
const router = setupRouter(db);
const marcar = router.match('POST', '/api/campaigns/leads/:leadId/estagio');
const respMarcar = fakeJson();
await marcar.handler(null, null, { json: respMarcar.json, params: { leadId: String(lead.id) }, body: { stage: 'interessado', note: 'ligar amanha' } });
assert.equal(respMarcar.calls[0].status, 200);
const consultar = router.match('GET', '/api/campaigns/leads/:leadId/estagio');
const respConsultar = fakeJson();
await consultar.handler(null, null, { json: respConsultar.json, params: { leadId: String(lead.id) } });
assert.equal(respConsultar.calls[0].data.atual.stage, 'interessado');
assert.equal(respConsultar.calls[0].data.historico.length, 1);
db.close();
});
test('POST /api/campaigns/opt-out bloqueia e DELETE libera', async () => {
const db = openDb(':memory:');
const router = setupRouter(db);
const adicionar = router.match('POST', '/api/campaigns/opt-out');
await adicionar.handler(null, null, { json: fakeJson().json, body: { numero: '5511999990001', motivo: 'pediu' } });
assert.ok(db.prepare('SELECT 1 FROM outreach_opt_out WHERE numero = ?').get('5511999990001'));
const remover = router.match('DELETE', '/api/campaigns/opt-out/:numero');
await remover.handler(null, null, { json: fakeJson().json, params: { numero: '5511999990001' } });
assert.equal(db.prepare('SELECT 1 FROM outreach_opt_out WHERE numero = ?').get('5511999990001'), undefined);
db.close();
});
```
- [ ] **Step 2: Rodar e confirmar que falha**
Run: `node --test tests/campaign-routes.test.mjs`
Expected: FAIL — módulo não existe
- [ ] **Step 3: Implementar**
Criar `src/server/routes/campaigns.mjs`:
```js
import {
createCampaign, getCampaign, listCampaigns, setCampaignStatus, resumeCampaign,
addOptOut, removeOptOut
} from '../../outreach/campaign-store.mjs';
import { generateCampaignQueue, listQueue, approveQueueRows, cancelQueueRows } from '../../outreach/campaign-queue.mjs';
import { evaluateCampaignHealth, variantStats } from '../../outreach/campaign-metrics.mjs';
export function registerCampaignRoutes(router, { db }) {
router.add('POST', '/api/campaigns', async (req, res, { json, body }) => {
const nome = String(body?.nome || '').trim();
const produto = String(body?.produto || '').trim();
const segmentos = Array.isArray(body?.segmentos) ? body.segmentos.filter(Boolean) : [];
const variantesValidas = Array.isArray(body?.variantes)
? body.variantes.filter((v) => v && String(v.mensagem || '').trim())
: [];
if (!nome || !produto) { json(400, { erro: 'informe nome e produto' }); return; }
if (!segmentos.length) { json(400, { erro: 'escolha ao menos um segmento' }); return; }
if (!variantesValidas.length) { json(400, { erro: 'escreva ao menos uma variante de mensagem' }); return; }
const campanha = createCampaign(db, {
nome, produto, segmentos,
variantes: variantesValidas.map((v, i) => ({ code: v.code || String.fromCharCode(65 + i), mensagem: v.mensagem })),
limiteDiarioInicial: Number(body.limiteDiarioInicial) || 10,
limiteDiarioTeto: Number(body.limiteDiarioTeto) || 80
});
json(200, campanha);
});
router.add('GET', '/api/campaigns', async (req, res, { json }) => {
json(200, { campanhas: listCampaigns(db) });
});
// Precisa vir ANTES de GET /api/campaigns/:id (mesmo numero de segmentos no
// path — o router retorna a primeira rota que casar).
router.add('GET', '/api/campaigns/segmentos', async (req, res, { json, query }) => {
const produto = String(query?.get('produto') || '').trim();
if (!produto) { json(400, { erro: 'informe o produto' }); return; }
const segmentos = db.prepare(
`SELECT segmento AS value, COUNT(*) AS total FROM leads
WHERE produto_principal = ? AND segmento != '' GROUP BY segmento ORDER BY total DESC`
).all(produto);
json(200, { segmentos });
});
router.add('GET', '/api/campaigns/produtos', async (req, res, { json }) => {
const produtos = db.prepare(
`SELECT produto_principal AS value, COUNT(*) AS total FROM leads
WHERE produto_principal != '' GROUP BY produto_principal ORDER BY total DESC`
).all();
json(200, { produtos });
});
router.add('GET', '/api/campaigns/:id', async (req, res, { json, params }) => {
const campanha = getCampaign(db, Number(params.id));
if (!campanha) { json(404, { erro: 'campanha nao encontrada' }); return; }
json(200, campanha);
});
router.add('POST', '/api/campaigns/:id/gerar-fila', async (req, res, { json, params, body }) => {
try {
const resultado = generateCampaignQueue(db, Number(params.id), { quantidade: Number(body?.quantidade) || 50 });
json(200, resultado);
} catch (error) {
json(400, { erro: String(error.message || error) });
}
});
router.add('GET', '/api/campaigns/:id/fila', async (req, res, { json, params, query }) => {
json(200, { fila: listQueue(db, Number(params.id), query?.get('status') || null) });
});
router.add('POST', '/api/campaigns/:id/fila/aprovar', async (req, res, { json, params, body }) => {
const queueIds = Array.isArray(body?.queueIds) ? body.queueIds.map(Number).filter(Number.isFinite) : [];
json(200, { aprovados: approveQueueRows(db, Number(params.id), queueIds) });
});
router.add('POST', '/api/campaigns/:id/fila/cancelar', async (req, res, { json, params, body }) => {
const queueIds = Array.isArray(body?.queueIds) ? body.queueIds.map(Number).filter(Number.isFinite) : [];
json(200, { cancelados: cancelQueueRows(db, Number(params.id), queueIds, body?.motivo || 'operador') });
});
router.add('POST', '/api/campaigns/:id/iniciar', async (req, res, { json, params }) => {
json(200, setCampaignStatus(db, Number(params.id), 'rodando'));
});
router.add('POST', '/api/campaigns/:id/pausar', async (req, res, { json, params, body }) => {
json(200, setCampaignStatus(db, Number(params.id), 'pausado', body?.motivo || 'manual'));
});
router.add('POST', '/api/campaigns/:id/retomar', async (req, res, { json, params }) => {
json(200, resumeCampaign(db, Number(params.id)));
});
router.add('GET', '/api/campaigns/:id/saude', async (req, res, { json, params }) => {
json(200, evaluateCampaignHealth(db, Number(params.id)));
});
router.add('GET', '/api/campaigns/:id/variantes-stats', async (req, res, { json, params }) => {
json(200, { variantes: variantStats(db, Number(params.id)) });
});
router.add('POST', '/api/campaigns/leads/:leadId/estagio', async (req, res, { json, params, body }) => {
const stage = String(body?.stage || '').trim();
if (!stage) { json(400, { erro: 'informe o estagio' }); return; }
const leadId = Number(params.leadId);
db.prepare(
`INSERT INTO outreach_lead_states (lead_id, stage, updated_at) VALUES (?, ?, datetime('now'))
ON CONFLICT(lead_id) DO UPDATE SET stage = excluded.stage, updated_at = excluded.updated_at`
).run(leadId, stage);
db.prepare(
`INSERT INTO outreach_stage_events (lead_id, campaign_id, stage, note) VALUES (?, ?, ?, ?)`
).run(leadId, body?.campaignId ? Number(body.campaignId) : null, stage, body?.note || null);
json(200, { ok: true });
});
router.add('GET', '/api/campaigns/leads/:leadId/estagio', async (req, res, { json, params }) => {
const leadId = Number(params.leadId);
json(200, {
atual: db.prepare('SELECT * FROM outreach_lead_states WHERE lead_id = ?').get(leadId) || null,
historico: db.prepare('SELECT * FROM outreach_stage_events WHERE lead_id = ? ORDER BY id DESC').all(leadId)
});
});
router.add('POST', '/api/campaigns/leads/:leadId/agendamentos', async (req, res, { json, params, body }) => {
const kind = String(body?.kind || '').trim();
if (!kind) { json(400, { erro: 'informe o tipo de agendamento' }); return; }
db.prepare(
`INSERT INTO outreach_appointments (lead_id, kind, scheduled_at, note) VALUES (?, ?, ?, ?)`
).run(Number(params.leadId), kind, body?.scheduledAt || null, body?.note || null);
json(200, { ok: true });
});
router.add('GET', '/api/campaigns/leads/:leadId/agendamentos', async (req, res, { json, params }) => {
json(200, {
agendamentos: db.prepare('SELECT * FROM outreach_appointments WHERE lead_id = ? ORDER BY id DESC').all(Number(params.leadId))
});
});
router.add('POST', '/api/campaigns/opt-out', async (req, res, { json, body }) => {
const numero = String(body?.numero || '').trim();
if (!numero) { json(400, { erro: 'informe o numero' }); return; }
addOptOut(db, numero, body?.motivo || null);
json(200, { ok: true });
});
router.add('DELETE', '/api/campaigns/opt-out/:numero', async (req, res, { json, params }) => {
removeOptOut(db, params.numero);
json(200, { ok: true });
});
}
```
- [ ] **Step 4: Registrar as rotas no servidor**
Em `src/server/index.mjs`, adicionar o import junto aos outros (depois de `import { registerOutreachRoutes } from './routes/outreach.mjs';`):
```js
import { registerCampaignRoutes } from './routes/campaigns.mjs';
```
E depois de `registerOutreachRoutes(router, deps);`:
```js
registerCampaignRoutes(router, deps);
```
- [ ] **Step 5: Rodar e confirmar que passa**
Run: `node --test tests/campaign-routes.test.mjs`
Expected: PASS (6 testes)
- [ ] **Step 6: Rodar a suite inteira**
Run: `node --test tests/*.test.mjs`
Expected: todos os testes passam
- [ ] **Step 7: Commit**
```bash
git add src/server/routes/campaigns.mjs src/server/index.mjs tests/campaign-routes.test.mjs
git commit -m "Add campaign HTTP routes"
```
---
### Task 9: Front-end — aba Campanhas (esqueleto + criação de campanha)
**Files:**
- Modify: `public/index.html`
- Modify: `public/js/app.js`
- Create: `public/js/campanhas.js`
**Interfaces:**
- Consumes: `API.get`/`API.post` de `api.js`, `el`/`h`/`toast` de `api.js` (já existentes), rotas de `campaigns.mjs` (Task 8).
- Produces: objeto global `Campanhas` com `.ativar()`, chamado pelo listener de troca de aba em `app.js` — consumido pelas Tasks 10 e 11 que vão adicionar mais funções a esse mesmo módulo.
Sem teste automatizado (é UI); verificação manual descrita no Step 5.
- [ ] **Step 1: Adicionar a aba e o painel em `public/index.html`**
Trocar a linha 18 (depois do botão "Tratar Leads") para incluir o botão da nova aba:
```html
<button class="tab" data-tab="tratamento" role="tab" aria-selected="false">📊 Tratar Leads</button>
<button class="tab" data-tab="campanhas" role="tab" aria-selected="false">🎯 Campanhas</button>
```
Adicionar um novo `<section>` logo antes de `<script src="/js/api.js"></script>` (perto do fim do `<main>`, depois da section `tab-tratamento` existente):
```html
<!-- ==================== CAMPANHAS ==================== -->
<section id="tab-campanhas" class="tab-panel">
<div class="row space-between">
<h2>Campanhas de outreach</h2>
<button class="btn-ghost btn-sm" id="btn-nova-campanha" type="button">+ Nova campanha</button>
</div>
<div id="campanhas-lista" class="lista"></div>
<dialog id="modal-nova-campanha">
<form id="form-nova-campanha" method="dialog">
<h2>Nova campanha</h2>
<div class="field">
<label for="campanha-nome">Nome</label>
<input type="text" id="campanha-nome" required>
</div>
<div class="field">
<label for="campanha-produto">Produto</label>
<select id="campanha-produto" required></select>
</div>
<div class="field">
<label>Segmentos</label>
<div id="campanha-segmentos" class="chips"></div>
</div>
<div class="field">
<label>Variantes de mensagem (A/B/C)</label>
<div id="campanha-variantes"></div>
<button class="btn-ghost btn-sm" id="btn-add-variante" type="button">+ Variante</button>
</div>
<div class="row">
<label>Limite diário inicial <input type="number" id="campanha-limite-inicial" value="10" min="1"></label>
<label>Teto do limite <input type="number" id="campanha-limite-teto" value="80" min="1"></label>
</div>
<p class="muted" id="campanha-erro"></p>
<div class="row space-between">
<button class="btn-ghost" id="btn-cancelar-campanha" type="button">Cancelar</button>
<button class="btn btn-primary" id="btn-salvar-campanha" type="button">Criar campanha</button>
</div>
</form>
</dialog>
</section>
</main>
<script src="/js/api.js"></script>
```
(o `</main>` e o `<script src="/js/api.js">` já existem no arquivo — o bloco acima só insere a nova `<section>` imediatamente antes deles, sem duplicar as tags de fechamento.)
- [ ] **Step 2: Registrar o script e o disparo da aba em `app.js`**
Em `public/index.html`, adicionar antes de `<script src="/js/app.js"></script>`:
```html
<script src="/js/campanhas.js"></script>
```
Em `public/js/app.js`, dentro do loop de troca de aba (perto da linha 66), trocar:
```js
if (tab.dataset.tab === 'tratamento') Tratamento.ativar();
```
por:
```js
if (tab.dataset.tab === 'tratamento') Tratamento.ativar();
if (tab.dataset.tab === 'campanhas') Campanhas.ativar();
```
- [ ] **Step 3: Criar `public/js/campanhas.js` com listagem e criação**
```js
/* Aba Campanhas: criacao, fila de aprovacao, saude/variantes, estagio/agendamento. */
const Campanhas = (() => {
let carregado = false;
let variantesCount = 0;
const STATUS_LABELS = { rascunho: 'Rascunho', rodando: 'Rodando', pausado: 'Pausado', concluido: 'Concluido' };
function addVarianteRow(codigoSugerido) {
const codigo = codigoSugerido || String.fromCharCode(65 + variantesCount);
variantesCount += 1;
el('campanha-variantes').append(
h('div', { class: 'row', 'data-variante-code': codigo },
h('span', { class: 'chip' }, codigo),
h('textarea', { class: 'campanha-variante-mensagem', rows: 2, placeholder: 'Ola {empresa}, ...' }))
);
}
async function carregarProdutos() {
const { produtos } = await API.get('/api/campaigns/produtos');
el('campanha-produto').replaceChildren(
...produtos.map((p) => h('option', { value: p.value }, `${p.value} (${fmt.format(p.total)} leads)`))
);
}
async function carregarSegmentos(produto) {
const container = el('campanha-segmentos');
if (!produto) { container.replaceChildren(); return; }
const { segmentos } = await API.get(`/api/campaigns/segmentos?produto=${encodeURIComponent(produto)}`);
container.replaceChildren(...segmentos.map((s) =>
h('label', { class: 'chip' },
h('input', { type: 'checkbox', value: s.value, class: 'campanha-segmento-check' }),
` ${s.value} (${fmt.format(s.total)})`)
));
}
function segmentosSelecionados() {
return Array.from(document.querySelectorAll('.campanha-segmento-check:checked')).map((i) => i.value);
}
function variantesPreenchidas() {
return Array.from(el('campanha-variantes').children).map((row) => ({
code: row.dataset.varianteCode,
mensagem: row.querySelector('.campanha-variante-mensagem').value.trim()
})).filter((v) => v.mensagem);
}
async function abrirModalNovaCampanha() {
el('campanha-nome').value = '';
el('campanha-limite-inicial').value = 10;
el('campanha-limite-teto').value = 80;
el('campanha-erro').textContent = '';
el('campanha-variantes').replaceChildren();
variantesCount = 0;
addVarianteRow('A');
await carregarProdutos();
await carregarSegmentos(el('campanha-produto').value);
el('modal-nova-campanha').showModal();
}
function renderCampanhaCard(campanha) {
return h('div', { class: 'item' },
h('div', {},
h('strong', {}, campanha.nome),
h('span', { class: 'sub' }, ` ${campanha.produto} — ${campanha.segmentos.join(', ')}`)),
h('span', { class: `chip ${campanha.status === 'rodando' ? 'ok' : campanha.status === 'pausado' ? 'warn' : ''}` },
STATUS_LABELS[campanha.status] || campanha.status));
}
async function carregarLista() {
const { campanhas } = await API.get('/api/campaigns');
el('campanhas-lista').replaceChildren(
...(campanhas.length ? campanhas.map(renderCampanhaCard) : [h('p', { class: 'muted' }, 'Nenhuma campanha criada ainda.')])
);
}
function ativar() {
if (carregado) return;
carregado = true;
el('btn-nova-campanha').addEventListener('click', () => {
abrirModalNovaCampanha().catch((error) => toast(`Erro: ${error.message}`));
});
el('btn-cancelar-campanha').addEventListener('click', () => el('modal-nova-campanha').close());
el('btn-add-variante').addEventListener('click', () => addVarianteRow());
el('campanha-produto').addEventListener('change', (event) => {
carregarSegmentos(event.target.value).catch((error) => toast(`Erro: ${error.message}`));
});
el('btn-salvar-campanha').addEventListener('click', async () => {
try {
await API.post('/api/campaigns', {
nome: el('campanha-nome').value.trim(),
produto: el('campanha-produto').value,
segmentos: segmentosSelecionados(),
variantes: variantesPreenchidas(),
limiteDiarioInicial: Number(el('campanha-limite-inicial').value) || 10,
limiteDiarioTeto: Number(el('campanha-limite-teto').value) || 80
});
el('modal-nova-campanha').close();
toast('Campanha criada');
await carregarLista();
} catch (error) {
el('campanha-erro').textContent = error.message;
}
});
carregarLista().catch((error) => toast(`Erro: ${error.message}`));
}
return { ativar };
})();
```
- [ ] **Step 4: Adicionar estilo mínimo para o modal de campanha (reaproveitando classes existentes)**
Nenhuma classe CSS nova é necessária — `dialog`, `.field`, `.row`, `.chip`, `.chips`, `.item`, `.lista`, `.btn`/`.btn-primary`/`.btn-ghost` já existem em `public/css/app.css` e cobrem este formulário. Pular este step se a revisão visual (Step 5) não apontar necessidade.
- [ ] **Step 5: Verificação manual no navegador**
Rodar `npm start`, abrir `http://127.0.0.1:3900`, logar, clicar na aba "🎯 Campanhas", clicar em "+ Nova campanha", escolher um produto (a lista deve carregar da base de leads existente), marcar segmentos, escrever ao menos uma variante, salvar — a campanha deve aparecer na lista com status "Rascunho".
- [ ] **Step 6: Commit**
```bash
git add public/index.html public/js/app.js public/js/campanhas.js
git commit -m "Add Campanhas tab: listing and campaign creation"
```
---
### Task 10: Front-end — fila de aprovação, saúde e comparação de variantes
**Files:**
- Modify: `public/js/campanhas.js`
- Modify: `public/index.html`
**Interfaces:**
- Consumes: rotas `/api/campaigns/:id/gerar-fila`, `/api/campaigns/:id/fila`, `/api/campaigns/:id/fila/aprovar`, `/api/campaigns/:id/fila/cancelar`, `/api/campaigns/:id/iniciar`, `/api/campaigns/:id/pausar`, `/api/campaigns/:id/retomar`, `/api/campaigns/:id/saude`, `/api/campaigns/:id/variantes-stats` (todas da Task 8).
- Produces: adiciona `abrirDetalheCampanha(campanhaId)` ao módulo `Campanhas`, acionado ao clicar num card da lista (Task 9).
- [ ] **Step 1: Adicionar o painel de detalhe em `public/index.html`**
Dentro da `<section id="tab-campanhas">`, logo depois de `<div id="campanhas-lista" class="lista"></div>`, adicionar:
```html
<div id="campanha-detalhe" class="card hidden">
<div class="row space-between">
<h2 id="detalhe-nome"></h2>
<div class="row">
<span class="chip" id="detalhe-status"></span>
<button class="btn-ghost btn-sm" id="btn-fechar-detalhe" type="button">Fechar</button>
</div>
</div>
<div class="row" id="detalhe-acoes">
<button class="btn-ghost btn-sm" id="btn-iniciar-campanha" type="button">Iniciar</button>
<button class="btn-ghost btn-sm" id="btn-pausar-campanha" type="button">Pausar</button>
<button class="btn-ghost btn-sm" id="btn-retomar-campanha" type="button">Retomar</button>
<button class="btn-ghost btn-sm" id="btn-gerar-fila" type="button">Gerar fila</button>
</div>
<p class="muted" id="detalhe-saude"></p>
<div id="detalhe-variantes" class="row"></div>
<div class="row space-between">
<h3>Fila</h3>
<select id="fila-filtro-status">
<option value="preview">Preview</option>
<option value="approved">Aprovadas</option>
<option value="sent">Enviadas</option>
<option value="error">Erro</option>
<option value="cancelled">Canceladas</option>
</select>
</div>
<div class="row">
<button class="btn-ghost btn-sm" id="btn-aprovar-selecionados" type="button">Aprovar selecionados</button>
<button class="btn-ghost btn-sm" id="btn-cancelar-selecionados" type="button">Cancelar selecionados</button>
</div>
<table>
<thead><tr><th></th><th>Empresa</th><th>Numero</th><th>Mensagem</th><th>Status</th></tr></thead>
<tbody id="fila-tabela"></tbody>
</table>
</div>
```
- [ ] **Step 2: Implementar em `public/js/campanhas.js`**
Adicionar, dentro do IIFE, antes do `return { ativar };` final:
```js
let campanhaAtualId = null;
async function carregarDetalhe(campanhaId) {
campanhaAtualId = campanhaId;
const campanha = await API.get(`/api/campaigns/${campanhaId}`);
el('detalhe-nome').textContent = campanha.nome;
el('detalhe-status').textContent = STATUS_LABELS[campanha.status] || campanha.status;
el('campanha-detalhe').classList.remove('hidden');
await Promise.all([carregarSaude(campanhaId), carregarVariantesStats(campanhaId), carregarFila(campanhaId)]);
}
async function carregarSaude(campanhaId) {
const saude = await API.get(`/api/campaigns/${campanhaId}/saude`);
el('detalhe-saude').textContent = saude.pause
? `Pausada automaticamente: ${saude.reason}`
: 'Saude: sem alertas.';
}
async function carregarVariantesStats(campanhaId) {
const { variantes } = await API.get(`/api/campaigns/${campanhaId}/variantes-stats`);
el('detalhe-variantes').replaceChildren(...variantes.map((v) =>
h('span', { class: 'chip' },
`${v.code}: ${v.enviados} enviados, ${(v.taxaResposta * 100).toFixed(1)}% resposta${v.elegivelParaComparacao ? ' (elegivel)' : ''}`)
));
}
async function carregarFila(campanhaId) {
const status = el('fila-filtro-status').value;
const { fila } = await API.get(`/api/campaigns/${campanhaId}/fila?status=${status}`);
el('fila-tabela').replaceChildren(...fila.map((linha) =>
h('tr', {},
h('td', {}, h('input', { type: 'checkbox', class: 'fila-check', value: linha.id })),
h('td', {}, String(linha.lead_id)),
h('td', {}, linha.numero),
h('td', {}, linha.rendered_message),
h('td', {}, linha.status))
));
}
function filaSelecionada() {
return Array.from(document.querySelectorAll('.fila-check:checked')).map((i) => Number(i.value));
}
function ligarDetalheCampanha() {
el('btn-fechar-detalhe').addEventListener('click', () => el('campanha-detalhe').classList.add('hidden'));
el('fila-filtro-status').addEventListener('change', () => carregarFila(campanhaAtualId).catch((e) => toast(`Erro: ${e.message}`)));
el('btn-gerar-fila').addEventListener('click', async () => {
try {
const resultado = await API.post(`/api/campaigns/${campanhaAtualId}/gerar-fila`, {});
toast(`${resultado.adicionadosNaFila} leads adicionados a fila`);
await carregarFila(campanhaAtualId);
} catch (error) { toast(`Erro: ${error.message}`); }
});
el('btn-iniciar-campanha').addEventListener('click', async () => {
await API.post(`/api/campaigns/${campanhaAtualId}/iniciar`, {});
await carregarDetalhe(campanhaAtualId);
await carregarLista();
});
el('btn-pausar-campanha').addEventListener('click', async () => {
await API.post(`/api/campaigns/${campanhaAtualId}/pausar`, { motivo: 'manual' });
await carregarDetalhe(campanhaAtualId);
await carregarLista();
});
el('btn-retomar-campanha').addEventListener('click', async () => {
await API.post(`/api/campaigns/${campanhaAtualId}/retomar`, {});
await carregarDetalhe(campanhaAtualId);
await carregarLista();
});
el('btn-aprovar-selecionados').addEventListener('click', async () => {
const queueIds = filaSelecionada();
if (!queueIds.length) return;
const resultado = await API.post(`/api/campaigns/${campanhaAtualId}/fila/aprovar`, { queueIds });
toast(`${resultado.aprovados} aprovados`);
await carregarFila(campanhaAtualId);
});
el('btn-cancelar-selecionados').addEventListener('click', async () => {
const queueIds = filaSelecionada();
if (!queueIds.length) return;
const resultado = await API.post(`/api/campaigns/${campanhaAtualId}/fila/cancelar`, { queueIds, motivo: 'operador' });
toast(`${resultado.cancelados} cancelados`);
await carregarFila(campanhaAtualId);
});
}
```
Trocar `renderCampanhaCard` para tornar o card clicável (adicionar `onclick` no `h('div', { class: 'item' }, ...)`):
```js
function renderCampanhaCard(campanha) {
return h('div', { class: 'item', onclick: () => carregarDetalhe(campanha.id).catch((e) => toast(`Erro: ${e.message}`)) },
h('div', {},
h('strong', {}, campanha.nome),
h('span', { class: 'sub' }, ` ${campanha.produto} — ${campanha.segmentos.join(', ')}`)),
h('span', { class: `chip ${campanha.status === 'rodando' ? 'ok' : campanha.status === 'pausado' ? 'warn' : ''}` },
STATUS_LABELS[campanha.status] || campanha.status));
}
```
E, na função `ativar()`, chamar `ligarDetalheCampanha();` junto dos outros listeners (antes de `carregarLista().catch(...)`).
- [ ] **Step 2: Verificação manual**
Com uma campanha criada (Task 9), clicar no card dela, clicar "Iniciar", "Gerar fila", selecionar linhas e clicar "Aprovar selecionados" — a fila deve refletir o novo status e, depois de um ciclo do `campaign-scheduler` (ou chamando `runCampaignQueue` manualmente via um teste/REPL), as linhas aprovadas devem virar "sent" desde que `zpro.*` esteja configurado em Configurações.
- [ ] **Step 3: Commit**
```bash
git add public/index.html public/js/campanhas.js
git commit -m "Add campaign detail panel: queue approval, health and variant stats"
```
---
### Task 11: Front-end — classificação de estágio e agendamento + checagem final da suite
**Files:**
- Modify: `public/js/campanhas.js`
- Modify: `public/index.html`
- Test: rodar a suite inteira (nenhum arquivo de teste novo — esta task é só UI + verificação)
**Interfaces:**
- Consumes: rotas `/api/campaigns/leads/:leadId/estagio` (GET/POST) e `/api/campaigns/leads/:leadId/agendamentos` (GET/POST) da Task 8.
- [ ] **Step 1: Adicionar controles de estágio/agendamento por linha da fila em `public/index.html`**
Trocar o `<thead>` da tabela de fila (adicionada na Task 10) para incluir uma coluna de ação:
```html
<thead><tr><th></th><th>Empresa</th><th>Numero</th><th>Mensagem</th><th>Status</th><th>Estagio</th></tr></thead>
```
- [ ] **Step 2: Implementar em `public/js/campanhas.js`**
Trocar a função `carregarFila` (da Task 10) para incluir o seletor de estágio por linha (só faz sentido para linhas já `sent`/`error`, que de fato foram contatadas):
```js
const STAGE_OPTIONS = [
'respondeu', 'interessado', 'demonstracao_agendada', 'sem_interesse', 'opt_out', 'venda_fechada'
];
async function carregarFila(campanhaId) {
const status = el('fila-filtro-status').value;
const { fila } = await API.get(`/api/campaigns/${campanhaId}/fila?status=${status}`);
el('fila-tabela').replaceChildren(...fila.map((linha) => {
const podeMarcarEstagio = linha.status === 'sent' || linha.status === 'error';
const stageSelect = h('select', { class: 'fila-estagio-select', disabled: podeMarcarEstagio ? null : 'disabled' },
h('option', { value: '' }, '—'),
...STAGE_OPTIONS.map((s) => h('option', { value: s }, s)));
const marcarBtn = h('button', {
class: 'btn-ghost btn-sm', type: 'button', disabled: podeMarcarEstagio ? null : 'disabled',
onclick: async () => {
if (!stageSelect.value) return;
await API.post(`/api/campaigns/leads/${linha.lead_id}/estagio`, { stage: stageSelect.value, campaignId: campanhaId });
toast('Estagio atualizado');
if (stageSelect.value === 'demonstracao_agendada') {
const dataAgendamento = prompt('Data/hora do agendamento (AAAA-MM-DD HH:MM):');
if (dataAgendamento) {
await API.post(`/api/campaigns/leads/${linha.lead_id}/agendamentos`, { kind: 'demonstracao', scheduledAt: dataAgendamento });
toast('Agendamento registrado');
}
}
}
}, 'Marcar');
return h('tr', {},
h('td', {}, h('input', { type: 'checkbox', class: 'fila-check', value: linha.id })),
h('td', {}, String(linha.lead_id)),
h('td', {}, linha.numero),
h('td', {}, linha.rendered_message),
h('td', {}, linha.status),
h('td', { class: 'row' }, stageSelect, marcarBtn));
}));
}
```
- [ ] **Step 3: Verificação manual**
Com uma linha de fila em status `sent` (após um envio real ou simulado), abrir o detalhe da campanha, escolher um estágio no seletor da linha, clicar "Marcar" — checar via `GET /api/campaigns/leads/:leadId/estagio` (ou na aba Tratar Leads, se o lead for aberto lá) que o estágio foi gravado. Marcar `demonstracao_agendada` deve pedir a data e criar um agendamento.
- [ ] **Step 4: Rodar a suite inteira e revisar `git status`**
Run: `node --test tests/*.test.mjs`
Expected: todos os testes passam (backend Tasks 1-8 + qualquer teste pré-existente)
Run: `git status --short`
Expected: só os arquivos desta feature aparecem como modificados/staged do lado do que este plano tocou — nada do WIP alheio (outreach existente, capture, etc.) deve ter sido alterado por engano.
- [ ] **Step 5: Commit**
```bash
git add public/index.html public/js/campanhas.js
git commit -m "Add stage classification and appointment scheduling UI"
```
---
## Self-Review
**Cobertura da spec:** catálogo dinâmico (Task 2/9), fila/preview/aprovação (Task 4/10), variantes A/B/C só não-oficial (Task 3/6, `zproClient.sendText`), escalonamento semanal (Task 2/7), saúde/auto-pausa (Task 5/6), classificação de estágio e agendamento manual (Task 8/11), prevenção de contato duplicado com `run.mjs` (Task 4, cláusula `NOT EXISTS` por `lead_id OR numero`), opt-out (Task 2/6). Tudo coberto.
**Placeholder scan:** nenhum "TBD"/"implementar depois" — todo step tem código completo.
**Consistência de tipos:** `getCampaign` retorna `{...row, segmentos: [], variants: []}` — usado identicamente em `campaign-queue.mjs`, `campaign-worker.mjs` (via `db.prepare` direto, não via `getCampaign`, para pegar `limite_diario_atual` fresco a cada iteração do loop) e nas rotas. `variantForLead`/`renderCampaignMessage` com a mesma assinatura em `campaign-messages.mjs`, `campaign-queue.mjs`. Status de fila (`preview|approved|cancelled|sent|error`) e de campanha (`rascunho|rodando|pausado|concluido`) usados de forma consistente em todas as tasks.
Reference in New Issue View Git Blame Copy Permalink