Estoy construyendo un backend de tienda simple con fines prácticos. Tengo tres esquemas Product, Customer y Order.

Lo que estoy tratando de lograr es restar la cantidad pedida de la cantidad de stock para cada producto dentro de un pedido, cuando se crea el pedido. Claramente estoy haciendo algo mal porque mi productsToUpdateInDbArray contiene los productos correctos (lo comprobé con el registro de la consola) pero no puedo encontrar una manera de hacerlo funcionar.

El campo stockQty dentro de la colección de productos no se actualiza.

Mi código de controlador es:

'use strict'

// require validator for string validation
const validator = require('validator');
// import Order, Customer, Product Models
const Order = require("../models/order.model");
const Customer = require("../models/customer.model");
const Product = require("../models/product.model");

// DEFINE CONTROLLER FUNCTIONS

// listAllOrders function - To list all orders
exports.listAllOrders = (req, res) => {
    Order.find({}, (err, orders) => {
        if (err) {
            return res.status(500).send(`Internal server error: ${error}`);
        }

        if (orders && orders.length === 0) {
            return res.status(404).send(`No orders found!`);
        }

        return res.status(200).json(orders);
    });
};

// createNewOrder function - To create new order
exports.createNewOrder = (req, res) => {
    const customerId = req.body?.customerId;
    const productsArray = req.body?.products;

    let productsToUpdateInDbArray = [];

    if (!validator.isMongoId(customerId)) {
        return res.status(400).send('Invalid customer Id');
    }

    Customer.findById(customerId, async (err, customer) => {
        if (err) {
            return res.status(500).send(`Internal server error: ${error}`);
        }

        if (!customer) {
            return res.status(404).send(`No customers found!`);
        }

        if (!productsArray || productsArray.length === 0) {
            return res.status(400).send(`No products found in the order!`);
        }

        for (let product of productsArray) {
            if (!validator.isMongoId(product?.productId)) {
                return res.status(400).send('Invalid product Id');
            }

            if (!product?.quantity || product?.quantity < 1) {
                return res.status(400).send('Invalid product quantity');
            }

            let productFound = await Product.findById(product?.productId).exec();
            
            if (!productFound) {
                return res.status(404).send('Product not found!');
            }

            if (productFound.stockQty < product.quantity) {
                return res.status(400).send('Not enough product quantity in stock')
            }

            productFound.stockQty -= product.quantity;
            productsToUpdateInDbArray.push(productFound);
        }

        console.log(productsToUpdateInDbArray)

        const newOrder = new Order(req.body);
        newOrder.save((err, order) => {
            if (err) {
                return res.status(500).send(`Internal server error: ${error}`);
            }

            for (let item of productsToUpdateInDbArray) {
                const filter = { _id: item._id };
                const update = { stockQty: item.stockQty };

                Product.findOneAndUpdate( filter, update )
            }
            return res.status(201).json(order);
        });
    });
};


Y mis modelos son:

'use strict';

// Import mongoose
const mongoose = require("mongoose");

// Declare schema and assign Schema class
const Schema = mongoose.Schema;

// Create Schema Instance and add schema propertise
const ProductSchema = new Schema({
    name: {
        type: String,
        required: true
    },
    price: {
        type: Number,
        required: true
    },
    description: {
        type: String,
        required: true
    },
    imageUrl: {
        type: String,
        required: true
    },
    stockQty: {
        type: Number,
        required: true
    }
});

// create and export model
module.exports = mongoose.model("Products", ProductSchema);
'use strict';

// Import mongoose
const mongoose = require("mongoose");

// Declare schema and assign Schema class
const Schema = mongoose.Schema;

// Create Schema Instance and add schema propertise
const OrderSchema = new Schema({
    products: [
        {
            productId: {
                type: Schema.Types.ObjectId,
                required: true,
                ref: "Products"
            },
            quantity: {
                type: Number,
                default: 1
            }
        }
      ],
    customerId: {
        type: Schema.Types.ObjectId,
        required: true,
        ref: "Customers"
    }
});

// create and export model
module.exports = mongoose.model("Orders", OrderSchema);
0
Antonis Kiosses 25 ene. 2021 a las 01:32

1 respuesta

La mejor respuesta

findOneAndUpdate solo ejecutará la consulta cuando se pase un callback. Entonces, en su caso, puede agregar un await o callback.

await Product.findOneAndUpdate( filter, update );

O

Product.findOneAndUpdate( filter, update, callback );
0
Vishnu 25 ene. 2021 a las 07:51