init

fuintUniapp/utils/request/core/request.js

@@ -0,0 +1,143 @@
+import {
+  mergeConfig,
+  dispatchRequest,
+  jsonpRequest
+} from "./utils"
+
+export default class request {
+
+  constructor(options) {
+    // 请求公共地址
+    this.baseUrl = options.baseUrl || "";
+    // 公共文件上传请求地址
+    this.fileUrl = options.fileUrl || "";
+    // 超时时间
+    this.timeout = options.timeout || 6000;
+    // 服务器上传图片默认url
+    this.defaultUploadUrl = options.defaultUploadUrl || "";
+    // 默认请求头
+    this.header = options.header || {};
+    // 默认配置
+    this.config = options.config || {
+      isPrompt: true,
+      load: true,
+      isFactory: true,
+      resend: 0
+    };
+  }
+
+  // post请求
+  post(url = '', data = {}, options = {}) {
+    return this.request({
+      method: "POST",
+      data: data,
+      url: url,
+      ...options
+    });
+  }
+
+  // get请求
+  get(url = '', data = {}, options = {}) {
+    return this.request({
+      method: "GET",
+      data: data,
+      url: url,
+      ...options
+    });
+  }
+
+  // put请求
+  put(url = '', data = {}, options = {}) {
+    return this.request({
+      method: "PUT",
+      data: data,
+      url: url,
+      ...options
+    });
+  }
+
+  // delete请求
+  delete(url = '', data = {}, options = {}) {
+    return this.request({
+      method: "DELETE",
+      data: data,
+      url: url,
+      ...options
+    });
+  }
+
+  // jsonp请求(只限于H5使用)
+  jsonp(url = '', data = {}, options = {}) {
+    return this.request({
+      method: "JSONP",
+      data: data,
+      url: url,
+      ...options
+    });
+  }
+
+  // 接口请求方法
+  async request(data) {
+    // 请求数据
+    let requestInfo,
+      // 是否运行过请求开始钩子
+      runRequestStart = false;
+    try {
+      if (!data.url) {
+        throw {
+          errMsg: "【request】缺失数据url",
+          statusCode: 0
+        }
+      }
+      // 数据合并
+      requestInfo = mergeConfig(this, data);
+      // 代表之前运行到这里
+      runRequestStart = true;
+      // 请求前回调
+      if (this.requestStart) {
+        let requestStart = this.requestStart(requestInfo);
+        if (typeof requestStart == "object") {
+          let changekeys = ["data", "header", "isPrompt", "load", "isFactory"];
+          changekeys.forEach(key => {
+            requestInfo[key] = requestStart[key];
+          });
+        } else {
+          throw {
+            errMsg: "【request】请求开始拦截器未通过",
+            statusCode: 0,
+            data: requestInfo.data,
+            method: requestInfo.method,
+            header: requestInfo.header,
+            url: requestInfo.url,
+          }
+        }
+      }
+      let requestResult = {};
+      if (requestInfo.method == "JSONP") {
+        requestResult = await jsonpRequest(requestInfo);
+      } else {
+        requestResult = await dispatchRequest(requestInfo);
+      }
+      // 是否用外部的数据处理方法
+      if (requestInfo.isFactory && this.dataFactory) {
+        // 数据处理
+        let result = await this.dataFactory({
+          ...requestInfo,
+          response: requestResult
+        });
+        return Promise.resolve(result);
+      } else {
+        return Promise.resolve(requestResult);
+      }
+    } catch (err) {
+      this.requestError && this.requestError(err);
+      return Promise.reject(err);
+    } finally {
+      // 如果请求开始未运行到，请求结束也不运行
+      if (runRequestStart) {
+        this.requestEnd && this.requestEnd(requestInfo);
+      }
+    }
+  }
+
+}

fuintUniapp/utils/request/core/utils.js

@@ -0,0 +1,102 @@
+// 获取合并的数据
+export const mergeConfig = (_this, options) => {
+  //判断url是不是链接
+  let urlType = /^(http|https):\/\//.test(options.url);
+  let config = Object.assign({
+    timeout: _this.timeout
+  }, _this.config, options);
+  if (options.method == "FILE") {
+    config.url = urlType ? options.url : _this.fileUrl + options.url;
+  } else {
+    config.url = urlType ? options.url : _this.baseUrl + options.url;
+  }
+  //请求头
+  if (options.header) {
+    config.header = Object.assign({}, _this.header, options.header);
+  } else {
+    config.header = Object.assign({}, _this.header);
+  }
+  return config;
+}
+
+// 请求
+export const dispatchRequest = (requestInfo) => {
+  return new Promise((resolve, reject) => {
+    let requestAbort = true;
+    let requestData = {
+      url: requestInfo.url,
+      header: requestInfo.header, //加入请求头
+      success: (res) => {
+        requestAbort = false;
+        resolve(res);
+      },
+      fail: (err) => {
+        requestAbort = false;
+        if (err.errMsg == "request:fail abort") {
+          reject({
+            errMsg: "请求超时，请重新尝试",
+            statusCode: 0,
+          });
+        } else {
+          reject(err);
+        }
+      }
+    };
+    //请求类型
+    if (requestInfo.method) {
+      requestData.method = requestInfo.method;
+    }
+    if (requestInfo.data) {
+      requestData.data = requestInfo.data;
+    }
+    // #ifdef MP-WEIXIN || MP-ALIPAY
+    if (requestInfo.timeout) {
+      requestData.timeout = requestInfo.timeout;
+    }
+    // #endif
+    if (requestInfo.dataType) {
+      requestData.dataType = requestInfo.dataType;
+    }
+    // #ifndef APP-PLUS || MP-ALIPAY
+    if (requestInfo.responseType) {
+      requestData.responseType = requestInfo.responseType;
+    }
+    // #endif
+    // #ifdef H5
+    if (requestInfo.withCredentials) {
+      requestData.withCredentials = requestInfo.withCredentials;
+    }
+    // #endif
+    let requestTask = uni.request(requestData);
+    setTimeout(() => {
+      if (requestAbort) {
+        requestTask.abort();
+      }
+    }, requestInfo.timeout)
+  })
+}
+// jsonp请求
+export const jsonpRequest = (requestInfo) => {
+  return new Promise((resolve, reject) => {
+    let dataStr = '';
+    Object.keys(requestInfo.data).forEach(key => {
+      dataStr += key + '=' + requestInfo.data[key] + '&';
+    });
+    //匹配最后一个&并去除
+    if (dataStr !== '') {
+      dataStr = dataStr.substr(0, dataStr.lastIndexOf('&'));
+    }
+    requestInfo.url = requestInfo.url + '?' + dataStr;
+    let callbackName = "callback" + Math.ceil(Math.random() * 1000000);
+    // #ifdef H5
+    window[callbackName] = (data) => {
+      resolve(data);
+    }
+    let script = document.createElement("script");
+    script.src = requestInfo.url + "&callback=" + callbackName;
+    document.head.appendChild(script);
+    // 及时删除，防止加载过多的JS
+    document.head.removeChild(script);
+    // #endif
+  });
+}

fuintUniapp/utils/request/index.js

@@ -0,0 +1,205 @@
+/**
+ * request插件地址：https://ext.dcloud.net.cn/plugin?id=822
+ */
+import store from '@/store'
+import request from './request'
+import config from '@/config'
+import { isWechat } from '../app';
+
+// 后端api地址
+const baseURL = config.apiUrl;
+const merchantNo = config.merchantNo;
+
+// 可以new多个request来支持多个域名请求
+const $http = new request({
+  // 接口请求地址
+  baseUrl: baseURL,
+  // 服务器本地上传文件地址
+  fileUrl: baseURL,
+  // 服务器上传图片默认url
+  defaultUploadUrl: 'clientApi/file/upload',
+  // 设置请求头（如果使用报错跨域问题，可能是content-type请求类型和后台那边设置的不一致）
+  header: {
+    'content-type': 'application/json;charset=utf-8'
+  },
+  // 请求超时时间, 单位ms（默认300000）
+  timeout: 300000,
+  // 默认配置（可不写）
+  config: {
+    // 是否自动提示错误
+    isPrompt: true,
+    // 是否显示加载动画
+    load: true,
+    // 是否使用数据工厂
+    isFactory: true
+  }
+})
+
+// 当前接口请求数
+let requestNum = 0
+// 请求开始拦截器
+$http.requestStart = options => {
+  if (options.load) {
+    if (requestNum <= 0) {
+      // 打开加载动画
+      uni.showLoading({
+        title: '加载中',
+        mask: true
+      })
+    }
+    requestNum += 1
+  }
+  // 图片上传大小限制
+  if (options.method == "FILE" && options.maxSize) {
+    // 文件最大字节: options.maxSize 可以在调用方法的时候加入参数
+    const maxSize = options.maxSize
+    for (let item of options.files) {
+      if (item.size > maxSize) {
+        setTimeout(() => {
+          uni.showToast({
+            title: "图片过大，请重新上传",
+            icon: "none"
+          })
+        }, 10)
+        return false
+      }
+    }
+  }
+  // 请求前加入当前终端
+  options.header['platform'] = store.getters.platform ? String(store.getters.platform) : ''
+  
+  // 请求前加入Token
+  options.header['Access-Token'] = store.getters.token ? String(store.getters.token) : ''
+  // 商户号
+  options.header['merchantNo'] = uni.getStorageSync("merchantNo") ? uni.getStorageSync("merchantNo") : merchantNo; 
+  // 店铺ID
+  options.header['storeId'] = uni.getStorageSync("storeId") ? uni.getStorageSync("storeId") : 0;
+  options.header['latitude'] = uni.getStorageSync("latitude") ? uni.getStorageSync("latitude") : '';
+  options.header['longitude'] = uni.getStorageSync("longitude") ? uni.getStorageSync("longitude") : '';
+  options.header['isWechat'] = isWechat() ? 'Y' : 'N';
+  // return false 表示请求拦截，不会继续请求
+  return options
+}
+
+// 请求结束
+$http.requestEnd = options => {
+  // 判断当前接口是否需要加载动画
+  if (options.load) {
+    requestNum = requestNum - 1
+    if (requestNum <= 0) {
+      uni.hideLoading()
+    }
+  }
+}
+
+// 登录弹窗次数
+let loginPopupNum = 0
+
+// 所有接口数据处理（可在接口里设置不调用此方法）
+// 此方法需要开发者根据各自的接口返回类型修改，以下只是模板
+$http.dataFactory = async res => {
+  // console.log("接口请求数据", {
+  //   url: res.url,
+  //   resolve: res.response,
+  //   header: res.header,
+  //   data: res.data,
+  //   method: res.method,
+  // })
+
+  if (!res.response.statusCode || res.response.statusCode != 200) {
+    // 返回错误的结果(catch接受数据)
+    return Promise.reject({
+      statusCode: res.response.statusCode,
+      // errMsg: "数据工厂验证不通过"
+      errMsg: 'http状态码错误'
+    })
+  }
+
+  let httpData = res.response.data
+  if (typeof httpData == "string") {
+    try {
+      httpData = JSON.parse(httpData)
+    } catch {
+      httpData = false
+    }
+  }
+  if (httpData === false || typeof httpData !== 'object') {
+    // 返回错误的结果(catch接受数据)
+    return Promise.reject({
+      statusCode: res.response.statusCode,
+      errMsg: "返回数据验证不通过"
+    })
+  }
+
+  /*********以下只是模板(及共参考)，需要开发者根据各自的接口返回类型修改*********/
+  // 判断数据是否请求成功
+  // result.code [ 200正常 5000有错误 1001未登录 4003没有权限访问 ]
+  // 判断是否需要登录
+  if (httpData.code == 1001) {
+    // 1001也有可能是后端登录态到期, 所以要清空本地的登录状态
+    store.dispatch('Logout')
+    // 弹窗告诉用户去登录
+    if (loginPopupNum <= 0) {
+      loginPopupNum++
+      uni.showModal({
+        title: '温馨提示',
+        content: '此时此刻需要您登录喔~',
+        confirmText: "去登录",
+        cancelText: "再逛会",
+        success: res => {
+          loginPopupNum--
+          if (res.confirm) {
+            uni.navigateTo({
+              url: "/pages/login/index"
+            })
+          }
+        }
+      })
+    }
+    // 返回错误的结果(catch接受数据)
+    return Promise.reject({
+      statusCode: 0,
+      errMsg: httpData.message,
+      result: httpData
+    })
+  }
+  // 其他错误提示
+  else if (httpData.status == 5000) {
+    if (res.isPrompt) {
+      setTimeout(() => {
+        uni.showToast({
+          title: httpData.message,
+          icon: "none",
+          duration: 2500
+        }, 10)
+      })
+    }
+    // 返回错误的结果(catch接受数据)
+    return Promise.reject({
+      statusCode: 0,
+      errMsg: httpData.message,
+      result: httpData
+    })
+  } else {
+    // 返回正确的结果(then接受数据)
+    return Promise.resolve(httpData)
+  }
+
+  /*********以上只是模板(及共参考)，需要开发者根据各自的接口返回类型修改*********/
+}
+
+// 错误回调
+$http.requestError = e => {
+  if (e.statusCode === 0) {
+    throw e
+  } else {
+    setTimeout(() => {
+      uni.showToast({
+        title: `网络请求出错：${e.errMsg}`,
+        icon: "none",
+        duration: 2500
+      })
+    })
+  }
+}
+export default $http

fuintUniapp/utils/request/request.js

@@ -0,0 +1,7 @@
+/***************纯粹的数据请求（如果使用这种可以删除掉fileUpload.js）******************/
+// import request from "./core/request.js";
+// export default request;
+
+/********数据请求同时继承了文件上传（包括七牛云上传）************/
+import upload from "./upload/upload"
+export default upload

fuintUniapp/utils/request/request.md

@@ -0,0 +1,453 @@
+# request请求、配置简单、批量上传图片、视频、超强适应性（支持多域名请求）
+1. 配置简单、源码清晰注释多、适用于一项目多域名请求、第三方请求、七牛云图片上传、本地服务器图片上传等等
+2. 支持请求`get`、`post`、`put`、`delete`
+3. 自动显示请求加载动画（可单个接口关闭）
+4. 全局`api`数据处理函数，只回调请求正确的数据（可单个接口关闭）
+5. 未登录或登录失效自动拦截并调用登录方法（可单个接口关闭）
+6. 全局自动提示接口抛出的错误信息（可单个接口关闭）
+7. 支持 Promise
+8. 支持拦截器
+9. 支持七牛云文件（图片、视频）批量上传
+10. 支持本地服务器文件（图片、视频）批量上传
+11. 支持上传文件拦截过滤
+12. 支持上传文件进度监听
+13. 支持上传文件单张成功回调
+
+| `QQ交流群(607391225)`         | `微信交流群（加我好友备注"进群"）`                  |
+| ----------------------------|--------------------------- |
+|![QQ交流群](http://qn.kemean.cn//upload/202004/14/15868301778472k7oubi6.png)|![微信交流群](https://qn.kemean.cn/upload/202010/13/weiXin_group_code.jpg)|
+| QQ群号：607391225 |微信号：zhou0612wei|
+
+### [点击跳转-插件示例](https://ext.dcloud.net.cn/plugin?id=2009)
+### [点击跳转-5年的web前端开源的uni-app快速开发模板-下载看文档](https://ext.dcloud.net.cn/plugin?id=2009)
+
+### 常见问题
+1.接口请求成功了，没有返回数据或者数据是走的catch回调
+
+答：`requestConfig.js` 请求配置文件里面，有一个`$http.dataFactory`方法，里面写的只是参考示例，`此方法需要开发者根据各自的接口返回类型修改`
+
+2.官方的方法有数据，本插件方法请求报错跨域问题
+
+答：`requestConfig.js` 请求配置文件里面，`header`请求头设置的`content-type`请求类型需求和后台保持一致
+
+3.登录后用户`token`怎么设置？
+
+答：`requestConfig.js` 请求配置文件里面，`$http.requestStart`请求开始拦截器里面设置
+
+4.怎么判断上传的文件（图片）太大？怎么过滤掉太大的文件（图片）？
+
+答：`requestConfig.js` 请求配置文件里面，`$http.requestStart`请求开始拦截器里面设置
+
+5.接口请求成功了，一直提示“网络错误，请检查一下网络”？
+
+答：`requestConfig.js` 请求配置文件里面，有一个`$http.dataFactory`方法，里面写的只是参考示例，`此方法需要开发者根据各自的接口返回类型修改`
+
+### 本次更新注意事项
+1. 所有的headers都改成了header（和官方统一）
+2. 七牛云的获取token等信息提取到了`requestConfig.js`文件，参考如下
+
+```
+// 添加获取七牛云token的方法
+$http.getQnToken = function(callback){
+    //该地址需要开发者自行配置（每个后台的接口风格都不一样）
+    $http.get("api/kemean/aid/qn_upload").then(data => {
+        /*
+         *接口返回参数：
+         *visitPrefix:访问文件的域名
+         *token:七牛云上传token
+         *folderPath:上传的文件夹
+         *region: 地区 默认为：SCN
+         */
+        callback({
+            visitPrefix: data.visitPrefix,
+            token: data.token,
+            folderPath: data.folderPath,
+            region: "SCN"
+        });
+    });
+}
+```
+
+### 文件说明
+1. `request => core` 请求方法的目录
+2. `request => core => request.js` 请求方法的class文件
+3. `request => core => utils.js` 请求方法的源码文件
+4. `request => upload` 上传方法的目录
+5. `request => upload => upload.js` 上传方法的class文件
+6. `request => upload => utils.js` 上传方法源码文件
+7. `request => upload => qiniuUploader.js` 七牛云官方上传文件
+8. `request => index.js` 输出方法的文件
+9. `requestConfig.js` 请求配置文件（具体看代码）
+
+### 在main.js引入并挂在Vue上
+```
+import $http from '@/zhouWei-request/requestConfig';
+Vue.prototype.$http = $http;
+```
+
+### `requestConfig.js`配置说明（requestConfig.js有配置示例）
+```
+import request from "@/plugins/request";
+//可以new多个request来支持多个域名请求
+let $http = new request({
+    //接口请求地址
+    baseUrl: "https://twin-ui.com/", //示例域名，请自行设计
+    //服务器本地上传文件地址
+    fileUrl: "https://twin-ui.com/", //示例域名，请自行设计
+    // 服务器上传图片默认url
+    defaultUploadUrl: "clientApi/file/upload",
+    //设置请求头（如果使用报错跨域问题，可能是content-type请求类型和后台那边设置的不一致）
+    header: {
+        'Content-Type': 'application/json;charset=UTF-8'
+    },
+    // 请求超时时间（默认6000）
+    timeout: 6000,
+    // 默认配置（可不写）
+    config: {
+        // 是否自动提示错误
+        isPrompt: true,
+        // 是否显示加载动画
+        load: true,
+        // 是否使用数据工厂
+        isFactory: true,
+       // ... 可写更多配置
+    }
+});
+
+//当前接口请求数
+let requestNum = 0;
+//请求开始拦截器
+$http.requestStart = function(options) {
+    if (options.load) {
+        if (requestNum <= 0) {
+            //打开加载动画
+            uni.showLoading({
+                title: '加载中',
+                mask: true
+            });
+        }
+        requestNum += 1;
+    }
+    // 图片上传大小限制
+    if (options.method == "FILE" && options.maxSize) {
+        // 文件最大字节: options.maxSize 可以在调用方法的时候加入参数
+        let maxSize = options.maxSize;
+        for (let item of options.files) {
+            if (item.size > maxSize) {
+                setTimeout(() => {
+                    uni.showToast({
+                        title: "图片过大，请重新上传",
+                        icon: "none"
+                    });
+                }, 500);
+                return false;
+            }
+        }
+    }
+    //请求前加入token
+    options.header['token'] = "你的项目登录token";
+    return options; // return false 表示请求拦截，不会继续请求
+}
+//请求结束
+$http.requestEnd = function(options) {
+    //判断当前接口是否需要加载动画
+    if (options.load) {
+        requestNum = requestNum - 1;
+        if (requestNum <= 0) {
+            uni.hideLoading();
+        }
+    }
+}
+//所有接口数据处理（可在接口里设置不调用此方法）
+//此方法需要开发者根据各自的接口返回类型修改，以下只是模板
+$http.dataFactory = async function(res) {
+    console.log("接口请求数据", {
+        url: res.url,
+        resolve: res.response,
+        header: res.header,
+        data: res.data,
+        method: res.method,
+    });
+    if (res.response.statusCode && res.response.statusCode == 200) {
+        let httpData = res.response.data;
+        if (typeof (httpData) == "string") {
+            httpData = JSON.parse(httpData);
+        }
+        //判断数据是否请求成功
+        if (httpData.success || httpData.code == 200) {
+            // ---------重点----------返回正确的结果(then接受数据)------------重点------------
+            return Promise.resolve(httpData.data);
+        } else {
+            //其他错误提示
+            if (res.isPrompt) { // 是否提示
+                uni.showToast({
+                    title: httpData.info || httpData.msg,
+                    icon: "none",
+                    duration: 3000
+                });
+            }
+            // --------重点---------返回错误的结果(catch接受数据)------------重点------------
+            return Promise.reject({
+                statusCode: 0,
+                errMsg: "【request】" + (httpData.info || httpData.msg)
+            });
+        }
+    } else {
+        // 返回错误的结果(catch接受数据)
+        return Promise.reject({
+            statusCode: res.response.statusCode,
+            errMsg: "【request】数据工厂验证不通过"
+        });
+    }
+};
+// 错误回调
+$http.requestError = function (e) {
+    if (e.statusCode === 0) {
+        throw e;
+    } else {
+        uni.showToast({
+            title: "网络错误，请检查一下网络",
+            icon: "none"
+        });
+    }
+}
+```
+
+### 通用请求方法
+```
+this.$http.request({
+    url: 'aid/region',
+    method: "GET", // POST、GET、PUT、DELETE、JSONP，具体说明查看官方文档
+    data: {pid:0},
+    timeout: 30000,  // 默认 30000 说明：超时时间，单位 ms，具体说明查看官方文档
+    dataType: "json",  // 默认 json 说明：如果设为 json，会尝试对返回的数据做一次 JSON.parse，具体说明查看官方文档
+    responseType: "text",  // 默认 text 说明：设置响应的数据类型。合法值：text、arraybuffer，具体说明查看官方文档
+    withCredentials: false,  // 默认 false 说明：跨域请求时是否携带凭证（cookies），具体说明查看官方文档
+    isPrompt: true,//（默认 true 说明：本接口抛出的错误是否提示）
+    load: true,//（默认 true 说明：本接口是否提示加载动画）
+    header: { //默认 无 说明：请求头
+        'Content-Type': 'application/json'
+    },
+    isFactory: true, //（默认 true 说明：本接口是否调用公共的数据处理方法，设置false后isPrompt参数将失去作用）
+}).then(function (response) {
+    //这里只会在接口是成功状态返回
+}).catch(function (error) {
+    //这里只会在接口是失败状态返回，不需要去处理错误提示
+    console.log(error);
+});
+```
+
+### get请求 正常写法 
+```
+this.$http.get('aid/region',{pid:0}).
+then(function (response) {
+    //这里只会在接口是成功状态返回
+}).catch(function (error) {
+    //这里只会在接口是失败状态返回，不需要去处理错误提示
+    console.log(error);
+});
+```
+
+### post请求 async写法 
+```
+async request(){
+    let data = await this.$http.post('aid/region',{pid:0});
+    console.log(data);
+}
+```
+
+### 其他功能配置项
+```
+let data = await this.$http.post(
+    'http://www.aaa.com/aid/region', //可以直接放链接(将不启用全局定义域名)
+    {
+        pid:0
+    }, 
+    {
+        isPrompt: true,//（默认 true 说明：本接口抛出的错误是否提示）
+        load: true,//（默认 true 说明：本接口是否提示加载动画）
+        header: { //默认 无 说明：请求头
+            'Content-Type': 'application/json'
+        },
+        isFactory: true //（默认 true 说明：本接口是否调用公共的数据处理方法，设置false后isPrompt参数将失去作用）
+    }
+);
+```
+
+### `requestConfig.js`可以设置服务器上传图片默认url
+```
+//可以new多个request来支持多个域名请求
+let $http = new request({
+    //服务器本地上传文件地址
+    fileUrl: base.baseUrl,
+    // 服务器上传图片默认url
+    defaultUploadUrl: "api/common/v1/upload_image",
+});
+```
+```
+// 上传可以不用传递url（使用全局的上传图片url）
+this.$http.urlImgUpload({
+    name:"后台接受文件key名称", //默认 file
+    count:"最大选择数",//默认 9
+    sizeType:"选择压缩图原图，默认两个都选",//默认 ['original', 'compressed']
+    sourceType:"选择相机拍照或相册上传 默认两个都选",//默认 ['album','camera']
+    data:"而外参数" //可不填,
+});
+// 上传可以不用传递url（使用全局的上传图片url）
+this.$http.urlVideoUpload({
+    sourceType:"选择相机拍照或相册上传 默认两个都选",//默认 ['album','camera']
+    compressed:"是否压缩所选的视频源文件，默认值为 true，需要压缩",//默认 false
+    maxDuration: "拍摄视频最长拍摄时间，单位秒。最长支持 60 秒", //默认 60
+    camera: '前置还是后置摄像头', //'front'、'back'，默认'back'
+    name:"后台接受文件key名称", //默认 file
+    data:"而外参数" //可不填,
+});
+// 上传可以不用传递url（使用全局的上传图片url）
+this.$http.urlFileUpload({
+    files: [], // 必填 临时文件路径 格式: [{path: "图片地址"}]
+    data:"向服务器传递的参数", //可不填
+    name:"后台接受文件key名称", //默认 file
+});
+```
+
+### 本地服务器图片上传（支持多张上传）
+```
+this.$http.urlImgUpload('flie/upload',{
+    name:"后台接受文件key名称", //默认 file
+    count:"最大选择数",//默认 9
+    sizeType:"选择压缩图原图，默认两个都选",//默认 ['original', 'compressed']
+    sourceType:"选择相机拍照或相册上传 默认两个都选",//默认 ['album','camera']
+    data:"而外参数" //可不填,
+    isPrompt: true,//（默认 true 说明：本接口抛出的错误是否提示）
+    load: true,//（默认 true 说明：本接口是否提示加载动画）
+    header: { //默认 无 说明：请求头
+        'Content-Type': 'application/json'
+    },
+    isFactory: true, //（默认 true 说明：本接口是否调用公共的数据处理方法，设置false后isPrompt参数奖失去作用）
+    maxSize: 300000, //（默认 无 说明：上传的文件最大字节数限制，默认不限制）
+    onSelectComplete: res => {
+        console.log("选择完成返回：",res);
+    },
+    onEachUpdate: res => {
+        console.log("单张上传成功返回：",res);
+    },
+    onProgressUpdate: res => {
+        console.log("上传进度返回：",res);
+    }
+}).then(res => {
+    console.log("全部上传完返回结果：",res);
+});
+```
+### 本地服务器视频上传
+```
+this.$http.urlVideoUpload('flie/upload',{
+    sourceType:"选择相机拍照或相册上传 默认两个都选",//默认 ['album','camera']
+    compressed:"是否压缩所选的视频源文件，默认值为 true，需要压缩",//默认 false
+    maxDuration: "拍摄视频最长拍摄时间，单位秒。最长支持 60 秒", //默认 60
+    camera: '前置还是后置摄像头', //'front'、'back'，默认'back'
+    name:"后台接受文件key名称", //默认 file
+    data:"而外参数" //可不填,
+    isPrompt: true,//（默认 true 说明：本接口抛出的错误是否提示）
+    load: true,//（默认 true 说明：本接口是否提示加载动画）
+    header: { //默认 无 说明：请求头
+        'Content-Type': 'application/json'
+    },
+    isFactory: true, //（默认 true 说明：本接口是否调用公共的数据处理方法，设置false后isPrompt参数奖失去作用）
+    maxSize: 300000, //（默认 无 说明：上传的文件最大字节数限制，默认不限制）
+    onProgressUpdate: res => {
+        console.log("上传进度返回：",res);
+    },
+    onSelectComplete: res => {
+        console.log("选择完成返回：",res);
+    },
+}).then(res => {
+    console.log("全部上传完返回结果：",res);
+});
+```
+### 本地服务器文件上传（支持多张上传）
+```
+this.$http.urlFileUpload("flie/upload",{
+    files: [], // 必填 临时文件路径 格式: [{path: "图片地址"}]
+    data:"向服务器传递的参数", //可不填
+    name:"后台接受文件key名称", //默认 file
+    isPrompt: true,//（默认 true 说明：本接口抛出的错误是否提示）
+    load: true,//（默认 true 说明：本接口是否提示加载动画）
+    header: { //默认 无 说明：请求头
+        'Content-Type': 'application/json'
+    },
+    isFactory: true, //（默认 true 说明：本接口是否调用公共的数据处理方法，设置false后isPrompt参数奖失去作用）
+    maxSize: 300000, //（默认 无 说明：上传的文件最大字节数限制，默认不限制）
+    onEachUpdate: res => {
+        console.log("单张上传成功返回：",res);
+    },
+    onProgressUpdate: res => {
+        console.log("上传进度返回：",res);
+    }
+}).then(res => {
+    console.log("全部上传完返回结果：",res);
+});
+```
+
+### 七牛云图片上传（支持多张上传）
+```
+this.$http.qnImgUpload({
+    count:"最大选择数", // 默认 9
+    sizeType:"选择压缩图原图，默认两个都选", // 默认 ['original', 'compressed']
+    sourceType:"选择相机拍照或相册上传 默认两个都选", // 默认 ['album','camera']
+    load: true, //（默认 true 说明：本接口是否提示加载动画）
+    maxSize: 300000, //（默认 无 说明：上传的文件最大字节数限制，默认不限制）
+    onSelectComplete: res => {
+        console.log("选择完成返回：",res);
+    },
+    onEachUpdate: res => {
+        console.log("单张上传成功返回：",res);
+    },
+    onProgressUpdate: res => {
+        console.log("上传进度返回：",res);
+    }
+}).then(res => {
+    console.log("全部上传完返回结果：",res);
+});
+```
+### 七牛云视频上传
+```
+this.$http.qnVideoUpload({
+    sourceType:"选择相机拍照或相册上传 默认两个都选",//默认 ['album','camera']
+    compressed:"是否压缩所选的视频源文件，默认值为 true，需要压缩",//默认 false
+    maxDuration: "拍摄视频最长拍摄时间，单位秒。最长支持 60 秒", //默认 60
+    camera: '前置还是后置摄像头', //'front'、'back'，默认'back'
+    load: true,//（默认 true 说明：本接口是否提示加载动画）
+    maxSize: 300000, //（默认 无 说明：上传的文件最大字节数限制，默认不限制）
+    onSelectComplete: res => {
+        console.log("选择完成返回：",res);
+    },
+    onProgressUpdate: res => {
+        console.log("上传进度返回：",res);
+    }
+}).then(res => {
+    console.log("全部上传完返回结果：",res);
+});
+```
+### 七牛云文件上传（支持多张上传）
+```
+this.$http.qnFileUpload(
+{
+    files:[], // 必填 临时文件路径 格式: [{path: "图片地址"}]
+    load: true, //（默认 true 说明：本接口是否提示加载动画）
+    maxSize: 300000, //（默认 无 说明：上传的文件最大字节数限制，默认不限制）
+    onEachUpdate: res => {
+        console.log("单张上传成功返回：",res);
+    },
+    onProgressUpdate: res => {
+        console.log("上传进度返回：",res);
+    }
+}).then(res => {
+    console.log("全部上传完返回结果：",res);
+});
+```
+### jsonp 跨域请求（只支持H5）
+```
+let data = await this.$http.jsonp('http://www.aaa.com/aid/region',{pid:0}, {
+    isFactory: false, //（默认 true 说明：本接口是否调用公共的数据处理方法，设置false后isPrompt参数奖失去作用）
+});
+```

fuintUniapp/utils/request/upload/qiniuUploader.js

@@ -0,0 +1,169 @@
+// created by gpake
+(function () {
+
+  var config = {
+    qiniuRegion: '',
+    qiniuImageURLPrefix: '',
+    qiniuUploadToken: '',
+    qiniuUploadTokenURL: '',
+    qiniuUploadTokenFunction: null,
+    qiniuShouldUseQiniuFileName: false
+  }
+
+  module.exports = {
+    init: init,
+    upload: upload,
+  }
+
+  // 在整个程序生命周期中，只需要 init 一次即可
+  // 如果需要变更参数，再调用 init 即可
+  function init(options) {
+    config = {
+      qiniuRegion: '',
+      qiniuImageURLPrefix: '',
+      qiniuUploadToken: '',
+      qiniuUploadTokenURL: '',
+      qiniuUploadTokenFunction: null,
+      qiniuShouldUseQiniuFileName: false
+    };
+    updateConfigWithOptions(options);
+  }
+
+  function updateConfigWithOptions(options) {
+    if (options.region) {
+      config.qiniuRegion = options.region;
+    } else {
+      console.error('qiniu uploader need your bucket region');
+    }
+    if (options.uptoken) {
+      config.qiniuUploadToken = options.uptoken;
+    } else if (options.uptokenURL) {
+      config.qiniuUploadTokenURL = options.uptokenURL;
+    } else if (options.uptokenFunc) {
+      config.qiniuUploadTokenFunction = options.uptokenFunc;
+    }
+    if (options.domain) {
+      config.qiniuImageURLPrefix = options.domain;
+    }
+    config.qiniuShouldUseQiniuFileName = options.shouldUseQiniuFileName
+  }
+
+  function upload(filePath, success, fail, options, progress, cancelTask) {
+    if (null == filePath) {
+      console.error('qiniu uploader need filePath to upload');
+      return;
+    }
+    if (options) {
+      updateConfigWithOptions(options);
+    }
+    if (config.qiniuUploadToken) {
+      doUpload(filePath, success, fail, options, progress, cancelTask);
+    } else if (config.qiniuUploadTokenURL) {
+      getQiniuToken(function () {
+        doUpload(filePath, success, fail, options, progress, cancelTask);
+      });
+    } else if (config.qiniuUploadTokenFunction) {
+      config.qiniuUploadToken = config.qiniuUploadTokenFunction();
+      if (null == config.qiniuUploadToken && config.qiniuUploadToken.length > 0) {
+        console.error('qiniu UploadTokenFunction result is null, please check the return value');
+        return
+      }
+      doUpload(filePath, success, fail, options, progress, cancelTask);
+    } else {
+      console.error('qiniu uploader need one of [uptoken, uptokenURL, uptokenFunc]');
+      return;
+    }
+  }
+
+  function doUpload(filePath, success, fail, options, progress, cancelTask) {
+    if (null == config.qiniuUploadToken && config.qiniuUploadToken.length > 0) {
+      console.error('qiniu UploadToken is null, please check the init config or networking');
+      return
+    }
+    var url = uploadURLFromRegionCode(config.qiniuRegion);
+    var fileName = filePath.split('//')[1];
+    if (options && options.key) {
+      fileName = options.key;
+    }
+    var formData = {
+      'token': config.qiniuUploadToken
+    };
+    if (!config.qiniuShouldUseQiniuFileName) {
+      formData['key'] = fileName
+    }
+    var uploadTask = wx.uploadFile({
+      url: url,
+      filePath: filePath,
+      name: 'file',
+      formData: formData,
+      success: function (res) {
+        var dataString = res.data
+        if (res.data.hasOwnProperty('type') && res.data.type === 'Buffer') {
+          dataString = String.fromCharCode.apply(null, res.data.data)
+        }
+        try {
+          var dataObject = JSON.parse(dataString);
+          //do something
+          var imageUrl = config.qiniuImageURLPrefix + '/' + dataObject.key;
+          dataObject.imageURL = imageUrl;
+          if (success) {
+            success(dataObject);
+          }
+        } catch (e) {
+          console.log('parse JSON failed, origin String is: ' + dataString)
+          if (fail) {
+            fail(e);
+          }
+        }
+      },
+      fail: function (error) {
+        console.error(error);
+        if (fail) {
+          fail(error);
+        }
+      }
+    })
+
+    uploadTask.onProgressUpdate((res) => {
+      progress && progress(res)
+    })
+
+    cancelTask && cancelTask(() => {
+      uploadTask.abort()
+    })
+  }
+
+  function getQiniuToken(callback) {
+    wx.request({
+      url: config.qiniuUploadTokenURL,
+      success: function (res) {
+        var token = res.data.uptoken;
+        if (token && token.length > 0) {
+          config.qiniuUploadToken = token;
+          if (callback) {
+            callback();
+          }
+        } else {
+          console.error('qiniuUploader cannot get your token, please check the uptokenURL or server')
+        }
+      },
+      fail: function (error) {
+        console.error('qiniu UploadToken is null, please check the init config or networking: ' + error);
+      }
+    })
+  }
+
+  function uploadURLFromRegionCode(code) {
+    var uploadURL = null;
+    switch (code) {
+      case 'ECN': uploadURL = 'https://up.qbox.me'; break;
+      case 'NCN': uploadURL = 'https://up-z1.qbox.me'; break;
+      case 'SCN': uploadURL = 'https://up-z2.qbox.me'; break;
+      case 'NA': uploadURL = 'https://up-na0.qbox.me'; break;
+      case 'ASG': uploadURL = 'https://up-as0.qbox.me'; break;
+      default: console.error('please make the region is with one of [ECN, SCN, NCN, NA, ASG]');
+    }
+    return uploadURL;
+  }
+
+})();

fuintUniapp/utils/request/upload/upload.js

@@ -0,0 +1,208 @@
+import request from "./../core/request.js";
+const {
+    chooseImage,
+    chooseVideo,
+    qiniuUpload,
+    urlUpload
+} = require("./utils");
+import {
+    mergeConfig
+} from "./../core/utils.js";
+export default class fileUpload extends request {
+    constructor(props) {
+        // 调用实现父类的构造函数
+        super(props);
+    }
+    //七牛云上传图片
+    async qnImgUpload(options = {}) {
+        let files;
+        try {
+            files = await chooseImage(options);
+            // 选择完成回调
+            options.onSelectComplete && options.onSelectComplete(files);
+        } catch (err) {
+            this.requestError && this.requestError(err);
+            return Promise.reject(err);
+        }
+        if (files) {
+            return this.qnFileUpload({
+                ...options,
+                files: files
+            });
+        }
+    }
+    //七牛云上传视频
+    async qnVideoUpload(options = {}) {
+        let files;
+        try {
+            files = await chooseVideo(options);
+            // 选择完成回调
+            options.onSelectComplete && options.onSelectComplete(files);
+        } catch (err) {
+            this.requestError && this.requestError(err);
+            return Promise.reject(err);
+        }
+        if (files) {
+            return this.qnFileUpload({
+                ...options,
+                files: files
+            });
+        }
+    }
+
+    //七牛云文件上传（支持多张上传）
+    async qnFileUpload(options = {}) {
+        let requestInfo;
+        try {
+            // 数据合并
+            requestInfo = {
+                ...this.config,
+                ...options,
+                header: {},
+                method: "FILE"
+            };
+            //请求前回调
+            if (this.requestStart) {
+                let requestStart = this.requestStart(requestInfo);
+                if (typeof requestStart == "object") {
+                    let changekeys = ["load", "files"];
+                    changekeys.forEach(key => {
+                        requestInfo[key] = requestStart[key];
+                    });
+                } else {
+                    throw {
+                        errMsg: "【request】请求开始拦截器未通过",
+                        statusCode: 0,
+                        data: requestInfo.data,
+                        method: requestInfo.method,
+                        header: requestInfo.header,
+                        url: requestInfo.url,
+                    }
+                }
+            }
+            let requestResult = await qiniuUpload(requestInfo, this.getQnToken);
+            return Promise.resolve(requestResult);
+        } catch (err) {
+            this.requestError && this.requestError(err);
+            return Promise.reject(err);
+        } finally {
+            this.requestEnd && this.requestEnd(requestInfo);
+        }
+    }
+    //本地服务器图片上传
+    async urlImgUpload() {
+        let options = {};
+        if (arguments[0]) {
+            if (typeof(arguments[0]) == "string") {
+                options.url = arguments[0];
+            } else if (typeof(arguments[0]) == "object") {
+                options = Object.assign(options, arguments[0]);
+            }
+        }
+        if (arguments[1] && typeof(arguments[1]) == "object") {
+            options = Object.assign(options, arguments[1]);
+        }
+        try {
+            options.files = await chooseImage(options);
+            // 选择完成回调
+            options.onSelectComplete && options.onSelectComplete(options.files);
+        } catch (err) {
+            this.requestError && this.requestError(err);
+            return Promise.reject(err);
+        }
+        if (options.files) {
+            return this.urlFileUpload(options);
+        }
+    }
+    //本地服务器上传视频
+    async urlVideoUpload() {
+        let options = {};
+        if (arguments[0]) {
+            if (typeof(arguments[0]) == "string") {
+                options.url = arguments[0];
+            } else if (typeof(arguments[0]) == "object") {
+                options = Object.assign(options, arguments[0]);
+            }
+        }
+        if (arguments[1] && typeof(arguments[1]) == "object") {
+            options = Object.assign(options, arguments[1]);
+        }
+        try {
+            options.files = await chooseVideo(options);
+            // 选择完成回调
+            options.onSelectComplete && options.onSelectComplete(options.files);
+        } catch (err) {
+            this.requestError && this.requestError(err);
+            return Promise.reject(err);
+        }
+        if (options.files) {
+            return this.urlFileUpload(options);
+        }
+    }
+    //本地服务器文件上传方法
+    async urlFileUpload() {
+        let requestInfo = {
+            method: "FILE"
+        };
+        if (arguments[0]) {
+            if (typeof(arguments[0]) == "string") {
+                requestInfo.url = arguments[0];
+            } else if (typeof(arguments[0]) == "object") {
+                requestInfo = Object.assign(requestInfo, arguments[0]);
+            }
+        }
+        if (arguments[1] && typeof(arguments[1]) == "object") {
+            requestInfo = Object.assign(requestInfo, arguments[1]);
+        }
+        if (!requestInfo.url && this.defaultUploadUrl) {
+            requestInfo.url = this.defaultUploadUrl;
+        }
+        // 请求数据
+        // 是否运行过请求开始钩子
+        let runRequestStart = false;
+        try {
+            if (!requestInfo.url) {
+                throw {
+                    errMsg: "【request】文件上传缺失数据url",
+                    statusCode: 0,
+                    data: requestInfo.data,
+                    method: requestInfo.method,
+                    header: requestInfo.header,
+                    url: requestInfo.url,
+                }
+            }
+            // 数据合并
+            requestInfo = mergeConfig(this, requestInfo);
+            // 代表之前运行到这里
+            runRequestStart = true;
+            //请求前回调
+            if (this.requestStart) {
+                let requestStart = this.requestStart(requestInfo);
+                if (typeof requestStart == "object") {
+                    let changekeys = ["data", "header", "isPrompt", "load", "isFactory", "files"];
+                    changekeys.forEach(key => {
+                        requestInfo[key] = requestStart[key];
+                    });
+                } else {
+                    throw {
+                        errMsg: "【request】请求开始拦截器未通过",
+                        statusCode: 0,
+                        data: requestInfo.data,
+                        method: requestInfo.method,
+                        header: requestInfo.header,
+                        url: requestInfo.url,
+                    }
+                }
+            }
+            let requestResult = await urlUpload(requestInfo, this.dataFactory);
+            return Promise.resolve(requestResult);
+        } catch (err) {
+            this.requestError && this.requestError(err);
+            return Promise.reject(err);
+        } finally {
+            if (runRequestStart) {
+                this.requestEnd && this.requestEnd(requestInfo);
+            }
+        }
+    }
+}

fuintUniapp/utils/request/upload/utils.js

@@ -0,0 +1,288 @@
+const qiniuUploader = require("./qiniuUploader");
+//七牛云上传文件命名
+export const randomChar = function(l, url = "") {
+    const x = "0123456789qwertyuioplkjhgfdsazxcvbnm";
+    let tmp = "";
+    let time = new Date();
+    for (let i = 0; i < l; i++) {
+        tmp += x.charAt(Math.ceil(Math.random() * 100000000) % x.length);
+    }
+    return (
+        "file/" +
+        url +
+        time.getTime() +
+        tmp
+    );
+}
+//图片选择
+export const chooseImage = function(data) {
+    return new Promise((resolve, reject) => {
+        uni.chooseImage({
+            count: data.count || 9, //默认9
+            sizeType: data.sizeType || ['original', 'compressed'], //可以指定是原图还是压缩图，默认二者都有
+            sourceType: data.sourceType || ['album', 'camera'], //从相册选择
+            success: function(res) {
+                resolve(res.tempFiles);
+            },
+            fail: err => {
+                reject({
+                    errMsg: err.errMsg, 
+                    errCode: err.errCode, 
+                    statusCode: 0,
+                });
+            }
+        });
+    });
+}
+//视频选择
+export const chooseVideo = function(data) {
+    return new Promise((resolve, reject) => {
+        uni.chooseVideo({
+            sourceType: data.sourceType || ['album', 'camera'], //从相册选择
+            compressed: data.compressed || false, //是否压缩所选的视频源文件，默认值为 true，需要压缩。
+            maxDuration: data.maxDuration || 60, //拍摄视频最长拍摄时间，单位秒。最长支持 60 秒。
+            camera: data.camera || 'back', //'front'、'back'，默认'back'
+            success: function(res) {
+                let files = [{
+                    path: res.tempFilePath
+                }];
+                // #ifdef APP-PLUS || H5 || MP-WEIXIN
+                files[0].duration = res.duration;
+                files[0].size = res.size;
+                files[0].height = res.height;
+                files[0].width = res.width;
+                // #endif
+                // #ifdef H5
+                files[0].name = res.name;
+                // #endif
+                resolve(files);
+            },
+            fail: err => {
+                reject({
+                    errMsg: err.errMsg, 
+                    errCode: err.errCode, 
+                    statusCode: 0,
+                });
+            }
+        });
+    });
+}
+// 七牛云上传
+export const qiniuUpload = function(requestInfo, getQnToken) {
+    return new Promise((resolve, reject) => {
+        if (Array.isArray(requestInfo.files)) {
+            let len = requestInfo.files.length;
+            let fileList = new Array;
+            if (getQnToken) {
+                getQnToken(qnRes => {
+                    /*
+                     *接口返回参数：
+                     *visitPrefix:访问文件的域名
+                     *token:七牛云上传token
+                     *folderPath:上传的文件夹
+                     *region: 地区 默认为：SCN
+                     */
+                    let prefixLen = qnRes.visitPrefix.length;
+                    if(qnRes.visitPrefix.charAt(prefixLen - 1) == '/'){
+                        qnRes.visitPrefix = qnRes.visitPrefix.substring(0, prefixLen - 1)
+                    }
+                    uploadFile(0);
+
+                    function uploadFile(i) {
+                        let item = requestInfo.files[i];
+                        let updateUrl = randomChar(10, qnRes.folderPath);
+                        let fileData = {
+                            fileIndex: i,
+                            files: requestInfo.files,
+                            ...item
+                        };
+                        if (item.name) {
+                            fileData.name = item.name;
+                            let nameArr = item.name.split(".");
+                            updateUrl += "." + nameArr[nameArr.length - 1];
+                        }
+                        // 交给七牛上传
+                        qiniuUploader.upload(item.path || item, (res) => {
+                            fileData.url = res.imageURL;
+                            requestInfo.onEachUpdate && requestInfo.onEachUpdate({
+                                url: res.imageURL,
+                                ...fileData
+                            });
+                            fileList.push(res.imageURL);
+                            if (len - 1 > i) {
+                                uploadFile(i + 1);
+                            } else {
+                                resolve(fileList);
+                            }
+                        }, (error) => {
+                            reject(error);
+                        }, {
+                            region: qnRes.region || 'SCN', //地区
+                            domain: qnRes.visitPrefix, // bucket 域名，下载资源时用到。
+                            key: updateUrl,
+                            uptoken: qnRes.token, // 由其他程序生成七牛 uptoken
+                            uptokenURL: 'UpTokenURL.com/uptoken' // 上传地址
+                        }, (res) => {
+                            console.log(requestInfo);
+                            requestInfo.onProgressUpdate && requestInfo.onProgressUpdate(Object.assign({}, fileData, res));
+                            // console.log('上传进度', res.progress)
+                            // console.log('已经上传的数据长度', res.totalBytesSent)
+                            // console.log('预期需要上传的数据总长度', res.totalBytesExpectedToSend)
+                        });
+                    }
+                });
+            } else {
+                reject({
+                    errMsg: "请添加七牛云回调方法：getQnToken",
+                    statusCode: 0
+                });
+            }
+        } else {
+            reject({
+                errMsg: "files 必须是数组类型",
+                statusCode: 0
+            });
+        };
+    });
+}
+// 服务器URL上传
+export const urlUpload = function(requestInfo, dataFactory) {
+    return new Promise((resolve, reject) => {
+        // 本地文件上传去掉默认Content-Type
+        if (requestInfo.header['Content-Type']) {
+            delete requestInfo.header['Content-Type'];
+        }
+        // 本地文件上传去掉默认Content-Type
+        if (requestInfo.header['content-type']) {
+            delete requestInfo.header['content-type'];
+        }
+        if (Array.isArray(requestInfo.files)) {
+            // // #ifdef APP-PLUS || H5
+            // let files = [];
+            // let fileData = {
+            //     files: requestInfo.files,
+            //     name: requestInfo.name || "file"
+            // };
+            // requestInfo.files.forEach(item => {
+   //              let fileInfo = {
+   //                  name: requestInfo.name || "file",
+   //              };
+   //              if(item.path){
+   //                  fileInfo.uri = item.path;
+   //              } else {
+   //                  fileInfo.file = item;
+   //              }
+            //     files.push(fileInfo);
+            // });
+            // let config = {
+            //     url: requestInfo.url,
+            //     files: files,
+            //     header: requestInfo.header, //加入请求头
+            //     success: (response) => {
+            //         //是否用外部的数据处理方法
+            //         if (requestInfo.isFactory && dataFactory) {
+            //             //数据处理
+            //             dataFactory({
+            //                 ...requestInfo,
+            //                 response: response,
+            //             }).then(data => {
+            //                 requestInfo.onEachUpdate && requestInfo.onEachUpdate({
+            //                     data: data,
+            //                     ...fileData
+            //                 });
+            //                 resolve(data);
+            //             },err => {
+            //                 reject(err);
+            //             });
+            //         } else {
+            //             requestInfo.onEachUpdate && requestInfo.onEachUpdate({
+            //                 data: response,
+            //                 ...fileData
+            //             });
+            //             resolve(response);
+            //         }
+            //     },
+            //     fail: (err) => {
+            //         reject(err);
+            //     }
+            // };
+            // if (requestInfo.data) {
+            //     config.formData = requestInfo.data;
+            // }
+            // const uploadTask = uni.uploadFile(config);
+            // uploadTask.onProgressUpdate(res => {
+            //     requestInfo.onProgressUpdate && requestInfo.onProgressUpdate(Object.assign({}, fileData, res));
+            // });
+            // // #endif
+            // #-ifdef MP
+            const len = requestInfo.files.length - 1;
+            let fileList = new Array;
+            fileUpload(0);
+
+            function fileUpload(i) {
+                let item = requestInfo.files[i];
+                let fileData = {
+                    fileIndex: i,
+                    files: requestInfo.files,
+                    ...item
+                };
+                let config = {
+                    url: requestInfo.url,
+                    filePath: item.path,
+                    header: requestInfo.header, //加入请求头
+                    name: requestInfo.name || "file",
+                    success: (response) => {
+                        //是否用外部的数据处理方法
+                        if (requestInfo.isFactory && dataFactory) {
+                            //数据处理
+                            dataFactory({
+                                ...requestInfo,
+                                response: response,
+                            }).then(data => {
+                                fileList.push(data);
+                                requestInfo.onEachUpdate && requestInfo.onEachUpdate({
+                                    data: data,
+                                    ...fileData
+                                });
+                                if (len <= i) {
+                                    resolve(fileList);
+                                } else {
+                                    fileUpload(i + 1);
+                                }
+                            },err => {
+                                reject(err);
+                            });
+                        } else {
+                            requestInfo.onEachUpdate && requestInfo.onEachUpdate({
+                                data: response,
+                                ...fileData
+                            });
+                            fileList.push(response);
+                            if (len <= i) {
+                                resolve(fileList);
+                            } else {
+                                fileUpload(i + 1);
+                            }
+                        }
+                    },
+                    fail: (err) => {
+                        reject(err);
+                    }
+                };
+                if (requestInfo.data) {
+                    config.formData = requestInfo.data;
+                }
+                const uploadTask = uni.uploadFile(config);
+                uploadTask.onProgressUpdate(res => {
+                    requestInfo.onProgressUpdate && requestInfo.onProgressUpdate(Object.assign({}, fileData, res));
+                });
+            }
+            // #-endif
+        } else {
+            reject({
+                errMsg: "files 必须是数组类型",
+                statusCode: 0
+            });
+        }
+    });
+}