菜品管理--改为上传至七牛云，在新增或者修改传网络地址

 //logs.js
 //logs.js
 var util = require('../../utils/util.js')
 var util = require('../../utils/util.js')
 var uri=require('../../utils/uri.js')
 var uri=require('../../utils/uri.js')
+import App from '../../utils/api.js'
 
 
 Page({
 Page({
     data: {
     data: {
@@ -15,7 +16,8 @@ Page({
         price:'',
         price:'',
         member_price:'',
         member_price:'',
         status:1,
         status:1,
-        moresetting:true
+        moresetting:true,
+        token: '',
     },
     },
     onLoad:function(opt){
     onLoad:function(opt){
         var that=this;
         var that=this;
@@ -46,7 +48,13 @@ Page({
         }
         }
         console.log(this.data.id)
         console.log(this.data.id)
         this.switchstatus=this.selectComponent('#switch');
         this.switchstatus=this.selectComponent('#switch');
-
+        // 获取七牛云token
+        App.Qiniu.GetUploadToken().then(res => {
+            let token = res.data.token
+            this.setData({
+                token
+            })
+        })
     },
     },
     onShow:function(){
     onShow:function(){
         if(util.cache('spec')){
         if(util.cache('spec')){
@@ -432,34 +440,19 @@ Page({
             var that=this;
             var that=this;
             if(this.data.tempimage){
             if(this.data.tempimage){
                 var that=this;
                 var that=this;
-                wx.uploadFile({
-                        url: "https://xt03.colorcun.com/?s=App.Goods.UploadImg",
-                        filePath: this.data.tempimage,
-                        name: "file",
-                        header: {
-                            'content-type': 'multipart/form-data'
-                        }, // 设置请求的 header
-                        success: function (res) {
-                            console.log(res)
-                            if(res.statusCode==200){
-                                var img=JSON.parse(res.data).data[0]
-                                console.log(img)
-                                that.setData({
-                                    image:img
-                                })
-                                formdata['image']=img
-                                //有id，为修改；若无，为添加
-                                if(that.data.id){
-                                    that.changeFood(formdata)
-                                }else{
-                                    that.addFood(formdata)
-                                }
-                            }
-                        },
-                    fail: function (res){
-                        console.log(res);
+                util.uploadFile(this.data.tempimage, this.data.token, 'flyDuckDish').then(res => {
+                    console.log(res);
+                    that.setData({
+                        image:res
+                    })
+                    formdata['image']=res
+                    //有id，为修改；若无，为添加
+                    if(that.data.id){
+                        that.changeFood(formdata)
+                    }else{
+                        that.addFood(formdata)
                     }
                     }
-                });
+                })
             }else{
             }else{
                 if(that.data.id){
                 if(that.data.id){
                     that.changeFood(formdata)
                     that.changeFood(formdata)

@@ -139,6 +139,9 @@ export default {
    'App.Seller.BatchAddUser':null,
    'App.Seller.BatchAddUser':null,
    
    
    //获取添加员工二维码
    //获取添加员工二维码
-   'App.Seller.CreatebatchQrcode':null
+   'App.Seller.CreatebatchQrcode':null,
+
+   //获取七牛上传token信息
+   'App.Qiniu.GetUploadToken':null,
    
    
 }
 }

+;
+(function (root, factory) {
+	if (typeof exports === "object") {
+		// CommonJS
+		module.exports = exports = factory();
+	} else if (typeof define === "function" && define.amd) {
+		// AMD
+		define([], factory);
+	} else {
+		// Global (browser)
+		root.CryptoJS = factory();
+	}
+}(this, function () {
+
+	/**
+	 * CryptoJS core components.
+	 */
+	var CryptoJS = CryptoJS || (function (Math, undefined) {
+		/*
+		 * Local polyfil of Object.create
+		 */
+		var create = Object.create || (function () {
+			function F() {};
+
+			return function (obj) {
+				var subtype;
+
+				F.prototype = obj;
+
+				subtype = new F();
+
+				F.prototype = null;
+
+				return subtype;
+			};
+		}())
+
+		/**
+		 * CryptoJS namespace.
+		 */
+		var C = {};
+
+		/**
+		 * Library namespace.
+		 */
+		var C_lib = C.lib = {};
+
+		/**
+		 * Base object for prototypal inheritance.
+		 */
+		var Base = C_lib.Base = (function () {
+
+
+			return {
+				/**
+				 * Creates a new object that inherits from this object.
+				 *
+				 * @param {Object} overrides Properties to copy into the new object.
+				 *
+				 * @return {Object} The new object.
+				 *
+				 * @static
+				 *
+				 * @example
+				 *
+				 *     var MyType = CryptoJS.lib.Base.extend({
+				 *         field: 'value',
+				 *
+				 *         method: function () {
+				 *         }
+				 *     });
+				 */
+				extend: function (overrides) {
+					// Spawn
+					var subtype = create(this);
+
+					// Augment
+					if (overrides) {
+						subtype.mixIn(overrides);
+					}
+
+					// Create default initializer
+					if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
+						subtype.init = function () {
+							subtype.$super.init.apply(this, arguments);
+						};
+					}
+
+					// Initializer's prototype is the subtype object
+					subtype.init.prototype = subtype;
+
+					// Reference supertype
+					subtype.$super = this;
+
+					return subtype;
+				},
+
+				/**
+				 * Extends this object and runs the init method.
+				 * Arguments to create() will be passed to init().
+				 *
+				 * @return {Object} The new object.
+				 *
+				 * @static
+				 *
+				 * @example
+				 *
+				 *     var instance = MyType.create();
+				 */
+				create: function () {
+					var instance = this.extend();
+					instance.init.apply(instance, arguments);
+
+					return instance;
+				},
+
+				/**
+				 * Initializes a newly created object.
+				 * Override this method to add some logic when your objects are created.
+				 *
+				 * @example
+				 *
+				 *     var MyType = CryptoJS.lib.Base.extend({
+				 *         init: function () {
+				 *             // ...
+				 *         }
+				 *     });
+				 */
+				init: function () {},
+
+				/**
+				 * Copies properties into this object.
+				 *
+				 * @param {Object} properties The properties to mix in.
+				 *
+				 * @example
+				 *
+				 *     MyType.mixIn({
+				 *         field: 'value'
+				 *     });
+				 */
+				mixIn: function (properties) {
+					for (var propertyName in properties) {
+						if (properties.hasOwnProperty(propertyName)) {
+							this[propertyName] = properties[propertyName];
+						}
+					}
+
+					// IE won't copy toString using the loop above
+					if (properties.hasOwnProperty('toString')) {
+						this.toString = properties.toString;
+					}
+				},
+
+				/**
+				 * Creates a copy of this object.
+				 *
+				 * @return {Object} The clone.
+				 *
+				 * @example
+				 *
+				 *     var clone = instance.clone();
+				 */
+				clone: function () {
+					return this.init.prototype.extend(this);
+				}
+			};
+		}());
+
+		/**
+		 * An array of 32-bit words.
+		 *
+		 * @property {Array} words The array of 32-bit words.
+		 * @property {number} sigBytes The number of significant bytes in this word array.
+		 */
+		var WordArray = C_lib.WordArray = Base.extend({
+			/**
+			 * Initializes a newly created word array.
+			 *
+			 * @param {Array} words (Optional) An array of 32-bit words.
+			 * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.lib.WordArray.create();
+			 *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+			 *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+			 */
+			init: function (words, sigBytes) {
+				words = this.words = words || [];
+
+				if (sigBytes != undefined) {
+					this.sigBytes = sigBytes;
+				} else {
+					this.sigBytes = words.length * 4;
+				}
+			},
+
+			/**
+			 * Converts this word array to a string.
+			 *
+			 * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+			 *
+			 * @return {string} The stringified word array.
+			 *
+			 * @example
+			 *
+			 *     var string = wordArray + '';
+			 *     var string = wordArray.toString();
+			 *     var string = wordArray.toString(CryptoJS.enc.Utf8);
+			 */
+			toString: function (encoder) {
+				return (encoder || Hex).stringify(this);
+			},
+
+			/**
+			 * Concatenates a word array to this word array.
+			 *
+			 * @param {WordArray} wordArray The word array to append.
+			 *
+			 * @return {WordArray} This word array.
+			 *
+			 * @example
+			 *
+			 *     wordArray1.concat(wordArray2);
+			 */
+			concat: function (wordArray) {
+				// Shortcuts
+				var thisWords = this.words;
+				var thatWords = wordArray.words;
+				var thisSigBytes = this.sigBytes;
+				var thatSigBytes = wordArray.sigBytes;
+
+				// Clamp excess bits
+				this.clamp();
+
+				// Concat
+				if (thisSigBytes % 4) {
+					// Copy one byte at a time
+					for (var i = 0; i < thatSigBytes; i++) {
+						var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+						thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
+					}
+				} else {
+					// Copy one word at a time
+					for (var i = 0; i < thatSigBytes; i += 4) {
+						thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
+					}
+				}
+				this.sigBytes += thatSigBytes;
+
+				// Chainable
+				return this;
+			},
+
+			/**
+			 * Removes insignificant bits.
+			 *
+			 * @example
+			 *
+			 *     wordArray.clamp();
+			 */
+			clamp: function () {
+				// Shortcuts
+				var words = this.words;
+				var sigBytes = this.sigBytes;
+
+				// Clamp
+				words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
+				words.length = Math.ceil(sigBytes / 4);
+			},
+
+			/**
+			 * Creates a copy of this word array.
+			 *
+			 * @return {WordArray} The clone.
+			 *
+			 * @example
+			 *
+			 *     var clone = wordArray.clone();
+			 */
+			clone: function () {
+				var clone = Base.clone.call(this);
+				clone.words = this.words.slice(0);
+
+				return clone;
+			},
+
+			/**
+			 * Creates a word array filled with random bytes.
+			 *
+			 * @param {number} nBytes The number of random bytes to generate.
+			 *
+			 * @return {WordArray} The random word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.lib.WordArray.random(16);
+			 */
+			random: function (nBytes) {
+				var words = [];
+
+				var r = (function (m_w) {
+					var m_w = m_w;
+					var m_z = 0x3ade68b1;
+					var mask = 0xffffffff;
+
+					return function () {
+						m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
+						m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
+						var result = ((m_z << 0x10) + m_w) & mask;
+						result /= 0x100000000;
+						result += 0.5;
+						return result * (Math.random() > .5 ? 1 : -1);
+					}
+				});
+
+				for (var i = 0, rcache; i < nBytes; i += 4) {
+					var _r = r((rcache || Math.random()) * 0x100000000);
+
+					rcache = _r() * 0x3ade67b7;
+					words.push((_r() * 0x100000000) | 0);
+				}
+
+				return new WordArray.init(words, nBytes);
+			}
+		});
+
+		/**
+		 * Encoder namespace.
+		 */
+		var C_enc = C.enc = {};
+
+		/**
+		 * Hex encoding strategy.
+		 */
+		var Hex = C_enc.Hex = {
+			/**
+			 * Converts a word array to a hex string.
+			 *
+			 * @param {WordArray} wordArray The word array.
+			 *
+			 * @return {string} The hex string.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+			 */
+			stringify: function (wordArray) {
+				// Shortcuts
+				var words = wordArray.words;
+				var sigBytes = wordArray.sigBytes;
+
+				// Convert
+				var hexChars = [];
+				for (var i = 0; i < sigBytes; i++) {
+					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+					hexChars.push((bite >>> 4).toString(16));
+					hexChars.push((bite & 0x0f).toString(16));
+				}
+
+				return hexChars.join('');
+			},
+
+			/**
+			 * Converts a hex string to a word array.
+			 *
+			 * @param {string} hexStr The hex string.
+			 *
+			 * @return {WordArray} The word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+			 */
+			parse: function (hexStr) {
+				// Shortcut
+				var hexStrLength = hexStr.length;
+
+				// Convert
+				var words = [];
+				for (var i = 0; i < hexStrLength; i += 2) {
+					words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
+				}
+
+				return new WordArray.init(words, hexStrLength / 2);
+			}
+		};
+
+		/**
+		 * Latin1 encoding strategy.
+		 */
+		var Latin1 = C_enc.Latin1 = {
+			/**
+			 * Converts a word array to a Latin1 string.
+			 *
+			 * @param {WordArray} wordArray The word array.
+			 *
+			 * @return {string} The Latin1 string.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+			 */
+			stringify: function (wordArray) {
+				// Shortcuts
+				var words = wordArray.words;
+				var sigBytes = wordArray.sigBytes;
+
+				// Convert
+				var latin1Chars = [];
+				for (var i = 0; i < sigBytes; i++) {
+					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+					latin1Chars.push(String.fromCharCode(bite));
+				}
+
+				return latin1Chars.join('');
+			},
+
+			/**
+			 * Converts a Latin1 string to a word array.
+			 *
+			 * @param {string} latin1Str The Latin1 string.
+			 *
+			 * @return {WordArray} The word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+			 */
+			parse: function (latin1Str) {
+				// Shortcut
+				var latin1StrLength = latin1Str.length;
+
+				// Convert
+				var words = [];
+				for (var i = 0; i < latin1StrLength; i++) {
+					words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
+				}
+
+				return new WordArray.init(words, latin1StrLength);
+			}
+		};
+
+		/**
+		 * UTF-8 encoding strategy.
+		 */
+		var Utf8 = C_enc.Utf8 = {
+			/**
+			 * Converts a word array to a UTF-8 string.
+			 *
+			 * @param {WordArray} wordArray The word array.
+			 *
+			 * @return {string} The UTF-8 string.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+			 */
+			stringify: function (wordArray) {
+				try {
+					return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+				} catch (e) {
+					throw new Error('Malformed UTF-8 data');
+				}
+			},
+
+			/**
+			 * Converts a UTF-8 string to a word array.
+			 *
+			 * @param {string} utf8Str The UTF-8 string.
+			 *
+			 * @return {WordArray} The word array.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+			 */
+			parse: function (utf8Str) {
+				return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+			}
+		};
+
+		/**
+		 * Abstract buffered block algorithm template.
+		 *
+		 * The property blockSize must be implemented in a concrete subtype.
+		 *
+		 * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
+		 */
+		var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+			/**
+			 * Resets this block algorithm's data buffer to its initial state.
+			 *
+			 * @example
+			 *
+			 *     bufferedBlockAlgorithm.reset();
+			 */
+			reset: function () {
+				// Initial values
+				this._data = new WordArray.init();
+				this._nDataBytes = 0;
+			},
+
+			/**
+			 * Adds new data to this block algorithm's buffer.
+			 *
+			 * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+			 *
+			 * @example
+			 *
+			 *     bufferedBlockAlgorithm._append('data');
+			 *     bufferedBlockAlgorithm._append(wordArray);
+			 */
+			_append: function (data) {
+				// Convert string to WordArray, else assume WordArray already
+				if (typeof data == 'string') {
+					data = Utf8.parse(data);
+				}
+
+				// Append
+				this._data.concat(data);
+				this._nDataBytes += data.sigBytes;
+			},
+
+			/**
+			 * Processes available data blocks.
+			 *
+			 * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+			 *
+			 * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+			 *
+			 * @return {WordArray} The processed data.
+			 *
+			 * @example
+			 *
+			 *     var processedData = bufferedBlockAlgorithm._process();
+			 *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+			 */
+			_process: function (doFlush) {
+				// Shortcuts
+				var data = this._data;
+				var dataWords = data.words;
+				var dataSigBytes = data.sigBytes;
+				var blockSize = this.blockSize;
+				var blockSizeBytes = blockSize * 4;
+
+				// Count blocks ready
+				var nBlocksReady = dataSigBytes / blockSizeBytes;
+				if (doFlush) {
+					// Round up to include partial blocks
+					nBlocksReady = Math.ceil(nBlocksReady);
+				} else {
+					// Round down to include only full blocks,
+					// less the number of blocks that must remain in the buffer
+					nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+				}
+
+				// Count words ready
+				var nWordsReady = nBlocksReady * blockSize;
+
+				// Count bytes ready
+				var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
+
+				// Process blocks
+				if (nWordsReady) {
+					for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+						// Perform concrete-algorithm logic
+						this._doProcessBlock(dataWords, offset);
+					}
+
+					// Remove processed words
+					var processedWords = dataWords.splice(0, nWordsReady);
+					data.sigBytes -= nBytesReady;
+				}
+
+				// Return processed words
+				return new WordArray.init(processedWords, nBytesReady);
+			},
+
+			/**
+			 * Creates a copy of this object.
+			 *
+			 * @return {Object} The clone.
+			 *
+			 * @example
+			 *
+			 *     var clone = bufferedBlockAlgorithm.clone();
+			 */
+			clone: function () {
+				var clone = Base.clone.call(this);
+				clone._data = this._data.clone();
+
+				return clone;
+			},
+
+			_minBufferSize: 0
+		});
+
+		/**
+		 * Abstract hasher template.
+		 *
+		 * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
+		 */
+		var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+			/**
+			 * Configuration options.
+			 */
+			cfg: Base.extend(),
+
+			/**
+			 * Initializes a newly created hasher.
+			 *
+			 * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+			 *
+			 * @example
+			 *
+			 *     var hasher = CryptoJS.algo.SHA256.create();
+			 */
+			init: function (cfg) {
+				// Apply config defaults
+				this.cfg = this.cfg.extend(cfg);
+
+				// Set initial values
+				this.reset();
+			},
+
+			/**
+			 * Resets this hasher to its initial state.
+			 *
+			 * @example
+			 *
+			 *     hasher.reset();
+			 */
+			reset: function () {
+				// Reset data buffer
+				BufferedBlockAlgorithm.reset.call(this);
+
+				// Perform concrete-hasher logic
+				this._doReset();
+			},
+
+			/**
+			 * Updates this hasher with a message.
+			 *
+			 * @param {WordArray|string} messageUpdate The message to append.
+			 *
+			 * @return {Hasher} This hasher.
+			 *
+			 * @example
+			 *
+			 *     hasher.update('message');
+			 *     hasher.update(wordArray);
+			 */
+			update: function (messageUpdate) {
+				// Append
+				this._append(messageUpdate);
+
+				// Update the hash
+				this._process();
+
+				// Chainable
+				return this;
+			},
+
+			/**
+			 * Finalizes the hash computation.
+			 * Note that the finalize operation is effectively a destructive, read-once operation.
+			 *
+			 * @param {WordArray|string} messageUpdate (Optional) A final message update.
+			 *
+			 * @return {WordArray} The hash.
+			 *
+			 * @example
+			 *
+			 *     var hash = hasher.finalize();
+			 *     var hash = hasher.finalize('message');
+			 *     var hash = hasher.finalize(wordArray);
+			 */
+			finalize: function (messageUpdate) {
+				// Final message update
+				if (messageUpdate) {
+					this._append(messageUpdate);
+				}
+
+				// Perform concrete-hasher logic
+				var hash = this._doFinalize();
+
+				return hash;
+			},
+
+			blockSize: 512 / 32,
+
+			/**
+			 * Creates a shortcut function to a hasher's object interface.
+			 *
+			 * @param {Hasher} hasher The hasher to create a helper for.
+			 *
+			 * @return {Function} The shortcut function.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+			 */
+			_createHelper: function (hasher) {
+				return function (message, cfg) {
+					return new hasher.init(cfg).finalize(message);
+				};
+			},
+
+			/**
+			 * Creates a shortcut function to the HMAC's object interface.
+			 *
+			 * @param {Hasher} hasher The hasher to use in this HMAC helper.
+			 *
+			 * @return {Function} The shortcut function.
+			 *
+			 * @static
+			 *
+			 * @example
+			 *
+			 *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+			 */
+			_createHmacHelper: function (hasher) {
+				return function (message, key) {
+					return new C_algo.HMAC.init(hasher, key).finalize(message);
+				};
+			}
+		});
+
+		/**
+		 * Algorithm namespace.
+		 */
+		var C_algo = C.algo = {};
+
+		return C;
+	}(Math));
+
+
+	return CryptoJS;
+
+}));

+(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, before, complete) {
+    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, before, complete);
+    } else if (config.qiniuUploadTokenURL) {
+      getQiniuToken(function () {
+        doUpload(filePath, success, fail, options, progress, cancelTask, before, complete);
+      });
+    } 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, before, complete);
+    } else {
+      console.error('qiniu uploader need one of [uptoken, uptokenURL, uptokenFunc]');
+      return;
+    }
+  }
+
+  function doUpload(filePath, success, fail, options, progress, cancelTask, before, complete) {
+    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);
+    console.log('filePathfilePathfilePath', filePath);
+    var fileName = filePath[0].split('//')[1];
+    if (options && options.key) {
+      fileName = options.key;
+    }
+    var formData = {
+      'token': config.qiniuUploadToken
+    };
+    if (!config.qiniuShouldUseQiniuFileName) {
+      formData['key'] = fileName
+    }
+    before && before();
+    var uploadTask = wx.uploadFile({
+      url: url,
+      filePath: filePath,
+      name: 'file',
+      formData: formData,
+      success: function (res) {
+        var dataString = res.data
+        //   // this if case is a compatibility with wechat server returned a charcode, but was fixed
+        //   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 fileUrl = config.qiniuImageURLPrefix + '/' + dataObject.key;
+          dataObject.fileUrl = fileUrl
+          dataObject.imageURL = fileUrl;
+          // console.log(dataObject);
+          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);
+        }
+      },
+      complete: function (err) {
+        complete && complete(err);
+      }
+    })
+
+    uploadTask.onProgressUpdate((res) => {
+      progress && progress(res)
+    })
+
+    cancelTask && cancelTask(() => {
+      uploadTask.abort()
+    })
+  }
+
+  function getQiniuToken(callback) {
+    console.log('urlurl', config.qiniuUploadTokenURL);
+    wx.request({
+      url: config.qiniuUploadTokenURL,
+      header: {
+        'Content-Type': "application/json",
+        //   'Cookie': 'vertx-web.session=' + wx.getStorageSync("sessionId")
+      },
+      success: function (res) {
+        var token = res.data.message;
+        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.qiniup.com';
+        break;
+      case 'NCN':
+        uploadURL = 'https://up-z1.qiniup.com';
+        break;
+      case 'z2':
+        uploadURL = 'https://up-z0.qiniup.com';
+        break;
+      case 'NA':
+        uploadURL = 'https://up-na0.qiniup.com';
+        break;
+      case 'ASG':
+        uploadURL = 'https://up-as0.qiniup.com';
+        break;
+      default:
+        console.error('please make the region is with one of [ECN, SCN, NCN, NA, ASG]');
+    }
+    return uploadURL;
+  }
+
+})();

 var uri=require('uri.js')
 var uri=require('uri.js')
+import qiniuUploader from "./upload/qiniuUploader"; 
 
 
 
 
 
 
@@ -185,11 +186,36 @@ function orderPay(charge){
       }
       }
   })
   })
 }
 }
+// 上传图片
+function uploadFile(imgArr, token,type){
+  let path = imgArr.split('//')[1]
+  let promisevariable = new Promise(function (resolve, reject) {
+    qiniuUploader.upload(
+      imgArr, //上传的图片
+      (res) => {  //回调 success
+        console.log(res, '七牛云返回')
+        resolve(res.imageURL)
+      }, (error) => { //回调 fail
+        reject('error');
+      },
+      { // 参数设置  地区代码 token domain 和直传的链接 注意七牛四个不同地域的链接不一样，我使用的是华南地区
+        uptokenURL: token,
+        uploadURL: 'http://nosqn.colorcun.com',
+        region: 'ECN',	//服务器区域号
+        domain: 'http://nosqn.colorcun.com',//七牛云域名
+        key: `pinglun/${type}/${path}`, // 上传到七牛云图片就是这路径
+        uptoken: token,
+        uptokeFunc:'',
+      })
+  })
+  return promisevariable;
+}
 module.exports = {
 module.exports = {
   formatTime: formatTime,
   formatTime: formatTime,
   unixtoTime:unixtoTime,
   unixtoTime:unixtoTime,
   timetouUnix:timetouUnix,
   timetouUnix:timetouUnix,
   orderPay:orderPay,
   orderPay:orderPay,
+  uploadFile,
   cgi:function(act){
   cgi:function(act){
     return uri.HOST__LINE+act   //正式
     return uri.HOST__LINE+act   //正式
       //return uri.HOST__TEST+act     //测试
       //return uri.HOST__TEST+act     //测试