用平均堆栈构建一些简单的测试项目论坛

Question

我现在让我当前的项目工作有点麻烦...我知道在结构方面我没有遵循一些最佳实践，但这仅仅是对功能的测试，直到我可以让它工作，然后我会正确地构建它。

我正在建设一个简单的论坛，包括董事会，帖子和评论。我基于这个thinkster.io教程，https://thinkster.io/mean-stack-tutorial#opening-rest-routes。

我运作的董事会和职位，但添加评论是另一回事。我尝试添加一个新的Comment模式并定义一些服务器端路由以允许我获取和发布注释，但这没有用。现在我的策略是将注释放在我的mongoose postSchema中，然后隐藏它们和注释表单，或者在用户单击视图注释按钮时用角度注入html。这不起作用，因为我的提交不更新视图或数据库。这是我正在使用的。

app.js

(function() {
angular.module('test', ['ui.router', 'ngMaterial'])
.config(['$stateProvider', '$urlRouterProvider', function ($stateProvider, $urlRouterProvider) {
    $stateProvider
        .state('home', {
            url: '/home',
            templateUrl: '/views/home/home.html',
            controller: 'MainController',
            resolve: {
                boardPromise: ['boards', function (boards) {
                    return boards.getAll();
                }]
            }
        })

        .state('boards', {
            url: '/boards/{id}',
            templateUrl: '/views/posts/posts.html',
            controller: 'PostsController',
            resolve: {
                board: ['$stateParams', 'boards', function ($stateParams, boards) {
                    return boards.get($stateParams.id);
                }]
            }
        });



    $urlRouterProvider.otherwise('home');
}]);
}());

然后我的控制器如下：

主控制器

(function () {
angular.module('test')
.controller('MainController', ['$scope', 'boards', function($scope, boards) {
    $scope.boards = boards.boards;

    $scope.addBoard = function() {
        if ($scope.title === '') {
            return;
        }
        boards.create({
            title: $scope.title,
            description: $scope.description,
        });

        $scope.title = '';
        $scope.description = '';
    };
}]);
}());

帖子控制器

(function() {
'use strict';

angular.module('test')
.controller('PostsController', ['$scope', 'boards', 'board', function ($scope,                  boards, board) {
    $scope.board = board;

    $scope.addPost = function() {
        if ($scope.body === '') {
            return;
        }

        boards.addPost(board._id, {
            body: $scope.body,
            author: 'user',
        }).success(function (post) {
            $scope.board.posts.push(post);
        });
        $scope.body = '';
    };

    $scope.addComment = function() {
        if ($scope.commentts === '') {
            return;
        }

        boards.addComment(board._id, {
            comments: $scope.comments,
            author: 'user',
        }).success(function (comment) {
            $scope.board.posts.comments.push(comment);
        })
        $scope.comments = ''
    };
}]);
}());

处理我的$ http，

的服务

(function() {
'use strict';

angular.module('test')
.factory('boards', [ '$http', function($http) {
    var o = {
        boards: []
    };

    o.getAll = function() {
        return $http.get('/boards').success(function (data) {
            angular.copy(data, o.boards);
        });
    };

    o.create = function(board) {
        return $http.post('/boards', board).success(function (data) {
            o.boards.push(data);
        });
    };

    o.get = function(id) {
        return $http.get('/boards/' + id).then(function (res) {
            return res.data;
        });
    };

    o.addPost = function (id, post) {
        return $http.post('/boards/' + id + '/posts', post);
    };

    o.addComment = function (id, comment) {
        return $http.post('/boards/' + id + '/posts', comment);
    };


    return o;
}]);
}());

这是我后端的相关部分：

'use strict';

var mongoose = require('mongoose'),
Board = mongoose.model('Board'),
Post = mongoose.model('Post');

module.exports = function (app) {

app.get('/boards', function (req, res, next) {
    Board.find(function (err, boards) {
        if (err) {
            return next(err);
        }

        res.json(boards);
    });
});

app.post('/boards', function (req, res, next) {
    var board = new Board(req.body);

    board.save( function (err, board) {
        if (err) {
            return next(err);
        }

        res.json(board);
    });
});

app.param('board', function (req, res, next, id) {
    var query = Board.findById(id);

    query.exec(function (err, board) {
        if (err) {
            return next(err);
        }

        if (!board) {
            return next(new Error('can\'t find the boards'));
        }

        req.board = board;
        return next();
    });
});

app.param('post', function (req, res, next, id) {
    var query = Post.findById(id);

    query.exec = function (err, post) {
        if (err) {
            return next(err);
        }

        if (!post) {
            return next(new Error('can\'t find the post'));
        }

        req.post = post;
        return next();
    };
});

app.param('comment', function (req, res, next, id) {
    var query = Comment.findById(id);

    query.exec = function (err, comment) {
        if (err){
            return next(err);
        }

        if (!comment) {
            return next(new Error('can\'t find the comment'));
        }

        req.comment = comment;
        return next();
    };
});

app.get('/boards/:board', function (req, res, next) {
    req.board.populate('posts', 'comments', function (err, board) {
        if (err) {
            return next(err);
        }
        res.json(board);
    });
});

app.post('/boards/:board/posts', function (req, res, next) {
    var post = new Post(req.body);
    post.board = req.board;

    post.save(function (err, post) {
        if (err) {
            return next(err);
        }

        req.board.posts.push(post);
        req.board.save(function (err, board) {
            if (err) {
                return next(err);
            }

            res.json(post);
        });
    });
});

};

以及相应的模式：

Board架构：

'use strict';

var mongoose = require('mongoose'),
Schema = mongoose.Schema;

var boardSchema = new Schema({
  title: String,
  description: String,
  posts: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Post'
  }]
});

mongoose.model('Board', boardSchema);

和Post架构：

'use strict';

var mongoose = require('mongoose'),
Schema = mongoose.Schema;

var postSchema = new Schema({
  body: String,
  author: String,
  comments: {
    type: String,
  },
  board: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Board'
  },
});

mongoose.model('Post', postSchema);

感谢任何帮助。我对使用angular和MEAN堆栈相当新，但我真的希望变得更好。你们可能给我的任何信息肯定会提高我的理解力。非常感谢！ ：）

Answer 1

comments架构的Post字段定义为单个字符串。这意味着每个新评论都会覆盖前一个评论。它应该被定义为字符串数组：

Post架构

var postSchema = new Schema({
  body: String,
  author: String,
  comments: [{
    type: String,
  }],
  board: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Board'
  },
});

mongoose.model('Post', postSchema);