429 lines
12 KiB
JavaScript
429 lines
12 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 diagnostics = [];
|
|
|
|
var endpoints = [
|
|
"/fiscal-invoices?key=" + key,
|
|
"fiscal-invoices?key=" + key,
|
|
"/fiscal/invoices?key=" + key,
|
|
"/fiscal/invoice?key=" + key,
|
|
"/invoice?key=" + key
|
|
];
|
|
|
|
var apiObj = null;
|
|
var hitInfo = "";
|
|
var lastApiMessage = "";
|
|
|
|
try {
|
|
var clientService = fluigAPI.getAuthorizeClientService();
|
|
for (var i = 0; i < endpoints.length; i++) {
|
|
var endpoint = endpoints[i];
|
|
var resp = invokeAuthorizedGet(clientService, endpoint, auth);
|
|
diagnostics.push(endpoint + " => 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;
|
|
break;
|
|
}
|
|
}
|
|
} catch (eService) {
|
|
diagnostics.push("authorizeClientService exception: " + eService);
|
|
}
|
|
|
|
if (!apiObj) {
|
|
var directUrls = [
|
|
"https://api.grupoginseng.com.br/fiscal-invoices?key=" + key,
|
|
"https://api.grupoginseng.com.br/fiscal/invoice?key=" + key
|
|
];
|
|
|
|
for (var d = 0; d < directUrls.length; d++) {
|
|
var url = directUrls[d];
|
|
var directResp = fetchDirect(url, 30000, auth);
|
|
diagnostics.push(url + " => 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;
|
|
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;
|
|
}
|
|
|
|
if (!apiObj.success || !apiObj.data) {
|
|
addErrorRow(dataset, trim(apiObj.message) || "NFe nao encontrada. Fonte: " + hitInfo);
|
|
return dataset;
|
|
}
|
|
|
|
var dataNfe = apiObj.data || {};
|
|
var itens = dataNfe.itens || [];
|
|
var itensJson = JSON.stringify(buildNfeItems(itens));
|
|
|
|
dataset.addRow([
|
|
"true",
|
|
"OK (" + hitInfo + ")",
|
|
trim(dataNfe.key),
|
|
trim(dataNfe.invoiceNumber),
|
|
trim(dataNfe.serie),
|
|
formatIsoDate(dataNfe.emissionDate),
|
|
formatIsoDate(dataNfe.operationDate),
|
|
trim(dataNfe.supplierName),
|
|
trim(dataNfe.documentValue),
|
|
trim(dataNfe.totalItemsValue),
|
|
trim(dataNfe.situation),
|
|
trim(dataNfe.fiscalOperationDescription),
|
|
String(itens.length),
|
|
itensJson,
|
|
trim(dataNfe.storeId),
|
|
trim(dataNfe.invoiceId),
|
|
trim(dataNfe.emitterEmployeeId),
|
|
formatIsoDateTime(dataNfe.updatedAt)
|
|
]);
|
|
} 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 "";
|
|
|
|
for (var i = 0; i < constraints.length; i++) {
|
|
var c = constraints[i];
|
|
if (!c || !c.fieldName) continue;
|
|
if (String(c.fieldName) === String(fieldName)) {
|
|
return c.initialValue;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function resolveAuth(constraints) {
|
|
var token = trim(getConstraintValue(constraints, "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(getConstraintValue(constraints, "basicUser"));
|
|
var basicPass = trim(getConstraintValue(constraints, "basicPass"));
|
|
|
|
// 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 invokeAuthorizedGet(clientService, endpoint, auth) {
|
|
var authHeader = resolveAuthHeader(auth);
|
|
var headers = { "Accept": "application/json" };
|
|
if (authHeader) {
|
|
headers.Authorization = authHeader;
|
|
if (auth && auth.token) {
|
|
headers["x-access-token"] = auth.token;
|
|
}
|
|
}
|
|
|
|
var data = {
|
|
companyId: String(getValue("WKCompany") || "1"),
|
|
serviceCode: "GinsengAPI2",
|
|
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 || !obj.data) return false;
|
|
if (obj.success === true) return true;
|
|
if (String(obj.success).toLowerCase() === "true") return true;
|
|
return false;
|
|
}
|
|
|
|
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 authHeader = resolveAuthHeader(auth);
|
|
if (authHeader) {
|
|
conn.setRequestProperty("Authorization", authHeader);
|
|
if (auth.token) conn.setRequestProperty("x-access-token", auth.token);
|
|
}
|
|
|
|
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 resolveAuthHeader(auth) {
|
|
auth = auth || {};
|
|
if (auth.basicUser && auth.basicPass) {
|
|
var raw = String(auth.basicUser) + ":" + String(auth.basicPass);
|
|
var bytes = new java.lang.String(raw).getBytes("UTF-8");
|
|
var encoded = java.util.Base64.getEncoder().encodeToString(bytes);
|
|
return "Basic " + String(encoded);
|
|
}
|
|
if (auth.token) {
|
|
return "Bearer " + String(auth.token);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
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)
|
|
});
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|