MEAN Blueprints

1. MEAN Blueprints
   
2. By: Robert Onodi
   
3. Publisher: Packt Publishing
   
4. Pub. Date: May 30, 2016
   
5. Web ISBN-13: 978-1-78528-580-6
   
6. Print ISBN-13: 978-1-78355-394-5
   
7. Pages in Print Edition: 336
   
8. Subscriber Rating: 0 out of 5 rating [0 Ratings]

复制代码

1. Creating the contact mongoose schema
   
2. Our system needs some sort of functionality to store the possible clients or just contact persons of other companies. For this, we are going to create a contact schema that will represent the same collection storing all the contacts in MongoDB. We are going to keep our contact schema simple. Let's create a model file in contact-manager/app/models/contact.js, which will hold the schema, and add the following code to it:
   
3. 
   
4. 'use strict';
   
5. 
   
6. const mongoose = require('mongoose');
   
7. const Schema = mongoose.Schema;
   
8. 
   
9. var ContactSchema = new Schema({
   
10.   email:  {
    
11.     type: String
    
12.   },
    
13.   name: {
    
14.     type: String
    
15.   },
    
16.   city: {
    
17.     type: String
    
18.   },
    
19.   phoneNumber: {
    
20.     type: String
    
21.   },
    
22.   company: {
    
23.     type: String
    
24.   },
    
25.   createdAt: {
    
26.     type: Date,
    
27.     default: Date.now
    
28.   }
    
29. });
    
30. 
    
31. // compile and export the Contact model
    
32. module.exports = mongoose.model('Contact', ContactSchema);

复制代码

1. 'use strict';
   
2. 
   
3. /**
   
4. * Important! Set the environment to test
   
5. */
   
6. process.env.NODE_ENV = 'test';
   
7. 
   
8. const http = require('http');
   
9. const request = require('request');
   
10. const chai = require('chai');
    
11. const userFixture = require('../fixtures/user');
    
12. const should = chai.should();
    
13. 
    
14. let app;
    
15. let appServer;
    
16. let mongoose;
    
17. let User;
    
18. let Contact;
    
19. let config;
    
20. let baseUrl;
    
21. let apiUrl;
    
22. 
    
23. describe('Contacts endpoints test', function() {
    
24. 
    
25.   before((done) => {
    
26.     // boot app
    
27.     // start listening to requests
    
28.   });
    
29. 
    
30.   after(function(done) {
    
31.     // close app
    
32.     // cleanup database
    
33.     // close connection to mongo
    
34.   });
    
35. 
    
36.   afterEach((done) => {
    
37.     // remove contacts
    
38.   });
    
39. 
    
40.   describe('Save contact', () => {});
    
41. 
    
42.   describe('Get contacts', () => {});
    
43. 
    
44.   describe('Get contact', function() {});
    
45. 
    
46.   describe('Update contact', function() {});
    
47. 
    
48.   describe('Delete contact', function() {});
    
49. });

复制代码

1. Implementing the contact routes
   
2. Now, we'll start implementing the contact CRUD operations. We'll begin by creating our controller. Create a new file, contact-manager/app/controllers/contact.js, and add the following code:
   
3. 
   
4. 'use strict';
   
5. 
   
6. const _ = require('lodash');
   
7. const mongoose = require('mongoose');
   
8. const Contact = mongoose.model('Contact');
   
9. const ObjectId = mongoose.Types.ObjectId;
   
10. 
    
11. module.exports.create = createContact;
    
12. module.exports.findById = findContactById;
    
13. module.exports.getOne = getOneContact;
    
14. module.exports.getAll = getAllContacts;
    
15. module.exports.update = updateContact;
    
16. module.exports.remove = removeContact;
    
17. 
    
18. function createContact(req, res, next) {
    
19.   Contact.create(req.body, (err, contact) => {
    
20.     if (err) {
    
21.       return next(err);
    
22.     }
    
23. 
    
24.     res.status(201).json(contact);
    
25.   });
    
26. }

复制代码

1. Running the contact test
   
2. At this point, we should have implemented all the requirements for managing contacts on the backend. To test everything, we run the following command:
   
3. 
   
4. $ mocha tests/integration/contact.test.js

复制代码

1. Installing the dependencies
   
2. Let's start by creating our package.json file in the root of the project and adding the following code:
   
3. 
   
4. {
   
5.   "name": "mean-blueprints-expensetracker",
   
6.   "version": "0.0.1",
   
7.   "repository": {
   
8.     "type": "git",
   
9.     "url": "https://github.com/robert52/mean-blueprints-expensetracker.git"
   
10.   },
    
11.   "engines": {
    
12.     "node": ">=0.12.0"
    
13.   },
    
14.   "scripts": {
    
15.     "start": "node app.js",
    
16.     "unit": "mocha tests/unit/ --ui bdd --recursive --reporter spec --timeout 10000 --slow 900",
    
17.     "integration": "mocha tests/integration/ --ui bdd --recursive --reporter spec --timeout 10000 --slow 900"
    
18.   },
    
19.   "dependencies": {
    
20.     "async": "^0.9.0",
    
21.     "body-parser": "^1.12.3",
    
22.     "express": "^4.12.4",
    
23.     "express-session": "^1.11.2",
    
24.     "lodash": "^3.7.0",
    
25.     "method-override": "^2.3.2",
    
26.     "mongoose": "^4.0.2",
    
27.     "passport": "^0.2.1",
    
28.     "passport-local": "^1.0.0",
    
29.     "serve-static": "^1.9.2"
    
30.   },
    
31.   "devDependencies": {
    
32.     "chai": "^2.3.0",
    
33.     "chai-things": "^0.2.0",
    
34.     "mocha": "^2.2.4",
    
35.     "request": "^2.55.0"
    
36.   }
    
37. }

复制代码

1. Creating the main server.js file
   
2. The main entry point for our application is the server.js file. Create it in the root of the project. This file starts the web server and bootstraps all of the logic. Add the following lines of code:
   
3. 
   
4. 'use strict';
   
5. 
   
6. // Get process environment or set default environment to development
   
7. const ENV = process.env.NODE_ENV || 'development';
   
8. const DEFAULT_PORT = 3000;
   
9. const DEFAULT_HOSTNAME = 'localhost';
   
10. 
    
11. const http = require('http');
    
12. const express = require('express');
    
13. const config = require('./config');
    
14. const app = express();
    
15. let server;
    
16. 
    
17. /**
    
18. * Set express (app) variables
    
19. */
    
20. app.set('config', config);
    
21. app.set('root', __dirname);
    
22. app.set('env', ENV);
    
23. 
    
24. require('./config/mongoose').init(app);
    
25. require('./config/models').init(app);
    
26. require('./config/passport').init(app);
    
27. require('./config/express').init(app);
    
28. require('./config/routes').init(app);
    
29. 
    
30. app.use((err, req, res, next) => {
    
31.   res.status(500).json(err);
    
32. });
    
33. 
    
34. /**
    
35. * Start the app if not loaded by another module
    
36. */
    
37. if (!module.parent) {
    
38.    server = http.createServer(app);
    
39.    server.listen(
    
40.      config.port || DEFAULT_PORT,
    
41.      config.hostname || DEFAULT_HOSTNAME,
    
42.      () => {
    
43.        console.log(`${config.app.name} is running`);
    
44.        console.log(`   listening on port: ${config.port}`);
    
45.        console.log(`   environment: ${ENV.toLowerCase()}`);
    
46.      }
    
47.    );
    
48. }
    
49. 
    
50. module.exports = app;

复制代码