本章节主要讲食品列表，具体内容包括：根据分类获取列表、默认显示全部数据、添加食品信息、修改食品信息、删除食品信息、查询食品信息、获取食品总数、食品数据分页等等，可以说它把大部分内容都包揽进去了，读者通过这个模块，可以更加清晰的知道nodejs+es6/7的用法。

创建食品数据模型

我们在web->models文件夹下创建food.js,具体内容如下：

'use strict';

import mongoose from 'mongoose';
const Schema = mongoose.Schema;

const foodSchema = new Schema({
    rating: {type: Number,default: 0},
    is_featured: {type: Number, default: 0},
    restaurant_id: {type: Number,isRequired: true}, //isRequired，说明该字段不能为空
    category_id: {type: Number, isRequired: true},
    pinyin_name: {type: String, default: ''},
    display_times: {type: Array, default: []},
    attrs: {type: Array, default:[]},
    description: {type: String, default: ""},
    month_sales: {type: Number, default: 0},
    rating_count: {type: Number, default: 0},
    tips: String,
    image_path: String,
    specifications: [Schema.Types.Mixed],
    server_utc: {type: Date, default: Date.now()},
    is_essential: {type: Boolean, default: false},
    attributes: {type: Array, default: []},
    item_id: {type: Number, isRequired: true},
    limitation: Schema.Types.Mixed,
    name: {type: String, isRequired: true},
    satisfy_count: {type: Number, default: 0},
    activity: Schema.Types.Mixed,
    satisfy_rate: {type: Number, default: 0},
    specfoods: [{
        original_price: {type: Number, default: 0},
        sku_id: {type: Number, isRequired: true},
        name: {type: String, isRequired: true},
        pinyin_name: {type: String, default: ""},
        restaurant_id: {type: Number, isRequired: true},
        food_id: {type: Number, isRequired: true},
        packing_fee: {type: Number, default: 0},
        recent_rating: {type: Number, default: 0},
        promotion_stock: {type: Number, default: -1},
        price: {type: Number, default: 0},
        sold_out: {type: Boolean, default: false},
        recent_popularity: {type: Number, default: 0},
        is_essential: {type: Boolean, default: false},
        item_id: {type: Number, isRequired: true},
        checkout_mode: {type: Number, default: 1},
        stock: {type: Number, default: 1000},
        specs_name: String,
        specs: [
            {
                name: String,
                value: String
            }
        ]
    }]
});

foodSchema.index({item_id: 1});

const menuSchema = new Schema({
    description: String,
    is_selected: {type:Boolean, default: true},
    icon_url: {type: String, default: ''},
    name: {type: String, isRequired: true},
    id: {type: Number, isRequired: true},
    restaurant_id: {type: Number, isRequired: true},
    type: {type: Number, default: 1},
    foods: [foodSchema]
});

menuSchema.index({id: 1});
const Food = mongoose.model('Food',foodSchema);
const Menu = mongoose.model('Menu',menuSchema);

export {Food, Menu}

创建商铺模型

因为商铺需要与食品关联，所以我们需要创建这个模型，我们在web->models文件夹下创建shop.js文件，具体代码如下：

'use strict';
import mongoose from 'mongoose';
const Schema = mongoose.Schema;

const shopSchema = new Schema({
    activities: [{
        description: String,
        icon_color: String,
        icon_name: String,
        id: Number,
        name: String
    }],
    address: String,
    delivery_mode: {
        color: String,
        id: Number,
        is_solid: Boolean,
        text: String,
    },
    description: {type: String, default:''},
    order_lead_time: {type: String, default: ''},
    distance: {type: String, default: ''},
    location: {type:[Number],index: '2d'},
    float_delivery_fee: {type: Number, default: 0},
    float_minimum_order_amount: {type: Number, default: 0},
    id: Number,
    category: String,
    identification: {
        company_name: {type: String, default: ''},
        identificate_agency: { type: String, default: "" },
        identificate_date: { type: Date, default: Date.now },
        legal_person: { type: String, default: "" },
        licenses_date: { type: String, default: "" },
        licenses_number: { type: String, default: "" },
        licenses_scope: { type: String, default: "" },
        operation_period: { type: String, default: "" },
        registered_address: { type: String, default: "" },
        registered_number: { type: String, default: "" },
    },
    image_path: {type: String,default: ''},
    is_premium: {type: Boolean, default: false},
    is_new: {type: Boolean, default: false},
    latitude: Number,
    longitude: Number,
    license: {
        business_license_image: { type: String, default: "" },
        catering_service_license_image: { type: String, default: "" },
    },
    name: {type: String, required: true},
    opening_hours: {type: Array, default:["08:30/20:30"]},
    phone: {type: String, required: true},
    piecewise_agent_fee: {tips: String},
    promotion_info: { type: String, default: "欢迎光临，用餐高峰请提前下单，谢谢" },
    rating: { type: Number, default: 0 },
    rating_count: { type: Number, default: 0 },
    recent_order_num: { type: Number, default: 0 },
    status: { type: Number, default: 0 },
    supports: [{
        description: String,
        icon_color: String,
        icon_name: String,
        id: Number,
        name: String
    }],
});

shopSchema.index({id: 1});

const Shop = mongoose.model('Shop',shopSchema);

export default Shop;

编写食品控制器

这是本章的重点，代码稍微长了点，希望读者好好研究一下。我们在web->controller->shop文件夹下创建food.js文件，具体代码如下：

import {Food as FoodModel, Menu as MenuModel} from '../../models/shop/food';
import ShopModel from '../../models/shop/shop';
import BaseComponent from '../../prototype/baseComponent';
import formidable from 'formidable';

class Food extends BaseComponent {
    constructor(){
        super();
        this.defaultData = [{
            name: '热销榜',
            description: '大家喜欢吃，才叫真好吃。',
            icon_url: "5da3872d782f707b4c82ce4607c73d1ajpeg",
            is_selected: true,
            type: 1,
            foods: [],
        }, {
            name: '优惠',
            description: '美味又实惠, 大家快来抢!',
            icon_url: "4735c4342691749b8e1a531149a46117jpeg",
            type: 1,
            foods: [],
        }]
        this.initData = this.initData.bind(this);
        this.addFood = this.addFood.bind(this);
        this.getCategory = this.getCategory.bind(this);
        this.addCategory = this.addCategory.bind(this);
        this.getSpecfoods = this.getSpecfoods.bind(this);
        this.updateFood = this.updateFood.bind(this);
    }

//数据初始化
    async initData(restaurant_id){
        for (let i = 0; i < this.defaultData.length; i++) {
            let category_id;
            try{
                category_id = await this.getId('category_id');
            }catch(err){
                console.log('获取category_id失败');
                throw new Error(err);
            }
            const defaultData = this.defaultData[i];
            const Category = {...defaultData, id: category_id, restaurant_id};
            const newFood = new MenuModel(Category);
            try{
                await newFood.save();
                console.log('初始化食品数据成功');
            }catch(err){
                console.log('初始化食品数据失败');
                throw new Error(err);
            }
        }
    }

//获取食品种类
    async getCategory(req, res, next){
        const restaurant_id = req.params.restaurant_id; //restaurant_id为需要传递的参数
        try{
            const category_list = await MenuModel.find({restaurant_id});
            res.send({
                status: 1,
                category_list,
            })
        }catch(err){
            console.log('获取餐馆食品种类失败');
            res.send({
                status: 0,
                type: 'ERROR_GET_DATA',
                message: '获取数据失败'
            })
        }
    }
//添加食品种类
    async addCategory(req, res, next){
        const form = new formidable.IncomingForm();
        form.parse(req, async (err, fields, files) => {
            try{
                if (!fields.name) {
                    throw new Error('必须填写食品类型名称');
                }else if(!fields.restaurant_id){
                    throw new Error('餐馆ID错误');
                }
            }catch(err){
                console.log(err.message, err);
                res.send({
                    status: 0,
                    type: 'ERROR_PARAMS',
                    message: err.message
                })
                return
            }
            let category_id;
            try{
                category_id = await this.getId('category_id');
            }catch(err){
                console.log('获取category_id失败');
                res.send({
                    type: 'ERROR_DATA',
                    message: '获取数据失败'
                })
                return
            }
            const foodObj = {
                name: fields.name,
                description: fields.description,
                restaurant_id: fields.restaurant_id,
                id: category_id,
                foods: [],
            }
            const newFood = new MenuModel(foodObj);
            try{
                await newFood.save();
                res.send({
                    status: 1,
                    success: '添加食品种类成功',
                })
            }catch(err){
                console.log('保存数据失败');
                res.send({
                    status: 0,
                    type: 'ERROR_IN_SAVE_DATA',
                    message: '保存数据失败',
                })
            }
        })
    }

//添加食品
    async addFood(req, res, next){
        const form = new formidable.IncomingForm();
        form.parse(req, async (err, fields, files) => {
            try{
                if (!fields.name) {
                    throw new Error('必须填写食品名称');
                }else if(!fields.image_path){
                    throw new Error('必须上传食品图片');
                }else if(!fields.specs.length){
                    throw new Error('至少填写一种规格');
                }else if(!fields.category_id){
                    throw new Error('食品类型ID错误');
                }else if(!fields.restaurant_id){
                    throw new Error('餐馆ID错误');
                }
            }catch(err){
                console.log('前台参数错误', err.message);
                res.send({
                    status: 0,
                    type: 'ERROR_PARAMS',
                    message: err.message
                })
                return
            }
            let category;
            let restaurant;
            try{
                category = await MenuModel.findOne({id: fields.category_id});
                restaurant = await ShopModel.findOne({id: fields.restaurant_id});
            }catch(err){
                console.log('获取食品类型和餐馆信息失败');
                res.send({
                    status: 0,
                    type: 'ERROR_DATA',
                    message: '添加食品失败'
                })
                return
            }
            let item_id;
            try{
                item_id = await this.getId('item_id');
            }catch(err){
                console.log('获取item_id失败');
                res.send({
                    status: 0,
                    type: 'ERROR_DATA',
                    message: '添加食品失败'
                })
                return
            }
            const rating_count = Math.ceil(Math.random()*1000);
            const month_sales = Math.ceil(Math.random()*1000);
            const tips = rating_count + "评价 月售" + month_sales + "份";
            const newFood = {
                name: fields.name,
                description: fields.description,
                image_path: fields.image_path,
                activity: null,
                attributes: [],
                restaurant_id: fields.restaurant_id,
                category_id: fields.category_id,
                satisfy_rate: Math.ceil(Math.random()*100),
                satisfy_count: Math.ceil(Math.random()*1000),
                item_id,
                rating: (4 + Math.random()).toFixed(1),
                rating_count,
                month_sales,
                tips,
                specfoods: [],
                specifications: [],
            }
            if (fields.activity) {
                newFood.activity = {
                    image_text_color: 'f1884f',
                    icon_color: 'f07373',
                    image_text: fields.activity,
                }
            }
            if (fields.attributes.length) {
                fields.attributes.forEach(item => {
                    let attr;
                    switch(item){
                        case '新':
                            attr = {
                                icon_color: '5ec452',
                                icon_name: '新'
                            }
                            break;
                        case '招牌':
                            attr = {
                                icon_color: 'f07373',
                                icon_name: '招牌'
                            }
                            break;
                    }
                    newFood.attributes.push(attr);
                })
            }
            try{
                const [specfoods, specifications] = await this.getSpecfoods(fields, item_id);
                newFood.specfoods = specfoods;
                newFood.specifications = specifications;
            }catch(err){
                console.log('添加specs失败', err);
                res.send({
                    status: 0,
                    type: 'ERROR_DATA',
                    message: '添加食品失败'
                })
                return
            }
            try{
                const foodEntity = await FoodModel.create(newFood);
                category.foods.push(foodEntity);
                category.markModified('foods');
                await category.save();
                res.send({
                    status: 1,
                    success: '添加食品成功',
                });
            }catch(err){
                console.log('保存食品到数据库失败', err);
                res.send({
                    status: 0,
                    type: 'ERROR_DATA',
                    message: '添加食品失败'
                })
            }
        })
    }

//获取符合要求的食品
    async getSpecfoods(fields, item_id){
        let specfoods = [], specifications = [];
        if (fields.specs.length < 2) {
            let food_id, sku_id;
            try{
                sku_id = await this.getId('sku_id');
                food_id = await this.getId('food_id');
            }catch(err){
                throw new Error('获取sku_id、food_id失败')
            }
            specfoods.push({
                packing_fee: fields.specs[0].packing_fee,
                price: fields.specs[0].price,
                specs: [],
                specs_name: fields.specs[0].specs,
                name: fields.name,
                item_id,
                sku_id,
                food_id,
                restaurant_id: fields.restaurant_id,
                recent_rating: (Math.random()*5).toFixed(1),
                recent_popularity: Math.ceil(Math.random()*1000),
            })
        }else{
            specifications.push({
                values: [],
                name: "规格"
            })
            for (let i = 0; i < fields.specs.length; i++) {
                let food_id, sku_id;
                try{
                    sku_id = await this.getId('sku_id');
                    food_id = await this.getId('food_id');
                }catch(err){
                    throw new Error('获取sku_id、food_id失败')
                }
                specfoods.push({
                    packing_fee: fields.specs[i].packing_fee,
                    price: fields.specs[i].price,
                    specs: [{
                        name: "规格",
                        value: fields.specs[i].specs
                    }],
                    specs_name: fields.specs[i].specs,
                    name: fields.name,
                    item_id,
                    sku_id,
                    food_id,
                    restaurant_id: fields.restaurant_id,
                    recent_rating: (Math.random()*5).toFixed(1),
                    recent_popularity: Math.ceil(Math.random()*1000),
                })
                specifications[0].values.push(fields.specs[i].specs);
            }
        }
        return [specfoods, specifications]
    }

//获取菜单
    async getMenu(req, res, next){
        const restaurant_id = req.query.restaurant_id;
        const allMenu = req.query.allMenu;
        if (!restaurant_id || !Number(restaurant_id)) {
            console.log('获取餐馆参数ID错误');
            res.send({
                status: 0,
                type: 'ERROR_PARAMS',
                message: '餐馆ID参数错误',
            })
            return
        }
        let filter;
        if (allMenu) {
            filter = {restaurant_id}
        }else{
            filter = {restaurant_id, $where: function(){return this.foods.length}};
        }
        try{
            const menu = await MenuModel.find(filter, '-_id');
            res.send(menu);
        }catch(err){
            console.log('获取食品数据失败', err);
            res.send({
                status: 0,
                type: 'GET_DATA_ERROR',
                message: '获取食品数据失败'
            })
        }
    }
//获取菜单详细页
    async getMenuDetail(req, res, next){
        const category_id = req.params.category_id;
        if (!category_id || !Number(category_id)) {
            console.log('获取Menu详情参数ID错误');
            res.send({
                status: 0,
                type: 'ERROR_PARAMS',
                message: 'Menu ID参数错误',
            })
            return
        }
        try{
            const menu = await MenuModel.findOne({id: category_id}, '-_id');
            res.send(menu)
        }catch(err){
            console.log('获取Menu详情失败', err);
            res.send({
                status: 0,
                type: 'GET_DATA_ERROR',
                message: '获取Menu详情失败'
            })
        }
    }

//获取食品列表
    async getFoods(req, res, next){
        const {restaurant_id, limit = 20, offset = 0} = req.query; //分页设置
        try{
            let filter = {};
            if (restaurant_id && Number(restaurant_id)) {
                filter = {restaurant_id}
            }

            const foods = await FoodModel.find(filter, '-_id').sort({item_id: -1}).limit(Number(limit)).skip(Number(offset));
            res.send(foods);
        }catch(err){
            console.log('获取食品数据失败', err);
            res.send({
                status: 0,
                type: 'GET_DATA_ERROR',
                message: '获取食品数据失败'
            })
        }
    }

//获取食品总数
    async getFoodsCount(req, res, next){
        const restaurant_id = req.query.restaurant_id;
        try{
            let filter = {};
            if (restaurant_id && Number(restaurant_id)) {
                filter = {restaurant_id}
            }

            const count = await FoodModel.find(filter).count();
            res.send({
                status: 1,
                count,
            })
        }catch(err){
            console.log('获取食品数量失败', err);
            res.send({
                status: 0,
                type: 'ERROR_TO_GET_COUNT',
                message: '获取食品数量失败'
            })
        }
    }

//修改食品信息
    async updateFood(req, res, next){
        const form = new formidable.IncomingForm();
        form.parse(req, async (err, fields, files) => {
            if (err) {
                console.log('获取食品信息form出错', err);
                res.send({
                    status: 0,
                    type: 'ERROR_FORM',
                    message: '表单信息错误',
                })
                return
            }
            const {name, item_id, description = "", image_path, category_id, new_category_id} = fields;
            try{
                if (!name) {
                    throw new Error('食品名称错误');
                }else if(!item_id || !Number(item_id)){
                    throw new Error('食品ID错误');
                }else if(!category_id || !Number(category_id)){
                    throw new Error('食品分类ID错误');
                }else if(!image_path){
                    throw new Error('食品图片地址错误');
                }
                const [specfoods, specifications] = await this.getSpecfoods(fields, item_id);
                let newData;
                if (new_category_id !== category_id) {
                    newData = {name, description, image_path, category_id: new_category_id, specfoods, specifications};
                    const food = await FoodModel.findOneAndUpdate({item_id}, {$set: newData});

                    const menu = await MenuModel.findOne({id: category_id})
                    const targetmenu = await MenuModel.findOne({id: new_category_id})

                    let subFood = menu.foods.id(food._id);
                    subFood.set(newData)
                    targetmenu.foods.push(subFood)
                    targetmenu.markModified('foods');
                    await targetmenu.save()
                    await subFood.remove()
                    await menu.save()
                }else{
                    newData = {name, description, image_path, specfoods, specifications};
                    const food = await FoodModel.findOneAndUpdate({item_id}, {$set: newData});

                    const menu = await MenuModel.findOne({id: category_id})
                    let subFood = menu.foods.id(food._id);
                    subFood.set(newData)
                    await menu.save()
                }

                res.send({
                    status: 1,
                    success: '修改食品信息成功',
                })
            }catch(err){
                console.log(err.message, err);
                res.send({
                    status: 0,
                    type: 'ERROR_UPDATE_FOOD',
                    message: '更新食品信息失败',
                })
            }
        })
    }

//删除食品
    async deleteFood(req, res, next){
        const food_id = req.params.food_id;
        if (!food_id || !Number(food_id)) {
            console.log('food_id参数错误');
            res.send({
                status: 0,
                type: 'ERROR_PARAMS',
                message: 'food_id参数错误',
            })
            return
        }
        try{
            const food = await FoodModel.findOne({item_id: food_id});
            const menu = await MenuModel.findOne({id: food.category_id})
            let subFood = menu.foods.id(food._id);
            await subFood.remove()
            await menu.save()
            await food.remove()
            res.send({
                status: 1,
                success: '删除食品成功',
            })
        }catch(err){
            console.log('删除食品失败', err);
            res.send({
                status: 0,
                type: 'DELETE_FOOD_FAILED',
                message: '删除食品失败',
            })
        }
    }
}

export default new Food();

编写路由

下面我们编写路由信息。我们在routes文件夹下创建shop.js文件，然后把我们的食品控制器加进去，具体代码如下：

import express from 'express';
import Shop from '../web/controller/shop/shop';
import Food from '../web/controller/shop/food';
import Check from '../web/middlewares/check'; //这是判断用户是否登录的文件，在前面的章节中我们已经写好了
const router = express.Router();

router.post('/addshop', Check.checkAdmin, Shop.addShop);
router.get('/restaurants', Shop.getRestaurants);
router.get('/restaurants/count', Shop.getShopCount);
router.post('/updateshop', Check.checkAdmin, Shop.updateshop);
router.delete('/restaurant/:restaurant_id', Check.checkSuperAdmin, Shop.deleteResturant);
router.get('/restaurant/:restaurant_id', Shop.getRestaurantDetail);
router.post('/addfood', Check.checkAdmin, Food.addFood);
router.get('/getcategory/:restaurant_id', Food.getCategory);
router.post('/addcategory', Check.checkAdmin, Food.addCategory);
router.get('/v2/menu', Food.getMenu);
router.get('/v2/menu/:category_id', Food.getMenuDetail);
router.get('/v2/foods', Food.getFoods);
router.get('/v2/foods/count', Food.getFoodsCount);
router.post('/v2/updatefood', Check.checkAdmin, Food.updateFood);
router.delete('/v2/food/:food_id', Check.checkSuperAdmin, Food.deleteFood);
export default router

当路由写好后，我们就在控制台启动项目，启动命令：npm run dev。然后在浏览器中输入：http://127.0.0.1:3000/shop/v2/menu?restaurant_id=1，就能看到我们想要的效果了。截图如下：

效果图