@lskjs/auth/Api/AuthApi.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.AuthApi = void 0;

var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));

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

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

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

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

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

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

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

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

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _env = require("@lskjs/env");

var _err = _interopRequireDefault(require("@lskjs/err"));

var _serverApi = _interopRequireDefault(require("@lskjs/server-api"));

var _canonizeParams = _interopRequireDefault(require("@lskjs/utils/canonizeParams"));

var _getReqOrigin = _interopRequireDefault(require("@lskjs/utils/getReqOrigin"));

var _transliterate = _interopRequireDefault(require("@lskjs/utils/transliterate"));

var _validateEmail = _interopRequireDefault(require("@lskjs/utils/validateEmail"));

var _bluebird = _interopRequireDefault(require("bluebird"));

var _get3 = _interopRequireDefault(require("lodash/get"));

var _map = _interopRequireDefault(require("lodash/map"));

var _merge = _interopRequireDefault(require("lodash/merge"));

var _omit = _interopRequireDefault(require("lodash/omit"));

var _random = _interopRequireDefault(require("lodash/random"));

var _set = _interopRequireDefault(require("lodash/set"));

var _unset = _interopRequireDefault(require("lodash/unset"));

var _excluded = ["password"];

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

var AuthApi = /*#__PURE__*/function (_BaseApi) {
  (0, _inherits2["default"])(AuthApi, _BaseApi);

  var _super = _createSuper(AuthApi);

  function AuthApi() {
    var _this;

    (0, _classCallCheck2["default"])(this, AuthApi);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = _super.call.apply(_super, [this].concat(args));
    _this.loginCreds = ['username', 'email', 'phone', 'login'];
    return _this;
  }

  (0, _createClass2["default"])(AuthApi, [{
    key: "init",
    value: function () {
      var _init = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return (0, _get2["default"])((0, _getPrototypeOf2["default"])(AuthApi.prototype), "init", this).call(this);

              case 2:
                _context.next = 4;
                return this.app.module('auth');

              case 4:
                this.authModule = _context.sent;
                this.helpers = this.authModule.helpers;

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

      function init() {
        return _init.apply(this, arguments);
      }

      return init;
    }()
  }, {
    key: "getRoutes",
    value: function getRoutes() {
      // const { isAuth } = this.app.middlewares;
      return _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(AuthApi.prototype), "getRoutes", this).call(this)), {}, {
        '/login': this.login.bind(this),
        '/signup': this.signup.bind(this),
        // POST
        '/updateToken': this.updateToken.bind(this),
        '/permit': this.getPermit.bind(this),
        // '/confirm': this.confirmPermit.bind(this),
        '/permit/confirm': this.confirmPermit.bind(this),
        // // '/loginToken': this.loginToken.bind(this),
        '/restorePassword': this.restorePassword.bind(this),
        // '/setPassword': this.setPassword.bind(this), => confirm
        // '/email/confirm': this.confirmEmail.bind(this), // (req, res) => res.redirect('/cabinet'));
        // '/phone/code': this.phoneCode.bind(this),
        // '/phone/approve': this.phoneApprove.bind(this), => confirm
        // '/phone/login': this.phoneLogin.bind(this),
        //
        '/status': this.status.bind(this),
        '/session': this.session.bind(this),
        '/check': this.check.bind(this),
        // Регистрация пользователя через соц сеть
        // '/social': this.getSocials.bind(this), // isAuth,
        // '/social/signup': this.socialLogin.bind(this),
        // '/social/login': this.socialLogin.bind(this),
        // '/social/bind': this.socialBind.bind(this), // Добавление соц.сетей к пользователю // isAuth,
        // '/social/unbind': this.socialUnbind.bind(this), // isAuth,
        // '/passport/getByToken': this.getPassportByToken.bind(this),
        // '/passports/detach': this.passportsDetach.bind(this),
        // '/restorePasswordPermit': this.restorePasswordPermit.bind(this),
        '/info': this.info.bind(this),
        // social auth init
        '/:provider': this.socialAuth.bind(this),
        '/:provider/auth': this.socialAuth.bind(this),
        '/:provider/callback': this.socialCallback.bind(this)
      });
    } // getRoutes() {
    //   return {
    //     '/login': this.login.bind(this),
    //     '/accountkit': this.accountkit.bind(this),
    //     '/facebook': this.facebook.bind(this),
    //     '/social': this.social.bind(this),
    //     // '/vkontakte': this.vkontakte.bind(this),
    //     '/phone': this.phoneOrEmail.bind(this),
    //     '/email': this.phoneOrEmail.bind(this),
    //     '/confirm': this.confirm.bind(this),
    //     '/status': this.status.bind(this),
    //     '/check': this.check.bind(this),
    //   };
    // }
    // async login() {
    //   return { asd: 12 };
    // }

  }, {
    key: "updateToken",
    value: function () {
      var _updateToken = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(req) {
        var UserModel, userId, user, token;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.app.module('models.UserModel');

              case 2:
                UserModel = _context2.sent;
                userId = req.user && req.user._id;

                if (userId) {
                  _context2.next = 6;
                  break;
                }

                throw new _err["default"]('auth.tokenIncorrect', {
                  status: 404
                });

              case 6:
                _context2.next = 8;
                return UserModel.findById(userId);

              case 8:
                user = _context2.sent;

                if (user) {
                  _context2.next = 11;
                  break;
                }

                throw new _err["default"]('auth.userNotFound', {
                  status: 404
                });

              case 11:
                req.user = user;
                token = this.helpers.generateAuthToken(user);
                _context2.next = 15;
                return UserModel.prepare(user, {
                  req: req,
                  withAppState: true
                });

              case 15:
                _context2.t0 = _context2.sent;
                _context2.t1 = token;
                return _context2.abrupt("return", {
                  user: _context2.t0,
                  token: _context2.t1
                });

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

      function updateToken(_x) {
        return _updateToken.apply(this, arguments);
      }

      return updateToken;
    }()
  }, {
    key: "status",
    value: function () {
      var _status = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                return _context3.abrupt("return", {});

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

      function status() {
        return _status.apply(this, arguments);
      }

      return status;
    }()
  }, {
    key: "session",
    value: function () {
      var _session = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(req) {
        var authModule;
        return _regenerator["default"].wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _context4.next = 2;
                return this.app.module('auth');

              case 2:
                authModule = _context4.sent;
                return _context4.abrupt("return", authModule.getAuthSession(req));

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

      function session(_x2) {
        return _session.apply(this, arguments);
      }

      return session;
    }()
  }, {
    key: "check",
    value: function () {
      var _check = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(req) {
        var criteria, UserModel, user;
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                criteria = (0, _canonizeParams["default"])(req.data);

                if (Object.keys(criteria)) {
                  _context5.next = 3;
                  break;
                }

                throw new _err["default"]('auth.loginRequired', {
                  status: 400
                });

              case 3:
                _context5.next = 5;
                return this.app.module('models.UserModel');

              case 5:
                UserModel = _context5.sent;
                _context5.next = 8;
                return UserModel.findOne(criteria).select('_id');

              case 8:
                user = _context5.sent;
                return _context5.abrupt("return", {
                  exists: !!user
                });

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

      function check(_x3) {
        return _check.apply(this, arguments);
      }

      return check;
    }() //

  }, {
    key: "getUserCriteria",
    value: function getUserCriteria(rawParams) {
      var _this$loginCreds = this.loginCreds,
          loginCreds = _this$loginCreds === void 0 ? [] : _this$loginCreds;
      var params = (0, _canonizeParams["default"])(rawParams); // eslint-disable-next-line no-restricted-syntax

      var _iterator = _createForOfIteratorHelper(loginCreds),
          _step;

      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var cred = _step.value;

          if (loginCreds.includes(cred) && params[cred]) {
            return (0, _defineProperty2["default"])({}, cred, params[cred]);
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }

      throw new _err["default"]('auth.loginEmpty', {
        status: 400
      });
    }
  }, {
    key: "login",
    value: function () {
      var _login = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(req) {
        var UserModel, password, user, token;
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _context6.next = 2;
                return this.app.module('models.UserModel');

              case 2:
                UserModel = _context6.sent;
                password = req.data.password;

                if (password) {
                  _context6.next = 6;
                  break;
                }

                throw new _err["default"]('auth.passwordEmpty', {
                  status: 400
                });

              case 6:
                _context6.next = 8;
                return UserModel.findOne(this.getUserCriteria(req.data));

              case 8:
                user = _context6.sent;

                if (user) {
                  _context6.next = 11;
                  break;
                }

                throw new _err["default"]('auth.loginIncorrect', {
                  status: 400
                });

              case 11:
                if (!(0, _get3["default"])(user, 'statuses.blockedAt')) {
                  _context6.next = 13;
                  break;
                }

                throw new _err["default"]('auth.blocked', {
                  status: 403
                });

              case 13:
                _context6.next = 15;
                return this.helpers.verifyPassword(password, user.password);

              case 15:
                if (_context6.sent) {
                  _context6.next = 17;
                  break;
                }

                throw new _err["default"]('auth.passwordIncorrect', {
                  status: 400
                });

              case 17:
                req.user = user;
                token = this.helpers.generateAuthToken(user); // await this.helpers.updateLoginAt(user);

                _context6.t0 = user._id;
                _context6.next = 22;
                return UserModel.prepare(user, {
                  req: req,
                  withAppState: true
                });

              case 22:
                _context6.t1 = _context6.sent;
                _context6.t2 = token;
                return _context6.abrupt("return", {
                  _id: _context6.t0,
                  user: _context6.t1,
                  token: _context6.t2
                });

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

      function login(_x4) {
        return _login.apply(this, arguments);
      }

      return login;
    }()
  }, {
    key: "signup",
    value: function () {
      var _signup = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(req) {
        var permitModule, UserModel, PermitModel, _req$data, password, userFields, loginParams, criteria, existUser, loginField, user, email, code, permit, token;

        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                _context7.next = 2;
                return this.app.module('permit');

              case 2:
                permitModule = _context7.sent;
                _context7.next = 5;
                return this.app.module('models.UserModel');

              case 5:
                UserModel = _context7.sent;
                _context7.next = 8;
                return this.app.module('models.PermitModel');

              case 8:
                PermitModel = _context7.sent;
                _req$data = req.data, password = _req$data.password, userFields = (0, _objectWithoutProperties2["default"])(_req$data, _excluded);
                loginParams = (0, _canonizeParams["default"])(req.data);
                criteria = this.getUserCriteria(loginParams);
                _context7.next = 14;
                return UserModel.findOne(criteria).select('_id');

              case 14:
                existUser = _context7.sent;
                loginField = Object.keys(criteria)[0];

                if (!existUser) {
                  _context7.next = 18;
                  break;
                }

                throw new _err["default"]("auth.".concat(loginField, "Exists"), {
                  status: 400
                });

              case 18:
                user = new UserModel(_objectSpread(_objectSpread({}, userFields), loginParams));

                if (!password) {
                  _context7.next = 22;
                  break;
                }

                _context7.next = 22;
                return this.helpers.setPassword(user, password);

              case 22:
                _context7.next = 24;
                return user.save();

              case 24:
                req.user = user;

                if (!(loginField === 'email')) {
                  _context7.next = 34;
                  break;
                }

                email = loginParams.email;
                _context7.next = 29;
                return permitModule.genCode('emailVerify');

              case 29:
                code = _context7.sent;
                _context7.next = 32;
                return PermitModel.createPermit({
                  expiredAt: permitModule.createExpiredAt('emailVerify'),
                  type: 'auth.confirmEmail',
                  userId: user._id,
                  info: {
                    provider: 'email',
                    email: email,
                    userId: user._id
                  },
                  code: code
                });

              case 32:
                permit = _context7.sent;
                this.app.emit('events.auth.signup', {
                  type: 'events.auth.signup',
                  userId: user._id,
                  user: user,
                  permit: permit,
                  email: permit.info.email,
                  link: this.app.url("/auth/permit?permitId=".concat(permit._id, "&code=").concat(permit.code))
                });

              case 34:
                // const link = (await this.helpers.genereateEmailApprovedLink) ? this.helpers.genereateEmailApprovedLink(user) : null;
                // this.app.emit('events.auth.signup', { user, link });
                token = this.helpers.generateAuthToken(user);
                _context7.t0 = user._id;
                _context7.next = 38;
                return UserModel.prepare(user, {
                  req: req,
                  withAppState: true
                });

              case 38:
                _context7.t1 = _context7.sent;
                _context7.t2 = token;
                return _context7.abrupt("return", {
                  signup: true,
                  _id: _context7.t0,
                  user: _context7.t1,
                  token: _context7.t2
                });

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

      function signup(_x5) {
        return _signup.apply(this, arguments);
      }

      return signup;
    }()
  }, {
    key: "permitAction",
    value: function () {
      var _permitAction = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(_ref2) {
        var req, permit, UserModel, PermitModel, user, token, password, _user, _token;

        return _regenerator["default"].wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                req = _ref2.req, permit = _ref2.permit;
                _context8.next = 3;
                return this.app.module('models.UserModel');

              case 3:
                UserModel = _context8.sent;
                _context8.next = 6;
                return this.app.module('models.PermitModel');

              case 6:
                PermitModel = _context8.sent;

                if (!(permit.type === 'auth.confirmEmail')) {
                  _context8.next = 20;
                  break;
                }

                _context8.next = 10;
                return UserModel.findById(permit.userId).sort({
                  createdAt: 1
                });

              case 10:
                user = _context8.sent;

                if (user) {
                  _context8.next = 13;
                  break;
                }

                throw new _err["default"]('!user');

              case 13:
                _context8.next = 15;
                return permit.activate();

              case 15:
                user.setStatus('confirmEmailAt', new Date());
                _context8.next = 18;
                return user.save();

              case 18:
                token = this.helpers.generateAuthToken(user);
                return _context8.abrupt("return", _bluebird["default"].props({
                  __pack: true,
                  user: UserModel.prepare(user, {
                    req: req
                  }),
                  token: token,
                  data: {
                    permit: PermitModel.prepare(permit, {
                      req: req
                    })
                  }
                }));

              case 20:
                if (!(permit.type === 'auth.restorePassword')) {
                  _context8.next = 36;
                  break;
                }

                password = req.data.password;
                _context8.next = 24;
                return UserModel.findById(permit.userId);

              case 24:
                _user = _context8.sent;

                if (_user) {
                  _context8.next = 27;
                  break;
                }

                throw new _err["default"]('!user');

              case 27:
                _context8.next = 29;
                return permit.activate();

              case 29:
                _context8.next = 31;
                return this.helpers.setPassword(_user, password);

              case 31:
                _user.setStatus('passwordAt', new Date());

                _context8.next = 34;
                return _user.save();

              case 34:
                _token = this.helpers.generateAuthToken(_user);
                return _context8.abrupt("return", _bluebird["default"].props({
                  __pack: true,
                  user: UserModel.prepare(_user, {
                    req: req
                  }),
                  token: _token,
                  data: {
                    permit: PermitModel.prepare(permit, {
                      req: req
                    })
                  }
                }));

              case 36:
                throw new _err["default"]('permit.incorrectType');

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

      function permitAction(_x6) {
        return _permitAction.apply(this, arguments);
      }

      return permitAction;
    }()
  }, {
    key: "confirmPermit",
    value: function () {
      var _confirmPermit = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(req) {
        var _req$data2, code, permitId, PermitModel, permit, status;

        return _regenerator["default"].wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                _req$data2 = req.data, code = _req$data2.code, permitId = _req$data2.permitId;
                _context9.next = 3;
                return this.app.module('models.PermitModel');

              case 3:
                PermitModel = _context9.sent;

                if (code) {
                  _context9.next = 6;
                  break;
                }

                throw new _err["default"]('!code');

              case 6:
                if (permitId) {
                  _context9.next = 8;
                  break;
                }

                throw new _err["default"]('permit.permitIdEmpty', {
                  status: 400
                });

              case 8:
                _context9.next = 10;
                return PermitModel.findById(permitId);

              case 10:
                permit = _context9.sent;

                if (permit) {
                  _context9.next = 13;
                  break;
                }

                throw new _err["default"]('permit.permitNotFound', {
                  status: 404
                });

              case 13:
                status = permit.getStatus();

                if (!(status !== 'valid')) {
                  _context9.next = 16;
                  break;
                }

                throw new _err["default"]('permit.statusInvalid', {
                  status: 400,
                  data: {
                    status: status
                  }
                });

              case 16:
                if (!(String(code) !== String(permit.code))) {
                  _context9.next = 18;
                  break;
                }

                throw new _err["default"]('permit.codeInvalid', {
                  status: 400
                });

              case 18:
                return _context9.abrupt("return", this.permitAction({
                  req: req,
                  permit: permit
                }));

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

      function confirmPermit(_x7) {
        return _confirmPermit.apply(this, arguments);
      }

      return confirmPermit;
    }()
  }, {
    key: "restorePassword",
    value: function () {
      var _restorePassword = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10(req) {
        var permitModule, UserModel, PermitModel, email, user, code, permit;
        return _regenerator["default"].wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                _context10.next = 2;
                return this.app.module('permit');

              case 2:
                permitModule = _context10.sent;
                _context10.next = 5;
                return this.app.module('models.UserModel');

              case 5:
                UserModel = _context10.sent;
                _context10.next = 8;
                return this.app.module('models.PermitModel');

              case 8:
                PermitModel = _context10.sent;
                email = req.data.email;

                if (!(!email || !(0, _validateEmail["default"])(email))) {
                  _context10.next = 12;
                  break;
                }

                throw new _err["default"]('auth.emailInvalid');

              case 12:
                _context10.next = 14;
                return UserModel.findOne({
                  email: email
                }).select(['email']);

              case 14:
                user = _context10.sent;

                if (user) {
                  _context10.next = 17;
                  break;
                }

                throw new _err["default"]('auth.userNotFound', {
                  status: 404
                });

              case 17:
                _context10.next = 19;
                return permitModule.genCode('emailVerifyStrong');

              case 19:
                code = _context10.sent;
                _context10.next = 22;
                return PermitModel.createPermit({
                  expiredAt: permitModule.createExpiredAt('emailVerifyStrong'),
                  type: 'auth.restorePassword',
                  userId: user._id,
                  info: {
                    userId: user._id,
                    email: email
                  },
                  code: code
                });

              case 22:
                permit = _context10.sent;
                this.app.emit('events.auth.restorePassword', {
                  type: 'events.auth.restorePassword',
                  userId: user._id,
                  user: user,
                  permit: permit,
                  email: email,
                  link: this.app.url("/auth/permit?permitId=".concat(permit._id, "&code=").concat(permit.code))
                });
                return _context10.abrupt("return", PermitModel.prepare(permit, {
                  req: req
                }));

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

      function restorePassword(_x8) {
        return _restorePassword.apply(this, arguments);
      }

      return restorePassword;
    }() // async setPassword(req) {
    //       const UserModel = await this.app.module('models.UserModel');
    //       cPermit UserModel = await this.app.module('models.PermitModel');
    //   const { code, password } = req.data;
    //   if (!code) throw new Err('!code');
    //   const permit = await PermitModel.findOne({
    //     type: 'user.restorePassword',
    //     code,
    //   });
    //   if (!permit) throw { code: 'invalidCode' };
    //   if (permit.activatedAt) throw { code: 'activated' };
    //   const date = new Date();
    //   if (date > permit.expiredAt) throw { code: 'expired' };
    //   const user = await UserModel.findById(permit.userId);
    //   if (!user) throw new Err('!user');
    //   await permit.activate();
    //   await this.helpers.setPassword(user, password);
    //   set(user, 'private.lastUpdates.password', date);
    //   user.markModified('private.lastUpdates.password');
    //   await user.save();
    //   const token = this.helpers.generateAuthToken(user);
    //   return Bluebird.props({
    //     __pack: true,
    //     user: UserModel.prepare(user, { req }),
    //     token,
    //     data: {
    //       permit: PermitModel.prepare(permit, { req }),
    //     },
    //   });
    // }
    // async silent(req) {
    //   const UserModel = this.app.models.UserModel || this.app.models.User;
    //   const { login, params } = canonizeParams(req.data);
    //   const username = `__s${Date.now()}__`;
    //   const user = new UserModel({
    //     username,
    //     type: 'silent',
    //     ...params,
    //   });
    //   await user.save();
    //   req.user = user;
    //   return {
    //     signup: true,
    //     user: await UserModel.prepare(user, { req, withAppState: true }),
    //     token: user.generateAuthToken(),
    //   };
    // }
    // async recovery(req) {
    //   const UserModel = this.app.models.UserModel || this.app.models.User;
    //   const { mailer } = this.app.modules;
    //   if (!mailer) throw new Err('Система не может отправить email');
    //   // const params = req.data;
    //   const criteria = this.getUserCriteria(req);
    //   const user = await UserModel.findOne(criteria);
    //   if (!user) throw new Err('Неверный логин', { status: 404 });
    //   const email = user.getEmail();
    //   if (!email) throw new Err('У этого пользователя не был указан емейл для восстановления', { status: 400 });
    //   const password = UserModel.generatePassword();
    //   await mailer.send({
    //     ...user.getMailerParams('primary'),
    //     template: 'recovery',
    //     // locale: user.locale || req.locale,
    //     // to: user.getEmail(),
    //     params: {
    //       user: user.toJSON(),
    //       password,
    //     },
    //   });
    //   await user.setPassword(password);
    //   await user.save();
    //   return {
    //     emailSended: true,
    //   };
    // }

  }, {
    key: "info",
    value: function () {
      var _info = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
        var authModule;
        return _regenerator["default"].wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                _context11.next = 2;
                return this.app.module('auth');

              case 2:
                authModule = _context11.sent;

                if (authModule) {
                  _context11.next = 5;
                  break;
                }

                return _context11.abrupt("return", []);

              case 5:
                return _context11.abrupt("return", {
                  providers: (0, _map["default"])(authModule.strategies, function (strategy, provider) {
                    return _objectSpread({
                      provider: provider
                    }, (0, _omit["default"])(strategy.getInfo(), _env.isDev ? [] : ['settings', 'clientId']));
                  })
                });

              case 6:
              case "end":
                return _context11.stop();
            }
          }
        }, _callee11, this);
      }));

      function info() {
        return _info.apply(this, arguments);
      }

      return info;
    }()
  }, {
    key: "socialAuth",
    value: function () {
      var _socialAuth = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12(req, res, next) {
        var authModule, provider, origin, strategy;
        return _regenerator["default"].wrap(function _callee12$(_context12) {
          while (1) {
            switch (_context12.prev = _context12.next) {
              case 0:
                _context12.next = 2;
                return this.app.module('auth');

              case 2:
                authModule = _context12.sent;

                if (authModule) {
                  _context12.next = 5;
                  break;
                }

                throw new _err["default"]('!authModule');

              case 5:
                provider = req.params.provider;
                origin = (0, _getReqOrigin["default"])(req);
                strategy = authModule.strategies[provider];
                if (!strategy) next(new _err["default"]('auth.providerInvalid'), {
                  status: 404,
                  provider: provider
                });
                authModule.passportService.authenticate(provider, strategy.getPassportAuthenticateParams({
                  method: 'auth',
                  origin: origin
                }))(req, res, next);

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

      function socialAuth(_x9, _x10, _x11) {
        return _socialAuth.apply(this, arguments);
      }

      return socialAuth;
    }()
  }, {
    key: "socialCallback",
    value: function () {
      var _socialCallback = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee14(req, res) {
        var authModule, provider;
        return _regenerator["default"].wrap(function _callee14$(_context14) {
          while (1) {
            switch (_context14.prev = _context14.next) {
              case 0:
                _context14.next = 2;
                return this.app.module('auth');

              case 2:
                authModule = _context14.sent;

                if (authModule) {
                  _context14.next = 5;
                  break;
                }

                throw new _err["default"]('!authModule');

              case 5:
                provider = req.params.provider;
                return _context14.abrupt("return", new _bluebird["default"](function (resolve, reject) {
                  authModule.passportService.authenticate(provider, authModule.strategies[provider].getPassportAuthenticateParams({
                    method: 'callback'
                  }), /*#__PURE__*/function () {
                    var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13(err, data) {
                      return _regenerator["default"].wrap(function _callee13$(_context13) {
                        while (1) {
                          switch (_context13.prev = _context13.next) {
                            case 0:
                              if (!err) {
                                _context13.next = 2;
                                break;
                              }

                              return _context13.abrupt("return", reject(err));

                            case 2:
                              return _context13.abrupt("return", resolve(res.redirect(data.redirect || '/')));

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

                    return function (_x14, _x15) {
                      return _ref3.apply(this, arguments);
                    };
                  }())(req);
                }));

              case 7:
              case "end":
                return _context14.stop();
            }
          }
        }, _callee14, this);
      }));

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

      return socialCallback;
    }() // ////////////////////////

  }, {
    key: "socialLogin",
    value: function () {
      var _socialLogin = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee15(req) {
        var UserModel, PassportModel, passport, user, params;
        return _regenerator["default"].wrap(function _callee15$(_context15) {
          while (1) {
            switch (_context15.prev = _context15.next) {
              case 0:
                UserModel = this.app.models.UserModel || this.app.models.User;
                PassportModel = this.app.models.PassportModel || this.app.models.Passport;
                _context15.next = 4;
                return PassportModel.getByToken(req.data.p);

              case 4:
                passport = _context15.sent;
                _context15.next = 7;
                return passport.getUser();

              case 7:
                user = _context15.sent;

                if (user) {
                  _context15.next = 23;
                  break;
                }

                _context15.t0 = _merge["default"];
                _context15.t1 = {
                  profile: passport.profile
                };
                _context15.next = 13;
                return passport.generateUsername(UserModel);

              case 13:
                _context15.t2 = _context15.sent;
                _context15.t3 = {
                  username: _context15.t2
                };
                params = (0, _context15.t0)(_context15.t1, _context15.t3);
                // console.log({ params });
                user = new UserModel(params); // await user.save();

                user.updateFromPassport(passport, {
                  req: req
                });
                _context15.next = 20;
                return user.save();

              case 20:
                passport.userId = user._id; // console.log('passport.save before', passport);

                _context15.next = 23;
                return passport.save();

              case 23:
                req.user = user;
                _context15.next = 26;
                return UserModel.prepare(user, {
                  req: req,
                  withAppState: true
                });

              case 26:
                _context15.t4 = _context15.sent;
                _context15.t5 = user.generateAuthToken();
                return _context15.abrupt("return", {
                  user: _context15.t4,
                  token: _context15.t5
                });

              case 29:
              case "end":
                return _context15.stop();
            }
          }
        }, _callee15, this);
      }));

      function socialLogin(_x16) {
        return _socialLogin.apply(this, arguments);
      }

      return socialLogin;
    }()
  }, {
    key: "socialBind",
    value: function () {
      var _socialBind = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee16(req) {
        var checkNotFound, UserModel, PassportModel, userId, passport, user;
        return _regenerator["default"].wrap(function _callee16$(_context16) {
          while (1) {
            switch (_context16.prev = _context16.next) {
              case 0:
                checkNotFound = this.app.helpers.checkNotFound;
                UserModel = this.app.models.UserModel || this.app.models.User;
                PassportModel = this.app.models.PassportModel || this.app.models.Passport;
                userId = req.user._id;
                _context16.next = 6;
                return PassportModel.getByToken(req.data.p).then(checkNotFound);

              case 6:
                passport = _context16.sent;
                _context16.next = 9;
                return UserModel.findById(req.user._id).then(checkNotFound);

              case 9:
                user = _context16.sent;

                if (!passport.userId) {
                  _context16.next = 12;
                  break;
                }

                throw new _err["default"]('passport.userId already exist', {
                  status: 400
                });

              case 12:
                passport.userId = userId; // user.passports.push(passport._id);

                _context16.next = 15;
                return passport.save();

              case 15:
                _context16.next = 17;
                return user.updateFromPassport(passport);

              case 17:
                _context16.next = 19;
                return user.save();

              case 19:
                return _context16.abrupt("return", PassportModel.find({
                  userId: userId
                }));

              case 20:
              case "end":
                return _context16.stop();
            }
          }
        }, _callee16, this);
      }));

      function socialBind(_x17) {
        return _socialBind.apply(this, arguments);
      }

      return socialBind;
    }()
  }, {
    key: "getSocials",
    value: function () {
      var _getSocials = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee17(req) {
        var PassportModel, userId;
        return _regenerator["default"].wrap(function _callee17$(_context17) {
          while (1) {
            switch (_context17.prev = _context17.next) {
              case 0:
                PassportModel = this.app.models.PassportModel || this.app.models.Passport;
                userId = req.user._id;
                return _context17.abrupt("return", PassportModel.find({
                  userId: userId
                }));

              case 3:
              case "end":
                return _context17.stop();
            }
          }
        }, _callee17, this);
      }));

      function getSocials(_x18) {
        return _getSocials.apply(this, arguments);
      }

      return getSocials;
    }()
  }, {
    key: "passportsDetach",
    value: function () {
      var _passportsDetach = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee18(req) {
        var PassportModel, _id, passport;

        return _regenerator["default"].wrap(function _callee18$(_context18) {
          while (1) {
            switch (_context18.prev = _context18.next) {
              case 0:
                _context18.next = 2;
                return this.isAuth(req);

              case 2:
                PassportModel = this.app.models.PassportModel;
                _id = req.data._id;
                _context18.next = 6;
                return PassportModel.findById(_id);

              case 6:
                passport = _context18.sent;

                if (!(String(passport.userId) !== String(req.user._id))) {
                  _context18.next = 9;
                  break;
                }

                throw new _err["default"]('!acl');

              case 9:
                _context18.next = 11;
                return PassportModel.deleteOne({
                  _id: passport._id
                });

              case 11:
                return _context18.abrupt("return", {
                  ok: 1
                });

              case 12:
              case "end":
                return _context18.stop();
            }
          }
        }, _callee18, this);
      }));

      function passportsDetach(_x19) {
        return _passportsDetach.apply(this, arguments);
      }

      return passportsDetach;
    }()
  }, {
    key: "socialUnbind",
    value: function () {
      var _socialUnbind = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee19(req) {
        var checkNotFound, UserModel, PassportModel, params, userId, user, findParams, passport;
        return _regenerator["default"].wrap(function _callee19$(_context19) {
          while (1) {
            switch (_context19.prev = _context19.next) {
              case 0:
                checkNotFound = this.app.helpers.checkNotFound;
                UserModel = this.app.models.UserModel || this.app.models.User;
                PassportModel = this.app.models.PassportModel || this.app.models.Passport;
                params = req.data;
                userId = req.user._id;
                _context19.next = 7;
                return UserModel.findById(req.user._id).then(checkNotFound);

              case 7:
                user = _context19.sent;
                // OR passportId: passport._id
                findParams = {};
                if (params.passportId) findParams._id = params.passportId;
                if (params.provider) findParams.provider = params.provider;
                findParams.userId = userId;

                if (!(!findParams.passportId && !findParams.provider)) {
                  _context19.next = 14;
                  break;
                }

                throw new _err["default"]('!findParams.passportId && !findParams.provider', {
                  status: 400
                });

              case 14:
                _context19.next = 16;
                return PassportModel.findOne(findParams).then(checkNotFound);

              case 16:
                passport = _context19.sent;

                if (!(passport.userId !== userId)) {
                  _context19.next = 19;
                  break;
                }

                throw new _err["default"]('Wrong user!', {
                  status: 403
                });

              case 19:
                passport.userId = null; // user.passports = user.passports.filter((pId) => {
                //   return pId && pId.toString() !== params.p;
                // });

                _context19.next = 22;
                return passport.save();

              case 22:
                _context19.next = 24;
                return user.save();

              case 24:
                return _context19.abrupt("return", PassportModel.find({
                  userId: userId
                }));

              case 25:
              case "end":
                return _context19.stop();
            }
          }
        }, _callee19, this);
      }));

      function socialUnbind(_x20) {
        return _socialUnbind.apply(this, arguments);
      }

      return socialUnbind;
    }()
  }, {
    key: "tokenLogin",
    value: function () {
      var _tokenLogin = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee20(req) {
        var UserModel, token, user;
        return _regenerator["default"].wrap(function _callee20$(_context20) {
          while (1) {
            switch (_context20.prev = _context20.next) {
              case 0:
                UserModel = this.app.models.UserModel || this.app.models.User;
                token = req.data.t || req.data.token;

                if (token) {
                  _context20.next = 4;
                  break;
                }

                throw new _err["default"]('!token', {
                  status: 400
                });

              case 4:
                _context20.next = 6;
                return UserModel.tokenLogin({
                  token: token
                });

              case 6:
                user = _context20.sent;

                if (user) {
                  _context20.next = 9;
                  break;
                }

                throw new _err["default"]('auth.userNotFound', {
                  status: 404
                });

              case 9:
                req.user = user;
                _context20.next = 12;
                return UserModel.prepare(user, {
                  req: req,
                  withAppState: true
                });

              case 12:
                _context20.t0 = _context20.sent;
                _context20.t1 = user.generateAuthToken();
                return _context20.abrupt("return", {
                  user: _context20.t0,
                  token: _context20.t1
                });

              case 15:
              case "end":
                return _context20.stop();
            }
          }
        }, _callee20, this);
      }));

      function tokenLogin(_x21) {
        return _tokenLogin.apply(this, arguments);
      }

      return tokenLogin;
    }()
  }, {
    key: "phoneCode",
    value: function () {
      var _phoneCode = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee21(req) {
        var smsConfig, phone, code, smsText, text, res, qs, body, pack;
        return _regenerator["default"].wrap(function _callee21$(_context21) {
          while (1) {
            switch (_context21.prev = _context21.next) {
              case 0:
                if (this.app.modules.auth.config.sms) {
                  _context21.next = 2;
                  break;
                }

                throw new _err["default"]('!module.config.sms');

              case 2:
                smsConfig = this.app.modules.auth.config.sms;
                phone = req.data.phone;
                code = (0, _random["default"])(100000, 999999);
                this.lastCode = code;
                smsText = "\u0412\u0430\u0448 \u043F\u0440\u043E\u0432\u0435\u0440\u043E\u0447\u043D\u044B\u0439 \u043A\u043E\u0434: ".concat(code);

                if (this.app.modules.auth.tbot) {
                  this.app.modules.auth.tbot.notify("\u041D\u043E\u043C\u0435\u0440: ".concat(phone, "\n").concat(smsText));
                }

                text = (0, _transliterate["default"])(smsText);

                if (!(smsConfig.provider === 'bytehand')) {
                  _context21.next = 16;
                  break;
                }

                qs = _objectSpread(_objectSpread({}, smsConfig.params), {}, {
                  to: phone,
                  text: text
                });
                _context21.next = 13;
                return this.app.api.fetch('http://bytehand.com:3800/send', {
                  qs: qs
                });

              case 13:
                res = _context21.sent;
                _context21.next = 26;
                break;

              case 16:
                if (!(smsConfig.provider === 'nexmo')) {
                  _context21.next = 25;
                  break;
                }

                body = _objectSpread(_objectSpread({}, smsConfig.params), {}, {
                  to: phone,
                  text: text
                }); // console.log('https://rest.nexmo.com/sms/json', { body });

                _context21.next = 20;
                return this.app.api.fetch('https://rest.nexmo.com/sms/json', {
                  method: 'POST',
                  // headers: {
                  //   'Content-Type': '!',
                  // },
                  body: body
                });

              case 20:
                res = _context21.sent;

                if (!(res.messages[0].status !== '0')) {
                  _context21.next = 23;
                  break;
                }

                throw res.messages[0]['error-text'];

              case 23:
                _context21.next = 26;
                break;

              case 25:
                throw new _err["default"]('!provider');

              case 26:
                pack = {
                  phone: phone,
                  res: res
                };

                if (_env.isDev) {
                  pack.code = code;
                } // console.log('result', JSON.stringify(pack, null, 2));


                return _context21.abrupt("return", pack);

              case 29:
              case "end":
                return _context21.stop();
            }
          }
        }, _callee21, this);
      }));

      function phoneCode(_x22) {
        return _phoneCode.apply(this, arguments);
      }

      return phoneCode;
    }()
  }, {
    key: "phoneApprove",
    value: function phoneApprove(req) {
      if (!this.app.modules.auth.config.sms) throw new _err["default"]('!module.config.sms');
      var _req$data3 = req.data,
          phone = _req$data3.phone,
          code = _req$data3.code;
      return {
        phone: phone,
        code: code
      };
    }
  }, {
    key: "phoneLogin",
    value: function () {
      var _phoneLogin = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee22(req) {
        var _req$data4, phone, code, UserModel, user;

        return _regenerator["default"].wrap(function _callee22$(_context22) {
          while (1) {
            switch (_context22.prev = _context22.next) {
              case 0:
                if (this.app.modules.auth.config.sms) {
                  _context22.next = 2;
                  break;
                }

                throw new _err["default"]('!module.config.sms');

              case 2:
                _req$data4 = req.data, phone = _req$data4.phone, code = _req$data4.code;
                UserModel = this.app.models.UserModel || this.app.models.User;

                if (this.app.modules.auth.config.sms.defaultCode && code === this.app.modules.auth.config.sms.code || code === this.lastCode) {
                  _context22.next = 6;
                  break;
                }

                throw new _err["default"]('Код не верный');

              case 6:
                _context22.next = 8;
                return UserModel.findOne({
                  username: phone
                });

              case 8:
                user = _context22.sent;

                if (user) {
                  _context22.next = 13;
                  break;
                }

                _context22.next = 12;
                return UserModel.create({
                  username: phone,
                  profile: {
                    contacts: {
                      phone: phone
                    }
                  }
                });

              case 12:
                user = _context22.sent;

              case 13:
                req.user = user;
                _context22.next = 16;
                return UserModel.prepare(user, {
                  req: req,
                  withAppState: true
                });

              case 16:
                _context22.t0 = _context22.sent;
                _context22.t1 = user.generateAuthToken();
                return _context22.abrupt("return", {
                  user: _context22.t0,
                  token: _context22.t1
                });

              case 19:
              case "end":
                return _context22.stop();
            }
          }
        }, _callee22, this);
      }));

      function phoneLogin(_x23) {
        return _phoneLogin.apply(this, arguments);
      }

      return phoneLogin;
    }()
  }, {
    key: "getPassportByToken",
    value: function () {
      var _getPassportByToken = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee23(req) {
        var PassportModel;
        return _regenerator["default"].wrap(function _callee23$(_context23) {
          while (1) {
            switch (_context23.prev = _context23.next) {
              case 0:
                PassportModel = this.app.models.PassportModel || this.app.models.Passport;
                return _context23.abrupt("return", PassportModel.getByToken(req.data.p));

              case 2:
              case "end":
                return _context23.stop();
            }
          }
        }, _callee23, this);
      }));

      function getPassportByToken(_x24) {
        return _getPassportByToken.apply(this, arguments);
      }

      return getPassportByToken;
    }()
  }, {
    key: "getPermit",
    value: function () {
      var _getPermit = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee24(req) {
        var _id, PermitModel, permit;

        return _regenerator["default"].wrap(function _callee24$(_context24) {
          while (1) {
            switch (_context24.prev = _context24.next) {
              case 0:
                _id = req.data._id;

                if (_id) {
                  _context24.next = 3;
                  break;
                }

                throw new _err["default"]('!_id');

              case 3:
                _context24.next = 5;
                return this.app.module('models.PermitModel');

              case 5:
                PermitModel = _context24.sent;
                _context24.next = 8;
                return PermitModel.findOne({
                  _id: _id
                });

              case 8:
                permit = _context24.sent;

                if (permit) {
                  _context24.next = 11;
                  break;
                }

                throw new _err["default"]('!permit');

              case 11:
                if (!(permit.type === 'user.restorePassword')) {
                  _context24.next = 13;
                  break;
                }

                return _context24.abrupt("return", PermitModel.prepare(permit, {
                  req: req
                }));

              case 13:
                if (!(!req.user || !req.user._id)) {
                  _context24.next = 15;
                  break;
                }

                throw new _err["default"]('!userId');

              case 15:
                if (permit) {
                  _context24.next = 17;
                  break;
                }

                throw new _err["default"]('not found');

              case 17:
                if (!(this.app.hasGrant(req.user, 'superadmin') || String(permit.userId) === req.user._id)) {
                  _context24.next = 19;
                  break;
                }

                return _context24.abrupt("return", PermitModel.prepare(permit, {
                  req: req
                }));

              case 19:
                throw new _err["default"]('!permission');

              case 20:
              case "end":
                return _context24.stop();
            }
          }
        }, _callee24, this);
      }));

      function getPermit(_x25) {
        return _getPermit.apply(this, arguments);
      }

      return getPermit;
    }()
  }, {
    key: "emailPermit",
    value: function () {
      var _emailPermit = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee25(req) {
        var permitModule, UserModel, PermitModel, ObjectId, userId, user, email, type, date, changeEmailTimeout, isTimeout, emailExist, str, code, permit, eventType;
        return _regenerator["default"].wrap(function _callee25$(_context25) {
          while (1) {
            switch (_context25.prev = _context25.next) {
              case 0:
                _context25.next = 2;
                return this.app.module('permit');

              case 2:
                permitModule = _context25.sent;
                UserModel = this.app.models.UserModel || this.app.models.User;
                _context25.next = 6;
                return this.app.module('models.PermitModel');

              case 6:
                PermitModel = _context25.sent;
                ObjectId = this.app.db.Types.ObjectId;

                if (!(!req.user || !req.user._id)) {
                  _context25.next = 10;
                  break;
                }

                throw new _err["default"]('!_id');

              case 10:
                userId = req.user._id;

                if (!(req.data._id && req.data._id !== userId)) {
                  _context25.next = 17;
                  break;
                }

                if (!this.app.hasGrant(req.user, 'admin')) {
                  _context25.next = 16;
                  break;
                }

                userId = req.data._id;
                _context25.next = 17;
                break;

              case 16:
                throw new _err["default"]('!permission');

              case 17:
                _context25.next = 19;
                return UserModel.findById(userId);

              case 19:
                user = _context25.sent;

                if (user) {
                  _context25.next = 22;
                  break;
                }

                throw new _err["default"]('auth.userNotFound', {
                  status: 404
                });

              case 22:
                email = req.data.email;

                if (!(!email || !(0, _validateEmail["default"])(email))) {
                  _context25.next = 25;
                  break;
                }

                throw new _err["default"]('auth.emailInvalid');

              case 25:
                if (user.email) {
                  type = 'change';
                } else {
                  type = 'set';
                }

                if (!(user.email && email === user.email)) {
                  _context25.next = 28;
                  break;
                }

                throw new _err["default"]('emailNotChanged');

              case 28:
                date = new Date();
                changeEmailTimeout = (0, _get3["default"])(this, 'app.config.auth.changeEmailTimeout', 7 * 24 * 60 * 60 * 1000);
                _context25.next = 32;
                return PermitModel.countDocuments({
                  activatedAt: {
                    $exists: false
                  },
                  expiredAt: {
                    $gte: date
                  },
                  'info.email': email,
                  'info.userId': ObjectId(user._id),
                  type: {
                    $in: ['user.setEmail', 'user.changeEmail']
                  },
                  createdAt: {
                    $gte: +date - changeEmailTimeout
                  }
                });

              case 32:
                isTimeout = _context25.sent;

                if (!isTimeout) {
                  _context25.next = 35;
                  break;
                }

                throw new _err["default"]('timeout');

              case 35:
                _context25.next = 37;
                return UserModel.countDocuments({
                  _id: {
                    $ne: userId
                  },
                  email: email
                });

              case 37:
                emailExist = _context25.sent;

                if (!emailExist) {
                  _context25.next = 40;
                  break;
                }

                throw new _err["default"]('emailExist');

              case 40:
                if (type === 'change') {
                  str = "".concat(user._id, "_").concat(email, "_").concat(user.email, "_").concat(date.getTime());
                } else if (type === 'set') {
                  str = "".concat(user._id, "_").concat(email, "_").concat(date.getTime());
                }

                _context25.next = 43;
                return PermitModel.generateUniqCode({
                  codeParams: {
                    str: str,
                    type: 'hash'
                  },
                  criteria: {
                    type: "user.".concat(type, "Email"),
                    activatedAt: {
                      $exists: false
                    },
                    expiredAt: {
                      $gte: date
                    }
                  }
                });

              case 43:
                code = _context25.sent;
                _context25.next = 46;
                return PermitModel.createPermit({
                  expiredAt: permitModule.createExpiredAt('emailVerifyStrong'),
                  type: "user.".concat(type, "Email"),
                  userId: user._id,
                  info: {
                    email: email,
                    oldEmail: user.email,
                    userId: user._id,
                    type: type
                  },
                  code: code
                });

              case 46:
                permit = _context25.sent;
                (0, _set["default"])(user, 'private.info.email', email);
                (0, _set["default"])(user, 'private.info.emailPermitId', permit._id);
                user.markModified('private.info');
                _context25.next = 52;
                return user.save();

              case 52:
                eventType = "events.user.".concat(type, "Email").concat(this.app.hasGrant(user, 'newUser') ? 'Old' : '');
                this.app.emit(eventType, {
                  type: eventType,
                  targetUser: user,
                  user: user,
                  userId: user._id,
                  permit: permit,
                  email: email,
                  link: this.app.url("/auth/confirm/email?code=".concat(permit.code))
                });
                return _context25.abrupt("return", PermitModel.prepare(permit, {
                  req: req
                }));

              case 55:
              case "end":
                return _context25.stop();
            }
          }
        }, _callee25, this);
      }));

      function emailPermit(_x26) {
        return _emailPermit.apply(this, arguments);
      }

      return emailPermit;
    }()
  }, {
    key: "confirmEmail",
    value: function () {
      var _confirmEmail = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee26(req) {
        var UserModel, PermitModel, code, permit, date, user, emailExist, permits;
        return _regenerator["default"].wrap(function _callee26$(_context26) {
          while (1) {
            switch (_context26.prev = _context26.next) {
              case 0:
                UserModel = this.app.models.UserModel || this.app.models.User;
                _context26.next = 3;
                return this.app.module('models.PermitModel');

              case 3:
                PermitModel = _context26.sent;
                code = req.data.code;

                if (code) {
                  _context26.next = 7;
                  break;
                }

                throw new _err["default"]('!code');

              case 7:
                _context26.next = 9;
                return PermitModel.findOne({
                  $or: [{
                    type: 'user.changeEmail'
                  }, {
                    type: 'user.setEmail'
                  }],
                  code: code
                });

              case 9:
                permit = _context26.sent;

                if (permit) {
                  _context26.next = 12;
                  break;
                }

                throw new _err["default"]('auth.invalidCode');

              case 12:
                if (!permit.activatedAt) {
                  _context26.next = 14;
                  break;
                }

                throw new _err["default"]('activated');

              case 14:
                date = new Date();

                if (!(date > permit.expiredAt)) {
                  _context26.next = 17;
                  break;
                }

                throw new _err["default"]('expired');

              case 17:
                _context26.next = 19;
                return UserModel.findById(permit.info.userId);

              case 19:
                user = _context26.sent;

                if (user) {
                  _context26.next = 22;
                  break;
                }

                throw new _err["default"]('!user');

              case 22:
                _context26.next = 24;
                return UserModel.findOne({
                  _id: {
                    $ne: user._id
                  },
                  email: permit.info.email
                }).select(['email']);

              case 24:
                emailExist = _context26.sent;

                if (!emailExist) {
                  _context26.next = 27;
                  break;
                }

                throw new _err["default"]('auth.emailExist');

              case 27:
                if (!(user.email && permit.info.oldEmail && user.email !== permit.info.oldEmail)) {
                  _context26.next = 29;
                  break;
                }

                throw new _err["default"]('auth.emailWasChanged');

              case 29:
                _context26.next = 31;
                return permit.activate();

              case 31:
                user.email = permit.info.email;
                (0, _unset["default"])(user, 'private.info.emailPermitId');
                (0, _unset["default"])(user, 'private.info.email');
                user.markModified('private.info');
                (0, _set["default"])(user, 'private.lastUpdates.email', date);
                user.markModified('private.lastUpdates.email');

                if (!user.meta.approvedEmail) {
                  user.meta.approvedEmail = true;
                  user.markModified('meta.approvedEmail');
                }

                _context26.next = 40;
                return user.save();

              case 40:
                _context26.next = 42;
                return PermitModel.find({
                  _id: {
                    $ne: permit._id
                  },
                  type: permit.type,
                  userId: user._id
                });

              case 42:
                permits = _context26.sent;
                _context26.next = 45;
                return _bluebird["default"].map(permits, function (p) {
                  p.disabledAt = date; // eslint-disable-line no-param-reassign

                  // eslint-disable-line no-param-reassign
                  return p.save();
                });

              case 45:
                return _context26.abrupt("return", permit);

              case 46:
              case "end":
                return _context26.stop();
            }
          }
        }, _callee26, this);
      }));

      function confirmEmail(_x27) {
        return _confirmEmail.apply(this, arguments);
      }

      return confirmEmail;
    }()
  }, {
    key: "findOneByCode",
    value: function () {
      var _findOneByCode = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee27(req) {
        var code, PermitModel, permit;
        return _regenerator["default"].wrap(function _callee27$(_context27) {
          while (1) {
            switch (_context27.prev = _context27.next) {
              case 0:
                code = req.data.code;

                if (code) {
                  _context27.next = 3;
                  break;
                }

                throw new _err["default"]('!code');

              case 3:
                _context27.next = 5;
                return this.app.module('models.PermitModel');

              case 5:
                PermitModel = _context27.sent;
                _context27.next = 8;
                return PermitModel.findOne({
                  code: code
                });

              case 8:
                permit = _context27.sent;

                if (permit) {
                  _context27.next = 11;
                  break;
                }

                throw new _err["default"]('!permit');

              case 11:
                if (!(permit.type === 'user.restorePassword')) {
                  _context27.next = 13;
                  break;
                }

                return _context27.abrupt("return", PermitModel.prepare(permit, {
                  req: req
                }));

              case 13:
                if (!(!req.user || !req.user._id)) {
                  _context27.next = 15;
                  break;
                }

                throw new _err["default"]('!userId');

              case 15:
                if (!(this.app.hasGrant(req.user, 'superadmin') || String(permit.userId) === req.user._id)) {
                  _context27.next = 17;
                  break;
                }

                return _context27.abrupt("return", PermitModel.prepare(permit, {
                  req: req
                }));

              case 17:
                throw new _err["default"]('!permission');

              case 18:
              case "end":
                return _context27.stop();
            }
          }
        }, _callee27, this);
      }));

      function findOneByCode(_x28) {
        return _findOneByCode.apply(this, arguments);
      }

      return findOneByCode;
    }()
  }]);
  return AuthApi;
}(_serverApi["default"]);

exports.AuthApi = AuthApi;
var _default = AuthApi;
exports["default"] = _default;
//# sourceMappingURL=AuthApi.js.map