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

for server

import mongoose from "mongoose"
import { ApolloError } from "apollo-server"
import mongooseDelete from "mongoosejs-soft-delete"
import { CAN_NOT_SAVE_TO_DB } from "../constants/errors/utils"

const mongoosePaginate = require("mongoose-paginate-v2")

const tokenExpired = new mongoose.Schema({
  accessTokenExpired: {
    type: String,
    required: [false, "accessToken expired is required"],
    default: "3m",
    trim: true,
  },
  refreshTokenExpired: {
    type: String,
    required: [false, "refreshToken expired is required"],
    default: "15m",
    trim: true,
  },
})

const notify = new mongoose.Schema({
  notifyToken: {
    type: String,
    required: [false, "notifyToken is required"],
    trim: true,
  },
  isSendNotify: {
    type: Boolean,
    required: [false, "isSendNotify is required"],
    default: false,
    trim: true,
  },
  notificationDisabled: {
    type: Boolean,
    required: [false, "notificationDisabled is required"],
    default: false,
    trim: true,
  },
})

const login = new mongoose.Schema({
  clientId: {
    type: String,
    required: [false, "clientId is required"],
    trim: true,
  },
  clientSecret: {
    type: String,
    required: [false, "clientSecret is required"],
    trim: true,
  },
  redirectUri: {
    type: String,
    required: [false, "redirectUri is required"],
    trim: true,
  },
})

const line = new mongoose.Schema({
  notify,
  login,
})

const aws = new mongoose.Schema({
  cloudWatchEnable: {
    type: Boolean,
    required: [false, "cloudWatchEnable is required"],
    default: false,
    trim: true,
  },
  accessKey: {
    type: String,
    required: [false, "accessKey is required"],
    trim: true,
  },
  secretKey: {
    type: String,
    required: [false, "secretKey is required"],
    trim: true,
  },
  region: {
    type: String,
    required: [false, "region is required"],
    trim: true,
  },
  bucketName: {
    type: String,
    required: [false, "bucketName is required"],
    trim: true,
  },
  endpoint: {
    type: String,
    required: [false, "endpoint is required"],
    trim: true,
  },
})
const smtp = new mongoose.Schema({
  host: {
    type: String,
    required: [false, "host is required"],
    trim: true,
  },
  port: {
    type: Number,
    required: [false, "port is required"],
    trim: true,
  },
  tls: {
    type: String,
    required: [false, "tls is required"],
    default: "no",
    trim: true,
  },
  username: {
    type: String,
    required: [false, "username is required"],
    trim: true,
  },
  password: {
    type: String,
    required: [false, "password is required"],
    trim: true,
  },
  senderEmail: {
    type: String,
    required: [false, "senderEmail is required"],
    trim: true,
  },
})

const socialContact = new mongoose.Schema({
  platform: { type: String, required: [true, "Platform is required"] },
  logo: { type: String, required: [true, "Logo is required"] },
  title: { type: String, required: [true, "Title is required"] },
  link: { type: String, required: [true, "Link is required"] },
})

const contact = new mongoose.Schema({
  address: { type: String, required: [true, "Address is required"] },
  companyName: { type: String, required: [true, "Company is required"] },
  email: { type: String, required: [true, "Email is required"] },
  tel: { type: String, required: [true, "Tel is required"] },
  socialContact: [socialContact],
  officeDay: { type: String, required: [true, "Office day is required"] },
  detail: { type: String },
})

const option = new mongoose.Schema({
  defaultLanguage: {
    type: String,
    required: [false, "defaultLanguage is required"],
    default: "en",
    trim: true,
  },
  line,
  aws,
  smtp,
  contact,
})

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

const template = new mongoose.Schema({
  name: {
    type: String,
    required: [false, "name is required"],
    trim: true,
  },
  content: {
    type: String,
    required: [false, "content is required"],
    trim: true,
  },
  keys: [key],
})

const attribute = new mongoose.Schema({
  key: {
    type: String,
    required: [true, "key is required"],
    trim: true,
  },
  value: {
    type: String,
    required: [true, "value is required"],
    trim: true,
  },
})
const featureOption = new mongoose.Schema({
  key: {
    type: String,
    required: [true, "key is required"],
    trim: true,
  },
  enable: {
    type: Boolean,
    required: [false, "Enable is required"],
    default: true,
  },
  description: {
    type: String,
    required: [false, "description is required"],
    trim: true,
  },
})
const feature = new mongoose.Schema({
  serviceId: { type: mongoose.Schema.Types.ObjectId, ref: "services" },
  key: {
    type: String,
    required: [false, "Key is required"],
    trim: true,
  },
  description: {
    type: String,
    required: [false, "Description is required"],
    trim: true,
  },
  enable: {
    type: Boolean,
    required: [false, "Enable is required"],
    default: true,
  },
  featureOptions: [featureOption],
})

const permission = new mongoose.Schema({
  permissionName: {
    type: String,
    trim: true,
  },
  code: {
    type: String,
    trim: true,
  },
  scopes: [String],
})

const userPermission = new mongoose.Schema({
  permissionType: {
    type: String,
    default: "DEFAULT",
    trim: true,
  },
  permissions: [permission],
})

const services = new mongoose.Schema({
  isCoreService: { type: Boolean, default: false },
  service: { type: mongoose.Schema.Types.ObjectId, ref: "services" },
  featureKeys: [feature],
  userPermissions: [
    { type: mongoose.Schema.Types.ObjectId, ref: "permissions" },
  ],
})

const credential = new mongoose.Schema({
  isAdminCredential: { type: Boolean, default: false },
  name: {
    type: String,
    required: [true, "name is required"],
    trim: true,
  },
  secretKey: {
    type: String,
    required: [true, "secret key is required"],
    trim: true,
  },
  credentialKey: {
    type: String,
    required: [true, "credential key is required"],
    trim: true,
  },
  tokenExpired,
})

const Option = new mongoose.Schema({
  optionKey: {
    type: String,
  },
  value: {
    type: String,
  },
})

const Config = new mongoose.Schema({
  configKey: {
    type: String,
  },
  options: [Option],
})

const Setting = new mongoose.Schema({
  key: {
    type: String,
    trim: true,
  },
  description: {
    type: String,
    trim: true,
  },
  value: {
    type: String,
    trim: true,
  },
  values: [attribute],
})

const Role = new mongoose.Schema({
  roleName: {
    type: String,
    required: [false, "roleName is required"],
  },
  roleKey: {
    type: String,
    required: [false, "roleKey is required"],
  },
  status: {
    type: String,
    required: [false, "status is required"],
  },
  default: {
    type: String,
    required: [false, "default is required"],
  },
  replaceable: {
    type: String,
    required: [false, "replaceable is required"],
    enum: ["YES", "NO"],
    default: "NO",
  },
})
const PermissionRole = new mongoose.Schema({
  roleKey: { type: String, required: [true, "roleKey is required"] },
  permissions: [permission],
})

const schema = new mongoose.Schema(
  {
    name: {
      type: String,
      required: [true, "Name is required"],
      trim: true,
    },
    appKey: {
      type: String,
      required: [true, "appKey is required"],
      trim: true,
    },
    option,
    settings: [Setting],
    templates: [template],
    attributes: [attribute],
    services: [services],
    roles: [Role],
    permissionRoles: [PermissionRole],
    credentials: [credential],
    resourceOwners: [
      { type: mongoose.Schema.Types.ObjectId, ref: "resource_owners" },
    ],
    theme: { type: mongoose.Schema.Types.ObjectId, ref: "themes" },
    configs: [Config],
    whitelist: [String],
  },
  { timestamps: true, versionKey: false }
)

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

schema.pre("save", async (next) => {
  next()
})

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

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