FM / controllers

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

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

Name	Size	Mode	Actions
tableReserv/	-	0755	rm
userAccount/	-	0755	rm
auth.controller.js	12306	0644	edit dl rm
branch.controller.js	25187	0644	edit dl rm
branchReview.controller.js	5620	0644	edit dl rm
category.controller.js	5521	0644	edit dl rm
company.controller.js	20595	0644	edit dl rm
companyReview.controller.js	5773	0644	edit dl rm
companyTypes.controller.js	2722	0644	edit dl rm
countryCodes.controller.js	2648	0644	edit dl rm
delivery.controller.js	7470	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	31301	0644	edit dl rm
orderCancelCause.controller.js	3460	0644	edit dl rm
payTypes.controller.js	2278	0644	edit dl rm
permission.controller.js	2605	0644	edit dl rm
product.controller.js	25793	0644	edit dl rm
productGroups.controller.js	6568	0644	edit dl rm
productReview.controller.js	5233	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	21794	0644	edit dl rm
userCart.controller.js	7231	0644	edit dl rm
waiter.controller.js	6173	0644	edit dl rm

Edit: /var/www/qr4y.gr/server/delivery/api/controllers/branch.controller.js (25187B)

const logger = require('../../logger')({ service: 'api' })
const checkPermission = require('../utils/checkPermission.util')
const { NotFound, BadRequest } = require('../responseModels/errors')
const { isSet, isEmpty, minLength, isPhone, isEmail } = require('../utils/validator.util')
const { performance } = require('perf_hooks')

const {
	BranchModel,
	BranchListModel,
	BranchUsersListModel,
	BranchListModelByArea
} = require('../responseModels')

module.exports = function ({ db }) {
	this.List = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			let t1 = performance.now()
			checkPermission(req, 'branch_list')
			const { companyId, page, limit } = req.query
			let where = {}
			if (companyId) {
				where['companyId'] = parseInt(companyId)
			}
			let offset = page ? (page - 1) * (limit || 10) : 0

const branches = await db.branch.findAll({
				include: [db.workTime, db.deliveryType, db.address, db.shippingRate, db.room],
				where,
				offset,
				limit: parseInt(limit) || 10
			})
			if (!Array.isArray(branches) || branches.length == 0) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const time = performance.now() - t1
			return res.status(200).json(new BranchListModel({ branches, time }))
		} catch (err) {
			next(err)
		}
	}
	this.ListByArea = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			let t1 = performance.now()
			let { active, working, latitude, longtitude, companyTypeId, page, limit, sort } = req.query

if (!isSet(latitude)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(longtitude)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(companyTypeId)) {
				companyTypeId = 0
			}
			if (!isSet(page)) {
				page = 1
			}
			if (!isSet(limit)) {
				limit = 10
			}
			if (!isSet(sort)) {
				sort = 'asc'
			}

const branches = await SERVICES.BranchService.GetBranchesByArea({
				active,
				working,
				latitude,
				longtitude,
				companyTypeId,
				page,
				limit,
				sort
			})
			const time = performance.now() - t1
			return res
				.status(200)
				.json(new BranchListModelByArea({ branches, time, latitude, longtitude }))
		} catch (err) {
			next(err)
		}
	}
	this.Details = async (req, res, next) => {
		logger.child({ path: req.path, request: req.params }).info()
		try {
			let t1 = performance.now()
			checkPermission(req, 'branch_list')
			const { uid } = req.params
			if (!uid) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

let branch = await db.branch.findOne({
				include: [
					{
						model: db.company,
						as: 'company',
						include: [
							// { model: db.companyType, as: 'companyTypes'},
							// { model: db.productGroup, as: 'product_groups' },
							{ model: db.companyImage }
						]
					},
					{ model: db.branchPrinter, as: 'branchPrinters' },
					{ model: db.address },
					{ model: db.workTime },
					{ model: db.deliveryType },
					{ model: db.shippingRate }
					// { model: db.room,
					// 	// include: {
					// 	// 	model: db.table
					// 	// }
					// },
					// {
					// 	model: db.user,
					// 	include: [
					// 		{ model: db.userPhone, as: 'userPhones' },
					// 		{ model: db.language },
					// 		{ model: db.role }
					// 	]
					// }
				],
				where: { uid: uid }
			})

const rooms = await db.room.findAll({
				include: [db.table], 
				// order: [[db.table,'name']],
				where: { branchId: branch.id }
			})
			const users = await db.branchUsers.findAll({
				include: [
					{
						model: db.user,
						include: [{ model: db.userPhone, as: 'userPhones' }, { model: db.language }]
					},
					{ model: db.role }
				],
				where: { branchId: branch.id }
			})
			const branchPayTypes = await db.branchPayTypes.findAll({
				include: [{ model: db.payType }, { model: db.deliveryType }],
				where: { branchId: branch.id }
			})

u2 = users.map((user) => {
				u = user.user
				u.role = user.role
				return u
			})

if (!branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			branch.rooms = rooms
			branch.users = u2

branch.deliveryTypes.map((dt) => {
				branchPayTypes.map((bpt) => {
					if (dt.id == bpt.deliveryType.id) {
						if (dt.payTypes == undefined) {
							dt.payTypes = []
						}
						dt.payTypes.push(bpt.payType)
					}
				})
			})

let discount = 0
			const companyClient = await db.companyClients.findOne({
				where: { companyId: branch.companyId, userId: req.user.id }
			})
			if (companyClient) {
				discount = companyClient.discount
			}

const time = performance.now() - t1
			return res.status(200).json(new BranchModel(branch, time, discount))
		} catch (err) {
			next(err)
		}
	}
	this.Create = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const {
				active,
				name,
				workMode,
				description,
				site,
				email,
				phone,
				area,
				companyId,
				minimum_order,
				wifi_enabled,
				wifi_show_pass,
				wifi_ssid,
				wifi_pass,
				wifi_type,
				wifi_hide
			} = req.body
			const branch = await db.branch.create({
				active,
				name,
				workMode,
				description,
				site,
				email,
				phone,
				area,
				companyId,
				minimum_order,
				wifi_enabled,
				wifi_show_pass,
				wifi_ssid,
				wifi_pass,
				wifi_type,
				wifi_hide
			})
			const user = await db.user.findOne({ where: { uid: req.user.uid } })
			branch.addUser(user)
			await SERVICES.BranchService.AddBranch(branch)
			return res.status(200).json({
				status: 'success',
				uid: branch.uid
			})
		} catch (err) {
			next(err)
		}
	}
	this.Edit = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const {
				uid,
				active,
				name,
				workMode,
				description,
				site,
				email,
				phone,
				area,
				minimum_order,
				wifi_enabled,
				wifi_show_pass,
				wifi_ssid,
				wifi_pass,
				wifi_type,
				wifi_hide
			} = req.body
			const branch = await db.branch.findOne({ where: { uid: uid } })
			if (!branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			if (active) branch.active = active
			if (name) branch.name = name
			if (workMode) branch.work_mode = workMode
			if (description) branch.description = description
			if (site) branch.site = site
			if (email) branch.email = email
			if (phone) branch.phone = phone
			if (area) branch.area = area
			if (minimum_order) branch.minimum_order = minimum_order
			if (wifi_enabled) branch.wifi_enabled = wifi_enabled
			if (wifi_show_pass) branch.wifi_show_pass = wifi_show_pass
			if (wifi_ssid) branch.wifi_ssid = wifi_ssid
			if (wifi_pass) branch.wifi_pass = wifi_pass
			if (wifi_type) branch.wifi_type = wifi_type
			if (wifi_hide) branch.wifi_hide = wifi_hide

await branch.save()
			await SERVICES.BranchService.ReloadBranch(branch.uid)

return res.status(200).json(new BranchModel(branch))
		} catch (err) {
			next(err)
		}
	}
	this.Delete = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const { uid } = req.body
			if (!isSet(uid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

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

await db.branch.destroy({ where: { uid: uid } })

return res.status(200).json({ status: 'success', uid: branch.uid })
		} catch (err) {
			next(err)
		}
	}
	this.Users = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			let t1 = performance.now()

const { uid, roleInCompanyUid, limit, page } = req.query

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

let where = {}

const branch = await db.branch.findOne({ where: { uid } })
			if (!branch) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			where['branchId'] = branch.id

if (roleInCompanyUid) {
				const role = await db.role.findOne({ where: { uid: roleInCompanyUid } })
				if (!role) {
					throw new BadRequest({ lang: req.user?.languageCode })
				}
				where['roleId'] = role.id
			}

const rows = await db.branchUsers.findAll({
				include: [
					db.branch,
					db.role,
					{ model: db.user, include: [db.role, db.userPhone, db.language] }
				],
				where,
				offset,
				limit: parseInt(limit) || 10
			})

if (!rows || rows.length == 0) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

const time = performance.now() - t1
			return res.status(200).json(new BranchUsersListModel({ rows, page, time }))
		} catch (err) {
			next(err)
		}
	}
	this.AddUser = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const { branchUid, userUid, roleUid } = req.body
			if (!isSet(branchUid) || isEmpty(branchUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(roleUid) || isEmpty(roleUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(userUid) || isEmpty(userUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

const rows = await Promise.all([
				db.branch.findOne({ where: { uid: branchUid } }),
				db.user.findOne({ where: { uid: userUid } }),
				db.role.findOne({ where: { uid: roleUid } })
			])

const [branch, user, role] = rows

if (!branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			if (!role) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			if (!user) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

let branchUser = await db.branchUsers.findOne({
				where: { userId: user.id, branchId: branch.id, roleId: role.id }
			})

if (branchUser) {
				// запись существует
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			await db.branchUsers.create({
				userId: user.id,
				branchId: branch.id,
				roleId: role.id
			})
			return res.status(200).json({ status: 'success' })
		} catch (err) {
			next(err)
		}
	}
	this.RemoveUser = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const { branchUid, userUid, roleUid } = req.body
			if (!isSet(branchUid) || isEmpty(branchUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(roleUid) || isEmpty(roleUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(userUid) || isEmpty(userUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

const rows = await Promise.all([
				db.branch.findOne({ where: { uid: branchUid } }),
				db.user.findOne({ where: { uid: userUid } }),
				db.role.findOne({ where: { uid: roleUid } })
			])

const [branch, user, role] = rows

let branchUser = await db.branchUsers.findOne({
				where: { userId: user.id, branchId: branch.id, roleId: role.id }
			})

if (!branchUser) {
				// запись не существует
				throw new NotFound({ lang: req.user?.languageCode })
			}
			await branchUser.destroy()
			return res.status(200).json({ status: 'success' })
		} catch (err) {
			next(err)
		}
	}
	this.UpdateWorkTime = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const {
				branchUid,
				active,
				dayOfWeek,
				startTime,
				finishTime,
				startTimeBreak,
				finishTimeBreak
			} = req.body
			if (!isSet(branchUid) || isEmpty(branchUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			const branch = await db.branch.findOne({ where: { uid: branchUid } })
			if (!branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const workTime = await db.workTime.findOne({
				where: { branchId: branch.id, dayOfWeek: dayOfWeek }
			})
			if (!workTime) {
				const workTime = await db.workTime.create({
					active,
					dayOfWeek,
					startTime,
					finishTime,
					startTimeBreak,
					finishTimeBreak,
					branchId: branch.id
				})
				if (workTime) {
					return res.status(200).json({ status: 'success' })
				}
			} else {
				workTime.active = active
				workTime.startTime = startTime
				workTime.finishTime = finishTime
				workTime.startTimeBreak = startTimeBreak
				workTime.finishTimeBreak = finishTimeBreak

await workTime.save()

if (workTime) {
					return res.status(200).json({ status: 'success' })
				}
			}
		} catch (err) {
			next(err)
		}
	}

this.SetAddress = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const {
				uid,
				address,
				latitude,
				longtitude,
				addressId,
				street,
				street_number,
				number,
				zip,
				comment,
				doorbell,
				floor
			} = req.body

if (!isSet(address) || isEmpty(address)) {
				throw new BadRequest({ code: 1004, lang: req.user?.languageCode })
			}

var foundAddress
			if (isSet(addressId) || !isEmpty(addressId)) {
				foundAddress = await db.address.findOne({
					where: { id: addressId }
				})
			}
			if (foundAddress) {
				foundAddress.adres = address
				foundAddress.latitude = latitude
				foundAddress.longtitude = longtitude
				foundAddress.street = street
				foundAddress.street_number = street_number
				foundAddress.number = number
				foundAddress.zip = zip
				foundAddress.comment = comment
				foundAddress.doorbell = doorbell
				foundAddress.floor = floor
				await foundAddress.save()
			} else {
				foundAddress = await db.address.create({
					adres: address,
					latitude: latitude,
					longtitude: longtitude,
					street: street,
					street_number: street_number,
					number: number,
					zip: zip,
					comment: comment,
					doorbell: doorbell,
					floor: floor
					// userId: user.id
				})
			}

const branch = await db.branch.findOne({ where: { uid: uid } })
			if (!branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			branch.addressId = foundAddress.id
			await branch.save()
			await SERVICES.BranchService.ReloadBranch(branch.uid)

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

this.AddDeliveryType = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const { branchUid, deliveryTypeUid } = req.body
			if (!branchUid || !deliveryTypeUid) {
				throw new BadRequest({ lang: req.user.languageCode })
			}
			let branch = await db.branch.findOne({
				where: { uid: branchUid }
			})
			const deliveryType = await db.deliveryType.findOne({
				where: { uid: deliveryTypeUid }
			})
			if (!branch) {
				throw new NotFound({ lang: req.user.languageCode })
			}
			if (!deliveryType) {
				throw new NotFound({ lang: req.user.languageCode })
			}
			branch.addDeliveryType(deliveryType)
			await branch.save()
			await SERVICES.BranchService.ReloadBranch(branch.uid)
			return res.status(200).json({ status: 'success' })
		} catch (err) {
			next(err)
		}
	}
	this.RemoveDeliveryType = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'branch_edit')
			const { branchUid, deliveryTypeUid } = req.body
			let branch = await db.branch.findOne({ where: { uid: branchUid } })
			const deliveryType = await db.deliveryType.findOne({
				where: { uid: deliveryTypeUid }
			})
			if (!branch) {
				throw new NotFound({ lang: req.user.languageCode })
			}
			if (!deliveryType) {
				throw new NotFound({ lang: req.user.languageCode })
			}
			branch.removeDeliveryType(deliveryType)
			await branch.save()
			await SERVICES.BranchService.ReloadBranch(branch.uid)
			return res.status(200).json({ status: 'success' })
		} catch (err) {
			next(err)
		}
	}
	this.ListFavorite = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			let t1 = performance.now()
			const uid = req.user.uid

const { limit, page } = req.query

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

const { rows } = await db.branch.findAndCountAll({
				include: [
					{
						model: db.company,
						as: 'company',
						paranoid: false,
						where: { deletedAt: null },
						include: { model: db.companyImage }
					},

{
						model: db.user,
						through: 'favorite_branches',
						as: 'favoriteUsers',
						where: { uid }
					},
					{ model: db.address },
					db.workTime,
					db.deliveryType,
					db.shippingRate
				],
				where: {},
				offset,
				limit: parseInt(limit) || 10
			})
			if (!rows || rows.length == 0) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

const time = performance.now() - t1
			return res
				.status(200)
				.json(new BranchListModel({ branches: rows, count: rows.length, page, time }))
		} catch (err) {
			next(err)
		}
	}
	this.AddFavorite = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			const { branchUid, userUid } = req.body
			if (!isSet(branchUid) || !isSet(userUid) || isEmpty(branchUid) || isEmpty(userUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			const branch = await db.branch.findOne({ where: { uid: branchUid } })
			const user = await db.user.findOne({ where: { uid: userUid } })
			if (!user || !branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			user.addFavoriteBranch(branch)
			return res.status(200).json({ status: 'success' })
		} catch (err) {
			next(err)
		}
	}
	this.RemoveFavorite = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			const { branchUid, userUid } = req.body
			if (!isSet(branchUid) || !isSet(userUid) || isEmpty(branchUid) || isEmpty(userUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			const branch = await db.branch.findOne({ where: { uid: branchUid } })
			const user = await db.user.findOne({ where: { uid: userUid } })
			if (!user || !branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			user.removeFavoriteBranch(branch)
			return res.status(200).json({ status: 'success' })
		} catch (err) {
			next(err)
		}
	}

// PRINTERS

this.AddPrinter = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			let t1 = performance.now()
			checkPermission(req, 'product_edit')
			const { branchUid, branchPrinter } = req.body
			if (!isSet(branchUid) || isEmpty(branchUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			if (!isSet(branchPrinter) || isEmpty(branchPrinter)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

const branch = await db.branch.findOne({
				where: { uid: branchUid }
			})
			if (!branch) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			let printer = JSON.parse(branchPrinter)
			printer.branchId = branch.id

const result = await db.branchPrinter.create(printer)

const time = performance.now() - t1
			return res.status(200).json({ status: 'success', uid: result.uid })
		} catch (err) {
			next(err)
		}
	}

this.EditPrinter = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			let t1 = performance.now()
			checkPermission(req, 'product_edit')
			const { printerUid, name, ip, port } = req.body
			if (!isSet(printerUid) || isEmpty(printerUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			const branchPrinter = await db.branchPrinter.findOne({
				where: { uid: printerUid }
			})
			if (!branchPrinter) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			branchPrinter.name = name
			branchPrinter.ip = ip
			branchPrinter.port = port

branchPrinter.save()

const time = performance.now() - t1
			return res.status(200).json({ status: 'success', uid: branchPrinter.uid })
		} catch (err) {
			next(err)
		}
	}

this.RemovePrinter = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			let t1 = performance.now()
			checkPermission(req, 'product_edit')
			const { printerUid } = req.body
			if (!isSet(printerUid) || isEmpty(printerUid)) {
				throw new BadRequest({ lang: req.user?.languageCode })
			}

await db.branchPrinter.destroy({ where: { uid: printerUid } })

const time = performance.now() - t1
			return res.status(200).json({ status: 'success', uid: printerUid })
		} catch (err) {
			next(err)
		}
	}

this.ListPayTypes = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			let t1 = performance.now()
			//checkPermission(req, 'branch_list')
			const { branchUid, page, limit } = req.query

let where = {}
			if (branchUid) {
				const branch = await db.branch.findOne({ where: { uid: branchUid } })
				if (!branch) throw new BadRequest({ lang: req.user?.languageCode })
				where['branchId'] = branch.id
			} else {
				throw new BadRequest({ lang: req.user?.languageCode })
			}
			let offset = page ? (page - 1) * (limit || 10) : 0

const rows = await db.branchPayTypes.findAll({
				include: [db.payType, db.deliveryType],
				where,
				offset,
				limit: parseInt(limit) || 10
			})
			if (!Array.isArray(rows) || rows.length == 0) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const time = performance.now() - t1
			return res.status(200).json({
				list: rows.map((r) => {
					const { payType, deliveryType } = r
					return {
						id: r.id,
						deliveryType: {
							id: deliveryType.id,
							uid: deliveryType.uid,
							name: deliveryType.name,
							key: deliveryType.key
						},
						payType: {
							id: payType.id,
							uid: payType.uid,
							name: payType.name,
							key: deliveryType.key
						}
					}
				}),
				time
			})
		} catch (err) {
			next(err)
		}
	}

this.AddPayType = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			//checkPermission(req, 'deliveryType_edit')
			const { deliveryTypeUid, payTypeUid, branchUid } = req.body
			if (!deliveryTypeUid || !payTypeUid || !branchUid) {
				throw new BadRequest({ lang: req.user.languageCode })
			}

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

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

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

const branchPayType = await db.branchPayTypes.findOne({
				where: {
					branchId: branch.id,
					deliveryTypeId: deliveryType.id,
					payTypeId: payType.id
				}
			})

if (!branchPayType) {
				await db.branchPayTypes.create({
					branchId: branch.id,
					deliveryTypeId: deliveryType.id,
					payTypeId: payType.id
				})
			}
			await SERVICES.BranchService.ReloadBranch(branch.uid)

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

this.RemovePayType = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			//checkPermission(req, 'deliveryType_edit')
			const { deliveryTypeUid, payTypeUid, branchUid } = req.body
			if (!deliveryTypeUid || !payTypeUid || !branchUid) {
				throw new BadRequest({ lang: req.user.languageCode })
			}

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

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

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

const branchPayType = await db.branchPayTypes.findOne({
				where: {
					branchId: branch.id,
					deliveryTypeId: deliveryType.id,
					payTypeId: payType.id
				}
			})

if (!branchPayType) {
				throw new NotFound({ lang: req.user.languageCode })
			}
			await branchPayType.destroy()
			await SERVICES.BranchService.ReloadBranch(branch.uid)

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

cmd: