/* global React, Icon, Button, Badge, Chip, PageHead, EstadoDados, TabelaDados, PainelRegistro, brl, fmtDate, fmtDatetime, ymdLocal,
useMktFiltros, mktTituloDaTela, mktFechFiltroServidor, mktFechAplicar, lerTodas, emLotes, mktDeclaracaoDoLancamento,
mktEstadoRepasse, MKT_REPASSE_ESTADOS, mktLerConferencia, mktRendimentosFaltaTabela, MKT_PAGADOR_NO_EXTRATO,
mktPagadoresDaLoja, normNome, periodoLabel, mktRotuloDeclaracao, RepasseForm, MktComContas, MKT_REC_TOLERANCIA */
// ============================================================
// Marketplace_Recebimentos.jsx — Marketplace › Recebimentos (Lote D do redesenho, 12/10/2026)
//
// O dinheiro que JÁ ESTÁ no caixa LIGADO aos fechamentos (N:N: um saque para várias semanas, várias entradas para uma
// semana), a diferença CLASSIFICADA, e o Mercado Livre com "liberação na Fase 2". As seis decisões do PM sobre o passo 0:
// 1. dinheiro novo fora do mês declarado entra pelo LÍQUIDO (o que caiu) e a diferença se classifica sem conta; o
// "Registrar repasse" de antes fica só para completar os registros antigos (os 4 "baixado sem taxa" da Daforsil);
// 2. a diferença classificada é "Taxa de marketplace" (a série do DRE não se parte), com o TIPO na diferença e na linha;
// 3. o histórico guarda a fotografia do dinheiro; estornar nunca apaga;
// 4. UMA definição de estado: `mktEstadoRepasse` (db.js) aprende os vínculos — Lançamentos, Painel, Faturamento por canal e
// esta tela leem a mesma;
// 5. lê quem vê o Marketplace OU o Financeiro;
// 6. dinheiro sem pagador de plataforma NÃO é oferecido — a tela conta quantos e manda acertar o pagador no Financeiro.
// O que não é estilo:
// - quem grava é o BANCO (as funções do SUPABASE_marketplace-loteD.sql): as travas (conta da loja, pagador, Σ ≤ o que
// entrou, Σ ≤ esperado + MKT_REC_TOLERANCIA, "já está no caixa?") valem no servidor; aqui elas só explicam antes;
// - LIGAR e ESTORNAR não mudam número nenhum de caixa (é a prova Daforsil: PROVA_recebimentos-mkt.js e a réplica);
// só dois caminhos mudam número, e a tela diz qual e quanto antes: registrar dinheiro NOVO (o saldo da conta, pelo
// valor) e classificar FORA do mês declarado (a "Taxa de marketplace" do DRE de Relatórios, pelo valor);
// - o liberado da Shopee é da LOJA e do MÊS (a declaração), nunca dividido por semana.
// ============================================================
const MKT_REC_JANELA_DIAS = 15; // a janela do "já está no caixa?" = o "+ 15" da mkt_registrar_recebimento
const MKT_REC_TIPOS = [
{ id: 'taxa', rotulo: 'Taxa' }, { id: 'frete', rotulo: 'Frete' }, { id: 'devolucao', rotulo: 'Devolução' }, { id: 'ajuste', rotulo: 'Ajuste' },
];
const MKT_REC_SITUACOES = {
fora_do_caixa: { rotulo: 'fora do caixa do app', tom: 'neutral' },
sem_dinheiro: { rotulo: 'sem dinheiro ligado', tom: 'neutral' },
com_diferenca: { rotulo: 'com diferença a classificar', tom: 'warning' },
na_declaracao: { rotulo: 'recebido · o resto está na declaração', tom: 'success' },
conferido: { rotulo: 'recebido e conferido', tom: 'success' },
acima: { rotulo: 'acima do esperado', tom: 'warning' },
cheio_declarado: { rotulo: 'venda cheia em mês declarado — conferir', tom: 'warning' },
antigo_ok: { rotulo: 'repasse registrado (o registro de antes)', tom: 'success' },
antigo_conferir: { rotulo: 'registro de antes — conferir', tom: 'warning' },
};
const MKT_REC_FILTROS = [
['fila', 'Todos na fila'], ['sem_dinheiro', 'Sem dinheiro ligado'], ['com_diferenca', 'Com diferença'],
['na_declaracao', 'Diferença na declaração'], ['classificada', 'Classificada'], ['conferidos', 'Conferidos'], ['conferir', 'Para conferir'],
];
const MKT_REC_FECH_COLS = 'id,numero,marketplace_loja_id,periodo_inicio,periodo_fim,data_venda,status,total,origem';
const MKT_REC_DINHEIRO_COLS = 'id,referencia,cliente_nome,observacoes,valor,valor_recebido,status,data_pagamento,conta_id,natureza,pedido_id';
const MKT_REC_DECL_COLS = 'id,loja_id,periodo_inicio,periodo_fim,pagamento_liberado,taxa_gravada,taxas,cupons_rebates,subtotal_frete,frete_comprador,subtotal_mercadoria,preco_produto';
const MKT_REC_ABRIR = 'tm-mkt-rec-abrir'; // sessionStorage: o fechamento a abrir ao chegar (vindo de Vendas › Fechamentos)
// "abrir este fechamento ao chegar" (Vendas › Fechamentos manda para cá): guardado na aba; sem armazenamento, abre a lista
function mktRecAbrirDepois(id) {
try { window.sessionStorage.setItem(MKT_REC_ABRIR, id); return true; } catch (e) { return false; }
}
// ── funções puras (a PROVA_recebimentos-mkt.js roda estas) ──────────────────────────────────────────────────────
function mktRecR2(x) { return Math.round((Number(x) || 0) * 100) / 100; }
function mktRecMaisDias(ymd, n) {
const m = String(ymd || '').match(/^(\d{4})-(\d{2})-(\d{2})/);
return m ? new Date(Date.UTC(+m[1], +m[2] - 1, +m[3] + n)).toISOString().slice(0, 10) : '';
}
function mktRecTexto(r) { return normNome([r && r.cliente_nome, r && r.referencia, r && r.observacoes].join(' ')); }
// a plataforma do PAGADOR escrito no título (a MESMA lista da trava de 22/09 e do SQL): 'shopee' | 'tiktok' | 'mercado livre' | ''
function mktRecPagador(r) {
const t = mktRecTexto(r);
return Object.keys(MKT_PAGADOR_NO_EXTRATO).find((k) => MKT_PAGADOR_NO_EXTRATO[k].some((p) => t.includes(p))) || '';
}
function mktRecCasaLoja(loja, r) {
const t = mktRecTexto(r);
return mktPagadoresDaLoja(loja).some((p) => t.includes(p));
}
// o DINHEIRO no caixa: título sem pedido, que entrou, com data, receita (venda ou sem natureza) — a regra da mkt__vincular
function mktRecEhDinheiro(r) {
return !!r && !r.pedido_id && !!r.data_pagamento && window.finEntrouNoCaixa(r) && window.naturezaEhReceita(r.natureza);
}
// cada dinheiro: o que entrou (finValorQueEntrou: o parcial vale o recebido), o já ligado (vínculos ATIVOS) e o livre
function mktRecDinheiros(recs, vinculos) {
const lig = {}, porDinheiro = {};
(Array.isArray(vinculos) ? vinculos : []).forEach((v) => {
if (!v || !v.conta_receber_id) return;
(porDinheiro[v.conta_receber_id] = porDinheiro[v.conta_receber_id] || []).push(v);
if (!v.estornado_em) lig[v.conta_receber_id] = (lig[v.conta_receber_id] || 0) + (Number(v.valor) || 0);
});
return (Array.isArray(recs) ? recs : []).filter(mktRecEhDinheiro).map((r) => {
const entrou = mktRecR2(window.finValorQueEntrou(r)), ligado = mktRecR2(lig[r.id] || 0);
return { id: r.id, r, entrou, ligado, livre: mktRecR2(entrou - ligado), pagador: mktRecPagador(r),
data: String(r.data_pagamento).slice(0, 10), contaId: r.conta_id || null, vinculos: porDinheiro[r.id] || [] };
});
}
// a referência do título traz o período DESTE fechamento ("06–12/07")? É a sugestão — nunca o vínculo automático
function mktRecRefCasa(r, p) {
if (!r || !p || !p.periodo_inicio || !p.periodo_fim) return false;
const m = String([r.referencia, r.observacoes].join(' ')).match(/(\d{2})(?:\/(\d{2}))?\s*[-\u2013]\s*(\d{2})\/(\d{2})/);
if (!m) return false;
const dm = (iso) => String(iso).slice(8, 10) + '/' + String(iso).slice(5, 7);
return dm(p.periodo_inicio) === m[1] + '/' + (m[2] || m[4]) && dm(p.periodo_fim) === m[3] + '/' + m[4];
}
// os dinheiros que se ligam a este fechamento: da CONTA de recebimento da loja, do PAGADOR da plataforma, com saldo livre,
// a partir do início do período. A sugestão pela referência vem primeiro; depois os da janela (fim + 15 dias).
function mktRecCandidatos(p, loja, dinheiros) {
if (!p || !loja || !loja.conta_id) return [];
const de = String(p.periodo_inicio || p.data_venda || '').slice(0, 10);
const ate = mktRecMaisDias(p.periodo_fim || p.data_venda, MKT_REC_JANELA_DIAS);
return (Array.isArray(dinheiros) ? dinheiros : [])
.filter((d) => d.contaId === loja.conta_id && d.livre > 0.004 && d.data >= de && mktRecCasaLoja(loja, d.r))
.map((d) => ({ ...d, naJanela: d.data <= ate, sugestao: mktRecRefCasa(d.r, p) }))
.sort((a, b) => (Number(b.sugestao) - Number(a.sugestao)) || (Number(b.naJanela) - Number(a.naJanela)) || a.data.localeCompare(b.data));
}
// dinheiro da MESMA plataforma, livre, na janela, numa conta que não é a de NENHUMA loja dela (a TopMix TikTok recebendo
// Shopee, ou sem conta): não se liga (o banco recusa) — a tela conta e diz. A conta de outra loja da plataforma é dela.
function mktRecEmOutrasContas(p, loja, dinheiros, lojas) {
if (!p || !loja) return { n: 0, soma: 0 };
const de = String(p.periodo_inicio || p.data_venda || '').slice(0, 10), ate = mktRecMaisDias(p.periodo_fim || p.data_venda, MKT_REC_JANELA_DIAS);
const daPlataforma = new Set((Array.isArray(lojas) ? lojas : []).filter((l) => l.plataforma === loja.plataforma && l.conta_id).map((l) => l.conta_id));
const l = (Array.isArray(dinheiros) ? dinheiros : []).filter((d) => d.contaId !== loja.conta_id && !daPlataforma.has(d.contaId) && d.livre > 0.004
&& d.data >= de && d.data <= ate && mktRecCasaLoja(loja, d.r));
return { n: l.length, soma: mktRecR2(l.reduce((a, d) => a + d.livre, 0)) };
}
// O RESUMO DE CADA FECHAMENTO: esperado (P), recebido na conta (R), diferenças (D), saldo (S = P − R − D) e a situação.
// · modelo novo: R = Σ vínculos ativos; D = as linhas de taxa amarradas (as classificadas fora do mês declarado; o ajuste
// negativo entra com sinal) + as diferenças que só IDENTIFICAM (no mês que tem declaração AGORA);
// · registro de antes (título próprio): R = o que entrou nele − a taxa paga NA CONTA (o repasse antigo grava o bruto como
// recebido e paga a taxa na mesma conta: o dinheiro de verdade é a diferença); D = a taxa amarrada;
// · "fora do caixa do app": o fim do período + 15 dias cai antes da âncora da conta da loja — o dinheiro dele é anterior
// ao caixa do app (e não há o que ligar).
function mktRecResumo({ fechamentos, lojas, contas, recsLegado, taxas, decls, vinculos, diferencas }) {
const por = (lista, chave) => { const o = {}; (Array.isArray(lista) ? lista : []).forEach((x) => { if (x && x[chave]) (o[x[chave]] = o[x[chave]] || []).push(x); }); return o; };
const lojaPor = {}; (lojas || []).forEach((l) => { lojaPor[l.id] = l; });
const contaPor = {}; (contas || []).forEach((c) => { contaPor[c.id] = c; });
const recP = por(recsLegado, 'pedido_id'), txP = por(taxas, 'pedido_id'), vP = por(vinculos, 'pedido_id'), dP = por(diferencas, 'pedido_id');
const soma = (l) => mktRecR2((l || []).reduce((a, x) => a + (Number(x.valor) || 0), 0));
return (Array.isArray(fechamentos) ? fechamentos : []).map((p) => {
const loja = lojaPor[p.marketplace_loja_id] || null;
const conta = loja && loja.conta_id ? contaPor[loja.conta_id] || null : null;
const P = mktRecR2(p.total);
const legados = recP[p.id] || [], tx = txP[p.id] || [], vs = vP[p.id] || [], ds = dP[p.id] || [];
const vAt = vs.filter((v) => !v.estornado_em), dAt = ds.filter((d) => !d.estornado_em);
const decl = mktDeclaracaoDoLancamento(p, decls);
const temNovo = vAt.length > 0 || dAt.length > 0;
const V = soma(vAt), L = soma(tx);
const Ds = decl ? soma(dAt.filter((d) => !d.conta_pagar_id)) : 0;
let R, D;
if (legados.length) {
const entrouLeg = legados.reduce((a, r) => a + (window.finEntrouNoCaixa(r) ? window.finValorQueEntrou(r) : 0), 0);
const taxaNaConta = tx.filter((t) => t.status === 'Pago' && t.conta_id && t.data_pagamento).reduce((a, t) => a + (Number(t.valor) || 0), 0);
R = mktRecR2(entrouLeg - taxaNaConta); D = L;
} else { R = V; D = mktRecR2(L + Ds); }
const S = mktRecR2(P - R - D);
const estado = mktEstadoRepasse(legados, tx, !!decl, temNovo ? { temNovo, previsto: P, vinculado: V } : null);
const ancora = conta && conta.data_saldo_inicial ? String(conta.data_saldo_inicial).slice(0, 10) : '';
const fimMais = mktRecMaisDias(p.periodo_fim || p.data_venda, MKT_REC_JANELA_DIAS);
const foraDoCaixa = !!ancora && !!fimMais && fimMais < ancora && !legados.length && !temNovo;
let sit;
if (foraDoCaixa) sit = 'fora_do_caixa';
else if (legados.length) sit = (estado === 'registrado' || estado === 'taxa_na_declaracao') ? 'antigo_ok' : 'antigo_conferir';
else if (R <= 0.004) sit = 'sem_dinheiro';
else if (decl && R >= P - MKT_REC_TOLERANCIA) sit = 'cheio_declarado'; // o bruto a centavos: a Shopee sempre retém
else if (Math.abs(S) < 0.005) sit = 'conferido';
else if (S < 0) sit = 'acima';
else sit = decl ? 'na_declaracao' : 'com_diferenca';
return { id: p.id, p, loja, conta, P, R, D, S, V, L, Ds, decl, estado, sit, temNovo, foraDoCaixa, ancora, legados, tx,
vinculos: vs, vAtivos: vAt, diferencas: ds, dAtivas: dAt, classificada: dAt.length > 0 };
});
}
// o filtro rápido da fila (a fila = tudo que não está fora do caixa do app)
function mktRecPassaFiltro(x, filtro) {
if (x.sit === 'fora_do_caixa') return false;
switch (filtro) {
case 'sem_dinheiro': return x.sit === 'sem_dinheiro';
case 'com_diferenca': return x.sit === 'com_diferenca';
case 'na_declaracao': return x.sit === 'na_declaracao';
case 'classificada': return x.classificada;
case 'conferidos': return x.sit === 'conferido' || x.sit === 'antigo_ok';
case 'conferir': return x.sit === 'acima' || x.sit === 'cheio_declarado' || x.sit === 'antigo_conferir';
default: return true;
}
}
// quanto ainda cabe NESTE fechamento (esperado + tolerância − ligado − diferenças positivas): a mesma conta do banco
function mktRecCabe(x) {
const dPos = mktRecR2((x.dAtivas || []).filter((d) => Number(d.valor) > 0).reduce((a, d) => a + Number(d.valor), 0));
return Math.max(0, mktRecR2(x.P + MKT_REC_TOLERANCIA - x.V - dPos));
}
// a pendência da decisão 6: dinheiro de venda no caixa SEM pagador de plataforma no texto — não é oferecido aqui
function mktRecSemPagador(recs) {
const l = (Array.isArray(recs) ? recs : []).filter(mktRecEhDinheiro).filter((r) => !mktRecPagador(r));
return { n: l.length, soma: mktRecR2(l.reduce((a, r) => a + window.finValorQueEntrou(r), 0)) };
}
// esperado, recebido e liberado POR LOJA E MÊS (o liberado é da declaração do mês inteiro — nunca dividido por semana)
function mktRecPorLojaMes(linhas, decls) {
const g = {};
(Array.isArray(linhas) ? linhas : []).filter((x) => x.sit !== 'fora_do_caixa' && x.loja).forEach((x) => {
const mes = String(x.p.data_venda || '').slice(0, 7), k = x.loja.id + '|' + mes;
const o = g[k] || (g[k] = { loja: x.loja, mes, esperado: 0, recebido: 0, n: 0, liberado: null });
o.esperado = mktRecR2(o.esperado + x.P); o.recebido = mktRecR2(o.recebido + x.R); o.n++;
});
Object.values(g).forEach((o) => {
const fimMes = mktRecMaisDias(mktRecMaisDias(o.mes + '-01', 32).slice(0, 8) + '01', -1);
const d = (Array.isArray(decls) ? decls : []).find((r) => r.loja_id === o.loja.id && String(r.periodo_inicio).slice(0, 10) <= o.mes + '-01'
&& String(r.periodo_fim).slice(0, 10) >= fimMes);
o.liberado = d ? mktRecR2(d.pagamento_liberado) : null;
});
return Object.values(g).sort((a, b) => (a.loja.nome || '').localeCompare(b.loja.nome || '') || a.mes.localeCompare(b.mes));
}
// ── as gravações (cada uma, uma função do banco numa transação) ──────────────────────────────────────────────────
async function mktRecRpc(nome, args, op) {
const neg = window.tmNegadoAqui ? window.tmNegadoAqui(op || 'editar') : null;
if (neg) return { error: { message: neg } };
const { data, error } = await window.tmSupabase.rpc(nome, args);
return error ? { error } : { data };
}
const mktRecLigar = (dinheiro, alocacoes) => mktRecRpc('mkt_vincular_recebimento', { p_dinheiro: dinheiro, p_alocacoes: alocacoes });
const mktRecEstornarVinculo = (id, motivo) => mktRecRpc('mkt_estornar_vinculo', { p_vinculo: id, p_motivo: motivo });
const mktRecClassificar = (pedido, itens) => mktRecRpc('mkt_classificar_diferenca', { p_pedido: pedido, p_itens: itens });
const mktRecEstornarDiferenca = (id, motivo) => mktRecRpc('mkt_estornar_diferenca', { p_diferenca: id, p_motivo: motivo });
const mktRecRegistrar = (a) => mktRecRpc('mkt_registrar_recebimento', { p_conta: a.conta, p_data: a.data, p_valor: a.valor, p_alocacoes: a.alocacoes,
p_confirmo_outro: !!a.confirmo, p_observacao: a.observacao || null }, ['criar', 'editar']);
function mktRecErro(e) { return (e && (e.message || e.code)) || 'erro desconhecido'; }
// ── a leitura (as duas vistas) ──────────────────────────────────────────────────────────────────────────────────
// `f` = o filtro do servidor (mktFechFiltroServidor); a lista de dependências é a CHAVE dele (texto estável).
function useMktRecDados(f, reloadKey, comML) {
const [d, setD] = React.useState({ lendo: true, erro: '' });
React.useEffect(() => {
let vivo = true;
(async () => {
if (!window.tmSupabase) { setD({ lendo: false, erro: '', fech: [], lojas: [], contas: [], legados: [], taxas: [], decls: [], conf: { vinculos: [], diferencas: [] }, recs: [], ml: [] }); return; }
const sb = window.tmSupabase;
setD((x) => ({ ...x, lendo: true }));
const [fech, lojas, contas, decls, recs, conf, ml] = await Promise.all([
f.nada ? Promise.resolve({ data: [], error: null })
: lerTodas(() => mktFechAplicar(sb.from('pedidos').select(MKT_REC_FECH_COLS).eq('tipo_registro', 'fechamento').neq('status', 'Cancelado'), f)),
sb.from('marketplace_lojas').select('id,nome,plataforma,empresa_id,conta_id,situacao'),
sb.from('contas_bancarias').select('id,nome,data_saldo_inicial,situacao'),
sb.from('marketplace_rendimentos').select(MKT_REC_DECL_COLS),
lerTodas(() => sb.from('contas_receber').select(MKT_REC_DINHEIRO_COLS).is('pedido_id', null)),
mktLerConferencia(null),
// Mercado Livre: o previsto (o total dos pedidos que vieram da sincronização, no período) — a liberação é da Fase 2
f.nada || !comML ? Promise.resolve({ data: [], error: null })
: lerTodas(() => mktFechAplicar(sb.from('pedidos').select('id,total,marketplace_loja_id').eq('origem', 'mercadolivre').eq('status', 'Atendido'), f)),
]);
const declErr = decls.error && !mktRendimentosFaltaTabela(decls.error) ? decls.error : null;
const erro1 = fech.error || lojas.error || contas.error || declErr || recs.error || conf.error || ml.error;
if (erro1) { if (vivo) setD({ lendo: false, erro: mktRecErro(erro1) }); return; }
const ids = (fech.data || []).map((p) => p.id);
const [leg, tx] = await Promise.all([
ids.length ? emLotes(ids, (l) => sb.from('contas_receber').select('id,pedido_id,valor,valor_recebido,status,data_pagamento,conta_id,referencia').in('pedido_id', l)) : Promise.resolve({ data: [] }),
ids.length ? emLotes(ids, (l) => sb.from('contas_pagar').select('id,pedido_id,valor,status,conta_id,data_pagamento,referencia').eq('categoria', 'Taxa de marketplace').in('pedido_id', l)) : Promise.resolve({ data: [] }),
]);
const erro2 = leg.error || tx.error;
if (!vivo) return;
if (erro2) { setD({ lendo: false, erro: mktRecErro(erro2) }); return; }
setD({ lendo: false, erro: '', lidoEm: new Date().toISOString(), fech: fech.data || [], lojas: lojas.data || [], contas: contas.data || [],
legados: leg.data || [], taxas: tx.data || [], decls: decls.error ? [] : (decls.data || []), recs: recs.data || [],
conf: { vinculos: conf.vinculos, diferencas: conf.diferencas, instalado: conf.instalado !== false }, ml: ml.data || [] });
})();
return () => { vivo = false; };
}, [f.chave, reloadKey, comML]); // eslint-disable-line react-hooks/exhaustive-deps
return d;
}
// ── o painel de UM FECHAMENTO: os valores, o dinheiro ligado, as diferenças, e as duas ações dentro dele ──────────
function MktRecEstornar({ rotulo, onConfirmar, salvando }) {
const [aberto, setAberto] = React.useState(false);
const [motivo, setMotivo] = React.useState('');
if (!aberto) return ;
return (
setMotivo(e.target.value)} />
);
}
function PainelRecFechamento({ x, dinheiros, lojas, contaPor, onFechar, onGravou, onNav }) {
const { p, loja, conta } = x;
const [modo, setModo] = React.useState(null); // null | 'ligar' | 'novo' | 'classificar'
const [msg, setMsg] = React.useState('');
const [salvando, setSalvando] = React.useState(false);
const [histo, setHisto] = React.useState(false);
const [repassando, setRepassando] = React.useState(false);
const info = MKT_REC_SITUACOES[x.sit] || {};
const per = (p.periodo_inicio && p.periodo_fim) ? periodoLabel(p.periodo_inicio, p.periodo_fim) : (fmtDate(p.data_venda) || '—');
const contaNome = (id) => (contaPor[id] ? contaPor[id].nome : 'outra conta');
const legado = x.legados.length > 0;
const fim = async (r, feito) => {
setSalvando(false);
if (r && r.error) { setMsg('Nada foi gravado: ' + mktRecErro(r.error)); return false; }
setMsg(feito); setModo(null); onGravou();
return true;
};
// parte gravou e parte não (vários dinheiros, uma transação por dinheiro): diz o que ficou, e relê
const parcial = (texto) => { setSalvando(false); setMsg(texto); setModo(null); onGravou(); };
const estornarV = async (v, motivo) => { setSalvando(true); await fim(await mktRecEstornarVinculo(v.id, motivo), `Vínculo de R$ ${brl(v.valor)} estornado: o dinheiro continua no caixa, livre para outro fechamento.`); };
const estornarD = async (d, motivo) => { setSalvando(true); await fim(await mktRecEstornarDiferenca(d.id, motivo), `Diferença de R$ ${brl(d.valor)} estornada${d.conta_pagar_id ? ': a linha dela saiu de Contas a Pagar' : ''}.`); };
const acoes = [];
if (legado && x.sit === 'antigo_conferir') {
acoes.push({ id: 'repasse', rotulo: 'Conferir repasse (o registro de antes)', icone: 'landmark', pede: ['editar', 'criar'], onClick: () => setRepassando(true) });
} else if (!legado && x.sit !== 'fora_do_caixa') {
acoes.push({ id: 'classificar', rotulo: 'Conferir diferença', icone: 'list-checks', variante: 'secondary', pede: 'editar', desabilitado: salvando,
onClick: () => { setModo('classificar'); setMsg(''); } });
acoes.push({ id: 'ligar', rotulo: 'Registrar recebimento', icone: 'link', pede: 'editar', desabilitado: salvando,
onClick: () => { setModo('ligar'); setMsg(''); } });
}
const linhaD = (d) => (MKT_REC_TIPOS.find((t) => t.id === d.tipo) || {}).rotulo || d.tipo;
return (
{msg &&
{msg}
}
Esperado, recebido e o que falta
Esperado (venda cheia)
R$ {brl(x.P)}
Recebido na conta
R$ {brl(x.R)}
Diferenças classificadas
R$ {brl(x.D)}
Saldo
R$ {brl(x.S)}
{x.sit === 'fora_do_caixa' ? (x.decl ? 'declarado · fora do caixa do app' : 'fora do caixa do app · sem declaração') : info.rotulo}
{x.sit === 'fora_do_caixa' && <>O período termina antes de a conta {conta ? conta.nome : 'da loja'} começar no app ({fmtDate(x.ancora)}): o dinheiro dele é anterior ao caixa do app. Não há o que ligar{x.decl ? ', e a retenção está na declaração ' + mktRotuloDeclaracao(x.decl) : ''}.}
{x.sit === 'sem_dinheiro' && <>Nenhum dinheiro ligado ainda. "Registrar recebimento" mostra os saques da {loja ? loja.plataforma : 'plataforma'} na conta da loja que ainda estão livres — e só registra dinheiro novo se ele não estiver lá.}
{x.sit === 'com_diferenca' && <>O que entrou é menor que a venda cheia: a diferença (R$ {brl(x.S)}) é o que a plataforma reteve, a classificar — taxa, frete, devolução ou ajuste. O app não chama tudo de taxa sozinho. Ou ainda falta dinheiro: ligue antes de classificar.}
{x.sit === 'na_declaracao' && <>Mês com declaração ({mktRotuloDeclaracao(x.decl)}): a retenção do mês já está na linha da declaração. Classificar aqui só IDENTIFICA o que foi (nada é lançado).}
{x.sit === 'conferido' && <>Recebido e conferido ao centavo: o dinheiro ligado e as diferenças classificadas fecham a venda cheia.}
{x.sit === 'acima' && <>Ligado e classificado passam do esperado em R$ {brl(-x.S)}. Até R$ {brl(MKT_REC_TOLERANCIA)} é arredondamento da plataforma: classifique um ajuste negativo. Mais que isso, estorne o que não é deste fechamento.}
{x.sit === 'cheio_declarado' && <>O dinheiro ligado é a venda cheia, num mês com declaração — e nas declarações a Shopee sempre reteve parte. Confira no extrato do banco o que entrou: se o título traz o bruto, o saldo da conta está acima do banco pela retenção.}
{x.sit === 'antigo_ok' && <>Este fechamento foi conferido pelo registro de antes (o título próprio e a taxa amarrada). Ele fica como está.}
{x.sit === 'antigo_conferir' && <>Registro de antes, para conferir ({(MKT_REPASSE_ESTADOS[x.estado] || {}).rotulo || x.estado}): ele se completa pelo "Conferir repasse", com o extrato do banco na mão — completar mexe no saldo da conta, de propósito.}
{loja && loja.plataforma === 'Shopee' &&
O liberado pela Shopee é da loja e do mês (a declaração), não deste fechamento — está em "Por loja e mês", na lista.
{linhaD(d)}R$ {brl(d.valor)} · {d.conta_pagar_id ? 'linha "Taxa de marketplace" em Contas a Pagar (sem conta, sem data: não mexe em saldo)' : 'só identifica (mês declarado: a retenção está na declaração)'}
{d.observacao ?
{h.tipo ? linhaD(h) : 'Dinheiro de ' + fmtDate(h.dinheiro_data)}R$ {brl(h.valor)} · estornado em {fmtDatetime(h.estornado_em)} — {h.estorno_motivo}
))}
)}
{repassando && (
{(contas) => (
setRepassando(false)} onSaved={() => { setRepassando(false); onGravou(); }} />)}
)}
);
}
// "Registrar recebimento", passo 1: o dinheiro JÁ ESTÁ no caixa? Os saques livres da plataforma na conta da loja.
function MktRecLigar({ x, dinheiros, lojas, contaNome, salvando, setSalvando, fim, parcial, onNovo, onCancelar }) {
const cands = mktRecCandidatos(x.p, x.loja, dinheiros);
const outras = mktRecEmOutrasContas(x.p, x.loja, dinheiros, lojas);
const cabe = mktRecCabe(x);
const [sel, setSel] = React.useState({}); // { [dinheiro]: valor (texto do campo) }
const marcar = (d) => setSel((s) => {
const n = { ...s };
if (n[d.id] !== undefined) delete n[d.id];
else {
// a SUGESTÃO é o saldo do fechamento (o que falta para a venda cheia); a tolerância é o teto, nunca a sugestão
const usado = Object.values(n).reduce((a, v) => a + (Number(v) || 0), 0);
n[d.id] = String(mktRecR2(Math.max(0, Math.min(d.livre, x.S - usado))));
}
return n;
});
const total = mktRecR2(Object.values(sel).reduce((a, v) => a + (Number(v) || 0), 0));
const invalido = Object.entries(sel).some(([id, v]) => { const d = cands.find((c) => c.id === id); return !(Number(v) > 0) || !d || Number(v) > d.livre + 0.004; });
const ligar = async () => {
setSalvando(true);
const feitos = [];
for (const [id, v] of Object.entries(sel)) {
const r = await mktRecLigar(id, [{ pedido_id: x.id, valor: mktRecR2(v) }]);
if (r.error) {
// cada dinheiro é uma transação: o que já ligou FICA. Parar no primeiro que falha e dizer o feito e o não feito.
if (!feitos.length) { await fim(r); return; }
parcial(`Ligados ${feitos.length} de ${Object.keys(sel).length} dinheiros (R$ ${brl(feitos.reduce((a, b) => a + b, 0))}); o seguinte foi recusado: ${mktRecErro(r.error)}. Os já ligados ficam — tentar de novo liga só o que falta.`);
return;
}
feitos.push(mktRecR2(v));
}
await fim({}, `Ligado R$ ${brl(total)} a este fechamento. Nada mudou no caixa: o dinheiro já estava lá.`);
};
return (
Registrar recebimento · o dinheiro já está no caixa?
Saques da {x.loja ? x.loja.plataforma : 'plataforma'} em {x.loja && x.loja.conta_id ? contaNome(x.loja.conta_id) : 'a conta da loja'}, ainda livres, desde {fmtDate(x.p.periodo_inicio || x.p.data_venda)}. Falta R$ {brl(Math.max(0, x.S))} para a venda cheia (o banco aceita até R$ {brl(cabe)}: a tolerância de R$ {brl(MKT_REC_TOLERANCIA)} é para o centavo que a plataforma arredonda).
{outras.n} saque(s) da {x.loja.plataforma} na janela em conta que não é de loja {x.loja.plataforma} nenhuma, ou sem conta (R$ {brl(outras.soma)}): não se ligam a esta loja — a conta de recebimento dela é {contaNome(x.loja.conta_id)}. Se forem dela, acerte a conta do título no Financeiro.
}
{total > cabe + 0.004 &&
Passa do que cabe neste fechamento (R$ {brl(cabe)}).
}
);
}
// "Registrar recebimento", passo 2: dinheiro NOVO (que não está no app). Muda o caixa pelo valor — e a tela diz isso antes.
function MktRecNovo({ x, dinheiros, contaNome, salvando, setSalvando, fim, onVoltar }) {
const hoje = ymdLocal(new Date());
const [data, setData] = React.useState(hoje);
const [valor, setValor] = React.useState('');
const [aqui, setAqui] = React.useState('');
const [obs, setObs] = React.useState('');
const [confirmo, setConfirmo] = React.useState(false);
const cands = mktRecCandidatos(x.p, x.loja, dinheiros).filter((d) => d.naJanela);
const cabe = mktRecCabe(x);
const v = mktRecR2(valor), a = aqui === '' ? Math.min(v, Math.max(0, x.S)) : mktRecR2(aqui);
const pode = v > 0 && a > 0 && a <= v + 0.004 && a <= cabe + 0.004 && !!data && data <= hoje && (!cands.length || confirmo) && !salvando;
const gravar = async () => {
setSalvando(true);
const r = await mktRecRegistrar({ conta: x.loja.conta_id, data, valor: v, alocacoes: [{ pedido_id: x.id, valor: mktRecR2(a) }], confirmo, observacao: obs });
await fim(r, `Registrado R$ ${brl(v)} recebido em ${fmtDate(data)} na ${contaNome(x.loja.conta_id)}, R$ ${brl(a)} ligados a este fechamento${v - a > 0.004 ? ` (R$ ${brl(v - a)} ficam livres, em Por dinheiro)` : ''}.`);
};
return (
Registrar recebimento · dinheiro novo
Isto põe R$ {brl(v)} no saldo de {contaNome(x.loja.conta_id)} em {fmtDate(data) || '—'} e nos Recebimentos do DRE de caixa: é dinheiro que entrou no banco e ainda não estava no app. Se ele já está no app, volte e ligue — registrar de novo contaria duas vezes.
{cands.length > 0 && (
Já existe R$ {brl(cands.reduce((s, d) => s + d.livre, 0))} livre da {x.loja.plataforma} em {contaNome(x.loja.conta_id)} na janela deste período ({cands.length} saque(s)). Se este dinheiro é um deles, não registre: volte e ligue.
)}
Conta: {contaNome(x.loja.conta_id)} (a de recebimento da loja — dinheiro de outra conta não se liga a ela). Pagador: {x.loja.plataforma}.
);
}
// "Conferir diferença": o saldo dividido em linhas tipo + valor. Começa VAZIO (o app nunca põe o total em "taxa").
function MktRecClassificar({ x, salvando, setSalvando, fim, onCancelar }) {
const [linhas, setLinhas] = React.useState([{ tipo: '', valor: '', observacao: '' }]);
const soma = mktRecR2(linhas.reduce((a, l) => a + (Number(l.valor) || 0), 0));
const resta = mktRecR2(x.S - soma);
const set = (i, k, v) => setLinhas((ls) => ls.map((l, j) => (j === i ? { ...l, [k]: v } : l)));
const ok = linhas.length > 0 && linhas.every((l) => l.tipo && Number(l.valor) !== 0 && !isNaN(Number(l.valor)) && (Number(l.valor) > 0 || l.tipo === 'ajuste'));
const gravar = async () => {
setSalvando(true);
const itens = linhas.map((l) => ({ tipo: l.tipo, valor: mktRecR2(l.valor), observacao: l.observacao || null }));
await fim(await mktRecClassificar(x.id, itens), x.decl
? `Classificado R$ ${brl(soma)}: só identifica — a retenção do mês está na declaração ${mktRotuloDeclaracao(x.decl)}.`
: `Classificado R$ ${brl(soma)}: entra no DRE de Relatórios como "Taxa de marketplace" (o tipo fica na linha). O saldo das contas não muda.`);
};
const d = x.decl;
return (
Conferir diferença · saldo R$ {brl(x.S)}
{d
? <>Mês com declaração ({mktRotuloDeclaracao(d)}): classificar aqui só IDENTIFICA — nada é lançado. Da declaração do mês (a loja inteira): taxas R$ {brl(Math.abs(Number(d.taxas) || 0))} · cupons e frete R$ {brl(Math.abs(Number(d.cupons_rebates) || 0) + Math.abs(Number(d.subtotal_frete) || 0))} · frete do comprador R$ {brl(d.frete_comprador)} · liberado R$ {brl(d.pagamento_liberado)}.
: <>Cada linha vira "Taxa de marketplace" em Contas a Pagar, Pago, SEM conta e SEM data — a plataforma reteve antes de o dinheiro entrar: entra no DRE de Relatórios e não mexe no saldo de conta nenhuma. O ajuste negativo só absorve o que passou do esperado.}
{semPag.n} recebimento{semPag.n !== 1 ? 's' : ''} sem pagador de plataforma (R$ {brl(semPag.soma)}) — se forem da Shopee ou do TikTok, acerte o pagador no Financeiro: só dinheiro com o pagador da plataforma se liga a fechamento.
{' '}
)}
{mlLojas.map((l) => (
{l.nome} (Mercado Livre): esperado R$ {brl((ml[l.id] || {}).total || 0)} em {(ml[l.id] || {}).n || 0} venda{((ml[l.id] || {}).n || 0) !== 1 ? 's' : ''} no período · liberação e recebimento: Fase 2 (Mercado Pago). Sem vínculo e sem valor aqui: o dinheiro do ML cai no saldo do Mercado Pago, misturado, e a liberação por venda é da API dele.
O liberado é da loja no mês inteiro (por data de liberação); o esperado e o recebido são dos fechamentos do mês (por data de venda). Não fecham mês a mês, e não deveriam: entre liberar e sacar fica o saldo da carteira na plataforma.
setReloadKey((k) => k + 1)}>Atualizar a tela} />
{d.erro && setReloadKey((k) => k + 1)} />}
{ok && doML.length > 0 && (
Mercado Pago / Mercado Livre: {doML.length} recebimento{doML.length !== 1 ? 's' : ''} no caixa (R$ {brl(doML.reduce((a, x) => a + x.entrou, 0))}) — aguardam a Fase 2. Não se ligam às vendas do ML: são os agregados do mês, e dividi-los por venda seria palpite.