518 lines
16 KiB
JavaScript
518 lines
16 KiB
JavaScript
function defineStructure() {
|
|
addColumn("Code");
|
|
addColumn("Description");
|
|
addColumn("codigoDescricao");
|
|
addColumn("descricao");
|
|
addColumn("sku");
|
|
addColumn("brand");
|
|
addColumn("ncmId");
|
|
addColumn("categoria");
|
|
}
|
|
|
|
function onSync(lastSyncDate) {}
|
|
|
|
var GB_TOKEN_URL = "https://api.grupoboticario.com.br/global/v2/jwt-token/token";
|
|
var GB_STRATEGICS_URL = "https://api.grupoboticario.com.br/global/v1/franchising/gb-stores-data/product/classification/strategics";
|
|
var DEFAULT_GB_CLIENT_ID = "88ymKwAUNfu06sD85i0RiokCxWGSkFBkx9ytgI5y1ZKxX3OQ";
|
|
var DEFAULT_GB_CLIENT_SECRET = "YDFz43qAzL6ApNIKVCxu3dAmS9GWOqJbcc2aPnFDkmEaBXexSpsHGfcItg56i2dE";
|
|
|
|
function createDataset(fields, constraints, sortFields) {
|
|
var dataset = DatasetBuilder.newDataset();
|
|
dataset.addColumn("Code");
|
|
dataset.addColumn("Description");
|
|
dataset.addColumn("codigoDescricao");
|
|
dataset.addColumn("descricao");
|
|
dataset.addColumn("sku");
|
|
dataset.addColumn("brand");
|
|
dataset.addColumn("ncmId");
|
|
dataset.addColumn("categoria");
|
|
|
|
try {
|
|
var filtro = parseConstraints(constraints);
|
|
var clientService = fluigAPI.getAuthorizeClientService();
|
|
var data = {
|
|
companyId: String(getValue("WKCompany") || "1"),
|
|
serviceCode: "GINSENG APITESTE",
|
|
endpoint: "/dados_rgb_products",
|
|
method: "get",
|
|
timeoutService: "60000",
|
|
params: {}
|
|
};
|
|
|
|
var vo = clientService.invoke(JSON.stringify(data));
|
|
var statusHttp = vo ? String(vo.getHttpStatusResult() || "") : "";
|
|
var retorno = vo ? String(vo.getResult() || "") : "";
|
|
|
|
// Fallback: se o servico integrado estiver com endpoint/base incorreto, chama URL direta.
|
|
if (statusHttp !== "200" || !retorno) {
|
|
var direct = fetchDirect("https://api.grupoginseng.com.br/dados_rgb_products", 60000);
|
|
statusHttp = String(direct.status || statusHttp);
|
|
retorno = direct.body || retorno;
|
|
}
|
|
|
|
if (!retorno) {
|
|
addDiagRow(dataset, "Sem retorno da API (HTTP " + statusHttp + ")");
|
|
return dataset;
|
|
}
|
|
|
|
var obj = parseJsonSafe(retorno);
|
|
if (!obj) {
|
|
addDiagRow(dataset, "Falha no JSON da API (HTTP " + statusHttp + ")");
|
|
return dataset;
|
|
}
|
|
|
|
var itens = extractItems(obj);
|
|
if (!itens || !itens.length) {
|
|
addDiagRow(dataset, "API sem itens (HTTP " + statusHttp + ")");
|
|
return dataset;
|
|
}
|
|
|
|
var searchNorm = normalize(filtro.search);
|
|
var maxRows = filtro.maxRows;
|
|
var categoryMap = null;
|
|
var categoryDiag = "";
|
|
|
|
for (var i = 0; i < itens.length; i++) {
|
|
var item = itens[i] || {};
|
|
|
|
if (item.discontinued === true) {
|
|
continue;
|
|
}
|
|
if (item.purchaseBlocked === true) {
|
|
continue;
|
|
}
|
|
|
|
var code = trim(item.sku);
|
|
var desc = trim(item.description);
|
|
var codigoDescricao = code + " - " + desc;
|
|
var brand = trim(item.brand);
|
|
var categoria = trim(item.strategicDescription || item.strategic_description || item.categoria);
|
|
if (!categoria) {
|
|
if (categoryMap == null) {
|
|
var categorization = loadStrategicCategoryMap(constraints, 30000);
|
|
categoryMap = categorization.map || {};
|
|
categoryDiag = categorization.diag || "";
|
|
}
|
|
var strategicId = resolveStrategicId(item, code);
|
|
categoria = resolveCategory(categoryMap, strategicId);
|
|
}
|
|
var blob = normalize([code, desc, brand, trim(item.id), categoria].join(" "));
|
|
|
|
if (searchNorm && searchNorm.length >= 2 && blob.indexOf(searchNorm) === -1) {
|
|
continue;
|
|
}
|
|
|
|
dataset.addRow([
|
|
code,
|
|
desc,
|
|
codigoDescricao,
|
|
desc,
|
|
code,
|
|
brand,
|
|
trim(item.ncmId),
|
|
categoria
|
|
]);
|
|
|
|
if (dataset.rowsCount >= maxRows) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dataset.rowsCount === 0) {
|
|
var suffix = categoryDiag ? " | Categoria: " + categoryDiag : "";
|
|
addDiagRow(dataset, "Sem produtos apos filtros (busca: " + filtro.search + ")" + suffix);
|
|
}
|
|
|
|
} catch (e) {
|
|
addDiagRow(dataset, "Erro ao consultar API: " + e);
|
|
}
|
|
|
|
return dataset;
|
|
}
|
|
|
|
function onMobileSync(user) {}
|
|
|
|
function parseConstraints(constraints) {
|
|
var out = {
|
|
search: "",
|
|
maxRows: 200
|
|
};
|
|
|
|
if (!constraints) {
|
|
return out;
|
|
}
|
|
|
|
for (var i = 0; i < constraints.length; i++) {
|
|
var c = constraints[i];
|
|
if (!c || !c.fieldName) continue;
|
|
|
|
var name = String(c.fieldName);
|
|
var lowerName = name.toLowerCase();
|
|
var value = cleanSearchValue(c.initialValue);
|
|
|
|
if (lowerName === "sqllimit") {
|
|
var n = parseInt(value, 10);
|
|
if (!isNaN(n) && n > 0 && n <= 1000) {
|
|
out.maxRows = n;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (
|
|
value &&
|
|
lowerName !== "metadata#id" &&
|
|
lowerName !== "metadata#active" &&
|
|
lowerName !== "sqllimit" &&
|
|
lowerName !== "gbclientid" &&
|
|
lowerName !== "gbclientsecret" &&
|
|
lowerName !== "clientid" &&
|
|
lowerName !== "clientsecret"
|
|
) {
|
|
if (!out.search || value.length > out.search.length) {
|
|
out.search = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function cleanSearchValue(v) {
|
|
var s = trim(v);
|
|
s = s.replace(/[%*_]/g, "");
|
|
// Evita que flags comuns do Fluig virem termo de busca
|
|
if (s === "true" || s === "false" || s === "on" || s === "off" || s === "1") {
|
|
return "";
|
|
}
|
|
return trim(s);
|
|
}
|
|
|
|
function normalize(v) {
|
|
return trim(v).toLowerCase();
|
|
}
|
|
|
|
function trim(v) {
|
|
return String(v == null ? "" : v).trim();
|
|
}
|
|
|
|
function parseJsonSafe(text) {
|
|
try {
|
|
return JSON.parse(text);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function extractItems(obj) {
|
|
if (!obj) return [];
|
|
if (obj instanceof Array) return obj;
|
|
if (obj.data && obj.data instanceof Array) return obj.data;
|
|
|
|
if (obj.content) {
|
|
if (obj.content instanceof Array) return obj.content;
|
|
if (typeof obj.content === "string") {
|
|
var parsedContent = parseJsonSafe(obj.content);
|
|
if (parsedContent && parsedContent.data && parsedContent.data instanceof Array) {
|
|
return parsedContent.data;
|
|
}
|
|
if (parsedContent && parsedContent instanceof Array) {
|
|
return parsedContent;
|
|
}
|
|
}
|
|
if (obj.content.data && obj.content.data instanceof Array) return obj.content.data;
|
|
}
|
|
|
|
if (obj.result) {
|
|
if (obj.result instanceof Array) return obj.result;
|
|
if (typeof obj.result === "string") {
|
|
var parsedResult = parseJsonSafe(obj.result);
|
|
if (parsedResult && parsedResult.data && parsedResult.data instanceof Array) {
|
|
return parsedResult.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
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 resolveGbCredentials(constraints) {
|
|
var clientId = trim(getConstraintValue(constraints, "gbClientId"));
|
|
if (!clientId) clientId = trim(getConstraintValue(constraints, "clientId"));
|
|
if (!clientId) {
|
|
try { clientId = trim(java.lang.System.getenv("GB_CLIENT_ID")); } catch (e1) {}
|
|
}
|
|
if (!clientId) clientId = DEFAULT_GB_CLIENT_ID;
|
|
|
|
var clientSecret = trim(getConstraintValue(constraints, "gbClientSecret"));
|
|
if (!clientSecret) clientSecret = trim(getConstraintValue(constraints, "clientSecret"));
|
|
if (!clientSecret) {
|
|
try { clientSecret = trim(java.lang.System.getenv("GB_CLIENT_SECRET")); } catch (e2) {}
|
|
}
|
|
if (!clientSecret) clientSecret = DEFAULT_GB_CLIENT_SECRET;
|
|
|
|
return {
|
|
clientId: clientId,
|
|
clientSecret: clientSecret
|
|
};
|
|
}
|
|
|
|
function loadStrategicCategoryMap(constraints, timeoutMs) {
|
|
var out = { map: {}, diag: "" };
|
|
|
|
var creds = resolveGbCredentials(constraints);
|
|
if (!creds.clientId || !creds.clientSecret) {
|
|
out.diag = "credenciais ausentes";
|
|
return out;
|
|
}
|
|
|
|
var tokenResp = requestGbToken(creds, timeoutMs || 30000);
|
|
if (!tokenResp.token) {
|
|
out.diag = tokenResp.diag || "falha ao obter token";
|
|
return out;
|
|
}
|
|
|
|
var strategicsResp = requestStrategics(tokenResp.token, timeoutMs || 30000);
|
|
var strategics = strategicsResp.items || [];
|
|
if (!strategics.length) {
|
|
out.diag = strategicsResp.diag || "sem classificacoes";
|
|
return out;
|
|
}
|
|
|
|
for (var i = 0; i < strategics.length; i++) {
|
|
var item = strategics[i] || {};
|
|
var id = trim(item.strategicId || item.strategicID || item.id || item.code);
|
|
var descricao = trim(item.description || item.descricao || item.category || item.name);
|
|
if (!id || !descricao) continue;
|
|
out.map[id] = descricao;
|
|
}
|
|
|
|
if (!hasOwnKeys(out.map)) {
|
|
out.diag = "classificacoes sem strategicId/description";
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function requestGbToken(creds, timeoutMs) {
|
|
var timeout = timeoutMs || 30000;
|
|
var body = "client_id=" + urlEncode(creds.clientId) +
|
|
"&client_secret=" + urlEncode(creds.clientSecret);
|
|
|
|
var attempts = [
|
|
{
|
|
name: "post-query-body",
|
|
method: "POST",
|
|
url: GB_TOKEN_URL + "?grant_type=client_credentials",
|
|
headers: {
|
|
"Accept": "application/json",
|
|
"Content-Type": "application/x-www-form-urlencoded"
|
|
},
|
|
body: body
|
|
}
|
|
];
|
|
|
|
var trace = [];
|
|
for (var i = 0; i < attempts.length; i++) {
|
|
var attempt = attempts[i];
|
|
var resp = httpRequest(attempt.url, attempt.method, attempt.headers, attempt.body, timeout);
|
|
trace.push(attempt.name + ":" + trim(resp.status));
|
|
var parsed = normalizeApiBody(resp.body);
|
|
var token = trim(parsed && (parsed.access_token || parsed.accessToken || parsed.token));
|
|
if (token) {
|
|
return { token: token, diag: "token ok (" + attempt.name + ")" };
|
|
}
|
|
}
|
|
|
|
return { token: "", diag: "token falhou [" + trace.join(" | ") + "]" };
|
|
}
|
|
|
|
function requestStrategics(accessToken, timeoutMs) {
|
|
var resp = httpRequest(
|
|
GB_STRATEGICS_URL,
|
|
"GET",
|
|
{
|
|
"Accept": "application/json",
|
|
"Authorization": "Bearer " + trim(accessToken)
|
|
},
|
|
"",
|
|
timeoutMs || 30000
|
|
);
|
|
|
|
var parsed = normalizeApiBody(resp.body);
|
|
var items = extractItems(parsed);
|
|
if ((!items || !items.length) && parsed && parsed.items instanceof Array) {
|
|
items = parsed.items;
|
|
}
|
|
if ((!items || !items.length) && parsed && parsed.strategics instanceof Array) {
|
|
items = parsed.strategics;
|
|
}
|
|
|
|
if (!items || !items.length) {
|
|
return { items: [], diag: "strategics HTTP " + trim(resp.status) };
|
|
}
|
|
|
|
return { items: items, diag: "ok" };
|
|
}
|
|
|
|
function resolveStrategicId(item, fallbackCode) {
|
|
var candidates = [
|
|
item && item.strategicId,
|
|
item && item.strategicID,
|
|
item && item.classificationStrategicId,
|
|
item && item.productStrategicId,
|
|
item && item.estrategicId,
|
|
item && item.strategyId,
|
|
item && item.code,
|
|
fallbackCode
|
|
];
|
|
|
|
for (var i = 0; i < candidates.length; i++) {
|
|
var value = trim(candidates[i]);
|
|
if (value) return value;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
function resolveCategory(map, strategicId) {
|
|
var id = trim(strategicId);
|
|
if (!id || !map) return "";
|
|
|
|
if (map.hasOwnProperty(id)) {
|
|
return trim(map[id]);
|
|
}
|
|
|
|
var asInt = parseInt(id, 10);
|
|
if (!isNaN(asInt)) {
|
|
var normalized = String(asInt);
|
|
if (map.hasOwnProperty(normalized)) {
|
|
return trim(map[normalized]);
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
function normalizeApiBody(text) {
|
|
var obj = parseJsonSafe(text);
|
|
if (!obj) return null;
|
|
|
|
if (obj.content && typeof obj.content === "string") {
|
|
var parsedContent = parseJsonSafe(obj.content);
|
|
if (parsedContent) return parsedContent;
|
|
}
|
|
|
|
if (obj.result && typeof obj.result === "string") {
|
|
var parsedResult = parseJsonSafe(obj.result);
|
|
if (parsedResult) return parsedResult;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
function hasOwnKeys(obj) {
|
|
for (var k in obj) {
|
|
if (obj.hasOwnProperty(k)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function urlEncode(value) {
|
|
return String(java.net.URLEncoder.encode(String(value || ""), "UTF-8"));
|
|
}
|
|
|
|
function addDiagRow(dataset, msg) {
|
|
dataset.addRow([
|
|
"DEBUG",
|
|
String(msg),
|
|
String(msg),
|
|
String(msg),
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]);
|
|
}
|
|
|
|
function fetchDirect(url, timeoutMs) {
|
|
return httpRequest(
|
|
url,
|
|
"GET",
|
|
{ "Accept": "application/json" },
|
|
"",
|
|
timeoutMs || 30000
|
|
);
|
|
}
|
|
|
|
function httpRequest(url, method, headers, body, timeoutMs) {
|
|
var conn = null;
|
|
var reader = null;
|
|
var writer = null;
|
|
try {
|
|
var URL = java.net.URL;
|
|
var InputStreamReader = java.io.InputStreamReader;
|
|
var BufferedReader = java.io.BufferedReader;
|
|
var OutputStreamWriter = java.io.OutputStreamWriter;
|
|
var StringBuilder = java.lang.StringBuilder;
|
|
|
|
var httpMethod = String(method || "GET").toUpperCase();
|
|
var timeout = timeoutMs || 30000;
|
|
var payload = body == null ? "" : String(body);
|
|
|
|
conn = new URL(url).openConnection();
|
|
conn.setRequestMethod(httpMethod);
|
|
conn.setConnectTimeout(timeout);
|
|
conn.setReadTimeout(timeout);
|
|
|
|
if (headers) {
|
|
for (var h in headers) {
|
|
if (!headers.hasOwnProperty(h)) continue;
|
|
if (headers[h] == null || headers[h] === "") continue;
|
|
conn.setRequestProperty(String(h), String(headers[h]));
|
|
}
|
|
}
|
|
|
|
if (payload && (httpMethod === "POST" || httpMethod === "PUT" || httpMethod === "PATCH")) {
|
|
conn.setDoOutput(true);
|
|
writer = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
|
|
writer.write(payload);
|
|
writer.flush();
|
|
}
|
|
|
|
var statusCode = conn.getResponseCode();
|
|
var status = String(statusCode);
|
|
var stream = (statusCode >= 200 && statusCode < 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: status, body: String(sb.toString()) };
|
|
} catch (e) {
|
|
return { status: "", body: "" };
|
|
} finally {
|
|
try { if (writer) writer.close(); } catch (e1) {}
|
|
try { if (reader) reader.close(); } catch (e2) {}
|
|
try { if (conn) conn.disconnect(); } catch (e3) {}
|
|
}
|
|
}
|