从零开始，搭建一个简单的购物平台（十）

从零开始，搭建一个简单的购物平台（九）：
https://blog.csdn.net/time_____/article/details/105465499
项目源码（持续更新）：https://gitee.com/DieHunter/myCode/tree/master/shopping
拖更时间较长，公司这几个月项目高峰期，请见谅

这篇文章主要讲述后端管理系统新增的订单模块的部分内容（前端在之前的计划下稍稍改动，引入了订单的功能，但不包含支付功能），由于与用户管理和商品管理稍有不同，所以单独拎出来介绍一下

前端效果：

对于订单模块，主要功能有订单列表显示，订单状态修改（不涉及订单状态外其他数据修改），删除订单，新增订单（新增订单方面只做了简单的通过商品名索引来添加，考虑到管理系统的订单新增不是主要的功能，几乎用不上，所以没有细化功能），这篇文章主要介绍后端订单管理实现，接口对接。

服务端：

• 首先我们需要在服务端配置一下数据库表结构，主要包含以下几个字段

      Order: {
        modelName: "orders",
        data: {
          orderId: {
            // 订单号
            type: String,
            required: true,
          },
          username: {
            //用户名
            type: String,
            required: true,
          },
          phoneNum: {
            //手机号
            type: String,
            required: true,
          },
          address: {
            //具体地址
            type: String,
            required: true,
          },
          orderState: {
            //订单状态
            type: String,
            required: true,
          },
          orderPrice: {
            // 订单总价
            type: String,
            required: true,
          },
          shopList: {
            //商品列表
            type: Array,
            required: true,
          },
          orderTime: {
            //订单创建时间
            type: String,
            required: true,
          },
        },
      },

• 使用npm start启动server
• 然后在src目录下controller目录中新建order文件夹，用于订单接口，逻辑的实现，mod文件和之前一样，新建order表
  
• 在order中引入依赖包，要注意的是，新增订单不仅仅是需要order一个表，还需要和user和shop表进行联动，因此我们需要调用其他接口逻辑中的方法，引入的包名如下

  const router = require("express").Router();//路由
  const UserMod = require("../user/mod");//user表联动
  const ShopMod = require("../shopList/mod");//shop表联动
  const Mod = require("./mod");//order表
  const Util = require("../../../utils/utils");//工具类
  const Config = require("../../../config/config");//配置文件
  const Bussiness = require("../../bussiness/bussiness");//接口逻辑
  const { addData, updateData, findData } = require("../../command/command");//数据库操作

•  首先是新增订单接口，这个接口也是需要注意的和坑最多的地方，以下是检测用户，用户地址，商品是否存在

  let userFindRes = await Bussiness.hasUser(req, res, UserMod);//检测用户及地址是否存在
    if (!userFindRes) {
      return;
    }
    if (!userFindRes[0].alladdress || !userFindRes[0].address) {
      res.send({
        result: -1,
        msg: "添加失败，请完善收货地址",
      });
      return;
    }
    let shopFindRes = await findData(ShopMod, {//检测商品是否存在
      shopName: {
        $in: res._data.shopList.map((item) => {
          return item.shopName;
        }),
      },
    });
    if (
      !shopFindRes ||
      !shopFindRes.length ||
      shopFindRes.length != res._data.shopList.length
    ) {
      res.send({
        result: -2,
        msg: "有商品不存在",
      });
      return;
    }

  下一步，将取出数据库信息（注意：数据库信息是只读，只能用数据库命令修改，所以不能用常规的堆内存存取需要用一个简单的堆变量复制）

  static deepCopy(org) {
      //简单的对象复制
      return JSON.parse(JSON.stringify(org));
    }

  使用拷贝函数，将数据库信息取出并进行后续修改

  let _shopFindRes = Util.deepCopy(shopFindRes); //解决数据库对象只读属性

  在返回前端之前，计算出总价和订单添加时间

  let _orderPrice;//初始化商品总价
    let _shopFindRes = Util.deepCopy(shopFindRes); //解决数据库对象只读属性
    _shopFindRes.forEach((item, index) => {//合计总费用
      if (index == 0) {
        _orderPrice = 0;
      }
      _shopFindRes[index].shopCount = res._data.shopList[index].shopCount;
      _orderPrice +=
        _shopFindRes[index].shopCount * _shopFindRes[index].shopPrice;
    });
  
    res._data = {
      ...res._data,
      username: userFindRes[0].username,
      phoneNum: userFindRes[0].phoneNum,
      address: userFindRes[0].alladdress.join("") + userFindRes[0].address,
      orderId: Util.createOrderNo(),
      orderTime: Util.joinDate(),
      shopList: _shopFindRes,
      orderPrice: _orderPrice,
    };
    let addRes = await addData(Mod, res._data);
    if (!addRes || !addRes.length) {
      res.send({
        result: 0,
        msg: "添加失败",
      });
      return;
    }
    res.send({
      result: 1,
      msg: "添加成功",
      orderId: res._data.orderId,
    });

•  与订单查询，删除，修改相比新增订单是个逻辑不同的功能，代码能复用的地方较少，其余三个功能均可仿照商品和用户接口写法实现

• 获取订单列表

  router.get(Config.ServerApi.orderList, Util.checkToken, async (req, res) => {
    Bussiness.findInfo(
      req,
      res,
      Mod,
      {
        orderTime: res._data.sort,//时间排序
      },
      {
        orderId: new RegExp(res._data.orderId, "i"),//orderId（订单号）模糊过滤
        username: new RegExp(res._data.keyWord, "i"),//订单用户名模糊过滤
        orderState: new RegExp(res._data.orderState, "i"),//订单状态模糊过滤
      }
    );
  });

• 删除订单

  router.get(Config.ServerApi.delOrder, Util.checkToken, async (req, res) => {
    if (!Bussiness.isAdmin(res)) {
      return;
    }
    Bussiness.delInfo(req, res, Mod);
  });

• 修改订单状态

  router.post(Config.ServerApi.updateOrder, Util.checkToken, async (req, res) => {
    let updateRes = await updateData(Mod, res._data._id, res._data);
    if (updateRes) {
      res.send({
        result: 1,
        msg: "修改成功",
      });
      return;
    }
    res.send({
      result: 0,
      msg: "修改失败",
    });
  });

  以上就是订单管理服务端接口和逻辑部分

总结：

编写面向对象代码与实现其功能时，尽量减少函数之间的耦合度（函数与函数之间的联系），使其复用性增强，大大节省开发效率