@sinosun/lib/lib/NetApi/BaseApi.js

sinosun jsbridge and net toolkit

"use strict";
/**
 * @author miaoju
 * !!! 里面部分方法需要子类api继承实现, @abstract 为可选重写，@virtual 为子类必须要重写实现的 !!!
 * 客户端请求api基础类
 * 1、网络检查
 * 2、用户信息header拼装
 * 3、提供doGet、doPost接口
 * 4、对于服务器返回结果resultCode，进行通用的错误码处理，具体的业务错误码在子类里面按业务处理
 */

var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");

var _promise = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/promise"));

var _symbol = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/symbol"));

var _iterator = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/symbol/iterator"));

var _defineProperty = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/define-property"));

var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));

var _parseInt2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/parse-int"));

var _startsWith = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/starts-with"));

var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function (resolve) {
      resolve(value);
    });
  }

  return new (P || (P = _promise["default"]))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }

    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }

    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }

    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};

var __generator = void 0 && (void 0).__generator || function (thisArg, body) {
  var _ = {
    label: 0,
    sent: function sent() {
      if (t[0] & 1) throw t[1];
      return t[1];
    },
    trys: [],
    ops: []
  },
      f,
      y,
      t,
      g;
  return g = {
    next: verb(0),
    "throw": verb(1),
    "return": verb(2)
  }, typeof _symbol["default"] === "function" && (g[_iterator["default"]] = function () {
    return this;
  }), g;

  function verb(n) {
    return function (v) {
      return step([n, v]);
    };
  }

  function step(op) {
    if (f) throw new TypeError("Generator is already executing.");

    while (_) {
      try {
        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
        if (y = 0, t) op = [op[0] & 2, t.value];

        switch (op[0]) {
          case 0:
          case 1:
            t = op;
            break;

          case 4:
            _.label++;
            return {
              value: op[1],
              done: false
            };

          case 5:
            _.label++;
            y = op[1];
            op = [0];
            continue;

          case 7:
            op = _.ops.pop();

            _.trys.pop();

            continue;

          default:
            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
              _ = 0;
              continue;
            }

            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
              _.label = op[1];
              break;
            }

            if (op[0] === 6 && _.label < t[1]) {
              _.label = t[1];
              t = op;
              break;
            }

            if (t && _.label < t[2]) {
              _.label = t[2];

              _.ops.push(op);

              break;
            }

            if (t[2]) _.ops.pop();

            _.trys.pop();

            continue;
        }

        op = body.call(thisArg, _);
      } catch (e) {
        op = [6, e];
        y = 0;
      } finally {
        f = t = 0;
      }
    }

    if (op[0] & 5) throw op[1];
    return {
      value: op[0] ? op[1] : void 0,
      done: true
    };
  }
};

var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
  return mod && mod.__esModule ? mod : {
    "default": mod
  };
};

(0, _defineProperty["default"])(exports, "__esModule", {
  value: true
});

var NetAdapter_1 = __importDefault(require("./NetAdapter"));

var BaseResponse_1 = __importDefault(require("./BaseResponse"));

var CommErrorCode_1 = require("./CommErrorCode");

var REQUEST_METHOD = {
  "GET": "get",
  "POST": "post"
};
/**
 * 是否空字符串
 * @param obj
 */

function isEmptyStr(obj) {
  if (typeof obj === "undefined" || obj === null || obj === "") {
    return true;
  } else {
    return false;
  }
}

var BaseApi =
/** @class */
function () {
  function BaseApi() {}
  /**
   * get请求
   * @param {*} url 请求相对地址，可以不要域名、端口
   * @param {*} params
   * @param {*} needLogin
   */


  BaseApi.prototype.doGet = function (url, params, needLogin, timeout) {
    if (needLogin === void 0) {
      needLogin = true;
    }

    if (timeout === void 0) {
      timeout = 30000;
    }

    return this.doRequest(url, params, REQUEST_METHOD.GET, needLogin, timeout);
  };
  /**
   * post 请求
   * @param {*} url  请求相对地址，可以不要域名、端口
   * @param {*} params
   * @param {*} needLogin
   */


  BaseApi.prototype.doPost = function (url, params, needLogin, timeout) {
    if (needLogin === void 0) {
      needLogin = true;
    }

    if (timeout === void 0) {
      timeout = 30000;
    }

    return this.doRequest(url, params, REQUEST_METHOD.POST, needLogin, timeout);
  };
  /**
   * 发送请求
   * @param {*} url  请求相对地址，可以不要域名、端口
   * @param {*} params
   * @param {*} header
   * @param {*} method
   */


  BaseApi.prototype.doRequest = function (url, params, method, needLogin, timeout) {
    var _this = this;

    if (needLogin === void 0) {
      needLogin = true;
    }

    if (timeout === void 0) {
      timeout = 30000;
    } // 把url、params放在response里面带回给界面调用处，可能会有用处


    var reqToResponse = {
      url: url,
      reqParams: params
    };
    return new _promise["default"](function (res, rej) {
      // 不管网络层返回的正常还是异常，在这里统一转换成 {@link BaseResponse} 对象抛给上层处理
      _this.checkNetWork().then(function (data) {
        // serviceName
        if (data && data["contectState"]) {
          return;
        } else {
          throw new Error("" + CommErrorCode_1.CommErrorCode.NETWORK_ERROR);
        }
      }).then(function (res) {
        return __awaiter(_this, void 0, void 0, function () {
          var header;
          return __generator(this, function (_a) {
            switch (_a.label) {
              case 0:
                return [4
                /*yield*/
                , this.dealRequestHeader(needLogin, url, params)];

              case 1:
                header = _a.sent();
                return [4
                /*yield*/
                , this.dealRequestParams(params, url, needLogin)];

              case 2:
                // 封装请求参数
                params = _a.sent(); // 发起请求

                return [2
                /*return*/
                , NetAdapter_1["default"].doRequest(url, params, header, method, timeout)];
            }
          });
        });
      }).then(function (result) {
        // 网络请求成功
        result.request = reqToResponse;

        var baseResponse = _this.dealResponse(result);

        res(baseResponse);
      })["catch"](function (error) {
        // error : { code, message, httpCode, responseMessage}
        // 网络请求失败
        var result = error;

        if (error) {
          // error 可能出现 undefined 的情况（如函数执行中出错了）
          result = (0, _assign["default"])(error, reqToResponse);
        }

        var baseResponse = _this.dealRequestException(result);

        rej(baseResponse);
      });
    });
  };
  /**
   * 检查网络状态，默认不检查直接返回true，业务可根据需要重写
   * @returns
   */


  BaseApi.prototype.checkNetWork = function () {
    return new _promise["default"](function (res, rej) {
      res({
        contectState: true
      });
    });
  };
  /**
   * 封装网络请求header，默认返回空对象，业务可根据需要填入token、channelId等信息
   * @param needLogin
   * @param url
   * @param params
   * @returns
   */


  BaseApi.prototype.dealRequestHeader = function (needLogin, // token: any,
  // channelId: any,
  url, params) {
    if (needLogin === void 0) {
      needLogin = true;
    }

    return __awaiter(this, void 0, void 0, function () {
      return __generator(this, function (_a) {
        return [2
        /*return*/
        , {}];
      });
    });
  };
  /**
   * 封装网络请求参数，默认直接返回params对象，业务可根据需要填入用户信息等参数
   * @param params
   * @param url
   * @param needLogin
   * @returns
   */


  BaseApi.prototype.dealRequestParams = function (params, url, needLogin) {
    return __awaiter(this, void 0, void 0, function () {
      return __generator(this, function (_a) {
        return [2
        /*return*/
        , params];
      });
    });
  };
  /**
   * 处理服务器返回结果,只处理通用的业务错误码
   * @param result
   */


  BaseApi.prototype.dealResponse = function (result) {
    var bRes = new BaseResponse_1["default"](result.resultCode, // resultCode 基础接口协议的异常码
    '', result.resultMessage // resultMessage 基础接口协议的异常描述
    ); // 如果业务不成功，在这里进行一次通用错误码转换

    bRes.request = result["request"];

    if (!bRes.isSuccess()) {
      bRes.resultMessage = result.resultMessage;
      bRes.resultDesc = this.transferErrorCode(bRes.resultCode, bRes.resultMessage, bRes.resultDesc); // 后端返回错误依然需要返回结果数据方便前端根据错误展示

      bRes.result = result["result"];
    } // 业务成功， 把result数据结果放进去
    else {
        bRes.result = this.tranferResultModel(result);
      }

    return bRes;
  };
  /**
   * 把网络层的错误信息也转换成BaseResponse，然后抛给上层
   * @param error
   */


  BaseApi.prototype.dealRequestException = function (error) {
    // TODO 根据error来设置errorCode，以及 resultDesc
    var errorCode = 0;
    var errorMessage = '';

    if (!error) {
      // error 为 undefined 或其他不明情况
      errorCode = CommErrorCode_1.CommErrorCode.UNKNOWN_ERROR;
    } else {
      errorCode = error.code || CommErrorCode_1.CommErrorCode.UNKNOWN_ERROR;
      errorMessage = error.message || error.responseMessage || "";
    }

    var errRes = new BaseResponse_1["default"](errorCode); // 把异常信息通过 error字段带到上层去

    errRes = (0, _assign["default"])(errRes, {
      error: error
    });
    errRes.resultDesc = this.transferErrorCode(errRes.resultCode, errorMessage, "");
    console.log("dealRequestException - e : ", errRes);
    return errRes;
  };
  /**
   * BaseApi这一层只处理跟网络、用户授权等相关的最基础错误码转换，具体的业务错误码在子类的api里面去转换
   * @param resultCode
   * @abstract 子类可重写
   */


  BaseApi.prototype.transferCommErrorCode = function (resultCode, resultMessage, resultDesc) {
    // 只返回通用异常错误码信息，其他的code返回“”，由业务自己处理
    // 如果是mPaaS 网关异常，把mPaaS错误信息直接拿出来:
    if ((0, _parseInt2["default"])(resultCode) == CommErrorCode_1.CommErrorCode.MPAAS_RPC_ERROR && resultMessage) {
      return resultMessage;
    }

    return CommErrorCode_1.CommErrorCodeDesc[resultCode] || "";
  };
  /**
   * 处理业务错误码
   * @virtual BaseApi中这是一个抽象方法，由子类具体的业务api去实现自己的业务错误码
   * @param resultCode
   */


  BaseApi.prototype.transferBisErrorCode = function (resultCode) {
    return "";
  }; // ---------- 错误码处理 start ---------------------------------------------------------------------//


  BaseApi.prototype.transferErrorCode = function (resultCode, resultMessage, resultDesc // url: string
  ) {
    // 1、先处理通用错误码，如果返回空，可能是业务错误码，进入 2
    var msg = this.transferCommErrorCode(resultCode, resultMessage, resultDesc); // 2、处理业务错误码(如果通用错误码没有匹配到，则调用业务错误码转换)

    if (isEmptyStr(msg)) {
      // transferBisErrorCode 业务子类应该要重写该方法来转换业务自己的错误码信息
      msg = this.transferBisErrorCode(resultCode);
    } // 3、通用、业务错误码都没有查询到，就给默认异常提示


    if (isEmptyStr(msg)) {
      msg = this.transferDefaultExceptionDesc() + '[' + resultCode + ']';
    } // 提示异常信息
    // this.showMessage(url, msg);


    return msg;
  };
  /**
   * @abstract 提示异常信息，业务api内部可重写决定
   * @param url
   * @param msg
   */


  BaseApi.prototype.showMessage = function (url, msg) {// if (msg) showToast(msg);
  };
  /**
   * 返回默认的错误提示
   * @abstract 子类Api可以重写, 如果通用、业务错误码都没找到，就用这个
   */


  BaseApi.prototype.transferDefaultExceptionDesc = function () {
    return "请求异常，请稍后重试!";
  };
  /**
   * 转换成本地业务api的model
   * @virtual 具体的转换在子类继承去处理，这里默认只是把result对象塞进去
   * !!! 原则是只要response含有业务数据对象，就应该进行本地model映射 !!!
   */


  BaseApi.prototype.tranferResultModel = function (result) {
    return result["result"];
  };
  /**
   * 转换成完整路径URL
   * @param url
   */


  BaseApi.prototype.getFullUrl = function (url) {
    if (!((0, _startsWith["default"])(url).call(url, "https://") || (0, _startsWith["default"])(url).call(url, "http://"))) {
      url = location.origin + ((0, _startsWith["default"])(url).call(url, "/") ? "" : "/") + url;
    }

    return url;
  };

  return BaseApi;
}();

exports["default"] = BaseApi;