ls-pro-common 3.1.57 → 3.1.59

package/lib/http/ajax.d.ts

@@ -0,0 +1,73 @@
+export declare const TIMEOUT = 60000;
+export declare const request: import("umi-request").RequestMethod<false>;
+export declare const httpStatus: any;
+export declare const ajaxHeader: Record<string, any>;
+/**
+ * 判断URL是否跨域
+ *
+ * @param url 需要判断的URL
+ * @returns 如果是跨域返回true，否则返回false
+ */
+export declare const isCrossDomain: (url: string) => boolean;
+export declare function ajax(url: string, params: Record<string, any> | undefined, type: string, needGateWay?: boolean, isJson?: boolean, timeout?: number): Promise<any>;
+/**
+ * Get请求
+ *
+ * @param url 接口
+ * @param params 参数{key:value}
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export declare function httpGet(url: string, params?: Record<string, any>, needGateWay?: boolean, timeout?: number): Promise<any>;
+/**
+ * Post请求
+ *
+ * @param url 接口
+ * @param data 参数{key:value}
+ * @param isJson Json请求还是form请求,默认为json请求
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export declare function httpPost(url: string, data?: Record<string, any>, isJson?: boolean, needGateWay?: boolean, timeout?: number): Promise<any>;
+/**
+ * Put 请求
+ *
+ * @param url 接口
+ * @param data 参数{key:value}
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export declare function httpPut(url: string, data?: Record<string, any>, needGateWay?: boolean, timeout?: number): Promise<any>;
+/**
+ * Delete 请求
+ *
+ * @param url 接口
+ * @param data 参数[]
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export declare function httpDelete(url: string, data: any, needGateWay?: boolean, timeout?: number): Promise<any>;
+/**
+ * 分批获取数据，当一次性取大于2000条，且是第一页时，分多次去取，避免一次性取太多数据导致后端工程压力过大
+ *
+ * 注意：如果pageSize小于等于2000，或不是取第一页数据时，直接使用普通请求
+ *
+ * @param url
+ * @param params
+ * @param needGateWay
+ * @param timeout
+ * @returns
+ */
+export declare const httpBatchGet: (url: string, params?: Record<string, any>, needGateWay?: boolean, timeout?: number) => Promise<any>;
+/**
+ * 分批获取数据，当一次性取大于2000条，且是第一页时，分多次去取，避免一次性取太多数据导致后端工程压力过大
+ *
+ * 注意：如果pageSize小于等于2000，或不是取第一页数据时，直接使用普通请求
+ *
+ * @param url
+ * @param params
+ * @param needGateWay
+ * @param timeout
+ * @returns
+ */
+export declare const httpBatchPost: (url: string, params?: Record<string, any>, needGateWay?: boolean, timeout?: number) => Promise<any>;

package/lib/http/ajax.js

@@ -0,0 +1,611 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { extend } from 'umi-request';
+import { getCache, getUrlQuery, setUrlQuery, getCookie, getCacheSessionFirst, getResourceProps, showError, httpError, toGatewayUrl, reLogin, showLoading, exitLoading, getBrowserId, setCache, isDingtalk } from '../utils';
+export var TIMEOUT = 60000;
+// 默认分批获取数据的大小
+var DEFAULT_PAGE_SIZE = 2000;
+//默认超时时间为1分钟
+export var request = extend({
+  timeout: TIMEOUT
+});
+export var httpStatus = {
+  404: '请求的服务不存在',
+  429: '请求的服务繁忙',
+  502: '请求的服务网关出错',
+  503: '请求的服务器异常',
+  504: '请求服务超时'
+};
+export var ajaxHeader = {
+  browserId: '',
+  ifExpireWarn: false
+};
+(function () {
+  setTimeout(function () {
+    getBrowserId().then(function (id) {
+      ajaxHeader.browserId = id;
+    });
+  }, 0);
+})();
+//是否跨域
+/**
+ * 判断URL是否跨域
+ *
+ * @param url 需要判断的URL
+ * @returns 如果是跨域返回true，否则返回false
+ */
+export var isCrossDomain = function isCrossDomain(url) {
+  // 如果URL不是以http(s)://开头，则直接认为是同源
+  if (!url.startsWith('http://') && !url.startsWith('https://') && !url.startsWith('//')) {
+    return false;
+  }
+  try {
+    // 创建URL对象
+    var currentUrl = window.location;
+    if (url.startsWith('//')) {
+      url = currentUrl.protocol + url;
+    }
+    var targetUrl = new URL(url);
+    // 判断协议、域名、端口是否一致
+    return targetUrl.protocol !== currentUrl.protocol || targetUrl.hostname !== currentUrl.hostname || targetUrl.port !== currentUrl.port;
+  } catch (e) {
+    // URL解析失败，返回true表示跨域
+    console.warn('URL解析失败:', e);
+    return true;
+  }
+};
+/** 请求拦截器,统一添加token */
+request.interceptors.request.use(function (url, options) {
+  var _window$crypto$random, _window$crypto, _options$params;
+  options.headers = options.headers || {};
+  // 处理浏览器指纹
+  if (ajaxHeader.browserId) {
+    options.headers.browserId = ajaxHeader.browserId;
+  } else {
+    if (getCache('browserId')) {
+      ajaxHeader.browserId = getCache('browserId');
+      options.headers.browserId = ajaxHeader.browserId;
+    } else {
+      getBrowserId().then(function (id) {
+        ajaxHeader.browserId = id;
+      });
+    }
+  }
+  // 处理门店
+  var shopNo = getCacheSessionFirst('shopNo');
+  if (shopNo) {
+    options.headers.shopNo = shopNo;
+  }
+  // 处理门店
+  var shopCode = getCacheSessionFirst('shopCode');
+  if (shopCode) {
+    options.headers.shopCode = shopCode;
+  }
+  // 处理仓库
+  var storeNo = getCacheSessionFirst('storeNo');
+  if (storeNo) {
+    options.headers.storeNo = storeNo;
+  }
+  var tag = getCookie('x-asm-prefer-tag');
+  if (tag) {
+    options.headers['x-asm-prefer-tag'] = tag; //灰度发版标识
+  }
+
+  if (isDingtalk) {
+    options.headers.terminal = 'APP';
+  } else {
+    options.headers.terminal = 'PC';
+  }
+  var expireWarnFlag = getCache('expireWarnFlag', true);
+  options.headers.expireWarnFlag = expireWarnFlag === '1' ? '1' : '0';
+  var token = getCookie('token');
+  if (token && url.indexOf('noToken=1') === -1) {
+    options.headers.token = token;
+  }
+  url = url.replace('&noToken=1', '').replace('noToken=1', '');
+  var resCode = getUrlQuery('resCode', url) || window.__currentResCode__ || getUrlQuery('resCode') || getUrlQuery('resourceId') || getResourceProps('resourceId');
+  var param = {
+    _t1: Date.now(),
+    __r: ((_window$crypto$random = (_window$crypto = window.crypto)['randomUUID']) === null || _window$crypto$random === void 0 ? void 0 : _window$crypto$random.call(_window$crypto)) || Math.random()
+  };
+  // 当没有明文参数resCode的时候，添加resCode参数为资源Id
+  if (resCode && !((_options$params = options.params) === null || _options$params === void 0 ? void 0 : _options$params.resCode)) {
+    param.resCode = resCode;
+  }
+  url = setUrlQuery(url, param);
+  return {
+    url: url,
+    options: options
+  };
+});
+/** 请求返回拦截器,统一处理业务异常 */
+request.interceptors.response.use( /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(response, options) {
+    var _navigator, _navigator$userAgent;
+    var noMsg, userAgent, isMobile, _data$flag, _data$flag2, _data$flag3, data, retCode, retMsg, faultCode, is99110, text, _text, _text2, _data$flag4, _data$flag5, _data$flag6, _data, _retCode, _retMsg, status, _faultCode, _is;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          noMsg = getUrlQuery('noMsg', options.url);
+          userAgent = (_navigator = navigator) === null || _navigator === void 0 ? void 0 : (_navigator$userAgent = _navigator.userAgent) === null || _navigator$userAgent === void 0 ? void 0 : _navigator$userAgent.toLowerCase();
+          isMobile = /mobile/i.test(userAgent); // http 状态码错误
+          if (!(response.status < 200 || response.status >= 300)) {
+            _context.next = 28;
+            break;
+          }
+          _context.prev = 4;
+          _context.next = 7;
+          return response.clone().json();
+        case 7:
+          data = _context.sent;
+          retCode = (_data$flag = data.flag) === null || _data$flag === void 0 ? void 0 : _data$flag.retCode;
+          retMsg = (_data$flag2 = data.flag) === null || _data$flag2 === void 0 ? void 0 : _data$flag2.retMsg;
+          faultCode = (_data$flag3 = data.flag) === null || _data$flag3 === void 0 ? void 0 : _data$flag3.faultCode;
+          is99110 = false; // wms 提示，是否排班标识
+          if (!(retCode === '99110')) {
+            _context.next = 18;
+            break;
+          }
+          is99110 = true;
+          if (!(getCache('expireWarnFlag', true) === '1' || ajaxHeader.ifExpireWarn)) {
+            _context.next = 16;
+            break;
+          }
+          return _context.abrupt("return", response);
+        case 16:
+          ajaxHeader.ifExpireWarn = true;
+          setCache('expireWarnFlag', '1', true);
+        case 18:
+          if ((retCode === 'timeout' || retCode === '4011' || retCode === '4013' || retCode === '9009' && retMsg === '令牌不能为空') && !isMobile) {
+            if (!getCookie('token')) {
+              (window.top || window).location.href = location.pathname === '/' || location.pathname.startsWith('/login') ? '/login' : '/login?redirect=' + encodeURIComponent(location.href);
+            } else {
+              reLogin();
+            }
+          } else if (noMsg !== '1') {
+            if (faultCode) {
+              if (retCode === '4012') {
+                text = '用户已禁用,无权限进行操作';
+              }
+              httpError(text || retMsg, retCode, faultCode, {
+                title: is99110 ? '账号到期提醒' : '请求接口出错'
+              });
+            } else {
+              _text = httpStatus[response.status];
+              if (response.status === 503 && response.statusText === 'no healthy upstream') {
+                _text = '请求的服务未启动';
+              } else if (response.status === 503 && response.statusText === 'reached concurrency limit') {
+                _text = '请求的服务被限流';
+              }
+              showError(_text || retMsg);
+            }
+          }
+          _context.next = 26;
+          break;
+        case 21:
+          _context.prev = 21;
+          _context.t0 = _context["catch"](4);
+          _text2 = httpStatus[response.status];
+          if (response.status === 503 && response.statusText === 'no healthy upstream') {
+            _text2 = '请求的服务未启动';
+          } else if (response.status === 503 && response.statusText === 'reached concurrency limit') {
+            _text2 = '请求的服务被限流';
+          }
+          showError(_text2 || _context.t0.message || response.statusText);
+        case 26:
+          _context.next = 44;
+          break;
+        case 28:
+          if (!(noMsg !== '1')) {
+            _context.next = 44;
+            break;
+          }
+          _context.next = 31;
+          return response.clone().json();
+        case 31:
+          _data = _context.sent;
+          _retCode = (_data === null || _data === void 0 ? void 0 : (_data$flag4 = _data.flag) === null || _data$flag4 === void 0 ? void 0 : _data$flag4.retCode) || '0';
+          _retMsg = ((_data$flag5 = _data.flag) === null || _data$flag5 === void 0 ? void 0 : _data$flag5.retMsg) || '请求的服务出错';
+          status = (getUrlQuery('apiStatus', options.url) || '0').split(',');
+          _faultCode = (_data$flag6 = _data.flag) === null || _data$flag6 === void 0 ? void 0 : _data$flag6.faultCode;
+          _is = false; // wms 提示，是否排班标识
+          if (!(_retCode === '99110')) {
+            _context.next = 43;
+            break;
+          }
+          _is = true;
+          if (!(getCache('expireWarnFlag', true) === '1' || ajaxHeader.ifExpireWarn)) {
+            _context.next = 41;
+            break;
+          }
+          return _context.abrupt("return", response);
+        case 41:
+          ajaxHeader.ifExpireWarn = true;
+          setCache('expireWarnFlag', '1', true);
+        case 43:
+          if (_retCode && !status.includes(_retCode)) {
+            if ((_retCode === 'timeout' || _retCode === '4011' || _retCode === '9009' && _retMsg === '令牌不能为空') && !isMobile) {
+              if (!getCookie('token')) {
+                (window.top || window).location.href = location.pathname === '/' || location.pathname.startsWith('/login') ? '/login' : '/login?redirect=' + encodeURIComponent(location.href);
+              } else {
+                reLogin();
+              }
+            } else {
+              if (_faultCode) {
+                httpError(_retMsg, _retCode, _faultCode, {
+                  title: _is ? '账号到期提醒' : '请求接口出错'
+                });
+              } else {
+                showError(_retMsg);
+              }
+            }
+          }
+        case 44:
+          return _context.abrupt("return", response);
+        case 45:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[4, 21]]);
+  }));
+  return function (_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}());
+export function ajax(url) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var type = arguments.length > 2 ? arguments[2] : undefined;
+  var needGateWay = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var isJson = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  var timeout = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : TIMEOUT;
+  if (needGateWay) {
+    url = toGatewayUrl(url);
+  }
+  var loadText = getUrlQuery('_loading', url);
+  if (loadText) {
+    showLoading(loadText);
+    url = setUrlQuery(url, {
+      _loading: ''
+    }).replace('&_loading=', '').replace('_loading=', '');
+  }
+  var finallyFn = function finallyFn() {
+    if (loadText) {
+      exitLoading();
+    }
+  };
+  if (type === 'get') {
+    return request.get(url, {
+      params: params,
+      timeout: timeout
+    }).finally(finallyFn);
+  } else if (type === 'delete') {
+    return request.delete(url, {
+      data: params,
+      timeout: timeout
+    }).finally(finallyFn);
+  } else if (type === 'put') {
+    return request.put(url, {
+      data: params,
+      timeout: timeout
+    }).finally(finallyFn);
+  } else {
+    // 如果sumProperties存在，则添加sumProperties参数到url中
+    if (params.sumProperties && typeof params.sumProperties === 'string') {
+      url = setUrlQuery(url, {
+        sumProperties: params.sumProperties
+      });
+    }
+    var requestType = isJson ? 'json' : 'form';
+    return request.post(url, {
+      data: params,
+      timeout: timeout,
+      requestType: requestType
+    }).finally(finallyFn);
+  }
+}
+/**
+ * Get请求
+ *
+ * @param url 接口
+ * @param params 参数{key:value}
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export function httpGet(url) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var needGateWay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var timeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TIMEOUT;
+  return ajax(url, params, 'get', needGateWay, true, timeout);
+}
+/**
+ * Post请求
+ *
+ * @param url 接口
+ * @param data 参数{key:value}
+ * @param isJson Json请求还是form请求,默认为json请求
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export function httpPost(url) {
+  var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var isJson = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var needGateWay = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var timeout = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : TIMEOUT;
+  return ajax(url, data, 'post', needGateWay, isJson, timeout);
+}
+/**
+ * Put 请求
+ *
+ * @param url 接口
+ * @param data 参数{key:value}
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export function httpPut(url) {
+  var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var needGateWay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var timeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TIMEOUT;
+  return ajax(url, data, 'put', needGateWay, true, timeout);
+}
+/**
+ * Delete 请求
+ *
+ * @param url 接口
+ * @param data 参数[]
+ * @param needGateWay 是否需要网关 默认为true
+ * @returns Promise<ApiResponse>
+ */
+export function httpDelete(url, data) {
+  var needGateWay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var timeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 60000;
+  return ajax(url, data, 'delete', needGateWay, true, timeout);
+}
+/**
+ * 分批获取数据
+ *
+ * @param url
+ * @param params
+ * @param method
+ * @param needGateWay
+ * @param timeout
+ * @returns
+ */
+function httpBatchRequest(_x3) {
+  return _httpBatchRequest.apply(this, arguments);
+}
+/**
+ * 分批获取数据，当一次性取大于2000条，且是第一页时，分多次去取，避免一次性取太多数据导致后端工程压力过大
+ *
+ * 注意：如果pageSize小于等于2000，或不是取第一页数据时，直接使用普通请求
+ *
+ * @param url
+ * @param params
+ * @param needGateWay
+ * @param timeout
+ * @returns
+ */
+function _httpBatchRequest() {
+  _httpBatchRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(url) {
+    var params,
+      method,
+      needGateWay,
+      timeout,
+      urlPageSize,
+      urlPageNum,
+      pageSize,
+      pageNum,
+      isV2,
+      PAGE_SIZE,
+      PAGE_NUM,
+      cleanUrl,
+      batchSize,
+      allRows,
+      total,
+      currentPage,
+      _objectSpread2,
+      firstParams,
+      api,
+      _setUrlQuery3,
+      firstResponse,
+      firstData,
+      actualPageSize,
+      totalPages,
+      maxConcurrent,
+      remainingPages,
+      i,
+      _i,
+      batchPages,
+      batchRequests,
+      batchResponses,
+      _args4 = arguments;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          params = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : {};
+          method = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : 'get';
+          needGateWay = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : true;
+          timeout = _args4.length > 4 && _args4[4] !== undefined ? _args4[4] : TIMEOUT;
+          // 从URL中获取pageSize和page参数
+          urlPageSize = getUrlQuery('pageSize', url) || getUrlQuery('page.size', url);
+          urlPageNum = getUrlQuery('page', url) || getUrlQuery('page.pn', url) || '1'; // 优先使用params中的分页参数，其次使用URL中的分页参数
+          pageSize = (params === null || params === void 0 ? void 0 : params.pageSize) || (params === null || params === void 0 ? void 0 : params['page.size']) || (urlPageSize ? parseInt(urlPageSize) : DEFAULT_PAGE_SIZE);
+          pageNum = (params === null || params === void 0 ? void 0 : params.page) || (params === null || params === void 0 ? void 0 : params['page.pn']) || parseInt(urlPageNum); // 如果pageSize小于等于DEFAULT_PAGE_SIZE，或不是取第一页数据时，直接使用普通请求
+          if (!(pageSize <= DEFAULT_PAGE_SIZE || pageNum !== 1)) {
+            _context4.next = 10;
+            break;
+          }
+          return _context4.abrupt("return", ajax(url, params, method, needGateWay, true, timeout));
+        case 10:
+          // 是否为 2.0版本的api。
+          isV2 = url.includes('page.size') || (params === null || params === void 0 ? void 0 : params['page.size']) ? true : false; // 不同版本api的请求分页关键字处理，
+          PAGE_SIZE = isV2 ? 'page.size' : 'pageSize';
+          PAGE_NUM = isV2 ? 'page.pn' : 'page'; // 分批获取数据时，需要从URL中移除原有的pageSize和page参数
+          cleanUrl = url;
+          if (urlPageSize) {
+            cleanUrl = setUrlQuery(cleanUrl, _defineProperty({}, PAGE_SIZE, '')).replace("&".concat(PAGE_SIZE, "="), '').replace("".concat(PAGE_SIZE, "="), '');
+          }
+          if (urlPageNum) {
+            cleanUrl = setUrlQuery(cleanUrl, _defineProperty({}, PAGE_NUM, '')).replace("&".concat(PAGE_NUM, "="), '').replace("".concat(PAGE_NUM, "="), '');
+          }
+          // 分批获取数据
+          batchSize = DEFAULT_PAGE_SIZE;
+          allRows = [];
+          total = 0;
+          currentPage = pageNum;
+          _context4.prev = 20;
+          // 第一次请求，获取总数
+          firstParams = _objectSpread(_objectSpread({}, params), {}, (_objectSpread2 = {}, _defineProperty(_objectSpread2, PAGE_SIZE, batchSize), _defineProperty(_objectSpread2, PAGE_NUM, currentPage), _objectSpread2)); // 如果是 post 请求，body 和 query 里都传入分页参数
+          api = cleanUrl;
+          if (method === 'post') {
+            api = setUrlQuery(cleanUrl, (_setUrlQuery3 = {}, _defineProperty(_setUrlQuery3, PAGE_SIZE, batchSize), _defineProperty(_setUrlQuery3, PAGE_NUM, currentPage), _setUrlQuery3));
+          }
+          _context4.next = 26;
+          return ajax(api, firstParams, method, needGateWay, true, timeout);
+        case 26:
+          firstResponse = _context4.sent;
+          firstData = firstResponse; // 如果返回值没有 rows 或 total，直接返回普通请求
+          if (!(!('rows' in firstData) || !('total' in firstData))) {
+            _context4.next = 30;
+            break;
+          }
+          return _context4.abrupt("return", ajax(url, params, method, needGateWay, true, timeout));
+        case 30:
+          if (firstData.rows) {
+            allRows.push.apply(allRows, _toConsumableArray(firstData.rows));
+            total = firstData.total || 0;
+          }
+          // 如果total小于等于DEFAULT_PAGE_SIZE，不需要分批获取，直接返回
+          if (!(total <= DEFAULT_PAGE_SIZE)) {
+            _context4.next = 33;
+            break;
+          }
+          return _context4.abrupt("return", firstResponse);
+        case 33:
+          // 计算实际需要获取的数据量（不超过用户传入的pageSize）
+          actualPageSize = Math.min(pageSize, total); // 计算需要请求的总页数（基于实际需要的数据量）
+          totalPages = Math.ceil(actualPageSize / batchSize); // 如果还有更多数据需要获取
+          if (!(totalPages > 1)) {
+            _context4.next = 50;
+            break;
+          }
+          // 分批并发请求，每次最多6个并发
+          maxConcurrent = 6;
+          remainingPages = []; // 准备所有需要请求的页码
+          for (i = currentPage + 1; i <= totalPages; i++) {
+            remainingPages.push(i);
+          }
+          // 分批处理请求
+          _i = 0;
+        case 40:
+          if (!(_i < remainingPages.length)) {
+            _context4.next = 50;
+            break;
+          }
+          batchPages = remainingPages.slice(_i, _i + maxConcurrent);
+          batchRequests = batchPages.map(function (page) {
+            var _objectSpread3;
+            var requestParams = _objectSpread(_objectSpread({}, params), {}, (_objectSpread3 = {}, _defineProperty(_objectSpread3, PAGE_SIZE, batchSize), _defineProperty(_objectSpread3, PAGE_NUM, page), _objectSpread3));
+            var requestApi = cleanUrl;
+            if (method === 'post') {
+              var _setUrlQuery4;
+              requestApi = setUrlQuery(cleanUrl, (_setUrlQuery4 = {}, _defineProperty(_setUrlQuery4, PAGE_SIZE, batchSize), _defineProperty(_setUrlQuery4, PAGE_NUM, page), _setUrlQuery4));
+            }
+            return ajax(requestApi, requestParams, method, needGateWay, true, timeout);
+          }); // 并发执行当前批次的请求
+          _context4.next = 45;
+          return Promise.all(batchRequests);
+        case 45:
+          batchResponses = _context4.sent;
+          // 合并当前批次的响应数据
+          batchResponses.forEach(function (response) {
+            var data = response;
+            if (data.rows) {
+              allRows.push.apply(allRows, _toConsumableArray(data.rows));
+            }
+          });
+        case 47:
+          _i += maxConcurrent;
+          _context4.next = 40;
+          break;
+        case 50:
+          // 如果获取的数据超过了用户要求的pageSize，进行截取
+          if (allRows.length > actualPageSize) {
+            allRows.splice(actualPageSize);
+          }
+          // 返回合并后的数据，保持与原始响应格式一致
+          return _context4.abrupt("return", _objectSpread(_objectSpread({}, firstResponse), {}, {
+            rows: allRows,
+            total: total // 保持原始的total值
+          }));
+        case 54:
+          _context4.prev = 54;
+          _context4.t0 = _context4["catch"](20);
+          throw _context4.t0;
+        case 57:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[20, 54]]);
+  }));
+  return _httpBatchRequest.apply(this, arguments);
+}
+export var httpBatchGet = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(url) {
+    var params,
+      needGateWay,
+      timeout,
+      _args2 = arguments;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          params = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+          needGateWay = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : true;
+          timeout = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : TIMEOUT;
+          return _context2.abrupt("return", httpBatchRequest(url, params, 'get', needGateWay, timeout));
+        case 4:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function httpBatchGet(_x4) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * 分批获取数据，当一次性取大于2000条，且是第一页时，分多次去取，避免一次性取太多数据导致后端工程压力过大
+ *
+ * 注意：如果pageSize小于等于2000，或不是取第一页数据时，直接使用普通请求
+ *
+ * @param url
+ * @param params
+ * @param needGateWay
+ * @param timeout
+ * @returns
+ */
+export var httpBatchPost = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(url) {
+    var params,
+      needGateWay,
+      timeout,
+      _args3 = arguments;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          params = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
+          needGateWay = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : true;
+          timeout = _args3.length > 3 && _args3[3] !== undefined ? _args3[3] : TIMEOUT;
+          return _context3.abrupt("return", httpBatchRequest(url, params, 'post', needGateWay, timeout));
+        case 4:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function httpBatchPost(_x5) {
+    return _ref3.apply(this, arguments);
+  };
+}();