367 lines
15 KiB
TypeScript
367 lines
15 KiB
TypeScript
import { Request, Response } from 'express';
|
|
import { sendToN8n } from '../services/n8n.service';
|
|
import { sendTinyOrderToGraphs } from '../services/graphs.service';
|
|
import axios from 'axios';
|
|
import fs from 'fs';
|
|
import path from 'path';
|
|
|
|
type CachedOrderDetails = {
|
|
expiresAt: number;
|
|
fullOrderDetails: any;
|
|
statusProcessamento: string;
|
|
whatsappVendedor: string;
|
|
};
|
|
|
|
const orderDetailsCache = new Map<string, CachedOrderDetails>();
|
|
const configuredCacheTtlMs = Number(process.env.TINY_ORDER_DETAILS_CACHE_TTL_MS || 120000);
|
|
const ORDER_DETAILS_CACHE_TTL_MS = Number.isFinite(configuredCacheTtlMs) ? configuredCacheTtlMs : 120000;
|
|
|
|
function pruneExpiredOrderDetailsCache() {
|
|
const now = Date.now();
|
|
for (const [orderId, cached] of orderDetailsCache.entries()) {
|
|
if (now > cached.expiresAt) {
|
|
orderDetailsCache.delete(orderId);
|
|
}
|
|
}
|
|
}
|
|
|
|
function getCachedOrderDetails(orderId: string) {
|
|
const cached = orderDetailsCache.get(orderId);
|
|
if (!cached) return null;
|
|
|
|
if (Date.now() > cached.expiresAt) {
|
|
orderDetailsCache.delete(orderId);
|
|
return null;
|
|
}
|
|
|
|
return cached;
|
|
}
|
|
|
|
function setCachedOrderDetails(orderId: string, cached: Omit<CachedOrderDetails, 'expiresAt'>) {
|
|
if (ORDER_DETAILS_CACHE_TTL_MS <= 0) return;
|
|
|
|
pruneExpiredOrderDetailsCache();
|
|
orderDetailsCache.set(orderId, {
|
|
...cached,
|
|
expiresAt: Date.now() + ORDER_DETAILS_CACHE_TTL_MS
|
|
});
|
|
}
|
|
|
|
export const handleTinyOrderUpdate = async (req: Request, res: Response): Promise<void> => {
|
|
try {
|
|
// 1. Security Check: Verify token from Tiny
|
|
const expectedToken = process.env.TINY_WEBHOOK_SECRET;
|
|
const providedToken = req.query.token;
|
|
|
|
if (expectedToken && providedToken !== expectedToken) {
|
|
console.warn('Unauthorized webhook attempt. Invalid or missing token.');
|
|
res.status(401).json({ error: 'Unauthorized' });
|
|
return;
|
|
}
|
|
|
|
let payload = req.body || {};
|
|
|
|
if (payload && typeof payload.dados === 'string') {
|
|
try {
|
|
payload.dados = JSON.parse(payload.dados);
|
|
} catch (e) {}
|
|
}
|
|
|
|
console.log('Received webhook from Tiny. Acknowledging immediately...');
|
|
|
|
// Acknowledge Tiny immediately to prevent timeouts
|
|
res.status(200).send('OK');
|
|
|
|
const orderId = payload?.dados?.id;
|
|
if (!orderId) {
|
|
console.warn('No order ID found in webhook payload. Cannot fetch details.');
|
|
return;
|
|
}
|
|
|
|
const tinyApiToken = process.env.TINY_API_TOKEN;
|
|
let fullOrderDetails: any = null;
|
|
|
|
let statusProcessamento = "";
|
|
let whatsappVendedor = "";
|
|
|
|
const cachedDetails = getCachedOrderDetails(String(orderId));
|
|
if (cachedDetails) {
|
|
fullOrderDetails = cachedDetails.fullOrderDetails;
|
|
statusProcessamento = cachedDetails.statusProcessamento;
|
|
whatsappVendedor = cachedDetails.whatsappVendedor;
|
|
console.log(`Using cached order details for Order ID: ${orderId}.`);
|
|
} else if (tinyApiToken) {
|
|
try {
|
|
console.log(`Fetching full details for Order ID: ${orderId} from Tiny API...`);
|
|
const params = new URLSearchParams();
|
|
params.append('token', tinyApiToken);
|
|
params.append('id', orderId);
|
|
params.append('formato', 'JSON');
|
|
|
|
const apiResponse = await axios.post('https://api.tiny.com.br/api2/pedido.obter.php', params, {
|
|
headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
|
|
});
|
|
|
|
if (apiResponse.data?.retorno?.status === 'OK') {
|
|
fullOrderDetails = apiResponse.data.retorno.pedido;
|
|
statusProcessamento = apiResponse.data.retorno.status_processamento || "";
|
|
console.log(`Successfully fetched order details! Found phone: ${fullOrderDetails.cliente?.celular || fullOrderDetails.cliente?.fone || 'None'}`);
|
|
|
|
// OPTION B: Fetch Vendor's WhatsApp
|
|
const idVendedor = fullOrderDetails.id_vendedor;
|
|
if (process.env.TINY_FETCH_SELLER_DETAILS === 'true' && idVendedor && idVendedor !== "0") {
|
|
console.log(`Fetching seller details for Seller ID: ${idVendedor}...`);
|
|
const vendorParams = new URLSearchParams();
|
|
vendorParams.append('token', tinyApiToken);
|
|
vendorParams.append('id', idVendedor);
|
|
vendorParams.append('formato', 'JSON');
|
|
|
|
const vendorResponse = await axios.post('https://api.tiny.com.br/api2/contato.obter.php', vendorParams, {
|
|
headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
|
|
});
|
|
|
|
if (vendorResponse.data?.retorno?.status === 'OK') {
|
|
const contato = vendorResponse.data.retorno.contato;
|
|
whatsappVendedor = contato?.celular || contato?.fone || contato?.telefone || "";
|
|
console.log(`Successfully fetched seller WhatsApp: ${whatsappVendedor || 'None'}`);
|
|
} else {
|
|
console.error('Failed to fetch seller details:', JSON.stringify(vendorResponse.data?.retorno?.erros || 'Unknown API error'));
|
|
}
|
|
}
|
|
|
|
setCachedOrderDetails(String(orderId), {
|
|
fullOrderDetails,
|
|
statusProcessamento,
|
|
whatsappVendedor
|
|
});
|
|
} else {
|
|
console.error('Tiny API returned an error:', apiResponse.data?.retorno?.erros || 'Unknown error');
|
|
}
|
|
} catch (apiError: any) {
|
|
console.error('Failed to fetch from Tiny API:', apiError.message);
|
|
}
|
|
} else {
|
|
console.warn('TINY_API_TOKEN is not set in environment variables. Skipping full details fetch.');
|
|
}
|
|
|
|
// Build the exact flat JSON payload requested by the user
|
|
const finalPayload = {
|
|
id: fullOrderDetails?.id || payload.dados?.id || "",
|
|
numero: fullOrderDetails?.numero || payload.dados?.numero || "",
|
|
numero_ecommerce: fullOrderDetails?.numero_ecommerce || fullOrderDetails?.ecommerce?.numeroPedidoEcommerce || payload.dados?.idPedidoEcommerce || "",
|
|
data_pedido: fullOrderDetails?.data_pedido || payload.dados?.data || "",
|
|
data_prevista: fullOrderDetails?.data_prevista || "",
|
|
nome: fullOrderDetails?.cliente?.nome || payload.dados?.cliente?.nome || "",
|
|
valor: parseFloat(fullOrderDetails?.total_pedido || fullOrderDetails?.valor_total || "0"),
|
|
id_vendedor: fullOrderDetails?.id_vendedor || "",
|
|
nome_vendedor: fullOrderDetails?.nome_vendedor || "",
|
|
whatsapp_vendedor: whatsappVendedor,
|
|
situacao: fullOrderDetails?.situacao || payload.dados?.descricaoSituacao || "",
|
|
fone: fullOrderDetails?.cliente?.celular || fullOrderDetails?.cliente?.telefone || fullOrderDetails?.cliente?.fone || "",
|
|
email: fullOrderDetails?.cliente?.email || "",
|
|
status_processamento: statusProcessamento,
|
|
forma_envio: fullOrderDetails?.forma_envio || "",
|
|
codigo_rastreamento: fullOrderDetails?.codigo_rastreamento || "",
|
|
url_rastreamento: fullOrderDetails?.url_rastreamento || "",
|
|
itens: fullOrderDetails?.itens || [] // Added so n8n can filter specific products!
|
|
};
|
|
|
|
console.log('Forwarding formatted payload to n8n...');
|
|
|
|
const statusUrl = process.env.N8N_WEBHOOK_STATUS || process.env.N8N_WEBHOOK_URL;
|
|
const graphsUrl = process.env.N8N_WEBHOOK_GRAPHS;
|
|
|
|
console.log(`[Config Check] Status URL: ${statusUrl ? 'CONFIGURED' : 'MISSING'}`);
|
|
console.log(`[Config Check] Graphs URL: ${graphsUrl ? 'CONFIGURED' : 'MISSING'} (${graphsUrl})`);
|
|
|
|
const dispatchPromises: Promise<void>[] = [];
|
|
|
|
if (statusUrl) {
|
|
console.log('-> Preparing dispatch to Status Workflow...');
|
|
dispatchPromises.push(sendToN8n(finalPayload, statusUrl));
|
|
}
|
|
|
|
if (graphsUrl) {
|
|
console.log('-> Preparing dispatch to Graphs Workflow...');
|
|
dispatchPromises.push(sendToN8n(finalPayload, graphsUrl));
|
|
}
|
|
|
|
if (fullOrderDetails && (process.env.GRAPHS_API_URL || process.env.NEXSTAR_GRAPHS_API_URL)) {
|
|
console.log('-> Preparing direct dispatch to Graphs API...');
|
|
dispatchPromises.push(sendTinyOrderToGraphs(fullOrderDetails));
|
|
}
|
|
|
|
// Fire them all in parallel so one does not block the other
|
|
await Promise.allSettled(dispatchPromises);
|
|
console.log('All n8n dispatch attempts completed.');
|
|
|
|
} catch (error) {
|
|
console.error('Error handling Tiny webhook:', error);
|
|
}
|
|
};
|
|
|
|
export const handleTinyStockUpdate = async (req: Request, res: Response): Promise<void> => {
|
|
try {
|
|
const expectedToken = process.env.TINY_WEBHOOK_SECRET;
|
|
const providedToken = req.query.token;
|
|
|
|
if (expectedToken && providedToken !== expectedToken) {
|
|
console.warn('Unauthorized webhook attempt on stock. Invalid or missing token.');
|
|
res.status(401).json({ error: 'Unauthorized' });
|
|
return;
|
|
}
|
|
res.status(200).send('OK');
|
|
|
|
const targetUrl = process.env.N8N_WEBHOOK_STOCK;
|
|
if (!targetUrl) {
|
|
console.warn('N8N_WEBHOOK_STOCK is not defined in environment variables. Skipping forward.');
|
|
return;
|
|
}
|
|
|
|
console.log('Received stock webhook from Tiny. Calculating delta and stats...');
|
|
let payload = req.body || {};
|
|
if (payload && typeof payload.dados === 'string') {
|
|
try { payload.dados = JSON.parse(payload.dados); } catch (e) {}
|
|
}
|
|
|
|
// --- SMART MEMORY & STATS LOGIC ---
|
|
const memoryFile = path.join(process.cwd(), 'stock_memory.json');
|
|
let memory: Record<string, any> = {};
|
|
|
|
// Load memory if it exists
|
|
if (fs.existsSync(memoryFile)) {
|
|
try {
|
|
memory = JSON.parse(fs.readFileSync(memoryFile, 'utf-8'));
|
|
} catch (e) {
|
|
console.error("Failed to parse stock_memory.json, starting fresh.");
|
|
}
|
|
}
|
|
|
|
const dados = payload.dados || {};
|
|
const idProduto = String(dados.idProduto || dados.id || "");
|
|
const nomeProduto = String(dados.nome || dados.descricao || "Unknown");
|
|
const novoSaldo = Number(dados.saldo || 0);
|
|
|
|
let deltaEstoque = 0;
|
|
|
|
if (idProduto) {
|
|
// Backwards compatibility for old memory format (if it was just a number)
|
|
if (typeof memory[idProduto] === 'number') {
|
|
memory[idProduto] = {
|
|
saldo: memory[idProduto],
|
|
addCount: 0,
|
|
addTotal: 0,
|
|
addMax: 0,
|
|
addMin: null
|
|
};
|
|
}
|
|
|
|
const prodMem = memory[idProduto] || {
|
|
saldo: undefined,
|
|
addCount: 0,
|
|
addTotal: 0,
|
|
addMax: 0,
|
|
addMin: null
|
|
};
|
|
|
|
const estoqueAntigo = prodMem.saldo;
|
|
|
|
if (estoqueAntigo !== undefined) {
|
|
// Calculate delta
|
|
deltaEstoque = novoSaldo - estoqueAntigo;
|
|
|
|
// Track statistics if stock was ADDED
|
|
if (deltaEstoque > 0) {
|
|
prodMem.addCount += 1;
|
|
prodMem.addTotal += deltaEstoque;
|
|
|
|
if (deltaEstoque > prodMem.addMax) {
|
|
prodMem.addMax = deltaEstoque;
|
|
}
|
|
|
|
if (prodMem.addMin === null || deltaEstoque < prodMem.addMin) {
|
|
prodMem.addMin = deltaEstoque;
|
|
}
|
|
}
|
|
} else {
|
|
deltaEstoque = 0;
|
|
}
|
|
|
|
// Update current balance in memory
|
|
prodMem.saldo = novoSaldo;
|
|
memory[idProduto] = prodMem;
|
|
fs.writeFileSync(memoryFile, JSON.stringify(memory, null, 2));
|
|
|
|
console.log(`[Stock Tracker] Product ${idProduto}: Old=${estoqueAntigo ?? 'None'} -> New=${novoSaldo}. Delta=${deltaEstoque > 0 ? '+' : ''}${deltaEstoque}`);
|
|
|
|
// --- CSV LOGGING FOR ANALYSIS ---
|
|
if (deltaEstoque !== 0 || estoqueAntigo === undefined) {
|
|
const csvFile = path.join(process.cwd(), 'stock_log.csv');
|
|
const timestamp = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
|
|
const oldStockStr = estoqueAntigo !== undefined ? estoqueAntigo : 'NEW';
|
|
|
|
const adicionado = deltaEstoque > 0 ? deltaEstoque : 0;
|
|
const vendido = deltaEstoque < 0 ? Math.abs(deltaEstoque) : 0;
|
|
|
|
// Calculate current average
|
|
const mediaAdicionado = prodMem.addCount > 0 ? (prodMem.addTotal / prodMem.addCount).toFixed(2) : 0;
|
|
const minAdicionado = prodMem.addMin !== null ? prodMem.addMin : 0;
|
|
const maxAdicionado = prodMem.addMax;
|
|
|
|
const csvLine = `"${timestamp}","${idProduto}","${nomeProduto}","${oldStockStr}","${novoSaldo}","${adicionado}","${vendido}","${mediaAdicionado}","${maxAdicionado}","${minAdicionado}"\n`;
|
|
|
|
// Create file with headers if it doesn't exist
|
|
if (!fs.existsSync(csvFile)) {
|
|
fs.writeFileSync(csvFile, '"Data","ID_Produto","Nome_Produto","Estoque_Antigo","Estoque_Novo","Adicionado","Vendido","Media_Adicionado","Max_Adicionado","Min_Adicionado"\n');
|
|
}
|
|
|
|
fs.appendFileSync(csvFile, csvLine);
|
|
}
|
|
}
|
|
|
|
// Inject the delta and stats into the payload so n8n can easily read it
|
|
if (!payload.dados) payload.dados = {};
|
|
payload.dados.delta_estoque = deltaEstoque;
|
|
if (idProduto && memory[idProduto]) {
|
|
const pm = memory[idProduto];
|
|
payload.dados.media_adicionado = pm.addCount > 0 ? (pm.addTotal / pm.addCount).toFixed(2) : 0;
|
|
payload.dados.max_adicionado = pm.addMax;
|
|
payload.dados.min_adicionado = pm.addMin !== null ? pm.addMin : 0;
|
|
}
|
|
|
|
await sendToN8n(payload, targetUrl);
|
|
} catch (error) {
|
|
console.error('Error handling Tiny stock webhook:', error);
|
|
}
|
|
};
|
|
|
|
export const handleTinyGraphsUpdate = async (req: Request, res: Response): Promise<void> => {
|
|
try {
|
|
const expectedToken = process.env.TINY_WEBHOOK_SECRET;
|
|
const providedToken = req.query.token;
|
|
|
|
if (expectedToken && providedToken !== expectedToken) {
|
|
console.warn('Unauthorized webhook attempt on graphs. Invalid or missing token.');
|
|
res.status(401).json({ error: 'Unauthorized' });
|
|
return;
|
|
}
|
|
res.status(200).send('OK');
|
|
|
|
const targetUrl = process.env.N8N_WEBHOOK_GRAPHS;
|
|
if (!targetUrl) {
|
|
console.warn('N8N_WEBHOOK_GRAPHS is not defined in environment variables. Skipping forward.');
|
|
return;
|
|
}
|
|
|
|
console.log('Received graphs webhook from Tiny. Forwarding to n8n...');
|
|
let payload = req.body || {};
|
|
if (payload && typeof payload.dados === 'string') {
|
|
try { payload.dados = JSON.parse(payload.dados); } catch (e) {}
|
|
}
|
|
|
|
await sendToN8n(payload, targetUrl);
|
|
} catch (error) {
|
|
console.error('Error handling Tiny graphs webhook:', error);
|
|
}
|
|
};
|