In order to handle Mongoose errors, it is preferable to write a simple error handling method that will take care of extracting a simple error message from the Mongoose error object and provide it to your controller methods. Go back to your app/controllers/articles.server.controller.js file and append the following lines of code:

var getErrorMessage = function(err) {
  if (err.errors) {
    for (var errName in err.errors) {
      if (err.errors[errName].message) return err.errors[errName].message;
    }
  } else {
    return 'Unknown server error';
  }
};

The getErrorMessage() method gets the Mongoose error object passed as an argument then iterates over the errors collection and extract the first message. This is done because you don't want to overwhelm your users with multiple error messages at once. Now that you have error handling set up, it is time to write your first controller method.

The create() method of the Express controller will provide the basic functions to create a new article document. It will use the HTTP request body as the JSON base object for the document and will use the model save() method to save it to MongoDB. To implement the create() method, append the following lines of code in your app/controllers/articles.server.controller.js file:

exports.create = function(req, res) {
  var article = new Article(req.body);
  article.creator = req.user;

  article.save(function(err) {
    if (err) {
      return res.status(400).send({
        message: getErrorMessage(err)
      });
    } else {
      res.json(article);
    }
  });
};

Let's go over the create() method code. First, you created a new Article model instance using the HTTP request body. Next, you added the authenticated Passport user as the article creator(). Finally, you used the Mongoose instance save() method to save the article document. In the save() callback function, it is worth noticing how you either return an error response and an appropriate HTTP error code or the new article object as a JSON response. Once you're done with the create() method, you will move on to implement the read operation. The read operation consists of two methods, one that retrieves a list of articles and a second method that retrieves a particular article. Let's begin with the method that lists a collection of articles.

The list() method of the Express controller will provide the basic operations to retrieve a list of existing articles. It will use the model's find() method to retrieve all the documents in the articles collection then output a JSON representation of this list. To implement the list() method, append the following lines of code in your app/controllers/articles.server.controller.js file:

exports.list = function(req, res) {
  Article.find().sort('-created').populate('creator', 'firstName   lastName fullName').exec(function(err, articles) {
    if (err) {
      return res.status(400).send({
        message: getErrorMessage(err)
      });
    } else {
      res.json(articles);
    }
  });
};

In this controller method, notice how you used the find() function of Mongoose to get the collection of article documents, and while we could add a MongoDB query of some sort, for now we'll retrieve all the documents in the collection. Next, you'll notice how the articles collection is sorted using the created property. Then, you can see how the populate() method of Mongoose was used to add some user fields to the creator property of the articles objects. In this case, you populated the firstName, lastName, and fullName properties of the creator user object.

The rest of the CRUD operations involve a manipulation of a single existing article document. You could of course implement the retrieval of the article document in each method by itself, basically repeating this logic. However, the Express router has a neat feature for handling route parameters, so before you'll implement the rest of your Express CRUD functionality, you'll first learn how to leverage the route parameter middleware to save some time and code redundancy.

The read() method of the Express controller will provide the basic operations to read an existing article document from the database. Since you're writing a sort of a RESTful API, the common usage of this method will be handled by passing the article's ID field as a route parameter. This means that your requests to the server will contain an articleId parameter in their paths.

Fortunately, the Express router provides the app.param() method for handling route parameters. This method allows you to attach a middleware for all requests containing the articleId route parameter. The middleware itself will then use the articleId provided to find the proper MongoDB document and add the retrieved article object to the request object. This will allow all the controller methods that manipulate an existing article to obtain the article object from the Express request object. To make this clearer, let's implement the route parameter middleware. Go to your app/controllers/articles.server.controller.js file and append the following lines of code:

exports.articleByID = function(req, res, next, id) {
  Article.findById(id).populate('creator', 'firstName lastName fullName').exec(function(err, article) {
    if (err) return next(err);
    if (!article) return next(new Error('Failed to load article ' + id));

    req.article = article;
    next();
  });
};

As you can see, the middleware function signature contains all the Express middleware arguments and an id argument. It then uses the id argument to find an article and reference it using the req.article property. Notice how the populate() method of the Mongoose model was used to add some user fields to the creator property of the article object. In this case, you populated the firstName, lastName, and fullName properties of the creator user object.

When you connect your Express routes, you'll see how to add the articleByID() middleware to different routes, but for now let's add the read() method of the Express controller, which will return an article object. To add the read() method, append the following lines of code to your app/controllers/articles.server.controller.js file:

exports.read = function(req, res) {
  res.json(req.article);
};

Quite simple, isn't it? That's because you already took care of obtaining the article object in the articleByID() middleware, so now all you have to do is just output the article object as a JSON representation. We'll connect the middleware and routes in next sections but before we'll do that, let's finish implementing the Express controller CRUD functionality.

The update() method of the Express controller will provide the basic operations to update an existing article document. It will use the existing article object as the base object, and then update the title and content fields using the HTTP request body. It will also use the model save() method to save the changes to the database. To implement the update() method, go to your app/controllers/articles.server.controller.js file and append the following lines of code:

exports.update = function(req, res) {
  var article = req.article;

  article.title = req.body.title;
  article.content = req.body.content;

  article.save(function(err) {
    if (err) {
      return res.status(400).send({
        message: getErrorMessage(err)
      });
    } else {
      res.json(article);
    }
  });
};

As you can see, the update() method also makes the assumption that you already obtained the article object in the articleByID() middleware. So, all you have to do is just update the title and content fields, save the article, and then output the updated article object as a JSON representation. In case of an error, it will output the appropriate error message using the getErrorMessage() method you wrote before and an HTTP error code. The last CRUD operation left to implement is the delete() method; so let's see how you can add a simple delete() method to your Express controller.

The delete() method of the Express controller will provide the basic operations to delete an existing article document. It will use the model remove() method to delete the existing article from the database. To implement the delete() method, go to your app/controllers/articles.server.controller.js file and append the following lines of code:

exports.delete = function(req, res) {
  var article = req.article;

  article.remove(function(err) {
    if (err) {
      return res.status(400).send({
        message: getErrorMessage(err)
      });
    } else {
      res.json(article);
    }
  });
};

Again, you can see how the delete() method also makes use of the already obtained article object by the articleByID() middleware. So, all you have to do is just invoke the Mongoose model's remove() method and then output the deleted article object as a JSON representation. In case of an error, it will instead output the appropriate error message using the getErrorMessage() method you wrote before and an HTTP error code.

Congratulations! You just finished implementing your Express controller's CRUD functionality. Before you continue to wire the Express routes that will invoke these methods, let's take some time to implement two authorization middleware.

While building your Express controller, you probably noticed that most methods require your user to be authenticated. For instance, the create() method won't be operational if the req.user object is not assigned. While you can check this assignment inside your methods, this will enforce you to implement the same validation code over and over. Instead you can just use the Express middleware chaining to block unauthorized requests from executing your controller methods. The first middleware you should implement will check whether a user is authenticated at all. Since it is an authentication-related method, it would be best to implement it in the Express users controller, so go to the app/controllers/users.server.controller.js file and append the following lines of code:

exports.requiresLogin = function(req, res, next) {
  if (!req.isAuthenticated()) {
    return res.status(401).send({
      message: 'User is not logged in'
    });
  }

  next();
};

The requiresLogin() middleware uses the Passport initiated req.isAuthenticated() method to check whether a user is currently authenticated. If it finds out the user is indeed signed in, it will call the next middleware in the chain; otherwise it will respond with an authentication error and an HTTP error code. This middleware is great, but if you want to check whether a specific user is authorized to perform a certain action, you will need to implement an article specific authorization middleware.

In your CRUD module, there are two methods that edit an existing article document. Usually, the update() and delete() methods should be restricted so that only the user who created the article will be able to use them. This means you need to authorize any request made to these methods to validate whether the current article is being edited by its creator. To do so, you will need to add an authorization middleware to your Articles controller, so go to the app/controllers/articles.server.controller.js file and append the following lines of code:

exports.hasAuthorization = function(req, res, next) {
    if (req.article.creator.id !== req.user.id) {
        return res.status(403).send({
            message: 'User is not authorized'
        });
    }
    next();
};

The hasAuthorization() middleware is using the req.article and req.user objects to verify that the current user is the creator of the current article. This middleware also assumes that it gets executed only for requests containing the articleId route parameter. Now that you have all your methods and middleware in place, it is time to wire the routes that enable their execution.

The create() method of our AngularJS controller will provide the basic operations for creating a new article. To do so, it will use the title and content form fields from the view that called the method, and it will use the Articles service to communicate with the corresponding RESTful endpoint and save the new article document. To implement the create() method, go to your public/articles/controllers/articles.client.controller.js file and append the following lines of code inside your controller's constructor function:

$scope.create = function() {
  var article = new Articles({
    title: this.title,
    content: this.content
  });

  article.$save(function(response) {
    $location.path('articles/' + response._id);
  }, function(errorResponse) {
    $scope.error = errorResponse.data.message;
  });
};

Let's go over the create() method functionality. First, you used the title and content form fields, and then the Articles resource service to create a new article resource. Then, you used the article resource $save() method to send the new article object to the corresponding RESTful endpoint, along with two callbacks. The first callback will be executed when the server responds with a success (200) status code, marking a successful HTTP request. It will then use the $location service to navigate to the route that will present the created article. The second callback will be executed when the server responds with an error status code, marking a failed HTTP request. The callback will then assign the error message to the $scope object, so the view will be able to present it to the user.

Your controller will contain two read methods. The first will take care of retrieving a single article and the second will retrieve a collection of articles. Both methods will use the Articles service to communicate with the corresponding RESTful endpoints. To implement these methods, go to your public/articles/controllers/articles.client.controller.js file and append the following lines code inside your controller's constructor function:

$scope.find = function() {
  $scope.articles = Articles.query();
};

$scope.findOne = function() {
  $scope.article = Articles.get({
    articleId: $routeParams.articleId
  });
};

In the preceding code, you defined two methods: the find() method that will retrieve a list of articles and a findOne() method that will retrieve a single article based on the articleId route parameter, which the function obtains directly from the URL. The find() method uses the resource query() method because it expects a collection, while the findOne() method is using the resource get() method to retrieve a single document. Notice how both methods are assigning the result to the $scope variable so that views could use it to present the data.

The update() method of the AngularJS controller will provide the basic operations for updating an existing article. To do so, it will use the $scope.article variable, then update it using the view inputs, and the Articles service to communicate with the corresponding RESTful endpoint and save the updated document. To implement the update() method, go to your public/articles/controllers/articles.client.controller.js file and append the following lines of code inside your controller's constructor function:

$scope.update = function() {
  $scope.article.$update(function() {
    $location.path('articles/' + $scope.article._id);
  }, function(errorResponse) {
    $scope.error = errorResponse.data.message;
  });
};

In the update() method, you used the resource article's $update() method to send the updated article object to the corresponding RESTful endpoint, along with two callbacks. The first callback will be executed when the server responds with a success (200) status code, marking a successful HTTP request. It will then use the $location service to navigate to the route that will present the updated article. The second callback will be executed when the server responds with an error status code, marking a failed HTTP request. The callback will then assign the error message to the $scope object so that the view will be able to present it to the user.

The delete() method of the AngularJS controller will provide the basic operations for deleting an existing article. Since the user might delete an article from the list view as well as the read view, the method will either use the $scope.article or $scope.articles variables. This means that it should also address the issue of removing the deleted article from the $scope.articles collection if necessary. The Articles service will be used again to communicate with the corresponding RESTful endpoint and delete the article document. To implement the delete() method, go to your public/articles/controllers/articles.client.controller.js file and append the following lines of code inside your controller's constructor function:

$scope.delete = function(article) {
  if (article) {
    article.$remove(function() {
      for (var i in $scope.articles) {
        if ($scope.articles[i] === article) {
          $scope.articles.splice(i, 1);
        }
      }
    });
  } else {
    $scope.article.$remove(function() {
      $location.path('articles');
    });
  }
};

The delete() method will first figure out whether the user is deleting an article from a list or directly from the article view. It will then use the article's $remove() method to call the corresponding RESTful endpoint. If the user deleted the article from a list view, it will then remove the deleted object from the articles collection; otherwise, it will delete the article then redirect the user back to the list view.

Once you finish setting up your controller, the next step is to implement the AngularJS views that will invoke the controller methods, and then connect them to the AngularJS routing mechanism.

The create-article view will provide your user with an interface to create a new article. It will contain an HTML form and will use your controller's create method to save the new article. To create your view, go to the public/articles/views folder and create a new file named create-article.client.view.html. In your new file, paste the following code snippet:

<section data-ng-controller="ArticlesController">
<h1>New Article</h1>
  <form data-ng-submit="create()" novalidate>
    <div>
      <label for="title">Title</label>
      <div>
        <input type="text" data-ng-model="title" id="title" placeholder="Title" required>
      </div>
    </div>
    <div>
      <label for="content">Content</label>
      <div>
        <textarea data-ng-model="content" id="content" cols="30" rows="10" placeholder="Content"></textarea>
      </div>
    </div>
    <div>
      <input type="submit">
    </div>
    <div data-ng-show="error">
      <strong data-ng-bind="error"></strong>
    </div>
  </form>
</section>

The create-article view contains a simple form with two text input fields and a submit button. The text fields use the ng-model directive to bind the user input to the controller scope, and as you specified in the ng-controller directive, this controller will be your ArticlesController. It is also important to notice the ng-submit directive you placed on the form element. This directive tells AngularJS to call a specific controller method when the form is submitted; in this case, the form submission will execute your controller's create() method. The last thing you should notice is the error message at the end of the form that will be shown in case of a creation error.

The view-article view will provide your user with an interface to view an existing article. It will contain a set of HTML elements and will use your controller's findOne() method to get an existing article. Your view will also contain a set of buttons only visible to the article creator that will allow the creator to delete the article or navigate to the update-article view. To create the view, go to the public/articles/views folder and create a new file named view-article.client.view.html. In your new file, paste the following code snippet:

<section data-ng-controller="ArticlesController" data-ng-init="findOne()">
  <h1 data-ng-bind="article.title"></h1>
  <div data-ng-show="authentication.user._id == article.creator._id">
    <a href="/#!/articles/{{article._id}}/edit">edit</a>
    <a href="#" data-ng-click="delete();">delete</a>
  </div>
  <small>
    <em>Posted on</em>
    <em data-ng-bind="article.created | date:'mediumDate'"></em>
    <em>by</em>
    <em data-ng-bind="article.creator.fullName"></em>
  </small>
  <p data-ng-bind="article.content"></p>
</section>

The view-article view contains a simple set of HTML elements presenting the article information using the ng-bind directive. Similar to what you did in the create-article view, you used the ng-controller directive to tell the view to use the ArticlesController. However, since you need to load the article information, your view uses the ng-init directive to call the controller's findOne() method when the view is loaded. It is also important to notice how you used the ng-show directive to present the article edit and delete links only to the creator of the article. The first link will direct the user to the update-article view, while the second one will call the delete() method of your controller.

The edit-article view will provide your user with an interface to update an existing article. It will contain an HTML form and will use your controller's update() method to save the updated article. To create this view go to the public/articles/views folder and create a new file named edit-article.client.view.html. In your new file, paste the following code snippet:

<section data-ng-controller="ArticlesController" data-ng-init="findOne()">
  <h1>Edit Article</h1>
  <form data-ng-submit="update()" novalidate>
    <div>
      <label for="title">Title</label>
      <div>
        <input type="text" data-ng-model="article.title" id="title" placeholder="Title" required>
      </div>
    </div>
    <div>
      <label for="content">Content</label>
      <div>
        <textarea data-ng-model="article.content" id="content" cols="30" rows="10" placeholder="Content"></textarea>
      </div>
    </div>
    <div>
      <input type="submit" value="Update">
    </div>
    <div data-ng-show="error">
      <strong data-ng-bind="error"></strong>
    </div>
  </form>
</section>

The edit-article view contains a simple form with two text input fields and a submit button. In the edit-article view, the text fields use the ng-model directive to bind the user input to the controller's scope.article object. Since you need to load the article information before editing it, your view uses the ng-init directive to call the controller's findOne() method when the view is loaded. It is also important to notice the ng-submit directive you placed on the form element. This time, the directive tells AngularJS that the form submission should execute your controller's update() method. The last thing you should notice is the error message in the end of the form that will be shown in the case of an editing error.

The list-articles view will provide your user with an interface to view the list of existing articles. It will contain a set of HTML elements and will use your controller's find() method to get the collection of articles. Your view will also use the ng-repeat directive to render a list of HTML elements, each representing a single article. If there aren't any existing articles, the view will offer the user to navigate to the create-article view. To create your view, go to the public/articles/views folder and create a new file named list-articles.client.view.html. In your new file, paste the following code snippet:

<section data-ng-controller="ArticlesController" data-ng-init="find()">
  <h1>Articles</h1>
  <ul>
    <li data-ng-repeat="article in articles">
      <a data-ng-href="#!/articles/{{article._id}}" data-ng-bind="article.title"></a>
      <br>
      <small data-ng-bind="article.created | date:'medium'"></small>
      <small>/</small>
      <small data-ng-bind="article.creator.fullName"></small>
      <p data-ng-bind="article.content"></p>
    </li>
  </ul>
 <div data-ng-hide="!articles || articles.length">
    No articles yet, why don't you <a href="/#!/articles/create">create one</a>?
  </div>
</section>

The list-articles view contains a simple set of repeating HTML elements that represent the list of articles. It uses the ng-repeat directive to duplicate the list item for every article in the collection and displays each article's information using the ng-bind directive. In the same way as in other views, you used the ng-controller directive to connect the view to your ArticlesController. However, since you need to load the articles list, your view also uses the ng-init directive to call the controller's find method when the view is loaded. It is also important to notice how you used the ng-hide directive to ask the user to create a new article in case there are no existing articles.

By implementing your AngularJS views, you came very close to finishing your first CRUD module. All that is left to do is wire the module's routes.