cloud-web-corejs 1.1.0-dev.6 → 1.1.0-dev.61

package/src/utils/baseDictsCache.js

@@ -0,0 +1,197 @@
+/**
+ * 基础字典（/user/common_attribute/listItems）的进程内缓存。
+ *
+ * 动机是同一个观察：打开一次详情页，光字典就会打出去 5~7 条 listItems —— 一部分来自
+ * 页面自己的 mounted，一部分来自表单里每个挂了 commonAttributeCode 的字段各发各的。
+ * 这批请求和详情取数挤在同一个 tick 里，是详情页请求突发量的主要来源。
+ *
+ * 于是这里做两件事：
+ *   1. **并发去重** —— 同一 key 在飞的请求只发一条，后来者挂到同一个 promise 上；
+ *   2. **结果复用** —— 字典内容按天计都未必变一次，TTL 内重复进出页面不再发请求。
+ *
+ * 几条刻意的约束：
+ *   - **只缓存成功响应**。失败（断网、DNS 解析失败、网关 502）一律不写缓存，否则一次
+ *     网络抖动会把「空字典」粘住整个 TTL —— 那比多发几个请求糟得多。
+ *   - **每次取用都复制一份再交出去**。调用方普遍把 dicts 直接挂到 Vue data 上，会被
+ *     响应式系统 observe；共享同一份数组会让 A 页面的改动漏到 B 页面。
+ *   - **key 必须带公司维度**。listItems 是带 forCompany: true 发的，而切换公司走的是
+ *     store 的 changeCompanyInfo，不刷新页面，不带公司维度就会命中上一家公司的字典。
+ *   - **失效要能打断在途请求的回写**。字典维护页保存后会调 invalidateBaseDicts，此时
+ *     可能有一条更早发出的请求还没回来；用 generation 计数把它的回写作废，
+ *     否则刚失效的缓存会被旧数据重新填上。
+ */
+
+export const DEFAULT_BASE_DICTS_TTL = 5 * 60 * 1000;
+
+/** key -> { code, res, expireAt } */
+const cache = new Map();
+/** key -> { code, promise } */
+const inflight = new Map();
+/** 每次失效 +1；在途请求回写前比对，对不上就丢弃结果。 */
+let generation = 0;
+
+function isPlainEmptyObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return false;
+  return Object.keys(value).length === 0;
+}
+
+/**
+ * 键顺序无关的序列化。option.data 多半是 handleCustomEvent 的返回值展开出来的，
+ * 同样的参数不保证同样的键顺序，直接 JSON.stringify 会漏掉本该命中的缓存。
+ */
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    const text = JSON.stringify(value);
+    return text === undefined ? "" : text;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+    .join(",")}}`;
+}
+
+/**
+ * @param {String} scope 公司维度，通常是 store.getters.companyCode
+ * @param {String} code  字典编码
+ * @param {Object} [data] 额外请求参数；不传和传 {} 发出去的请求一样，归一到同一个 key
+ */
+export function buildBaseDictsKey(scope, code, data) {
+  let extra = "";
+  if (data !== undefined && data !== null && !isPlainEmptyObject(data)) {
+    extra = stableStringify(data);
+  }
+  const dictCode = code === undefined || code === null ? "" : code;
+  return `${scope || ""}::${dictCode}::${extra}`;
+}
+
+function cloneResponse(res) {
+  if (!res || typeof res !== "object") return res;
+  const cloned = { ...res };
+  if (Array.isArray(res.objx)) {
+    cloned.objx = res.objx.map((item) =>
+      item && typeof item === "object" ? { ...item } : item
+    );
+  }
+  return cloned;
+}
+
+function isSuccessResponse(res) {
+  return !!res && res.type === "success";
+}
+
+/** 把响应拆成调用方要的 { dicts, dictMap }。 */
+export function toBaseDicts(res) {
+  const dicts = res && Array.isArray(res.objx) ? res.objx : [];
+  const dictMap = {};
+  for (const item of dicts) {
+    if (item && item.sn !== undefined && item.sn !== null) {
+      dictMap[item.sn] = item.value;
+    }
+  }
+  return { dicts, dictMap };
+}
+
+/**
+ * 取字典：先查缓存，再查在途，都没有才调 request()。
+ *
+ * @param {Object}   option
+ * @param {String}   option.key      buildBaseDictsKey 的结果
+ * @param {String}   [option.code]   字典编码，只用于按 code 失效
+ * @param {Function} option.request  真正发请求的函数，返回 Promise<res>
+ * @param {Number}   [option.ttl]    毫秒；<= 0 表示只去重不缓存
+ * @param {Boolean}  [option.force]  跳过缓存与在途，强制重取
+ * @returns {Promise} 解析为后端响应 res（结构与直接发请求一致）
+ */
+export function loadBaseDicts(option) {
+  const { key, code, request, force = false } = option || {};
+  const hasTtl = typeof option.ttl === "number";
+  const ttl = hasTtl ? option.ttl : DEFAULT_BASE_DICTS_TTL;
+
+  if (typeof request !== "function") {
+    return Promise.reject(new TypeError("loadBaseDicts 缺少 request 函数"));
+  }
+  // 没有 key（比如没传 code）就退化成一次普通请求，不走缓存。
+  if (!key) {
+    try {
+      return Promise.resolve(request());
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+
+  if (!force) {
+    const hit = cache.get(key);
+    if (hit) {
+      if (hit.expireAt > Date.now()) {
+        return Promise.resolve(cloneResponse(hit.res));
+      }
+      cache.delete(key);
+    }
+    const pending = inflight.get(key);
+    if (pending) return pending.promise.then(cloneResponse);
+  }
+
+  const startedAt = generation;
+  // 同步调 request()，别用 Promise.resolve().then(request) —— 那会把请求整体推迟
+  // 一个微任务，白白错过本可以和同批请求一起排队的时机。try/catch 只是接住
+  // request 自己同步抛出的情况。
+  let started;
+  try {
+    started = Promise.resolve(request());
+  } catch (error) {
+    return Promise.reject(error);
+  }
+
+  const task = started
+    .then((res) => {
+      if (ttl > 0 && isSuccessResponse(res) && generation === startedAt) {
+        cache.set(key, {
+          code,
+          res: cloneResponse(res),
+          expireAt: Date.now() + ttl,
+        });
+      }
+      return res;
+    })
+    .finally(() => {
+      const current = inflight.get(key);
+      if (current && current.promise === task) inflight.delete(key);
+    });
+
+  inflight.set(key, { code, promise: task });
+  return task;
+}
+
+/**
+ * 失效缓存。不传 code（或传空）则整体清空。
+ * @param {String|String[]} [code]
+ */
+export function invalidateBaseDicts(code) {
+  generation += 1;
+  if (code === undefined || code === null || code === "") {
+    cache.clear();
+    inflight.clear();
+    return;
+  }
+  const codes = Array.isArray(code) ? code : [code];
+  for (const [key, entry] of cache) {
+    if (codes.includes(entry.code)) cache.delete(key);
+  }
+  for (const [key, entry] of inflight) {
+    if (codes.includes(entry.code)) inflight.delete(key);
+  }
+}
+
+/** 清空全部。登出、切租户等场景直接调它。 */
+export function clearBaseDictsCache() {
+  invalidateBaseDicts();
+}
+
+/** 仅供测试与排查使用。 */
+export function getBaseDictsCacheStats() {
+  return { cached: cache.size, inflight: inflight.size };
+}

package/src/utils/chunkLoadError.js

@@ -0,0 +1,24 @@
+/**
+ * Webpack async chunk load error helpers.
+ *
+ * Keep this module dependency-free so dialogs and route loaders can share the
+ * same detection without pulling UI code into a chunk.
+ */
+export function isChunkLoadError(error) {
+  const name = (error && error.name) || "";
+  const message = (error && error.message) || String(error || "");
+  return (
+    name === "ChunkLoadError"
+    || /Loading (CSS )?chunk .* failed/i.test(message)
+    || /ChunkLoadError/i.test(message)
+    || /Failed to fetch dynamically imported module/i.test(message)
+    || /页面资源加载失败/i.test(message)
+  );
+}
+
+export function getChunkLoadErrorMessage(error, resourceName = "页面资源") {
+  if (isChunkLoadError(error)) {
+    return `${resourceName}加载失败，可能系统已发布新版本，请刷新页面后重试`;
+  }
+  return `${resourceName}加载失败，请稍后重试`;
+}

package/src/utils/featureResources.js

@@ -0,0 +1,57 @@
+/* global __CORE_RESOURCES__ */
+// Keep unmanaged legacy applications working. Managed starters fail explicitly
+// when a feature/mode was not declared, instead of issuing hidden 404 requests.
+export function codeEditorResourcePath(mode) {
+  const config = typeof __CORE_RESOURCES__ === "undefined" ? null : __CORE_RESOURCES__;
+  const feature = config && config.features.codeEditor;
+  if (config && !feature) throw new Error("CodeEditor 未启用资源，请配置 codeEditor 并运行 npm run resources:prepare");
+  if (feature && feature.modes !== "*" && !feature.modes.includes(mode)) {
+    throw new Error(`CodeEditor 资源未包含模式 ${mode}，请使用 full 配置并重新构建`);
+  }
+  return resolveResourceBase((feature && feature.basePath) || "base/ace/src-min-noconflict/");
+}
+
+export function richTextResourcePath(locale) {
+  const config = typeof __CORE_RESOURCES__ === "undefined" ? null : __CORE_RESOURCES__;
+  const feature = config && config.features.richText;
+  if (config && !feature) throw new Error("TinyMCE 未启用资源，请配置 richText 并运行 npm run resources:prepare");
+  if (feature && !feature.locales.includes(locale)) throw new Error(`TinyMCE 资源未包含语言 ${locale}`);
+  return resolveResourceBase((feature && feature.basePath) || "base/tinymce/");
+}
+
+export function spreadsheetResourcePath() {
+  const config = typeof __CORE_RESOURCES__ === "undefined" ? null : __CORE_RESOURCES__;
+  const feature = config && config.features.spreadsheet;
+  if (config && !feature) throw new Error("Luckysheet 未启用资源，请配置 spreadsheet 并运行 npm run resources:prepare");
+  return resolveResourceBase((feature && feature.basePath) || "luckysheet/");
+}
+
+export function workflowDesignerResourcePath() {
+  const config = typeof __CORE_RESOURCES__ === "undefined" ? null : __CORE_RESOURCES__;
+  const feature = config && config.features.workflowDesigner;
+  if (config && !feature) throw new Error("Activiti 未启用资源，请配置 workflowDesigner 并运行 npm run resources:prepare");
+  const base = resolveResourceBase((feature && feature.basePath) || "activiti-explorer/");
+  if (window.__POWERED_BY_QIANKUN__) {
+    throw new Error("Activiti 5.17 依赖真实父窗口回调，只支持主应用或非 qiankun 的同源页面");
+  }
+  return base;
+}
+
+export function workflowDesignerUrl({ wfType, serviceId, modelId, baseApi }) {
+  const resourceBase = workflowDesignerResourcePath();
+  window.sysParamForWf = {
+    webPrefix: new URL("../", resourceBase).href.replace(/\/$/, ""),
+    baseApi,
+  };
+  const url = new URL("modeler.html", resourceBase);
+  url.searchParams.set("wfType", wfType);
+  url.searchParams.set("serviceId", serviceId);
+  url.searchParams.set("modelId", modelId);
+  return url.href;
+}
+
+function resolveResourceBase(relative) {
+  const base = window.__POWERED_BY_QIANKUN__ && window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__
+    ? window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__ : (window.WEB_PREFIX || "") + "/";
+  return new URL(relative, new URL(base, window.location.href)).href;
+}

package/src/utils/importLimit.js

@@ -0,0 +1,72 @@
+/**
+ * 导入文件闸门。
+ *
+ * 导入侧是整文件 readAsBinaryString 读进内存 → XLSX.read（占用通常是文件体积的
+ * 5~20 倍）→ 再逐格建行数组，全程同步且没有任何让步。此前没有大小与行数校验，
+ * 几十 MB 的 xlsx 会直接把标签页撑爆，且崩在 FileReader / XLSX 内部，用户看到的
+ * 同样是"页面崩溃"而不是一句提示。
+ *
+ * 阈值都可以由导入配置覆盖（maxFileSize / maxRowNum，也支持写在 importOption 上），
+ * 传 0 表示不限制。
+ */
+
+/** 导入文件大小上限（字节）。 */
+export const DEFAULT_IMPORT_FILE_SIZE = 20 * 1024 * 1024;
+
+/** 导入数据行数上限（不含模板前 3 行表头）。 */
+export const DEFAULT_IMPORT_ROW_NUM = 20000;
+
+const readOption = (option, key) => {
+  if (option && option[key] !== undefined) return option[key];
+  if (option && option.importOption && option.importOption[key] !== undefined) {
+    return option.importOption[key];
+  }
+  return undefined;
+};
+
+const resolveLimit = (value, defaultValue) => {
+  let num = Number(value);
+  if (!isFinite(num) || num < 0) return defaultValue;
+  return num;
+};
+
+/** @param {Object} option 导入配置。@returns {Number} 文件大小上限，0 表示不限制。 */
+export function getImportFileSizeLimit(option) {
+  return resolveLimit(readOption(option, "maxFileSize"), DEFAULT_IMPORT_FILE_SIZE);
+}
+
+/** @param {Object} option 导入配置。@returns {Number} 行数上限，0 表示不限制。 */
+export function getImportRowLimit(option) {
+  return resolveLimit(readOption(option, "maxRowNum"), DEFAULT_IMPORT_ROW_NUM);
+}
+
+/** @param {File} file 待导入文件。@param {Object} option 导入配置。@returns {Boolean} */
+export function isImportFileOversize(file, option) {
+  let limit = getImportFileSizeLimit(option);
+  return limit > 0 && !!file && file.size > limit;
+}
+
+/** @param {Number} rowNum 数据行数。@param {Object} option 导入配置。@returns {Boolean} */
+export function isImportRowsOverLimit(rowNum, option) {
+  let limit = getImportRowLimit(option);
+  return limit > 0 && rowNum > limit;
+}
+
+/** @param {Number} bytes 字节数。@returns {Number} 保留一位小数的 MB 数。 */
+export function toFileSizeMb(bytes) {
+  return Math.round(((bytes || 0) / 1024 / 1024) * 10) / 10;
+}
+
+/**
+ * 取单元格文本：w（格式化文本）缺失时回退 v（原始值）。
+ * 模板里手工粘贴或公式生成的数值格常常只有 v，直接 w.trim() 会 TypeError，
+ * 而调用点外层的 catch 会把它吞成"点了导入没反应"。
+ * @param {Object} cell xlsx 单元格。
+ * @returns {String|undefined}
+ */
+export function getImportCellText(cell) {
+  if (cell === undefined || cell === null) return undefined;
+  let text = cell.w !== undefined && cell.w !== null ? cell.w : cell.v;
+  if (text === undefined || text === null) return undefined;
+  return String(text).trim();
+}

package/src/utils/pdfUtil.js

@@ -11,6 +11,8 @@ const PAGE_MARGIN = 10;
 //超过之后 toDataURL 直接返回空白图——长详情页很容易撞上，这里按内容尺寸回退 scale。
 const MAX_CANVAS_SIDE = 16384;
 const MAX_CANVAS_AREA = 268435456;
+//回退倍率的下限。再往下字就糊到认不出了，与其导出一份看不清的 PDF，不如让它明确失败
+const MIN_SCALE = 0.2;
 
 const JPEG_QUALITY = 0.92;
 
@@ -103,7 +105,10 @@ function pickScale(width, height, expected) {
     MAX_CANVAS_SIDE / height,
     Math.sqrt(MAX_CANVAS_AREA / (width * height))
   );
-  return Math.max(scale, 1);
+  //下限不能取 1：内容高度超过 16384 CSS px 的长页面(整页导出的常态)算出来的上限本就 <1，
+  //抬回 1 等于把上面这段保护整个作废——canvas 照样越界，toDataURL 返回空白图，
+  //正是 MAX_CANVAS_SIDE 想拦的那个失败。html2canvas 支持 scale < 1，糊一点也要出得来。
+  return Math.max(scale, MIN_SCALE);
 }
 
 //Safari(WebKit) 的 getComputedStyle 会把颜色序列化成 color(srgb …) / color(display-p3 …)，

package/src/utils/request.js

@@ -9,6 +9,7 @@ import PopupManager from "element-ui/src/utils/popup/popup-manager.js";
 import settingConfig from "@/settings.js";
 import { encode } from "js-base64";
 import { encrypt } from "@base/utils/aes";
+import { handleRequestNetworkError } from "@base/utils/runtimeRecovery";
 
 let configUtil = {
   baseUrl: process.env.VUE_APP_BASE_API,
@@ -56,8 +57,13 @@ service.interceptors.request.use(
         config.filterConfig
       );
     }
-    if (
-      (config.headers["Content-Type"] === "application/x-www-form-urlencoded" ||
+    if (settingConfig.requestAesEnabled === true) {
+      config.data = {
+        _aeenboda: encrypt(JSON.stringify(config.data === undefined ? {} : config.data)),
+      };
+      config.headers["Content-Type"] = "application/json;charset=UTF-8";
+    } else if (
+      (config.headers["Content-Type"] === "application/x-www-form-urlencoded" ||
         config.headers["Content-Type"] ===
           "application/x-www-form-urlencoded;charset=UTF-8") &&
       typeof config.data !== "string" &&
@@ -92,6 +98,15 @@ service.interceptors.request.use(
         background: "unset",
       });
     }
+
+    // 被取消的请求走不到响应/错误拦截器里的 removeModel —— Cancel 对象不带 config，
+    // 那边无从知道该清理哪一个请求。不收口的话上面这两样会永久留在页面上（一个关不掉
+    // 的转圈遮罩）。挂到令牌自己的 promise 上，取消时精确清理本次请求创建的那份。
+    if (config.cancelToken && (config.ajaxOverlay || config.loadingInstance)) {
+      config.cancelToken.promise.then(function () {
+        removeModel(config);
+      });
+    }
     return config;
   },
   (error) => {
@@ -115,6 +130,103 @@ function removeModel(config) {
   }
 }
 
+function getSafeRequestUrl(config) {
+  if (!config || !config.url) return t1("未知");
+  const rawUrl = String(config.url).split("?")[0].split("#")[0];
+  const baseUrl = config.baseURL || "";
+  if (/^https?:\/\//i.test(rawUrl)) return rawUrl;
+  return `${baseUrl || ""}${rawUrl}` || t1("未知");
+}
+
+function t1(path, values) {
+  const translate = Vue.prototype.$t1;
+  return typeof translate === "function" ? translate(path, values) : path;
+}
+
+function isAxiosNetworkError(error) {
+  if (!error || error.response) return false;
+  const message = (error.message || "").toString();
+  if (error.code === "ECONNABORTED" || /timeout/i.test(message)) return false;
+  return error.code === "ERR_NETWORK" || /network error/i.test(message);
+}
+
+function isGateway502(error) {
+  return !!(error && error.response && error.response.status === 502);
+}
+
+function shouldSwallowNetworkError(config, error) {
+  return !!(
+    config &&
+    config.ignoreNetworkError === true &&
+    isAxiosNetworkError(error)
+  );
+}
+
+function shouldSwallow502(config, error) {
+  return !!(config && config.ignore502 === true && isGateway502(error));
+}
+
+function getRequestErrorMessage(error) {
+  const config = (error && error.config) || {};
+  const response = error && error.response;
+  const status = response && response.status;
+  const method = String(config.method || "GET").toUpperCase();
+  const requestUrl = getSafeRequestUrl(config);
+  const originalMessage = (error && error.message) || "未知错误";
+  let summary = t1("请求失败，请稍后重试。");
+
+  if (error && (error.code === "ECONNABORTED" || /timeout/i.test(originalMessage))) {
+    summary = t1("请求超时，请检查网络或稍后重试。");
+  } else if (!response) {
+    summary = t1("无法连接服务器，请检查网络、VPN/代理及服务状态后重试。");
+  } else if ([501, 502, 503, 504].includes(status)) {
+    summary = t1("网关或后端服务异常，请稍后重试或联系管理员。");
+  } else if (status >= 500) {
+    summary = t1("服务器暂时不可用，请稍后重试或联系管理员。");
+  } else if (status === 404) {
+    summary = t1("请求的服务地址不存在，请联系管理员检查接口配置。");
+  } else if (status === 403) {
+    summary = t1("服务器拒绝了本次请求，请检查访问权限。");
+  } else if (status === 401) {
+    summary = t1("登录状态已失效或无效，请重新登录。");
+  } else if (status >= 400) {
+    summary = t1("服务器未能处理本次请求，请检查输入后重试。");
+  }
+
+  const details = [
+    summary,
+    t1("请求：{method} {url}", { method, url: requestUrl }),
+    t1("状态码：{status}", {
+      status: status || t1("未收到服务器响应（浏览器未提供 HTTP 状态码）"),
+    }),
+  ];
+  if (error && error.code) {
+    details.push(t1("错误码：{code}", { code: error.code }));
+  }
+  details.push(
+    t1("原始错误：{message}", { message: originalMessage }),
+    t1("发生时间：{time}", { time: new Date().toLocaleString() })
+  );
+
+  if (!response) {
+    details.push(t1("可能原因："));
+    details.push(t1("ERR_CONNECTION_RESET：连接被服务端、网关或安全设备重置；"));
+    details.push(t1("CORS：浏览器跨域配置异常；"));
+    details.push(t1("ERR_CERT_*：HTTPS 证书异常；"));
+    details.push(t1("请求长期 Pending：接口阻塞或连接未释放。"));
+    details.push(t1("实际 HTTP 状态码请在浏览器 Network 面板或网关日志中确认。"));
+  } else if ([501, 502, 503, 504].includes(status)) {
+    details.push(t1("501/502/503/504：网关或后端服务异常。"));
+  }
+
+  return {
+    summary,
+    details: details.join("\n"),
+    // 有 HTTP 状态码时直接挂到弹窗标题 Error（502），不用点开「详情」
+    errorLabel: status ? String(status) : !response ? originalMessage : "",
+  };
+}
+
 async function handleNickName(option) {
   let { vueTarget, res, callback, config } = option;
   if (res.type !== "success" || !res.objx) {
@@ -383,7 +495,31 @@ service.interceptors.response.use(
     }
   },
   (error) => {
+    // 主动取消（axios.CancelToken）不是错误，必须最先短路返回。
+    // axios 0.18 取消时 reject 的是 Cancel 对象，它**不带 config**，会一路落到下面
+    // 那个 else 分支无条件弹 ErroreBox —— 而 ErroreBox 是弹窗不是 toast，取消 N 个
+    // 在途请求就会连弹 N 个错误框。config.errorMsg 那条逃生口在 if (config) 里面，
+    // Cancel 走不到，所以只能在这里拦。调用方按需自行 catch。
+    if (axios.isCancel(error)) {
+      return Promise.reject(error);
+    }
     let config = error.config;
+    // ignoreNetworkError 只吞 Network Error；ignore502 只吞 502。两者互不影响。
+    const swallowError =
+      shouldSwallowNetworkError(config, error) || shouldSwallow502(config, error);
+    // modalStrictly 的语义是「业务失败后由后续流程接管遮罩」，只对响应拦截器里
+    // res.type !== 'success' 那条分支成立。传输层错误（断网、DNS 解析失败、连接被
+    // 重置）没有任何后续流程会接手，再跳过 removeModel，遮罩就永远留在页面上。
+    //
+    // $baseLoading({ target: document.body }) 拿到的是 element 的 fullscreen 单例
+    // （见 utils/pdfUtil.js 里的说明），平时靠「同一批里随便哪个请求收尾」顺手关掉，
+    // 所以只有整批请求全军覆没时才暴露出来 —— 正好就是详情页 mounted 一口气发
+    // 8+ 个 isLoading + modalStrictly 请求、网络一抖就整页白屏且滚动被锁死的场景。
+    // 下面两处一律 removeModel：正常情况下本来也会被别的请求关掉，行为不变。
+    if (handleRequestNetworkError()) {
+      removeModel(config);
+      return swallowError ? Promise.resolve() : Promise.reject(error);
+    }
     if (
       error.response &&
       error.response.data &&
@@ -394,23 +530,27 @@ service.interceptors.response.use(
     } else {
       if (config) {
         config.error && config.error(error);
-        if (config.modalStrictly !== true) {
-          removeModel(config);
-        }
-        if (config.errorMsg !== false) {
+        removeModel(config);
+        if (config.errorMsg !== false && !swallowError) {
+          const requestError = getRequestErrorMessage(error);
           ErroreBox.msg({
-            content: error.message,
+            content: requestError.summary,
+            _errorMsg: requestError.details,
+            errorLabel: requestError.errorLabel,
             type: "error",
           });
         }
       } else {
+        const requestError = getRequestErrorMessage(error);
         ErroreBox.msg({
-          content: error.message,
+          content: requestError.summary,
+          _errorMsg: requestError.details,
+          errorLabel: requestError.errorLabel,
           type: "error",
         });
       }
     }
-    return Promise.reject(error);
+    return swallowError ? Promise.resolve() : Promise.reject(error);
   }
 );