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

for server

import mongoose from "mongoose"
import bcrypt from "bcrypt"
import { ApolloError } from "apollo-server"
import mongooseDelete from "mongoosejs-soft-delete"
import mongoosePaginate from "mongoose-paginate-v2"
import { USER_TYPE } from "../constants/configUser"
import { CAN_NOT_SAVE_TO_DB } from "../constants/errors/utils"

const attribute = new mongoose.Schema({
  key: {
    type: String,
    required: [true, "key is required"],
    trim: true,
  },
  value: {
    type: String,
    required: [false, "value is required"],
    trim: true,
  },
})

const verifyToken = new mongoose.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,
  },
})

const permission = new mongoose.Schema({
  permissionName: {
    type: String,
    required: [false, "permissionName is required"],
    trim: true,
  },
  code: {
    type: String,
    // enum: [CODE.YES, CODE.NO],
    trim: true,
  },
})

const userPermission = new mongoose.Schema({
  service: { type: mongoose.Schema.Types.ObjectId, ref: "services" },
  permissions: [permission],
})

const account = new mongoose.Schema({
  value: {
    type: String,
    required: [false, "value is required"],
    //  unique: true,
  },
  verifyStatus: {
    type: String,
    required: [false, "verify is required"],
    default: "NO",
  },
})

const email = new mongoose.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",
  },
})
const role = new mongoose.Schema({
  roleName: {
    type: String,
    required: [true, "Role name is required"],
    default: "Default",
  },
  roleKey: {
    type: String,
    required: [true, "Role Key is required"],
    default: "DEFAULT",
  },
})

const ParentUsers = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: "resource_owners" },
  organizationId: {
    type: mongoose.Schema.Types.ObjectId,
    ref: "organizations",
  },
})

const RefId = new mongoose.Schema({
  value: {
    type: String,
    required: [true, "RefId value is required"],
    trim: true,
  },
  expireIn: {
    type: Date,
    required: [false, "expireIn is required"],
    trim: true,
  },
})
const Rating = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: "resource_owners" },
  value: { type: Number },
  message: { type: String },
})
const Coins = new mongoose.Schema({
  value: { type: Number },
})
const schema = new mongoose.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: USER_TYPE.USER,
    },
    role,
    verifyTokens: [verifyToken],
    application: { type: mongoose.Schema.Types.ObjectId, ref: "applications" },
    attributes: [attribute],
    // New
    userPermission,
    parentUsers: [ParentUsers],
    organizations: [
      { type: mongoose.Schema.Types.ObjectId, ref: "organizations" },
    ],
    refId: RefId,
    ratingNumber: { type: Number },
    ratings: [Rating],
    coins: Coins,
    adminOrganizations: [
      { type: mongoose.Schema.Types.ObjectId, ref: "organizations" },
    ],
    acceptAgreement: { type: Boolean, default: false },
  },
  { timestamps: true }
)

schema.plugin(mongooseDelete)
schema.plugin(mongoosePaginate)

schema.pre("save", async function (next) {
  // Hash the password before saving the user model
  const admin = this
  if (admin.isModified("password")) {
    admin.password = await bcrypt.hash(admin.password, 8)
  }
  next()
})

schema.post("save", (error, doc, next) => {
  if (error.code === 11000) {
    console.log(error)
    next(
      new ApolloError(CAN_NOT_SAVE_TO_DB.message.en, CAN_NOT_SAVE_TO_DB.code)
    )
  } else next(error)
})

export default (connection) =>
  connection.model("resource_owners", schema, "resource_owners")