@@ -20,9 +24,9 @@ const actions = (
const SSOSuccess = ({ location }) => {
useEffect(() => {
if (location?.query?.payload) {
- localStorage.setItem("login-response", location.query.payload);
+ const loginResponse = storeLoginResponse(location.query.payload);
try {
- const query = JSON.parse(location.query.payload);
+ const query = loginResponse || JSON.parse(location.query.payload);
if (query?.privilege) {
setAuthority(query.privilege);
reloadAuthorized();
@@ -33,7 +37,7 @@ const SSOSuccess = ({ location }) => {
localStorage.setItem("infini-console-authority", "");
}
} else {
- localStorage.setItem("login-response", "");
+ clearStoredLoginResponse();
}
setTimeout(() => {
router.push("/");
diff --git a/web/src/utils/auth_session.js b/web/src/utils/auth_session.js
new file mode 100644
index 000000000..2e036ea60
--- /dev/null
+++ b/web/src/utils/auth_session.js
@@ -0,0 +1,432 @@
+const LOGIN_RESPONSE_KEY = "login-response";
+const LOGIN_ACTIVITY_KEY = "login-last-activity-at";
+const REFRESH_ENDPOINT = "/account/refresh";
+const MIN_REFRESH_THRESHOLD_MS = 5 * 60 * 1000;
+const ACTIVITY_IDLE_TIMEOUT_MS = 15 * 60 * 1000;
+const ACTIVITY_PERSIST_INTERVAL_MS = 30 * 1000;
+const REFRESH_RETRY_INTERVAL_MS = 30 * 1000;
+
+let refreshPromise = null;
+let refreshTimer = null;
+let managerStarted = false;
+let lastRecordedActivityAt = 0;
+let lastRefreshAttemptAt = 0;
+
+function canUseWindow() {
+ return typeof window !== "undefined";
+}
+
+function parseJSON(value) {
+ if (!value) {
+ return null;
+ }
+ try {
+ return JSON.parse(value);
+ } catch (e) {
+ return null;
+ }
+}
+
+function decodeJwtPayload(token) {
+ if (!token || !canUseWindow()) {
+ return null;
+ }
+ const segments = token.split(".");
+ if (segments.length < 2) {
+ return null;
+ }
+ try {
+ const base64 = segments[1].replace(/-/g, "+").replace(/_/g, "/");
+ const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "=");
+ return JSON.parse(window.atob(padded));
+ } catch (e) {
+ return null;
+ }
+}
+
+function toUnixMs(value) {
+ const numericValue = Number(value);
+ if (!Number.isFinite(numericValue) || numericValue <= 0) {
+ return 0;
+ }
+ return numericValue > 1e12 ? numericValue : numericValue * 1000;
+}
+
+function normalizeLoginResponse(response, now = Date.now()) {
+ if (!response || typeof response !== "object") {
+ return null;
+ }
+ const normalized = {
+ ...response,
+ };
+ let expiresAt = toUnixMs(normalized.expires_at);
+
+ if (!expiresAt && normalized.access_token) {
+ const payload = decodeJwtPayload(normalized.access_token);
+ expiresAt = toUnixMs(payload?.exp);
+ }
+
+ if (!expiresAt) {
+ const expireInSeconds = Number(normalized.expire_in);
+ if (Number.isFinite(expireInSeconds) && expireInSeconds > 0) {
+ expiresAt = now + expireInSeconds * 1000;
+ }
+ }
+
+ if (expiresAt) {
+ normalized.expires_at = expiresAt;
+ }
+
+ return normalized;
+}
+
+function getStoredActivityAt() {
+ if (!canUseWindow()) {
+ return 0;
+ }
+ return Number(window.localStorage.getItem(LOGIN_ACTIVITY_KEY) || 0);
+}
+
+function setStoredActivityAt(activityAt) {
+ if (!canUseWindow()) {
+ return;
+ }
+ window.localStorage.setItem(LOGIN_ACTIVITY_KEY, `${activityAt}`);
+}
+
+function clearRefreshTimer() {
+ if (refreshTimer) {
+ window.clearTimeout(refreshTimer);
+ refreshTimer = null;
+ }
+}
+
+function getRefreshThresholdMs(loginResponse) {
+ const tokenLifetimeMs = Number(loginResponse?.expire_in || 0) * 1000;
+ if (tokenLifetimeMs > 0) {
+ return Math.max(MIN_REFRESH_THRESHOLD_MS, tokenLifetimeMs / 2);
+ }
+ return MIN_REFRESH_THRESHOLD_MS;
+}
+
+function getNormalizedRequestPath(requestUrl) {
+ if (!canUseWindow()) {
+ return requestUrl;
+ }
+
+ const resolvedUrl = new URL(requestUrl, window.location.origin);
+ let pathname = resolvedUrl.pathname;
+ const basePath =
+ window.routerBase && window.routerBase !== "/"
+ ? window.routerBase.replace(/\/$/, "")
+ : "";
+
+ if (basePath && pathname.startsWith(`${basePath}/`)) {
+ pathname = pathname.slice(basePath.length);
+ } else if (basePath && pathname === basePath) {
+ pathname = "/";
+ }
+
+ return pathname;
+}
+
+function buildUrlWithBasePath(relativeUrl) {
+ if (!canUseWindow() || /^(https?:)?\/\//.test(relativeUrl)) {
+ return relativeUrl;
+ }
+ const basePath =
+ window.routerBase && window.routerBase !== "/"
+ ? window.routerBase.replace(/\/$/, "")
+ : "";
+ const cleanUrl = relativeUrl.replace(/^\//, "");
+ return `${basePath}/${cleanUrl}`;
+}
+
+function isRefreshPath(requestUrl) {
+ const path = getNormalizedRequestPath(requestUrl);
+ return (
+ path === REFRESH_ENDPOINT ||
+ path === "/account/login" ||
+ path === "/account/login/challenge" ||
+ path === "/account/logout"
+ );
+}
+
+function hasRecentUserActivity(now = Date.now()) {
+ const lastActivityAt = getStoredActivityAt();
+ return lastActivityAt > 0 && now-lastActivityAt <= ACTIVITY_IDLE_TIMEOUT_MS;
+}
+
+function dispatchLogout() {
+ if (
+ !canUseWindow() ||
+ window.location.href.indexOf("user/login") !== -1 ||
+ !window.g_app?._store
+ ) {
+ return;
+ }
+ window.g_app._store.dispatch({
+ type: "login/logout",
+ payload: {
+ skipServerLogout: true,
+ },
+ });
+}
+
+function scheduleNextRefresh() {
+ if (!canUseWindow()) {
+ return;
+ }
+ clearRefreshTimer();
+ const loginResponse = getStoredLoginResponse();
+ const expiresAt = Number(loginResponse?.expires_at || 0);
+ if (!loginResponse?.access_token || !expiresAt) {
+ return;
+ }
+
+ const now = Date.now();
+ const remainingMs = expiresAt - now;
+ if (remainingMs <= 0) {
+ return;
+ }
+ const refreshThresholdMs = getRefreshThresholdMs(loginResponse);
+
+ const delayMs =
+ remainingMs > refreshThresholdMs
+ ? remainingMs - refreshThresholdMs
+ : Math.min(REFRESH_RETRY_INTERVAL_MS, remainingMs);
+
+ refreshTimer = window.setTimeout(() => {
+ refreshTimer = null;
+ if (!hasRecentUserActivity()) {
+ scheduleNextRefresh();
+ return;
+ }
+ refreshAccessToken().catch(() => {
+ scheduleNextRefresh();
+ });
+ }, Math.max(1000, delayMs));
+}
+
+async function requestTokenRefresh(currentToken) {
+ if (!canUseWindow() || !currentToken) {
+ return null;
+ }
+
+ const refreshUrl = buildUrlWithBasePath(REFRESH_ENDPOINT);
+ if (new URL(refreshUrl, window.location.origin).protocol !== "https:") {
+ return null;
+ }
+
+ const response = await window.fetch(refreshUrl, {
+ method: "POST",
+ credentials: "include",
+ headers: {
+ Accept: "application/json",
+ "Content-Type": "application/json; charset=utf-8",
+ Authorization: `Bearer ${currentToken}`,
+ },
+ });
+
+ let payload = null;
+ try {
+ payload = await response.json();
+ } catch (e) {
+ payload = null;
+ }
+
+ if (!response.ok) {
+ const error = new Error(
+ payload?.error?.reason || response.statusText || "failed to refresh token"
+ );
+ error.status = response.status;
+ throw error;
+ }
+
+ return payload;
+}
+
+export function getStoredLoginResponse() {
+ if (!canUseWindow()) {
+ return null;
+ }
+ const parsed = parseJSON(window.localStorage.getItem(LOGIN_RESPONSE_KEY));
+ const normalized = normalizeLoginResponse(parsed);
+ if (!normalized?.access_token) {
+ return null;
+ }
+
+ if (parsed?.expires_at !== normalized.expires_at) {
+ window.localStorage.setItem(LOGIN_RESPONSE_KEY, JSON.stringify(normalized));
+ }
+
+ return normalized;
+}
+
+export function storeLoginResponse(response, { recordActivity = true } = {}) {
+ if (!canUseWindow()) {
+ return null;
+ }
+ const parsed =
+ typeof response === "string"
+ ? parseJSON(response)
+ : response;
+
+ if (!parsed?.access_token) {
+ clearStoredLoginResponse();
+ return null;
+ }
+
+ const normalized = normalizeLoginResponse(parsed);
+ if (!normalized) {
+ clearStoredLoginResponse();
+ return null;
+ }
+
+ window.localStorage.setItem(LOGIN_RESPONSE_KEY, JSON.stringify(normalized));
+
+ if (recordActivity) {
+ setStoredActivityAt(Date.now());
+ }
+
+ scheduleNextRefresh();
+ return normalized;
+}
+
+export function clearStoredLoginResponse() {
+ if (!canUseWindow()) {
+ return;
+ }
+ window.localStorage.removeItem(LOGIN_RESPONSE_KEY);
+ window.localStorage.removeItem(LOGIN_ACTIVITY_KEY);
+ clearRefreshTimer();
+}
+
+export function getAuthorizationToken() {
+ return getStoredLoginResponse()?.access_token || "";
+}
+
+export function recordUserActivity({ force = false } = {}) {
+ if (!canUseWindow() || !getStoredLoginResponse()?.access_token) {
+ return;
+ }
+
+ const now = Date.now();
+ if (!force && now - lastRecordedActivityAt < ACTIVITY_PERSIST_INTERVAL_MS) {
+ return;
+ }
+
+ lastRecordedActivityAt = now;
+ setStoredActivityAt(now);
+
+ const loginResponse = getStoredLoginResponse();
+ const refreshThresholdMs = getRefreshThresholdMs(loginResponse);
+ if (
+ loginResponse?.expires_at &&
+ loginResponse.expires_at - now <= refreshThresholdMs
+ ) {
+ refreshAccessToken().catch(() => {});
+ return;
+ }
+
+ scheduleNextRefresh();
+}
+
+export async function refreshAccessToken({ force = false } = {}) {
+ const loginResponse = getStoredLoginResponse();
+ if (!loginResponse?.access_token) {
+ return null;
+ }
+
+ const now = Date.now();
+ const expiresAt = Number(loginResponse.expires_at || 0);
+ const refreshThresholdMs = getRefreshThresholdMs(loginResponse);
+ if (
+ !force &&
+ (
+ !expiresAt ||
+ expiresAt - now > refreshThresholdMs ||
+ !hasRecentUserActivity(now) ||
+ now - lastRefreshAttemptAt < REFRESH_RETRY_INTERVAL_MS
+ )
+ ) {
+ return loginResponse;
+ }
+
+ if (refreshPromise) {
+ return refreshPromise;
+ }
+
+ lastRefreshAttemptAt = now;
+ const previousToken = loginResponse.access_token;
+
+ refreshPromise = requestTokenRefresh(previousToken)
+ .then((response) => {
+ if (response?.status === "ok" && response.access_token) {
+ return storeLoginResponse(response, { recordActivity: false });
+ }
+ return getStoredLoginResponse();
+ })
+ .catch((error) => {
+ const latest = getStoredLoginResponse();
+ if (latest?.access_token && latest.access_token !== previousToken) {
+ return latest;
+ }
+ if (Number(error?.status) === 401) {
+ dispatchLogout();
+ return null;
+ }
+ return latest;
+ })
+ .finally(() => {
+ refreshPromise = null;
+ scheduleNextRefresh();
+ });
+
+ return refreshPromise;
+}
+
+export function ensureFreshAccessToken(requestUrl) {
+ if (!getStoredLoginResponse()?.access_token || isRefreshPath(requestUrl)) {
+ return Promise.resolve(getStoredLoginResponse());
+ }
+ return refreshAccessToken();
+}
+
+export function startActivityAwareTokenRefresh() {
+ if (!canUseWindow() || managerStarted) {
+ return;
+ }
+
+ managerStarted = true;
+
+ const handleActivity = () => {
+ recordUserActivity();
+ };
+
+ ["mousedown", "keydown", "scroll", "touchstart", "mousemove"].forEach(
+ (eventName) => {
+ window.addEventListener(eventName, handleActivity, { passive: true });
+ }
+ );
+
+ document.addEventListener("visibilitychange", () => {
+ if (document.visibilityState === "visible") {
+ recordUserActivity({ force: true });
+ refreshAccessToken().catch(() => {});
+ } else {
+ scheduleNextRefresh();
+ }
+ });
+
+ window.addEventListener("storage", (event) => {
+ if (
+ event.key === LOGIN_RESPONSE_KEY ||
+ event.key === LOGIN_ACTIVITY_KEY
+ ) {
+ scheduleNextRefresh();
+ }
+ });
+
+ scheduleNextRefresh();
+}
diff --git a/web/src/utils/authority.js b/web/src/utils/authority.js
index 73f07abd9..14dd4a068 100644
--- a/web/src/utils/authority.js
+++ b/web/src/utils/authority.js
@@ -1,4 +1,28 @@
import request from "./request";
+import {
+ getAuthorizationToken,
+ getStoredLoginResponse,
+} from "./auth_session";
+
+const APPLICATION_AUTH_KEY = "infini-auth";
+const APPLICATION_ROLLUP_KEY = "infini-rollup-enabled";
+const ENTERPRISE_TASK_MANAGER_KEY = "infini-enterprise-task-manager-enabled";
+export const APPLICATION_SETTINGS_UPDATED_EVENT =
+ "console:application-settings-updated";
+let applicationSettingsPromise = null;
+let applicationSettingsCache = null;
+
+function persistApplicationSettings(res) {
+ localStorage.setItem(APPLICATION_AUTH_KEY, `${res.auth_enabled}`);
+ localStorage.setItem(
+ APPLICATION_ROLLUP_KEY,
+ `${!!res.system_cluster?.rollup_enabled}`
+ );
+ localStorage.setItem(
+ ENTERPRISE_TASK_MANAGER_KEY,
+ `${!!res.enterprise_plugins?.task_manager}`
+ );
+}
// use localStorage to store the authority info, which might be sent from server in actual project.
export function getAuthority(str) {
@@ -37,49 +61,64 @@ export function hasAuthority(authority) {
}
export function getAuthEnabled() {
- return localStorage.getItem("infini-auth");
+ return localStorage.getItem(APPLICATION_AUTH_KEY);
}
export function isLogin() {
- const responseStr = localStorage.getItem("login-response");
- if (responseStr) {
- let loginResponse = null;
- try {
- loginResponse = JSON.parse(responseStr);
- if (loginResponse?.username && loginResponse?.status == "ok") {
- return true;
- }
- } catch (err) {
- console.error(err);
- }
+ const loginResponse = getStoredLoginResponse();
+ if (loginResponse?.username && loginResponse?.status == "ok") {
+ return true;
}
return false;
}
export function getAuthorizationHeader() {
- const responseStr = localStorage.getItem("login-response");
- if (responseStr) {
- let loginResponse = null;
- try {
- loginResponse = JSON.parse(responseStr);
- } catch (err) {
- console.error(err);
- }
- if (loginResponse) {
- return "Bearer " + loginResponse.access_token;
- }
+ const accessToken = getAuthorizationToken();
+ if (accessToken) {
+ return "Bearer " + accessToken;
}
return "";
}
export function getRollupEnabled() {
- return localStorage.getItem("infini-rollup-enabled");
+ return localStorage.getItem(APPLICATION_ROLLUP_KEY);
}
-(async function() {
- const res = await request("/setting/application");
- if (res && !res.error) {
- localStorage.setItem("infini-auth", res.auth_enabled);
- localStorage.setItem('infini-rollup-enabled', res.system_cluster?.rollup_enabled || false)
+export function getEnterpriseTaskManagerEnabled() {
+ return localStorage.getItem(ENTERPRISE_TASK_MANAGER_KEY);
+}
+
+export async function refreshApplicationSettings(force = false) {
+ if (applicationSettingsPromise) {
+ return applicationSettingsPromise;
}
+
+ if (!force && applicationSettingsCache) {
+ return applicationSettingsCache;
+ }
+
+ applicationSettingsPromise = request("/setting/application")
+ .then((res) => {
+ if (res && !res.error) {
+ persistApplicationSettings(res);
+ applicationSettingsCache = res;
+ if (typeof window !== "undefined") {
+ window.dispatchEvent(
+ new CustomEvent(APPLICATION_SETTINGS_UPDATED_EVENT, {
+ detail: res,
+ })
+ );
+ }
+ }
+ return res;
+ })
+ .finally(() => {
+ applicationSettingsPromise = null;
+ });
+
+ return applicationSettingsPromise;
+}
+
+(async function() {
+ await refreshApplicationSettings();
})();
diff --git a/web/src/utils/request.js b/web/src/utils/request.js
index 876aaaea7..c1162e272 100644
--- a/web/src/utils/request.js
+++ b/web/src/utils/request.js
@@ -5,6 +5,7 @@ import hash from "hash.js";
import { isAntdPro } from "./utils";
import { formatMessage } from "umi/locale";
import { getAuthorizationHeader } from "./authority";
+import { ensureFreshAccessToken } from "./auth_session";
import * as uuid from 'uuid';
export const formatResponse = (response) => {
@@ -31,6 +32,187 @@ export const formatResponse = (response) => {
}
}
+const secureTransportErrorReason =
+ "Sensitive requests require HTTPS. Enable Console HTTPS or put Console behind an HTTPS reverse proxy.";
+const ERROR_NOTIFICATION_DEDUPE_MS = 4000;
+const DATATOOLS_LICENSE_REQUIRED_REASON =
+ "a valid license is required to use DataTools";
+const DATATOOLS_LICENSE_MODAL_EVENT = "console:datatools-license-required";
+const DATATOOLS_LICENSE_MODAL_DEDUPE_MS = 3000;
+const recentErrorNotifications = new Map();
+let lastDataToolsLicenseModalAt = 0;
+
+const sensitiveRequestRules = [
+ { method: "POST", pattern: /^\/account\/login\/challenge$/ },
+ { method: "POST", pattern: /^\/account\/login$/ },
+ { method: "POST", pattern: /^\/account\/refresh$/ },
+ { method: "PUT", pattern: /^\/account\/password$/ },
+ { method: "POST", pattern: /^\/user$/ },
+ { method: "PUT", pattern: /^\/user\/[^/]+\/password$/ },
+ { method: "POST", pattern: /^\/credential$/ },
+ { method: "PUT", pattern: /^\/credential\/[^/]+$/ },
+ { method: "POST", pattern: /^\/setup\/_validate$/ },
+ { method: "POST", pattern: /^\/setup\/_initialize$/ },
+ { method: "POST", pattern: /^\/setup\/_validate_secret$/ },
+ { method: "POST", pattern: /^\/elasticsearch\/$/ },
+ { method: "PUT", pattern: /^\/elasticsearch\/[^/]+$/ },
+ { method: "POST", pattern: /^\/elasticsearch\/try_connect$/ },
+ { method: "POST", pattern: /^\/email\/server$/ },
+ { method: "POST", pattern: /^\/email\/server\/_test$/ },
+ { method: "PUT", pattern: /^\/email\/server\/[^/]+$/ },
+ { method: "PUT", pattern: /^\/setting\/system\/rollup$/ },
+ { method: "PUT", pattern: /^\/setting\/system\/retention$/ },
+];
+
+const getNormalizedRequestPath = (requestUrl) => {
+ if (typeof window === "undefined") {
+ return requestUrl;
+ }
+
+ const resolvedUrl = new URL(requestUrl, window.location.origin);
+ let pathname = resolvedUrl.pathname;
+ const basePath =
+ window.routerBase && window.routerBase !== "/"
+ ? window.routerBase.replace(/\/$/, "")
+ : "";
+
+ if (basePath && pathname.startsWith(`${basePath}/`)) {
+ pathname = pathname.slice(basePath.length);
+ } else if (basePath && pathname === basePath) {
+ pathname = "/";
+ }
+
+ return pathname;
+};
+
+const requestUsesSecureTransport = (requestUrl) => {
+ if (typeof window === "undefined") {
+ return true;
+ }
+
+ return new URL(requestUrl, window.location.origin).protocol === "https:";
+};
+
+const getCurrentRoutePath = () => {
+ if (typeof window === "undefined") {
+ return "/";
+ }
+
+ const hash = window.location.hash || "";
+ const hashPath = hash.startsWith("#") ? hash.slice(1) : hash;
+ if (hashPath.startsWith("/")) {
+ return getNormalizedRequestPath(hashPath);
+ }
+
+ return getNormalizedRequestPath(window.location.pathname || "/");
+};
+
+const isDataToolsRoute = () => {
+ return /^\/data_tools(\/|$)/.test(getCurrentRoutePath());
+};
+
+const openDataToolsLicenseModal = () => {
+ if (typeof window === "undefined") {
+ return;
+ }
+
+ const now = Date.now();
+ if (now - lastDataToolsLicenseModalAt < DATATOOLS_LICENSE_MODAL_DEDUPE_MS) {
+ return;
+ }
+
+ lastDataToolsLicenseModalAt = now;
+ window.dispatchEvent(new CustomEvent(DATATOOLS_LICENSE_MODAL_EVENT));
+};
+
+const requestRequiresSecureTransport = (requestUrl, method = "GET") => {
+ const normalizedMethod = method.toUpperCase();
+ const normalizedPath = getNormalizedRequestPath(requestUrl);
+
+ return sensitiveRequestRules.some(
+ ({ method: sensitiveMethod, pattern }) =>
+ sensitiveMethod === normalizedMethod && pattern.test(normalizedPath)
+ );
+};
+
+const getInsecureTransportResponse = () => ({
+ status: "error",
+ success: false,
+ currentAuthority: "guest",
+ error: {
+ reason: secureTransportErrorReason,
+ },
+});
+
+const cleanupRecentErrorNotifications = (now = Date.now()) => {
+ recentErrorNotifications.forEach((timestamp, key) => {
+ if (now - timestamp >= ERROR_NOTIFICATION_DEDUPE_MS) {
+ recentErrorNotifications.delete(key);
+ }
+ });
+};
+
+const showErrorNotification = ({
+ message,
+ description,
+ style,
+ dedupeKey,
+}) => {
+ const now = Date.now();
+ cleanupRecentErrorNotifications(now);
+ const key = dedupeKey || `${message}`;
+ const lastShownAt = recentErrorNotifications.get(key);
+ if (lastShownAt && now - lastShownAt < ERROR_NOTIFICATION_DEDUPE_MS) {
+ return;
+ }
+ recentErrorNotifications.set(key, now);
+ notification.error({
+ key,
+ placement: "topRight",
+ message,
+ description,
+ style,
+ });
+};
+
+const fetchReplayNonce = async (requestUrl, requestMethod, authorizationHeader) => {
+ const nonceEndpoint = buildUrlWithBasePath("/account/replay_nonce");
+ const headers = {
+ Accept: "application/json",
+ "Content-Type": "application/json; charset=utf-8",
+ };
+ if (authorizationHeader) {
+ headers.Authorization = authorizationHeader;
+ }
+
+ const response = await fetch(nonceEndpoint, {
+ method: "POST",
+ credentials: "include",
+ headers,
+ body: JSON.stringify({
+ method: requestMethod,
+ path: getNormalizedRequestPath(requestUrl),
+ }),
+ });
+
+ let payload = null;
+ try {
+ payload = await response.json();
+ } catch (error) {
+ payload = null;
+ }
+
+ if (!response.ok || !payload?.nonce) {
+ const reason =
+ payload?.error?.reason ||
+ payload?.message ||
+ "failed to fetch replay nonce";
+ throw new Error(reason);
+ }
+
+ return payload.nonce;
+};
+
const checkStatus = async (response, noticeable, option={}) => {
const codeMessage = {
200: formatMessage({ id: "app.message.http.status.200" }),
@@ -53,25 +235,31 @@ const checkStatus = async (response, noticeable, option={}) => {
if (response.status >= 200 && response.status < 300) {
return response;
}
+ if (response.status === 403 && isDataToolsRoute()) {
+ let jsonRes = null;
+ try {
+ jsonRes = await response.clone().json();
+ } catch (error) {
+ jsonRes = null;
+ }
+ if (jsonRes?.error?.reason === DATATOOLS_LICENSE_REQUIRED_REASON) {
+ openDataToolsLicenseModal();
+ return response;
+ }
+ }
if (response.status == 500) {
- const jsonRes = await response.clone().json();
- if (jsonRes.error && !jsonRes.stack) {
+ let jsonRes = null;
+ try {
+ jsonRes = await response.clone().json();
+ } catch (error) {
+ jsonRes = null;
+ }
+ if (jsonRes?.error && !jsonRes.stack) {
if (noticeable) {
- let desc = "";
- if (typeof jsonRes.error == "string") {
- desc = jsonRes.error;
- } else {
- if (jsonRes.error?.reason) {
- desc = (
-
- {jsonRes.error.reason}
-
- );
- } else {
- desc = JSON.stringify(jsonRes.error);
- }
- }
- desc = (
+ const friendlyMessage = jsonRes.error?.key
+ ? formatMessage({ id: jsonRes.error.key })
+ : formatMessage({ id: "app.message.http.status.500" });
+ const desc = (
{
{response.status}
- {desc}
+
+ {friendlyMessage}
+
);
- notification.error({
+ showErrorNotification({
message: formatMessage({ id: "app.message.http.request.error" }),
description: desc,
style: { wordBreak: "break-all" },
+ dedupeKey: `http-500:${jsonRes.error?.key || jsonRes.error?.reason || friendlyMessage}`,
});
}
return response;
@@ -104,10 +295,11 @@ const checkStatus = async (response, noticeable, option={}) => {
option.hasOwnProperty("showErrorInner") &&
option.showErrorInner === true
) {
- notification.error({
+ showErrorNotification({
message: response.statusText,
description: errortext,
style: { wordBreak: "break-all" },
+ dedupeKey: `http-inner:${response.status}:${response.statusText}:${errortext}`,
});
return response;
}
@@ -136,10 +328,11 @@ const checkStatus = async (response, noticeable, option={}) => {
{errortext}