FM / controllers

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

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

Name	Size	Mode	Actions
account/	-	0755	rm
auth/	-	0755	rm
country_code/	-	0755	rm
delivery_server/	-	0755	rm
iap/	-	0755	rm
order/	-	0755	rm
qr/	-	0755	rm
system/	-	0755	rm
branch.controller.js	29869	0644	edit dl rm
branchApp.controller.js	4686	0644	edit dl rm
branchReview.controller.js	6321	0644	edit dl rm
company.controller.js	25111	0644	edit dl rm
companyReview.controller.js	6368	0644	edit dl rm
companyTypes.controller.js	3134	0644	edit dl rm
delivery.controller.js	2827	0644	edit dl rm
deliveryTypes.controller.js	2382	0644	edit dl rm
driver.controller.js	4580	0644	edit dl rm
gallery.controller.js	7929	0644	edit dl rm
language.controller.js	2709	0644	edit dl rm
orderCancelCause.controller.js	3442	0644	edit dl rm
payTypes.controller.js	2314	0644	edit dl rm
permission.controller.js	2590	0644	edit dl rm
plan.controller.js	3618	0644	edit dl rm
planConfig.controller.js	3453	0644	edit dl rm
product.controller.js	13402	0644	edit dl rm
productFilters.controller.js	3301	0644	edit dl rm
productGroups.controller.js	6538	0644	edit dl rm
productReview.controller.js	6164	0644	edit dl rm
productTypeFilters.controller.js	2964	0644	edit dl rm
productTypeFiltersValues.controller.js	3149	0644	edit dl rm
productTypes.controller.js	2690	0644	edit dl rm
role.controller.js	3982	0644	edit dl rm
room.controller.js	3443	0644	edit dl rm
table.controller.js	15454	0644	edit dl rm
user.controller.js	25502	0644	edit dl rm
userCart.controller.js	5827	0644	edit dl rm
waiter.controller.js	6167	0644	edit dl rm

Edit: /var/www/qr4y.com/server/delivery/api/controllers/user.controller.js (25502B)

const logger = require('../../logger')({ service: 'api' })
const bcrypt = require('bcryptjs')
const { Op } = require('sequelize')
const PointInPolygon = require('point-in-polygon')
const { UserModel, UsersListModel } = require('../responseModels')
const { NotFound, BadRequest } = require('../responseModels/errors')
const { isSet, isEmpty, isArray, minLength, isPhone, isEmail } = require('../utils/validator.util')
const checkPermission = require('../utils/checkPermission.util')

module.exports = function ({ db }) {
	this.Profile = async (req, res, next) => {
		logger.child({ path: req.path, user: req.user.id }).info()
		try {
			let user = await db.user.findOne({
				include: [{ model: db.language }],
				where: { id: req.user.id }
			})

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

const userData = await Promise.all([
				/*0*/ db.role.findOne({
					include: {
						model: db.permission,
						through: { attributes: [] }
					},
					where: { id: user.roleId }
				}),
				/*1*/ db.userLoginHistory.findAll({ where: { userId: user.id }, limit: 10, order: [['createdAt', 'DESC']] }),
				/*2*/ db.userPhone.findAll({ where: { userId: user.id }, limit: 10 }),
				/*3*/ db.userToken.findAll({ where: { userId: user.id }, limit: 10 }),
				/*4*/ db.address.findAll({ where: { userId: user.id }, limit: 10 }),
				/*5*/ db.companyClients.findAll({
					include: { model: db.company, where: { deletedAt: null } },
					where: { userId: user.id }
				}),
				/*6*/ db.companyUsers.findAll({
					include: [
						{ model: db.company, include: [{ model: db.companyImage }], paranoid: false, where: { deletedAt: null } },
						{ model: db.role }
					],
					where: { userId: user.id }
				}),
				/*7*/ db.branchUsers.findAll({
					include: [
						{
							model: db.branch,
							include: [
								{
									model: db.company,
									as: 'company',
									paranoid: false,
									where: { deletedAt: null }
								}
							],
							paranoid: false,
							where: { deletedAt: null }
						},
						{ model: db.role }
					],
					where: { userId: user.id, '$branch.company.deletedAt$': null }
				}),
				/*8*/ db.userGoogleToken.findAll({ where: { userId: user.id } })
			])

if (isArray(userData)) {
				user.role = userData[0]
				user.userLoginHistories = userData[1]
				user.userPhones = userData[2]
				user.userTokens = userData[3]
				user.addresses = userData[4]
				user.companyClient = userData[5]
				user.userCompanies = userData[6]
				user.userBranches = userData[7]
				user.userGoogleTokens = userData[8]
			}
			return res.status(200).json(new UserModel(user))
		} catch (err) {
			next(err)
		}
	}
	this.List = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			const t1 = performance.now()
			checkPermission(req, 'user_list')

const { branchId, companyId, languageId, roleId, phone, email, name, limit, page } =
				req.query

let required = {
				phones: false,
				companies: false,
				branches: false
			}
			let where = {}
			if (isSet(name)) {
				where['name'] = { [Op.like]: `%${name}%` }
			}
			if (isSet(email)) {
				where['email'] = { [Op.like]: `%${email}%` }
			}
			if (isSet(roleId)) {
				where['roleId'] = roleId
			}
			if (isSet(languageId)) {
				where['languageId'] = languageId
			}
			let whereBranch = {}
			if (isSet(branchId)) {
				whereBranch['id'] = branchId
				required.branches = true
			}
			let whereCompany = {}
			if (isSet(companyId)) {
				whereCompany['id'] = companyId
				required.companies = true
			}
			let wherePhone = {}
			if (isSet(phone)) {
				wherePhone['phone'] = {
					[Op.like]: `%${phone}%`
				}
				required.phones = true
			}

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

const rows = await db.user.findAll({
				include: [
					{
						model: db.userPhone,
						required: required.phones,
						as: 'userPhones',
						where: wherePhone
					},
					{
						model: db.role,
						// Очень долго выбирает, непонятно зачем разрешения в списке
						// include: {
						// 	model: db.permission,
						// 	through: { attributes: [] }
						// }
					},
					{
						model: db.branch,
						required: required.branches,
						through: 'branch_users',
						as: 'userBranches',
						where: whereBranch
					},
					{
						model: db.company,
						required: required.companies,
						through: 'copmany_users',
						as: 'userCompanies',
						where: whereCompany
					},
					{ model: 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 UsersListModel({ users: rows, page, time }))
		} catch (err) {
			next(err)
		}
	}
	this.Details = async (req, res, next) => {
		logger.child({ path: req.path, user: req.user.id }).info()
		try {
			const { id } = req.params
			if (!isSet(id) || isEmpty(id)) {
				throw new BadRequest({ code: 400, lang: req.user?.languageCode })
			}

let user = await db.user.findOne({
				include: [{ model: db.language }],
				where: { id: id }
			})

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

const userData = await Promise.all([
				/*0*/ db.role.findOne({
					include: {
						model: db.permission,
						through: { attributes: [] }
					},
					where: { id: user.roleId }
				}),
				/*1*/ db.userLoginHistory.findAll({ where: { userId: user.id }, limit: 10, order: [['createdAt', 'DESC']] }),
				/*2*/ db.userPhone.findAll({ where: { userId: user.id }, limit: 10 }),
				/*3*/ db.userToken.findAll({ where: { userId: user.id }, limit: 10 }),
				/*4*/ db.address.findAll({ where: { userId: user.id }, limit: 10 }),
				/*5*/ db.companyClients.findAll({
					include: { model: db.company, where: { deletedAt: null } },
					where: { userId: user.id }
				}),
				/*6*/ db.companyUsers.findAll({
					include: [
						{ model: db.company, paranoid: false, where: { deletedAt: null } },
						{ model: db.role }
					],
					where: { userId: user.id }
				}),
				/*7*/ db.branchUsers.findAll({
					include: [
						{
							model: db.branch,
							include: [
								{
									model: db.company,
									as: 'company',
									paranoid: false,
									where: { deletedAt: null }
								}
							],
							paranoid: false,
							where: { deletedAt: null }
						},
						{ model: db.role }
					],
					where: { userId: user.id, '$branch.company.deletedAt$': null }
				}),
				/*8*/ db.userGoogleToken.findAll({ where: { userId: user.id } })
			])

this.Create = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		let t1 = performance.now()
		try {
			checkPermission(req, 'user_edit')
			const { name, image, email, pass } = req.body
			if (!isSet(name) || isEmpty(name) || !minLength(name, 2)) {
				throw new BadRequest({
					code: 1001,
					lang: req.user?.languageCode
				})
			}
			// if (!isSet(login) || isEmpty(login) || !minLength(login, 4)) {
			// 	throw new BadRequest({
			// 		code: 1002,
			// 		lang: req.user?.languageCode
			// 	})
			// }
			if (!isSet(email) || !isEmail(email)) {
				throw new BadRequest({
					code: 1003,
					lang: req.user?.languageCode
				})
			}
			// if (isSet(pass) && !minLength(pass, 4)) {
			// 	throw new BadRequest({
			// 		code: 1011,
			// 		lang: req.user?.languageCode
			// 	})
			// }

const role = await db.role.findOne({
				where: { key: 'client' }
			})
			if (!role) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

var params = {
				name,
				image,
				email,
				roleId: role.id,
				userAccount: {
					type: ACCOUNT_TYPE.CLIENT,
					default: true
				}
			}

if(isSet(pass)){
				// сгенегрировать хэш пароля
				const salt = await bcrypt.genSalt(10)
				const passwordHash = await bcrypt.hash(pass, salt)
				params['passwordHash'] = passwordHash
			}

const user = await db.user.create(params)
			const time = performance.now() - t1
			return res.status(200).json({ status: 'success', id: user.id, time })
		} catch (err) {
			next(err)
		}
	}
	this.Edit = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}

const { id, name, image, email, pass } = req.body
			if (!isSet(id) || isEmpty(id)) {
				throw new BadRequest({ code: 400, lang: req.user?.languageCode })
			}
			if (!isSet(name) || isEmpty(name) || !minLength(name, 4)) {
				throw new BadRequest({
					code: 1001,
					lang: req.user?.languageCode
				})
			}
			// if (!isSet(login) || isEmpty(login) || !minLength(login, 4)) {
			// 	throw new BadRequest({
			// 		code: 1002,
			// 		lang: req.user?.languageCode
			// 	})
			// }
			if (isSet(pass) && !minLength(pass, 4)) {
				throw new BadRequest({
					code: 1011,
					lang: req.user?.languageCode
				})
			}
			if (!isSet(email) || !isEmail(email)) {
				throw new BadRequest({
					code: 1003,
					lang: req.user?.languageCode
				})
			}

const user = await db.user.findOne({
				include: [{ model: db.language }, { model: db.role }],
				where: { id: id }
			})
			if (!user) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			user.name = name
			user.image = image
			if (user.email != email) {
				user.emailConfirmed = false
			}
			user.email = email

if(isSet(pass)){
				// сгенегрировать хэш пароля
				const salt = await bcrypt.genSalt(10)
				const passwordHash = await bcrypt.hash(pass, salt)
				user.passwordHash = passwordHash
			}

await user.save()
			return res.status(200).json(new UserModel(user))
		} catch (err) {
			next(err)
		}
	}
	this.Delete = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			checkPermission(req, 'user_edit')
			const { id } = req.body
			if (!isSet(id) || isEmpty(id)) {
				throw new BadRequest({ code: 400, lang: req.user?.languageCode })
			}

const user = await db.user.findOne({
				where: { id: id }
			})
			if (!user) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			await db.user.destroy({ where: { id: id } })
			return res.status(200).json({ status: 'success', id: user.id })
		} catch (err) {
			next(err)
		}
	}
	this.AddPhone = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const { phone, id } = req.body

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

const foundPhone = await db.userPhone.findOne({
				where: { phone: phone }
			})
			if (foundPhone) {
				throw new BadRequest({ code: 1012, lang: req.user?.languageCode })
			}

const user = await db.user.findOne({
				where: { id: id },
				include: ['userPhones']
			})

if (!user) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const new_phone = await db.userPhone.create({
				phone,
				userId: user.id
			})

return res.status(200).json({ status: 'success', id: new_phone.id })
		} catch (err) {
			next(err)
		}
	}
	this.RemovePhone = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const { id } = req.body

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

const userPhone = await db.userPhone.findOne({
				where: { id: id }
			})

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

await userPhone.destroy()
			return res.status(200).json({ status: 'success', id: id })
		} catch (err) {
			next(err)
		}
	}
	this.AddAddress = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const {
				id,
				address,
				latitude,
				longtitude,
				street,
				street_number,
				number,
				zip,
				comment,
				doorbell,
				floor
			} = req.body

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

const foundAddress = await db.address.findOne({
				where: { adres: address, userId: id }
			})
			if (foundAddress) {
				return res.status(200).json({ status: 'success', id: foundAddress.id })
			}

const user = await db.user.findOne({
				where: { id: id },
				// include: ['addresses']
			})

if (!user) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const new_address = 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
			})

return res.status(200).json({ status: 'success', id: new_address.id })
		} catch (err) {
			next(err)
		}
	}
	this.EditAddress = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const {
				address,
				latitude,
				longtitude,
				id,
				addressId,
				street,
				street_number,
				number,
				zip,
				comment,
				doorbell,
				floor
			} = req.body

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

const foundAddress = await db.address.findOne({
				where: { id: addressId }
			})
			if (!foundAddress) {
				throw new NotFound({ lang: req.user?.languageCode })
			}

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),
				foundAddress.save()

return res.status(200).json({ status: 'success', address: foundAddress })
		} catch (err) {
			next(err)
		}
	}
	this.RemoveAddress = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const { id, addressId } = req.body

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

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

const userAddress = await db.address.findOne({
				where: { id: addressId }
			})

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

await userAddress.destroy()
			return res.status(200).json({ status: 'success', id: addressId })
		} catch (err) {
			next(err)
		}
	}
	this.SetDefaultAddress = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const { id, addressId, branches } = req.body
			let branchesResult = []

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

var userAddress
			if (isSet(addressId) && !isEmpty(addressId)) {
				userAddress = await db.address.findOne({
					where: { id: addressId }
				})
			}

const user = await db.user.findOne({
				where: { id: id }
			})

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

if (isSet(userAddress)) {
				user.defaultAddressId = userAddress.id
			} else {
				user.defaultAddressId = null
			}
			await user.save()

// if (isArray(branches) && branches.length > 0) {
			// 	const branchesArray = await db.branch.findAll({
			// 		where: {
			// 			id: { [Op.in]: branches }
			// 		}
			// 	})
			// 	if (branchesArray.length > 0) {
			// 		for (const branch in branchesArray) {
			// 			branchesResult.push({
			// 				id: branch.id,
			// 				result: PointInPolygon(
			// 					[userAddress.latitude, userAddress.longtitude], // или [userAddress.longtitude, userAddress.latitude] ?
			// 					JSON.parse(branch.area) // area в базе "[[1, 1], [1, -1], [-1, -1], [-1, 1]]"
			// 				)
			// 			})
			// 		}
			// 	}
			// }
			return res.status(200).json({ status: 'success', id: id}) //, branches: branchesResult 
		} catch (err) {
			next(err)
		}
	}
	this.AddToken = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const { token, platform, deviceId, device, app, id } = req.body

if (!isSet(id) || isEmpty(id)) {
				throw new BadRequest({
					lang: req.user?.languageCode
				})
			}
			if (!isSet(token) || isEmpty(token)) {
				throw new BadRequest({ code: 1016, lang: req.user?.languageCode })
			}
			if (!isSet(app) || isEmpty(app)) {
				throw new BadRequest({ code: 1018, lang: req.user?.languageCode })
			}
			if (!isSet(deviceId) || isEmpty(deviceId)) {
				throw new BadRequest({ code: 1019, lang: req.user?.languageCode })
			}
			if (!isSet(platform) || isEmpty(platform)) {
				throw new BadRequest({ code: 1017, lang: req.user?.languageCode })
			}

const user = await db.user.findOne({
				where: { id: id },
			})

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

await db.userToken.destroy({
				where: { deviceId: deviceId }
			})

const new_token = await db.userToken.create({
				token,
				platform,
				deviceId,
				device,
				app,
				userId: user.id
			})

return res.status(200).json({ status: 'success', id: new_token.id })
		} catch (err) {
			next(err)
		}
	}
	this.RemoveToken = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			if (req.body.id != req.user.id) {
				checkPermission(req, 'user_edit')
			}
			const { id, tokenId } = req.body

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

const userToken = await db.userToken.findOne({
				where: { id: tokenId }
			})

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

await userToken.destroy()
			return res.status(200).json({ status: 'success', id: tokenId })
		} catch (err) {
			next(err)
		}
	}
	this.ConfirmEmailRequest = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			const { id } = req.body
			if (!isSet(id) || isEmpty(id)) {
				throw new BadRequest({
					lang: req.user?.languageCode
				})
			}
			// найти пользователя
			const user = await db.user.findOne({ where: { id } })
			if (!user) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			// сгенрировать токен
			const mailConfirmToken = jwt.sign(
				{
					id: user.id
				},
				config.jwt.secret,
				{
					expiresIn: config.jwt.confirmTokenExpires
				}
			)

const nodemailer = require('nodemailer')
			const smtpProtocol = nodemailer.createTransport({
				host: config.mail.smtpServer,
				port: config.mail.smtpPort,
				secure: true,
				auth: {
					user: config.mail.userName,
					pass: config.mail.password
				}
			})
			const message = {
				from: config.mail.userName, // адрес отправителя
				to: email, // список получателей "mailto1, mailto2"
				subject: 'Подтверждение адреса электронной почты', // заголовок
				//text: 'text',
				html: `Для подтверждения адреса электронной почты перейдите по <a href='${config.mail.mailConfirmCallbackUrl}?token=${mailConfirmToken}'>ссылке</a>.`
			}
			// отправка сообщения
			const result = await smtpProtocol.sendMail(message)
			return res.status(200).json(result)
		} catch (err) {
			next(err)
		}
	}
	this.ConfirmEmail = async (req, res, next) => {
		try {
			logger.child({ path: req.path, request: req.body }).info()
			// разбор и валидация запроса
			const { token } = req.body
			if (!isSet(token) || isEmpty(token)) {
				throw new BadRequest({
					lang: req.user?.languageCode
				})
			}
			// декодировать токен
			const decodedToken = jwt.verify(token, config.jwt.secret)
			if (!decodedToken || !decodedToken.id) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			// найти пользователя
			let user = await db.user.findOne({
				where: { id: decodedToken.id }
			})
			user.emailConfirmed = true
			await user.save()
			return res.status(200).json({ status: 'success' })
		} catch (err) {
			next(err)
		}
	}
	this.UserLoginHistory = async (req, res, next) => {
		logger.child({ path: req.path, request: req.query }).info()
		try {
			const t1 = performance.now()
			checkPermission(req, 'user_login_history')

const { userId, roleId, phone, ipAddress, limit, page } = req.query

let where = {}
			if (userId) {
				where['userId'] = parseInt(userId)
			}
			if (ipAddress) {
				where['ipAddress'] = ipAddress
			}
			// let whereRole = {}
			// if (roleId) {
			// 	whereRole['id'] = parseInt(roleId)
			// }
			// let wherePhone = {}
			// if (phone) {
			// 	wherePhone['phone'] = phone
			// }

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

const userLoginHistories = await db.userLoginHistory.findAll({
				include: [
					{
						model: db.user,
						// include: [
						// 	{ model: db.userPhone, as: 'userPhones', where: wherePhone },
						// 	{
						// 		model: db.role,
						// 		where: whereRole
						// 	}
						// ]
					}
				],
				where,
				offset,
				order: [
					['createdAt', 'DESC'],
				],
				limit: parseInt(limit) || 10
			})
			if (!userLoginHistories || userLoginHistories.length == 0) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const time = performance.now() - t1
			return res.status(200).json({ list: userLoginHistories, page, time })
		} catch (err) {
			next(err)
		}
	}

this.PushMessage = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			let { message, id } = req.body

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

const user = await this.db.user.findOne({
				where: { id }
			})

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

let options = {}

const result = await SERVICES.Firebase.sendToUser(user.id, message, options)
			res.status(200).json(result)
		} catch (err) {
			next(err)
		}
	}

this.MakeSuper = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			let { id } = req.body

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

const role = await db.role.findOne({
				where: { key: 'su' }
			})
			if (!role) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const user = await db.user.findOne({
				where: { id }
			})

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

user.roleId = role.id
			user.save()

res.status(200).json({ 'id': user.id })
		} catch (err) {
			next(err)
		}
	}

this.MakeClient = async (req, res, next) => {
		logger.child({ path: req.path, request: req.body }).info()
		try {
			let { id } = req.body

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

const role = await this.db.role.findOne({
				where: { key: 'client' }
			})
			if (!role) {
				throw new NotFound({ lang: req.user?.languageCode })
			}
			const user = await this.db.user.findOne({
				where: { id }
			})

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

user.roleId = role.id
			user.save()
			
			res.status(200).json({ 'id': user.id })
		} catch (err) {
			next(err)
		}
	}
}

cmd: