MEAN Stack (Angular 2.

x)
Duration: 6 days
Pre requisite: Good knowledge of Javascript Design Patterns,DOM,AJAX & CSS would be good to have.
_________________________________________________________________________
Day -1:
Introduction:
Three-tier web application development
The evolution of JavaScript
Introduction to ECMAScript 2015
Modules
Classes
Arrow functions
Let and Const
Default, Rest, and Spread

Introducing MEAN:
Installing MongoDB
Installing MongoDB on Windows
Running MongoDB manually
Running MongoDB as a Windows service
Installing MongoDB on Mac OS X and Linux
Installing MongoDB from binaries
Installing MongoDB using a package manager
Using the MongoDB shell
Installing Node.js
Installing Node.js on Windows
Installing Node.js on Mac OS X
Installing Node.js on Linux
Running Node.js
Introducing npm
Using npm
The installation process of npm
Installing a package using npm
Removing a package using npm
Updating a package using npm
Managing dependencies using the package.json file
Creating a package.json file
Installing the package.json dependencies
Updating the package.json file

Getting Started with Node.js:

Introduction to Node.js
io.js and the Node.js foundation
Node.js ES6 support
Node.js LTS support
JavaScript event-driven programming
 Node.js event-driven programming
JavaScript Closures
Node modules
CommonJS modules
Node.js core modules
Node.js third-party modules
Node.js file modules
Node.js folder modules
Developing Node.js web applications
Meet the Connect module
Connect middleware
Understanding the order of Connect middleware
Mounting Connect middleware

Building an Express Web Application:

Introducing Express
Installing Express
Creating your first Express application
The application, request, and response objects
The application object
The request object
The response object
External middleware
Implementing the MVC pattern
The application folder structure
Horizontal folder structure
Vertical folder structure
File-naming conventions
Implementing the horizontal folder structure
Handling request routing
Adding the routing file
Configuring an Express application
Environment configuration files
Rendering views
Configuring the view system
Rendering EJS views
Serving static files
Configuring sessions

Introduction to MongoDB:
Introduction to NoSQL
Introducing MongoDB
Key features of MongoDB
The BSON format
MongoDB ad hoc queries
MongoDB indexing
MongoDB replica set
MongoDB sharding
MongoDB 3.0
MongoDB shell
MongoDB databases
MongoDB collections
MongoDB CRUD operations
Creating a new document
Creating a document using insert ()
Creating a document using update ()
Creating a document using save ()
Reading documents
Finding all the collection documents
Using an equality statement
Using query operators
Building AND/OR queries
Updating existing documents
Updating documents using update ()
Updating documents using save ()
Deleting documents
Deleting all documents
Deleting multiple documents
Deleting a single document
Day -2:
Introduction to Mongoose:
Introducing Mongoose
Installing Mongoose
Connecting to MongoDB
Understanding Mongoose schemas
Creating the user schema and model
Registering the User model
Creating new users using save ()
Finding multiple user documents using find ()
Advanced querying using find ()
Reading a single user document using findOne ()
Updating an existing user document
Deleting an existing user document
Extending your Mongoose schema
Defining default values
Using schema modifiers
Predefined modifiers
Custom setter modifiers
Custom getter modifiers
Adding virtual attributes
Optimizing queries using indexes
Defining custom model methods
Defining custom static methods
Defining custom instance methods
Model validation
Predefined validators
Custom validators
Using Mongoose middleware
Using pre middleware
Using post middleware
Using Mongoose ref fields

Managing User Authentication Using Passport:

Introducing Passport
Installing Passport
Configuring Passport
Understanding Passport strategies
Using Passport's local strategy
Installing Passport's local strategy module
Configuring Passport's local strategy
Adapting the User model
Creating the authentication views
Modifying the Users controller
Displaying flash error messages
Installing the Connect-Flash module
 Configuring Connect-Flash module
Using Connect-Flash module
Wiring the user's routes
Understanding Passport OAuth strategies
Setting up OAuth strategies
Handling OAuth user creation
Using Passport's Facebook strategy
Installing Passport's Facebook strategy
Configuring Passport's Facebook strategy
Wiring Passport's Facebook strategy routes
Using Passport's Twitter strategy
Installing Passport's Twitter strategy
Configuring Passport's Twitter strategy
Wiring Passport's Twitter strategy routes
Using Passport's Google strategy
Installing Passport's Google strategy
Configuring Passport's Google strategy
Wiring Passport's Google strategy routes

Introduction to Angular 2:
Introducing Angular 2
From Angular 1.x to Angular 2.x
Introduction to TypeScript
Types
Basic types
The any type
Interfaces
Decorators
Day -3:
Angular 2 Architecture:
Angular 2 Modules
Angular 2 Components
Angular 2 Templates
Angular 2 data binding
Interpolation binding
Property binding
Event binding
Two-way binding
Angular 2 Directives
Attribute directives
Structural directives
Component directives
Angular 2 Services
Angular 2 Dependency Injection
Using Dependency Injection in Angular 2
Angular 2 Routing
Setup
Routes
Router outlet
Router links

The project setup:

Configuring Typescript
Configuring Express
Restructuring the application
Creating the application module
Creating the application component
Bootstrapping the application module
Starting your Angular application
Managing authentication
Rendering the user object
Modifying the users' server controller
Creating the authentication module
Creating the authentication component
Configuring the authentication routes
Creating the sign in component
Creating the signup component
Creating the authentication service
Creating the home module
Creating the home component
Configuring the home routes
Refactoring the application module
Configuring the application routes
Day -4:
Creating a MEAN CRUD Module:
Introducing CRUD modules
Setting up the Express components
Creating the Mongoose model
Setting up the Express controller
The error handling method of the Express controller
The create () method of the Express controller
The list () method of the Express controller
The read () middleware of the Express controller
The update () method of the Express controller
The delete () method of the Express controller
Implementing an authentication middleware
Implementing an authorization middleware
Wiring the Express routes
Configuring the Express application
Using the HTTP client
Reactive programming and Observables
The Reactive X library
Using the http client
Implementing the Angular module
Creating the Angular module service
Implementing the Create subcomponent
Adding the template
Implementing the View subcomponent
Adding the template
Implementing the Edit subcomponent
Adding the template
Implementing the List subcomponent
Adding the template
Wrapping up

Adding Real-time Functionality Using Socket.io:

Introducing Web Sockets
Introducing Socket.io
The Socket.io server object
Socket.io handshaking
The Socket.io configuration middleware
The Socket.io client object
Socket.io events
Handling events
Emitting events
Socket.io namespaces
Socket.io server namespaces
Socket.io client namespaces
Socket.io rooms
 Joining and leaving rooms
Emitting events to rooms
Installing Socket.io
Configuring the Socket.io server
Configuring the Socket.io session
Installing the connect-mongo and cookie-parser modules
Configuring the connect-mongo module
Configuring the Socket.io session
Building a Socket.io chat
Setting the event handlers of the chat server
Creating the Chat Angular module
Setting up the Socket.io client library
Creating the Chat module
Creating the Chat service
Creating the Chat component
Creating the Chat template
Adding the Chat routing configuration
Using the Chat module

Auction Application:
Setting up the base app
What we are building
Data modeling
Auction
Bidder
Auction backend
The Mediator
Auction manager
Auctioneer
Using the service from controller
Accessing data from the e-commerce API
E-commerce client service
Frontend services
Auction service
The socket service
The bid service
The bidder service
The Auction module
The base component
The auction list
The detail page
The bid module
Listing bids
The bid component
Day -5:
Expense Tracker:
Setting up the base application
Installing the dependencies
Creating the base configuration files
Creating the main server.js file
Setting up the user section
Describing the user model
Implementing the user model
Authenticating users
Describing the authentication strategies
Implementing the token generation
Persisting tokens in MongoDB
Authentication using HTTP Basic
Adding authentication routes
Verifying users using bearer authentication
Bearer strategy
Protecting resources using tokens
Tracking expenses
Monetary values
The category model
Categories routes
Getting the category by ID
Creating a category
Getting one and all categories
Updating and deleting a category
Defining the expense model
Describing the expense module functionality
CRUD operations for expenses
Create expense
Get expense by ID
Get one expense
Get all expenses
Update expense
Delete expense
Getting the expense balance
Implementing the Angular client application
Bootstrapping the project
Registering users
The auth service
Register component
Sign-in-user component
Common functionalities
Custom HTTP service
Using a single export file
The categories module
 Category service
The categories component
Create a new category
List all categories
The category component
The expenses module
Expense service
Filter expenses
Add a new expense
List expenses
Display balance
Expenses component

Contact Manager:
Setting up the base application
Folder structure
Server-side package.json
The first application file
Creating the Express configuration file
Setting up mocha for testing
Setting up Mongoose
Managing contacts
Creating the contact mongoose schema
Describing the contact route
Creating a contact
Getting contacts
Getting a contact by ID
Updating a contact
Removing a contact
Running our tests
Implementing the contact routes
Adding all endpoints
Finding a contact by ID
Getting contact information
Updating a contact
Removing a contact
Running the contact test
Securing your application routes
Describing the password helper
Implementing the password helper
Creating the user Mongoose schema
Describing the authentication method from the user model
Implementing the authentication method
Authentication routes
Describing the authentication routes
Integrating Passport
Implementing the authentication routes
Restricting access to contacts routes
Integrating Angular 2 into our application
Granting access to our application
AuthService
User sign-in component
Custom HTTP service
The Contact module
Contact service
Contact component
List contacts component
Creating a contact component
Editing an existing contact
Finishing touch
Day -6:
Job Board:
Setting up the base application
Modifying the user backend
Modifying the user model
An authorization policy
The company backend module
The company model
The company controller
Creating a company
Getting a company by ID
Getting all companies
Updating a company
Adding a company member
Removing a company member
Company routes
The job backend module
The job model
Job controller
Adding a new job for a company
Finding a job by ID
Getting all jobs
Updating a specific job
Job routes
Getting one and all jobs
Creating a route
Updating a route
Job applications
The application model
Controller logic
Applying for a job
Finding a given application by ID
Getting all job applications
Updating an application
Removing an application from a job
Creating a new company
The company service
Creating a company component
Displaying companies
The job module
The job service
The job base component
The jobs component
The job list component
Job details
Adding new jobs
 Company details
User profile
Profile backend
Synchronizing profile data
Editing profile data
The profile block component
Extra models

Testing MEAN Applications:

Introducing JavaScript testing
TDD, BDD, and unit testing
Test frameworks
Assertion libraries
Test runners
Testing your Express application
Introducing Mocha
Introducing Should.js
Introducing SuperTest
Installing Mocha
Installing the Should.js and SuperTest modules
Configuring your test environment
Writing your first Mocha test
Testing the Express model
Testing the Express controller
Running your Mocha test
Testing your Angular application
Introducing the Jasmine framework
Angular unit tests
Introducing Karma test runner
Installing the Karma command-line tool
Installing Karma's dependencies
Configuring the Karma test runner
Writing Angular unit tests
Testing components
Mocking backend data
Testing services
Testing routes
Testing directives
Testing pipes
Running your Angular unit tests
Angular E2E tests
Introducing the Protractor test runner
Installing the Protractor test runner
Configuring the Protractor test runner
Writing your first E2E test
Running your Angular E2E tests
Automating and Debugging MEAN Applications:
Using NPM scripts
Introducing Webpack
Installing Webpack
Configuring Webpack
Introducing ESLint
Installing ESLint
Configuring ESLint
Using Nodemon
Debugging Express with V8 inspector
Debugging your application
Debugging Angular applications with Angular Augury
Using Angular Augury
The component tree
Router tree