kritsana135-hooray-server/build/models/ResourceOwnerModel.js

for server

"use strict";

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

var _mongoose = _interopRequireDefault(require("mongoose"));

var _bcrypt = _interopRequireDefault(require("bcrypt"));

var _apolloServer = require("apollo-server");

var _mongoosejsSoftDelete = _interopRequireDefault(require("mongoosejs-soft-delete"));

var _mongoosePaginateV = _interopRequireDefault(require("mongoose-paginate-v2"));

var _configUser = require("../constants/configUser");

var _utils = require("../constants/errors/utils");

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

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var attribute = new _mongoose.default.Schema({
  key: {
    type: String,
    required: [true, "key is required"],
    trim: true
  },
  value: {
    type: String,
    required: [false, "value is required"],
    trim: true
  }
});
var verifyToken = new _mongoose.default.Schema({
  token: {
    type: String,
    required: [false, "token is required"],
    trim: true
  },
  type: {
    type: String,
    required: [false, "type is required"],
    trim: true
  },
  status: {
    type: String,
    required: [false, "status is required"],
    trim: true
  },
  expireIn: {
    type: Date,
    required: [false, "expireIn is required"],
    trim: true
  }
});
var permission = new _mongoose.default.Schema({
  permissionName: {
    type: String,
    required: [false, "permissionName is required"],
    trim: true
  },
  code: {
    type: String,
    // enum: [CODE.YES, CODE.NO],
    trim: true
  }
});
var userPermission = new _mongoose.default.Schema({
  service: {
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "services"
  },
  permissions: [permission]
});
var account = new _mongoose.default.Schema({
  value: {
    type: String,
    required: [false, "value is required"] //  unique: true,

  },
  verifyStatus: {
    type: String,
    required: [false, "verify is required"],
    default: "NO"
  }
});
var email = new _mongoose.default.Schema({
  value: {
    type: String,
    required: [false, "value is required"] //  unique: true,
    // validate: (value) => {
    //   if (!validator.isEmail(value)) {
    //     throw new ApolloError(INVALID_EMAIL_ADDRESS.message.en,INVALID_EMAIL_ADDRESS.code);
    //   }
    // },

  },
  verifyStatus: {
    type: String,
    required: [false, "verify is required"],
    default: "NO"
  }
});
var role = new _mongoose.default.Schema({
  roleName: {
    type: String,
    required: [true, "Role name is required"],
    default: "Default"
  },
  roleKey: {
    type: String,
    required: [true, "Role Key is required"],
    default: "DEFAULT"
  }
});
var ParentUsers = new _mongoose.default.Schema({
  userId: {
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "resource_owners"
  },
  organizationId: {
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "organizations"
  }
});
var RefId = new _mongoose.default.Schema({
  value: {
    type: String,
    required: [true, "RefId value is required"],
    trim: true
  },
  expireIn: {
    type: Date,
    required: [false, "expireIn is required"],
    trim: true
  }
});
var Rating = new _mongoose.default.Schema({
  userId: {
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "resource_owners"
  },
  value: {
    type: Number
  },
  message: {
    type: String
  }
});
var Coins = new _mongoose.default.Schema({
  value: {
    type: Number
  }
});
var schema = new _mongoose.default.Schema({
  facebook: account,
  google: account,
  line: account,
  apple: account,
  phoneNumber: account,
  username: account,
  email,
  password: {
    type: String,
    required: false,
    minLength: 7
  },
  userType: {
    type: String,
    required: [true, "userType is required"],
    trim: true,
    default: _configUser.USER_TYPE.USER
  },
  role,
  verifyTokens: [verifyToken],
  application: {
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "applications"
  },
  attributes: [attribute],
  // New
  userPermission,
  parentUsers: [ParentUsers],
  organizations: [{
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "organizations"
  }],
  refId: RefId,
  ratingNumber: {
    type: Number
  },
  ratings: [Rating],
  coins: Coins,
  adminOrganizations: [{
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "organizations"
  }],
  acceptAgreement: {
    type: Boolean,
    default: false
  }
}, {
  timestamps: true
});
schema.plugin(_mongoosejsSoftDelete.default);
schema.plugin(_mongoosePaginateV.default);
schema.pre("save", /*#__PURE__*/function () {
  var _ref = _asyncToGenerator(function* (next) {
    // Hash the password before saving the user model
    var admin = this;

    if (admin.isModified("password")) {
      admin.password = yield _bcrypt.default.hash(admin.password, 8);
    }

    next();
  });

  return function (_x) {
    return _ref.apply(this, arguments);
  };
}());
schema.post("save", (error, doc, next) => {
  if (error.code === 11000) {
    console.log(error);
    next(new _apolloServer.ApolloError(_utils.CAN_NOT_SAVE_TO_DB.message.en, _utils.CAN_NOT_SAVE_TO_DB.code));
  } else next(error);
});

var _default = connection => connection.model("resource_owners", schema, "resource_owners");

exports.default = _default;