1043 lines
24 KiB
JavaScript
Executable File
1043 lines
24 KiB
JavaScript
Executable File
mongoose = require('mongoose').set('debug', false)
|
|
const Schema = mongoose.Schema;
|
|
|
|
const tools = require('../tools/general');
|
|
|
|
const Producer = require('../models/producer');
|
|
const Storehouse = require('../models/storehouse');
|
|
const Provider = require('../models/provider');
|
|
const CatProd = require('../models/catprod');
|
|
const SubCatProd = require('../models/subcatprod');
|
|
const Gasordine = require('../models/gasordine');
|
|
const Scontistica = require('../models/scontistica');
|
|
|
|
const shared_consts = require('../tools/shared_nodejs');
|
|
|
|
const { ObjectId } = require('mongodb');
|
|
|
|
mongoose.Promise = global.Promise;
|
|
mongoose.level = "F";
|
|
|
|
// A1P
|
|
|
|
// Resolving error Unknown modifier: $pushAll
|
|
mongoose.plugin(schema => {
|
|
schema.options.usePushEach = true
|
|
});
|
|
|
|
const productSchema = new Schema({
|
|
idapp: {
|
|
type: String,
|
|
},
|
|
active: {
|
|
type: Boolean,
|
|
default: true,
|
|
},
|
|
isbn: {
|
|
type: String,
|
|
},
|
|
idProductInfo: { type: Schema.Types.ObjectId, ref: 'ProductInfo' },
|
|
idProducer: { type: Schema.Types.ObjectId, ref: 'Producer' },
|
|
idStorehouses: [
|
|
{ type: Schema.Types.ObjectId, ref: 'Storehouse' }
|
|
],
|
|
idGasordine: { type: Schema.Types.ObjectId, ref: 'Gasordine' },
|
|
idScontisticas: [
|
|
{ type: Schema.Types.ObjectId, ref: 'Scontistica' }
|
|
],
|
|
idProvider: { type: Schema.Types.ObjectId, ref: 'Provider' },
|
|
prezzo_ivato: { // Con IVA
|
|
type: Number
|
|
},
|
|
perc_iva: { // 4, 10, 22 &
|
|
type: Number
|
|
},
|
|
price: {
|
|
type: Number,
|
|
required: true,
|
|
},
|
|
arrvariazioni: [
|
|
{
|
|
active: {
|
|
type: Boolean,
|
|
},
|
|
versione: {
|
|
type: Number,
|
|
},
|
|
status: { //publish
|
|
type: String,
|
|
},
|
|
price: {
|
|
type: Number,
|
|
},
|
|
sale_price: {
|
|
type: Number,
|
|
},
|
|
quantita: { // in magazzino
|
|
type: Number,
|
|
},
|
|
pagine: {
|
|
type: Number,
|
|
},
|
|
misure: {
|
|
type: String,
|
|
},
|
|
formato: {
|
|
type: String,
|
|
},
|
|
tipologia: {
|
|
type: String,
|
|
},
|
|
edizione: {
|
|
type: String,
|
|
},
|
|
preOrderDate: {
|
|
type: Date
|
|
},
|
|
addtocart_link: {
|
|
type: String
|
|
},
|
|
eta: {
|
|
type: String
|
|
},
|
|
}
|
|
],
|
|
price_acquistato: {
|
|
type: Number,
|
|
required: true,
|
|
},
|
|
after_price: {
|
|
type: String
|
|
},
|
|
minBuyQty: { // quantità minima acquistabile
|
|
type: Number,
|
|
default: 1,
|
|
required: true,
|
|
},
|
|
minStepQty: { // step quantità acquistabile
|
|
type: Number,
|
|
default: 1,
|
|
required: true,
|
|
},
|
|
maxBookableSinglePersQty: { // quantità massima Pre-ordinabile (singolarmente)
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
stockQty: { // in magazzino
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
stockBloccatiQty: { // Prenotati Bloccati
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
bookedQtyOrdered: { // Quantità Prenotate ordinate (in Lavorazione)
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
bookedQtyConfirmed: { // Quantità Prenotate Confermate Totali
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
|
|
// GAS:
|
|
qtyToReachForGas: { // Quantità minima da raggiungere per fare l'ordine GAS
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
maxbookableGASQty: { // Quantità massima (ancora disponibile) Ordine GAS prenotabile (Complessivamente tra tutti gli ordini)
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
bookedGASQtyOrdered: { // Quantità Ordine GAS Prenotate Totali
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
bookedGASQtyConfirmed: { // Quantità Ordine GAS Confermate Totali
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
bookableGASBloccatiQty: { // Quantità Prenotate Bloccate GAS
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
|
|
quantityLow: { //Soglia disponibilità bassa
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
visibilityProductOutOfStock: { // Visibilità prodotto "esaurito"
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
canBeShipped: { // è spedibile
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
canBeBuyOnline: { // è acquistabile online
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
stars: {
|
|
type: Number,
|
|
default: 0,
|
|
},
|
|
dateAvailableFrom: {
|
|
type: Date
|
|
},
|
|
note: {
|
|
type: String,
|
|
},
|
|
producer_name: {
|
|
type: String,
|
|
},
|
|
provider_name: {
|
|
type: String,
|
|
},
|
|
magazzino_name: {
|
|
type: String,
|
|
},
|
|
cat_name: {
|
|
type: String,
|
|
},
|
|
subcat_name: {
|
|
type: String,
|
|
},
|
|
sconto1: {
|
|
type: String,
|
|
},
|
|
sconto2: {
|
|
type: String,
|
|
},
|
|
gas_name: {
|
|
type: String,
|
|
},
|
|
|
|
date_created: {
|
|
type: Date,
|
|
default: Date.now
|
|
},
|
|
date_updated: {
|
|
type: Date,
|
|
},
|
|
|
|
});
|
|
|
|
var Product = module.exports = mongoose.model('Product', productSchema);
|
|
|
|
productSchema.index({ idapp: 1 });
|
|
|
|
module.exports.getFieldsForSearch = function () {
|
|
return [
|
|
{ field: 'name', type: tools.FieldType.string },
|
|
{ field: 'description', type: tools.FieldType.string },
|
|
]
|
|
};
|
|
|
|
module.exports.executeQueryTable = function (idapp, params) {
|
|
params.fieldsearch = this.getFieldsForSearch();
|
|
return tools.executeQueryTable(this, idapp, params);
|
|
};
|
|
|
|
module.exports.executeQueryPickup = async function (idapp, params) {
|
|
|
|
let strfind = params.search;
|
|
|
|
strfind = strfind.replace(/[-@]/g, '');
|
|
|
|
if (strfind === '' && !params.filter) {
|
|
return [];
|
|
}
|
|
|
|
let filterfindexact = {};
|
|
if (strfind) {
|
|
filterfindexact = { comune: strfind };
|
|
}
|
|
|
|
let limit = 10;
|
|
let risexact = [];
|
|
|
|
let filterfind = {
|
|
idapp,
|
|
'productInfo.name': {
|
|
$regex: `\\b${strfind}`, // Usa \\b per trovare solo le parole che iniziano con strfind
|
|
$options: 'i' // Rendi la ricerca case-insensitive
|
|
}
|
|
};
|
|
|
|
/*
|
|
let aggr1 = [
|
|
{
|
|
$lookup: {
|
|
from: 'productinfos',
|
|
localField: 'idProductInfo',
|
|
foreignField: '_id',
|
|
as: 'productInfo'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'authors',
|
|
localField: 'idAuthors',
|
|
foreignField: '_id',
|
|
as: 'authors'
|
|
}
|
|
},
|
|
{
|
|
$match: { 'productInfo.name': strfind },
|
|
},
|
|
{ $limit: 1 },
|
|
{
|
|
$project: {
|
|
name: { $concat: ["$productInfo.name", " (", "$authors", ")"] },
|
|
},
|
|
},
|
|
];
|
|
|
|
|
|
if (params.filter) {
|
|
filterfind = { ...params.filter, ...filterfind };
|
|
limit = 200;
|
|
} else {
|
|
// risexact = await City.find(filterfindexact, {comune: 1, prov: 1, reg: 1}).lean();
|
|
risexact = await City.aggregate(aggr1);
|
|
}
|
|
*/
|
|
|
|
if (params.filter) {
|
|
filterfind = { ...params.filter, ...filterfind };
|
|
limit = 200;
|
|
}
|
|
|
|
let aggr2 = [
|
|
{
|
|
$lookup: {
|
|
from: 'productinfos',
|
|
localField: 'idProductInfo',
|
|
foreignField: '_id',
|
|
as: 'productInfo'
|
|
}
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: '$productInfo',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'authors',
|
|
localField: 'idAuthors',
|
|
foreignField: '_id',
|
|
as: 'authors'
|
|
}
|
|
},
|
|
{
|
|
$match: filterfind,
|
|
},
|
|
{ $limit: limit },
|
|
{
|
|
$project: {
|
|
name: '$productInfo.name',
|
|
},
|
|
},
|
|
];
|
|
|
|
|
|
// let ris = await City.find(filterfind, {comune: 1, prov: 1, reg: 1}).lean().limit(limit);
|
|
let ris = await this.aggregate(aggr2).limit(limit);
|
|
|
|
return [...risexact, ...ris];
|
|
|
|
};
|
|
|
|
|
|
module.exports.getProductByCode = function (idapp, code) {
|
|
return Product.findAllIdApp(idapp, code);
|
|
}
|
|
|
|
module.exports.getProductById = async function (id) {
|
|
const arrris = await Product.findAllIdApp('', '', id);
|
|
return arrris && arrris.length > 0 ? arrris[0] : null
|
|
}
|
|
|
|
module.exports.getInStockById = async function (id) {
|
|
const myprod = await Product.findOne({ _id: id });
|
|
if (myprod) {
|
|
let instock = 0;
|
|
if (myprod.idGasordine) {
|
|
instock = myprod.maxbookableGASQty;
|
|
} else {
|
|
instock = myprod.stockQty;
|
|
}
|
|
return instock
|
|
}
|
|
return null;
|
|
}
|
|
|
|
module.exports.isLowQuantityInStockById = async function (id) {
|
|
const instock = await Product.getInStockById(id);
|
|
const myprod = await Product.findOne({ _id: id });
|
|
if (instock) {
|
|
return (instock <= (myprod.quantityLow + 1));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
module.exports.findAllIdApp = async function (idapp, code, id, all) {
|
|
let myfind = {};
|
|
let myqueryadd = {};
|
|
let query = [];
|
|
|
|
try {
|
|
|
|
if (idapp) {
|
|
myfind = { idapp };
|
|
}
|
|
|
|
if (!all) {
|
|
myfind = { ...myfind, active: true }
|
|
}
|
|
|
|
if (code) {
|
|
myfind = { ...myfind, code }
|
|
}
|
|
if (id) {
|
|
myqueryadd = {
|
|
$addFields: {
|
|
myId1: {
|
|
$toObjectId: id,
|
|
},
|
|
},
|
|
}
|
|
myfind = {
|
|
$expr: {
|
|
$eq: ["$_id", "$myId1"],
|
|
},
|
|
}
|
|
|
|
query.push(myqueryadd);
|
|
}
|
|
|
|
// DA TOGLIEREE
|
|
// myfind = { ...myfind, code: '4012824406094' };
|
|
|
|
// return await Product.find(myfind);
|
|
|
|
query.push(
|
|
{ $match: myfind },
|
|
{
|
|
$lookup: {
|
|
from: 'producers',
|
|
localField: 'idProducer',
|
|
foreignField: '_id',
|
|
as: 'producer'
|
|
}
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: '$producer',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'productinfos',
|
|
localField: 'idProductInfo',
|
|
foreignField: '_id',
|
|
as: 'productInfo'
|
|
}
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: '$productInfo',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'gasordines',
|
|
localField: 'idGasordine',
|
|
foreignField: '_id',
|
|
as: 'gasordine'
|
|
}
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: '$gasordine',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$match: {
|
|
$or: [
|
|
{ 'gasordine.active': true }, // Include documents where gasordines.active is true
|
|
{ 'gasordine': { $exists: false } } // Include documents where gasordines array doesn't exist
|
|
]
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: '$_id',
|
|
gasordine: { $first: '$gasordine' },
|
|
originalFields: { $first: '$$ROOT' } // Preserve all existing fields
|
|
}
|
|
},
|
|
{
|
|
$replaceRoot: {
|
|
newRoot: {
|
|
$mergeObjects: ['$originalFields', { gasordine: '$gasordine' }]
|
|
}
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'providers',
|
|
localField: 'idProvider',
|
|
foreignField: '_id',
|
|
as: 'provider'
|
|
}
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: '$provider',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'authors',
|
|
localField: 'productInfo.idAuthors',
|
|
foreignField: '_id',
|
|
as: 'productInfo.authors'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'publishers',
|
|
localField: 'productInfo.idPublisher',
|
|
foreignField: '_id',
|
|
as: 'productInfo.publisher'
|
|
}
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: '$productInfo.publisher',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'collanas',
|
|
localField: 'productInfo.idCollana',
|
|
foreignField: '_id',
|
|
as: 'productInfo.collana'
|
|
}
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: '$productInfo.collana',
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'catprods',
|
|
localField: 'productInfo.idCatProds',
|
|
foreignField: '_id',
|
|
as: 'productInfo.catprods'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'subcatprods',
|
|
localField: 'productInfo.idSubCatProds',
|
|
foreignField: '_id',
|
|
as: 'productInfo.subcatprods'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'scontisticas',
|
|
localField: 'idScontisticas',
|
|
foreignField: '_id',
|
|
as: 'scontisticas'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'storehouses',
|
|
localField: 'idStorehouses',
|
|
foreignField: '_id',
|
|
as: 'storehouses'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'orders',
|
|
let: { productId: '$_id' },
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{ $eq: ['$idProduct', '$$productId'] },
|
|
{
|
|
$or: [
|
|
{
|
|
$eq: ['$status', shared_consts.OrderStatus.CHECKOUT_SENT]
|
|
},
|
|
{
|
|
$and: [{ $lt: ['$status', shared_consts.OrderStatus.CHECKOUT_SENT] },
|
|
{
|
|
$gt: [
|
|
'$modify_at',
|
|
{ $subtract: [new Date(), 60 * 60 * 1000] } // 1 hour in milliseconds 60 * 60
|
|
]
|
|
}]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
totalQty: { $sum: '$quantity' },
|
|
}
|
|
}
|
|
],
|
|
as: 'productOrders'
|
|
}
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: 'orders',
|
|
let: { productId: '$_id' },
|
|
pipeline: [
|
|
{
|
|
$match: {
|
|
$expr: {
|
|
$and: [
|
|
{ $eq: ['$idProduct', '$$productId'] },
|
|
{
|
|
$or: [
|
|
{
|
|
$eq: ['$status', shared_consts.OrderStatus.CHECKOUT_SENT]
|
|
},
|
|
{
|
|
$and: [{ $lt: ['$status', shared_consts.OrderStatus.CHECKOUT_SENT] },
|
|
{
|
|
$gt: [
|
|
'$modify_at',
|
|
{ $subtract: [new Date(), 60 * 60 * 1000] } // 1 hour in milliseconds 60 * 60
|
|
]
|
|
}]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
totalQtyPreordered: { $sum: '$quantitypreordered' }
|
|
}
|
|
}
|
|
],
|
|
as: 'productPreOrders'
|
|
}
|
|
},
|
|
{
|
|
$addFields: {
|
|
QuantitaOrdinateInAttesa: {
|
|
$ifNull: [
|
|
{
|
|
$cond: {
|
|
if: { $isArray: '$productOrders' },
|
|
then: { $arrayElemAt: ['$productOrders.totalQty', 0] },
|
|
else: 0
|
|
}
|
|
},
|
|
0
|
|
]
|
|
},
|
|
QuantitaPrenotateInAttesa: {
|
|
$ifNull: [
|
|
{
|
|
$cond: {
|
|
if: { $isArray: '$productPreOrders' },
|
|
then: { $arrayElemAt: ['$productPreOrders.totalQtyPreordered', 0] },
|
|
else: 0
|
|
}
|
|
},
|
|
0
|
|
]
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
quantityAvailable: {
|
|
$subtract: ["$stockQty", "$QuantitaOrdinateInAttesa"],
|
|
},
|
|
bookableAvailableQty: {
|
|
$subtract: ["$maxbookableGASQty", "$QuantitaPrenotateInAttesa"],
|
|
}
|
|
}
|
|
},
|
|
{
|
|
$unset: 'productOrders'
|
|
},
|
|
{
|
|
$unset: 'productPreOrders'
|
|
},
|
|
{
|
|
$sort: {
|
|
'productInfo.name': 1 // 1 for ascending order, -1 for descending order
|
|
}
|
|
},
|
|
);
|
|
|
|
// console.log('query=', query);
|
|
|
|
let ris = await Product.aggregate(query)
|
|
|
|
// console.table('ris', ris);
|
|
|
|
return ris;
|
|
|
|
} catch (e) {
|
|
console.error('E', e);
|
|
}
|
|
|
|
|
|
};
|
|
|
|
module.exports.getAllProducts = function (query, sort, callback) {
|
|
Product.find(query, null, sort, callback)
|
|
}
|
|
|
|
module.exports.getProductByDepartment = function (query, sort, callback) {
|
|
Product.find(query, null, sort, callback)
|
|
}
|
|
|
|
module.exports.getProductByCatProd = function (query, sort, callback) {
|
|
Product.find(query, null, sort, callback)
|
|
}
|
|
|
|
module.exports.getProductByTitle = function (query, sort, callback) {
|
|
Product.find(query, null, sort, callback)
|
|
}
|
|
|
|
module.exports.filterProductByDepartment = function (department, callback) {
|
|
let regexp = new RegExp(`^${department}$`, 'i')
|
|
var query = { department: { $regex: regexp } };
|
|
Product.find(query, callback)
|
|
}
|
|
|
|
module.exports.filterProductByCatProd = function (catprod, callback) {
|
|
let regexp = new RegExp(`^${catprod}$`, 'i')
|
|
var query = { catprod: { $regex: regexp } };
|
|
Product.find(query, callback);
|
|
}
|
|
|
|
module.exports.filterProductByTitle = function (title, callback) {
|
|
let regexp = new RegExp(`^${title}$`, 'i')
|
|
var query = { title: { $regex: regexp } };
|
|
Product.find(query, callback);
|
|
}
|
|
|
|
module.exports.getProductByID = function (id, callback) {
|
|
Product.findById(id, callback);
|
|
}
|
|
|
|
module.exports.updateProductInOrder = async function (order) {
|
|
|
|
if (order.product)
|
|
order.product = await Product.getProductById(order.product._id);
|
|
|
|
return order;
|
|
}
|
|
|
|
module.exports.createIndexes()
|
|
.then(() => { })
|
|
.catch((err) => { throw err; });
|
|
|
|
|
|
module.exports.convertAfterImportALLPROD = async function (idapp, dataObjects) {
|
|
|
|
const arrprod = await Product.find({ idapp }).lean();
|
|
for (const prod of arrprod) {
|
|
await this.singlerecconvert_AfterImport_AndSave(prod);
|
|
}
|
|
|
|
};
|
|
|
|
module.exports.getArrCatProds = async function (idapp, cosa) {
|
|
|
|
try {
|
|
let addquery = [];
|
|
let arr = [];
|
|
if (cosa === shared_consts.PROD.GAS) {
|
|
addquery = [
|
|
{ $match: { idapp, idGasordine: { $exists: true, $ne: null, $type: 'objectId' } } }
|
|
];
|
|
|
|
addquery.push(
|
|
{
|
|
$lookup: {
|
|
from: 'gasordines',
|
|
localField: 'idGasordine',
|
|
foreignField: '_id',
|
|
as: 'gasordine'
|
|
}
|
|
}
|
|
);
|
|
|
|
addquery.push(
|
|
{
|
|
$match: {
|
|
"gasordine.active": true
|
|
}
|
|
}
|
|
);
|
|
|
|
} else if (cosa === shared_consts.PROD.BOTTEGA) {
|
|
addquery = [{
|
|
$match: {
|
|
idapp, $or: [
|
|
{ idGasordine: { $exists: false } },
|
|
{ idGasordine: { $exists: true, $eq: null } }
|
|
]
|
|
}
|
|
}]
|
|
} else {
|
|
addquery = [{ $match: { idapp } }];
|
|
}
|
|
|
|
let myquery = [...addquery,
|
|
{
|
|
$lookup: {
|
|
from: "productinfos",
|
|
localField: "idProductInfo",
|
|
foreignField: "_id",
|
|
as: "productInfo",
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "catprods",
|
|
localField: "productInfo.idCatProds",
|
|
foreignField: "_id",
|
|
as: "category"
|
|
}
|
|
},
|
|
{ $unwind: "$category" },
|
|
{ $group: { _id: "$category._id", name: { $first: "$category.name" } } },
|
|
{ $sort: { name: 1 } }
|
|
];
|
|
|
|
try {
|
|
let arr = [];
|
|
arr = await Product.aggregate(myquery);
|
|
|
|
// arr = result.map(category => category.name);
|
|
return arr;
|
|
} catch (e) {
|
|
console.error('err', e);
|
|
}
|
|
// Ora uniqueCategories contiene l'array delle categorie univoche utilizzate in tutti i prodotti con active = true
|
|
return arr;
|
|
} catch (e) {
|
|
console.error('err', e);
|
|
return [];
|
|
}
|
|
|
|
|
|
}
|
|
|
|
module.exports.singlerecconvert_AfterImport_AndSave = async function (idapp, prod, isnuovo) {
|
|
|
|
let setta = false;
|
|
|
|
try {
|
|
let objtoset = {}
|
|
let rec = null
|
|
|
|
// Impostazioni Base:
|
|
if (isnuovo) {
|
|
objtoset = {
|
|
idapp,
|
|
// minBuyQty: 1,
|
|
// minStepQty: 1,
|
|
maxBookableSinglePersQty: 0,
|
|
bookedGASQtyOrdered: 0,
|
|
bookableGASBloccatiQty: 0,
|
|
bookedGASQtyConfirmed: 0,
|
|
// qtyToReachForGas: 0,
|
|
// maxbookableGASQty: 0,
|
|
}
|
|
}
|
|
|
|
if (prod.producer_name) {
|
|
// Cerca il produttore
|
|
let recproducer = await Producer.findOne({ idapp, name: prod.producer_name }).lean();
|
|
if (!recproducer) {
|
|
// Non esiste questo produttore, quindi lo creo !
|
|
recproducer = new Producer({ idapp, name: prod.producer_name });
|
|
ris = await recproducer.save();
|
|
recproducer = await Producer.findOne({ idapp, name: prod.producer_name }).lean();
|
|
}
|
|
|
|
if (recproducer) {
|
|
objtoset = {
|
|
...objtoset,
|
|
idProducer: recproducer._id,
|
|
}
|
|
setta = true;
|
|
}
|
|
}
|
|
|
|
if (prod.magazzino_name) {
|
|
// Cerca il produttore
|
|
let recstorehouse = await Storehouse.findOne({ idapp, name: prod.magazzino_name }).lean();
|
|
if (!recstorehouse) {
|
|
// Non esiste questo produttore, quindi lo creo !
|
|
recstorehouse = new Storehouse({ idapp, name: prod.magazzino_name });
|
|
ris = await recstorehouse.save();
|
|
recstorehouse = await Storehouse.findOne({ idapp, name: prod.magazzino_name }).lean();
|
|
}
|
|
|
|
if (recstorehouse) {
|
|
objtoset = {
|
|
...objtoset,
|
|
idStorehouses: [recstorehouse._id],
|
|
}
|
|
setta = true;
|
|
}
|
|
}
|
|
|
|
|
|
if (prod.provider_name) {
|
|
// Cerca il produttore
|
|
let recprovider = await Provider.findOne({ idapp, name: prod.provider_name }).lean();
|
|
if (!recprovider) {
|
|
recprovider = new Provider({ idapp, name: prod.provider_name });
|
|
// Non esiste questo produttore, quindi lo creo !
|
|
ris = await recprovider.save();
|
|
recprovider = await Provider.findOne({ idapp, name: prod.provider_name }).lean();
|
|
}
|
|
|
|
if (recprovider) {
|
|
objtoset = {
|
|
...objtoset,
|
|
idProvider: recprovider._id,
|
|
}
|
|
setta = true;
|
|
}
|
|
}
|
|
if (prod.gas_name) {
|
|
// Cerca il GAS
|
|
rec = await Gasordine.findOne({ idapp, name: prod.gas_name }).lean();
|
|
if (!rec) {
|
|
rec = new Gasordine({ idapp, name: prod.gas_name, active: true });
|
|
// Non esiste questo GAS, quindi lo creo !
|
|
ris = await rec.save();
|
|
rec = await Gasordine.findOne({ idapp, name: prod.gas_name }).lean();
|
|
}
|
|
|
|
if (rec) {
|
|
objtoset = {
|
|
...objtoset,
|
|
idGasordine: rec._id,
|
|
}
|
|
setta = true;
|
|
}
|
|
}
|
|
|
|
let arrsconti = []
|
|
|
|
if (prod.sconto1) {
|
|
// Cerca la scontistica
|
|
let recscontistica = await Scontistica.findOne({ idapp, code: prod.sconto1 }).lean();
|
|
if (!recscontistica) {
|
|
recscontistica = new Scontistica({ idapp, code: prod.sconto1 });
|
|
// Non esiste questa scontistica, quindi lo creo !
|
|
ris = await recscontistica.save();
|
|
recscontistica = await Scontistica.findOne({ idapp, code: prod.sconto1 }).lean();
|
|
}
|
|
|
|
if (recscontistica) {
|
|
arrsconti.push(recscontistica);
|
|
}
|
|
}
|
|
|
|
if (prod.sconto2) {
|
|
// Cerca la scontistica
|
|
let recscontistica = await Scontistica.findOne({ idapp, code: prod.sconto2 }).lean();
|
|
if (!recscontistica) {
|
|
recscontistica = new Scontistica({ idapp, code: prod.sconto2 });
|
|
// Non esiste questa scontistica, quindi lo creo !
|
|
ris = await recscontistica.save();
|
|
recscontistica = await Scontistica.findOne({ idapp, code: prod.sconto2 }).lean();
|
|
}
|
|
|
|
if (recscontistica) {
|
|
arrsconti.push(recscontistica);
|
|
}
|
|
}
|
|
|
|
if (arrsconti.length > 0) {
|
|
objtoset = {
|
|
...objtoset,
|
|
idScontisticas: arrsconti,
|
|
}
|
|
setta = true;
|
|
}
|
|
|
|
// Aggiorna il prezzo ?
|
|
const aggiornaprezzo = false;
|
|
if (aggiornaprezzo) {
|
|
// cerca il prodotto
|
|
const myprodinput = dataObjects.find((rec) => rec._id === prod._id)
|
|
if (myprodinput) {
|
|
objtoset = {
|
|
...objtoset,
|
|
price: myprodinput.price,
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!tools.isObjectEmpty(objtoset)) {
|
|
ris = await Product.findOneAndUpdate({ _id: new ObjectId(prod._id) }, { $set: objtoset })
|
|
|
|
const objDelete = {
|
|
cat_name: 1,
|
|
subcat_name: 1,
|
|
producer_name: 1,
|
|
provider_name: 1,
|
|
magazzino_name: 1,
|
|
sconto1: 1,
|
|
sconto2: 1,
|
|
gas_name: 1,
|
|
};
|
|
|
|
ris = await Product.updateOne({ _id: new ObjectId(prod._id) }, { $unset: objDelete })
|
|
|
|
if (ris && ris.nModified > 0) {
|
|
console.log('Modificato: ', objtoset.name);
|
|
}
|
|
|
|
// const campodarimuovere = 'producer_name';
|
|
// await Product.findOneAndUpdate({ _id: prod._id }, { $unset: { [campodarimuovere]: 1 } })
|
|
}
|
|
} catch (e) {
|
|
console.error('Err', e);
|
|
}
|
|
|
|
} |