/var/www/verywell.gr/server/delivery/services
Edit: /var/www/verywell.gr/server/delivery/services/order.service.js (17546B)
const logger = require('../logger')({ service: 'OrderService' })
const { Op } = require('sequelize')
const {
OrderHeaderClients,
OrderHeaderDrivers,
OrderHeaderOperators
} = require('../api/responseModels')
module.exports = class OrderService {
constructor({ db, config }) {
this.db = db
this.interval = null
this.config = config
this.orders = VARS.orders
logger.child({ service: 'OrderService', method: 'Constructor' }).info('Success')
}
async Run() {
// загрузить заказы
this.orders = await this.db.order.findAll({
include: [
{ model: this.db.orderAddress },
{
model: this.db.branch,
include: [{ model: this.db.deliveryType }],
foreginKey: 'branchId'
},
{ model: this.db.payType, foreginKey: 'payTypeId', as: 'payType' },
{ model: this.db.payType, foreginKey: 'deliveryPayTypeId', as: 'deliveryPayType' },
{ model: this.db.deliveryType },
{ model: this.db.company, foreginKey: 'companyId' },
{
model: this.db.user,
foreginKey: 'userId',
as: 'user',
include: { model: this.db.userPhone }
},
{
model: this.db.user,
foreginKey: 'operatorId',
as: 'operator',
include: { model: this.db.userPhone }
},
{ model: this.db.user, foreginKey: 'orderId', as: 'orderWaiters' },
{ model: this.db.orderItems, foreginKey: 'orderId', as: 'orderItems' },
{
model: this.db.driver,
foreginKey: 'driverId',
as: 'driver',
include: [{ model: this.db.user, include: [{ model: this.db.userPhone }] }]
},
{ model: this.db.orderCancelCause },
{ model: this.db.table }
],
where: {
status: {
[Op.in]: ['new', 'pending', 'accept', 'ready', 'delivery']
}
}
})
logger
.child({ service: 'OrderService', method: 'Run' })
.info(`Orders loaded: ${this.orders?.length || 0}.`)
// запустить цикл
this.interval = setInterval(() => {
}, this.config.orderService?.timeout || 1000)
logger.child({ service: 'OrderService', method: 'Run' }).info('Success')
}
async Stop() {
this.interval = null
this.orders = []
logger.child({ service: 'OrderService', method: 'Stop' }).info('Success')
}
async GetOrders() {
logger.child({ service: 'OrderService', method: 'GetOrders' }).info('Success')
return this.orders
}
async LoadOrder(uid) {
return await this.db.order.findOne({
include: [
{ model: this.db.orderAddress },
{
model: this.db.branch,
include: [{ model: this.db.deliveryType }],
foreginKey: 'branchId'
},
{ model: this.db.payType, foreginKey: 'payTypeId', as: 'payType' },
{
model: this.db.payType,
foreginKey: 'deliveryPayTypeId',
as: 'deliveryPayType'
},
{ model: this.db.deliveryType },
{ model: this.db.company, foreginKey: 'companyId' },
{
model: this.db.user,
foreginKey: 'userId',
as: 'user',
include: { model: this.db.userPhone }
},
{
model: this.db.user,
foreginKey: 'operatorId',
as: 'operator',
include: { model: this.db.userPhone }
},
{ model: this.db.user, foreginKey: 'orderId', as: 'orderWaiters' },
// { model: this.db.orderItems, foreginKey: 'orderId', as: 'orderItems' },
{
model: this.db.driver,
foreginKey: 'driverId',
as: 'driver',
include: [{ model: this.db.user, include: [{ model: this.db.userPhone }] }]
},
{ model: this.db.orderCancelCause },
{ model: this.db.table },
{ model: this.db.orderItems, include: [{ model: this.db.product, include: [this.db.branchProduct, this.db.productImage] }] }
],
where: { uid: uid }
})
}
async GetOrder(uid) {
let order = this.orders.find((p) => p.uid === uid)
if (!order) {
order = await this.LoadOrder(uid)
if (!order) {
logger
.child({ service: 'OrderService', method: 'GetOrder', uid: uid })
.info('Not Found')
return
}
await this.AddOrder(order)
logger
.child({ service: 'OrderService', method: 'GetOrder', uid: order.uid })
.info('Success')
}
return order
}
async AddOrder(order) {
if (order) {
const idx = this.orders.findIndex((p) => p.uid == order.uid)
if (idx === -1) {
this.orders.push(order)
logger
.child({ service: 'OrderService', method: 'AddOrder', uid: order.uid })
.info('Success')
} else {
this.orders[idx] = order
}
}
}
async ReloadOrder(uid) {
let order = await this.LoadOrder(uid)
await this.AddOrder(order)
return order
}
async RemoveOrder(uid) {
const idx = this.orders.findIndex((p) => p.uid == uid)
if (idx !== -1) {
this.orders.splice(idx, 1)
logger
.child({ service: 'OrderService', method: 'RemoveOrder', uid: uid })
.info('Success')
}
}
////////////////////////////////////////////////////////////////////////////////////////
// создан
async CreateOrder(order) {
// await order.reload()
// await this.AddOrder(order)
await this.GetOrder(order.uid).then((ord) => (order = ord))
const headerClients = new OrderHeaderClients(order.dataValues)
const headerOperators = new OrderHeaderOperators(order.dataValues)
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderCreate', headerClients)
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(
order.branchId,
'orderCreate',
headerOperators
)
await SERVICES.WebSocketService.SendToWaitersByBranch(
order.branchId,
'orderCreate',
headerOperators
)
}
// принят оператором
async PendOrder(order) {
await order.reload()
await this.AddOrder(order)
const headerClients = new OrderHeaderClients(order.dataValues)
const headerDrivers = new OrderHeaderDrivers(order.dataValues)
const headerOperators = new OrderHeaderOperators(order.dataValues)
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderPend', headerClients)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' accepted'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 1
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 1,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_accept'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(
order.branchId,
'orderPend',
headerOperators
)
await SERVICES.WebSocketService.SendToWaitersByBranch(
order.branchId,
'orderPend',
headerOperators
)
// отправить доставщикам
await SERVICES.WebSocketService.SendToDriversByBranch(
order.branchId,
'orderPend',
headerDrivers
)
}
// принят доставщиком
async AcceptOrder(order) {
await order.reload()
const headerClients = new OrderHeaderClients(order.dataValues)
const headerDrivers = new OrderHeaderDrivers(order.dataValues)
const headerOperators = new OrderHeaderOperators(order.dataValues)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' accepted'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 1
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 1,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_accept'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderAccept', headerClients)
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(
order.branchId,
'orderAccept',
headerOperators
)
await SERVICES.WebSocketService.SendToWaitersByBranch(
order.branchId,
'orderAccept',
headerOperators
)
// отправить доставщикам
await SERVICES.WebSocketService.SendToDriversByBranch(
order.branchId,
'orderRemove',
headerDrivers
)
}
// собран готов
async ReadyOrder(order) {
await order.reload()
const headerClients = new OrderHeaderClients(order.dataValues)
const headerDrivers = new OrderHeaderDrivers(order.dataValues)
const headerOperators = new OrderHeaderOperators(order.dataValues)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' ready'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 1
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 1,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_ready'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderReady', headerClients)
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(
order.branchId,
'orderReady',
headerOperators
)
await SERVICES.WebSocketService.SendToWaitersByBranch(
order.branchId,
'orderReady',
headerOperators
)
if (parseInt(order.driverId) === 0) {
await SERVICES.WebSocketService.SendToDriversByBranch(
order.branchId,
'orderReady',
headerDrivers
)
} else {
await SERVICES.WebSocketService.SendToDriver(
order.driverId,
'orderReady',
headerDrivers
)
}
}
// принят доставляется
async DeliveryOrder(order) {
await order.reload()
const headerClients = new OrderHeaderClients(order.dataValues)
const headerOperators = new OrderHeaderOperators(order.dataValues)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' is delivered'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 1
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 1,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_delivery'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderDelivery', headerClients)
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(
order.branchId,
'orderDelivery',
headerOperators
)
await SERVICES.WebSocketService.SendToWaitersByBranch(
order.branchId,
'orderDelivery',
headerOperators
)
}
// принят доставлен
async ArrivedOrder(order) {
await order.reload()
const headerClients = new OrderHeaderClients(order.dataValues)
const headerOperators = new OrderHeaderOperators(order.dataValues)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' is arrived'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 1
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 1,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_arrived'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderArrived', headerClients)
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(
order.branchId,
'orderArrived',
headerOperators
)
await SERVICES.WebSocketService.SendToWaitersByBranch(
order.branchId,
'orderArrived',
headerOperators
)
}
// отменен
async CancelOrder(order) {
await this.RemoveOrder(order.uid)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' canceled'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 0
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 0,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_cancel'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderCancel', {
id: order.id,
uid: order.uid,
status: order.status
})
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(order.branchId, 'orderCancel', {
id: order.id,
uid: order.uid,
status: order.status
})
await SERVICES.WebSocketService.SendToWaitersByBranch(order.branchId, 'orderCancel', {
id: order.id,
uid: order.uid,
status: order.status
})
if (parseInt(order.driverId) === 0) {
await SERVICES.WebSocketService.SendToDriversByBranch(order.branchId, 'orderCancel', {
id: order.id,
uid: order.uid,
status: order.status
})
} else {
await SERVICES.WebSocketService.SendToDriver(order.driverId, 'orderCancel', {
id: order.id,
uid: order.uid,
status: order.status
})
}
}
// заверщен
async CompleteOrder(order) {
await this.RemoveOrder(order.uid)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' completed'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 0
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 0,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_accept'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderComplete', {
id: order.id,
uid: order.uid,
status: order.status
})
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(order.branchId, 'orderComplete', {
id: order.id,
uid: order.uid,
status: order.status
})
await SERVICES.WebSocketService.SendToWaitersByBranch(order.branchId, 'orderComplete', {
id: order.id,
uid: order.uid,
status: order.status
})
// отправить доставщикам
await SERVICES.WebSocketService.SendToDriver(order.driverId, 'orderComplete', {
id: order.id,
uid: order.uid,
status: order.status
})
}
// оплата
async PayOrder(order, orderPay) {
// await this.GetOrder(order.uid).then((ord) => (order = ord))
// await SERVICES.WebSocketService.SendToClient(order.userId, 'orderPay', orderPay)
// await SERVICES.WebSocketService.SendToOperatorsByBranch(
// order.branchId,
// 'orderPay',
// orderPay
// )
// await SERVICES.WebSocketService.SendToWaitersByBranch(
// order.branchId,
// 'orderPay',
// orderPay
// )
await order.reload()
const headerClients = new OrderHeaderClients(order.dataValues)
const headerOperators = new OrderHeaderOperators(order.dataValues)
// отправить PUSH клинету
let message = {
notification: {
title: this.config.app.name,
body: 'Order ' + order.id + ' has been paid'
},
// data: {
// channel_id: threadId,
// },
android: {
ttl: 3600 * 1000,
notification: {
priority: 'high',
sound: 'default',
notificationCount: 1
// icon: 'stock_ticker_update',
// color: '#f45342',
}
},
apns: {
payload: {
aps: {
badge: 1,
sound: 'default'
}
}
},
fcmOptions: {
analyticsLabel: 'order_arrived'
}
}
await SERVICES.Firebase.SendToUser(order.userId, message, {})
// отправить клинету
await SERVICES.WebSocketService.SendToClient(order.userId, 'orderPay', headerClients)
// отправить операторам
await SERVICES.WebSocketService.SendToOperatorsByBranch(
order.branchId,
'orderPay',
headerOperators
)
await SERVICES.WebSocketService.SendToWaitersByBranch(
order.branchId,
'orderPay',
headerOperators
)
}
}