javascript 在 Postman 中获取错误“无法读取null的属性(阅读'_id')”

yftpprvb  于 2023-10-14  发布在  Java
关注(0)|答案(1)|浏览(126)

你能帮我解决下面的问题吗？
实际上建立一个电子商务网站，我正在测试一个API的，我遇到下面的错误，而在 Postman 测试。
错误：-"{“错误”：“无法读取null的属性（阅读”_id“）”}”
我迷失了方向，请帮助我。下面是来自不同文件的代码，请仔细阅读并建议需要做哪些更改。
下面是jxt.js

  1. const jwt = require("jsonwebtoken");
  3. const SECRET_KEY = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
  4. const generateToken = (userId) => {
  5.   const token = jwt.sign({ userId }, SECRET_KEY, { expiresIn: "48h" });
  6.   return token;
  7. };
  9. const getUserIdFromToken = (token) => {
  10.   const decodedToken = jwt.verify(token, SECRET_KEY);
  11.   return decodedToken.userId;
  12. };
  14. module.exports = { generateToken, getUserIdFromToken };

下面是Authenticate.js

  1. const jwtProvider = require("../config/jwtProvider.js");
  2. const userService = require("../services/user.services.js");
  4. const authenticate = async (req, res, next) => {
  5.   try {
  6.     const token = req.headers.authorization?.split(" ")[1];
  7.     if (!token) {
  8.       return res.status(401).send({ error: "Invalid" });
  9.     }
  11.     const userId = jwtProvider.getUserIdFromToken(token);
  12.     const user = userService.findUserById(userId);
  14.     if (!user) {
  15.       return res.status(401).send({ error: "User not found" });
  16.     }
  17.     req.user = user;
  18.   } catch (error) {
  19.     return res.status(500).send({ error: error.message });
  20.   }
  22.   next();
  23. };
  25. module.exports = authenticate;

下面是orderController.js

  1. const orderService = require("../services/order.services.js");
  3. const createOrder = async (req, res) => {
  4.   const user = await req.user;
  5.   try {
  6.     let createdOrder = await orderService.createOrder(user, req.body);
  7.     return res.status(201).send(createdOrder);
  8.   } catch (error) {
  9.     return res.status(500).send({ error: error.message });
  10.   }
  11. };
  13. const findOrderById = async (req, res) => {
  14.   const user = await req.user;
  15.   try {
  16.     let createdOrder = await orderService.findOrderById(req.params.id);
  17.     return res.status(201).send(createdOrder);
  18.   } catch (error) {
  19.     return res.status(500).send({ error: error.message });
  20.   }
  21. };
  23. const orderHistory = async (req, res) => {
  24.   const user = await req.user;
  25.   try {
  26.     let createdOrder = await orderService.usersOrderHistory(user._id);
  27.     return res.status(201).send(createdOrder);
  28.   } catch (error) {
  29.     return res.status(500).send({ error: error.message });
  30.   }
  31. };
  33. module.exports = {
  34.   createOrder,
  35.   findOrderById,
  36.   orderHistory,
  37. };
  39. "Below is the userController"
  41. const userService = require("../services/user.services.js");
  43. const getUserProfile = async (req, res) => {
  44.   try {
  45.     const jwt = req.headers.authorization?.split(" ")[1];
  47.     if (!jwt) {
  48.       return res.status(404).send({ error: "token not found" });
  49.     }
  50.     const user = await userService.getUserProfileByToken(jwt);
  51.     return res.status(200).send(user);
  52.   } catch (error) {
  53.     return res.status(500).send({ error: error.message });
  54.   }
  55. };
  57. const getAllUsers = async (req, res) => {
  58.   try {
  59.     const users = await userService.getAllUsers();
  60.     return res.status(200).send(users);
  61.   } catch (error) {
  62.     return res.status(500).send({ error: error.message });
  63.   }
  64. };
  66. module.exports = { getUserProfile, getAllUsers };
  68. "Below is the User Modal"
  70. const mongoose = require("mongoose");
  71. const userSchema = new mongoose.Schema({
  72.   firstName: {
  73.     type: String,
  74.     required: true,
  75.   },
  76.   lastName: {
  77.     type: String,
  78.     required: true,
  79.   },
  81.   password: {
  82.     type: String,
  83.     required: true,
  84.   },
  86.   email: {
  87.     type: String,
  88.     required: true,
  89.   },
  90.   role: {
  91.     type: String,
  92.     required: true,
  93.     default: "CUSTOMER",
  94.   },
  96.   mobile: {
  97.     type: String,
  98.   },
  100.   address: [
  101.     {
  102.       type: mongoose.Schema.Types.ObjectId,
  103.       ref: "addresses",
  104.     },
  105.   ],
  107.   paymentInformation: [
  108.     {
  109.       type: mongoose.Schema.Types.ObjectId,
  110.       ref: "payment_information",
  111.     },
  112.   ],
  114.   ratings: [
  115.     {
  116.       type: mongoose.Schema.Types.ObjectId,
  117.       ref: "ratings",
  118.     },
  119.   ],
  120.   reviews: [
  121.     {
  122.       type: mongoose.Schema.Types.ObjectId,
  123.       ref: "reviews",
  124.     },
  125.   ],
  127.   createdAt: {
  128.     type: Date,
  129.     default: Date.now(),
  130.   },
  131. });
  133. const User = mongoose.model("users", userSchema);
  134. module.exports = User;

下面是orderservices代码

  1. const Address = require("../models/address.model.js");
  2. const Order = require("../models/order.model.js");
  3. const OrderItem = require("../models/orderItems.js");
  4. const cartService = require("../services/cart.services.js");
  6. async function createOrder(user, shipAddress) {
  7.   let address;
  8.   if (shipAddress._id) {
  9.     let existAddress = await Address.findById(shipAddress._id);
  10.     address = existAddress;
  11.   } else {
  12.     address = new Address(shipAddress);
  13.     address.user = user;
  14.     await address.save();
  16.     console.error(address);
  18.     user.address.push(address);
  19.     await user.save();
  20.   }
  22.   const cart = await cartService.findUserCart(user._id);
  23.   const orderItems = [];
  25.   for (const item of cart.cartItems) {
  26.     const orderItem = new OrderItem({
  27.       price: item.price,
  28.       product: item.product,
  29.       quantity: item.quantity,
  30.       size: item.size,
  31.       userId: item.userId,
  32.       discountedPrice: item.discountedPrice,
  33.     });
  34.     const createdOrderItem = await orderItem.save();
  35.     orderItems.push(createdOrderItem);
  36.   }
  38.   const createdOrder = new Order({
  39.     user,
  40.     orderItems,
  41.     totalPrice: cart.totalPrice,
  42.     totalDiscountedPrice: cart.totalDiscountedPrice,
  43.     discount: cart.discount,
  44.     totalItem: cart.totalItem,
  45.     shipAddress: address,
  46.   });
  48.   const savedOrder = await createdOrder.save();
  49.   return savedOrder;
  50. }
  51. async function placeOrder(orderId) {
  52.   const order = await findOrderById(orderId);
  53.   order.orderStatus = "PLACED";
  54.   order.paymentDetails.status = "COMPLETED";
  56.   return await order.save();
  57. }
  59. async function confirmedOrder(orderId) {
  60.   const order = await findOrderById(orderId);
  61.   order.orderStatus = "CONFIRMED";
  62.   return await order.save();
  63. }
  65. async function shippedOrder(orderId) {
  66.   const order = await findOrderById(orderId);
  67.   order.orderStatus = "SHIPPED";
  68.   return await order.save();
  69. }
  71. async function deliveredOrder(orderId) {
  72.   const order = await findOrderById(orderId);
  73.   order.orderStatus = "DELIVERED";
  74.   return await order.save();
  75. }
  77. async function cancelledOrder(orderId) {
  78.   const order = await findOrderById(orderId);
  79.   order.orderStatus = "CANCELLED";
  80.   return await order.save();
  81. }
  83. async function findOrderById(orderId) {
  84.   const order = await Order.findById(orderId)
  85.     .populate("user")
  86.     .populate({ path: "orderItems", populate: { path: "product" } })
  87.     .populate("shippingAddress");
  89.   return order;
  90. }
  92. async function usersOrderHistory(userId) {
  93.   try {
  94.     const orders = await Order.find({
  95.       user: userId,
  96.       orderStatus: "PLACED",
  97.     })
  98.       .populate({ path: "orderItems", populate: { path: "product" } })
  99.       .lean();
  100.     return orders;
  101.   } catch (error) {
  102.     throw new Error(error.message);
  103.   }
  104. }
  106. async function getAllOrders() {
  107.   return await Order.find()
  108.     .populate({ path: "orderItems", populate: { path: "product" } })
  109.     .lean();
  110. }
  112. async function deleteOrder(orderId) {
  113.   const order = await findOrderById(orderId);
  114.   await Order.findByIdAndDelete(order._id);
  115. }
  117. module.exports = {
  118.   createOrder,
  119.   placeOrder,
  120.   confirmedOrder,
  121.   shippedOrder,
  122.   deliveredOrder,
  123.   cancelledOrder,
  124.   findOrderById,
  125.   usersOrderHistory,
  126.   getAllOrders,
  127.   deleteOrder,
  128. };
  130. Below is the userServices code 
  132. const User = require("../models/user.model");
  133. const bcrypt = require("bcrypt");
  134. const jwtProvider = require("../config/jwtProvider.js");
  136. const createUser = async (userData) => {
  137.   try {
  138.     let { firstName, lastName, email, password } = userData;
  139.     const isUserExist = await User.findOne({ email });
  140.     if (isUserExist) {
  141.       throw new Error(
  142.         `Sorry, but a user with  email address: ${email} already exists. Please use a different email.`
  143.       );
  144.     }
  145.     password = await bcrypt.hash(password, 8);
  147.     const user = await User.create({ firstName, lastName, email, password });
  149.     console.log("create user", user);
  150.     return user;
  151.   } catch (error) {
  152.     throw new Error(error.message);
  153.   }
  154. };
  156. const findUserById = async (userId) => {
  157.   try {
  158.     const user = await User.findById(userId).populate("address");
  159.     if (!user) {
  160.       throw new Error(
  161.         `User not found with userId ${userId}. Please check your user ID and try again.`
  162.       );
  163.     }
  164.     return user;
  165.   } catch (error) {
  166.     throw new Error(error.message);
  167.   }
  168. };
  170. const getUserByEmail = async (email) => {
  171.   try {
  172.     const user = await User.findOne({ email });
  173.     if (!user) {
  174.       throw new Error(
  175.         `User not found with email ${email}. Please check your email ID and try again.`
  176.       );
  177.     }
  178.     return user;
  179.   } catch (error) {
  180.     throw new Error(error.message);
  181.   }
  182. };
  184. const getUserProfileByToken = async (token) => {
  185.   try {
  186.     const userId = jwtProvider.getUserIdFromToken(token);
  188.     const user = await findUserById(userId);
  190.     if (!user) {
  191.       throw new Error(
  192.         `User not found with userId ${userId}. Please check your email ID and try again.`
  193.       );
  194.     }
  195.     return user;
  196.   } catch (error) {
  197.     throw new Error(error.message);
  198.   }
  199. };
  201. const getAllUsers = async () => {
  202.   try {
  203.     const users = await User.find();
  204.     return users;
  205.   } catch (error) {
  206.     throw new Error(error.message);
  207.   }
  208. };
  209. module.exports = {
  210.   createUser,
  211.   findUserById,
  212.   getUserByEmail,
  213.   getUserProfileByToken,
  214.   getAllUsers,
  215. };

试着找出错误。没有尝试任何不同的东西

JavaScript

1条答案

按热度按时间
mspsb9vt

mspsb9vt1#

不需要太仔细地观察，您应该能够在包含_id的对象上使用安全导航器。我怀疑这个问题源于：

  1. let createdOrder = await orderService.usersOrderHistory(user._id);

因为这似乎是您定义错误响应格式的地方。但是，在尝试访问null对象的_id时，以下所有内容都可能引发类似的问题。

  1. if (shipAddress._id) {
  1. const cart = await cartService.findUserCart(user._id);
  1. await Order.findByIdAndDelete(order._id);

一个简单的修复方法是添加JS的安全对象访问器/导航器?。范例：

  1. let createdOrder = await orderService.usersOrderHistory(user?._id);

但是，请注意，如果无论什么处理结果（在这种情况下：usersOrderHistory）如果无法处理null值，则可能会引发问题。
另一种选择是创建一个if保护，以应对_id的对象可能为空的情况：

  1. if (user) {
  2.   ...
  3.   let createdOrder = await orderService.usersOrderHistory(user?._id);
  4.   ...
  5. }

（虽然对于这种情况不一定值得，但我倾向于将lodash包/库用于许多与对象相关的操作。有了这个，你可以做：

  1. import _ from 'lodash';
  2. ...
  3. // a default value is not 100% necessary, but if `user` does not have
  4. // `_id` for whatever reason, then this will return `undefined`
  5. const someDefaultValue = -1;
  6. let createdOrder = await orderService.usersOrderHistory(_.get(user, '_id', someDefaultValue);
  7. ...

）

展开查看全部
赞(0）分享  回复(0）举报  2023-10-14
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com