Question

我有两个模型，一个是我的用户模型，另一个是我的课程模型。我希望如此，当用户（教师）创建课程时，它会将课程分配给他们，反之亦然。以下是我的模型，以便更好地解释：

课程架构/模型：

var CourseSchema = new Schema({
    courseID: {
        type: Number,
        unique: true
    },
    courseName: String,
    courseDesc: {
        type: String,
        default: "No course description provided."
    },
    coursePicture: {
        type: String,
        required: false
    },
    teacher: [
        {
           type: mongoose.Schema.Types.ObjectId,
           ref: 'User'
        }
    ],
    students: [
        {
            type: mongoose.Schema.Types.ObjectId,
            ref: 'Student'
         }
    ]
})

用户架构/型号：

var UserSchema = new mongoose.Schema({  
  firstName: String,
  lastName: String,
  email: String,
  courses: [
    {
       type: mongoose.Schema.Types.ObjectId,
       ref: 'Course'
    }
  ], 
  password: String
});

基本上，我希望在我的前端拥有它，我可以做一些事情，比如course.teacher.firstName或user.courses。我的模式有两个不同的文件，但我相信这很好。这就像在用户创建帖子时为其分配帖子一样。我不知道如何做到这一点，因为我已尝试过多种方法。

现在，我目前正在创建一门课程。

// Creates a new course
router.post('/create', function (req, res) {
    Course.create({
            courseID : req.body.courseID,
            courseName : req.body.courseName,
            courseDesc : req.body.courseDesc,
            coursePicture : req.body.coursePicture,
            teacher : req.body.id,
            students: req.body.students
        }, 
        function (err, course) {
            if (err) return res.status(500).send("There was a problem adding the information to the database.");
            res.status(200).send(course);

        });
});

我已经在代码^所属的控制器中引用了User模型，因此var User = require（＆＃39; ../ user / User＆＃39;）; 我认为需要这样做。如果您有任何疑问，请告诉我，因为我不是最好的解释这样的事情。

希望有人可以帮助我！

感谢。

Answer 1

// Creates a new course
router.post('/create', function (req, res) {
    Course.create({
            courseID : req.body.courseID,
            courseName : req.body.courseName,
            courseDesc : req.body.courseDesc,
            coursePicture : req.body.coursePicture,
            teacher : req.body.id, // find this user
            students: req.body.students,
            attendance: req.body.attendance 
        }, 
        function (err, course) {
            User.findById(req.body.id, function(err, user) {
                user.update({
                    $push: {
                        courses: course._id
                    }
                }, function(err) {
                     if (err) return res.status(500).send("There was a problem adding the information to the database.");
                     res.status(200).send(course);
                })
            })
        });
});

Answer 2

这是数据库设计的问题。应该只有一个地方存储有关课程的信息，课程表和用户表应该对课程一无所知。应该有一个表与用户相关的课程：UserCourseRelations表。

我会强烈避免在用户表中存储用户相关的courseIds数组的方法，因为这是不必要的耦合，因此不是好的数据库设计。此外，当这些数组在每一行上增长时，它会对您的Users表进行读取操作。

在这里，我将如何处理这个问题。请注意，此代码中的某些代码使用ES6语法。以下代码未经测试，但应该可以使用。看看：

创建CourseSchema和CourseModel

var CourseSchema = new mongoose.Schema({
    courseID: {
        type: Number,
        unique: true
    },
    courseName: String,
    courseDesc: {
        type: String,
        default: "No course description provided."
    },
    teacherId: {
        type: mongoose.Schema.Types.ObjectId,
    }
    coursePicture: {
        type: String,
        required: false
    },
    students: [
        {
            type: mongoose.Schema.Types.ObjectId,
            ref: 'Student'
        }
    ]
})

CourseSchema.statics.createNew = function(data, callback) {
    // do some verification here

    // insert the new course
    return new this(data).save((err, dbCourse) => {
        if (err) {
            return callback(err)
        }

        UserCourseRelationSchema.insertNew('teacher', userId, courseID, (err, dbUserCourseRelation) => {
            if (err) {
                return callback(err)
            }

            // done. return the new course
            callback(null, dbCourse)
        })
    })

    CourseSchema.statics.getByIds = function(courseIDs, callback) {
        // find all of the courses where the courseID is in the courseIDs array
        // see https://docs.mongodb.com/manual/reference/operator/query/in/
        this.find({courseID: {$in: courseIDs}}, (err, courses) => {
            if (err) {
                // something went wrong
                return callback(err)
            }
            callback(null, courses)
        })
    }
}

let CourseModel mongoose.model('courses', CourseSchema);

创建将课程与用户相关联的UserCourseRelationSchema和UserCourseRelationModel，反之亦然

var UserCourseRelationSchema = new mongoose.Schema({  
    userId: {
        type: String,
        required: true,
    },
    courseID: {
        type: Number,
        required: true,
    },
    type: {
        type: String,
        enum: ['teacher', 'student'],
        required: true,
    },
});

UserCourseRelationSchema.statics.createNew = function(type, courseID, userId, callback) {
    // do some verification here. I suggest making sure this relation doesn't already exist

    // insert the new course
    return new this({
        courseID: courseID,
        userId: userId,
        type: type,
    }).save((err, dbUserCourseRelation) => {
        if (err) {
            return callback(err)
        }

        // return the new relation
        callback(null, dbRelation)
    })
}

UserCourseRelationSchema.statics.getTeacherRelationCourseIdsByUserId = function(userId, callback) {
    let query = this.find({userId: userId, type: 'teacher'})
    query.distinct('courseID') // get an array of only the distinct courseIDs
    query.exec((err, courseIDs) => {
        if (err) {
            // something went wrong
            return callback(err)
        }
        callback(null, courseIDs)
    })
}

let UserCourseRelationModel = mongoose.model('user_course_relations', UserCourseRelationSchema);

创建UserSchema和UserModel

var UserSchema = new mongoose.Schema({  
    firstName: String,
    lastName: String,
    email: String,
    password: String
});

UserSchema.statics.getAllCoursesById = function(userId, callback) {
    // get the relations for the courses the user is a teacher of
    UserCourseRelationModel.getTeacherRelationCourseIdsByUserId(userId, (err, courseIDs) => {
        // get the courses by the returned coursIDs
        CourseModel.getByIds(courseIDs, (err, courses) => {
            if (err) {
                // something went wrong
                return callback(err)
            }
            callback(nul, courses)
        })
    })
}

let UserModel = mongoose.model('users', UserSchema);

// -- create the router

// Creates a new course
router.post('/create', function (req, res) {
    CourseModel.createNew({
        courseID : req.body.courseID,
        courseName : req.body.courseName,
        courseDesc : req.body.courseDesc,
        coursePicture : req.body.coursePicture,
        teacher : req.body.id,
        students: req.body.students
    }, function (err, course) {
        if (err) return res.status(500).send("There was a problem adding the information to the database.");
        res.status(200).send(course);
    });
});

 // -- done

我还建议尽可能使用promises，因为它使所有这些逻辑变得更加简单。

如何使用Express / Mongoose

2 个答案: