635 lines
19 KiB
JavaScript
635 lines
19 KiB
JavaScript
function defineStructure() {
|
|
addColumn("success");
|
|
addColumn("message");
|
|
addColumn("key");
|
|
addColumn("invoiceNumber");
|
|
addColumn("serie");
|
|
addColumn("emissionDate");
|
|
addColumn("operationDate");
|
|
addColumn("supplierName");
|
|
addColumn("documentValue");
|
|
addColumn("totalItemsValue");
|
|
addColumn("situation");
|
|
addColumn("fiscalOperationDescription");
|
|
addColumn("itemCount");
|
|
addColumn("itensJson");
|
|
addColumn("storeId");
|
|
addColumn("invoiceId");
|
|
addColumn("emitterEmployeeId");
|
|
addColumn("updatedAt");
|
|
}
|
|
|
|
function onSync(lastSyncDate) {}
|
|
|
|
function createDataset(fields, constraints, sortFields) {
|
|
var dataset = DatasetBuilder.newDataset();
|
|
addDefaultColumns(dataset);
|
|
|
|
try {
|
|
var key = normalizeDigits(getConstraintValue(constraints, "key"));
|
|
if (!key) {
|
|
addErrorRow(dataset, "Informe a chave da NFe.");
|
|
return dataset;
|
|
}
|
|
|
|
if (!/^\d{44}$/.test(key)) {
|
|
addErrorRow(dataset, "A chave da NFe deve conter 44 digitos.");
|
|
return dataset;
|
|
}
|
|
|
|
var auth = resolveAuth(constraints);
|
|
var authVariants = buildAuthVariants(auth);
|
|
var diagnostics = [];
|
|
|
|
var query = "page=1&page_size=50&key=" + key + "&sort_by=updatedAt&sort_order=desc";
|
|
var endpoints = [
|
|
"/v2/vendas/rgb-transferencias?" + query,
|
|
"v2/vendas/rgb-transferencias?" + query,
|
|
"/rgb-transferencias?" + query
|
|
];
|
|
|
|
var apiObj = null;
|
|
var hitInfo = "";
|
|
var lastApiMessage = "";
|
|
|
|
try {
|
|
var clientService = fluigAPI.getAuthorizeClientService();
|
|
for (var i = 0; i < endpoints.length; i++) {
|
|
var endpoint = endpoints[i];
|
|
for (var a = 0; a < authVariants.length; a++) {
|
|
var authVariant = authVariants[a];
|
|
var resp = invokeAuthorizedGet(clientService, endpoint, authVariant);
|
|
diagnostics.push(endpoint + " [" + authVariant.name + "] => HTTP " + trim(resp.status));
|
|
var parsed = parseApiPayload(resp.body);
|
|
if (parsed && trim(parsed.message)) {
|
|
lastApiMessage = trim(parsed.message);
|
|
}
|
|
if (String(resp.status) === "200" && isApiSuccess(parsed)) {
|
|
apiObj = parsed;
|
|
hitInfo = endpoint + " [" + authVariant.name + "]";
|
|
break;
|
|
}
|
|
}
|
|
if (apiObj) {
|
|
break;
|
|
}
|
|
}
|
|
} catch (eService) {
|
|
diagnostics.push("authorizeClientService exception: " + eService);
|
|
}
|
|
|
|
if (!apiObj) {
|
|
var directUrls = [
|
|
"https://api.grupoginseng.com.br/v2/vendas/rgb-transferencias?" + query
|
|
];
|
|
|
|
for (var d = 0; d < directUrls.length; d++) {
|
|
var url = directUrls[d];
|
|
for (var da = 0; da < authVariants.length; da++) {
|
|
var directAuthVariant = authVariants[da];
|
|
var directResp = fetchDirect(url, 30000, directAuthVariant);
|
|
diagnostics.push(url + " [" + directAuthVariant.name + "] => HTTP " + trim(directResp.status));
|
|
var parsedDirect = parseApiPayload(directResp.body);
|
|
if (parsedDirect && trim(parsedDirect.message)) {
|
|
lastApiMessage = trim(parsedDirect.message);
|
|
}
|
|
if (String(directResp.status) === "200" && isApiSuccess(parsedDirect)) {
|
|
apiObj = parsedDirect;
|
|
hitInfo = url + " [" + directAuthVariant.name + "]";
|
|
break;
|
|
}
|
|
}
|
|
if (apiObj) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!apiObj) {
|
|
var msg = "Falha ao consultar API da NFe. Tentativas: " + diagnostics.join(" | ");
|
|
if (lastApiMessage) {
|
|
msg += " | Ultima mensagem da API: " + lastApiMessage;
|
|
}
|
|
addErrorRow(dataset, msg);
|
|
return dataset;
|
|
}
|
|
|
|
var dataNfe = extractInvoiceData(apiObj, key);
|
|
if (!dataNfe) {
|
|
addErrorRow(dataset, trim(apiObj.message) || "NFe nao encontrada. Fonte: " + hitInfo);
|
|
return dataset;
|
|
}
|
|
var itens = resolveItems(dataNfe);
|
|
var itensJson = JSON.stringify(buildNfeItems(itens));
|
|
|
|
dataset.addRow([
|
|
"true",
|
|
"OK (" + hitInfo + ")",
|
|
trim(dataNfe.key || dataNfe.nfeKey || dataNfe.chave || key),
|
|
trim(dataNfe.invoiceNumber || dataNfe.numeroNota || dataNfe.numero || dataNfe.number),
|
|
trim(dataNfe.serie || dataNfe.series),
|
|
formatIsoDate(dataNfe.emissionDate || dataNfe.issueDate || dataNfe.invoiceDate),
|
|
formatIsoDate(dataNfe.operationDate || dataNfe.transactionDate || dataNfe.operation_at),
|
|
trim(dataNfe.supplierName || dataNfe.supplier || dataNfe.fornecedor || dataNfe.emitente),
|
|
trim(dataNfe.documentValue || dataNfe.totalValue || dataNfe.valorDocumento || dataNfe.amount),
|
|
trim(dataNfe.totalItemsValue || dataNfe.itemsValue || dataNfe.valorItens || dataNfe.totalValue),
|
|
trim(dataNfe.situation || dataNfe.status),
|
|
trim(dataNfe.fiscalOperationDescription || dataNfe.operationDescription || dataNfe.naturezaOperacao),
|
|
String(itens.length),
|
|
itensJson,
|
|
trim(dataNfe.storeId || dataNfe.pdv || dataNfe.storeCode || dataNfe.lojaId),
|
|
trim(dataNfe.invoiceId || dataNfe.id_venda || dataNfe.id || dataNfe.transferId),
|
|
trim(dataNfe.emitterEmployeeId || dataNfe.emitterId || dataNfe.usuarioEmissor),
|
|
formatIsoDateTime(dataNfe.updatedAt || dataNfe.modifiedAt || dataNfe.lastUpdate)
|
|
]);
|
|
} catch (e) {
|
|
addErrorRow(dataset, "Erro ao consultar a NFe: " + e);
|
|
}
|
|
|
|
return dataset;
|
|
}
|
|
|
|
function onMobileSync(user) {}
|
|
|
|
function addDefaultColumns(dataset) {
|
|
dataset.addColumn("success");
|
|
dataset.addColumn("message");
|
|
dataset.addColumn("key");
|
|
dataset.addColumn("invoiceNumber");
|
|
dataset.addColumn("serie");
|
|
dataset.addColumn("emissionDate");
|
|
dataset.addColumn("operationDate");
|
|
dataset.addColumn("supplierName");
|
|
dataset.addColumn("documentValue");
|
|
dataset.addColumn("totalItemsValue");
|
|
dataset.addColumn("situation");
|
|
dataset.addColumn("fiscalOperationDescription");
|
|
dataset.addColumn("itemCount");
|
|
dataset.addColumn("itensJson");
|
|
dataset.addColumn("storeId");
|
|
dataset.addColumn("invoiceId");
|
|
dataset.addColumn("emitterEmployeeId");
|
|
dataset.addColumn("updatedAt");
|
|
}
|
|
|
|
function addErrorRow(dataset, message) {
|
|
dataset.addRow([
|
|
"false",
|
|
String(message || "Erro ao consultar NFe."),
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"0",
|
|
"[]",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]);
|
|
}
|
|
|
|
function getConstraintValue(constraints, fieldName) {
|
|
if (!constraints || !fieldName) return "";
|
|
var target = String(fieldName).toLowerCase();
|
|
|
|
for (var i = 0; i < constraints.length; i++) {
|
|
var c = constraints[i];
|
|
if (!c || !c.fieldName) continue;
|
|
if (String(c.fieldName).toLowerCase() === target) {
|
|
return c.initialValue;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function resolveAuth(constraints) {
|
|
var token = trim(getFirstConstraintValue(constraints, [
|
|
"token",
|
|
"accessToken",
|
|
"xAccessToken",
|
|
"bearerToken",
|
|
"access_token"
|
|
]));
|
|
if (!token) {
|
|
try {
|
|
token = trim(java.lang.System.getenv("GINSENG_FISCAL_TOKEN"));
|
|
} catch (e1) {}
|
|
}
|
|
if (!token) {
|
|
// fallback informado durante homologacao
|
|
token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJhcGlnaW5zZW5nIiwiZXhwIjoxNzg3NDQ4MDY3fQ.GJqcIJBkMIfp_q_KRzgGuAHWWo93j3FWo3TObKqlAwA";
|
|
}
|
|
|
|
var basicUser = trim(getFirstConstraintValue(constraints, [
|
|
"basicUser",
|
|
"username",
|
|
"user"
|
|
]));
|
|
var basicPass = trim(getFirstConstraintValue(constraints, [
|
|
"basicPass",
|
|
"password",
|
|
"pass"
|
|
]));
|
|
|
|
// Fallback operacional para homologacao, conforme credenciais validadas em teste manual.
|
|
if (!basicUser) basicUser = "fluig";
|
|
if (!basicPass) basicPass = "Ginseng@";
|
|
|
|
return {
|
|
token: token,
|
|
basicUser: basicUser,
|
|
basicPass: basicPass
|
|
};
|
|
}
|
|
|
|
function getFirstConstraintValue(constraints, names) {
|
|
if (!names || !(names instanceof Array)) return "";
|
|
for (var i = 0; i < names.length; i++) {
|
|
var val = getConstraintValue(constraints, names[i]);
|
|
if (trim(val)) return val;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function buildAuthVariants(auth) {
|
|
auth = auth || {};
|
|
var variants = [];
|
|
|
|
var token = trim(auth.token);
|
|
var basicUser = trim(auth.basicUser);
|
|
var basicPass = trim(auth.basicPass);
|
|
var basicHeader = buildBasicAuthHeader(basicUser, basicPass);
|
|
|
|
if (token) {
|
|
variants.push({
|
|
name: "Bearer+XToken",
|
|
authorization: "Bearer " + token,
|
|
xAccessToken: token
|
|
});
|
|
variants.push({
|
|
name: "XToken",
|
|
xAccessToken: token
|
|
});
|
|
variants.push({
|
|
name: "Bearer",
|
|
authorization: "Bearer " + token
|
|
});
|
|
}
|
|
|
|
if (basicHeader) {
|
|
variants.push({
|
|
name: "Basic",
|
|
authorization: basicHeader
|
|
});
|
|
if (token) {
|
|
variants.push({
|
|
name: "Basic+XToken",
|
|
authorization: basicHeader,
|
|
xAccessToken: token
|
|
});
|
|
}
|
|
}
|
|
|
|
variants.push({ name: "NoAuth" });
|
|
return dedupeAuthVariants(variants);
|
|
}
|
|
|
|
function dedupeAuthVariants(variants) {
|
|
var out = [];
|
|
var seen = {};
|
|
|
|
for (var i = 0; i < variants.length; i++) {
|
|
var v = variants[i] || {};
|
|
var signature = trim(v.authorization) + "|" + trim(v.xAccessToken);
|
|
if (seen[signature]) continue;
|
|
seen[signature] = true;
|
|
out.push(v);
|
|
}
|
|
|
|
if (!out.length) {
|
|
out.push({ name: "NoAuth" });
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function invokeAuthorizedGet(clientService, endpoint, authVariant) {
|
|
var headers = { "Accept": "application/json" };
|
|
applyAuthHeaders(headers, authVariant);
|
|
|
|
var data = {
|
|
companyId: String(getValue("WKCompany") || "1"),
|
|
serviceCode: "Fastapi",
|
|
endpoint: endpoint,
|
|
method: "get",
|
|
timeoutService: "30000",
|
|
params: {},
|
|
headers: headers
|
|
};
|
|
|
|
var vo = clientService.invoke(JSON.stringify(data));
|
|
return {
|
|
status: vo ? String(vo.getHttpStatusResult() || "") : "",
|
|
body: vo ? String(vo.getResult() || "") : ""
|
|
};
|
|
}
|
|
|
|
function parseApiPayload(bodyText) {
|
|
var raw = trim(bodyText);
|
|
if (!raw) return null;
|
|
|
|
var obj = parseJsonSafe(raw);
|
|
if (!obj) return null;
|
|
|
|
if (typeof obj.success !== "undefined" || typeof obj.data !== "undefined") {
|
|
return obj;
|
|
}
|
|
|
|
if (obj.content) {
|
|
if (typeof obj.content === "string") {
|
|
var c = parseJsonSafe(obj.content);
|
|
if (c) return c;
|
|
} else {
|
|
return obj.content;
|
|
}
|
|
}
|
|
|
|
if (obj.result) {
|
|
if (typeof obj.result === "string") {
|
|
var r = parseJsonSafe(obj.result);
|
|
if (r) return r;
|
|
} else {
|
|
return obj.result;
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
function isApiSuccess(obj) {
|
|
if (!obj) return false;
|
|
if (obj.success === true) return true;
|
|
if (String(obj.success).toLowerCase() === "true") return true;
|
|
if (obj.data || obj.items || obj.result || obj.content) return true;
|
|
return false;
|
|
}
|
|
|
|
function extractInvoiceData(apiObj, expectedKey) {
|
|
if (!apiObj) return null;
|
|
var normalizedKey = normalizeDigits(expectedKey);
|
|
return extractInvoiceFromNode(apiObj, normalizedKey);
|
|
}
|
|
|
|
function extractInvoiceFromNode(node, normalizedKey) {
|
|
if (!node) return null;
|
|
|
|
if (typeof node === "string") {
|
|
var parsed = parseJsonSafe(node);
|
|
if (!parsed) return null;
|
|
return extractInvoiceFromNode(parsed, normalizedKey);
|
|
}
|
|
|
|
if (node instanceof Array) {
|
|
return extractInvoiceFromArray(node, normalizedKey);
|
|
}
|
|
|
|
if (matchesInvoiceObject(node, normalizedKey)) {
|
|
return node;
|
|
}
|
|
|
|
var nestedCandidates = [
|
|
node.data,
|
|
node.items,
|
|
node.rows,
|
|
node.results,
|
|
node.content,
|
|
node.result,
|
|
node.list,
|
|
node.transferencias,
|
|
node.rgbTransferencias
|
|
];
|
|
|
|
for (var i = 0; i < nestedCandidates.length; i++) {
|
|
var nested = extractInvoiceFromNode(nestedCandidates[i], normalizedKey);
|
|
if (nested) return nested;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function extractInvoiceFromArray(list, normalizedKey) {
|
|
if (!list || !(list instanceof Array) || list.length === 0) return null;
|
|
|
|
for (var i = 0; i < list.length; i++) {
|
|
var item = list[i];
|
|
if (matchesInvoiceObject(item, normalizedKey)) {
|
|
return item;
|
|
}
|
|
}
|
|
|
|
return list[0] || null;
|
|
}
|
|
|
|
function matchesInvoiceObject(item, normalizedKey) {
|
|
if (!item || item instanceof Array || typeof item !== "object") return false;
|
|
|
|
var keyCandidate = normalizeDigits(item.key || item.nfeKey || item.chave || item.invoiceKey || item.nfe_key);
|
|
if (normalizedKey && keyCandidate) {
|
|
return keyCandidate === normalizedKey;
|
|
}
|
|
|
|
if (keyCandidate) return true;
|
|
|
|
var hasIdentity = trim(item.invoiceNumber || item.numeroNota || item.invoiceId || item.transferId);
|
|
return !!hasIdentity;
|
|
}
|
|
|
|
function resolveItems(dataNfe) {
|
|
if (!dataNfe || typeof dataNfe !== "object") return [];
|
|
|
|
var candidates = [
|
|
dataNfe.itens,
|
|
dataNfe.itensJson,
|
|
dataNfe.items,
|
|
dataNfe.products,
|
|
dataNfe.produtos
|
|
];
|
|
|
|
for (var i = 0; i < candidates.length; i++) {
|
|
var raw = candidates[i];
|
|
if (!raw) continue;
|
|
|
|
if (raw instanceof Array) {
|
|
return raw;
|
|
}
|
|
|
|
if (typeof raw === "string") {
|
|
var parsed = parseJsonSafe(raw);
|
|
if (parsed instanceof Array) {
|
|
return parsed;
|
|
}
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
function fetchDirect(url, timeoutMs, auth) {
|
|
var conn = null;
|
|
var reader = null;
|
|
try {
|
|
var URL = java.net.URL;
|
|
var InputStreamReader = java.io.InputStreamReader;
|
|
var BufferedReader = java.io.BufferedReader;
|
|
var StringBuilder = java.lang.StringBuilder;
|
|
|
|
conn = new URL(url).openConnection();
|
|
conn.setRequestMethod("GET");
|
|
conn.setConnectTimeout(timeoutMs || 30000);
|
|
conn.setReadTimeout(timeoutMs || 30000);
|
|
conn.setRequestProperty("Accept", "application/json");
|
|
|
|
var authHeaders = {};
|
|
applyAuthHeaders(authHeaders, auth);
|
|
for (var h in authHeaders) {
|
|
if (!authHeaders.hasOwnProperty(h)) continue;
|
|
if (!authHeaders[h]) continue;
|
|
conn.setRequestProperty(h, String(authHeaders[h]));
|
|
}
|
|
|
|
var status = conn.getResponseCode();
|
|
var stream = (status >= 200 && status < 300) ? conn.getInputStream() : conn.getErrorStream();
|
|
if (stream == null) return { status: status, body: "" };
|
|
|
|
reader = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
|
|
var sb = new StringBuilder();
|
|
var line = null;
|
|
while ((line = reader.readLine()) != null) {
|
|
sb.append(line);
|
|
}
|
|
|
|
return { status: String(status), body: String(sb.toString()) };
|
|
} catch (e) {
|
|
return { status: "", body: "" };
|
|
} finally {
|
|
try { if (reader) reader.close(); } catch (e1) {}
|
|
try { if (conn) conn.disconnect(); } catch (e2) {}
|
|
}
|
|
}
|
|
|
|
function applyAuthHeaders(headers, authVariant) {
|
|
headers = headers || {};
|
|
authVariant = authVariant || {};
|
|
|
|
var authorization = trim(authVariant.authorization);
|
|
var xAccessToken = trim(authVariant.xAccessToken);
|
|
|
|
if (authorization) {
|
|
headers.Authorization = authorization;
|
|
}
|
|
if (xAccessToken) {
|
|
headers["x-access-token"] = xAccessToken;
|
|
}
|
|
}
|
|
|
|
function buildBasicAuthHeader(basicUser, basicPass) {
|
|
var user = trim(basicUser);
|
|
var pass = trim(basicPass);
|
|
if (!user || !pass) return "";
|
|
|
|
var raw = String(user) + ":" + String(pass);
|
|
var bytes = new java.lang.String(raw).getBytes("UTF-8");
|
|
var encoded = java.util.Base64.getEncoder().encodeToString(bytes);
|
|
return "Basic " + String(encoded);
|
|
}
|
|
|
|
function buildNfeItems(items) {
|
|
var out = [];
|
|
if (!items || !(items instanceof Array)) return out;
|
|
|
|
for (var i = 0; i < items.length; i++) {
|
|
var item = items[i] || {};
|
|
out.push({
|
|
productId: trim(item.productId),
|
|
quantity: toNumber(item.quantity || item.completeQuantity),
|
|
code: trim(item.code || item.sku || item.productCode || item.codigo || item.productId),
|
|
unitValue: toNumber(item.unitValue || item.unit_value || item.value)
|
|
});
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function toNumber(value) {
|
|
var text = trim(value).replace(",", ".");
|
|
var n = parseFloat(text);
|
|
return isNaN(n) ? 0 : n;
|
|
}
|
|
|
|
function normalizeDigits(value) {
|
|
return String(value == null ? "" : value).replace(/\D/g, "");
|
|
}
|
|
|
|
function parseJsonSafe(text) {
|
|
try {
|
|
return JSON.parse(text);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function trim(value) {
|
|
return String(value == null ? "" : value).trim();
|
|
}
|
|
|
|
function formatIsoDate(value) {
|
|
var text = trim(value);
|
|
if (!text) return "";
|
|
|
|
try {
|
|
var datePart = text.split("T")[0].split("-");
|
|
if (datePart.length !== 3) {
|
|
return text;
|
|
}
|
|
return datePart[2] + "/" + datePart[1] + "/" + datePart[0];
|
|
} catch (e) {
|
|
return text;
|
|
}
|
|
}
|
|
|
|
function formatIsoDateTime(value) {
|
|
var text = trim(value);
|
|
if (!text) return "";
|
|
|
|
try {
|
|
var dt = text.split("T");
|
|
if (dt.length < 1) return text;
|
|
|
|
var datePart = dt[0].split("-");
|
|
if (datePart.length !== 3) return text;
|
|
|
|
var timePart = "";
|
|
if (dt.length > 1) {
|
|
timePart = dt[1].replace("Z", "");
|
|
var dotIndex = timePart.indexOf(".");
|
|
if (dotIndex >= 0) {
|
|
timePart = timePart.substring(0, dotIndex);
|
|
}
|
|
}
|
|
|
|
var dateStr = datePart[2] + "/" + datePart[1] + "/" + datePart[0];
|
|
if (!timePart) return dateStr;
|
|
|
|
return dateStr + " " + timePart;
|
|
} catch (e) {
|
|
return text;
|
|
}
|
|
}
|