freeplanet_serverside/src/server/models/orderscart.js

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 },
  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 (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: { $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).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) {

  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;
  }

  myorderscart = await OrdersCart.find(query).populate('items.order')
    .populate({
      path: 'items.order',
      populate: {
        path: 'idProduct',
        model: 'Product'
      },
      /*transform: function(doc, populated) {
        // Rinomina 'idProduct' a 'product' nei risultati della popolazione
        populated.product = populated.idProduct;
        delete populated.idProduct;
        return populated;
      },*/
    })
    .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'
      },
      /*transform: function(doc, populated) {
        // Rinomina 'idProduct' a 'product' nei risultati della popolazione
        populated.storehouse = populated.idStorehouse;
        delete populated.idStorehouse;
        return populated;
      },*/
    })
    .populate('userId').lean();

    myorderscart = myorderscart.map(order => {
      order.items = order.items.map(item => {
        item.order.product = item.order.idProduct;
        delete item.order.idProduct;
        item.order.producer = item.order.idProducer;
        delete item.order.idProducer;
        item.order.storehouse = item.order.idStorehouse;
        delete item.order.idStorehouse;
        item.order.provider = item.order.idProvider;
        delete item.order.idProvider;
        return item;
      });
      return order;
    });

  /*for (let ind = 0; ind < myorderscart.length; ind++) {
    for (const idkey in myorderscart[ind].items) {
      try {
        let idorder = myorderscart[ind].items[idkey]._id.toString();
        const myorder = myorderscart[ind].items[idkey].order;
        if (!!myorder) {
          idorder = myorderscart[ind].items[idkey].order._id.toString();
        }
        // myorderscart[ind].nameSurname = await User.getNameSurnameById(idapp, myorderscart[ind].userId);
        // const myord = await Order.getTotalOrderById(idorder);
        // if (myord.length > 0) {
        //   myorderscart[ind].items[idkey].order = myord[0];
        // }
      } catch (e) {
        console.log('err', e);
      }
    }
  }*/

  /*  if (!!mycart) {
      for (const idkey in mycart.items) {
        try {
          idorder = mycart.items[idkey]._id.toString();
          const myorder = mycart.items[idkey].order;
          if (!!myorder) {
            idorder = mycart.items[idkey].order._id.toString();
          }
          const myord = await Order.getTotalOrderById(idorder);
          if (myord.length > 0) {
            mycart.items[idkey]._doc.order = myord[0];
          }
        } catch (e) {
          console.log('err', e);
        }
      }
      return mycart;
    }*/
  return myorderscart
  // return null;
}

module.exports.getOrdersCartByDepartmentId = async function (depId, idapp) {
  let query = {
    idapp, status: { $gte: shared_consts.OrderStatus.CHECKOUT_SENT },
    deleted: false,
  }
  const myorderscart = await OrdersCart.find(query).lean();

  for (let ind = 0; ind < myorderscart.length; ind++) {
    for (const idkey in myorderscart[ind].items) {
      try {
        let idorder = myorderscart[ind].items[idkey]._id.toString();
        const myorder = myorderscart[ind].items[idkey].order;
        if (!!myorder) {
          idorder = myorderscart[ind].items[idkey].order._id.toString();
        }
        myorderscart[ind].nameSurname = await User.getNameSurnameById(idapp, myorderscart[ind].userId);
        const myord = await Order.getTotalOrderById(idorder);
        if (myord.length > 0) {
          myorderscart[ind].items[idkey].order = myord[0];
        }
      } catch (e) {
        console.log('err', e);
      }
    }
  }

  return myorderscart
  // return null;
}

module.exports.getOrderById = async function (Id, idapp) {
  let query = { _id: Id, idapp, status: { $gte: shared_consts.OrderStatus.CHECKOUT_SENT } }
  const myorderscart = await OrdersCart.find(query).lean();

  for (let ind = 0; ind < myorderscart.length; ind++) {
    for (const idkey in myorderscart[ind].items) {
      try {
        let idorder = myorderscart[ind].items[idkey]._id.toString();
        const myorder = myorderscart[ind].items[idkey].order;
        if (!!myorder) {
          idorder = myorderscart[ind].items[idkey].order._id.toString();
        }
        myorderscart[ind].nameSurname = await User.getNameSurnameById(idapp, myorderscart[ind].userId);
        const myord = await Order.getTotalOrderById(idorder);
        if (myord.length > 0) {
          myorderscart[ind].items[idkey].order = myord[0];
        }
      } catch (e) {
        console.log('err', e);
      }
    }
  }

  return myorderscart
  // 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,
            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) {

  const ris = await OrdersCart.findOneAndUpdate(
    { _id: myOrderCart._id },
    {
      $set: objtoset
    },
    { new: false }
  )

  // Imposta su tutti i singoli prodotti ordinati (Order)
  for (const order of myOrderCart.items) {
    await Order.findOneAndUpdate(
      { _id: order._id },
      {
        $set: objtoset
      },
      { new: false }
    )
  }

}

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 idorder = myorderscart.items[idkey]._id;
        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;
});