/var/www/greso.tech/server/nsm/models
Edit: /var/www/greso.tech/server/nsm/models/index.js (13274B)
'use strict'
const fs = require('fs')
const path = require('path')
const mysql = require('mysql2/promise');
const Sequelize = require('sequelize')
const basename = path.basename(__filename)
const env = process.env.NODE_ENV || 'development'
const config = require(__dirname + '/../config/config.json')[env]
const db = {}
db.init = async function () {
let dbStatus = 0
const connection = await mysql.createConnection({
host: config.host,
port: config.port,
user: config.username,
password: config.password
})
try {
await connection.query(`CREATE DATABASE ${config.database};`)
dbStatus = 'created'
} catch (e) {
if (e.code === 'ER_DB_CREATE_EXISTS') dbStatus = 'exists'
}
let sequelize
if (config.use_env_variable) {
sequelize = new Sequelize(process.env[config.use_env_variable], config)
} else {
sequelize = new Sequelize(config.database, config.username, config.password, config)
}
// загрузка моделей
fs.readdirSync(__dirname)
.filter((file) => {
return file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js'
})
.forEach((file) => {
const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes)
db[model.name] = model
})
Object.keys(db).forEach((modelName) => {
if (db[modelName].associate) {
db[modelName].associate(db)
}
})
db.sequelize = sequelize
db.Sequelize = Sequelize
db.Op = Sequelize.Op
// 1:N роль пользователя
db.role.hasMany(db.user)
db.user.belongsTo(db.role, {
foreignKey: 'roleId'
})
// 1:N телефоны пользователя
db.user.hasMany(db.userPhone)
db.userPhone.belongsTo(db.user, {
foreignKey: 'userId'
})
// 1:N emails пользователя
db.user.hasMany(db.userEmail)
db.userEmail.belongsTo(db.user, {
foreignKey: 'userId'
})
// токен к пользователю
db.user.hasOne(db.refreshToken, {
foreignKey: 'userId'
})
db.refreshToken.belongsTo(db.user, {
foreignKey: 'userId'
})
// 1:N токены пользователя
db.user.hasMany(db.userToken)
db.userToken.belongsTo(db.user, {
foreignKey: 'userId'
})
// 1:N история входов пользователя
db.user.hasMany(db.userLoginHistory)
db.userLoginHistory.belongsTo(db.user, {
foreignKey: 'userId'
})
// 1:N отделения компании
db.company.hasMany(db.branch, { as: 'branches' })
db.branch.belongsTo(db.company, {
foreignKey: 'companyId',
as: 'company'
})
// 1:N providers компании
db.company.hasMany(db.providers, { as: 'providers' })
db.providers.belongsTo(db.company, {
foreignKey: 'companyId',
as: 'company'
})
// 1:N склады компании
db.company.hasMany(db.warehouses, { as: 'warehouses' })
db.warehouses.belongsTo(db.company, {
foreignKey: 'companyId',
as: 'company'
})
// 1:N rate area компании
// db.company.hasMany(db.rateAreas, { as: 'rateAreas' })
// db.rateAreas.belongsTo(db.company, {
// foreignKey: 'companyId',
// as: 'company'
// })
// 1:N rate local компании
db.company.hasMany(db.rateLocal, { as: 'rateLocal' })
db.rateLocal.belongsTo(db.company, {
foreignKey: 'companyId',
as: 'company'
})
// 1:N package компании
db.company.hasMany(db.packages, { as: 'packages' })
db.packages.belongsTo(db.company, {
foreignKey: 'companyId',
as: 'company'
})
// 1:N condition компании
db.company.hasMany(db.conditions, { as: 'conditions' })
db.conditions.belongsTo(db.company, {
foreignKey: 'companyId',
as: 'company'
})
// M:N пользователи компании
db.user.belongsToMany(db.company, {
through: db.companyUsers,
foreignKey: 'userId',
as: 'userCompanies'
})
db.company.belongsToMany(db.user, {
through: db.companyUsers,
foreignKey: 'companyId',
as: 'users'
})
db.role.hasOne(db.companyUsers)
db.companyUsers.belongsTo(db.role)
db.user.hasOne(db.companyUsers)
db.companyUsers.belongsTo(db.user)
db.company.hasOne(db.companyUsers)
db.companyUsers.belongsTo(db.company)
// M:N клиенты компании
db.user.belongsToMany(db.company, {
through: db.companyClients,
foreignKey: 'userId',
as: 'clientCompanies'
})
db.company.belongsToMany(db.user, {
through: db.companyClients,
foreignKey: 'companyId',
as: 'clients'
})
db.user.hasOne(db.companyClients)
db.companyClients.belongsTo(db.user)
db.company.hasOne(db.companyClients)
db.companyClients.belongsTo(db.company)
// 1:1 адрес к company
db.address.hasOne(db.company)
db.company.belongsTo(db.address)
// 1:1 адрес к филиалу
db.address.hasOne(db.branch)
db.branch.belongsTo(db.address)
// 1:1 адрес к warehouse
// db.address.hasOne(db.warehouses)
// db.warehouses.belongsTo(db.address, {
// foreignKey: 'addressId',
// as: 'address'
// })
// M:N филиалы к пользователям
db.user.belongsToMany(db.branch, {
through: db.branchUsers,
foreignKey: 'userId',
as: 'userBranches'
})
db.branch.belongsToMany(db.user, {
through: db.branchUsers,
foreignKey: 'branchId',
as: 'users'
})
db.role.hasOne(db.branchUsers)
db.branchUsers.belongsTo(db.role)
db.user.hasOne(db.branchUsers)
db.branchUsers.belongsTo(db.user)
db.branch.hasOne(db.branchUsers)
db.branchUsers.belongsTo(db.branch)
// 1:N items category компании
db.company.hasMany(db.itemsCategory, { as: 'itemsCategory' })
db.itemsCategory.belongsTo(db.company, {
foreignKey: 'companyId'
})
// 1:N группа продукта
db.itemsCategory.hasMany(db.items, { as: 'items' })
db.items.belongsTo(db.itemsCategory, {
foreignKey: 'itemsCategoryId'
})
// 1:N company items
db.company.hasMany(db.items, { as: 'items' })
db.items.belongsTo(db.company, {
foreignKey: 'companyId'
})
// 1:N order pickup address
db.address.hasOne(db.order)
db.order.belongsTo(db.address, {
foreignKey: 'pickupAddressId',
as: 'pickupAddress'
})
// 1:N order delivery address
db.address.hasOne(db.order)
db.order.belongsTo(db.address, {
foreignKey: 'deliveryAddressId',
as: 'deliveryAddress'
})
// 1:N order pickup area
db.rateAreas.hasOne(db.order)
db.order.belongsTo(db.rateAreas, {
foreignKey: 'pickupAreaId',
as: 'pickupArea'
})
// 1:N order delivery area
db.rateAreas.hasOne(db.order)
db.order.belongsTo(db.rateAreas, {
foreignKey: 'deliveryAreaId',
as: 'deliveryArea'
})
// ORDER -->
// 1:N order client
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
foreignKey: 'userId',
as: 'user'
})
// 1:N order destination client
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
foreignKey: 'destinationUserId',
as: 'destinationUser'
})
// 1:N order default worker
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
foreignKey: 'workerId',
as: 'worker'
})
// 1:N order default carrier worker
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
foreignKey: 'carrierWorkerId',
as: 'carrierWorker'
})
// 1:N order default warehouse
db.warehouses.hasMany(db.order)
db.order.belongsTo(db.warehouses, {
foreignKey: 'warehouseId',
as: 'warehouse'
})
// 1:N order default provider
db.providers.hasMany(db.order)
db.order.belongsTo(db.providers, {
foreignKey: 'providerId',
as: 'provider'
})
// 1:N order default branch
db.branch.hasMany(db.order)
db.order.belongsTo(db.branch, {
foreignKey: 'branchId',
as: 'branch'
})
// 1:N order default carrier
db.branch.hasMany(db.order)
db.order.belongsTo(db.branch, {
foreignKey: 'carrierId',
as: 'carrier'
})
// 1:N order sales rep
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
foreignKey: 'salesRepId',
as: 'salesRep'
})
// 1:N order sales qa
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
foreignKey: 'qaId',
as: 'qa'
})
// 1:N documents к заказам
db.order.hasMany(db.orderDocument)
db.orderDocument.belongsTo(db.order, {
foreignKey: 'orderId'
})
// 1:N payment к заказам
db.order.hasMany(db.orderPayment)
db.orderPayment.belongsTo(db.order, {
foreignKey: 'orderId'
})
// 1:N коментарии к заказам
db.order.hasMany(db.orderComment)
db.orderComment.belongsTo(db.order, {
foreignKey: 'orderId'
})
// 1:N история заказа к заказам
db.order.hasMany(db.orderHistory)
db.orderHistory.belongsTo(db.order, {
foreignKey: 'orderId'
})
// 1:N история заказа к пользователям
db.user.hasMany(db.orderHistory)
db.orderHistory.belongsTo(db.user, {
foreignKey: 'userId'
})
///// WORKERS
db.user.hasOne(db.orderMovementWorkers)
db.orderMovementWorkers.belongsTo(db.user)
// M:N Order Movement -> Users
db.orderMovement.belongsToMany(db.user, {
through: db.orderMovementWorkers,
foreignKey: 'orderMovementId',
as: 'workers',
})
db.user.belongsToMany(db.orderMovement, {
through: db.orderMovementWorkers,
foreignKey: 'userId',
as: 'workers',
})
///// WAREHOUSES
// db.user.hasOne(db.orderWarehouses)
// db.orderWarehouses.belongsTo(db.user)
// // M:N Order -> Users
// db.order.belongsToMany(db.user, {
// through: db.orderWarehouses,
// foreignKey: 'orderId',
// })
// db.user.belongsToMany(db.order, {
// through: db.orderWarehouses,
// foreignKey: 'warehouseId',
// })
// -------------------------------------
// 1:N current order inventory
db.orderInventory.hasOne(db.order)
db.order.belongsTo(db.orderInventory, {
foreignKey: 'orderInventoryId',
as: 'inventory'
})
// 1:N order inventories
db.order.hasMany(db.orderInventory,{as: 'inventories'})
db.orderInventory.belongsTo(db.order, {
foreignKey: 'orderId',
})
// // M:N Order -> Inventory -> Items
db.orderInventory.hasMany(db.inventoryItems,{as:'items'})
db.inventoryItems.belongsTo(db.orderInventory, {
foreignKey: 'orderInventoryId',
})
// M:N Order -> Inventory -> Items category
db.orderInventory.hasMany(db.inventoryItemsCategories,{as:'itemsCategory'})
db.inventoryItemsCategories.belongsTo(db.orderInventory, {
foreignKey: 'orderInventoryId',
})
// M:N Order -> Inventory -> Extra
db.orderInventory.hasMany(db.inventoryExtras,{as:'extras'})
db.inventoryExtras.belongsTo(db.orderInventory, {
foreignKey: 'orderInventoryId',
})
// M:N Order -> Inventory -> Items -> Conditions
db.inventoryItems.hasMany(db.inventoryItemsConditions,{as:'conditions'})
db.inventoryItemsConditions.belongsTo(db.inventoryItems, {
foreignKey: 'inventoryItemId',
foreignKeyConstraint: true
})
// M:N Order -> Inventory -> Items -> Destination Conditions
db.inventoryItems.hasMany(db.inventoryItemsDestConditions,{as:'dest_conditions'})
db.inventoryItemsDestConditions.belongsTo(db.inventoryItems, {
foreignKey: 'inventoryItemId',
foreignKeyConstraint: true
})
// M:N Order -> Inventory -> Items -> Packages
db.inventoryItems.hasMany(db.inventoryItemsPackages,{as:'packages'})
db.inventoryItemsPackages.belongsTo(db.inventoryItems, {
foreignKey: 'inventoryItemId',
foreignKeyConstraint: true
})
// M:N Order -> Inventory -> Items -> Attachment
db.inventoryItems.hasMany(db.inventoryItemsAttachments,{as:'attachments'})
db.inventoryItemsAttachments.belongsTo(db.inventoryItems, {
foreignKey: 'inventoryItemId',
foreignKeyConstraint: true
})
// order inventory -------------------------------------
// ORDER <--
if (dbStatus === 'created') await db.sequelize.sync({ alter: true })
// await db.sequelize.sync() // проверяет только наличие таблиц
// await db.sequelize.sync({ force: true }) // удаляет таблицы и создает новые
// await db.sequelize.sync({ alter: true }) // обновляет таблицы
}
module.exports = db