519 lines
12 KiB
JavaScript
Executable File
519 lines
12 KiB
JavaScript
Executable File
const mongoose = require('mongoose').set('debug', false)
|
|
const Schema = mongoose.Schema;
|
|
|
|
const shared_consts = require('../tools/shared_nodejs');
|
|
|
|
const Order = require('../models/order');
|
|
var { User } = require('../models/user');
|
|
|
|
const Storehouse = require('../models/storehouse');
|
|
const Provider = require('../models/provider');
|
|
const Product = require('../models/product');
|
|
|
|
const tools = require('../tools/general');
|
|
|
|
const { ObjectID } = require('mongodb');
|
|
|
|
const OrdersCartSchema = new Schema({
|
|
idapp: {
|
|
type: String
|
|
},
|
|
numorder: { type: Number },
|
|
numord_pers: { type: Number },
|
|
userId: { type: Schema.Types.ObjectId, ref: 'User' },
|
|
totalQty: { type: Number, default: 0 },
|
|
totalPrice: { type: Number, default: 0 },
|
|
department: {
|
|
type: String, ref: 'Department'
|
|
},
|
|
items: [
|
|
{
|
|
order:
|
|
{ type: Schema.Types.ObjectId, ref: 'Order' }
|
|
}
|
|
],
|
|
status: {
|
|
type: Number,
|
|
Default: 0,
|
|
},
|
|
evaso: { // e quindi è stato tolto dal magazzino (aggiornando il campo stockQty)
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_evaso: {
|
|
type: Date
|
|
},
|
|
pagato: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_pagato: {
|
|
type: Date
|
|
},
|
|
spedito: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_spedito: {
|
|
type: Date
|
|
},
|
|
completato: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_completato: {
|
|
type: Date
|
|
},
|
|
consegnato: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_consegnato: {
|
|
type: Date
|
|
},
|
|
ricevuto: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
date_ricevuto: {
|
|
type: Date
|
|
},
|
|
note: {
|
|
type: String
|
|
},
|
|
modify_at: {
|
|
type: Date
|
|
},
|
|
created_at: {
|
|
type: Date
|
|
},
|
|
deleted: {
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
});
|
|
|
|
var OrdersCart = module.exports = mongoose.model('OrdersCart', OrdersCartSchema);
|
|
|
|
module.exports.findAllIdApp = async function (idapp, userId) {
|
|
const myfind = { idapp, userId, deleted: false };
|
|
|
|
return await await OrdersCart.find(myfind);
|
|
};
|
|
|
|
module.exports.executeQueryTable = function (idapp, params) {
|
|
params.fieldsearch = this.getFieldsForSearch();
|
|
return tools.executeQueryTable(this, idapp, params);
|
|
};
|
|
|
|
module.exports.getFieldsForSearch = function () {
|
|
return [{ field: 'note', type: tools.FieldType.string }]
|
|
};
|
|
|
|
|
|
module.exports.getLastNumOrder = async function (idapp) {
|
|
let query = { idapp, deleted: false }
|
|
let numorder = 100;
|
|
let numorderrec = await OrdersCart.find(query).sort({ numorder: -1 }).limit(1);
|
|
|
|
if (numorderrec && numorderrec.length > 0)
|
|
numorder = numorderrec[0].numorder;
|
|
else
|
|
numorder = 100;
|
|
|
|
return numorder;
|
|
|
|
};
|
|
|
|
module.exports.getLastNumOrdPers = async function (uid, idapp) {
|
|
let query = { userId: uid, idapp, deleted: false }
|
|
let numorder = 1;
|
|
let numorderrec = await OrdersCart.find(query).sort({ numorder: -1 }).limit(1);
|
|
|
|
if (numorderrec && numorderrec.length > 0)
|
|
numorder = numorderrec[0].numorder;
|
|
else
|
|
numorder = 0;
|
|
|
|
return numorder;
|
|
|
|
};
|
|
|
|
module.exports.getStatusCartByUserId = async function (uid, idapp, numorder) {
|
|
let query = { userId: uid, idapp, status: { $gte: shared_consts.OrderStatus.CHECKOUT_SENT } }
|
|
let myorderscart = null;
|
|
if (numorder > 0) {
|
|
query = { userId: uid, idapp, numorder, status: { $gte: shared_consts.OrderStatus.CHECKOUT_SENT } }
|
|
}
|
|
|
|
myorderscart = await OrdersCart.findOne(query);
|
|
|
|
if (!!myorderscart)
|
|
return myorderscart.status;
|
|
else
|
|
return shared_consts.OrderStatus.NONE
|
|
|
|
}
|
|
|
|
module.exports.getRecCartByUserId = async function (uid, idapp, numorder) {
|
|
let query = { userId: uid, idapp, status: { $lt: shared_consts.OrderStatus.CHECKOUT_SENT } }
|
|
let myorderscart = null;
|
|
if (numorder > 0) {
|
|
query = { userId: uid, idapp, numorder, status: { $lt: shared_consts.OrderStatus.CHECKOUT_SENT } }
|
|
}
|
|
|
|
myorderscart = await OrdersCart.findOne(query).lean();
|
|
|
|
return myorderscart
|
|
}
|
|
|
|
module.exports.getOrdersCartById = async function (id) {
|
|
let query = { _id: id };
|
|
|
|
return await OrdersCart.findOne(query);
|
|
|
|
}
|
|
module.exports.getOrdersCartByUserId = async function (uid, idapp, numorder) {
|
|
|
|
try {
|
|
let query = { idapp, status: { $gte: shared_consts.OrderStatus.CHECKOUT_SENT }, deleted: false }
|
|
let myorderscart = null;
|
|
if (numorder > 0) {
|
|
query.numorder = numorder;
|
|
}
|
|
|
|
if (uid !== 'ALL') {
|
|
query.userId = uid;
|
|
}
|
|
|
|
/*transform: function(doc, populated) {
|
|
// Rinomina 'idProduct' a 'product' nei risultati della popolazione
|
|
populated.product = populated.idProduct;
|
|
delete populated.idProduct;
|
|
return populated;
|
|
},*/
|
|
|
|
myorderscart = await OrdersCart.find(query)
|
|
.populate('items.order')
|
|
.populate({
|
|
path: 'items.order',
|
|
populate: {
|
|
path: 'idProduct',
|
|
model: 'Product'
|
|
},
|
|
})
|
|
.populate({
|
|
path: 'items.order',
|
|
populate: {
|
|
path: 'idProducer',
|
|
model: 'Producer'
|
|
},
|
|
})
|
|
.populate({
|
|
path: 'items.order',
|
|
populate: {
|
|
path: 'idProvider',
|
|
model: 'Provider'
|
|
},
|
|
})
|
|
.populate({
|
|
path: 'items.order',
|
|
populate: {
|
|
path: 'idStorehouse',
|
|
model: 'Storehouse'
|
|
},
|
|
})
|
|
.populate({
|
|
path: 'items.order',
|
|
populate: {
|
|
path: 'idScontisticas',
|
|
model: 'Scontistica'
|
|
},
|
|
})
|
|
.populate({
|
|
path: 'userId',
|
|
model: 'User',
|
|
select: '_id name surname username profile', // Specify the fields you want to retrieve
|
|
})
|
|
.lean();
|
|
|
|
myorderscart = myorderscart.map(order => {
|
|
order.user = order.userId
|
|
order.userId = order.user._id
|
|
order.items = order.items.map(item => {
|
|
if (item.order) {
|
|
try {
|
|
item.order.product = item.order.idProduct;
|
|
item.order.idProduct = item.order.product ? item.order.product._id : '';
|
|
item.order.producer = item.order.idProducer;
|
|
item.order.idProducer = item.order.producer ? item.order.producer._id : '';
|
|
item.order.storehouse = item.order.idStorehouse;
|
|
item.order.idStorehouse = item.order.storehouse ? item.order.storehouse._id : '';
|
|
item.order.provider = item.order.idProvider;
|
|
item.order.idProvider = item.order.provider ? item.order.provider._id : '';
|
|
item.order.scontisticas = item.order.scontisticas;
|
|
item.order.idScontisticas = item.order.idScontisticas ? item.order.idScontisticas._id : '';
|
|
} catch (e) {
|
|
console.error('Err: ', e);
|
|
}
|
|
}
|
|
return item;
|
|
});
|
|
return order;
|
|
});
|
|
|
|
console.log('*** Num myorderscart ', myorderscart.length);
|
|
return myorderscart
|
|
} catch (e) {
|
|
console.error('Err:', e);
|
|
}
|
|
// return null;
|
|
}
|
|
|
|
|
|
module.exports.updateOrdersCartById = function (id, newOrdersCart, callback) {
|
|
let query = {
|
|
id,
|
|
deleted: false,
|
|
}
|
|
OrdersCart.find(query, function (err, c) {
|
|
if (err) throw err
|
|
|
|
//exist cart in databse
|
|
if (c.length > 0) {
|
|
return OrdersCart.findOneAndUpdate(
|
|
{ _id: id },
|
|
{
|
|
$set: {
|
|
items: newOrdersCart.items,
|
|
totalQty: newOrdersCart.totalQty,
|
|
totalPrice: newOrdersCart.totalPrice,
|
|
userId: userId,
|
|
status: newOrdersCart.status,
|
|
numorder: newOrdersCart.numorder,
|
|
numord_pers: newOrdersCart.numord_pers,
|
|
note: newOrdersCart.note,
|
|
modify_at: new Date(),
|
|
}
|
|
},
|
|
{ new: true },
|
|
callback
|
|
)
|
|
} else {
|
|
//no cart in database
|
|
return newOrdersCart.save(callback)
|
|
}
|
|
})
|
|
}
|
|
|
|
module.exports.setFieldInOrdersById = async function (objtoset, myOrderCart) {
|
|
|
|
try {
|
|
let ris2 = null;
|
|
// Imposta su tutti i singoli prodotti ordinati (Order)
|
|
for (const recitem of myOrderCart.items) {
|
|
ris2 = await Order.findOneAndUpdate(
|
|
{ _id: recitem.order._id },
|
|
{
|
|
$set: objtoset
|
|
},
|
|
{ new: false }
|
|
)
|
|
// console.log('ris', ris2);
|
|
}
|
|
|
|
const ris = await OrdersCart.findOneAndUpdate(
|
|
{ _id: myOrderCart._id },
|
|
{
|
|
$set: objtoset
|
|
},
|
|
{ new: false }
|
|
)
|
|
|
|
} catch (e) {
|
|
console.log('Err', e);
|
|
}
|
|
|
|
}
|
|
|
|
module.exports.setConsegnatoById = async function (value, myOrderCart) {
|
|
|
|
let objtoset = {
|
|
consegnato: value,
|
|
date_consegnato: new Date(),
|
|
};
|
|
|
|
return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);
|
|
|
|
}
|
|
|
|
module.exports.setSpeditoById = async function (value, myOrderCart) {
|
|
|
|
let objtoset = {
|
|
spedito: value,
|
|
date_spedito: new Date(),
|
|
};
|
|
|
|
return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);
|
|
|
|
}
|
|
|
|
module.exports.setPagatoById = async function (value, myOrderCart) {
|
|
|
|
let objtoset = {
|
|
pagato: value,
|
|
date_pagato: new Date(),
|
|
};
|
|
|
|
if (!value) {
|
|
objtoset.date_pagato = null;
|
|
}
|
|
|
|
return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);
|
|
|
|
}
|
|
|
|
module.exports.setCompletatoById = async function (value, myOrderCart) {
|
|
|
|
let objtoset = {
|
|
completato: value,
|
|
date_completato: new Date(),
|
|
};
|
|
|
|
return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);
|
|
|
|
}
|
|
|
|
module.exports.setEvasoById = async function (value, myOrderCart) {
|
|
|
|
let objtoset = {
|
|
evaso: value,
|
|
date_evaso: new Date(),
|
|
};
|
|
|
|
return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);
|
|
|
|
}
|
|
|
|
module.exports.setRicevutoById = async function (value, myOrderCart) {
|
|
|
|
let objtoset = {
|
|
ricevuto: value,
|
|
date_ricevuto: new Date(),
|
|
};
|
|
|
|
return await OrdersCart.setFieldInOrdersById(objtoset, myOrderCart);
|
|
}
|
|
|
|
module.exports.createOrdersCart = async function (newOrdersCart) {
|
|
return await newOrdersCart.save()
|
|
}
|
|
module.exports.updateStockQtaDalMagazzino = async function (idorderscart) {
|
|
|
|
try {
|
|
|
|
const myorderscart = await OrdersCart.findOne({ _id: idorderscart }).populate('items.order').lean();
|
|
|
|
if (myorderscart) {
|
|
for (const idkey in myorderscart.items) {
|
|
let order = myorderscart.items[idkey].order;
|
|
|
|
if (!order.evaso) {
|
|
const update = {
|
|
$inc: {
|
|
stockQty: -order.quantity
|
|
}
|
|
};
|
|
await Product.findOneAndUpdate({ _id: order.idProduct }, update, { new: false });
|
|
}
|
|
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.error('Err', e);
|
|
}
|
|
|
|
}
|
|
|
|
module.exports.updateCmd = async function (ordersCart, status, value) {
|
|
|
|
|
|
let myOrderCart = await OrdersCart.findOne({ _id: ordersCart._id }).populate('items.order').lean();
|
|
|
|
try {
|
|
if (!!myOrderCart) {
|
|
|
|
const id = myOrderCart._id;
|
|
if (status === shared_consts.OrderStatus.ORDER_CONFIRMED) {
|
|
|
|
// Aggiorna anche il Magazzino, togliendo le quantità in Stock
|
|
if (value) {
|
|
OrdersCart.updateStockQtaDalMagazzino(id);
|
|
}
|
|
ris = await OrdersCart.setEvasoById(value, myOrderCart);
|
|
|
|
} else if (status === shared_consts.OrderStatus.DELIVERED) {
|
|
ris = await OrdersCart.setConsegnatoById(value, myOrderCart);
|
|
} else if (status === shared_consts.OrderStatus.SHIPPED) {
|
|
ris = await OrdersCart.setSpeditoById(value, myOrderCart);
|
|
} else if (status === shared_consts.OrderStatus.PAYED) {
|
|
ris = await OrdersCart.setPagatoById(value, myOrderCart);
|
|
} else if (status === shared_consts.OrderStatus.COMPLETED) {
|
|
ris = await OrdersCart.setCompletatoById(value, myOrderCart);
|
|
} else if (status === shared_consts.OrderStatus.RECEIVED) {
|
|
ris = await OrdersCart.setRicevutoById(value, myOrderCart);
|
|
}
|
|
|
|
await OrdersCart.setFieldInOrdersById({ status }, myOrderCart);
|
|
|
|
myOrderCart = await OrdersCart.findOne({ _id: ordersCart._id }).populate('items.order').lean();
|
|
// myOrderCart = await OrdersCart.findOne({ _id: idorderscart });
|
|
|
|
return myOrderCart;
|
|
}
|
|
} catch (e) {
|
|
console.error('Err:', e)
|
|
}
|
|
|
|
}
|
|
|
|
OrdersCartSchema.pre('save', async function (next) {
|
|
|
|
try {
|
|
if (this.isNew) {
|
|
try {
|
|
const myrec = await User.findOne({ idapp: this.idapp }).limit(1).sort({ neworder: -1 });
|
|
|
|
if (!!myrec) {
|
|
this.neworder = myrec._doc.neworder + 1;
|
|
} else {
|
|
this.neworder = 1;
|
|
}
|
|
} catch (e) {
|
|
this.neworder = 2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
if (user.isModified('password')) {
|
|
bcrypt.genSalt(10, (err, salt) => {
|
|
bcrypt.hash(user.password, salt, (err, hash) => {
|
|
user.password = hash;
|
|
next();
|
|
});
|
|
});
|
|
} else {
|
|
next();
|
|
}
|
|
*/
|
|
|
|
next();
|
|
} catch (e) {
|
|
console.error(e.message);
|
|
}
|
|
});
|
|
|
|
module.exports.createIndexes((err) => {
|
|
if (err) throw err;
|
|
});
|