FM / models

/var/www/greso.tech/server/nsm/models

Name	Size	Mode	Actions
address.js	1316	0644	edit dl rm
branch.js	1680	0644	edit dl rm
branchUsers.js	689	0644	edit dl rm
company.js	2631	0644	edit dl rm
companyClients.js	779	0644	edit dl rm
companyUsers.js	694	0644	edit dl rm
condition.js	1028	0644	edit dl rm
config.js	634	0644	edit dl rm
document.js	1183	0644	edit dl rm
emailTemplates.js	962	0644	edit dl rm
extra.js	1258	0644	edit dl rm
index.js	13274	0644	edit dl rm
inventoryExtras.js	1653	0644	edit dl rm
inventoryItems.js	2132	0644	edit dl rm
inventoryItemsAttachment.js	956	0644	edit dl rm
inventoryItemsCategories.js	808	0644	edit dl rm
inventoryItemsConditions.js	814	0644	edit dl rm
inventoryItemsDestConditions.js	831	0644	edit dl rm
inventoryItemsPackages.js	1483	0644	edit dl rm
items.js	1411	0644	edit dl rm
itemsCategory.js	1087	0644	edit dl rm
leadDistribution.js	467	0644	edit dl rm
links.js	788	0644	edit dl rm
merchant.js	1257	0644	edit dl rm
order.js	4693	0644	edit dl rm
orderComment.js	746	0644	edit dl rm
orderDocument.js	1488	0644	edit dl rm
orderHistory.js	1140	0644	edit dl rm
orderInventory.js	5194	0644	edit dl rm
orderMessage.js	950	0644	edit dl rm
orderMovement.js	1529	0644	edit dl rm
orderMovementWorkers.js	714	0644	edit dl rm
orderPayment.js	2117	0644	edit dl rm
package.js	1184	0644	edit dl rm
payType.js	1046	0644	edit dl rm
provider.js	1019	0644	edit dl rm
rateArea.js	1228	0644	edit dl rm
rateItem.js	951	0644	edit dl rm
rateLocal.js	876	0644	edit dl rm
refreshToken.js	1281	0644	edit dl rm
role.js	2039	0644	edit dl rm
truck.js	1180	0644	edit dl rm
user.js	1583	0644	edit dl rm
userEmail.js	1419	0644	edit dl rm
userLoginHistory.js	1396	0644	edit dl rm
userPhone.js	744	0644	edit dl rm
userToken.js	1243	0644	edit dl rm
valuation.js	817	0644	edit dl rm
warehouse.js	1271	0644	edit dl rm
zipCodes.js	1014	0644	edit dl rm
zipRadius.js	1271	0644	edit dl rm

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

cmd: