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

for server

"use strict";

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

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

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

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

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 mongoosePaginate = require("mongoose-paginate-v2");

var tokenExpired = new _mongoose.default.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
  }
});
var notify = new _mongoose.default.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
  }
});
var login = new _mongoose.default.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
  }
});
var line = new _mongoose.default.Schema({
  notify,
  login
});
var aws = new _mongoose.default.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
  }
});
var smtp = new _mongoose.default.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
  }
});
var socialContact = new _mongoose.default.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"]
  }
});
var contact = new _mongoose.default.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
  }
});
var option = new _mongoose.default.Schema({
  defaultLanguage: {
    type: String,
    required: [false, "defaultLanguage is required"],
    default: "en",
    trim: true
  },
  line,
  aws,
  smtp,
  contact
});
var key = new _mongoose.default.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
  }
});
var template = new _mongoose.default.Schema({
  name: {
    type: String,
    required: [false, "name is required"],
    trim: true
  },
  content: {
    type: String,
    required: [false, "content is required"],
    trim: true
  },
  keys: [key]
});
var attribute = new _mongoose.default.Schema({
  key: {
    type: String,
    required: [true, "key is required"],
    trim: true
  },
  value: {
    type: String,
    required: [true, "value is required"],
    trim: true
  }
});
var featureOption = new _mongoose.default.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
  }
});
var feature = new _mongoose.default.Schema({
  serviceId: {
    type: _mongoose.default.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]
});
var permission = new _mongoose.default.Schema({
  permissionName: {
    type: String,
    trim: true
  },
  code: {
    type: String,
    trim: true
  },
  scopes: [String]
});
var userPermission = new _mongoose.default.Schema({
  permissionType: {
    type: String,
    default: "DEFAULT",
    trim: true
  },
  permissions: [permission]
});
var services = new _mongoose.default.Schema({
  isCoreService: {
    type: Boolean,
    default: false
  },
  service: {
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "services"
  },
  featureKeys: [feature],
  userPermissions: [{
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "permissions"
  }]
});
var credential = new _mongoose.default.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
});
var Option = new _mongoose.default.Schema({
  optionKey: {
    type: String
  },
  value: {
    type: String
  }
});
var Config = new _mongoose.default.Schema({
  configKey: {
    type: String
  },
  options: [Option]
});
var Setting = new _mongoose.default.Schema({
  key: {
    type: String,
    trim: true
  },
  description: {
    type: String,
    trim: true
  },
  value: {
    type: String,
    trim: true
  },
  values: [attribute]
});
var Role = new _mongoose.default.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"
  }
});
var PermissionRole = new _mongoose.default.Schema({
  roleKey: {
    type: String,
    required: [true, "roleKey is required"]
  },
  permissions: [permission]
});
var schema = new _mongoose.default.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.default.Schema.Types.ObjectId,
    ref: "resource_owners"
  }],
  theme: {
    type: _mongoose.default.Schema.Types.ObjectId,
    ref: "themes"
  },
  configs: [Config],
  whitelist: [String]
}, {
  timestamps: true,
  versionKey: false
});
schema.plugin(_mongoosejsSoftDelete.default);
schema.plugin(mongoosePaginate);
schema.pre("save", /*#__PURE__*/function () {
  var _ref = _asyncToGenerator(function* (next) {
    next();
  });

  return function (_x) {
    return _ref.apply(this, arguments);
  };
}());
schema.post("save", (error, doc, next) => {
  if (error.code === 11000) {
    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("applications", schema, "applications");

exports.default = _default;