att

2026-04-14 08:37:19 -03:00
parent fb2bec0fd5
commit 54ab21ef3b
91 changed files with 5660 additions and 195 deletions
@@ -38,14 +38,14 @@ function createDataset(fields, constraints, sortFields) {
        }

        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 = [
-            "/fiscal-invoices?key=" + key,
-            "fiscal-invoices?key=" + key,
-            "/fiscal/invoices?key=" + key,
-            "/fiscal/invoice?key=" + key,
-            "/invoice?key=" + key
+            "/v2/vendas/rgb-transferencias?" + query,
+            "v2/vendas/rgb-transferencias?" + query,
+            "/rgb-transferencias?" + query
        ];

        var apiObj = null;
@@ -56,15 +56,21 @@ function createDataset(fields, constraints, sortFields) {
            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);
+                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 (String(resp.status) === "200" && isApiSuccess(parsed)) {
-                    apiObj = parsed;
-                    hitInfo = endpoint;
+                if (apiObj) {
                    break;
                }
            }
@@ -74,21 +80,26 @@ function createDataset(fields, constraints, sortFields) {

        if (!apiObj) {
            var directUrls = [
-                "https://api.grupoginseng.com.br/fiscal-invoices?key=" + key,
-                "https://api.grupoginseng.com.br/fiscal/invoice?key=" + key
+                "https://api.grupoginseng.com.br/v2/vendas/rgb-transferencias?" + query
            ];

            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);
+                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 (String(directResp.status) === "200" && isApiSuccess(parsedDirect)) {
-                    apiObj = parsedDirect;
-                    hitInfo = url;
+                if (apiObj) {
                    break;
                }
            }
@@ -103,34 +114,33 @@ function createDataset(fields, constraints, sortFields) {
            return dataset;
        }

-        if (!apiObj.success || !apiObj.data) {
+        var dataNfe = extractInvoiceData(apiObj, key);
+        if (!dataNfe) {
            addErrorRow(dataset, trim(apiObj.message) || "NFe nao encontrada. Fonte: " + hitInfo);
            return dataset;
        }
-
-        var dataNfe = apiObj.data || {};
-        var itens = dataNfe.itens || [];
+        var itens = resolveItems(dataNfe);
        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),
+            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),
-            trim(dataNfe.invoiceId),
-            trim(dataNfe.emitterEmployeeId),
-            formatIsoDateTime(dataNfe.updatedAt)
+            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);
@@ -187,11 +197,12 @@ function addErrorRow(dataset, message) {

 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) === String(fieldName)) {
+        if (String(c.fieldName).toLowerCase() === target) {
            return c.initialValue;
        }
    }
@@ -199,7 +210,13 @@ function getConstraintValue(constraints, fieldName) {
 }

 function resolveAuth(constraints) {
-    var token = trim(getConstraintValue(constraints, "token"));
+    var token = trim(getFirstConstraintValue(constraints, [
+        "token",
+        "accessToken",
+        "xAccessToken",
+        "bearerToken",
+        "access_token"
+    ]));
    if (!token) {
        try {
            token = trim(java.lang.System.getenv("GINSENG_FISCAL_TOKEN"));
@@ -210,8 +227,16 @@ function resolveAuth(constraints) {
        token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJhcGlnaW5zZW5nIiwiZXhwIjoxNzg3NDQ4MDY3fQ.GJqcIJBkMIfp_q_KRzgGuAHWWo93j3FWo3TObKqlAwA";
    }

-    var basicUser = trim(getConstraintValue(constraints, "basicUser"));
-    var basicPass = trim(getConstraintValue(constraints, "basicPass"));
+    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";
@@ -224,19 +249,84 @@ function resolveAuth(constraints) {
    };
 }

-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;
+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: "GinsengAPI2",
+        serviceCode: "Fastapi",
        endpoint: endpoint,
        method: "get",
        timeoutService: "30000",
@@ -284,12 +374,113 @@ function parseApiPayload(bodyText) {
 }

 function isApiSuccess(obj) {
-    if (!obj || !obj.data) return false;
+    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;
@@ -305,10 +496,12 @@ function fetchDirect(url, timeoutMs, auth) {
        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 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();
@@ -331,18 +524,30 @@ function fetchDirect(url, timeoutMs, auth) {
    }
 }

-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);
+function applyAuthHeaders(headers, authVariant) {
+    headers = headers || {};
+    authVariant = authVariant || {};
+
+    var authorization = trim(authVariant.authorization);
+    var xAccessToken = trim(authVariant.xAccessToken);
+
+    if (authorization) {
+        headers.Authorization = authorization;
    }
-    if (auth.token) {
-        return "Bearer " + String(auth.token);
+    if (xAccessToken) {
+        headers["x-access-token"] = xAccessToken;
    }
-    return "";
+}
+
+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) {
@@ -354,7 +559,8 @@ function buildNfeItems(items) {
        out.push({
            productId: trim(item.productId),
            quantity: toNumber(item.quantity || item.completeQuantity),
-            code: trim(item.code || item.sku || item.productCode || item.codigo)
+            code: trim(item.code || item.sku || item.productCode || item.codigo || item.productId),
+            unitValue: toNumber(item.unitValue || item.unit_value || item.value)
        });
    }