sunmao-sdk/src/net/request.js

榫卯-开箱即用赋能-sdk

import lodash, { isString } from "lodash";
import { CP } from "..";
import qs from "qs";
import { message } from "antd";
import * as commonUtils from "../utils/commonUtils";
import { isSkipLog, redirectUrl } from "./api";

const codeMessage = {
  200: "请求成功,但数据异常！",
  201: "新建或修改数据成功。",
  202: "一个请求已经进入后台排队（异步任务）。",
  204: "删除数据成功。",
  400: "发出的请求有错误，服务器没有进行新建或修改数据的操作。",
  401: "用户没有权限（令牌、用户名、密码错误）。",
  403: "用户得到授权，但是访问是被禁止的。",
  404: "发出的请求针对的是不存在的记录，服务器没有进行操作。",
  406: "请求的格式不可得。",
  410: "请求的资源被永久删除，且不会再得到的。",
  422: "当创建一个对象时，发生一个验证错误。",
  500: "服务器发生错误，请检查服务器。",
  502: "网关错误。",
  503: "服务不可用，服务器暂时过载或维护。",
  504: "网关超时。"
};
const getMsgInfo = obj => {
  if (!obj) return "";
  for (let key in obj) {
    if (
      key.includes("Msg") ||
      key.includes("msg") ||
      key.includes("Message") ||
      key.includes("message")
    ) {
      return obj[key];
    }
  }
  return;
};
const getDataInfo = obj => {
  if (!obj) return true;
  return obj.data || obj.model || obj.result || obj.module;
};
/**
 * 异常处理程序
 */
const errorHandler = async (error, resType, okPath, json = true) => {
  // 兼容精确索引
  if (!json && okPath && lodash.get(error, okPath)) {
    const ret = {};
    // 最外层数据 兼容处理
    const root = okPath.split(".")[0];
    ret[root] = lodash.get(error, root);
    ret.data = ret[root];
    // 精确数据
    ret.exactData = lodash.get(error, okPath);
    return { ...error, ...ret };
  }
  const { ok, status, statusText, ...other } = error;
  const statusMsg = statusText || getMsgInfo(other);
  const data = getDataInfo(other);
  // 符合平台返回 res 数据结构 status & ok
  if ((status === 200 && ok) || lodash.get(error, CP.getCPInfo().postOk)) {
    if (json) {
      const res = await error.json();
      return errorHandler(res, resType, okPath, false);
    }
    if (resType) {
      const dataType = Object.prototype.toString.call(data);
      if (resType !== dataType) {
        console.error(`服务端返回结构为${dataType},与目标${resType}不匹配！`);
        return {
          sdkErrorMsg: `服务端返回结构为${dataType},与目标${resType}不匹配！`
        };
      }
    }
    statusMsg && isString(statusMsg) && message.info(statusMsg);
    return { ...other, data };
  }
  return { sdkErrorMsg: statusMsg || codeMessage[status] || "数据异常！" };
};

/**
 * @param {接口信息} url
 * @param {传参信息} params
 * @param {请求头信息} props
 * @param {接受结构} resType 用于业务逻辑，返回数据结构不匹配则为业务异常链路；传值推荐：'[object Object]'、'[object Array]'
 */
const postNew = async (
  url,
  params = {},
  okPath = undefined,
  props = {},
  resType = false,
  loading
) => {
  params = getCommonParams(params);
  const res = await request(
    url,
    {
      method: "POST",
      mode: "cors",
      body: JSON.stringify(params),
      headers: {
        "content-type": "application/json;charset=utf-8"
      },
      ...props
    },
    resType,
    okPath,
    loading
  );
  return res;
};

const getCommonParams = (params = {}) => {
  // // 网关转发处理
  // if (commonUtils.isObj(params.params)) {
  //   if (!(params.params.projectId && params.params.appId)) {
  //     // 配置至cookie或许更合
  //     !params.params.projectId &&
  //       (params.params.projectId = CP?.info?.projectId);
  //     !params.params.appId && (params.params.appId = CP?.info?.appId);
  //     params.params.deleteSunmaoParams = true;
  //   }
  //   params.params.user = CP?.info?.user; // 配置至cookie或许更合
  //   params.params.env = CP?.info?.env;
  // } else {
  //   if (!(params.projectId && params.appId)) {
  //     // 配置至cookie或许更合
  //     !params.projectId && (params.projectId = CP?.info?.projectId);
  //     !params.appId && (params.appId = CP?.info?.appId);
  //     params.deleteSunmaoParams = true;
  //   }
  //   params.user = CP?.info?.user; // 配置至cookie或许更合适
  //   params.env = CP?.info?.env;
  // }
  // 网关转发处理
  if (commonUtils.isObj(params.params)) {
    if (!params.params.sunmao_Params) {
      params.params.sunmao_Params = CP.getSunmaoParams();
    }
  } else {
    if (!params.sunmao_Params) {
      params.sunmao_Params = CP.getSunmaoParams();
    }
  }
  return params;
};
const urlGetParams = (url, params = {}) => {
  params = getCommonParams(params);
  url +=
    (url.indexOf("?") > -1 ? "&" : "?") +
    Object.keys(params)
      .map(key => {
        const value = params[key]?.toString();
        if (!value) {
          return `${key}`;
        } else if (key === "sunmao_Params") {
          return Object.keys(params.sunmao_Params)
            .map(key => {
              const value = params.sunmao_Params[key]?.toString();
              if (!value) {
                return `sunmao_Params_${key}`;
              } else {
                return `sunmao_Params_${key}=${encodeURIComponent(value)}`;
              }
            })
            .join("&");
        } else {
          return `${key}=${encodeURIComponent(value)}`;
        }
      })
      .join("&");
  return url;
};

/**
 * @param {接口信息} url
 * @param {传参信息} params
 * @param {请求头信息} props
 * @param {接受结构} resType 用于业务逻辑，返回数据结构不匹配则为业务异常链路
 * @param {string} okPath 自定义返回成功路径
 */
const getNew = async (
  url,
  params = {},
  okPath = undefined,
  props = {},
  resType = false
) => {
  url = urlGetParams(url, params);
  const res = await request(
    url,
    {
      method: "GET",
      mode: "cors",
      ...props
    },
    resType,
    okPath
  );
  return res;
};

const request = async (url, data, resType, okPath, loading) =>
  new Promise(async (resolve, reject) => {
    if (!CP.getSunmaoParams().appId) {
      console.error("未配置应用的appId,通过CP.init进行配置！");
      reject("未配置应用的appId,通过CP.init进行配置！");
    }
    let req = false;
    try {
      commonUtils.log("-----request-----:", data, url);
      req = await fetch(url, data);
      commonUtils.log("--response--first--:", req, url);
      req = await errorHandler(req, resType, okPath);
      commonUtils.log("--response--handler--:", req, url);
      try {
        if (loading) loading.destroy();
      } catch {}
      if (req.sdkErrorMsg) {
        throw new Error(req.sdkErrorMsg);
      } else {
        // 兼容处理
        resolve(
          !okPath || "data" === okPath ? { data: req.data, ...req.data } : req
        );
      }
    } catch (e) {
      try {
        if (loading) loading.destroy();
      } catch {}
      if (isSkipLog(url)) {
        CP.error(`${e?.message || e?.msg || "请求失败！"}`);
      } else {
        commonUtils.log(url, `${e?.message || e?.msg || "请求失败！"}`);
      }
      reject();
    }
  });

// 获取字典信息
const getDicDetails = (
  url,
  params = {},
  okPath = undefined,
  props = {},
  resType = false
) => {
  return postNew(
    redirectUrl,
    {
      url: urlGetParams(url, params),
      method: "GET",
      type: "http"
    },
    okPath,
    props,
    resType
  );
};

/**
 * 应用级 统一处理请求入参函数
 * @param {入参} params
 * @param {入参过滤函数} filter
 */
const handleAppParams = (params, filter) => {
  // 先分隔“，” 入参，
  // 再去除空 入参
  const _params = commonUtils.filterParams(
    commonUtils.splitParams({
      ...CP.getCPInfo().extParams, // 应用扩展入参 数据 ； 可被覆盖 ； 注意避开关键字段
      ...params
    })
  );
  try {
    // 自定义过滤函数
    return filter ? filter(_params) : _params;
  } catch {
    return _params;
  }
};

export { getNew, postNew, urlGetParams, getDicDetails, handleAppParams };