FM / models

/var/www/p4ela.kz/server/delivery/models/

/var/www/p4ela.kz/server/delivery/models

Name	Size	Mode	Actions
account.js	1189	0644	edit dl rm
accountHistory.js	1267	0644	edit dl rm
address.js	1272	0644	edit dl rm
branch.js	2127	0644	edit dl rm
branchPayTypes.js	616	0644	edit dl rm
branchPrinters.js	820	0644	edit dl rm
branchPrintTemplate.js	1099	0644	edit dl rm
branchProducts.js	1704	0644	edit dl rm
branchReviews.js	767	0644	edit dl rm
branchShift.js	1296	0644	edit dl rm
branchUsers.js	581	0644	edit dl rm
category.js	945	0644	edit dl rm
categoryImage.js	1074	0644	edit dl rm
company.js	2153	0644	edit dl rm
companyClients.js	684	0644	edit dl rm
companyImage.js	1070	0644	edit dl rm
companyReviews.js	771	0644	edit dl rm
companyType.js	730	0644	edit dl rm
companyUsers.js	586	0644	edit dl rm
countryCode.js	703	0644	edit dl rm
deliveryType.js	854	0644	edit dl rm
driver.js	645	0644	edit dl rm
index.js	16230	0644	edit dl rm
language.js	621	0644	edit dl rm
message.js	813	0644	edit dl rm
order.js	2945	0644	edit dl rm
orderAddress.js	870	0644	edit dl rm
orderCancelCause.js	730	0644	edit dl rm
orderHistory.js	1006	0644	edit dl rm
orderItems.js	1329	0644	edit dl rm
orderPay.js	900	0644	edit dl rm
orderWaiters.js	495	0644	edit dl rm
payType.js	757	0644	edit dl rm
permission.js	731	0644	edit dl rm
plan.js	1240	0644	edit dl rm
planConfig.js	1038	0644	edit dl rm
product.js	1460	0644	edit dl rm
productExtra.js	696	0644	edit dl rm
productFeature.js	643	0644	edit dl rm
productGroup.js	1487	0644	edit dl rm
productGroupImage.js	1056	0644	edit dl rm
productImage.js	1035	0644	edit dl rm
productIngridient.js	716	0644	edit dl rm
productReviews.js	841	0644	edit dl rm
productType.js	664	0644	edit dl rm
productTypeFeature.js	660	0644	edit dl rm
productVariant.js	794	0644	edit dl rm
refreshToken.js	1218	0644	edit dl rm
role.js	819	0644	edit dl rm
room.js	837	0644	edit dl rm
shippingRate.js	1918	0644	edit dl rm
table.js	1149	0644	edit dl rm
tableHistory.js	1223	0644	edit dl rm
tableReserv.js	1453	0644	edit dl rm
user.js	2321	0644	edit dl rm
userCartItem.js	1267	0644	edit dl rm
userGoogleToken.js	874	0644	edit dl rm
userLoginHistory.js	1421	0644	edit dl rm
userPhone.js	836	0644	edit dl rm
userToken.js	1234	0644	edit dl rm
workTime.js	979	0644	edit dl rm

Edit: /var/www/p4ela.kz/server/delivery/models/index.js (16230B)

'use strict'

const fs = require('fs')
const path = require('path')
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 = {}

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.user.hasOne(db.refreshToken, {
	foreignKey: 'userId'
	// targetKey: 'id'
})
db.refreshToken.belongsTo(db.user, {
	foreignKey: 'userId'
	// targetKey: 'id'
})

db.address.hasOne(db.user)
db.user.belongsTo(db.address, {
	foreignKey: 'defaultAddressId'
})

// 1:N телефоны пользователя
db.user.hasMany(db.userPhone)
db.userPhone.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N токены пользователя
db.user.hasMany(db.userToken)
db.userToken.belongsTo(db.user, {
	foreignKey: 'userId'
})
// 1:N google токены пользователя
db.user.hasMany(db.userGoogleToken)
db.userGoogleToken.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N история входов пользователя
db.user.hasMany(db.userLoginHistory)
db.userLoginHistory.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N адреса к пользователям
db.user.hasMany(db.address)
db.address.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N карзина пользователя
db.user.hasMany(db.userCartItem)
db.userCartItem.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N карзина пользователя
db.product.hasOne(db.userCartItem)
db.userCartItem.belongsTo(db.product)

// 1:N product printer
db.branchPrinter.hasMany(db.product)
db.product.belongsTo(db.branchPrinter, {
	foreignKey: 'printerId'
})

// 1:N роль пользователя
db.role.hasMany(db.user, { as: 'users' })
db.user.belongsTo(db.role, {
	foreignKey: 'roleId'
})

// 1:N язык пользователя
db.language.hasMany(db.user, { as: 'users' })
db.user.belongsTo(db.language, {
	foreignKey: 'languageId'
})

// 1:N счета пользователя
db.branch.hasMany(db.account)
db.account.belongsTo(db.branch, {
	foreignKey: 'branchId'
})
// 1:N счета компании
db.company.hasMany(db.account)
db.account.belongsTo(db.company, {
	foreignKey: 'companyId'
})
// 1:N счета филиала
db.user.hasMany(db.account)
db.account.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N история счетов пользователя
db.account.hasMany(db.accountHistory)
db.accountHistory.belongsTo(db.account, {
	foreignKey: 'accountId'
})

// 1:1 водитель к пользователю
db.user.hasOne(db.driver)
db.driver.belongsTo(db.user)

// M:N разрешения к ролям
db.permission.belongsToMany(db.role, {
	through: 'roles_permissions',
	foreignKey: 'permissionId'
})
db.role.belongsToMany(db.permission, {
	through: 'roles_permissions',
	foreignKey: 'roleId'
})

// 1:N категории подкатегории
db.category.hasMany(db.category, { as: 'subcategories' })

// 1:N картинки категории
db.category.hasMany(db.categoryImage)
db.categoryImage.belongsTo(db.category, {
	foreignKey: 'categoryId'
})

// 1:N отделения компании
db.company.hasMany(db.branch, { as: 'branches' })
db.branch.belongsTo(db.company, {
	foreignKey: 'companyId',
	as: 'company'
})

// 1:N картинки категории
db.company.hasMany(db.companyImage)
db.companyImage.belongsTo(db.company, {
	foreignKey: 'companyId'
})

// 1:N отзывы о компании
db.company.hasMany(db.companyReview)
db.companyReview.belongsTo(db.company, {
	foreignKey: 'companyId'
})

// 1:N отзывы пользователя о компании
db.user.hasMany(db.companyReview)
db.companyReview.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N отзывы о филиале
db.branch.hasMany(db.branchReview)
db.branchReview.belongsTo(db.branch, {
	foreignKey: 'branchId'
})

// 1:N отзывы пользователя о филиале
db.user.hasMany(db.branchReview)
db.branchReview.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N тип оплаты заказа
db.payType.hasMany(db.order)
db.order.belongsTo(db.payType, {
	foreignKey: 'payTypeId'
})
// 1:N тип оплаты доставки
db.payType.hasMany(db.order)
db.order.belongsTo(db.payType, {
	as: 'deliveryPayType',
	foreignKey: 'deliveryPayTypeId'
})
// 1:N тип доставки
db.deliveryType.hasMany(db.order)
db.order.belongsTo(db.deliveryType, {
	foreignKey: 'deliveryTypeId'
})

// 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)

// M:N избранные компании
db.user.belongsToMany(db.company, {
	through: 'favorite_companies',
	foreignKey: 'userId',
	as: 'favoriteCompanies'
})
db.company.belongsToMany(db.user, {
	through: 'favorite_companies',
	foreignKey: 'companyId',
	as: 'favoriteUsers'
})

// M:N избранные филиалы
db.user.belongsToMany(db.branch, {
	through: 'favorite_branches',
	foreignKey: 'userId',
	as: 'favoriteBranches'
})
db.branch.belongsToMany(db.user, {
	through: 'favorite_branches',
	foreignKey: 'branchId',
	as: 'favoriteUsers'
})

// 1:1 адрес к филиалу
db.address.hasOne(db.branch)
db.branch.belongsTo(db.address)

// 1:N время работы филиала
db.branch.hasMany(db.workTime)
db.workTime.belongsTo(db.branch, {
	foreignKey: 'branchId'
})

// 1:N printers филиала
db.branch.hasMany(db.branchPrinter)
db.branchPrinter.belongsTo(db.branch, {
	foreignKey: 'branchId',
	as: 'branchPrinters'
})

// 1:N print template филиала
db.branch.hasMany(db.branchPrintTemplate)
db.branchPrintTemplate.belongsTo(db.branch, {
	foreignKey: 'branchId',
	as: 'branchPrintTemplates'
})

// 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)

// M:N филиалы к delivery types
db.branch.belongsToMany(db.deliveryType, {
	through: 'branches_delivery_types',
	foreignKey: 'branchId'
})
db.deliveryType.belongsToMany(db.branch, {
	through: 'branches_delivery_types',
	foreignKey: 'deliveryTypeId'
})

// 1:N тарифы типа доставки
db.deliveryType.hasMany(db.shippingRate)
db.shippingRate.belongsTo(db.deliveryType)

// 1:N тарифы филиала
db.branch.hasMany(db.shippingRate)
db.shippingRate.belongsTo(db.branch)

// M:N филиалы к пользователям
db.payType.belongsToMany(db.branch, {
	through: db.branchPayTypes,
	foreignKey: 'payTypeId',
	as: 'payTypeBranches'
})
db.branch.belongsToMany(db.payType, {
	through: db.branchPayTypes,
	foreignKey: 'branchId',
	as: 'payTypes'
})
db.payType.hasOne(db.branchPayTypes)
db.branchPayTypes.belongsTo(db.payType)
db.deliveryType.hasOne(db.branchPayTypes)
db.branchPayTypes.belongsTo(db.deliveryType)
db.branch.hasOne(db.branchPayTypes)
db.branchPayTypes.belongsTo(db.branch)

// // M:N типы оплаты типов доставки
// db.deliveryType.belongsToMany(db.payType, {
// 	through: 'delivery_types_pay_types',
// 	foreignKey: 'deliveryTypeId'
// })
// db.payType.belongsToMany(db.deliveryType, {
// 	through: 'delivery_types_pay_types',
// 	foreignKey: 'payTypeId'
// })

// M:N типы компаний к компаниям
db.company.belongsToMany(db.companyType, {
	through: 'companies_types',
	foreignKey: 'companyId'
})
db.companyType.belongsToMany(db.company, {
	through: 'companies_types',
	foreignKey: 'companyTypeId'
})

// 1:N группы продуктов компании
db.company.hasMany(db.productGroup, { as: 'product_groups' })
db.productGroup.belongsTo(db.company, {
	foreignKey: 'companyId'
})

// 1:N продукты компании
db.company.hasMany(db.product, { as: 'products' })
db.product.belongsTo(db.company, {
	foreignKey: 'companyId'
})

// 1:N тип продукта
db.productType.hasMany(db.product, { as: 'products' })
db.product.belongsTo(db.productType, {
	foreignKey: 'productTypeId'
})

// 1:N группа продукта
db.productGroup.hasMany(db.product, { as: 'products' })
db.product.belongsTo(db.productGroup, {
	foreignKey: 'productGroupId'
})

// 1:N изображения продукта
db.product.hasMany(db.productImage)
db.productImage.belongsTo(db.product, {
	foreignKey: 'productId',
	as: 'productImages'
})

// 1:N extras продукта
db.product.hasMany(db.productExtra)
db.productExtra.belongsTo(db.product, {
	foreignKey: 'productId',
	as: 'productExtras'
})

// 1:N variants продукта
db.product.hasMany(db.productVariant)
db.productVariant.belongsTo(db.product, {
	foreignKey: 'productId',
	as: 'productVariants'
})

// 1:N ingridients продукта
db.product.hasMany(db.productIngridient)
db.productIngridient.belongsTo(db.product, {
	foreignKey: 'productId',
	as: 'productIngridients'
})

// 1:N
db.product.hasMany(db.branchProduct)
db.branchProduct.belongsTo(db.product, {
	foreignKey: 'productId',
	as: 'branchProduct'
})

// 1:N изображения группы продукта
db.productGroup.hasMany(db.productGroupImage)
db.productGroupImage.belongsTo(db.productGroup, {
	foreignKey: 'productGroupId',
	as: 'productGroupImages'
})

// M:N опции типа продукта
db.productType.belongsToMany(db.productTypeFeature, {
	through: 'product_type_features_product_types',
	foreignKey: 'productTypeId'
})
db.productTypeFeature.belongsToMany(db.productType, {
	through: 'product_type_features_product_types',
	foreignKey: 'productTypeFeatureId'
})

db.productTypeFeature.hasMany(db.productFeature)
db.productFeature.belongsTo(db.productTypeFeature, {
	foreignKey: 'productTypeFeatureId'
})
// 1:N опции продукта
db.product.hasMany(db.productFeature)
db.productFeature.belongsTo(db.product, {
	foreignKey: 'productId'
})

// 1:N отзывы о продукте
db.product.hasMany(db.productReview)
db.productReview.belongsTo(db.product, {
	foreignKey: 'productId'
})

// M:N избранные продукты пользователя
db.user.belongsToMany(db.product, {
	through: 'favorite_products',
	foreignKey: 'userId',
	as: 'favoriteProducts'
})
db.product.belongsToMany(db.user, {
	through: 'favorite_products',
	foreignKey: 'productId',
	as: 'favoriteUsers'
})

// 1:N отзывы пользователя о продукте
db.user.hasMany(db.productReview)
db.productReview.belongsTo(db.user, {
	foreignKey: 'userId'
})

// 1:N категория продукта
db.category.hasMany(db.product, { as: 'categories' })
db.product.belongsTo(db.category, {
	foreignKey: 'categoryId'
})

// 1:N цены и остаток продукта
db.product.hasMany(db.branchProduct)
db.branchProduct.belongsTo(db.product, {
	foreignKey: 'productId'
})

// 1:N продукты отделения
db.branch.hasMany(db.branchProduct, { as: 'products' })
db.branchProduct.belongsTo(db.branch, {
	foreignKey: 'branchId'
})

// 1:N заказы отделения
db.branch.hasMany(db.order)
db.order.belongsTo(db.branch, {
	foreignKey: 'branchId'
})
// 1:N заказы компании
db.company.hasMany(db.order)
db.order.belongsTo(db.company, {
	foreignKey: 'companyId'
})

// 1:N рабочие смены филиала
db.branch.hasMany(db.branchShift)
db.branchShift.belongsTo(db.branch, {
	foreignKey: 'branchId'
})

// 1:N причины отмены заказа
db.orderCancelCause.hasOne(db.order)
db.order.belongsTo(db.orderCancelCause)

// 1:N адреса доставки
db.order.hasOne(db.orderAddress)
db.orderAddress.belongsTo(db.order, {
	foreignKey: 'orderId'
})

// 1:N товары заказа
db.order.hasMany(db.orderItems)
db.orderItems.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: 'orderId'
})

// 1:N карзина пользователя
db.product.hasOne(db.orderItems)
db.orderItems.belongsTo(db.product)

// 1:N заказы клиента
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
	foreignKey: 'userId',
	as: 'user'
})

// 1:N заказы водителя
db.driver.hasMany(db.order)
db.order.belongsTo(db.driver, {
	foreignKey: 'driverId',
	as: 'driver'
})

// 1:N заказы оператора
db.user.hasMany(db.order)
db.order.belongsTo(db.user, {
	foreignKey: 'operatorId',
	as: 'operator'
})

// 1:N комнаты филиала
db.branch.hasMany(db.room)
db.room.belongsTo(db.branch)

// 1:N столы комнаты
db.room.hasMany(db.table)
db.table.belongsTo(db.room)

// 1:N заказы стола
db.table.hasMany(db.order)
db.order.belongsTo(db.table)

// 1:N история стола
db.table.hasMany(db.tableHistory)
db.tableHistory.belongsTo(db.table,{
	foreignKey: 'tableId'
})

// 1:N брони филиала
// db.branch.hasMany(db.tableReserv)
// db.tableReserv.belongsTo(db.branch,{
// 	foreignKey: 'branchId'
// })
// 1:N брони стола
// db.table.hasMany(db.tableReserv)
// db.tableReserv.belongsTo(db.table,{
// 	foreignKey: 'tableId'
// })
// 1:N заказы брони стола
db.tableReserv.hasMany(db.order)
db.order.belongsTo(db.tableReserv)

// M:N офицанты заказа
db.order.belongsToMany(db.user, {
	through: 'order_waiters',
	foreignKey: 'orderId',
	as: 'orderWaiters'
})
db.user.belongsToMany(db.order, {
	through: 'order_waiters',
	foreignKey: 'userId',
	as: 'waiterOrders',
})

// PLANS
db.plan.hasMany(db.planConfig)
db.planConfig.belongsTo(db.plan)
db.plan.hasMany(db.company)
db.company.belongsTo(db.plan)

// M:N офицанты заказа
// db.company.belongsToMany(db.plan, {
// 	through: 'company_plans',
// 	foreignKey: 'companyId',
// 	as: 'companyPlans'
// })
// db.plan.belongsToMany(db.company, {
// 	through: 'company_plans',
// 	foreignKey: 'planId',
// 	as: 'planCompanies',
// })

// 1:N телефоны пользователя
// db.planConfig.hasOne(db.plan)
// db.plan.belongsTo(db.planConfig, {
// 	foreignKey: 'planId'
// })

db.sequelize = sequelize
db.Sequelize = Sequelize

// db.sequelize.sync() // проверяет только наличие таблиц
// db.sequelize.sync({ force: true }) // удаляет таблицы и создает новые
//db.sequelize.sync({ alter: true }) // обновляет таблицы

module.exports = db

cmd: