hamid.zarghami1@gmail.com
1937 lines
62 KiB
JavaScript
1937 lines
62 KiB
JavaScript
const CartItem = require('../models/CartItem')
|
|
const Order = require('../models/Order')
|
|
const User = require('../models/User')
|
|
const Food = require('../models/Food')
|
|
const Payment = require('../models/Payment')
|
|
const DiscountCode = require('../models/DiscountCode')
|
|
const StoreInfo = require('../models/StoreInfo')
|
|
const {body, validationResult} = require('express-validator')
|
|
const {res404, res500, checkValidations} = require('../plugins/controllersHelperFunctions')
|
|
const {_sr} = require('../plugins/serverResponses')
|
|
const axios = require('axios')
|
|
const zarinpal = require('./../zarinpal')
|
|
const {sendSingle, sendMulti} = require('./../plugins/pushNotif').notification
|
|
const {sendNotifyOrder} = require('./../socket/adminNotify')
|
|
const moment = require('moment-jalaali');
|
|
const {sms} = require('./../SMSModule')
|
|
const CronJob = require('cron').CronJob
|
|
|
|
|
|
/////////// variables
|
|
const apiKey = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImp0aSI6ImRiYjIwMmRhYzAxYzFjNzgwYjgxNWQyZDgyMWNmNmY1Njk0MThhMGE3N2Q1M2Y0OTZkYzQzYTgxMmNmN2U3ZWJjNzI5MjY5YjkxMjA4MTYyIn0.eyJhdWQiOiIxNDk3OSIsImp0aSI6ImRiYjIwMmRhYzAxYzFjNzgwYjgxNWQyZDgyMWNmNmY1Njk0MThhMGE3N2Q1M2Y0OTZkYzQzYTgxMmNmN2U3ZWJjNzI5MjY5YjkxMjA4MTYyIiwiaWF0IjoxNjI3MzI2Mzc0LCJuYmYiOjE2MjczMjYzNzQsImV4cCI6MTYyOTkxODM3NCwic3ViIjoiIiwic2NvcGVzIjpbImJhc2ljIl19.hyKNSy4fmPps6yIdm33Wof-mES9ujh5lmI3VFWyecbkNCm9ATPwsZ9s53A3a1wPJmHfLBXpCcob5NGL-GjZlVfqfRBiReRMr_iniCjUOnqENfFwVEJutxI-xrzVe7PZzOgx1Vr6WwSUHvQ36eJSS1lBlHlqCgwRbkG0hs4YdZsKhzhfYdlAluNw9djjUAMbRWZVL0EluP9CYko4w8tB0KHUZMZYGQcevCfb_3OU9ygHo7B--Z5aTPfm7IK4eP0gHsZ_t857B3tu3ZJB1mkgxc2R9gZUflKqj1ZqkYiR0uMGP-571enXh6pYQLXL2k-gOxLIedCaE6XytxVXhENnotA';
|
|
const limit = 20
|
|
const zarinUrl = 'https://www.zarinpal.com/pg/StartPay'
|
|
const timeToStart = 1800000
|
|
// const timeToStart = 1800000
|
|
|
|
////////// functions
|
|
const deg2rad = (deg) => {
|
|
return deg * (Math.PI / 180)
|
|
}
|
|
|
|
const _computeShippingCost = async (addresses, location) => {
|
|
try {
|
|
if (addresses.length && location) {
|
|
const address = addresses[0]
|
|
|
|
const R = 6371; // Radius of the earth in km
|
|
const dLat = deg2rad(address.location.coordinates[1] - location.coordinates[1]); // deg2rad below
|
|
const dLon = deg2rad(address.location.coordinates[0] - location.coordinates[0]);
|
|
const a =
|
|
Math.sin(dLat / 2) * Math.sin(dLat / 2) +
|
|
Math.cos(deg2rad(address.location.coordinates[1])) * Math.cos(deg2rad(location.coordinates[1])) *
|
|
Math.sin(dLon / 2) * Math.sin(dLon / 2)
|
|
;
|
|
const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
|
|
// Distance in km
|
|
return R * c;
|
|
|
|
} else {
|
|
return 0
|
|
}
|
|
} catch (error) {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
const _computeShippingCostByRoad = async (addresses, storeLocation) => {
|
|
try {
|
|
if (addresses.length && storeLocation) {
|
|
const address = addresses.find(item2 => item2.used === true)
|
|
const lng = address.location.coordinates[0]
|
|
const lat = address.location.coordinates[1]
|
|
|
|
const storeLng = storeLocation.coordinates[0]
|
|
const storeLat = storeLocation.coordinates[1]
|
|
|
|
const getDistance = await axios.get(`https://map.ir/routes/route/v1/driving/${lng},${lat};${storeLng},${storeLat}`, {
|
|
headers: {
|
|
'x-api-key': apiKey
|
|
}
|
|
});
|
|
|
|
if (getDistance.data.code !== 'Ok') return new Error(_sr['fa'].response.unknownError);
|
|
|
|
//@todo if distance under 1000 meter equal to 0
|
|
return getDistance.data.routes[0].distance <= 1000 ? 0 : Math.round(getDistance.data.routes[0].distance / 1000);
|
|
|
|
} else {
|
|
return 0
|
|
}
|
|
} catch (error) {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
const getMinutes = (str) => {
|
|
var time = str.split(':');
|
|
return time[0] * 60 + time[1] * 1;
|
|
}
|
|
|
|
const getMinutesNow = (timezone) => {
|
|
var timeNow = new Date();
|
|
return timeNow.getUTCHours() * 60 + timeNow.getUTCMinutes();
|
|
}
|
|
|
|
const _computeHavePointPrice = async (items) => {
|
|
try {
|
|
let total = 0
|
|
for (const item of items) {
|
|
if (item.havePoint) {
|
|
let priceItem = item.price - (item.price * item.static_discount || 0 / 100)
|
|
let totalPrice = priceItem * item.quantity
|
|
total += totalPrice
|
|
}
|
|
}
|
|
|
|
return total
|
|
} catch (error) {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////public
|
|
////////////////////////////////////// cart
|
|
module.exports.addToCart = [
|
|
//// check start time and end time
|
|
// async (req, res, next) => {
|
|
// try {
|
|
// const getTime = await StoreInfo.findOne()
|
|
//
|
|
// if (getTime) {
|
|
// if (getTime?.open24){
|
|
// return next()
|
|
// } else if (getTime?.utcStartTime && getTime?.utcEndTime) {
|
|
// let start = getMinutes(getTime.utcStartTime)
|
|
// let end = getMinutes(getTime.utcEndTime)
|
|
// let now = getMinutesNow(getTime.timezone)
|
|
//
|
|
// if (
|
|
// (start < now && end > now) || (start > end && (now < end || now > start))
|
|
// ) {
|
|
// return next()
|
|
// } else if (start === end) {
|
|
// return res.status(503).json({message: `در حال حاظر پذیرش سفارش نداریم`})
|
|
// }else {
|
|
// return res.status(503).json({message: `پذیرش سفارش از ساعت ${getTime?.startTime} تا ${getTime?.endTime} می باشد`})
|
|
// }
|
|
//
|
|
// } else {
|
|
// return next()
|
|
// }
|
|
// } else {
|
|
// return next()
|
|
// }
|
|
//
|
|
// } catch (error) {
|
|
// return res500(res, _sr['fa'].response.unknownError)
|
|
// }
|
|
// },
|
|
[
|
|
body('product_id')
|
|
.custom((value, {req}) => {
|
|
return Food.findById(value)
|
|
.then(product => {
|
|
if (product) return true
|
|
else return Promise.reject(_sr['fa'].not_found.item_id)
|
|
})
|
|
.catch(err => {
|
|
return Promise.reject(_sr['fa'].not_found.item_id)
|
|
})
|
|
}),
|
|
body('type')
|
|
.notEmpty().withMessage(`نوع عملی که باید انجام شود را بفرستید`),
|
|
|
|
body('branchId')
|
|
.notEmpty().withMessage(_sr['fa'].required.field)
|
|
.bail()
|
|
.custom((value, {req}) => {
|
|
return StoreInfo.findOne({_id: value})
|
|
.then(store => {
|
|
if (!store) return Promise.reject(_sr['fa'].not_found.item_id)
|
|
else return true
|
|
})
|
|
})
|
|
],
|
|
checkValidations(validationResult),
|
|
async (req, res) => {
|
|
try {
|
|
const {product_id, type, branchId} = req.body;
|
|
const checkCart = await CartItem.findOne({branchId, product_id , user_id: req.user._id}).populate('product_id');
|
|
|
|
if (checkCart) {
|
|
if (Number(checkCart.quantity) > 0) {
|
|
if (type === 'positive') {
|
|
checkCart.quantity = Number(checkCart.quantity) + 1;
|
|
} else if (type === 'negative') {
|
|
checkCart.quantity = Number(checkCart.quantity) - 1;
|
|
}
|
|
await checkCart.save();
|
|
|
|
if (Number(checkCart.quantity) === 0 || checkCart.product_id.stock === 0) {
|
|
await checkCart.deleteOne()
|
|
}
|
|
}
|
|
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
} else {
|
|
const addCart = await CartItem.create({
|
|
branchId,
|
|
product_id,
|
|
user_id: req.user._id,
|
|
quantity: 1
|
|
})
|
|
|
|
if (!addCart) return res500(res, _sr['fa'].response.unknownError);
|
|
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
}
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError);
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.getCartItems = [
|
|
async (req, res) => {
|
|
try {
|
|
const branchId = req?.params?.branchId
|
|
|
|
const allCartItems = await CartItem.find({branchId, user_id: req.user._id}).populate({
|
|
path: 'user_id',
|
|
select: '-password -token',
|
|
sort: {useRate: -1}
|
|
}).populate('product_id')
|
|
|
|
return res.json(allCartItems);
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError);
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.updateCart = [
|
|
[
|
|
body('quantity')
|
|
.notEmpty()
|
|
.withMessage((value, {req}) => {
|
|
return _sr['fa'].required.quantity
|
|
})
|
|
.bail()
|
|
.isNumeric()
|
|
.withMessage((value, {req}) => {
|
|
return _sr['fa'].format.number
|
|
})
|
|
],
|
|
checkValidations(validationResult),
|
|
(req, res) => {
|
|
CartItem.findById(req.params.item_id)
|
|
.then(item => {
|
|
if (!item) return res404(res, _sr['fa'].not_found.item_id)
|
|
item.quantity = Number(req.body.quantity)
|
|
item.save()
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
})
|
|
.catch(err => {
|
|
return res404(res, err)
|
|
})
|
|
}
|
|
]
|
|
|
|
module.exports.deleteAllCartItem = [
|
|
(req, res) => {
|
|
CartItem.deleteMany({user_id: req.user._id}, (err, result) => {
|
|
if (err) return res500(res, _sr['fa'].response.unknownError)
|
|
else return res.json({message: _sr['fa'].response.success_remove})
|
|
})
|
|
}
|
|
]
|
|
|
|
/////////////////////////////////// reorder
|
|
module.exports.reOrder = [
|
|
//////////////////// validation step
|
|
// (req, res, next) => {
|
|
// CartItem.find({user_id: req.user._id})
|
|
// .then(items => {
|
|
// // check if cart is not empty
|
|
// if (items.length) {
|
|
// // check product stock
|
|
// let outOfRun = []
|
|
// items.forEach(async (item, index) => {
|
|
// await Food.findById(item.product_id)
|
|
// .then(product => {
|
|
// if (product.stock < item.quantity) {
|
|
// outOfRun.push({
|
|
// product_id: product._id,
|
|
// category_id: product.category,
|
|
// stock: product.stock
|
|
// })
|
|
// item.remove()
|
|
// }
|
|
// if (index + 1 === items.length) {
|
|
// if (!outOfRun.length) return next()
|
|
// else return res.status(422).json(outOfRun)
|
|
// }
|
|
// })
|
|
// })
|
|
// } else {
|
|
// return res.status(404).json({message: _sr['fa'].response.cart_empty})
|
|
// }
|
|
// })
|
|
// },
|
|
async (req, res) => {
|
|
try {
|
|
const orderId = req.params?.orderId
|
|
const checkOrder = await Order.findOne({'status': 'delivered', user_id: req.user._id, _id: orderId}).populate('product_id')
|
|
|
|
if (!checkOrder) return res404(res, `سفارش کاربر یافت نشد`);
|
|
|
|
await CartItem.deleteMany({user_id: req.user._id})
|
|
|
|
for (const food of checkOrder.order_items) {
|
|
if (food.product_id && !food.product_id?.deleted) {
|
|
await CartItem.create({
|
|
product_id: food.product_id._id,
|
|
user_id: req.user._id,
|
|
quantity: food.quantity
|
|
})
|
|
}
|
|
}
|
|
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
////////////////////////////////////// order
|
|
module.exports.addOrder = [
|
|
[
|
|
body('description')
|
|
.optional().isString().withMessage(`توضیحات سفارش باید به صورت رشته فرستاده شود`),
|
|
|
|
body('bag')
|
|
.optional().isBoolean().withMessage(_sr['fa'].format.boolean),
|
|
|
|
body('score')
|
|
.optional().isBoolean().withMessage(_sr['fa'].format.boolean),
|
|
|
|
body('discountCode')
|
|
.if((value, {req}) => {
|
|
return value;
|
|
})
|
|
.custom((value, {req}) => {
|
|
return DiscountCode.findOne({discount_code: value}).then(discount => {
|
|
if (!discount) return Promise.reject(`کد تخفیف وارد شده صحیح نمیباشد`);
|
|
if (Number(discount.discount_expire_date) > Date.now()) return Promise.reject(`تاریخ مصرف کد تخفیف به اتمام رشیده است`)
|
|
if (discount.used_by.includes(req?.user?._id)) return Promise.reject(`کد تخفیف قبلا استفاده شده است`);
|
|
if (!discount.isPublic) {
|
|
if (discount?.discount_user_id?.toString() !== req?.user?._id.toString()) return Promise.reject(`کد تخفیف وارد شده صحیح نمیباشد`)
|
|
} else return true
|
|
}).catch(error => {
|
|
return Promise.reject(`کد تخفیف وارد شده صحیح نمیباشد`);
|
|
})
|
|
}),
|
|
|
|
body('branchId')
|
|
.notEmpty().withMessage(_sr['fa'].required.field)
|
|
.bail()
|
|
.custom((value, {req}) => {
|
|
return StoreInfo.findOne({_id: value})
|
|
.then(store => {
|
|
if (!store) return Promise.reject(_sr['fa'].not_found.item_id)
|
|
else return true
|
|
})
|
|
})
|
|
|
|
],
|
|
checkValidations(validationResult),
|
|
//////////////////// validation step
|
|
(req, res, next) => {
|
|
CartItem.find({branchId: req?.body?.branchId, user_id: req.user._id})
|
|
.then(items => {
|
|
// check if cart is not empty
|
|
if (items.length) {
|
|
// check product stock
|
|
let outOfRun = []
|
|
items.forEach(async (item, index) => {
|
|
await Food.findById(item.product_id)
|
|
.then(product => {
|
|
if (product.stock < item.quantity) {
|
|
outOfRun.push({
|
|
name: product.name,
|
|
product_id: product._id,
|
|
category_id: product.category,
|
|
stock: product.stock
|
|
})
|
|
item.remove()
|
|
}
|
|
if (index + 1 === items.length) {
|
|
if (!outOfRun.length) return next()
|
|
else return res.status(422).json(outOfRun)
|
|
}
|
|
})
|
|
})
|
|
} else {
|
|
return res.status(404).json({message: _sr['fa'].response.cart_empty})
|
|
}
|
|
})
|
|
},
|
|
//////////////////// save order
|
|
async (req, res) => {
|
|
try {
|
|
const {branchId , description, bag, score, discountCode} = req.body;
|
|
const cartItems = await CartItem.find({branchId ,user_id: req.user._id}).populate('product_id');
|
|
const getUserInfo = await User.findById(req.user._id);
|
|
const getDiscountCode = await DiscountCode.findOne({branchId ,discount_code: discountCode});
|
|
|
|
if (!getUserInfo) return res404(res, `اطلاعات کاربر یافت نشد`);
|
|
|
|
if (!cartItems.length) return res.status(404).json({message: `هیچ محصولی در سبد خرید شما وجود ندارد`})
|
|
|
|
await Order.deleteMany({branchId, status: 'incomplete', user_id: req.user._id});
|
|
|
|
/// check order exist or not
|
|
// const checkOrder = await Order.findOne({'status': 'incomplete', user_id: req.user._id});
|
|
//
|
|
// if (checkOrder) {
|
|
// await checkOrder.remove()
|
|
// }
|
|
|
|
const orderItems = [];
|
|
for (const item of cartItems) {
|
|
orderItems.push({
|
|
product_id: item.product_id._id,
|
|
name: item.product_id.name,
|
|
quantity: item.quantity,
|
|
price: item.product_id.price,
|
|
static_discount: item.product_id.static_discount,
|
|
havePoint: item.product_id.havePoint
|
|
});
|
|
}
|
|
|
|
|
|
if (score && bag) return res.status(422).json({message: 'استفاده همزمان از کیف پول و امتیاز برای خرید مجاز نمی باشد'})
|
|
|
|
const orderData = {
|
|
branchId,
|
|
user_id: req.user._id,
|
|
number: Date.now(),
|
|
order_items: orderItems,
|
|
statuses: [{
|
|
status: 'incomplete'
|
|
}],
|
|
description,
|
|
bag,
|
|
score,
|
|
discount_code: getDiscountCode?.discount_code,
|
|
discount_amount: getDiscountCode?.discount_amount,
|
|
discount_menuType: getDiscountCode?.menuTypeId
|
|
};
|
|
await Order.create(orderData);
|
|
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
|
|
} catch (error) {
|
|
console.log(error)
|
|
return res500(res, _sr['fa'].response.unknownError);
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.orderPay = [
|
|
[
|
|
body('branchId')
|
|
.notEmpty().withMessage(_sr['fa'].required.field)
|
|
.bail()
|
|
.custom((value, {req}) => {
|
|
return StoreInfo.findOne({_id: value})
|
|
.then(store => {
|
|
if (!store) return Promise.reject(_sr['fa'].not_found.item_id)
|
|
else return true
|
|
})
|
|
})
|
|
|
|
],
|
|
checkValidations(validationResult),
|
|
(req, res, next) => {
|
|
CartItem.find({branchId: req?.body?.branchId, user_id: req.user._id})
|
|
.then(items => {
|
|
// check if cart is not empty
|
|
if (items.length) {
|
|
// check product stock
|
|
let outOfRun = []
|
|
items.forEach(async (item, index) => {
|
|
await Food.findById(item.product_id)
|
|
.then(product => {
|
|
if (product.stock < item.quantity) {
|
|
outOfRun.push({
|
|
product_id: product._id,
|
|
category_id: product.category,
|
|
stock: product.stock
|
|
})
|
|
item.remove()
|
|
}
|
|
if (index + 1 === items.length) {
|
|
if (!outOfRun.length) return next()
|
|
else return res.status(422).json(outOfRun)
|
|
}
|
|
})
|
|
})
|
|
} else {
|
|
return res.status(404).json({message: _sr['fa'].response.cart_empty})
|
|
}
|
|
})
|
|
},
|
|
async (req, res) => {
|
|
try {
|
|
const branchId = req?.body?.branchId
|
|
const cartItems = await CartItem.find({branchId , user_id: req.user._id}).populate('product_id');
|
|
const checkOrder = await Order.findOne({branchId , 'status': 'incomplete', user_id: req.user._id})
|
|
const getUserInfo = await User.findById(req.user._id);
|
|
const getStoreInfo = await StoreInfo.findOne({_id : branchId})
|
|
|
|
if (!checkOrder) return res404(res, 'لطفا از مرحله سبد خرید دوباره ادامه دهید')
|
|
|
|
let pricePoint = Math.floor(getStoreInfo?.priceForChange/getStoreInfo?.pointForChange) || 0
|
|
let totalPricePoint = getStoreInfo?.totalPricePoint || 0
|
|
let pointForBuy = getStoreInfo?.pointForBuy || 0
|
|
|
|
let discount_percent = checkOrder?.discount_amount || 0;
|
|
let discount_menuType = checkOrder?.discount_menuType;
|
|
let specialDiscountMenuType = false;
|
|
let routePrice = 0;
|
|
let sum = 0;
|
|
let sumFoodByPercent = 0;
|
|
let sumFoodByPercentForDiscount = 0;
|
|
let total = 0
|
|
let firstTotal = 0
|
|
let percent = 0;
|
|
let tax = 0;
|
|
|
|
if (!getUserInfo) return res404(res, `اطلاعات کاربر یافت نشد`);
|
|
|
|
if (!cartItems.length) return res.status(404).json({message: `هیچ محصولی در سبد خرید شما وجود ندارد`})
|
|
|
|
|
|
const orderItems = [];
|
|
for (const item of cartItems) {
|
|
orderItems.push({
|
|
product_id: item.product_id._id,
|
|
name: item.product_id.name,
|
|
quantity: item.quantity,
|
|
price: item.product_id.price,
|
|
static_discount: item.product_id.static_discount,
|
|
havePoint: item.product_id.havePoint
|
|
});
|
|
|
|
const itemPercent = item.product_id.price * item.product_id.static_discount / 100;
|
|
const sumPercent = itemPercent * item.quantity;
|
|
const price = item.product_id.price;
|
|
const sumPriceItem = price * item.quantity;
|
|
|
|
|
|
let sumByPercentForDiscount = sumPriceItem - sumPercent
|
|
|
|
if (Boolean(discount_percent) && discount_menuType) {
|
|
specialDiscountMenuType = true
|
|
if (item?.product_id?.category.type?.toString() === discount_menuType?.toString()) {
|
|
sumFoodByPercentForDiscount += sumByPercentForDiscount
|
|
}
|
|
}
|
|
|
|
|
|
sum = sum + sumPriceItem; /// sum food price without percent
|
|
percent = percent + sumPercent; /// sum all food percent
|
|
}
|
|
|
|
/// sum food price with percent
|
|
sumFoodByPercent = sum - percent
|
|
|
|
/// compute shipping cost
|
|
if (getStoreInfo) {
|
|
if (getStoreInfo?.shippingType) {
|
|
routePrice = getStoreInfo?.shippingCost || 0;
|
|
} else {
|
|
routePrice = await _computeShippingCostByRoad(getUserInfo?.addresses, getStoreInfo?.location) * (getStoreInfo?.shippingCost || 0) || 0;
|
|
}
|
|
|
|
/// compute tax of order
|
|
if (getStoreInfo?.tax) {
|
|
tax = sumFoodByPercent * 9 / 100
|
|
}
|
|
}
|
|
|
|
/// compute discount code
|
|
if (Boolean(discount_percent)) {
|
|
let discountPercent = (specialDiscountMenuType ? sumFoodByPercentForDiscount : sumFoodByPercent) * discount_percent / 100
|
|
percent = percent + discountPercent
|
|
/// compute sum food with discount percent
|
|
sumFoodByPercent = sumFoodByPercent - discountPercent
|
|
}
|
|
|
|
/// compute total of order
|
|
total = sumFoodByPercent + tax + routePrice;
|
|
|
|
checkOrder.order_items = orderItems
|
|
checkOrder.createdOn = Date.now()
|
|
checkOrder.address = getUserInfo.addresses.find(item => item.used)
|
|
checkOrder.sum = Math.ceil(sum)
|
|
checkOrder.routePrice = Math.ceil(routePrice)
|
|
checkOrder.tax = Math.ceil(tax)
|
|
checkOrder.percent = Math.ceil(percent)
|
|
checkOrder.total = Math.ceil(total)
|
|
checkOrder.pricePoint = pricePoint
|
|
firstTotal = Math.ceil(total)
|
|
|
|
if (checkOrder.bag) {
|
|
const payPrice = total - getUserInfo?.bagAmount
|
|
total = payPrice <= 0 ? 0 : payPrice
|
|
}
|
|
|
|
if (checkOrder.score && pricePoint > 0) {
|
|
const payScore = total - (getUserInfo?.score * pricePoint)
|
|
total = payScore <= 0 ? 0 : payScore
|
|
}
|
|
|
|
checkOrder.payTotal = Math.ceil(total)
|
|
|
|
console.log('total', total)
|
|
console.log('payTotal', checkOrder?.payTotal)
|
|
|
|
/// if total pay is zero dont move to pay method
|
|
if (checkOrder?.payTotal <= 0) {
|
|
|
|
/// if bag true use the bagAmount of user
|
|
if (checkOrder?.bag) {
|
|
getUserInfo.bagAmount -= firstTotal
|
|
|
|
// add point for user only for available product
|
|
const computeAvaPro = await _computeHavePointPrice(checkOrder.order_items)
|
|
/// add score for order
|
|
if (computeAvaPro >= totalPricePoint && totalPricePoint > 0) {
|
|
const point = (Math.floor(computeAvaPro / totalPricePoint) * pointForBuy)
|
|
|
|
if (point > 0) {
|
|
getUserInfo.score = getUserInfo.score + point
|
|
getUserInfo.scoreLogs = [
|
|
{
|
|
score: point,
|
|
order_id: getUserInfo._id,
|
|
forWhat: 'buy',
|
|
action: 'increase'
|
|
}
|
|
]
|
|
}
|
|
}
|
|
await getUserInfo.save()
|
|
|
|
if (Boolean(discount_percent)) {
|
|
const updateDiscount = await DiscountCode.findOne({discount_code: checkOrder.discount_code})
|
|
|
|
if (!updateDiscount || (Number(updateDiscount.discount_expire_date) > Date.now())) return res.status(403).json({message: 'مشکلی در پرداخت و ثبت سفارش پیش آمده است لطفا با پشتیبانی تماس بگیرید'})
|
|
|
|
updateDiscount.used_by.push(getUserInfo._id)
|
|
await updateDiscount.save()
|
|
}
|
|
|
|
const addPayment = await Payment.create({
|
|
user_id: getUserInfo._id,
|
|
order_id: checkOrder._id,
|
|
transactionId: Date.now(),
|
|
refId: Date.now(),
|
|
getPayment: true,
|
|
action: 'decreaseBag',
|
|
status: 'paid',
|
|
cost: firstTotal,
|
|
})
|
|
|
|
checkOrder.payment.push(addPayment._id)
|
|
checkOrder.bagCost = firstTotal
|
|
} /// it was ok!
|
|
|
|
/// if score true use the score of user
|
|
if (checkOrder?.score && pricePoint > 0) {
|
|
const point = Math.ceil(firstTotal / pricePoint)
|
|
checkOrder.scoreCost = point * pricePoint
|
|
checkOrder.scorePoint = point
|
|
getUserInfo.score -= point
|
|
getUserInfo.scoreLogs = [
|
|
{
|
|
score: point,
|
|
order_id: checkOrder._id,
|
|
forWhat: 'buy',
|
|
action: 'decrease'
|
|
}
|
|
]
|
|
|
|
await getUserInfo.save()
|
|
}
|
|
|
|
checkOrder.statuses.push({
|
|
status: 'processing'
|
|
})
|
|
checkOrder.status = 'processing'
|
|
checkOrder.paymentStatus = 'paid'
|
|
await checkOrder.save()
|
|
|
|
for (const food of checkOrder.order_items) {
|
|
const getFood = await Food.findById(food.product_id)
|
|
|
|
if (getFood) {
|
|
getFood.stock = getFood.stock - food.quantity
|
|
// getFood.canReview.push(req.user._id)///add user id for review
|
|
getFood.save()
|
|
}
|
|
}
|
|
|
|
/// remove cart item
|
|
await CartItem.deleteMany({user_id: getUserInfo._id})
|
|
|
|
//----------------------- send notif for admins -----------------
|
|
const fcmTokens = []
|
|
const allAdmins = await User.find({scope: 'admin'})
|
|
for (const admin of allAdmins) {
|
|
if (admin.fcmToken) fcmTokens.push(admin.fcmToken)
|
|
}
|
|
const objNotif = {
|
|
title: 'سفارش جدید!',
|
|
body: 'یک سفارش جدید در پنل برگ من ثبت گردید'
|
|
}
|
|
const payload = {
|
|
notification: objNotif,
|
|
};
|
|
const input = {
|
|
registrationTokens: fcmTokens,
|
|
payload
|
|
}
|
|
await sendMulti(input)
|
|
|
|
sendNotifyOrder(checkOrder?.branchId)
|
|
//----------------------------------------------------------------
|
|
|
|
//--------------------- send notif to user --------------------------
|
|
const messageUser = {
|
|
title: 'ثبت سفارش',
|
|
body: 'با تشکر از اعتماد شما سفارش شما با موفقیت ثبت شد'
|
|
}
|
|
const payloadUser = {
|
|
notification: messageUser,
|
|
};
|
|
const inputUser = {
|
|
registrationTokens: getUserInfo.fcmToken,
|
|
payload: payloadUser
|
|
}
|
|
await sendSingle(inputUser)
|
|
//-------------------------------------------------------------------
|
|
|
|
//------------------------------- send sms --------------------------
|
|
const smsTemplate = `سفارش شما با موفقیت ثبت شد با تشکر از اعتماد شما برگ من لغو11`
|
|
|
|
const smsResult = await sms(getUserInfo.mobile_number, smsTemplate)
|
|
|
|
if (!smsResult || !smsResult.data.IsSuccessful) {
|
|
return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
|
|
}
|
|
//-------------------------------------------------------------------
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
}
|
|
|
|
const request = await zarinpal.request(checkOrder?.payTotal, checkOrder?.number?.toString(), req.user)
|
|
|
|
if (!request.status) {
|
|
console.log(request)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
|
|
// add payment to order
|
|
const addPayment = await Payment.create({
|
|
user_id: getUserInfo._id,
|
|
order_id: checkOrder._id,
|
|
transactionId: request.response.authority,
|
|
cost: checkOrder.payTotal,
|
|
})
|
|
|
|
if (addPayment) {
|
|
checkOrder.payment = addPayment._id
|
|
await checkOrder.save();
|
|
} else {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
|
|
/// remove cart item
|
|
await CartItem.deleteMany({branchId , user_id: req.user._id})
|
|
|
|
return res.json({paymentUrl: `${zarinUrl}/${request.response.authority}`})
|
|
|
|
} catch (error) {
|
|
console.log(error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.getPaymentResponse = [
|
|
async (req, res) => {
|
|
try {
|
|
const checkPayment = await Payment.findOne({transactionId: req?.query?.Authority}).populate('order_id')
|
|
|
|
const user = await User.findById(checkPayment.user_id)
|
|
|
|
///check duplicate transaction
|
|
if (!checkPayment || checkPayment.getPayment || checkPayment.action === 'decreaseBag') {
|
|
return res.json({
|
|
status: false,
|
|
fromWhere : user?.fromWhere || 'app',
|
|
message: 'پرداخت ناموفق بود'
|
|
})
|
|
}
|
|
|
|
/// verify transaction
|
|
const verify = await zarinpal.verify(checkPayment.action === 'increaseBag' ? checkPayment.cost : checkPayment.order_id.payTotal, checkPayment.transactionId)
|
|
|
|
console.log(verify)
|
|
|
|
if (verify.status) {
|
|
|
|
if (verify.code === 101) {
|
|
console.log(verify)
|
|
return res.json({
|
|
status: false,
|
|
message: 'پرداخت ناموفق بود'
|
|
})
|
|
}
|
|
|
|
checkPayment.status = 'paid'
|
|
checkPayment.refId = verify?.response?.ref_id
|
|
checkPayment.getPayment = true
|
|
checkPayment.fee_type = verify?.response?.fee_type
|
|
checkPayment.card_hash = verify?.response?.card_hash
|
|
checkPayment.card_pan = verify?.response?.card_pan
|
|
checkPayment.fee = verify?.response?.fee
|
|
checkPayment.created_at = Date.now()
|
|
checkPayment.createdOn = Date.now()
|
|
|
|
await checkPayment.save()
|
|
|
|
/// only for buy food execute this action
|
|
if (checkPayment.action === 'payOrder') {
|
|
const getOrder = await Order.findById(checkPayment.order_id._id)
|
|
|
|
if (!getOrder) return res404(res, 'سفارش پیدا نشد')
|
|
|
|
for (const food of getOrder.order_items) {
|
|
const getFood = await Food.findById(food.product_id)
|
|
|
|
if (getFood) {
|
|
getFood.stock = getFood.stock - food.quantity
|
|
// getFood.canReview.push(req.user._id)///add user id for review
|
|
getFood.save()
|
|
}
|
|
}
|
|
|
|
if (getOrder.discount_code) {
|
|
const discount = await DiscountCode.findOne({discount_code: getOrder.discount_code})
|
|
|
|
if (discount) {
|
|
discount.used_by.push(getOrder.user_id)
|
|
|
|
await discount.save()
|
|
}
|
|
}
|
|
|
|
if (user) {
|
|
/// decrease score
|
|
if (getOrder?.score) {
|
|
getOrder.scorePoint = user.score
|
|
getOrder.scoreCost = user.score * getOrder?.pricePoint
|
|
user.scoreLogs = [
|
|
{
|
|
score: user.score,
|
|
order_id: getOrder._id,
|
|
forWhat: 'buy',
|
|
action: 'decrease'
|
|
}
|
|
]
|
|
user.score = 0
|
|
await user.save()
|
|
}
|
|
|
|
/// decrease bag
|
|
if (getOrder.bag) {
|
|
const addPayment = await Payment.create({
|
|
user_id: user._id,
|
|
order_id: getOrder._id,
|
|
transactionId: Date.now(),
|
|
refId: Date.now(),
|
|
getPayment: true,
|
|
action: 'decreaseBag',
|
|
status: 'paid',
|
|
cost: user.bagAmount,
|
|
})
|
|
getOrder.payment.push(addPayment._id)
|
|
getOrder.bagCost = user.bagAmount
|
|
user.bagAmount = 0
|
|
await user.save()
|
|
}
|
|
|
|
if (!getOrder.score || !getOrder?.discount_code) {
|
|
// add point for user only for available product
|
|
const computeAvaPro = await _computeHavePointPrice(getOrder?.order_items)
|
|
|
|
/// add score for order
|
|
if (computeAvaPro >= getOrder?.totalPricePoint && getOrder?.totalPricePoint > 0) {
|
|
const point = (Math.floor(computeAvaPro / getOrder?.totalPricePoint) * getOrder?.pointForBuy)
|
|
|
|
if (point > 0) {
|
|
user.score = user.score + point
|
|
user.scoreLogs = [
|
|
{
|
|
score: point,
|
|
order_id: getOrder._id,
|
|
forWhat: 'buy',
|
|
action: 'increase'
|
|
}
|
|
]
|
|
await user.save()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
getOrder.statuses.push({
|
|
status: 'processing'
|
|
})
|
|
getOrder.status = 'processing'
|
|
getOrder.paymentStatus = 'paid'
|
|
|
|
await getOrder.save()
|
|
|
|
//----------------------- send notif for admins -----------------
|
|
const fcmTokens = []
|
|
const allAdmins = await User.find({scope: 'admin'})
|
|
for (const admin of allAdmins) {
|
|
if (admin.fcmToken) fcmTokens.push(admin.fcmToken)
|
|
}
|
|
const objNotif = {
|
|
title: 'سفارش جدید!',
|
|
body: 'یک سفارش جدید در پنل برگ من ثبت گردید'
|
|
}
|
|
const payload = {
|
|
notification: objNotif,
|
|
};
|
|
const input = {
|
|
registrationTokens: fcmTokens,
|
|
payload
|
|
}
|
|
await sendMulti(input)
|
|
|
|
sendNotifyOrder(getOrder?.branchId)
|
|
//----------------------------------------------------------------
|
|
|
|
//--------------------- send notif to user --------------------------
|
|
const messageUser = {
|
|
title: 'ثبت سفارش',
|
|
body: 'با تشکر از اعتماد شما سفارش شما با موفقیت ثبت شد'
|
|
}
|
|
const payloadUser = {
|
|
notification: messageUser,
|
|
};
|
|
const inputUser = {
|
|
registrationTokens: user.fcmToken,
|
|
payload: payloadUser
|
|
}
|
|
await sendSingle(inputUser)
|
|
//-------------------------------------------------------------------
|
|
|
|
//------------------------------- send sms --------------------------
|
|
const smsTemplate = `سفارش شما با موفقیت ثبت شد با تشکر از اعتماد شما برگ من لغو11`
|
|
|
|
const smsResult = await sms(user.mobile_number, smsTemplate)
|
|
|
|
if (!smsResult || !smsResult.data.IsSuccessful) {
|
|
return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
|
|
}
|
|
//-------------------------------------------------------------------
|
|
|
|
|
|
} else if (checkPayment.action === 'increaseBag') {
|
|
if (!user) return res.json({
|
|
status: false,
|
|
message: 'مشکلی در افزایش موجودی کیف پول شما پیش آمده است لطفا با پشتیبانی تماس بگیرید'
|
|
})
|
|
|
|
user.bagAmount = user.bagAmount + checkPayment?.cost
|
|
|
|
await user.save()
|
|
//--------------------- send notif to user --------------------------
|
|
const messageUser = {
|
|
title: 'افزایش موجودی',
|
|
body: 'با تشکر از اعتماد شما کیف پول شما با موفقیت شارژ شد برگ من'
|
|
}
|
|
const payloadUser = {
|
|
notification: messageUser,
|
|
};
|
|
const inputUser = {
|
|
registrationTokens: user.fcmToken,
|
|
payload: payloadUser
|
|
}
|
|
await sendSingle(inputUser)
|
|
//-------------------------------------------------------------------
|
|
|
|
//------------------------------- send sms --------------------------
|
|
const smsTemplate = `با تشکر از اعتماد شما کیف پول شما با موفقیت شارژ شد برگ من لغو11`
|
|
|
|
const smsResult = await sms(user.mobile_number, smsTemplate)
|
|
|
|
if (!smsResult || !smsResult.data.IsSuccessful) {
|
|
return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
|
|
}
|
|
//-------------------------------------------------------------------
|
|
}
|
|
|
|
return res.json({
|
|
status: true,
|
|
refId: verify?.response?.ref_id,
|
|
fromWhere : user?.fromWhere || 'app',
|
|
message: 'پرداخت با موفقیت انجام شد'
|
|
})
|
|
|
|
} else {
|
|
/// only for buy food execute this action
|
|
if (checkPayment.action === 'payOrder') {
|
|
let getOrder = await Order.findById(checkPayment.order_id._id)
|
|
|
|
if (getOrder) {
|
|
getOrder.statuses.push({
|
|
status: 'void'
|
|
})
|
|
getOrder.status = 'void'
|
|
getOrder.paymentStatus = 'unpaid'
|
|
|
|
await getOrder.save()
|
|
}
|
|
|
|
checkPayment.getPayment = true
|
|
checkPayment.created_at = new Date()
|
|
await checkPayment.save()
|
|
}
|
|
|
|
return res.json({
|
|
status: false,
|
|
fromWhere : user?.fromWhere || 'app',
|
|
message: 'پرداخت ناموفق بود'
|
|
})
|
|
}
|
|
} catch (error) {
|
|
console.log(error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.addAddressToOrder = [
|
|
(req, res) => {
|
|
Order.findById(req.params.order_id)
|
|
.then(order => {
|
|
if (!order.address) {
|
|
User.findOne({'addresses._id': req.body.address_id})
|
|
.then(user => {
|
|
order.address = user.addresses.id(req.body.address_id)
|
|
// add processing status to order
|
|
order.statuses.push({
|
|
status: 'processing'
|
|
})
|
|
order.save()
|
|
return res.json(order)
|
|
})
|
|
.catch(err => {
|
|
return res500(res, err)
|
|
})
|
|
} else {
|
|
return res.status(500).json({message: v_m[req.body.locale].response.already_has_address})
|
|
}
|
|
})
|
|
.catch(err => {
|
|
return res404(res, err)
|
|
})
|
|
}
|
|
]
|
|
|
|
module.exports.addStatusToOrder = [
|
|
async (req, res) => {
|
|
try {
|
|
const order = await Order.findById(req.params.order_id).populate('user_id')
|
|
|
|
if (!order) return res404(res, 'سفارش مورد نظر یافت نشد')
|
|
|
|
order.statuses.push({
|
|
status: req.body.status
|
|
})
|
|
order.status = req.body.status
|
|
order.save()
|
|
|
|
if (req.body.status === 'delivered') {
|
|
//--------------------- send notif to user --------------------------
|
|
const messageUser = {
|
|
title: 'ارسال سفارش',
|
|
body: 'سفارش شما ارسال گردید با تشکر برگ من'
|
|
}
|
|
const payloadUser = {
|
|
notification: messageUser,
|
|
};
|
|
const inputUser = {
|
|
registrationTokens: order?.user_id?.fcmToken,
|
|
payload: payloadUser
|
|
}
|
|
await sendSingle(inputUser)
|
|
//-------------------------------------------------------------------
|
|
|
|
setTimeout(async () => {
|
|
let smsTemplate = ''
|
|
if (order.user_id.fromWhere === 'app') smsTemplate = `لطفا با ثبت نظر برای سفارش خود به ما برای خدمات بهتر کمک کنید با تشکر برگ من`
|
|
else smsTemplate = `لطفا با ثبت نظر برای سفارش خود به ما برای خدمات بهتر کمک کنید با تشکر برگ من لغو11
|
|
لینک : https://app.bargrestaurant.com/rate/${req.params.order_id}`
|
|
const smsResult = await sms(order?.user_id?.mobile_number, smsTemplate)
|
|
|
|
//--------------------- send notif to user --------------------------
|
|
const messageUser = {
|
|
title: 'ثبت نظر',
|
|
body: 'لطفا با ثبت نظر برای سفارش خود به ما برای خدمات بهتر کمک کنید با تشکر'
|
|
}
|
|
const payloadUser = {
|
|
notification: messageUser,
|
|
};
|
|
const inputUser = {
|
|
registrationTokens: order?.user_id?.fcmToken,
|
|
payload: payloadUser
|
|
}
|
|
await sendSingle(inputUser)
|
|
//-------------------------------------------------------------------
|
|
|
|
if (!smsResult || !smsResult.data.IsSuccessful) {
|
|
console.log('order sms', smsResult)
|
|
}
|
|
}, timeToStart)
|
|
}
|
|
return res.json(order)
|
|
} catch (error) {
|
|
console.log(error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.changePayStatus = [
|
|
[
|
|
body('status')
|
|
.notEmpty().withMessage(_sr['fa'].required.field)
|
|
.bail()
|
|
.isIn(['refund', 'unpaid', 'paid']).withMessage('وضعیت ارسال شده صحیح نمی باشد')
|
|
],
|
|
checkValidations(validationResult),
|
|
async (req, res) => {
|
|
try {
|
|
const targetOrder = await Order.findById(req.params.id)
|
|
|
|
if (!targetOrder) return res404(res, 'سفارش مورد نظر پیدا نشد');
|
|
|
|
const targetPayment = await Payment.findById(targetOrder.payment)
|
|
|
|
if (targetPayment) {
|
|
targetPayment.status = req.body.status
|
|
await targetPayment.save()
|
|
}
|
|
|
|
targetOrder.paymentStatus = req.body.status
|
|
await targetOrder.save()
|
|
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.getOrders = [
|
|
(req, res) => {
|
|
const branchId = req?.params?.branchId
|
|
Order.find({
|
|
branchId,
|
|
user_id: req.user._id,
|
|
status: {$in: ['canceled' , 'processing', 'sent', 'delivered']},
|
|
paymentStatus: 'paid'
|
|
}).populate({
|
|
path: 'order_items.product_id',
|
|
select: 'name canReview ratings'
|
|
}).sort({_id: -1})
|
|
.then(orders => {
|
|
const allOrders = []
|
|
|
|
for (const item of orders) {
|
|
let clone = JSON.parse(JSON.stringify(item.order_items))
|
|
|
|
clone.map(food => {
|
|
// food.review = food?.product_id?.canReview?.includes(req.user._id.toString())
|
|
// food.rating = food?.product_id?.ratings?.find(rate => rate.user_id.toString() === req.user._id.toString() && rate?.order_id?.toString() === item?._id?.toString())?.rate || 0
|
|
food.rating = food?.product_id?.ratings?.find(rate => rate?.user_id?.toString() === req?.user?._id.toString())?.rate || 0
|
|
})
|
|
|
|
allOrders.push({
|
|
_id: item._id,
|
|
address: item.address,
|
|
status: item.status,
|
|
items: clone,
|
|
orderType: item.orderType,
|
|
review: item.rating.rate,
|
|
created_at: item.createdOn,
|
|
total: item.total
|
|
})
|
|
}
|
|
|
|
return res.json(allOrders)
|
|
})
|
|
.catch(err => {
|
|
console.log(err.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
})
|
|
}
|
|
]
|
|
|
|
module.exports.getOrdersForReport = [
|
|
async (req, res) => {
|
|
try {
|
|
const branchId = req?.params?.branchId
|
|
const orders = await Order.find({
|
|
branchId,
|
|
status: {$in: ['canceled' ,'processing', 'sent', 'delivered']},
|
|
paymentStatus: 'paid'
|
|
})
|
|
return res.json(orders)
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.getOneOrderByUser = [
|
|
async (req, res) => {
|
|
try {
|
|
const targetOrder = await Order.findOne({_id: req.params.id, user_id: req.user._id}).select('status')
|
|
|
|
if (!targetOrder) return res404(res, 'سفارش مورد نظر پیدا نشد')
|
|
|
|
return res.json(targetOrder)
|
|
} catch (error) {
|
|
console.log('get one order by user |', error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.deleteOrder = [
|
|
async (req, res) => {
|
|
try {
|
|
const targetOrder = await Order.findById(req.params.id);
|
|
|
|
if (!targetOrder) return res404(res, 'سفارش مورد نظر پیدا نشد')
|
|
|
|
/// @todo maybe delete payment too
|
|
|
|
await targetOrder.deleteOne()
|
|
|
|
return res.json({message: _sr['fa'].response.success_remove})
|
|
} catch (error) {
|
|
console.log('delete order: ', error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.increaseBag = [
|
|
[
|
|
body('price')
|
|
.notEmpty().withMessage(`لطفا یک مقدار مشخص کنید`)
|
|
],
|
|
checkValidations(validationResult),
|
|
async (req, res) => {
|
|
try {
|
|
const cost = req.body.price;
|
|
const user = await User.findById(req.user._id)
|
|
|
|
if (!user) return res404(res, `اطلاعات کاربر پیدا نشد`)
|
|
|
|
const request = await zarinpal.request(cost, 'کیف پول', req.user)
|
|
|
|
if (!request.status) {
|
|
console.log(request)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
|
|
// add payment to order
|
|
await Payment.create({
|
|
user_id: user._id,
|
|
order_id: null,
|
|
transactionId: request.response.authority,
|
|
cost: cost,
|
|
action: 'increaseBag'
|
|
})
|
|
|
|
return res.json({paymentUrl: `${zarinUrl}/${request.response.authority}`})
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
/////// admin panel
|
|
module.exports.getOneOrder = [
|
|
(req, res) => {
|
|
Order.findById(req.params.id).populate({
|
|
path: 'user_id',
|
|
select: 'first_name last_name scoreLogs'
|
|
}).populate('order_items.product_id')
|
|
.populate('payment')
|
|
.then(order => {
|
|
return res.json(order)
|
|
})
|
|
.catch(err => {
|
|
return res404(res, err)
|
|
})
|
|
}
|
|
]
|
|
|
|
module.exports.search = [
|
|
async (req, res) => {
|
|
try {
|
|
let {
|
|
branchId,
|
|
number,
|
|
orderStatus,
|
|
paymentStatus,
|
|
userId,
|
|
date
|
|
} = req.body;
|
|
|
|
let findQuery = {
|
|
branchId,
|
|
status: {$nin: ['incomplete', 'void']}
|
|
};
|
|
findQuery['$and'] = [];
|
|
findQuery['$or'] = [];
|
|
|
|
/** search by number */
|
|
if (number && !_.isEmpty(number)) {
|
|
findQuery['$and'].push({
|
|
number
|
|
});
|
|
}
|
|
|
|
/** search by orderStatus */
|
|
if (orderStatus && !_.isEmpty(orderStatus)) {
|
|
findQuery['$and'].push({
|
|
status: {
|
|
$in: orderStatus
|
|
}
|
|
});
|
|
}
|
|
|
|
/** search by paymentStatus */
|
|
if (paymentStatus && !_.isEmpty(paymentStatus)) {
|
|
findQuery['$and'].push({
|
|
paymentStatus: {
|
|
$in: paymentStatus
|
|
}
|
|
});
|
|
}
|
|
|
|
/** search by user_id */
|
|
if (userId && !_.isEmpty(userId)) {
|
|
findQuery['$and'].push({
|
|
user_id: userId
|
|
});
|
|
}
|
|
|
|
/** search by date */
|
|
if (date && !_.isEmpty(date)) {
|
|
if (date.length === 1) {
|
|
findQuery['$and'].push({
|
|
createdOn: {
|
|
$gte: moment(date[0]).startOf('days'),
|
|
$lt: moment(date[0]).endOf('days')
|
|
}
|
|
});
|
|
} else {
|
|
findQuery['$and'].push({
|
|
createdOn: {
|
|
$gte: new Date(date[0]),
|
|
$lt: new Date(date[1])
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
_.isEmpty(findQuery['$and']) && delete findQuery['$and'];
|
|
_.isEmpty(findQuery['$or']) && delete findQuery['$or'];
|
|
|
|
/** get news */
|
|
const orders = await Order.paginate(findQuery, {
|
|
page: req.query.page, limit, populate: [{path: 'user_id', select: 'first_name last_name'}],
|
|
sort: {
|
|
_id: -1
|
|
}
|
|
});
|
|
|
|
/** show result */
|
|
return res.json(orders);
|
|
} catch (error) {
|
|
console.log(error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.reports = [
|
|
// [
|
|
// body('startDate')
|
|
// .notEmpty().withMessage(_sr['fa'].required.date),
|
|
//
|
|
// body('endDate')
|
|
// .notEmpty().withMessage(_sr['fa'].required.date),
|
|
// ],
|
|
// checkValidations(validationResult),
|
|
async (req, res) => {
|
|
try {
|
|
const branchId = req?.params?.branchId
|
|
let findQuery = {
|
|
branchId,
|
|
status: {$nin: ['incomplete', 'void']}
|
|
};
|
|
|
|
let {startDate,endDate} = req.body;
|
|
|
|
// if (!startDate || !endDate){
|
|
// findQuery.createdOn = {
|
|
// createdOn: {
|
|
// $gte: moment().startOf('days'),
|
|
// $lt: moment().endOf('days')
|
|
// }
|
|
// }
|
|
// }else {
|
|
if (startDate && endDate) {
|
|
findQuery.createdOn = {
|
|
$gte: new Date(startDate),
|
|
$lt: new Date(endDate)
|
|
}
|
|
}else if (startDate){
|
|
findQuery.createdOn = {
|
|
$gte: moment(startDate),
|
|
$lt: new Date()
|
|
}
|
|
}else if (endDate){
|
|
findQuery.createdOn = {
|
|
// $gte: '',
|
|
$lt: moment(endDate)
|
|
}
|
|
}
|
|
// }
|
|
|
|
/** search by date */
|
|
// if (startDate || endDate && !_.isEmpty(date)) {
|
|
// if (date.length === 1) {
|
|
// findQuery.createdOn = {
|
|
// $gte: moment(startDate),
|
|
// $lt: moment(startDate)
|
|
// }
|
|
// } else {
|
|
// findQuery.createdOn = {
|
|
// $gte: new Date(date[0]),
|
|
// $lt: new Date(date[1])
|
|
// }
|
|
// }
|
|
// } else {
|
|
//
|
|
// }
|
|
|
|
/** get news */
|
|
const orders = await Order.find(findQuery).populate({path: 'user_id', select: 'first_name last_name'}).sort({_id: -1});
|
|
|
|
let result = {
|
|
count: orders?.length || 0,
|
|
total: orders?.reduce((total, item) => {
|
|
return total + item?.total
|
|
}, 0) || 0,
|
|
payOnline: orders?.reduce((total, item) => {
|
|
return total + item?.payTotal
|
|
}, 0) || 0,
|
|
routePrice: orders?.reduce((total, item) => {
|
|
return total + item?.routePrice
|
|
}, 0) || 0,
|
|
bagCost: orders?.reduce((total, item) => {
|
|
return total + item?.bagCost
|
|
}, 0) || 0,
|
|
scorePoint: orders?.reduce((total, item) => {
|
|
return total + item?.scorePoint
|
|
}, 0) || 0,
|
|
scoreCost: orders?.reduce((total, item) => {
|
|
return total + item?.scoreCost
|
|
}, 0) || 0,
|
|
}
|
|
|
|
/** show result */
|
|
return res.json(result);
|
|
} catch (error) {
|
|
console.log(error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
//////////////////////////////////// compute price
|
|
module.exports.computePrice = [
|
|
//////////////////// validation step
|
|
(req, res, next) => {
|
|
const branchId = req?.params?.branchId
|
|
CartItem.find({branchId , user_id: req.user._id})
|
|
.then(items => {
|
|
// check if cart is not empty
|
|
if (items.length) {
|
|
// check product stock
|
|
let outOfRun = []
|
|
items.forEach(async (item, index) => {
|
|
await Food.findById(item.product_id)
|
|
.then(product => {
|
|
if (product.stock < item.quantity) {
|
|
outOfRun.push({
|
|
product_id: product._id,
|
|
category_id: product.category,
|
|
stock: product.stock
|
|
})
|
|
item.remove()
|
|
}
|
|
if (index + 1 === items.length) {
|
|
if (!outOfRun.length) return next()
|
|
else return res.status(422).json(outOfRun)
|
|
}
|
|
})
|
|
})
|
|
} else {
|
|
return res.status(404).json({message: _sr['fa'].response.cart_empty})
|
|
}
|
|
})
|
|
},
|
|
async (req, res) => {
|
|
try {
|
|
const branchId = req?.params?.branchId
|
|
const cartItems = await CartItem.find({branchId, user_id: req.user._id}).populate({
|
|
path: 'product_id',
|
|
populate: {
|
|
path: 'category',
|
|
model: 'FoodCategory'
|
|
}
|
|
});
|
|
const checkOrder = await Order.findOne({branchId , 'status': 'incomplete', user_id: req.user._id})
|
|
const getUserInfo = await User.findById(req.user._id);
|
|
const getStoreInfo = await StoreInfo.findOne({_id : branchId})
|
|
const product = [];
|
|
const userAddress = getUserInfo.addresses.find(item => item.used === true) || null
|
|
let specialDiscountMenuType = false;
|
|
let discount_percent = checkOrder?.discount_amount || 0;
|
|
let discount_menuType = checkOrder?.discount_menuType;
|
|
let routePrice = 0;
|
|
let sum = 0;
|
|
let sumFoodByPercent = 0;
|
|
let sumFoodByPercentForDiscount = 0;
|
|
let total = 0;
|
|
let percent = 0;
|
|
let tax = 0;
|
|
|
|
if (!getUserInfo) return res404(res, `اطلاعات کاربر یافت نشد`);
|
|
|
|
if (!cartItems.length) return res.status(404).json({message: `هیچ محصولی در سبد خرید شما وجود ندارد`})
|
|
|
|
if (checkOrder) {
|
|
const orderItems = [];
|
|
for (const item of cartItems) {
|
|
orderItems.push({
|
|
product_id: item.product_id._id,
|
|
name: item.product_id.name,
|
|
quantity: item.quantity,
|
|
price: item.product_id.price,
|
|
static_discount: item.product_id.static_discount,
|
|
havePoint: item.product_id.havePoint
|
|
});
|
|
|
|
product.push({
|
|
product: item.product_id,
|
|
quantity: item.quantity
|
|
})
|
|
|
|
const itemPercent = item.product_id.price * item.product_id.static_discount / 100;
|
|
const sumPercent = itemPercent * item.quantity;
|
|
const price = item.product_id.price;
|
|
const sumPriceItem = price * item.quantity;
|
|
|
|
let sumByPercentForDiscount = sumPriceItem - sumPercent
|
|
|
|
if (Boolean(discount_percent) && discount_menuType) {
|
|
specialDiscountMenuType = true
|
|
if (item?.product_id?.category.type?.toString() === discount_menuType?.toString()) {
|
|
sumFoodByPercentForDiscount += sumByPercentForDiscount
|
|
}
|
|
}
|
|
|
|
sum = sum + sumPriceItem; /// sum food price without percent
|
|
percent = percent + sumPercent; /// sum all food percent
|
|
}
|
|
|
|
/// sum food price with percent
|
|
sumFoodByPercent = sum - percent
|
|
|
|
/// compute shipping cost
|
|
if (getStoreInfo) {
|
|
if (getStoreInfo?.shippingType) {
|
|
routePrice = getStoreInfo?.shippingCost || 0;
|
|
} else {
|
|
routePrice = await _computeShippingCostByRoad(getUserInfo?.addresses, getStoreInfo?.location) * (getStoreInfo?.shippingCost || 0) || 0;
|
|
}
|
|
|
|
/// compute tax of order
|
|
if (getStoreInfo?.tax) {
|
|
tax = sumFoodByPercent * 9 / 100
|
|
}
|
|
}
|
|
|
|
/// compute discount code
|
|
if (Boolean(discount_percent)) {
|
|
let discountPercent = (specialDiscountMenuType ? sumFoodByPercentForDiscount : sumFoodByPercent) * discount_percent / 100
|
|
percent = percent + discountPercent
|
|
/// compute sum food with discount percent
|
|
sumFoodByPercent = sumFoodByPercent - discountPercent
|
|
}
|
|
|
|
/// compute total of order
|
|
total = sumFoodByPercent + tax + routePrice;
|
|
|
|
checkOrder.order_items = orderItems
|
|
checkOrder.createdOn = Date.now()
|
|
checkOrder.sum = Math.ceil(sum)
|
|
checkOrder.routePrice = Math.ceil(routePrice)
|
|
checkOrder.tax = Math.ceil(tax)
|
|
checkOrder.percent = Math.ceil(percent)
|
|
checkOrder.total = Math.ceil(total)
|
|
checkOrder.pricePoint = getStoreInfo?.pricePoint
|
|
|
|
if (checkOrder.bag) {
|
|
const payPrice = total - getUserInfo?.bagAmount
|
|
total = payPrice <= 0 ? 0 : payPrice
|
|
}
|
|
|
|
if (checkOrder.score && getStoreInfo?.pricePoint > 0) {
|
|
const payScore = total - (getUserInfo?.score * getStoreInfo?.pricePoint)
|
|
total = payScore <= 0 ? 0 : payScore
|
|
}
|
|
|
|
checkOrder.payTotal = Math.ceil(total)
|
|
|
|
checkOrder.save();
|
|
}
|
|
|
|
return res.json({
|
|
usePoint: getStoreInfo?.usePointWhenPay,
|
|
product,
|
|
userAddress,
|
|
sum: Math.ceil(sum),
|
|
routePrice: Math.ceil(routePrice),
|
|
tax: Math.ceil(tax),
|
|
percent: Math.ceil(percent),
|
|
total: Math.ceil(checkOrder.payTotal)
|
|
})
|
|
|
|
} catch (error) {
|
|
console.log(error.message)
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
////////////////////////////////////// get list of all orders for admin
|
|
module.exports.getAllOrders = [
|
|
async (req, res) => {
|
|
try {
|
|
const branchId = req?.params?.branchId
|
|
const orders = await Order.paginate({branchId, status: {$nin: ['incomplete', 'void']}}, {
|
|
page: req.query.page || 1,
|
|
limit,
|
|
populate: [
|
|
{path: 'user_id', select: 'first_name last_name'}
|
|
],
|
|
sort: {_id: -1}
|
|
})
|
|
|
|
return res.json(orders)
|
|
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
///////////////////////////////////// get payment list
|
|
module.exports.getAllPaymentByUser = [
|
|
async (req, res) => {
|
|
try {
|
|
const getAll = await Payment.find({user_id: req.user._id}).sort({_id: -1})
|
|
return res.json(getAll)
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.getAllPaymentByAdmin = [
|
|
async (req, res) => {
|
|
try {
|
|
const getAll = await Payment.paginate({user_id: req.params.id}, {
|
|
page: req.query.page || 1,
|
|
limit,
|
|
sort: {_id: -1}
|
|
})
|
|
return res.json(getAll)
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
//////////////////////////////////// get all foods for rates
|
|
module.exports.getAllRateFood = [
|
|
async (req, res) => {
|
|
try {
|
|
const getOrder = await Order.findOne({
|
|
_id: req.params.order_id,
|
|
user_id: req.user._id,
|
|
status: 'delivered',
|
|
paymentStatus: 'paid'
|
|
}).populate({
|
|
path: 'order_items.product_id',
|
|
select: 'name ratings'
|
|
})
|
|
|
|
if (!getOrder) return res404(res, `سفارش مورد نظر پیدا نشد`)
|
|
|
|
return res.json(getOrder)
|
|
} catch (e) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
/////////////////////////////////// rate order
|
|
module.exports.rateOrderAndFood = [
|
|
[
|
|
body('rateOrder')
|
|
.notEmpty().withMessage(_sr['fa'].required.field)
|
|
],
|
|
checkValidations(validationResult),
|
|
async (req, res) => {
|
|
try {
|
|
const orderId = req?.params?.order_id
|
|
const {rateOrder, reason, foods} = req.body
|
|
const getOrder = await Order.findOne({
|
|
_id: orderId,
|
|
user_id: req.user._id,
|
|
status: 'delivered',
|
|
paymentStatus: 'paid'
|
|
})
|
|
|
|
if (!getOrder) return res404(res, `سفارش مورد نظر پیدا نشد`)
|
|
|
|
//// add rate for all foods
|
|
for (const food of foods) {
|
|
const data = {
|
|
rate: food.rate,
|
|
comment: food.comment,
|
|
order_id: getOrder._id,
|
|
user_id: getOrder.user_id
|
|
}
|
|
//// check food exist or not
|
|
const getFood = await Food.findById(food?.product_id?._id)
|
|
|
|
if (getFood && getOrder?.order_items.some(item => item?.product_id?._id?.toString() === getFood?._id?.toString())) {
|
|
getFood.ratings.push(data)
|
|
let rateSUM = 0
|
|
getFood?.ratings?.forEach(item => rateSUM += Number(item.rate))
|
|
getFood.rate = (rateSUM / getFood?.ratings?.length).toFixed(1)
|
|
await getFood.save()
|
|
}
|
|
}
|
|
|
|
//// add rate to order
|
|
getOrder.rating = {
|
|
rate: rateOrder,
|
|
reasonForBad: reason
|
|
}
|
|
|
|
await getOrder.save()
|
|
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
} catch (e) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
////////////////////////////////// buy club
|
|
module.exports.buyClub = [
|
|
[
|
|
body('clubId')
|
|
.notEmpty().withMessage(_sr['fa'].required.field)
|
|
],
|
|
checkValidations(validationResult),
|
|
async (req, res) => {
|
|
try {
|
|
const clubId = req.body?.clubId
|
|
|
|
const user = await User.findById(req.user._id)
|
|
if (!user) return res404(res, 'اطلاعات کاربر یافت نشد')
|
|
|
|
const club = await Food.findOne({_id: clubId, club: true})
|
|
if (!club) return res404(res, 'کلاب مورد نظر پیدا نشد')
|
|
|
|
if (user.score < club.point) return res.status(422).json({message: 'امتیاز شما برای خرید این محصول کافی نمی باشد'})
|
|
|
|
const data = {
|
|
user_id: user._id,
|
|
score: true,
|
|
scorePoint: club.point,
|
|
scoreCost: club.price,
|
|
orderType: 'club',
|
|
number: Date.now(),
|
|
address: user?.addresses.find(item => item.used),
|
|
createdOn: Date.now(),
|
|
paymentStatus: 'paid',
|
|
statuses: [{
|
|
status: 'processing'
|
|
}],
|
|
status: 'processing',
|
|
order_items: [{
|
|
product_id: club._id,
|
|
name: club.name,
|
|
quantity: 1,
|
|
price: club.price,
|
|
point: club.point,
|
|
havePoint: true
|
|
}],
|
|
sum: club.point,
|
|
routePrice: 0,
|
|
tax: 0,
|
|
percent: 0,
|
|
total: club.price
|
|
}
|
|
|
|
const order = await Order.create(data)
|
|
if (!order) return res500(res, _sr['fa'].response.unknownError)
|
|
|
|
user.score -= club.point
|
|
user.scoreLogs = [
|
|
{
|
|
score: club.point,
|
|
order_id: order._id,
|
|
forWhat: 'buy',
|
|
action: 'decrease'
|
|
}
|
|
]
|
|
await user.save()
|
|
|
|
club.stock -= club?.clubQuantity || 1
|
|
await club.save()
|
|
|
|
return res.json({message: _sr['fa'].response.success_save})
|
|
} catch (error) {
|
|
return res500(res, _sr['fa'].response.unknownError)
|
|
}
|
|
}
|
|
]
|
|
|
|
////////////////////////////////// test notif
|
|
module.exports.testNotif = [
|
|
async (req, res) => {
|
|
try {
|
|
sendNotifyOrder('6126313206f2593a6a4f71db')
|
|
return res.json({})
|
|
} catch (error) {
|
|
return res500(res, error.message)
|
|
}
|
|
}
|
|
]
|
|
|
|
module.exports.chromeNotif = [
|
|
async (req, res) => {
|
|
try {
|
|
const fcmTokens = []
|
|
const allAdmins = await User.find({scope: 'admin'})
|
|
|
|
for (const admin of allAdmins) {
|
|
if (admin.fcmToken) fcmTokens.push(admin.fcmToken)
|
|
}
|
|
|
|
const objNotif = {
|
|
title: "سفارش جدید!",
|
|
body: "یک سفارش جدید در پنل برگ من ثبت گردید"
|
|
}
|
|
|
|
const payload = {
|
|
notification: objNotif,
|
|
data: {
|
|
routeName: 'test',
|
|
type: "bazaar",
|
|
routeType: "viewBazaar",
|
|
},
|
|
};
|
|
console.log(fcmTokens)
|
|
|
|
const input = {
|
|
registrationTokens: fcmTokens,
|
|
payload
|
|
}
|
|
|
|
console.log(input)
|
|
|
|
const test = await sendMulti(input)
|
|
|
|
return res.json(test)
|
|
// const payload = JSON.stringify({
|
|
// title: 'Push notifications with Service Workers',
|
|
// });
|
|
//
|
|
// webPush.sendNotification('test', payload)
|
|
// .catch(error => console.error(error));
|
|
} catch (error) {
|
|
|
|
}
|
|
}
|
|
]
|
|
|