nsn-service/lib/core/request.js

NSN服务组件

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.httpErrorHandler = exports.request = void 0;

var _antd = require("antd");

var _nsnConst = require("nsn-const");

var _nsnEnum = require("nsn-enum");

var _nsnUtil = require("nsn-util");

var _umiRequest = require("umi-request");

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var getHashCode = function getHashCode(url) {
  var chars = url.split('');
  var hash = 0;
  chars.forEach(function (c) {
    var character = c.charCodeAt(0);
    hash = (hash << 5) - hash + character;
    hash |= 0;
  });
  return hash;
};
/**
 * // 文件名(后端下载时，在响应头中设置了该文件头 Content-Disposition)
 * @param response 响应体
 */


var getFileNameFromHeader = function getFileNameFromHeader(response) {
  var filename = "".concat(new Date().getTime());
  response.headers.forEach(function (value, key) {
    if (_nsnUtil.NStr.isEqual(key.toLocaleLowerCase(), 'content-disposition')) {
      filename = window.decodeURI(value);
    }
  });
  var ZH_CN_STR = 'zh_cn';

  if (filename && filename.includes(ZH_CN_STR)) {
    filename = filename.substring(filename.indexOf(ZH_CN_STR) + ZH_CN_STR.length + 1);
  }

  return filename;
};
/** 非 200 响应处理 */


var httpErrorHandler = function httpErrorHandler(error) {
  _antd.notification.destroy();

  var response = error.response;

  if (response && response.status) {
    var status = response.status,
        url = response.url; // 请求已发送但服务端返回状态码非 2xx 的响应

    var errorText = _nsnUtil.NLocale.getText("http.status.".concat(status)) || response.statusText;

    _antd.notification.error({
      message: "".concat(_nsnUtil.NLocale.getText('http.request-error'), " ").concat(status),
      description: "".concat(errorText, ", ").concat(url),
      duration: 0
    });
  } else if (!response) {
    // 请求初始化时出错或者没有响应返回的异常
    _antd.notification.error({
      message: _nsnUtil.NLocale.getText('http.network-error.title'),
      description: _nsnUtil.NLocale.getText('http.network-error.description'),
      duration: 0
    });
  }
};
/** 非 正常 业务响应处理 */


exports.httpErrorHandler = httpErrorHandler;

var nsnErrorHandler = function nsnErrorHandler(rs) {
  _antd.notification.destroy();

  var response = rs.response,
      data = rs.data;

  _antd.notification.error({
    message: _nsnUtil.NLocale.getMsg(data),
    description: "".concat(response.url, ". ").concat(data.errors ? "stack= ".concat(data.errors) : _nsnConst.NConst.EMPTY),
    duration: 0
  });
};
/** 自定义抛出异常 处理 */


var customErrorHandler = function customErrorHandler(e) {
  _antd.notification.error({
    message: e.name,
    description: "".concat(e.message, ". stack= ").concat(e.stack),
    duration: 0
  });
};
/** 请求头参数 */


var getHeaders = function getHeaders(url, ignoreToken) {
  var headers = {
    Accept: 'application/json'
  };
  headers[_nsnConst.NConst.HEADER_TOKEN] = _nsnUtil.NToken.get();

  if (ignoreToken === true) {
    headers[_nsnConst.NConst.HEADER_TOKEN] = getHashCode(url);
  }

  if (_nsnUtil.NUser.isMultiRoleMode()) {
    headers[_nsnConst.NConst.HEADER_ROLE_ID] = _nsnUtil.NStr.blankToEmpty(_nsnUtil.NUser.getRoleId());
  }

  if (_nsnUtil.NUser.isAdminSuper() && _nsnUtil.NUser.isMultiTenantMode()) {
    headers[_nsnConst.NConst.HEADER_TENANT_ID] = _nsnUtil.NStr.blankToEmpty(_nsnUtil.NUser.getTenantId());
  }

  return headers;
};
/** 配置request请求时的默认参数 */


var requestExtend = (0, _umiRequest.extend)({
  // 发送包含凭据的请求（即使是跨域源）
  credentials: 'include',
  // 获取response源，既返回blob，又返回response
  getResponse: true,
  // 统一错误处理
  errorHandler: httpErrorHandler
});
/** 全局中间件，添加请求前后处理 */

requestExtend.use( /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(ctx, next) {
    var req, url, options, headers, ignoreToken, token, res, rs, _rs$data, data, code, skipAlert, lang;

    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            req = ctx.req;
            url = req.url, options = req.options;
            headers = options.headers;
            ignoreToken = false;

            if (headers) {
              token = headers[_nsnConst.NConst.HEADER_TOKEN];

              if (_nsnUtil.NStr.isEqual(token, getHashCode(url))) {
                ignoreToken = true;
              }
            } // 若不忽略token检查


            if (ignoreToken) {
              _context.next = 8;
              break;
            }

            if (!(!_nsnUtil.NUrl.isIgnoreUrl(url) && _nsnUtil.NToken.isExpired())) {
              _context.next = 8;
              break;
            }

            return _context.abrupt("return");

          case 8:
            _context.next = 10;
            return next();

          case 10:
            // 请求后，返回前（在请求前获取 res 会导致请求失败）
            res = ctx.res;

            if (res) {
              rs = res;
              _rs$data = rs.data, data = _rs$data === void 0 ? {} : _rs$data;
              code = data.code; // 业务异常检查

              skipAlert = _nsnUtil.NStore.get(url);

              if (!_nsnUtil.NStr.isEqual(code, _nsnEnum.ResponseCode.SUCCESS)) {
                if (!skipAlert && !_nsnUtil.NUrl.isBlobUrl(url)) {
                  nsnErrorHandler(res);
                }

                if (_nsnUtil.NStr.isEqual(code, _nsnEnum.ResponseCode.EXPIRED)) {
                  // 清空 store
                  lang = _nsnUtil.NLocale.get();

                  _nsnUtil.NStore.clear();

                  if (lang) {
                    _nsnUtil.NLocale.set(lang);
                  }
                }
              }
            }

          case 12:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function (_x, _x2) {
    return _ref.apply(this, arguments);
  };
}(), {
  global: true
});
/** http请求。默认 GET 请求 */

var request = /*#__PURE__*/function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(params) {
    var ctx, uri, options, skipAlert, nonPrefix, ignoreToken, url, defaultData, resultData, headers, result, rs, data, response;
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            ctx = params.ctx, uri = params.uri, options = params.options, skipAlert = params.skipAlert, nonPrefix = params.nonPrefix, ignoreToken = params.ignoreToken;
            url = _nsnUtil.NUrl.getUrl(ctx, uri, nonPrefix);

            if (skipAlert) {
              _nsnUtil.NStore.set(_defineProperty({}, url, skipAlert));
            }

            defaultData = {
              code: _nsnEnum.ResponseCode.REQUEST_ERROR,
              errors: _nsnUtil.NLocale.getText('http.no-response')
            };
            resultData = Promise.resolve(defaultData); // 请求头 eg: {'Content-Type': 'multipart/form-data'}
            // FormData 封装的数据，浏览器自动会添加该文件头，不用自定义设置

            headers = getHeaders(url, ignoreToken);
            result = requestExtend(url, _objectSpread({
              headers: headers
            }, options));
            _context2.next = 9;
            return result;

          case 9:
            rs = _context2.sent;

            if (!rs) {
              _context2.next = 19;
              break;
            }

            data = rs.data, response = rs.response;

            if (!response) {
              _context2.next = 17;
              break;
            }

            if (!_nsnUtil.NUrl.isBlobUrl(url)) {
              _context2.next = 15;
              break;
            }

            return _context2.abrupt("return", response.blob().then(function (blob) {
              if (blob) {
                // 创建
                var objectURL = URL.createObjectURL(blob);
                var btn = document.createElement('a');
                btn.download = getFileNameFromHeader(response);
                btn.href = objectURL;
                btn.click(); // 释放

                URL.revokeObjectURL(objectURL);
                btn = null;
              }
            }));

          case 15:
            if (!(response.status === 204)) {
              _context2.next = 17;
              break;
            }

            return _context2.abrupt("return", response.text());

          case 17:
            if (!data || !response) {
              customErrorHandler(new Error(defaultData.errors));
            }

            return _context2.abrupt("return", data || resultData);

          case 19:
            return _context2.abrupt("return", resultData);

          case 20:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));

  return function request(_x3) {
    return _ref2.apply(this, arguments);
  };
}();

exports.request = request;