REST-API-07-Relationships

发表于 | 分类于 ，

Create Relationship between car and user

models/user.js

1
2
3
4
5
6
7
8
9
10
11
12
13
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const userSchema = new Schema({
    firstName:String,
    lastName: String,
    email: String,
    cars: [{
        type: Schema.Types.ObjectId,
        ref: 'car'
    }]
});
const User = mongoose.model('user',userSchema);
module.exports = User;

models/car.js

1
2
3
4
5
6
7
8
9
10
11
12
13
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const carSchema = new Schema({
    make:String,
    model:String,
    year:Number,
    seller:{
        type:Schema.Types.ObjectId,
        ref:'user'
    }
});
const Car = mongoose.model('car',carSchema);
module.exports = Car;

routers/users.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const express = require('express');
//const router = express.Router();
const router = require('express-promise-router')();
const userController = require('../controllers/users');
router.route('/')
    .get(userController.index)
    .post(userController.newUser);
router.route('/:userId')
    .get(userController.getUser)
    .put(userController.replaceUser)
    .patch(userController.updateUser);
router.route('/:userId/cars').get(userController.getUserCars)
    .post(userController.newUserCar);
module.exports = router;

routers/index.js

1
2
3
4
5
6
7
const express = require('express');
const router = express.Router();
const userController = require('../controllers/index');
router.route('/')
    .get(userController.index)
    .post();
module.exports = router;

controllers/users.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
const User = require('../models/user');
const Car =  require('../models/car');
module.exports = {
    index: async (req, res, next) => {
        const users = await User.find();
        res.status(200).json(users);
    },
    newUser: async (req, res, next) => {
        const newUser = new User(req.body);
        const user = await newUser.save();
        res.status(200).json(user);
    },
    getUser: async (req, res, next) => {
        // enforce that req.body must contain all the fields
        console.log('req.params', req.params);
        const { userId } = req.params;
        const users = await User.findById(userId);
        res.status(200).json(users);
    },
    replaceUser: async (req, res, next) => {
        // req.body may contain any number of fields
        const { userId } = req.params;
        const newUser = req.body;
        const result = await User.findByIdAndUpdate(userId, newUser);
        res.status(200).json({ success: true });
    },
    updateUser: async (req, res, next) => {
        const { userId } = req.params;
        const newUser = req.body;
        const result = await User.findByIdAndUpdate(userId, newUser);
        res.status(200).json({ success: true });
    },
    getUserCars: async (req, res, next) => {
        const { userId } = req.params;
        const user = await User.findById(userId).populate('cars');
        res.status(200).json(user.cars);
    },
    newUserCar: async (req, res, next) => {
        const { userId } = req.params;
        // Create a new car
        const newCar = new Car(req.body);
        // Get user
        const user = await User.findById(userId);
        // Assign user as a car's seller
        newCar.seller = user;
        // Save the car
        await newCar.save();
        // Add car to the user's selling array 'cars'
        user.cars.push(newCar);
        // Save the user
        await user.save();        
        res.status(201).json(newCar);
    }
}

controllers/index.js

1
2
3
4
5
6
7
module.exports = {
    index:(req,res,next) => {
        res.status(200).json({
            message:'You are request index page.'
        });
    }
}

app.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
const express = require('express');
const logger = require('morgan')
const mongoose = require('mongoose');
const bodyParser = require('body-parser');
mongoose.Promise = global.Promise;
mongoose.connect('mongodb://localhost/APIProject01',{useMongoClient: true});
const app = express();
//Routes
const users = require('./routers/users');
const index = require('./routers/index');
// Middlewares
app.use(logger('dev'));
app.use(bodyParser.json());
//Routes
app.get('/',index);
app.use('/users',users);
//Catch 404 Errors and forword them to error handler
app.use((req,res,next) => {
    const err = new Error('Not Found');
    err.status = 404;
    next(err);
});
//Error handler function
app.use((err,req,res,next) => {
    //Response to client
    const error = app.get('env') === 'development' ? err : {};
    const status = err.status || 500;
    //Reponse to ourselves
    console.log(err);
    res.status(status).json({
        error:{
            message: error.message
        }
    });
});
//Start the server
const port = app.get('port') || 3000;
app.listen(port,()=> console.log(`Server is listening on port ${port}`));

package.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
{
  "name": "APIProject",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "start": "nodemon app.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "1623695606@qq.com",
  "license": "ISC",
  "dependencies": {
    "body-parser": "^1.17.2",
    "express": "^4.15.4",
    "express-promise-router": "^2.0.0",
    "mongoose": "^4.11.7",
    "morgan": "^1.8.2"
  },
  "devDependencies": {
    "nodemon": "^1.11.0"
  }
}

代码

https://github.com/monk8/expressjs-rest-api-server/tree/lesson07

参考
https://www.bilibili.com/video/av11683622/#page=7