From 5e6abad91f1b97e55ddd46af681d42fb49ed12e0 Mon Sep 17 00:00:00 2001 From: ivinwu Date: Mon, 24 Sep 2018 21:58:20 +0800 Subject: [PATCH] =?UTF-8?q?=E6=94=AF=E6=8C=81=E9=85=8D=E7=BD=AEsessionExpi?= =?UTF-8?q?reTime?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 11 ++++++++++- build/weRequest.js | 42 +++++++++++++++++++++++++++++++++++---- build/weRequest.min.js | 2 +- example/request.js | 45 +++++++++++++++++++++++------------------- src/weRequest.js | 41 ++++++++++++++++++++++++++++++++++---- 5 files changed, 111 insertions(+), 30 deletions(-) diff --git a/README.md b/README.md index 2972362..ea0611a 100644 --- a/README.md +++ b/README.md @@ -105,6 +105,8 @@ weRequest.request({ |reportCGI|Function|否||接口返回成功之后，会执行统一的回调函数，这里可以做统一的耗时上报等处理| |mockJson|Object|否||可为接口提供mock数据| |globalData|Object/Function|否||所有请求都会自动带上这里的参数| +|sessionExpireTime|Int|否|null|为用户登陆态设置本地缓存时间（单位为ms），一旦过期，直接废弃缓存中的登陆态| +|sessionExpireKey|String|否|sessionExpireKey|如果为用户登陆态设置了本地缓存时间，则过期时间将以此值为key存储在Storage中| ##### codeToSession参数说明 @@ -261,7 +263,14 @@ weRequest.request({ ### .getConfig() [return Object] -获取weRequest的配置。目前Object仅包含urlPerfix字段 +获取weRequest的配置。返回的Object内容如下： + +|参数名|类型|说明| +| :-------- | :-------| :------ | +|urlPerfix|String|在组件初始化时传入的请求URL的固定前缀| +|sessionExpireTime|Int|在组件初始化时传入的用户登陆态设置本地缓存时间| +|sessionExpireKey|String|在组件初始化时传入的用户登陆态本地缓存时间Storage的key| +|sessionExpire|Int|用户登陆态本地缓存过期的时间戳| ### .login() diff --git a/build/weRequest.js b/build/weRequest.js index 08a724b..fa0d3bd 100644 --- a/build/weRequest.js +++ b/build/weRequest.js @@ -187,6 +187,12 @@ var errorCallback = null; var reportCGI = false; var mockJson = false; var globalData = false; +// session在本地缓存的有效时间 +var sessionExpireTime = null; +// session在本地缓存的key +var sessionExpireKey = "sessionExpireKey"; +// session过期的时间点 +var sessionExpire = Infinity; //global data var session = ''; @@ -235,9 +241,18 @@ function checkSession(callback, obj) { } function doLogin(callback, obj) { - if (session || obj.isLogin) { - // 缓存中有session，或者是登录接口 + if (obj.isLogin) { + // 登录接口，直接放过 typeof callback === "function" && callback(); + } else if(session) { + // 缓存中有session + if(sessionExpireTime && new Date().getTime() > sessionExpire) { + // 如果有设置本地session缓存时间，且缓存时间已到 + session = ''; + doLogin(callback, obj); + } else { + typeof callback === "function" && callback(); + } } else if (logining) { // 正在登录中，请求轮询稍后，避免重复调用登录接口 flow.wait('doLoginFinished', function () { @@ -281,6 +296,14 @@ function doLogin(callback, obj) { success: function (s) { session = s; sessionIsFresh = true; + // 如果有设置本地session过期时间 + if(sessionExpireTime) { + sessionExpire = new Date().getTime() + sessionExpireTime; + wx.setStorage({ + key: sessionExpireKey, + data: sessionExpire + }) + } typeof callback === "function" && callback(); wx.setStorage({ key: sessionName, @@ -656,9 +679,16 @@ function init(params) { reportCGI = params.reportCGI || false; mockJson = params.mockJson || false; globalData = params.globalData || false; + sessionExpireTime = params.sessionExpireTime || null; + sessionExpireKey = params.sessionExpireKey || "sessionExpireKey"; try { session = wx.getStorageSync(sessionName) || ''; + sessionExpire = wx.getStorageSync(sessionExpireKey) || Infinity; + // 如果有设置本地session过期时间，且验证已过期，则直接清空session + if(new Date().getTime() > sessionExpire) { + session = ''; + } } catch (e) { } } @@ -712,7 +742,10 @@ function getSession() { function getConfig() { return { - 'urlPerfix': urlPerfix + urlPerfix: urlPerfix, + sessionExpireTime: sessionExpireTime, + sessionExpireKey: sessionExpireKey, + sessionExpire: sessionExpire } } @@ -726,7 +759,8 @@ module.exports = { getConfig: getConfig }; + /***/ }) /******/ }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://weRequest/webpack/bootstrap","webpack://weRequest/./src/lib/flow.js","webpack://weRequest/./src/loading.js","webpack://weRequest/./src/weRequest.js"],"names":[],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;AClFA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,mBAAmB;AACtC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,C;;;;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,C;;;;;;;;;;;AChBA,gBAAgB,mBAAO,CAAC,mCAAW;AACnC,aAAa,mBAAO,CAAC,qCAAY;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,+BAA+B;;AAE/B;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,iBAAiB;AACjB;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,mCAAmC;;AAEnC;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,cAAc;AAC9F,iBAAiB;AACjB,gFAAgF,cAAc;AAC9F;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;;AAEA;AACA,6BAA6B;AAC7B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E","file":"weRequest.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/weRequest.js\");\n","var store = {};\n\nfunction emit (key){\n    var flow = getFlow(key);\n    console.log(\"waitingList Length: \" + flow.waitingList.length);\n    var currentLength = flow.waitingList.length;\n    for (var i = 0; i < currentLength; i ++) {\n        var callback = flow.waitingList.shift();\n        typeof callback == \"function\" && callback();\n    }\n}\n\nfunction wait (key,callback){\n    var flow = getFlow(key);\n    flow.waitingList.push(callback)\n}\n\nfunction getFlow(key){\n    if(!store[key]){\n        store[key] = {\n            waitingList:[]\n        }\n    }\n\n    return store[key];\n}\n\nmodule.exports = {\n    wait: wait,\n    emit: emit\n}","function show(txt) {\n    wx.showToast({\n        title: typeof txt === 'boolean' ? '加载中' : txt,\n        icon: 'loading',\n        mask: true,\n        duration: 60000\n    })\n}\n\nfunction hide() {\n    wx.hideToast();\n}\n\nmodule.exports = {\n    show: show,\n    hide: hide\n}","const loading = require('./loading');\nconst flow = require('./lib/flow');\n\n//params\nvar sessionName    = \"session\";\nvar loginTrigger   = function () {\n    return false\n};\nvar codeToSession  = {};\nvar successTrigger = function () {\n    return true\n};\nvar urlPerfix      = \"\";\nvar successData    = function (res) {\n    return res\n};\nvar errorTitle     = \"操作失败\";\nvar errorContent   = function (res) {\n    return res\n};\nvar reLoginLimit   = 3;\nvar errorCallback  = null;\nvar reportCGI      = false;\nvar mockJson       = false;\nvar globalData     = false;\n\n//global data\nvar session           = '';\nvar sessionIsFresh    = false;\n// 正在登录中，其他请求轮询稍后，避免重复调用登录接口\nvar logining          = false;\n// 正在查询session有效期中，避免重复调用接口\nvar isCheckingSession = false;\n\nfunction checkSession(callback, obj) {\n    if (isCheckingSession) {\n        flow.wait('checkSessionFinished', function () {\n            checkSession(callback, obj)\n        })\n    } else if (!sessionIsFresh && session) {\n        isCheckingSession = true;\n        obj.count++;\n        // 如果还没检验过session是否有效，则需要检验一次\n        obj._checkSessionStartTime = new Date().getTime();\n\n        console.log('wx.checkSession');\n        wx.checkSession({\n            success: function () {\n                // 登录态有效，且在本生命周期内无须再检验了\n                sessionIsFresh = true;\n            },\n            fail: function () {\n                // 登录态过期\n                session = '';\n            },\n            complete: function () {\n                isCheckingSession = false;\n                obj.count--;\n                obj._checkSessionEndTime = new Date().getTime();\n                if (typeof reportCGI === \"function\") {\n                    reportCGI('wx_checkSession', obj._checkSessionStartTime, obj._checkSessionEndTime, request);\n                }\n                doLogin(callback, obj);\n                flow.emit('checkSessionFinished');\n            }\n        })\n    } else {\n        // 已经检验过了\n        doLogin(callback, obj);\n    }\n}\n\nfunction doLogin(callback, obj) {\n    if (session || obj.isLogin) {\n        // 缓存中有session，或者是登录接口\n        typeof callback === \"function\" && callback();\n    } else if (logining) {\n        // 正在登录中，请求轮询稍后，避免重复调用登录接口\n        flow.wait('doLoginFinished', function () {\n            doLogin(callback, obj);\n        })\n    } else {\n        // 缓存中无session\n        logining = true;\n        obj.count++;\n        // 记录调用wx.login前的时间戳\n        obj._loginStartTime = new Date().getTime();\n        console.log('wx.login');\n        wx.login({\n            complete: function () {\n                obj.count--;\n                // 记录wx.login返回数据后的时间戳，用于上报\n                obj._loginEndTime = new Date().getTime();\n                if (typeof reportCGI === \"function\") {\n                    reportCGI('wx_login', obj._loginStartTime, obj._loginEndTime, request);\n                }\n                typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n            },\n            success: function (res) {\n                if (res.code) {\n                    var data;\n                    // codeToSession.data支持函数\n                    if (typeof codeToSession.data === \"function\") {\n                        data = codeToSession.data();\n                    } else {\n                        data = codeToSession.data || {};\n                    }\n                    data[codeToSession.codeName] = res.code;\n\n                    obj.count++;\n                    requestWrapper({\n                        url: codeToSession.url,\n                        data: data,\n                        method: codeToSession.method,\n                        isLogin: true,\n                        report: codeToSession.report || codeToSession.url,\n                        success: function (s) {\n                            session        = s;\n                            sessionIsFresh = true;\n                            typeof callback === \"function\" && callback();\n                            wx.setStorage({\n                                key: sessionName,\n                                data: session\n                            })\n                        },\n                        complete: function () {\n                            obj.count--;\n                            typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n                            logining = false;\n                            flow.emit('doLoginFinished');\n                        },\n                        fail: codeToSession.fail || null\n                    });\n                } else {\n                    fail(obj, res);\n                    console.error(res);\n                    // 登录失败，解除锁，防止死锁\n                    logining = false;\n                    flow.emit('doLoginFinished');\n                }\n            },\n            fail: function (res) {\n                fail(obj, res);\n                console.error(res);\n                // 登录失败，解除锁，防止死锁\n                logining = false;\n                flow.emit('doLoginFinished');\n            }\n        })\n    }\n}\n\nfunction preDo(obj) {\n    typeof obj.beforeSend === \"function\" && obj.beforeSend();\n\n    // 登录态失效，重复登录计数\n    if (typeof obj.reLoginLimit === \"undefined\") {\n        obj.reLoginLimit = 0;\n    } else {\n        obj.reLoginLimit++;\n    }\n\n    if (typeof obj.count === \"undefined\") {\n        obj.count = 0;\n    }\n\n    if (obj.showLoading) {\n        loading.show(obj.showLoading);\n        obj.complete = (function (fn) {\n            return function () {\n                loading.hide();\n                typeof fn === \"function\" && fn.apply(this, arguments);\n            }\n        })(obj.complete)\n    }\n\n    return obj;\n}\n\nfunction request(obj) {\n    obj.count++;\n\n    if (!obj.data) {\n        obj.data = {};\n    }\n\n    if (obj.url != codeToSession.url && session) {\n        obj.data[sessionName] = session;\n    }\n\n    // 如果有全局参数，则添加\n    var gd = {};\n    if (typeof globalData === \"function\") {\n        gd = globalData();\n    } else if (typeof globalData === \"object\") {\n        gd = globalData;\n    }\n    obj.data = Object.assign({}, gd, obj.data);\n\n    obj.method = obj.method || 'GET';\n\n    // 如果请求的URL中不是http开头的，则自动添加配置中的前缀\n    var url = obj.url.startsWith('http') ? obj.url : (urlPerfix + obj.url);\n    // 如果请求不是GET，则在URL中自动加上登录态和全局参数\n    if (obj.method != \"GET\") {\n\n        if (session) {\n            if (url.indexOf('?') >= 0) {\n                url += '&' + sessionName + '=' + encodeURIComponent(session);\n            } else {\n                url += '?' + sessionName + '=' + encodeURIComponent(session);\n            }\n        }\n\n        // 如果有全局参数，则在URL中添加\n        for (var i in gd) {\n            if (url.indexOf('?') >= 0) {\n                url += '&' + i + '=' + gd[i];\n            } else {\n                url += '?' + i + '=' + gd[i];\n            }\n        }\n    }\n\n    // 如果有上报字段配置，则记录请求发出前的时间戳\n    if (obj.report) {\n        obj._reportStartTime = new Date().getTime();\n    }\n\n    wx.request({\n        url: url,\n        data: obj.data,\n        method: obj.method,\n        header: obj.header || {},\n        dataType: obj.dataType || 'json',\n        success: function (res) {\n            if (res.statusCode == 200) {\n\n                // 如果有上报字段配置，则记录请求返回后的时间戳，并进行上报\n                if (obj.report && typeof reportCGI === \"function\") {\n                    obj._reportEndTime = new Date().getTime();\n                    reportCGI(obj.report, obj._reportStartTime, obj._reportEndTime, request);\n                }\n\n                if (obj.isLogin) {\n                    // 登录请求\n                    var s = \"\";\n                    try {\n                        s = codeToSession.success(res.data);\n                    } catch (e) {\n                    }\n                    if (s) {\n                        obj.success(s);\n                    } else {\n                        fail(obj, res);\n                    }\n                } else if (loginTrigger(res.data) && obj.reLoginLimit < reLoginLimit) {\n                    // 登录态失效，且重试次数不超过配置\n                    session = '';\n                    wx.removeStorage({\n                        key: sessionName,\n                        complete: function () {\n                            doLogin(function () {\n                                requestWrapper(obj);\n                            }, obj)\n                        }\n                    })\n                } else if (successTrigger(res.data) && typeof obj.success === \"function\") {\n                    // 接口返回成功码\n                    var realData = null;\n                    try {\n                        realData = successData(res.data);\n                    } catch (e) {\n                        console.error(\"Function successData occur error: \" + e);\n                    }\n                    if(!obj.noCacheFlash) {\n                        // 如果为了保证页面不闪烁，则不回调，只是缓存最新数据，待下次进入再用\n                        obj.success(realData);\n                    }\n                    if (obj.cache === true || (typeof obj.cache === \"function\" && obj.cache(realData))) {\n                        wx.setStorage({\n                            key: obj.url,\n                            data: realData\n                        })\n                    }\n                } else {\n                    // 接口返回失败码\n                    fail(obj, res);\n                }\n            } else {\n                fail(obj, res);\n            }\n        },\n        fail: function (res) {\n            fail(obj, res);\n            console.error(res);\n        },\n        complete: function () {\n            obj.count--;\n            typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n        }\n    })\n}\n\nfunction uploadFile(obj) {\n    obj.count++;\n\n    if (!obj.formData) {\n        obj.formData = {};\n    }\n    obj.formData[sessionName] = session;\n\n    // 如果有全局参数，则添加\n    var gd = {};\n    if (typeof globalData === \"function\") {\n        gd = globalData();\n    } else if (typeof globalData === \"object\") {\n        gd = globalData;\n    }\n    obj.formData = Object.assign({}, gd, obj.formData);\n\n    obj.dataType = obj.dataType || 'json';\n\n    // 如果请求的URL中不是http开头的，则自动添加配置中的前缀\n    var url = obj.url.startsWith('http') ? obj.url : (urlPerfix + obj.url);\n\n    // 在URL中自动加上登录态和全局参数\n    if (session) {\n        if (url.indexOf('?') >= 0) {\n            url += '&' + sessionName + '=' + session;\n        } else {\n            url += '?' + sessionName + '=' + session;\n        }\n    }\n\n    // 如果有全局参数，则在URL中添加\n    for (var i in gd) {\n        if (url.indexOf('?') >= 0) {\n            url += '&' + i + '=' + gd[i];\n        } else {\n            url += '?' + i + '=' + gd[i];\n        }\n    }\n\n    // 如果有上报字段配置，则记录请求发出前的时间戳\n    if (obj.report) {\n        obj._reportStartTime = new Date().getTime();\n    }\n\n    wx.uploadFile({\n        url: url,\n        filePath: obj.filePath || '',\n        name: obj.name || '',\n        formData: obj.formData,\n        success: function (res) {\n            if (res.statusCode == 200 && res.errMsg == 'uploadFile:ok') {\n\n                // 如果有上报字段配置，则记录请求返回后的时间戳，并进行上报\n                if (obj.report && typeof reportCGI === \"function\") {\n                    obj.endTime = new Date().getTime();\n                    reportCGI(obj.report, obj._reportStartTime, obj._reportEndTime, request);\n                }\n\n                if (obj.dataType == 'json') {\n                    try {\n                        res.data = JSON.parse(res.data);\n                    } catch (e) {\n                        fail(obj, res);\n                        return false;\n                    }\n                }\n                if (loginTrigger(res.data) && obj.reLoginLimit < reLoginLimit) {\n                    // 登录态失效，且重试次数不超过配置\n                    session = '';\n                    wx.removeStorage({\n                        key: sessionName,\n                        complete: function () {\n                            doLogin(function () {\n                                uploadFileWrapper(obj);\n                            }, obj)\n                        }\n                    })\n                } else if (successTrigger(res.data) && typeof obj.success === \"function\") {\n                    // 接口返回成功码\n                    obj.success(successData(res.data));\n                } else {\n                    // 接口返回失败码\n                    fail(obj, res);\n                }\n            } else {\n                fail(obj, res);\n            }\n        },\n        fail: function (res) {\n            fail(obj, res);\n            console.error(res);\n        },\n        complete: function () {\n            obj.count--;\n            typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n        }\n    })\n}\n\nfunction fail(obj, res) {\n    if (typeof obj.fail === \"function\") {\n        obj.fail(res);\n    } else {\n        var title = \"\";\n        if (typeof errorTitle === \"function\") {\n            try {\n                title = errorTitle(res.data)\n            } catch (e) {\n            }\n        } else if (typeof errorTitle === \"string\") {\n            title = errorTitle;\n        }\n\n        var content = \"\";\n        if (typeof errorContent === \"function\") {\n            try {\n                content = errorContent(res.data)\n            } catch (e) {\n            }\n        } else if (typeof errorContent === \"string\") {\n            content = errorContent;\n        }\n\n        wx.showModal({\n            title: title,\n            content: content || \"网络或服务异常，请稍后重试\",\n            showCancel: false\n        })\n    }\n\n    // 如果有配置统一错误回调函数，则执行它\n    if (typeof errorCallback === \"function\") {\n        errorCallback(obj, res);\n    }\n\n    console.error(res);\n}\n\nfunction getCache(obj, callback) {\n    if (obj.cache) {\n        wx.getStorage({\n            key: obj.url,\n            success: function (res) {\n                typeof obj.beforeSend === \"function\" && obj.beforeSend();\n                if (typeof obj.cache === \"function\" && obj.cache(res.data)) {\n                    typeof obj.success === \"function\" && obj.success(res.data, {isCache: true});\n                } else if (obj.cache == true) {\n                    typeof obj.success === \"function\" && obj.success(res.data, {isCache: true});\n                }\n                typeof obj.complete === \"function\" && obj.complete();\n                // 成功取出缓存，还要去请求拿最新的再存起来\n                callback(obj);\n            },\n            fail: function() {\n                // 找不到缓存，直接发起请求，且不再防止页面闪烁（本来就没缓存了，更不存在更新页面导致的闪烁）\n                obj.noCacheFlash = false;\n                callback(obj);\n            }\n        })\n    } else {\n        callback(obj);\n    }\n}\n\nfunction login(callback) {\n    checkSession(callback, {})\n}\n\nfunction init(params) {\n    sessionName    = params.sessionName || 'session';\n    loginTrigger   = params.loginTrigger || function () {\n            return false\n        };\n    codeToSession  = params.codeToSession || {};\n    successTrigger = params.successTrigger || function () {\n            return true\n        };\n    urlPerfix      = params.urlPerfix || \"\";\n    successData    = params.successData || function (res) {\n            return res\n        };\n    errorTitle     = params.errorTitle || \"操作失败\";\n    errorContent   = params.errorContent || false;\n    reLoginLimit   = params.reLoginLimit || 3;\n    errorCallback  = params.errorCallback || null;\n    sessionIsFresh = params.doNotCheckSession || false;\n    reportCGI      = params.reportCGI || false;\n    mockJson       = params.mockJson || false;\n    globalData     = params.globalData || false;\n\n    try {\n        session = wx.getStorageSync(sessionName) || '';\n    } catch (e) {\n    }\n}\n\nfunction requestWrapper(obj) {\n    obj = preDo(obj);\n    if (mockJson && mockJson[obj.url]) {\n        // mock 模式\n        mock(obj);\n    } else {\n        getCache(obj, function (obj) {\n                checkSession(function () {\n                    request(obj);\n                }, obj)\n            }\n        )\n    }\n}\n\nfunction uploadFileWrapper(obj) {\n    obj = preDo(obj);\n    checkSession(function () {\n        uploadFile(obj);\n    }, obj)\n}\n\nfunction setSession(s) {\n    session        = s;\n    sessionIsFresh = true;\n}\n\nfunction mock(obj) {\n    var res = {\n        data: mockJson[obj.url]\n    };\n    if (successTrigger(res.data) && typeof obj.success === \"function\") {\n        // 接口返回成功码\n        obj.success(successData(res.data));\n    } else {\n        // 接口返回失败码\n        fail(obj, res);\n    }\n    if (typeof obj.complete === \"function\") {\n        obj.complete();\n    }\n}\n\nfunction getSession() {\n    return session;\n}\n\nfunction getConfig() {\n    return {\n        'urlPerfix': urlPerfix\n    }\n}\n\nmodule.exports = {\n    init: init,\n    request: requestWrapper,\n    uploadFile: uploadFileWrapper,\n    setSession: setSession,\n    login: login,\n    getSession: getSession,\n    getConfig: getConfig\n};"],"sourceRoot":""} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://weRequest/webpack/bootstrap","webpack://weRequest/./src/lib/flow.js","webpack://weRequest/./src/loading.js","webpack://weRequest/./src/weRequest.js"],"names":[],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;AClFA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,mBAAmB;AACtC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,C;;;;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,C;;;;;;;;;;;AChBA,gBAAgB,mBAAO,CAAC,mCAAW;AACnC,aAAa,mBAAO,CAAC,qCAAY;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,+BAA+B;;AAE/B;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,iBAAiB;AACjB;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,mCAAmC;;AAEnC;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,cAAc;AAC9F,iBAAiB;AACjB,gFAAgF,cAAc;AAC9F;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;;AAEA;AACA,6BAA6B;AAC7B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"weRequest.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/weRequest.js\");\n","var store = {};\n\nfunction emit (key){\n    var flow = getFlow(key);\n    console.log(\"waitingList Length: \" + flow.waitingList.length);\n    var currentLength = flow.waitingList.length;\n    for (var i = 0; i < currentLength; i ++) {\n        var callback = flow.waitingList.shift();\n        typeof callback == \"function\" && callback();\n    }\n}\n\nfunction wait (key,callback){\n    var flow = getFlow(key);\n    flow.waitingList.push(callback)\n}\n\nfunction getFlow(key){\n    if(!store[key]){\n        store[key] = {\n            waitingList:[]\n        }\n    }\n\n    return store[key];\n}\n\nmodule.exports = {\n    wait: wait,\n    emit: emit\n}","function show(txt) {\n    wx.showToast({\n        title: typeof txt === 'boolean' ? '加载中' : txt,\n        icon: 'loading',\n        mask: true,\n        duration: 60000\n    })\n}\n\nfunction hide() {\n    wx.hideToast();\n}\n\nmodule.exports = {\n    show: show,\n    hide: hide\n}","const loading = require('./loading');\nconst flow = require('./lib/flow');\n\n//params\nvar sessionName    = \"session\";\nvar loginTrigger   = function () {\n    return false\n};\nvar codeToSession  = {};\nvar successTrigger = function () {\n    return true\n};\nvar urlPerfix      = \"\";\nvar successData    = function (res) {\n    return res\n};\nvar errorTitle     = \"操作失败\";\nvar errorContent   = function (res) {\n    return res\n};\nvar reLoginLimit   = 3;\nvar errorCallback  = null;\nvar reportCGI      = false;\nvar mockJson       = false;\nvar globalData     = false;\n// session在本地缓存的有效时间\nvar sessionExpireTime = null;\n// session在本地缓存的key\nvar sessionExpireKey = \"sessionExpireKey\";\n// session过期的时间点\nvar sessionExpire = Infinity;\n\n//global data\nvar session           = '';\nvar sessionIsFresh    = false;\n// 正在登录中，其他请求轮询稍后，避免重复调用登录接口\nvar logining          = false;\n// 正在查询session有效期中，避免重复调用接口\nvar isCheckingSession = false;\n\nfunction checkSession(callback, obj) {\n    if (isCheckingSession) {\n        flow.wait('checkSessionFinished', function () {\n            checkSession(callback, obj)\n        })\n    } else if (!sessionIsFresh && session) {\n        isCheckingSession = true;\n        obj.count++;\n        // 如果还没检验过session是否有效，则需要检验一次\n        obj._checkSessionStartTime = new Date().getTime();\n\n        console.log('wx.checkSession');\n        wx.checkSession({\n            success: function () {\n                // 登录态有效，且在本生命周期内无须再检验了\n                sessionIsFresh = true;\n            },\n            fail: function () {\n                // 登录态过期\n                session = '';\n            },\n            complete: function () {\n                isCheckingSession = false;\n                obj.count--;\n                obj._checkSessionEndTime = new Date().getTime();\n                if (typeof reportCGI === \"function\") {\n                    reportCGI('wx_checkSession', obj._checkSessionStartTime, obj._checkSessionEndTime, request);\n                }\n                doLogin(callback, obj);\n                flow.emit('checkSessionFinished');\n            }\n        })\n    } else {\n        // 已经检验过了\n        doLogin(callback, obj);\n    }\n}\n\nfunction doLogin(callback, obj) {\n    if (obj.isLogin) {\n        // 登录接口，直接放过\n        typeof callback === \"function\" && callback();\n    } else if(session) {\n        // 缓存中有session\n        if(sessionExpireTime && new Date().getTime() > sessionExpire) {\n            // 如果有设置本地session缓存时间，且缓存时间已到\n            session = '';\n            doLogin(callback, obj);\n        } else {\n            typeof callback === \"function\" && callback();\n        }\n    } else if (logining) {\n        // 正在登录中，请求轮询稍后，避免重复调用登录接口\n        flow.wait('doLoginFinished', function () {\n            doLogin(callback, obj);\n        })\n    } else {\n        // 缓存中无session\n        logining = true;\n        obj.count++;\n        // 记录调用wx.login前的时间戳\n        obj._loginStartTime = new Date().getTime();\n        console.log('wx.login');\n        wx.login({\n            complete: function () {\n                obj.count--;\n                // 记录wx.login返回数据后的时间戳，用于上报\n                obj._loginEndTime = new Date().getTime();\n                if (typeof reportCGI === \"function\") {\n                    reportCGI('wx_login', obj._loginStartTime, obj._loginEndTime, request);\n                }\n                typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n            },\n            success: function (res) {\n                if (res.code) {\n                    var data;\n                    // codeToSession.data支持函数\n                    if (typeof codeToSession.data === \"function\") {\n                        data = codeToSession.data();\n                    } else {\n                        data = codeToSession.data || {};\n                    }\n                    data[codeToSession.codeName] = res.code;\n\n                    obj.count++;\n                    requestWrapper({\n                        url: codeToSession.url,\n                        data: data,\n                        method: codeToSession.method,\n                        isLogin: true,\n                        report: codeToSession.report || codeToSession.url,\n                        success: function (s) {\n                            session        = s;\n                            sessionIsFresh = true;\n                            // 如果有设置本地session过期时间\n                            if(sessionExpireTime) {\n                                sessionExpire = new Date().getTime() + sessionExpireTime;\n                                wx.setStorage({\n                                    key: sessionExpireKey,\n                                    data: sessionExpire\n                                })\n                            }\n                            typeof callback === \"function\" && callback();\n                            wx.setStorage({\n                                key: sessionName,\n                                data: session\n                            })\n                        },\n                        complete: function () {\n                            obj.count--;\n                            typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n                            logining = false;\n                            flow.emit('doLoginFinished');\n                        },\n                        fail: codeToSession.fail || null\n                    });\n                } else {\n                    fail(obj, res);\n                    console.error(res);\n                    // 登录失败，解除锁，防止死锁\n                    logining = false;\n                    flow.emit('doLoginFinished');\n                }\n            },\n            fail: function (res) {\n                fail(obj, res);\n                console.error(res);\n                // 登录失败，解除锁，防止死锁\n                logining = false;\n                flow.emit('doLoginFinished');\n            }\n        })\n    }\n}\n\nfunction preDo(obj) {\n    typeof obj.beforeSend === \"function\" && obj.beforeSend();\n\n    // 登录态失效，重复登录计数\n    if (typeof obj.reLoginLimit === \"undefined\") {\n        obj.reLoginLimit = 0;\n    } else {\n        obj.reLoginLimit++;\n    }\n\n    if (typeof obj.count === \"undefined\") {\n        obj.count = 0;\n    }\n\n    if (obj.showLoading) {\n        loading.show(obj.showLoading);\n        obj.complete = (function (fn) {\n            return function () {\n                loading.hide();\n                typeof fn === \"function\" && fn.apply(this, arguments);\n            }\n        })(obj.complete)\n    }\n\n    return obj;\n}\n\nfunction request(obj) {\n    obj.count++;\n\n    if (!obj.data) {\n        obj.data = {};\n    }\n\n    if (obj.url != codeToSession.url && session) {\n        obj.data[sessionName] = session;\n    }\n\n    // 如果有全局参数，则添加\n    var gd = {};\n    if (typeof globalData === \"function\") {\n        gd = globalData();\n    } else if (typeof globalData === \"object\") {\n        gd = globalData;\n    }\n    obj.data = Object.assign({}, gd, obj.data);\n\n    obj.method = obj.method || 'GET';\n\n    // 如果请求的URL中不是http开头的，则自动添加配置中的前缀\n    var url = obj.url.startsWith('http') ? obj.url : (urlPerfix + obj.url);\n    // 如果请求不是GET，则在URL中自动加上登录态和全局参数\n    if (obj.method != \"GET\") {\n\n        if (session) {\n            if (url.indexOf('?') >= 0) {\n                url += '&' + sessionName + '=' + encodeURIComponent(session);\n            } else {\n                url += '?' + sessionName + '=' + encodeURIComponent(session);\n            }\n        }\n\n        // 如果有全局参数，则在URL中添加\n        for (var i in gd) {\n            if (url.indexOf('?') >= 0) {\n                url += '&' + i + '=' + gd[i];\n            } else {\n                url += '?' + i + '=' + gd[i];\n            }\n        }\n    }\n\n    // 如果有上报字段配置，则记录请求发出前的时间戳\n    if (obj.report) {\n        obj._reportStartTime = new Date().getTime();\n    }\n\n    wx.request({\n        url: url,\n        data: obj.data,\n        method: obj.method,\n        header: obj.header || {},\n        dataType: obj.dataType || 'json',\n        success: function (res) {\n            if (res.statusCode == 200) {\n\n                // 如果有上报字段配置，则记录请求返回后的时间戳，并进行上报\n                if (obj.report && typeof reportCGI === \"function\") {\n                    obj._reportEndTime = new Date().getTime();\n                    reportCGI(obj.report, obj._reportStartTime, obj._reportEndTime, request);\n                }\n\n                if (obj.isLogin) {\n                    // 登录请求\n                    var s = \"\";\n                    try {\n                        s = codeToSession.success(res.data);\n                    } catch (e) {\n                    }\n                    if (s) {\n                        obj.success(s);\n                    } else {\n                        fail(obj, res);\n                    }\n                } else if (loginTrigger(res.data) && obj.reLoginLimit < reLoginLimit) {\n                    // 登录态失效，且重试次数不超过配置\n                    session = '';\n                    wx.removeStorage({\n                        key: sessionName,\n                        complete: function () {\n                            doLogin(function () {\n                                requestWrapper(obj);\n                            }, obj)\n                        }\n                    })\n                } else if (successTrigger(res.data) && typeof obj.success === \"function\") {\n                    // 接口返回成功码\n                    var realData = null;\n                    try {\n                        realData = successData(res.data);\n                    } catch (e) {\n                        console.error(\"Function successData occur error: \" + e);\n                    }\n                    if(!obj.noCacheFlash) {\n                        // 如果为了保证页面不闪烁，则不回调，只是缓存最新数据，待下次进入再用\n                        obj.success(realData);\n                    }\n                    if (obj.cache === true || (typeof obj.cache === \"function\" && obj.cache(realData))) {\n                        wx.setStorage({\n                            key: obj.url,\n                            data: realData\n                        })\n                    }\n                } else {\n                    // 接口返回失败码\n                    fail(obj, res);\n                }\n            } else {\n                fail(obj, res);\n            }\n        },\n        fail: function (res) {\n            fail(obj, res);\n            console.error(res);\n        },\n        complete: function () {\n            obj.count--;\n            typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n        }\n    })\n}\n\nfunction uploadFile(obj) {\n    obj.count++;\n\n    if (!obj.formData) {\n        obj.formData = {};\n    }\n    obj.formData[sessionName] = session;\n\n    // 如果有全局参数，则添加\n    var gd = {};\n    if (typeof globalData === \"function\") {\n        gd = globalData();\n    } else if (typeof globalData === \"object\") {\n        gd = globalData;\n    }\n    obj.formData = Object.assign({}, gd, obj.formData);\n\n    obj.dataType = obj.dataType || 'json';\n\n    // 如果请求的URL中不是http开头的，则自动添加配置中的前缀\n    var url = obj.url.startsWith('http') ? obj.url : (urlPerfix + obj.url);\n\n    // 在URL中自动加上登录态和全局参数\n    if (session) {\n        if (url.indexOf('?') >= 0) {\n            url += '&' + sessionName + '=' + session;\n        } else {\n            url += '?' + sessionName + '=' + session;\n        }\n    }\n\n    // 如果有全局参数，则在URL中添加\n    for (var i in gd) {\n        if (url.indexOf('?') >= 0) {\n            url += '&' + i + '=' + gd[i];\n        } else {\n            url += '?' + i + '=' + gd[i];\n        }\n    }\n\n    // 如果有上报字段配置，则记录请求发出前的时间戳\n    if (obj.report) {\n        obj._reportStartTime = new Date().getTime();\n    }\n\n    wx.uploadFile({\n        url: url,\n        filePath: obj.filePath || '',\n        name: obj.name || '',\n        formData: obj.formData,\n        success: function (res) {\n            if (res.statusCode == 200 && res.errMsg == 'uploadFile:ok') {\n\n                // 如果有上报字段配置，则记录请求返回后的时间戳，并进行上报\n                if (obj.report && typeof reportCGI === \"function\") {\n                    obj.endTime = new Date().getTime();\n                    reportCGI(obj.report, obj._reportStartTime, obj._reportEndTime, request);\n                }\n\n                if (obj.dataType == 'json') {\n                    try {\n                        res.data = JSON.parse(res.data);\n                    } catch (e) {\n                        fail(obj, res);\n                        return false;\n                    }\n                }\n                if (loginTrigger(res.data) && obj.reLoginLimit < reLoginLimit) {\n                    // 登录态失效，且重试次数不超过配置\n                    session = '';\n                    wx.removeStorage({\n                        key: sessionName,\n                        complete: function () {\n                            doLogin(function () {\n                                uploadFileWrapper(obj);\n                            }, obj)\n                        }\n                    })\n                } else if (successTrigger(res.data) && typeof obj.success === \"function\") {\n                    // 接口返回成功码\n                    obj.success(successData(res.data));\n                } else {\n                    // 接口返回失败码\n                    fail(obj, res);\n                }\n            } else {\n                fail(obj, res);\n            }\n        },\n        fail: function (res) {\n            fail(obj, res);\n            console.error(res);\n        },\n        complete: function () {\n            obj.count--;\n            typeof obj.complete === \"function\" && obj.count == 0 && obj.complete();\n        }\n    })\n}\n\nfunction fail(obj, res) {\n    if (typeof obj.fail === \"function\") {\n        obj.fail(res);\n    } else {\n        var title = \"\";\n        if (typeof errorTitle === \"function\") {\n            try {\n                title = errorTitle(res.data)\n            } catch (e) {\n            }\n        } else if (typeof errorTitle === \"string\") {\n            title = errorTitle;\n        }\n\n        var content = \"\";\n        if (typeof errorContent === \"function\") {\n            try {\n                content = errorContent(res.data)\n            } catch (e) {\n            }\n        } else if (typeof errorContent === \"string\") {\n            content = errorContent;\n        }\n\n        wx.showModal({\n            title: title,\n            content: content || \"网络或服务异常，请稍后重试\",\n            showCancel: false\n        })\n    }\n\n    // 如果有配置统一错误回调函数，则执行它\n    if (typeof errorCallback === \"function\") {\n        errorCallback(obj, res);\n    }\n\n    console.error(res);\n}\n\nfunction getCache(obj, callback) {\n    if (obj.cache) {\n        wx.getStorage({\n            key: obj.url,\n            success: function (res) {\n                typeof obj.beforeSend === \"function\" && obj.beforeSend();\n                if (typeof obj.cache === \"function\" && obj.cache(res.data)) {\n                    typeof obj.success === \"function\" && obj.success(res.data, {isCache: true});\n                } else if (obj.cache == true) {\n                    typeof obj.success === \"function\" && obj.success(res.data, {isCache: true});\n                }\n                typeof obj.complete === \"function\" && obj.complete();\n                // 成功取出缓存，还要去请求拿最新的再存起来\n                callback(obj);\n            },\n            fail: function() {\n                // 找不到缓存，直接发起请求，且不再防止页面闪烁（本来就没缓存了，更不存在更新页面导致的闪烁）\n                obj.noCacheFlash = false;\n                callback(obj);\n            }\n        })\n    } else {\n        callback(obj);\n    }\n}\n\nfunction login(callback) {\n    checkSession(callback, {})\n}\n\nfunction init(params) {\n    sessionName    = params.sessionName || 'session';\n    loginTrigger   = params.loginTrigger || function () {\n            return false\n        };\n    codeToSession  = params.codeToSession || {};\n    successTrigger = params.successTrigger || function () {\n            return true\n        };\n    urlPerfix      = params.urlPerfix || \"\";\n    successData    = params.successData || function (res) {\n            return res\n        };\n    errorTitle     = params.errorTitle || \"操作失败\";\n    errorContent   = params.errorContent || false;\n    reLoginLimit   = params.reLoginLimit || 3;\n    errorCallback  = params.errorCallback || null;\n    sessionIsFresh = params.doNotCheckSession || false;\n    reportCGI      = params.reportCGI || false;\n    mockJson       = params.mockJson || false;\n    globalData     = params.globalData || false;\n    sessionExpireTime = params.sessionExpireTime || null;\n    sessionExpireKey = params.sessionExpireKey || \"sessionExpireKey\";\n\n    try {\n        session = wx.getStorageSync(sessionName) || '';\n        sessionExpire = wx.getStorageSync(sessionExpireKey) || Infinity;\n        // 如果有设置本地session过期时间，且验证已过期，则直接清空session\n        if(new Date().getTime() > sessionExpire) {\n            session = '';\n        }\n    } catch (e) {\n    }\n}\n\nfunction requestWrapper(obj) {\n    obj = preDo(obj);\n    if (mockJson && mockJson[obj.url]) {\n        // mock 模式\n        mock(obj);\n    } else {\n        getCache(obj, function (obj) {\n                checkSession(function () {\n                    request(obj);\n                }, obj)\n            }\n        )\n    }\n}\n\nfunction uploadFileWrapper(obj) {\n    obj = preDo(obj);\n    checkSession(function () {\n        uploadFile(obj);\n    }, obj)\n}\n\nfunction setSession(s) {\n    session        = s;\n    sessionIsFresh = true;\n}\n\nfunction mock(obj) {\n    var res = {\n        data: mockJson[obj.url]\n    };\n    if (successTrigger(res.data) && typeof obj.success === \"function\") {\n        // 接口返回成功码\n        obj.success(successData(res.data));\n    } else {\n        // 接口返回失败码\n        fail(obj, res);\n    }\n    if (typeof obj.complete === \"function\") {\n        obj.complete();\n    }\n}\n\nfunction getSession() {\n    return session;\n}\n\nfunction getConfig() {\n    return {\n        urlPerfix: urlPerfix,\n        sessionExpireTime: sessionExpireTime,\n        sessionExpireKey: sessionExpireKey,\n        sessionExpire: sessionExpire\n    }\n}\n\nmodule.exports = {\n    init: init,\n    request: requestWrapper,\n    uploadFile: uploadFileWrapper,\n    setSession: setSession,\n    login: login,\n    getSession: getSession,\n    getConfig: getConfig\n};\n"],"sourceRoot":""} \ No newline at end of file diff --git a/build/weRequest.min.js b/build/weRequest.min.js index 6962df9..4eb64eb 100644 --- a/build/weRequest.min.js +++ b/build/weRequest.min.js @@ -1 +1 @@ -module.exports=function(e){var t={};function n(o){if(t[o])return t[o].exports;var i=t[o]={i:o,l:!1,exports:{}};return e[o].call(i.exports,i,i.exports,n),i.l=!0,i.exports}return n.m=e,n.c=t,n.d=function(e,t,o){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:o})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var o=Object.create(null);if(n.r(o),Object.defineProperty(o,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var i in e)n.d(o,i,function(t){return e[t]}.bind(null,i));return o},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=0)}([function(e,t,n){const o=n(1),i=n(2);var c="session",r=function(){return!1},a={},u=function(){return!0},f="",s=function(e){return e},l="操作失败",d=function(e){return e},p=3,m=null,g=!1,h=!1,y=!1,w="",T=!1,S=!1,x=!1;function v(e,t){x?i.wait("checkSessionFinished",function(){v(e,t)}):!T&&w?(x=!0,t.count++,t._checkSessionStartTime=(new Date).getTime(),console.log("wx.checkSession"),wx.checkSession({success:function(){T=!0},fail:function(){w=""},complete:function(){x=!1,t.count--,t._checkSessionEndTime=(new Date).getTime(),"function"==typeof g&&g("wx_checkSession",t._checkSessionStartTime,t._checkSessionEndTime,_),L(e,t),i.emit("checkSessionFinished")}})):L(e,t)}function L(e,t){w||t.isLogin?"function"==typeof e&&e():S?i.wait("doLoginFinished",function(){L(e,t)}):(S=!0,t.count++,t._loginStartTime=(new Date).getTime(),console.log("wx.login"),wx.login({complete:function(){t.count--,t._loginEndTime=(new Date).getTime(),"function"==typeof g&&g("wx_login",t._loginStartTime,t._loginEndTime,_),"function"==typeof t.complete&&0==t.count&&t.complete()},success:function(n){var o;n.code?((o="function"==typeof a.data?a.data():a.data||{})[a.codeName]=n.code,t.count++,D({url:a.url,data:o,method:a.method,isLogin:!0,report:a.report||a.url,success:function(t){w=t,T=!0,"function"==typeof e&&e(),wx.setStorage({key:c,data:w})},complete:function(){t.count--,"function"==typeof t.complete&&0==t.count&&t.complete(),S=!1,i.emit("doLoginFinished")},fail:a.fail||null})):(k(t,n),console.error(n),S=!1,i.emit("doLoginFinished"))},fail:function(e){k(t,e),console.error(e),S=!1,i.emit("doLoginFinished")}}))}function b(e){return"function"==typeof e.beforeSend&&e.beforeSend(),void 0===e.reLoginLimit?e.reLoginLimit=0:e.reLoginLimit++,void 0===e.count&&(e.count=0),e.showLoading&&(o.show(e.showLoading),e.complete=function(e){return function(){o.hide(),"function"==typeof e&&e.apply(this,arguments)}}(e.complete)),e}function _(e){e.count++,e.data||(e.data={}),e.url!=a.url&&w&&(e.data[c]=w);var t={};"function"==typeof y?t=y():"object"==typeof y&&(t=y),e.data=Object.assign({},t,e.data),e.method=e.method||"GET";var n=e.url.startsWith("http")?e.url:f+e.url;if("GET"!=e.method)for(var o in w&&(n.indexOf("?")>=0?n+="&"+c+"="+encodeURIComponent(w):n+="?"+c+"="+encodeURIComponent(w)),t)n.indexOf("?")>=0?n+="&"+o+"="+t[o]:n+="?"+o+"="+t[o];e.report&&(e._reportStartTime=(new Date).getTime()),wx.request({url:n,data:e.data,method:e.method,header:e.header||{},dataType:e.dataType||"json",success:function(t){if(200==t.statusCode)if(e.report&&"function"==typeof g&&(e._reportEndTime=(new Date).getTime(),g(e.report,e._reportStartTime,e._reportEndTime,_)),e.isLogin){var n="";try{n=a.success(t.data)}catch(e){}n?e.success(n):k(e,t)}else if(r(t.data)&&e.reLoginLimit=0?n+="&"+c+"="+w:n+="?"+c+"="+w),t)n.indexOf("?")>=0?n+="&"+o+"="+t[o]:n+="?"+o+"="+t[o];e.report&&(e._reportStartTime=(new Date).getTime()),wx.uploadFile({url:n,filePath:e.filePath||"",name:e.name||"",formData:e.formData,success:function(t){if(200==t.statusCode&&"uploadFile:ok"==t.errMsg){if(e.report&&"function"==typeof g&&(e.endTime=(new Date).getTime(),g(e.report,e._reportStartTime,e._reportEndTime,_)),"json"==e.dataType)try{t.data=JSON.parse(t.data)}catch(n){return k(e,t),!1}r(t.data)&&e.reLoginLimitx?(S="",D(e,t)):"function"==typeof e&&e():L?i.wait("doLoginFinished",function(){D(e,t)}):(L=!0,t.count++,t._loginStartTime=(new Date).getTime(),console.log("wx.login"),wx.login({complete:function(){t.count--,t._loginEndTime=(new Date).getTime(),"function"==typeof g&&g("wx_login",t._loginStartTime,t._loginEndTime,E),"function"==typeof t.complete&&0==t.count&&t.complete()},success:function(n){var o;n.code?((o="function"==typeof a.data?a.data():a.data||{})[a.codeName]=n.code,t.count++,C({url:a.url,data:o,method:a.method,isLogin:!0,report:a.report||a.url,success:function(t){S=t,v=!0,w&&(x=(new Date).getTime()+w,wx.setStorage({key:T,data:x})),"function"==typeof e&&e(),wx.setStorage({key:c,data:S})},complete:function(){t.count--,"function"==typeof t.complete&&0==t.count&&t.complete(),L=!1,i.emit("doLoginFinished")},fail:a.fail||null})):(j(t,n),console.error(n),L=!1,i.emit("doLoginFinished"))},fail:function(e){j(t,e),console.error(e),L=!1,i.emit("doLoginFinished")}}))}function k(e){return"function"==typeof e.beforeSend&&e.beforeSend(),void 0===e.reLoginLimit?e.reLoginLimit=0:e.reLoginLimit++,void 0===e.count&&(e.count=0),e.showLoading&&(o.show(e.showLoading),e.complete=function(e){return function(){o.hide(),"function"==typeof e&&e.apply(this,arguments)}}(e.complete)),e}function E(e){e.count++,e.data||(e.data={}),e.url!=a.url&&S&&(e.data[c]=S);var t={};"function"==typeof h?t=h():"object"==typeof h&&(t=h),e.data=Object.assign({},t,e.data),e.method=e.method||"GET";var n=e.url.startsWith("http")?e.url:u+e.url;if("GET"!=e.method)for(var o in S&&(n.indexOf("?")>=0?n+="&"+c+"="+encodeURIComponent(S):n+="?"+c+"="+encodeURIComponent(S)),t)n.indexOf("?")>=0?n+="&"+o+"="+t[o]:n+="?"+o+"="+t[o];e.report&&(e._reportStartTime=(new Date).getTime()),wx.request({url:n,data:e.data,method:e.method,header:e.header||{},dataType:e.dataType||"json",success:function(t){if(200==t.statusCode)if(e.report&&"function"==typeof g&&(e._reportEndTime=(new Date).getTime(),g(e.report,e._reportStartTime,e._reportEndTime,E)),e.isLogin){var n="";try{n=a.success(t.data)}catch(e){}n?e.success(n):j(e,t)}else if(r(t.data)&&e.reLoginLimit=0?n+="&"+c+"="+S:n+="?"+c+"="+S),t)n.indexOf("?")>=0?n+="&"+o+"="+t[o]:n+="?"+o+"="+t[o];e.report&&(e._reportStartTime=(new Date).getTime()),wx.uploadFile({url:n,filePath:e.filePath||"",name:e.name||"",formData:e.formData,success:function(t){if(200==t.statusCode&&"uploadFile:ok"==t.errMsg){if(e.report&&"function"==typeof g&&(e.endTime=(new Date).getTime(),g(e.report,e._reportStartTime,e._reportEndTime,E)),"json"==e.dataType)try{t.data=JSON.parse(t.data)}catch(n){return j(e,t),!1}r(t.data)&&e.reLoginLimitx&&(S="")}catch(e){}},request:C,uploadFile:O,setSession:function(e){S=e,v=!0},login:function(e){_(e,{})},getSession:function(){return S},getConfig:function(){return{urlPerfix:u,sessionExpireTime:w,sessionExpireKey:T,sessionExpire:x}}}},function(e,t){e.exports={show:function(e){wx.showToast({title:"boolean"==typeof e?"加载中":e,icon:"loading",mask:!0,duration:6e4})},hide:function(){wx.hideToast()}}},function(e,t){var n={};function o(e){return n[e]||(n[e]={waitingList:[]}),n[e]}e.exports={wait:function(e,t){o(e).waitingList.push(t)},emit:function(e){var t=o(e);console.log("waitingList Length: "+t.waitingList.length);for(var n=t.waitingList.length,i=0;i sessionExpire) { + // 如果有设置本地session缓存时间，且缓存时间已到 + session = ''; + doLogin(callback, obj); + } else { + typeof callback === "function" && callback(); + } } else if (logining) { // 正在登录中，请求轮询稍后，避免重复调用登录接口 flow.wait('doLoginFinished', function () { @@ -117,6 +132,14 @@ function doLogin(callback, obj) { success: function (s) { session = s; sessionIsFresh = true; + // 如果有设置本地session过期时间 + if(sessionExpireTime) { + sessionExpire = new Date().getTime() + sessionExpireTime; + wx.setStorage({ + key: sessionExpireKey, + data: sessionExpire + }) + } typeof callback === "function" && callback(); wx.setStorage({ key: sessionName, @@ -492,9 +515,16 @@ function init(params) { reportCGI = params.reportCGI || false; mockJson = params.mockJson || false; globalData = params.globalData || false; + sessionExpireTime = params.sessionExpireTime || null; + sessionExpireKey = params.sessionExpireKey || "sessionExpireKey"; try { session = wx.getStorageSync(sessionName) || ''; + sessionExpire = wx.getStorageSync(sessionExpireKey) || Infinity; + // 如果有设置本地session过期时间，且验证已过期，则直接清空session + if(new Date().getTime() > sessionExpire) { + session = ''; + } } catch (e) { } } @@ -548,7 +578,10 @@ function getSession() { function getConfig() { return { - 'urlPerfix': urlPerfix + urlPerfix: urlPerfix, + sessionExpireTime: sessionExpireTime, + sessionExpireKey: sessionExpireKey, + sessionExpire: sessionExpire } } @@ -560,4 +593,4 @@ module.exports = { login: login, getSession: getSession, getConfig: getConfig -}; \ No newline at end of file +};