vesh/com/coooders/Project/VESH/V/Control/session.js

码农nodejs版本VESH框架，使用函数责任链模式 实现了 默认文件跳转，自定义错误页，空文件处理，URL解析，Querystring与Form参数解析，PostFiles解析，MVC自动映射，SQL自动服务化，可继承页面,静态文件，json,tjson,jsonp,tjsonp,string,void,xjson,xjosnp等等6种JSON格式,http与https等等操作

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SessionDataAdapter = exports.NoStoreSessionSource = exports.NiSessionSource = exports.SecuritySessionSourceDecorator = exports.CookieSessionSource = exports.ConstSessionSource = exports.ASessionSource = exports.SessionDataManager = exports.SessionDataManagerFactory = exports.CreateID = exports.User = exports.SessionData = undefined;

var _regenerator = require("babel-runtime/regenerator");

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require("babel-runtime/helpers/asyncToGenerator");

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _get2 = require("babel-runtime/helpers/get");

var _get3 = _interopRequireDefault(_get2);

var _inherits2 = require("babel-runtime/helpers/inherits");

var _inherits3 = _interopRequireDefault(_inherits2);

var _typeof2 = require("babel-runtime/helpers/typeof");

var _typeof3 = _interopRequireDefault(_typeof2);

var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require("babel-runtime/helpers/createClass");

var _createClass3 = _interopRequireDefault(_createClass2);

var _gcl = require("gcl");

var _gcl2 = _interopRequireDefault(_gcl);

var _zlib = require("zlib");

var _zlib2 = _interopRequireDefault(_zlib);

var _config = require("gcl/com/coooders/io/config");

var _config2 = _interopRequireDefault(_config);

var _cookie = require("gcl/com/coooders/net/cookie");

var _cookie2 = _interopRequireDefault(_cookie);

var _mime = require("gcl/com/coooders/net/mime");

var _ni = require("gcl/com/coooders/db/ni");

var _ni2 = _interopRequireDefault(_ni);

var _querystring = require("querystring");

var _querystring2 = _interopRequireDefault(_querystring);

var _nodeXlsx = require("node-xlsx");

var _nodeXlsx2 = _interopRequireDefault(_nodeXlsx);

var _ws = require("ws");

var _ws2 = _interopRequireDefault(_ws);

var _tool = require("gcl/com/coooders/common/tool");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * session:VESH V层会话管理器删除会话信息
 */
var SessionData = exports.SessionData = function () {
  function SessionData(id, name) {
    (0, _classCallCheck3.default)(this, SessionData);

    var _pri = pri(this, {
      name: name,
      idic: {},
      isClear: false,
      isClearCache: false,
      id: id,
      manager: null
    }),
        _ = _pri._,
        __ = _pri.__;
  }

  (0, _createClass3.default)(SessionData, [{
    key: "clear",
    value: function clear() {
      var _pri2 = pri(this),
          _ = _pri2._,
          __ = _pri2.__;

      __.isClear = true;
      __.idic = {};
    }
  }, {
    key: "clearCache",
    value: function clearCache() {
      var _pri3 = pri(this),
          _ = _pri3._,
          __ = _pri3.__;

      __.isClearCache = true;
    }
  }, {
    key: "data",
    value: function data(k, v) {
      var _pri4 = pri(this),
          _ = _pri4._,
          __ = _pri4.__;

      if (typeof v != "undefined") __.idic[k] = v;else return __.idic[k];
    }
  }, {
    key: "remove",
    value: function remove(k) {
      var _pri5 = pri(this),
          _ = _pri5._,
          __ = _pri5.__;

      delete __.idic[k];
    }
  }, {
    key: "serialize",
    value: function serialize() {
      var _pri6 = pri(this),
          _ = _pri6._,
          __ = _pri6.__;

      return _gcl2.default.merge({}, __.idic);
    }
  }, {
    key: "toString",
    value: function toString() {
      return _gcl2.default.toJsonString(this.serialize());
    }
  }, {
    key: "deserialize",
    value: function deserialize(data, clear) {
      var _pri7 = pri(this),
          _ = _pri7._,
          __ = _pri7.__;

      if (clear) __.idic = {};
      if (data && data.split) {
        var _data = _querystring2.default.parse(data);
        for (var i in _data) {
          if (typeof _data[i] != "function") __.idic[i] = _data[i];
        }
      } else if ((typeof data === "undefined" ? "undefined" : (0, _typeof3.default)(data)) == "object") _gcl2.default.merge(__.idic, data, true);
      return;
    }
  }, {
    key: "dispose",
    value: function dispose() {
      clear();
    }
  }, {
    key: "SessionID",
    get: function get() {
      var _pri8 = pri(this),
          _ = _pri8._,
          __ = _pri8.__;

      return __.id;
    },
    set: function set(id) {
      var _pri9 = pri(this),
          _ = _pri9._,
          __ = _pri9.__;

      if (__.id && __.id != id) throw new Error("SessionID 只能设置一次");
      __.id = id;
    }
  }, {
    key: "Name",
    get: function get() {
      var _pri10 = pri(this),
          _ = _pri10._,
          __ = _pri10.__;

      return __.name;
    }
  }, {
    key: "IsClear",
    get: function get() {
      var _pri11 = pri(this),
          _ = _pri11._,
          __ = _pri11.__;

      return __.isClear;
    }
  }, {
    key: "IsClearCache",
    get: function get() {
      var _pri12 = pri(this),
          _ = _pri12._,
          __ = _pri12.__;

      return __.isClearCache;
    }
  }, {
    key: "Manager",
    get: function get() {
      var _pri13 = pri(this),
          _ = _pri13._,
          __ = _pri13.__;

      return __.manager;
    },
    set: function set(sdm) {
      var _pri14 = pri(this),
          _ = _pri14._,
          __ = _pri14.__;

      if (__.manager) throw new Error("manager 只能设置一次");
      __.manager = sdm;
    }
  }]);
  return SessionData;
}();
var User = exports.User = function (_SessionData) {
  (0, _inherits3.default)(User, _SessionData);

  function User() {
    (0, _classCallCheck3.default)(this, User);
    return (0, _possibleConstructorReturn3.default)(this, (User.__proto__ || (0, _getPrototypeOf2.default)(User)).call(this, null, ".User"));
  }

  (0, _createClass3.default)(User, [{
    key: "serialize",
    value: function serialize() {
      var _pri15 = pri(this),
          _ = _pri15._,
          __ = _pri15.__,
          id = (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "SessionID", this);

      if (!_gcl2.default.isValid(id)) throw new Error("必须定义SessionID");
      if (_.Login) {
        if (!_gcl2.default.isValid(_.UserID)) throw new Error("必须定义UserID");
        this.LoginTime = new Date();
      }
      var ret = (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "serialize", this).call(this);
      if (this.LoginTime) ret["LT"] = this.LoginTime.getTime();
      ret[".ID"] = id;
      return ret;
    }
  }, {
    key: "deserialize",
    value: function deserialize(data, clear) {
      var _pri16 = pri(this),
          _ = _pri16._,
          __ = _pri16.__;

      (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "deserialize", this).call(this, data, clear);
      if (this.LoginTime) this.LoginTime = new Date(parseInt(this.LoginTime));
      if ((0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, ".ID") && _.SessionID && _.SessionID != _.data(".ID")) throw new Error("SessionID 不同！不能重复设置！");else _.SessionID = (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, ".ID");
      _.remove(".ID");
    }
  }, {
    key: "toString",
    value: function () {
      var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
        var _pri17, _, __, ret;

        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _pri17 = pri(this), _ = _pri17._, __ = _pri17.__;
                ret = this.serialize();

                delete ret[".ID"];
                delete ret["UID"];
                delete ret["SID"];
                delete ret["EID"];
                delete ret["LT"];
                delete ret["lin"];
                ret.UserID = this.UserID;
                ret.SessionID = this.SessionID;
                ret.EntityID = this.EntityID;
                ret.SystemID = this.SystemID;
                ret.LoginTime = this.LoginTime;
                ret.Login = this.Login;

                if (!_.Manager) {
                  _context.next = 27;
                  break;
                }

                _context.next = 17;
                return _.Manager.EIDS.get();

              case 17:
                ret.EIDS = _context.sent;
                _context.next = 20;
                return _.Manager.MEIDS.get();

              case 20:
                ret.MEIDS = _context.sent;
                _context.next = 23;
                return _.Manager.Permission.get();

              case 23:
                ret.PIDS = _context.sent;
                _context.next = 26;
                return _.Manager.MENUS.get();

              case 26:
                ret.MENUS = _context.sent;

              case 27:
                return _context.abrupt("return", _gcl2.default.toJsonString(ret));

              case 28:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function toString() {
        return _ref.apply(this, arguments);
      }

      return toString;
    }()
  }, {
    key: "Login",
    get: function get() {
      return (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "lin") == 1;
    },
    set: function set(v) {
      var _pri18 = pri(this),
          _ = _pri18._,
          __ = _pri18.__;

      if (v != this.Login) {
        (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "lin", v ? 1 : 0);
        if (v) {
          _.LoginTime = new Date();
        } else {
          (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "clear", this).call(this);
          _.Manager.EIDS.clear();
          _.Manager.MEIDS.clear();
          _.Manager.MENUS.clear();
          _.Manager.Permission.clear();
        }
      }
    }
  }, {
    key: "UserID",
    get: function get() {
      return (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "UID");
    },
    set: function set(v) {
      (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "UID", v);
    }
  }, {
    key: "SystemID",
    get: function get() {
      return (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "SID");
    },
    set: function set(v) {
      (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "SID", v);
    }
  }, {
    key: "EntityID",
    get: function get() {
      return (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "EID");
    },
    set: function set(v) {
      (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "EID", v);
    }
  }, {
    key: "LoginTime",
    get: function get() {
      return (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "LT");
    },
    set: function set(v) {
      (0, _get3.default)(User.prototype.__proto__ || (0, _getPrototypeOf2.default)(User.prototype), "data", this).call(this, "LT", v);
    }
  }]);
  return User;
}(SessionData);
var CreateID = exports.CreateID = function CreateID() {
  return (0, _tool.GUID)();
};
var SessionDataManagerFactory = exports.SessionDataManagerFactory = function () {
  function SessionDataManagerFactory(adapter, security, language) {
    (0, _classCallCheck3.default)(this, SessionDataManagerFactory);

    pri(this, { adapter: adapter, security: security, language: language });
  }

  (0, _createClass3.default)(SessionDataManagerFactory, [{
    key: "getValue",
    value: function getValue() {
      var _pri19 = pri(this),
          _ = _pri19._,
          __ = _pri19.__;

      return new SessionDataManager(__.adapter, __.security, __.language);
    }
  }, {
    key: "setValue",
    value: function setValue(sdm) {
      if (sdm && sdm.dispose) sdm.dispose();
    }
  }]);
  return SessionDataManagerFactory;
}();
/**
 * SessionDataManager:会话管理 每次请求都会新建一个会话管理用于管理这个会话上下文,改造为prototype模式以方面快速new
 */
var SessionDataManager = exports.SessionDataManager = function () {
  function SessionDataManager(adapter, passtime, language) {
    var _this2 = this;

    (0, _classCallCheck3.default)(this, SessionDataManager);

    this.testRequired = function (key, error) {
      _gcl2.default.testRequired(_this2.param(key), error || "\u9650\u5236" + key + "\u8981\u6C42\u4E3A\u5FC5\u586B");
      return _this2.param(key);
    };

    this.testRequired = function (key, error) {
      _gcl2.default.testRequired(_this2.param(key), error || "\u9650\u5236" + key + "\u8981\u6C42\u4E3A\u5FC5\u586B");
      return _this2.param(key);
    };

    var _pri20 = pri(this, {
      adapter: adapter,
      passtime: passtime || 8,
      lang: language,
      idic: {},
      user: new User(),
      wxuser: null,
      end: false,
      sb: _gcl2.default.sb(),
      streams: []
    }),
        _ = _pri20._,
        __ = _pri20.__;

    __.user.Manager = _;
    this.status = "";
    this.encoding = "UTF-8";
  }

  /**
   * 最重要的属性 用于决定是否结束moduler链的处理
   */


  (0, _createClass3.default)(SessionDataManager, [{
    key: "end",
    value: function end(statusCode, desc) {
      var _pri21 = pri(this),
          _ = _pri21._,
          __ = _pri21.__;

      __.end = true;
      if (__.interrupt) {
        desc && (this.status = desc);
        return;
      }
      this.Response.statusCode = statusCode;
      if (desc) _.write(desc, null, true);
    }
  }, {
    key: "redirect",


    /**
     * @param {重定向URL} url
     */
    value: function redirect(url) {
      var _pri22 = pri(this),
          _ = _pri22._,
          __ = _pri22.__;

      __.end = true;
      if (__.interrupt) return;
      this.Response.statusCode = 302;
      this.Response.setHeader("Location", url);
    }

    /**
     *
     * @param {gcl config对象} config
     * @param {gcl middler对象} middler
     * @param {gcl log对象} log
     * @param {gcl ni对象} ni
     * @param {node req对象} req
     * @param {node rep对象} rep
     */

  }, {
    key: "init",
    value: function init(config, middler, log, ni, req, rep, wsSessionIdic) {
      var _pri23 = pri(this, { config: config, middler: middler, log: log, ni: ni, req: req, rep: rep }),
          _ = _pri23._,
          __ = _pri23.__;

      _.WSSessionMap = wsSessionIdic;
    }

    /**
     * 重新初始化会话纤细
     * @param {会话ID} sessionID
     */

  }, {
    key: "reInit",
    value: function reInit(sessionID) {
      var _pri24 = pri(this),
          _ = _pri24._,
          __ = _pri24.__;

      for (var k in __) {
        switch (k) {
          case "adapter":
          case "config":
          case "middler":
          case "log":
          case "ni":
          case "req":
          case "rep":
          case "lang":
          case "passtime":
            break;
          default:
            delete __[k];
            break;
        }
      }var user = new User();
      user.SessionID = sessionID;
      user.Manager = _;
      __.user = user;
      __.idic = {};
      __.end = false;
      __.sb = _gcl2.default.sb();
      __.streams = [];
    }

    /**
     * 不能和init一起运行，因为init运行时没有Cookie等信息
     */

  }, {
    key: "initSession",
    value: function () {
      var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(ID) {
        var _pri25, _, __;

        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _pri25 = pri(this), _ = _pri25._, __ = _pri25.__;
                _context2.next = 3;
                return __.adapter.fillSessionData(__.user);

              case 3:
                if (!__.user.SessionID) __.user.SessionID = ID || CreateID();
                if (__.user.Login && (!__.user.LoginTime || new Date().sub("h", __.user.LoginTime) >= __.passtime)) __.user.Login = false;

              case 5:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function initSession(_x) {
        return _ref2.apply(this, arguments);
      }

      return initSession;
    }()

    /**
     *
     * @param {文件路径} file
     */

  }, {
    key: "map",
    value: function map(file) {
      //需要知道__dirname;
    }
  }, {
    key: "write",
    value: function write(data, encoding) {
      var clear = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

      var _pri26 = pri(this),
          _ = _pri26._,
          __ = _pri26.__;

      _.encoding = encoding || _.encoding;
      if (clear) __.sb.clear();
      __.sb.append(data);
    }
  }, {
    key: "clearWrite",
    value: function clearWrite() {
      var _pri27 = pri(this),
          _ = _pri27._,
          __ = _pri27.__;

      __.sb.clear();
    }
  }, {
    key: "writeStream",
    value: function writeStream(stream) {
      var _pri28 = pri(this),
          _ = _pri28._,
          __ = _pri28.__;

      __.streams.push(stream);
    }

    /**
     * 用于生成符合结构的dbresult;
     * @param {Object/Array} obj
     */

  }, {
    key: "exportDBResult",
    value: function () {
      var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3() {
        var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var dbresult, _obj, level;

        return _regenerator2.default.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                dbresult = obj;
                _obj = obj, level = 0;

                while (_gcl2.default.isArray(_obj || {})) {
                  //开始剥葱
                  _obj = _obj[0];
                  level++;
                }
                while (level++ < 3) {
                  dbresult = [dbresult];
                }this.dbresult = dbresult;

              case 5:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function exportDBResult() {
        return _ref3.apply(this, arguments);
      }

      return exportDBResult;
    }()

    /**
     * 用于生成返回的string
     * @param {Object/Array/Error} obj
     */

  }, {
    key: "exportString",
    value: function () {
      var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4() {
        var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        var iserror;
        return _regenerator2.default.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                iserror = obj.toString().startsWith("Error");

                this.status = typeof obj == "string" ? obj : _gcl2.default.toJsonString([[[iserror ? {
                  success: false,
                  error: obj.message || obj.err_msg || obj.errmsg
                } : {
                  success: true,
                  data: _gcl2.default.isArray(obj) ? obj : [obj]
                }]]]);

              case 2:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function exportString() {
        return _ref4.apply(this, arguments);
      }

      return exportString;
    }()

    /**
     * 导出文件
     * @param {流或者Buffer} obj
     * @param {附件文件名} name
     */

  }, {
    key: "exportFile",
    value: function () {
      var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(obj, name) {
        var _pri29, _, __, stream;

        return _regenerator2.default.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                _pri29 = pri(this), _ = _pri29._, __ = _pri29.__;

                if (!__.interrupt) {
                  _context5.next = 3;
                  break;
                }

                return _context5.abrupt("return");

              case 3:
                this.Response.setHeader("content-type", (0, _mime.get)(name));
                this.Response.setHeader("Content-Disposition", encodeURI("attachment;filename=" + name));
                if (typeof obj == "string") _.write(obj, "utf-8");else if (obj.on) _.writeStream(obj);else {
                  //_.getResponseStream.write(obj);
                  stream = new _gcl2.default.ArrayStream();

                  stream.write(obj);
                  _.writeStream(stream);
                }

              case 6:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function exportFile(_x5, _x6) {
        return _ref5.apply(this, arguments);
      }

      return exportFile;
    }()

    /**
     * 导出文件
     * @param {[[name,name],[value,value],[value,value]]} obj
     * @param {附件文件名} name
     */

  }, {
    key: "exportExcel",
    value: function () {
      var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(db, name) {
        var count, _db, i, buffer;

        return _regenerator2.default.wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                count = 0, _db = db, i = 0;

                while (_gcl2.default.isArray(_db[0])) {
                  _db = _db[0];
                  count++;
                }
                count == 1 && (db = [db]); //1维要升级成2维
                count == 0 && (db = [[]]);
                i = 0;
                buffer = _nodeXlsx2.default.build(db.map(function (v) {
                  return {
                    name: "sheet" + ++i,
                    data: v
                  };
                }));
                // console.log(350,name);

                _context6.next = 8;
                return this.exportFile(buffer, name);

              case 8:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function exportExcel(_x7, _x8) {
        return _ref6.apply(this, arguments);
      }

      return exportExcel;
    }()
  }, {
    key: "clearStream",
    value: function clearStream() {
      var _pri30 = pri(this),
          _ = _pri30._,
          __ = _pri30.__;

      var ret = __.streams;
      __.streams = [];
      return ret;
    }
  }, {
    key: "getResponseStream",
    value: function getResponseStream() {
      var _pri31 = pri(this),
          _ = _pri31._,
          __ = _pri31.__;

      if (__.interrupt) return;
      return __.stream || function () {
        var encodings = (__.req.headers["vesh-encoding"] || __.req.headers["accept-encoding-vesh"] || __.req.headers["accept-encoding"] || "text/plain").replace(/\s/g, "").split(",").filter(function (v) {
          return _gcl2.default.isValid(v);
        }),
            stream = null;
        for (var i = 0; i < encodings.length; i++) {
          var v = encodings[i];
          //todo 因为gzip和deflate导致发送压缩计算 影响速度
          switch (v.toLowerCase()) {
            case "gzip":
              _.Response.setHeader("content-encoding", "gzip");
              stream = _zlib2.default.createGzip();
              stream.pipe(_.Response);
              __.stream = stream;
              return __.stream;
            case "deflate":
              _.Response.setHeader("content-encoding", "deflate");
              stream = _zlib2.default.Deflate();
              stream.pipe(_.Response);
              __.stream = stream;
              return __.stream;
            case "ws":
            case "mqtt":
              return _.Response;
          }
        }
        //_.Response.setHeader("content-encoding", "text/plain");
        __.stream = _.Response;
        return __.stream;
      }();
    }
  }, {
    key: "flush",
    value: function () {
      var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7() {
        var _pri32, _, __, st, stream;

        return _regenerator2.default.wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                _pri32 = pri(this), _ = _pri32._, __ = _pri32.__;

                if (!__.interrupt) {
                  _context7.next = 3;
                  break;
                }

                return _context7.abrupt("return", false);

              case 3:
                if (!(__.sb && __.sb.length > 0)) {
                  _context7.next = 10;
                  break;
                }

                st = _.getResponseStream();
                //console.log(394, __.interrupt, __.sb && __.sb.toString(), __.streams && __.streams.length);

                _context7.next = 7;
                return _gcl2.default.callback(function (call) {
                  return st.end(__.sb.clear(), _.encoding, call);
                });

              case 7:
                return _context7.abrupt("return", false);

              case 10:
                if (!(__.streams && __.streams.length > 0)) {
                  _context7.next = 17;
                  break;
                }

                stream = _.getResponseStream();
                _context7.next = 14;
                return _gcl2.default.each(__.streams, function (v, next) {
                  v.on("error", function (err) {
                    __.log.error("VESH:" + err.stack);
                    next();
                  });
                  v.on("end", next);
                  //写入文件
                  v.pipe(stream, { end: false });
                }).then(function () {
                  return _gcl2.default.callback(function (call) {
                    _.Response.on("finish", function (err) {
                      if (err) call(err);
                      _.Response.removeAllListeners("finish");
                      _.Response.end();
                      call(null, true);
                    });
                    __.stream.end();
                    __.streams = [];
                  });
                });

              case 14:
                return _context7.abrupt("return", false);

              case 17:
                if (!__.stream) {
                  _context7.next = 23;
                  break;
                }

                _context7.next = 20;
                return _gcl2.default.callback(function (call) {
                  _.Response.on("finish", function () {
                    _.Response.removeAllListeners("finish");
                    _.Response.end();
                    call();
                  });
                  __.stream.end();
                });

              case 20:
                return _context7.abrupt("return", false);

              case 23:
                return _context7.abrupt("return", true);

              case 24:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      function flush() {
        return _ref7.apply(this, arguments);
      }

      return flush;
    }()

    /**
     * 中止后续session操作 ，MSocket方法专用
     */

  }, {
    key: "interrupt",
    value: function () {
      var _ref8 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee8() {
        return _regenerator2.default.wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                pri(this, { interrupt: true });

              case 1:
              case "end":
                return _context8.stop();
            }
          }
        }, _callee8, this);
      }));

      function interrupt() {
        return _ref8.apply(this, arguments);
      }

      return interrupt;
    }()
  }, {
    key: "isInterrupt",
    value: function isInterrupt() {
      return !!pri(this).__.interrupt;
    }

    /**
     * 从QueryString和Form中获取数据
     * @param {从QueryString和Form中获取数据} k
     */

  }, {
    key: "param",
    value: function param(k) {
      var _pri33 = pri(this),
          _ = _pri33._,
          __ = _pri33.__;

      return k ? (_.querystring ? _.querystring[k] : null) || (_.form ? _.form[k] : null) : null;
    }
  }, {
    key: "send",


    /**
     * 主动下行其它SessionID 并返回下行成功的sessionID
     * @param {*} sessionIDs
     */
    value: function send(sessionIDs) {
      var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      var _pri34 = pri(this),
          _ = _pri34._,
          __ = _pri34.__;

      sessionIDs = _gcl2.default.isArray(sessionIDs) ? sessionIDs : typeof sessionIDs == "string" ? sessionIDs.split(",") : null;
      var rets = [];
      // console.log(623, sessionIDs, data);
      if (sessionIDs && _.WSSessionMap) {
        sessionIDs.map(function (id) {
          var client = _.WSSessionMap[id];
          if (client && client.readyState == _ws2.default.OPEN) {
            client.send(_gcl2.default.toJsonString(_gcl2.default.merge({
              event: "send",
              ID: _gcl2.default.SNOWID(),
              data: ""
            }, data)));
            rets.push(id);
          }
        });
      } else throw Error("不是webSocket会话!");
      return rets;
    }
  }, {
    key: "closeWS",
    value: function closeWS(id) {
      var _pri35 = pri(this),
          _ = _pri35._,
          __ = _pri35.__;

      if (id && _.WSSessionMap) {
        var client = _.WSSessionMap[id];
        try {
          client.close();
        } catch (e) {}
        delete _.WSSessionMap[id];
      }
    }
  }, {
    key: "AppSettings",
    value: function AppSettings(k) {
      var _pri36 = pri(this),
          _ = _pri36._,
          __ = _pri36.__;

      return _config2.default.AppSettings(__.config, k);
    }

    /**
     * 用户信息
     */

  }, {
    key: "hasRight",
    value: function () {
      var _ref9 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee9(key) {
        var value;
        return _regenerator2.default.wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                _context9.next = 2;
                return this.data(".Permissions");

              case 2:
                value = _context9.sent;

                if (!_gcl2.default.isArray(value.data(key))) {
                  _context9.next = 5;
                  break;
                }

                throw new Error(key + "\u7684\u6743\u9650\u503C\u91CD\u590D!");

              case 5:
                if (!(_gcl2.default.isValid(value) && value.data(key))) {
                  _context9.next = 11;
                  break;
                }

                _context9.next = 8;
                return this.Permission.hasRight(value.data(key));

              case 8:
                _context9.t0 = _context9.sent;
                _context9.next = 12;
                break;

              case 11:
                _context9.t0 = false;

              case 12:
                return _context9.abrupt("return", _context9.t0);

              case 13:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9, this);
      }));

      function hasRight(_x10) {
        return _ref9.apply(this, arguments);
      }

      return hasRight;
    }()
  }, {
    key: "data",
    value: function () {
      var _ref10 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee10(k) {
        var _pri37, _, __, _data2;

        return _regenerator2.default.wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                _pri37 = pri(this), _ = _pri37._, __ = _pri37.__;

                if (!(k.toLowerCase() == _.User.Name.toLowerCase())) {
                  _context10.next = 5;
                  break;
                }

                return _context10.abrupt("return", _.User);

              case 5:
                if (!__.idic[k]) {
                  _context10.next = 9;
                  break;
                }

                return _context10.abrupt("return", __.idic[k]);

              case 9:
                _context10.next = 11;
                return __.adapter.getSessionData(this, _.User.SessionID, k);

              case 11:
                _data2 = _context10.sent;

                __.idic[k] = _data2;
                return _context10.abrupt("return", __.idic[k]);

              case 14:
              case "end":
                return _context10.stop();
            }
          }
        }, _callee10, this);
      }));

      function data(_x11) {
        return _ref10.apply(this, arguments);
      }

      return data;
    }()
  }, {
    key: "update",
    value: function () {
      var _ref11 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee12() {
        var _this3 = this;

        var _pri38, _, __;

        return _regenerator2.default.wrap(function _callee12$(_context12) {
          while (1) {
            switch (_context12.prev = _context12.next) {
              case 0:
                _pri38 = pri(this), _ = _pri38._, __ = _pri38.__;

                if (_.isStatic) {
                  _context12.next = 11;
                  break;
                }

                _context12.next = 4;
                return _gcl2.default.forC(__.idic, function () {
                  var _ref12 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee11(k, v) {
                    return _regenerator2.default.wrap(function _callee11$(_context11) {
                      while (1) {
                        switch (_context11.prev = _context11.next) {
                          case 0:
                            if (!v.IsClear) {
                              _context11.next = 5;
                              break;
                            }

                            _context11.next = 3;
                            return __.adapter.clearSessionData(v);

                          case 3:
                            _context11.next = 7;
                            break;

                          case 5:
                            _context11.next = 7;
                            return __.adapter.saveSessionData(v);

                          case 7:
                            return _context11.abrupt("return", false);

                          case 8:
                          case "end":
                            return _context11.stop();
                        }
                      }
                    }, _callee11, _this3);
                  }));

                  return function (_x12, _x13) {
                    return _ref12.apply(this, arguments);
                  };
                }());

              case 4:
                if (!__.user.IsClear) {
                  _context12.next = 9;
                  break;
                }

                _context12.next = 7;
                return __.adapter.clearSessionData(__.user);

              case 7:
                _context12.next = 11;
                break;

              case 9:
                _context12.next = 11;
                return __.adapter.saveSessionData(__.user);

              case 11:
                return _context12.abrupt("return");

              case 12:
              case "end":
                return _context12.stop();
            }
          }
        }, _callee12, this);
      }));

      function update() {
        return _ref11.apply(this, arguments);
      }

      return update;
    }()
  }, {
    key: "dispose",
    value: function dispose() {
      var _pri39 = pri(this),
          _ = _pri39._,
          __ = _pri39.__;

      __.user.dispose();
      for (var k in __.idic) {
        __.idic[k].dispose();
      }
    }

    /**
     * 根据键值进行正则判断
     * @param {*} key
     * @param {*} regex
     * @param {*} error
     * @param {*} isRequire
     */

  }, {
    key: "testRegex",
    value: function testRegex(key, regex, error, isRequire) {
      _gcl2.default.testRegex(this.param(key), regex, error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是数字
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} isRequire
     */

  }, {
    key: "testNumber",
    value: function testNumber(key, error, isRequire) {
      _gcl2.default.testNumber(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是数字
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testInt",
    value: function testInt(key, error, isRequire) {
      _gcl2.default.testInt(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是字母
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testLetter",
    value: function testLetter(key, error, isRequire) {
      _gcl2.default.testLetter(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是数字
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testPassword",
    value: function testPassword(key, error, isRequire) {
      _gcl2.default.testPassword(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是非空必填
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testCard",


    /**
     * 限制参数满足是身份证
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */
    value: function testCard(key, error, isRequire) {
      _gcl2.default.testCard(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是手机号
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testMobile",
    value: function testMobile(key, error, isRequire) {
      _gcl2.default.testMobile(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是座机
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testPhone",
    value: function testPhone(key, error, isRequire) {
      _gcl2.default.testPhone(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是网络地址
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testUrl",
    value: function testUrl(key, error, isRequire) {
      _gcl2.default.testUrl(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是电子邮箱
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testEmail",
    value: function testEmail(key, error, isRequire) {
      _gcl2.default.testEmail(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是中文
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testChinese",
    value: function testChinese(key, error, isRequire) {
      _gcl2.default.testChinese(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是QQ
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testQQ",
    value: function testQQ(key, error, isRequire) {
      _gcl2.default.testQQ(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是邮政编码
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testZipCode",
    value: function testZipCode(key, error, isRequire) {
      _gcl2.default.testZipCode(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是IP
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testIP",
    value: function testIP(key, error, isRequire) {
      _gcl2.default.testIP(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是金额（2位小数）
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testCurreny",
    value: function testCurreny(key, error, isRequire) {
      _gcl2.default.testCurreny(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是数字
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} isRequire
     */

  }, {
    key: "testNumberOrNull",
    value: function testNumberOrNull(key, error, isRequire) {
      _gcl2.default.testNumberOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是数字
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testIntOrNull",
    value: function testIntOrNull(key, error, isRequire) {
      _gcl2.default.testIntOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是字母
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testLetterOrNull",
    value: function testLetterOrNull(key, error, isRequire) {
      _gcl2.default.testLetterOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是数字
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testPasswordOrNull",
    value: function testPasswordOrNull(key, error, isRequire) {
      _gcl2.default.testPasswordOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是非空必填
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testCardOrNull",


    /**
     * 限制参数满足是身份证
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */
    value: function testCardOrNull(key, error, isRequire) {
      _gcl2.default.testCardOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是手机号
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testMobileOrNull",
    value: function testMobileOrNull(key, error, isRequire) {
      _gcl2.default.testMobileOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是座机
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testPhoneOrNull",
    value: function testPhoneOrNull(key, error, isRequire) {
      _gcl2.default.testPhoneOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是网络地址
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testUrlOrNull",
    value: function testUrlOrNull(key, error, isRequire) {
      _gcl2.default.testUrlOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是电子邮箱
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testEmailOrNull",
    value: function testEmailOrNull(key, error, isRequire) {
      _gcl2.default.testEmailOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是中文
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testChineseOrNull",
    value: function testChineseOrNull(key, error, isRequire) {
      _gcl2.default.testChineseOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是QQ
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testQQOrNull",
    value: function testQQOrNull(key, error, isRequire) {
      _gcl2.default.testQQOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是邮政编码
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testZipCodeOrNull",
    value: function testZipCodeOrNull(key, error, isRequire) {
      _gcl2.default.testZipCodeOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是IP
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testIPOrNull",
    value: function testIPOrNull(key, error, isRequire) {
      _gcl2.default.testIPOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 限制参数满足是金额（2位小数）
     * @param {要判断的值} value
     * @param {错误说明} error
     * @param {是否必填} testRequire
     */

  }, {
    key: "testCurrenyOrNull",
    value: function testCurrenyOrNull(key, error, isRequire) {
      _gcl2.default.testCurrenyOrNull(this.param(key), error, key, isRequire);
      return this.param(key);
    }

    /**
     * 测试访问方法 多个为;号隔开
     */

  }, {
    key: "testMethod",
    value: function testMethod() {
      var methods = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "GET";

      var method = {};
      methods = methods.toUpperCase();
      methods.split(";").forEach(function (v) {
        return method[v] = true;
      });
      if (!method[this.Request.method]) {
        var e = new Error("限制的Method为" + methods);
        e.status = 401;
        throw e;
      }
      return true;
    }

    /**
     * 测试访问方法为GET
     */

  }, {
    key: "testGet",
    value: function testGet() {
      return this.testMethod("get");
    }

    /**
     * 测试访问方法为POST
     */

  }, {
    key: "testPost",
    value: function testPost() {
      return this.testMethod("post");
    }

    /**
     * 限制Restful几个方法
     */

  }, {
    key: "testRestful",
    value: function testRestful() {
      return this.testMethod("get;post;put;delete");
    }

    /**
     *
     * @param {权限名,号隔开} key
     * @param {错误说明} error
     */

  }, {
    key: "testPermission",
    value: function () {
      var _ref13 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee14(key, error) {
        var _this4 = this;

        var _pri40, _, __, val, e;

        return _regenerator2.default.wrap(function _callee14$(_context14) {
          while (1) {
            switch (_context14.prev = _context14.next) {
              case 0:
                _pri40 = pri(this), _ = _pri40._, __ = _pri40.__;
                val = false;
                _context14.next = 4;
                return _gcl2.default.each(key.split(","), function () {
                  var _ref14 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee13(v) {
                    return _regenerator2.default.wrap(function _callee13$(_context13) {
                      while (1) {
                        switch (_context13.prev = _context13.next) {
                          case 0:
                            _context13.t0 = val;

                            if (_context13.t0) {
                              _context13.next = 5;
                              break;
                            }

                            _context13.next = 4;
                            return _.hasRight(v);

                          case 4:
                            _context13.t0 = _context13.sent;

                          case 5:
                            val = _context13.t0;
                            return _context13.abrupt("return", false);

                          case 7:
                          case "end":
                            return _context13.stop();
                        }
                      }
                    }, _callee13, _this4);
                  }));

                  return function (_x17) {
                    return _ref14.apply(this, arguments);
                  };
                }(), true);

              case 4:
                if (val) {
                  _con