FM / controllers

/var/www/verywell.gr/server/delivery/api/controllers/

/var/www/verywell.gr/server/delivery/api/controllers

Name	Size	Mode	Actions
account/	-	0755	rm
tableReserv/	-	0755	rm
auth.controller.js	13187	0644	edit dl rm
branch.controller.js	32443	0644	edit dl rm
branchReview.controller.js	5975	0644	edit dl rm
category.controller.js	5521	0644	edit dl rm
company.controller.js	22632	0644	edit dl rm
companyReview.controller.js	6396	0644	edit dl rm
companyTypes.controller.js	2765	0644	edit dl rm
countryCodes.controller.js	2648	0644	edit dl rm
delivery.controller.js	7624	0644	edit dl rm
deliveryTypes.controller.js	2397	0644	edit dl rm
driver.controller.js	4603	0644	edit dl rm
language.controller.js	2709	0644	edit dl rm
order.controller.js	40326	0644	edit dl rm
orderCancelCause.controller.js	3460	0644	edit dl rm
payTypes.controller.js	2329	0644	edit dl rm
permission.controller.js	2605	0644	edit dl rm
plan.controller.js	3630	0644	edit dl rm
planConfig.controller.js	3465	0644	edit dl rm
product.controller.js	25793	0644	edit dl rm
productGroups.controller.js	6618	0644	edit dl rm
productReview.controller.js	5992	0644	edit dl rm
productTypeFeatures.controller.js	2713	0644	edit dl rm
productTypes.controller.js	4154	0644	edit dl rm
role.controller.js	4012	0644	edit dl rm
room.controller.js	3457	0644	edit dl rm
table.controller.js	15495	0644	edit dl rm
user.controller.js	22213	0644	edit dl rm
userCart.controller.js	7231	0644	edit dl rm
waiter.controller.js	6173	0644	edit dl rm

Edit: /var/www/verywell.gr/server/delivery/api/controllers/table.controller.js (15495B)

const logger = require('../../logger')({ service: 'tableController' })
const { Op } = require('sequelize')
const checkPermission = require('../utils/checkPermission.util')
const { isSet, isEmpty, minLength, isPhone, isEmail } = require('../utils/validator.util')
const { NotFound, BadRequest, ApiError } = require('../responseModels/errors')

module.exports = function ({ db }) {
	this.List = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		let t1 = performance.now()
		try {
			const { roomId, status, limit, page } = req.query

let where = {}
			if (roomId) {
				where['roomId'] = parseInt(roomId)
			}
			if (status) {
				where['status'] = status
			}
			let offset = page > 0 ? (page - 1) * (limit || 10) : 0

const tables = await db.table.findAll({
				include: [
					{
						model: db.order,
						include: [
							{
								model: db.user,
								foreginKey: 'userId',
								as: 'user',
								include: { model: db.userPhone }
							},
							{
								model: db.user,
								foreginKey: 'operatorId',
								as: 'operator',
								include: { model: db.userPhone }
							},
							{ model: db.user, foreginKey: 'orderId', as: 'orderWaiters' }
						]
					}
				],
				where,
				order: [['name', 'ASC']],
				offset,
				limit: parseInt(limit) || 10
			})
			if (tables.length == 0 || !tables) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

const time = performance.now() - t1
			return res.status(200).json({ list: tables, count: tables.length, time, page })
		} catch (err) {
			next(err)
		}
	}
	this.Details = async (req, res, next) => {
		logger.child({ path: req.path, request: req.params }).info()
		try {
			const { uid } = req.params
			if (!isSet(uid) || isEmpty(uid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

const table = await db.table.findOne({
				include: [
					{
						model: db.room,
						foreginKey: 'roomId',
						include: {
							model: db.branch,
							foreginKey: 'branchId',
							include: { model: db.company, foreginKey: 'companyId', as: 'company' }
						}
					}
				],
				where: { uid }
			})
			if (!table) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			return res.status(200).json(table)
		} catch (err) {
			next(err)
		}
	}
	this.History = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			let t1 = performance.now()
			let { tableUid, limit, page, sort, event, eventExclude, eventHandled } = req.query
			let where = {}

if (tableUid) {
				const table = await db.table.findOne({ where: { uid: tableUid } })
				if (table) where['tableId'] = table.id
				else throw new BadRequest({ lang: req.user?.languageCode })
			} else {
				// throw new BadRequest({ lang: req.user?.languageCode })
			}

let offset = page > 0 ? (page - 1) * (limit || 10) : 0

if (eventHandled)
				where['eventHandled'] = eventHandled === 'true' || eventHandled === 1 ? 1 : 0
			if (eventExclude) {
				if (statusExclude === 'true') {
					where['event'] = {
						[Op.not]: event.split(',').map((p) => {
							return p.trim()
						})
					}
				} else {
					where['event'] = {
						[Op.in]: event.split(',').map((p) => {
							return p.trim()
						})
					}
				}
			}

const list = await db.tableHistory.findAll({
				//include: [{ model: db.order }],
				where,
				offset,
				order: [
					['id', 'DESC']
					// ['name', 'ASC'],
				],
				limit: parseInt(limit) || 10
				// sort
			})
			if (list.length == 0 || !list) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

const time = performance.now() - t1
			return res.status(200).json({ list, time, count: list.length })
		} catch (err) {
			next(err)
		}
	}
	this.Create = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			const { name, description, image, places, status, roomId } = req.body

if (!isSet(name) || isEmpty(name)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(roomId)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

const table = await db.table.create({
				name,
				description,
				image,
				places,
				roomId,
				status
			})
			return res.status(200).json({
				status: 'success',
				uid: table.uid
			})
		} catch (err) {
			next(err)
		}
	}
	this.MultiCreate = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			let { count, image, places, status, roomId } = req.body

if (!isSet(count)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(roomId)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

if (!places || parseInt(places) <= 0) {
				places = 4
			}

// посчитать кол-во столов в помещении
			let tableNum = 0
			const tables = await db.table.findAll({ where: { roomId } })
			if (tables && tables.length > 0) {
				tableNum = tables.length + 1
			}

for (i = 0; i < count; i++) {
				tableNum++
				const table = await db.table.create({
					name: tableNum,
					image,
					places,
					roomId,
					status
				})
			}
			return res.status(200).json({
				status: 'success'
			})
		} catch (err) {
			next(err)
		}
	}
	this.Edit = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			const { uid, name, description, image, places, status, roomId, alarm } = req.body
			if (!isSet(uid) || isEmpty(uid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(name) || isEmpty(name)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

const table = await db.table.findOne({
				where: { uid }
			})
			if (!table) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

table.name = name ? name : table.name
			table.description = description ? description : table.description
			table.image = image ? image : table.image
			table.status = status ? status : table.status
			table.roomId = roomId ? parseInt(roomId) : table.roomId
			table.places = places ? parseInt(places) : table.places
			table.alarm = alarm ? alarm : table.alarm

await table.save()

return res.status(200).json(table)
		} catch (err) {
			next(err)
		}
	}
	this.Delete = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			const { uid } = req.body
			const table = await db.table.findOne({
				where: { uid }
			})
			if (!table) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			await db.table.destroy({ where: { uid } })
			return res.status(200).json({ status: 'success', uid })
		} catch (err) {
			next(err)
		}
	}
	this.Set = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			const { uid, status } = req.body
			if (!isSet(uid) || isEmpty(uid)) {
				throw new BadRequest({ code: 1023, lang: req.user?.languageCode })
			}
			if (!isSet(status) || isEmpty(status)) {
				throw new BadRequest({ code: 1022, lang: req.user?.languageCode })
			}

const table = await db.table.findOne({
				include: [db.room],
				where: { uid }
			})
			if (!table) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			if (table.status == status) {
				throw new ApiError({
					code: 1021,
					lang: req.user?.languageCode
				})
			}
			table.status = status

await table.save()
			await db.tableHistory.create({
				tableId: table.id,
				event: table.status,
				created: req.user.app || 'system',
				createdId: req.user.id,
				eventHandled: true,
				processed: 'system'
			})

// TODO: Разослать по всем операторам и официантам этого филиала
			const branchId = table.room?.branchId
			if (branchId) {
				const tableData = {
					uid: table.uid,
					status: table.status
				}

await SERVICES.WebSocketService.SendToOperatorsByBranch(
					branchId,
					'tableStatus',
					tableData
				)
				await SERVICES.WebSocketService.SendToWaitersByBranch(
					branchId,
					'tableStatus',
					tableData
				)
			}

return res.status(200).json({ status: 'success', uid: table.uid, status: table.status })
		} catch (err) {
			next(err)
		}
	}

this.CallWaiter = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		let transaction = await db.sequelize.transaction()
		try {
			const t1 = performance.now()

const { tableUid } = req.body

const table = await db.table.findOne({
				where: { uid: tableUid },
				include: [
					{ model: db.room, include: [{ model: db.branch }] },
					{
						model: db.order,
						include: [
							{
								model: db.user,
								through: 'order_waiters',
								foreginKey: 'orderId',
								as: 'orderWaiters',
								required: false
							}
						],
						required: false,
						where: { status: { [Op.in]: [ORDER_STATUS.ACCEPT] } }
					}
				]
			})
			if (!table) throw new NotFound({ lang: req.user?.languageCode })

const historyItem = await db.tableHistory.create({
				tableId: table.id,
				event: 'waiter',
				created: req.user.app,
				createdId: req.user.id
			})

if (table.orders && table.orders.length > 0) {
				for (const order of table.orders) {
					for (const waiter of order.orderWaiters) {
						await SERVICES.WebSocketService.SendToWaiter(
							waiter.id,
							'tableEvent',
							historyItem
						)
					}
				}
			} else {
				await SERVICES.WebSocketService.SendToWaitersByBranch(
					table.room.branch.id,
					'tableEvent',
					historyItem
				)
			}

await await SERVICES.WebSocketService.SendToOperatorsByBranch(
				table.room.branch.id,
				'tableEvent',
				historyItem
			)

const time = performance.now() - t1
			transaction.commit()
			transaction = null
			return res.status(200).json({ status: 'success', event: historyItem, time })
		} catch (err) {
			transaction?.rollback()
			next(err)
		}
	}

this.CallWaiterAccept = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		let transaction = await db.sequelize.transaction()
		try {
			const t1 = performance.now()

const { tableUid, eventId } = req.body

let historyItem = await db.tableHistory.findOne({ where: { id: eventId } })

if (!historyItem) throw new NotFound({ lang: req.user?.languageCode })
			historyItem.eventHandled = true
			historyItem.processedId = req.user.id
			historyItem.processed = 'waiter'
			await historyItem.save()

await await SERVICES.WebSocketService.SendToOperatorsByBranch(
				table.room.branch.id,
				'tableEvent',
				historyItem
			)

if (historyItem.createdId) {
				await SERVICES.WebSocketService.SendToClient(
					historyItem.createdId,
					'tableEvent',
					historyItem
				)
			}

this.PaymentCheck = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		let transaction = await db.sequelize.transaction()
		try {
			const t1 = performance.now()

const { tableUid, orderUid } = req.body

const order = await db.order.findOne({ where: { uid: orderUid } })
			if (!order) throw new NotFound({ lang: req.user?.languageCode })

const historyItem = await db.tableHistory.create({
				tableId: table.id,
				orderId: order.id,
				event: 'check',
				created: req.user.app,
				createdId: req.user.id
			})

for (const order of table.orders) {
				for (const waiter of order.orderWaiters) {
					await SERVICES.WebSocketService.SendToWaiter(
						waiter.id,
						'tableEvent',
						historyItem
					)
				}
			}
			await await SERVICES.WebSocketService.SendToOperatorsByBranch(
				table.room.branch.id,
				'tableEvent',
				historyItem
			)

this.PaymentCheckAccept = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		let transaction = await db.sequelize.transaction()
		try {
			const t1 = performance.now()

const { tableUid, eventId } = req.body

let historyItem = await db.tableHistory.findOne({ where: { id: eventId } })

for (const order of table.orders) {
				for (const waiter of order.orderWaiters) {
					await SERVICES.WebSocketService.SendToWaiter(
						waiter.id,
						'tableEvent',
						historyItem
					)
				}
			}
			if (historyItem.createdId) {
				await SERVICES.WebSocketService.SendToClient(
					historyItem.createdId,
					'tableEvent',
					historyItem
				)
			}
			await await SERVICES.WebSocketService.SendToOperatorsByBranch(
				table.room.branch.id,
				'tableEvent',
				historyItem
			)

cmd: