AngularJS

Agenda
• Introduction to AngularJS
• Single Page Application (SPA)
• Downloading AngularJS and Understanding API
• Directives, Filters and Data Binding
– Using Directives and Data Binding
– Data-Binding Example using AngularJS Directives
– Iterating with the ng-repeat Directive
– Using Filters
• MVC with Angular JS
– Views, Controllers and Scope
– Creating a View and Controller

Agenda
• Modules, Routes and Factories
– Creating a Module.
– Creating a Controller in a Module.
– The Role of Routes
– Defining Routes
• Using Factories and Services
– The Role of the Factory
– Creating Factory

Single Page Application
• HTML is a great declarative language for static documents.
– It does not contain much in the way of creating applications,
• One "real" HTML page whose content can be changed in Javascript
without having to download a new page.
• The new content is created programmatically in Javascript using
templates.
• It has advantages like performances since we're not downloading a
new HTML page each time as we navigate to a new page.
• Page never reloads
• No server-side page rendering

Characteristics Single Page Application:
• Chunking
– the web page is constructed by loading chunks of HTML fragments and
JSON data instead of receiving full HTML from a web server on every
request.
• Controllers
– JavaScript code that handles complex DOM and data manipulations,
application logic and AJAX calls is replaced by controllers that separate
views and models using MVC or MVVM patterns.
• Templating
– coding of UI and DOM manipulations are replaced by declarative
binding of data to HTML templates.

Characteristics Single Page Application:
• Routing
– selection of views and navigation (without page reloads) that preserves
page state, elements and data
• Real-time communication
– two-way communication of a client application and web server replaces
one-way requests from a browser
• Local storage
– capabilities of storing data on a browser for performance and offline
access replace cookies and intensive data loads from web server

What is AngularJS
• A JavaScript Library and also a framework to make the development
of web apps easier and faster than ever before.
• Gives HTML a native Model-View-Controller (MVC) capabilities.
• Extends HTML attributes with Directives, and binds data to HTML
with Expressions
• Uses HTML as template language and extend HTML's syntax to
express application's components clearly and succinctly.
• Has data binding and dependency injection within the browser,

Downloading AngularJS
• Can be download from http://angularjs.org/
• Added to a web page with a script tag.
– <script src="Scripts/angular.js"></script>
• Can also be added through latest CDN link
<head>
<title>Learning AngularJS</title>
<script src=https://ajax.googleapis.com/ajax/libs/angularjs/1.0.7/angular.min.js
></script>
</head>
• There are two types of angular script URLs we can point to,
• angular.js
– This is the human-readable, non-minified version, suitable for web
development.
• angular.min.js
– This is the minified version, usually used in production.

Building Blocks AngularJS
• View Component
– what the user sees (the DOM)
• Directives
– extend HTML with custom attributes and elements
• Controllers Component
– the business logic behind views
• Model Component
– the data shown to the user in the view and with which the user interacts
• Filters
– formats the value of an expression for display to the user
• Services
– reusable business logic independent of views
• Dependency Injection
– Creates and wires objects and functions

View And Templates
• view is a projection of the model through the HTML template
– Pure static HTML page is turned into a template to display result with
any set of data.
– it's the structure of the web page before it's processed by AngularJS.
– Its scanned for directives and template commands, and compiled to a
application.

A Simple View (Template)
<!DOCTYPE html>
<html>
<head>
<title>First Example</title>
<script src="Scripts/angular.js"></script>
</head>
<body ng-app>
{{"Hello" + "World"}}
</body>
</html>
Directive
Expression

Working of AngularJS
1. HTML document with special Angular Attributes known as template
is loaded into the browser
2. AngularJS JavaScript file is loaded
3. The angular global object is created,
4. Template is parsed using "compiler".
5. The loaded, transformed and rendered DOM is the "view".

Directives
• Used to extend HTML ,understandable to AngularJS.
• Directives are HTML attributes with an ng prefix.
– Can use data-ng- to make it HTML5 compliant
• Can also Attach behavior to a DOM element
• ng-App.
– Best Practice is to put to the parent tag <html>
– Indicate the AngularJS compiler that the page is an angular
module/application.
– defines the root element of an AngularJS application.
– Will automatically initialize the application when page is loaded.

Directives
• ng-bind
– binds the innerHTML of the element to the application variable .
• ng-model
– binds the value of HTML controls to application data.
– Provide type validation for application data (number, email, required).
– Provide CSS classes for HTML elements.
– Bind HTML elements to HTML forms.

Directives- Example-I
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Directive Example-One</title>
</head>
<body>
<div ng-app="">
<label>First Name</label>
<input type="text" ng-model="name">
<p ng-bind="name"></p>
</div>
</body>
</html>
Model
View
Data
Binding

Directives
• The ng-show and ng-hide directives are used to conditionally display
HTML DOM elements based on variables, Expressions or functions
– <img src="Images/orderedList1.png" ng-show="true" />
• Used to display DOM elements like an error message
• Both the directives require a boolean value to evaluate the visible
state of the element on which they are defined.
• They can be used as attributes in an element
• ng-click
– own HTML events directives.
– defines an AngularJS click event.

Directive Statement-Example-II
<div ng-app="">
<div id="left">
<img src="Images/orderedList1.png" ng-show="true" />
</div>
<div id="right" >
<img src="Images/orderedList2.png" ng-show="false"/>
</div>
</div>

Directive Statement-Example-III
<div ng-app="" ng-controller="showHideController">
<div id="left">
<img src="Images/orderedList1.png" ng-show="status" />
</div>
<button ng-click="show()">Hide Image</button>
</div>
<script>
function showHideController($scope) {
$scope.status = true;
$scope.show = function () {
$scope.status = false;
} }
</script>.

Directives
• ng-init
– directive initialize AngularJS application variables.
– Can also use a controller or module instead of init directive
• <div ng-app="" ng-init="firstName=‘Ramesh'">
<p>The name is <span ng-bind="firstName"></span></p>
</div>
– <div ng-app="" ng-init="
person={userName:‘Ramesh',email:‘ram@abc.cm'}">
<p>The name is <span ng-bind="person.userName"></span></p>
</div>

Directives
• The ng-repeat directive used on an array of objects, it repeats an
HTML element:
• Used for displaying data in a tables.
• Can be Used to iterate over a Array of Values
<div ng-app="" ng-init=" nameList=['Jagan','Hari','Kumar']">
<table>
<tr ng-repeat="name in nameList">
<td>{{ name }}</td>
</tr>
</table>
</div>

Directive Statement-Example-V
<div ng-app=""
ng-init="items=[ {itemCode:101,itemName:'laptop'},
{itemCode:102,itemName:'smaartphone'}]">
<ul>
<li ng-repeat="x in items">
{{ x.itemCode + ', ' + x.itemName}}
</li>
</ul>
</div>

Directive
• ng-disabled
– binds application data to the disabled attribute of HTML elements
Click me to toggle:
<input type="checkbox" ng-model="checked">
<button ng-disabled="checked">Button</button>
• ng-include
• Fetches, compiles and includes an external HTML fragment.
<div class="container">
<div ng-include="'myUsers_List.htm'"></div>
<div ng-include="'myUsers_Form.htm'"></div>
</div>

ngClass
• Used to dynamically set CSS classes on an HTML element
– Data binding an expression that represents all classes to be added.
• The directive operates based on the expression
– evaluates to a string,
– the string should be one or more space-delimited class names.
• .bold {
• font-size:1.2em;
• }
<body ng-app="" ng-init="clsName='bold'">
<h1 ng-class="clsName">CSS Styling</h1>

Custom Directives
• In Angular we can create custom directives .
• The commonly implemented custom directives:
• Element directives
– activated when a matching HTML element in the HTML
template.
• Attribute directives
– activated when a matching HTML element attribute.
25

Custom Directive
• Directive are registered with the module using directive() function
– myapp= angular.module('custDirective', []);
– myapp.directive('mydirctive', function () {} );
– First Parameter is a function takes is the name of the directive to
register, used in HTML templates to activate the directive.
– The second parameter is a factory function that returns a directive
definition when invoked.
– Factory function returns a JavaScript object which has two properties:
• A restrict field and a template field.
26

Custom Directive
• The restrict field
– By setting restrict to E directive should be activated by a
matching HTML element
– By setting restrict to A directive should be activated by
matching HTML attributes
– Can also use a value of AE which will match both HTML
element names and attribute names.
• The template field
– HTML template that will be used instead of the
matched div element.
– The HTML template replaces the matched HTML element.
27

Custom Directive
<script>
myapp = angular.module('custDirective', []);
myapp.directive('mydirctive', function () {
return {
restrict: 'AE',
replace: 'true',
template: '<h3>Hello World!!</h3>'
};
});
</script>
<div ng-app="custDirective">
<div mydirctive></div>
</div>
28

Custom Directive
angular.module('custDirective', [])
.controller('Controller', ['$scope', function($scope) {
$scope.customer = {
name: 'Ramesh',
address: 'Chennai-117'
};
}])
.directive('myCustomer', function() {
return {
template: 'Name: {{customer.name}} Address: {{customer.address}}'
};
<div ng-app="custDirective" ng-controller="Controller">
<div my-customer></div>
</div>
29

Directive Processing
• Directives life begins and ends within the AngularJS bootstrapping
process, before the page is rendered.
• Directive processes the element depends directive definition object.
• It can define a compile function, a link function or both.
– Link function can be defined as a pre-link function and a post-link
function
• compile
– The directive to manipulate the DOM before it is compiled and linked
– Allowing to add/remove/change directives,
– Allowing to add/remove/change other DOM elements.

Directive Processing
• The pre-link
– function allows for private $scope manipulation before the post-link
process begins.
• The post-link
– The primary workhorse method of the directive.
– DOM manipulation takes place,
– event handlers are configured,
– watches are configured

Data-binding framework
• In traditional server-side HTML programming, model interact within a
server process to produce new HTML views.
• Angular provides Automatic data binding
– ability to consider the view to be a projection of the model state.
• Any time the model is changed in the client-side model, the view
reflects these changes without writing any custom code.
• Views created are live templates
– Individual components of the views are dynamically interpolated .
– Pages are generated without any interaction with a server.

Data Binding Expressions
• Binds data to HTML using Expressions {{ expression }}.
– Expressions are written inside double braces:
– Same way as the ng-bind directive.
• They can contain literals, operators, and variables.
• Will "output" data exactly where the expression is written.
• <div ng-app="" ng-init="firstName='John';lastName='Doe'">
<p>The name is {{ firstName + " " + lastName }}</p>
</div>
• <div ng-app="" ng-init="quantity=1;cost=5">
<p>Total in dollar: {{ quantity * cost }}</p>
</div>

Angular vs. JavaScript Expressions
• Angular expressions are like JavaScript expressions with the
following differences:
• Context:
– JavaScript expressions are evaluated against the global window.
– In Angular, expressions are evaluated against a scopeobject.
• Forgiving:
– In JavaScript, trying to evaluate undefined properties
generates ReferenceError or TypeError.
– In Angular, expression evaluation is forgiving to undefined and null.
• No Control Flow Statements:
– In Angular cannot use the conditionals, loops, or exceptions.
• Filters:
– Filters can be used within expressions to format data before displaying it.
– Instead of using eval() use the $eval() method.

One Way Data Binding
• Data Binding is a process that links UI and business logic, changes
done to either of them will reflect in both.
• one way data binding
– model values are automatically assigned to the HTML placeholder
elements specified through the data binding notation,
– but the HTML elements don't change the values in the model .
• Specified in two different ways:
1. with curly braces: {{expression}}
2. ng-bind
• ng-bind="varName“
• ($scope --> view).
• $scope.val inserted into html where val is a variable name.

One Way Data Binding
• <body ng-app ng-init=“userName= ‘Ramesh'; email =
‘ram@abc.com';">
<p>First name: {{userName}}</p>
<p>Email : <span ng-bind=“email"></span>
• </body>

Two Way Data Binding
• Its the ability to bind changes to an object’s properties to changes in
the UI, and vice-versa.
– Can have more than one HTML element bound to the same variable.
• ng-model
– has two-way data binding
– Variable it will be bound to the scope.
– Scope for the variable will be available in UI as well as model.
– model –> view and view –> model.
• When the page is loaded, the value of the input elements are
initialized to those of the respective model variables
– whenever the user types something in an input, the value of the model
variable is modified as well

Two Way data-Binding
• Handling Value Changes
– If the view changes the value, the model observes the change through
dirty checking,
– If the model changes the value, the view updates with the change.
• Any update on model will be immediately reflected in view without
the need for any DOM manipulation or event handling

<body ng-app="twoway" ng-controller="twoWayController" >
First name: {{firstName}}
Last name: <span ng-bind="lastName"></span>
<label>FirstNaeme </label>
<input type="text" ng-model="firstName" />
<label>Last Name </label>
<input type="text" ng-model="lastName" />
</body>

• Dirty checking
– for two way data binding on $scope variables.
– dirty checking allows Angular to watch for variables that may or may not
exist.
• $scope.$watch
– Used to watch when a variable changes,
• $scope.$watch( watchExp, listener, objectEquality );
– what to watch (watchExp),
– what to do when it's updated (listener),
– and whether or not you're checking on a variable or on an object.
– As we are checking a variable, we can ommit this when we call the
function.
• Angular will register watcher function in the $scope.

Two Way Binding with Watch
<script>
var myapp = angular.module("twoway", []);
myapp.controller('twoWayController', function ($scope) {
$scope.firstName = "Ramesh";
$scope.lastName = "kumar";
$scope.$watch(function () {
return $scope.firstName;
}, function (newValue, oldValue) {
console.log('$scope.firstName was updated!');
});
}
);
</script>

$SCOPE
• $scope
– glues the View with Controller.
– uses two-way data binding to bind model data to view
– application object (the owner of application variables and functions).
– Can be used to set the initial state attaching properties
– added as a parameter to the controller function.
app.controller("MainController", function($scope){
$scope.name = “Ramesh";
});
• Inline injection used to explicitly specify $scope to Controller
• Properties found on the scope automatically accessible
– with {{ }} in View/HTML/
– with Directive into a DOM component
– With user input validation controls

Adding Behavior to a Scope Object
• Can attach methods to the $scope object.
• Methods are then available to be called from the template/view.
• They can be invoked via angular expressions
• Can also be invoked with event handler directives like ngClick
var myApp = angular.module('myApp',[]);
myApp.controller('DoubleController', ['$scope', function($scope)
{
$scope.double = function(value) { return value * 2; };
}
]);
• <div ng-controller="DoubleController">
• Two times <input ng-model="num"> equals {{ double(num) }} </div>

$scope Lifecycle
• When the browser receives a JavaScript callback that
executes inside of the Angular execution context the $scope will be
made aware of the model mutation.
• If the callback executes outside of the Angular context, we can force
the $scope to have knowledge of the change using
the $apply method.
• After the scope expression is evaluated and the $digest loop runs,
the $scope's watch expressions will run dirty checking.
• Creation
– When we create a controller or directive, Angular creates a new
scope with the $injector and passes this new scope for the
controller or directive at runtime.

$scope Life Cycle
• Linking
– When the $scope is linked to the view, all directives that
create $scopes will register their watches on the parent scope.
– These watches watch for and propagate model changes from the view
to the directive.
• Updating
– During the $digest cycle, which executes on the $rootScope, all of the
children scopes will perform dirty digest checking.
– All of the watching expressions are checked for any changes, and the
scope calls the listener callback when they are changed.
• Destruction
– When a $scope is no longer needed, the child scope creator will need
to callscope.$destroy() to clean up the child scope.
– Note that when a scope is destroyed, the$destroy event will be
broadcasted.

$rootScope
• The $rootScope is the top level scope for the application.
• Can be accessed anywhere in the view
• scopes are created with prototypal inheritance
• Isolate Scope
– scope created inside of a directive
• How it works
– If property is not found on a local scope,
– It crawl up to the containing (parent) scope and look for the property or
method there.
– If is not found there it will walk to that scope's parent and so on and so
forth until it reaches the $rootScope.
– If it doesn't find it on the $rootScope, then it moves on and is unable to
update the view.

Nesting of Scopes
• Scope objects can be nested.
– looks up the value of a variable it at the current scope
– then look “upwards” for the variable in any of the parent scopes.
• Creates scopes in a variety of situations.
– For instance, a child scope is created for every controller in our app.
– a scope is a plain old javascript object (also known as a POJO).
– scope does have functionality that makes it really useful, it isn’t magic.
– Scopes are javascript objects just like everything else in our program.
• scopes are a way to organize key-value pairs without polluting
a global namespace.

$Scope
<script>
function ListCtrl($scope) {
$scope.department = 'Training';
$scope.names = ['Jagan', 'Hari', 'Kumar'];
}
</script>
</head>
<body>
<div ng-app="" ng-controller="ListCtrl">
<div>
<p>Name is <span ng-bind="department"></span> </p>
</div>
<div>
<ol>
<li ng-repeat="name in names">{{name}} from {{department}}</li>
</ol>
</div>
</div>.

Controllers
• These are functions used to initialize the model objects,
– Can also have utility functions
• ng-controller
– directive defines the controller.
– Gets executed when the page loads.
– attribute on a DOM element says that all of the elements inside of it
belong to the controller.
– The value should also be the name of the function it is pointing to.
– They have special parameters with fixed names like $scope.
• NameSpace
– Created by Placing it in a module and then creating within the module.

Controller-Example-I
var app = angular.module("ctrlExample1", []);
app.controller("booksController", function ($scope) {
$scope.books = [
{
bookNo:'101',bookName:'java'
} ,
{
bookNo: '202', bookName: 'jQuery'
}
]
});
</script>

Controller-Example-1
•
<div ng-app="ctrlExample1" ng-controller="booksController">
<ul>
<li ng-repeat=“bk in books">
{{ bk.bookNo + ', ' + bk.bookName }}
</li>
</ul>
</div>

Controllers
– A new Controller object is instantiated , using the specified
Controller's constructor function.
– A new child scope will be available as an injectable parameter
to the Controller's constructor function as $scope.
• Use controllers to:
– Set up the initial state of the $scope object.
– Add behavior to the $scope object.
– Controllers should contain only business logic.

Multiple Controller
• Can define multiple controllers in the same HTML template
– each one manages its own $scope object.
• Properties resides in its own $scope thus avoiding any conflict
• Nested Controller
– To share model and functions through an inheritance tree.
– Done by assigning a controller to a DOM element that is inside another
one
– Nesting happens in scopes.
• The $scope passed to a nested controller prototypically inherits from
its parent controller’s $scope.

Multiple Controller-Example II
var firstController = function ($scope) {
$scope.firstName = "John";
$scope.lastName = "Doe";
$scope.getFullName = function () {
return $scope.firstName + " " + $scope.lastName;
}; };
var secondController = function ($scope) {
$scope.firstName = "Bob";
$scope.middleName = "Al";
$scope.lastName = "Smith";
$scope.getFullName = function ()
{
return $scope.firstName + " " + $scope.middleName + " " +
$scope.lastName;
}; };

Nested Controllers-Example-III
<script>
function BankConroller($scope) {
$scope.productName = 'BankAccount';
}
function DepController($scope) {
$scope.PersonalType1 = 'SavingsAccount';
$scope.PersonalType2 = 'RecurringDeposit';
}
</script>

Nested Controller-Example-III
<div ng-controller="BankConroller">
Product : {{ productName }}
<div ng-controller="DepController">
Product SubTypes
<ol>
<li>{{ PersonalType1 }}</li>
<li>{{ PersonalType2 }}</li>
</ol>
</div>
</div>

Dependency Injection
• Component can get a hold of its dependencies:
1. can create the dependency, using the new operator.
2. can look up the dependency, by referring to a global variable.
3. can have the dependency passed to it where it is needed.
• Issues with First Two Options
– Dependency is hard coded in to the component.
– Difficult, to modify the dependencies.
– Problematic in tests, where it is often desirable to provide mock
dependencies for test isolation.

• Can use the third way where injector subsystem creates
components,
– resolving their dependencies,
– The dependency is simply handed to the component.
– providing them to other components as requested.
– function SomeClass(greeter) {
– this.greeter = greeter;
– }
– SomeClass.prototype.doSomething = function(name) {
this.greeter.greet(name); }
• This is desirable, but it puts the responsibility of getting hold of the
dependency on the code that constructs SomeClass.

• When Angular compiles the HTML, it processes the ng-ontroller
directive,
– Then Using the injector creates an instance of the controller and its
dependencies.
– injector.instantiate(MyController);
• It will Inject all the dependecy without the controller ever knowing
about the injector.
• The application code declares the dependencies it needs, without
having to deal with the injector.

• General Syntax for Creating Controllers
– use array based dependencies approach.
• module.controller('ControllerName',['dependency1','dependency2',
function(dependency1, dependency2){
//logic
• }
• myApp.controller('TodoController',['$scope','$http',function($scope,
$http){ //logic }]);
– AngularJS injects the dependencies by name
– JavaScript code are minified with tools to reduce the size.
– Which rename your variables to short variable names.
– $scope and $http may become $s and $h and eventually it will fail.

myApp.controller('TodoController',function($scope,$http){
//logic
});
• While Minifying the code turns into
myApp.controller('TodoController',function($s,$h){
//logic
});
Here $s represents $scope and $h represents $http services
myApp.controller('TodoController',['$scope','$http',function($s,$h){
}]);
• Now Even after JavaScript minifies the function argument names, string
literals remains same and right services are injected.

Filters
• Used for transforming the data for display used along with
expressions.
– Can also be added to directives using a pipe (|) character
– multiple filters can be used by using two or more pipes.
• To use the uppercase filter,
– <p>The Firstname is {{ firstName | uppercase }}</p>
• We can also use filters from within JavaScript by using
the $filter service.
app.controller('DemoController', ['$scope', '$filter',
function ($scope, $filter) {
$scope.name = $filter('lowercase')(‘Ramesh');
}
]);

Filters
• Currency
– Format a number to a currency format.
• Select
– a subset of items from an array.
• Lowercase
• Format a string to lower case.
• orderBy
• Orders an array by an expression.
• Uppercase
• Format a string to upper case.

Currency Filters
• currency filter accepts the symbol for the currency and the default
is $.
• Use the (:) symbol to pass parameter to a filter as follows.
• {{ 123.456789 | number:2 }} 
• <div>{{ 12345.67 | currency }}</div>
<body ng-app>
<div>{{ "12345.67" | currency:"USD" }}</div>
</body>
– Date Filter
<div>{{ 1288323623006 | date }}</div>

Filtering Input
• An input filter can be added to a directive with a pipe character (|)
and filter followed by a colon and a model name.
• The filter filter selects a subset of an array:
• <div ng-app="" ng-controller="namesController">
<p><input type="text" ng-model="test"></p>
<ul>
<li ng-repeat="x in names | filter:test | orderBy:'country'">
{{ (x.name | uppercase) + ', ' + x.country }}
</li>
</ul>
</div>

orderBy filter
• Display with orderBy Filter
• To sort the table, add an orderBy filter:
<div ng-app="" ng-controller="namesController">
<table>
<tr ng-repeat="x in names | orderBy : 'Country'">
<td>{{ x.Name }}</td>
<td>{{ x.Country }}</td>
</tr>
</table
</div>

Custom Filters
• To create a filter, we put it under its own module
• They are functions to which we pass input.
var filters = app.module('app.filters', []);
filters.filter('capitalize', function () {
return function (input) {
if (input) {
return input[0].toUpperCase() + input.slice(1);
}
}
});

Modules
• Building blocks of well structured application.
• Used to nicely organize code into modules to avoid declaring
objects and variables in the global namespace.
• Defined by calling the angular.module function,
• The angular.module function accepts two parameters:
– the name of the module
– an array of dependencies on other modules.
• The angular.module returns a module instance
– Can define a controller directly on that instance through
the controller function.
– controller's constructor function out of the global scope.

Benefits of Modules
• Advantages of modules include:
– Keeping the global namespace clean
– Making tests easier to write and keeping them clean so as to more
easily target isolated functionality
– Making it easy to share code between applications
– Allowing the application to load different parts of the code in any order

Creating Modules
• angular.module('myApp', []);
• Modules Method has two parameter
– The first parameter to the module method is the name of the module
– The second parameter array of strings contains a list of modules as
strings
– The injector loads these modules before the module itself is loaded.
• angular.module('myApp');
– If second parameter if omitted,
– Will try to retrieve the module of given name instead of creating NEW
• ngApp directive accepts the module name to load during the
initialization process.

Module Example -I
<script>
var app = angular.module("ctrlExample1", []);
app.controller("booksController", function ($scope) {
$scope.bookList = [
{ bookNo:'101',bookName:'java‘ } ,
{ bookNo: '202', bookName: 'jQuery’ }
]
});
</script>
77

Module Example -I
<div ng-app="ctrlExample1" ng-controller="
booksController">
<ul>
<li ng-repeat="bk in bookList">
{{ bk.bookNo + ', ' + bk.bookName }}
</li>
</ul>
</div>
78

Modularization with Value
• Value can be a number, string or JavaScript object.
• Injected into factories, services or controllers.
• Defined using the value() function on the module.
• app.value("invoiceNumber", 102);
– The first parameter is the name of the value
– Second parameter is the value
app.controller("MyController", function ($scope, invoiceNumber) {
$scope.invNumber = invoiceNumber;
console.log(invoiceNumber);
});
79

Module Example -II
<script>
var app = angular.module("valExample", []);
app.value("items", { item1: 'laptop', item2: "pc" });
app.controller("MyController", function ($scope, items) {
$scope.items = items;
});
</script>
80

Module Example -II
<div ng-app="valExample" ng-controller="MyController">
<ul>
<li>Invoice Number{{invNumber}}</li>
<li>Item {{items.item1}}</li>
</ul>
</div>
81

$.http
• The Most common way to send AJAX requests
– Using $http service.
– REST type calls.
• $http
– service for reading data from remote servers.
– Can read a JSON File
angular.module("myapp", [])
.controller("MyController", function ($scope, $http)
• var promise = $http(config);
– Used as as a function directly,
– URL and HTTP method are set inside the config object.

$http Functions
• The $http service has several functions to send AJAX requests.
– $http.get(url, config)
– $http.post(url, data, config)
– $http.put(url, data, config)
– $http.delete(url, config)
– $http.head(url, config)
• POST and PUT can take the data to be sent to the server.
• The data parameter will be converted to a JSON string and included
in the HTTP Request

Functions of The Promise Object
• $http.get()
– returns a "promise" object.
• Functions in $http service return a promise object.
• This promise object has two functions called success() and error().
– They take a callback function as parameter.
– Used to set appropriate values on the $scope object.
– Can Update the $scope object with data,
– AngularJS will trigger the HTML template rendering so the data can be
made visible to the user.

The config Parameter
• Config parameter passed to the $http functions controls the HTTP
request sent to the server.
– A JavaScript object which can contain the following properties:
• method
• url
• params
• headers
• timeout
• cache
• transformRequest
• transformResponse

• Method
– used to set the HTTP method for pthe request.
– The method is one of either GET, POST, PUT, DELETE or HEAD.
– This property is normally set implicitly via the function you choose to call
• url
– used to set the URL of the AJAX call.
– This is already provided to the various $http functions,
• params
– used to set any additional request parameters to be appended to the
URL query string.
– The params property is a JavaScript object with one property per
request parameter to add.
• cache
– used to enable XHR GET request caching.

• headers
– used to set any additional HTTP headers you want sent to the server.
– The headers property is a JavaScript object with one property per
header.
• timeout
– used to set the timeout for the AJAX call.
– When the timeout limit is reached, the AJAX call is aborted.
– The timeout is specified in milliseconds.
• transformRequest
– used to set a function which can transform the request object before it is
sent to the server.
• transformResponse
– used to set a function which can transform the response sent back from
the server, before it is passed to your application.

Functions of The Promise Object
• Both Success and Error functions take the following parameters:
• Data
– is the JSON object returned by the server. The $http service assumes
that your server sends back JSON.
• status
– parameter is the HTTP status code returned by the server along with
the response.
• headers
– used to obtain any HTTP response headers
– returns a JavaScript object with one key, value pair for each header,
• config
– configuration object that was used to create the given HTTP request
– Its passed as parameter to the $http

$http –Example -I
angular.module("myapp", []) .controller("MyController", function ($scope,
$http)
{
$scope.myData = {};
$scope.myData.doClick = function (item, event) {
var responsePromise = $http.get("/Home/greet");
responsePromise.success(function (data, status, headers,
config) {
$scope.myData.fromServer = data;
});
responsePromise.error(function (data, status, headers, config) {
alert("AJAX failed!");
});
}
});
90

$http –GET- Example -I
<div ng-app="myapp" ng-controller="MyController">
<button ng-click="myData.doClick(item, $event)">
Send AJAX Request
</button>
Data from server: {{myData.fromServer}}
</div>
91

$http –GET- Example -I
namespace AngularShowCase.Controllers
{
public class HomeController : Controller
{
public string greet()
{
return "Hello From Controller";
}
}
}
92

$http –POST-Example -II
angular.module("myapp", []).controller("MyController", function ($scope,
$http) {
$scope.myForm = {};
$scope.myForm.name = "";
$scope.myForm.car = "";
$scope.myForm.submitTheForm = function (item, event) {
var dataObject = {
name: $scope.myForm.name,
car: $scope.myForm.car
};
var responsePromise = $http.post("../Home/handleForm",
dataObject, {});
responsePromise.success(function (dataFromServer, status,
headers, config) {
console.log(dataFromServer);
});
93

$http –POST-Example -II
namespace AngularShowCase.Controllers
{
public class HomeController : Controller
{
[HttpPost]
public String handleForm(String name,String car)
{
return "Received One Request: "+name + car;
}
}
}
94

AngularJS Forms
• Easier to work with forms by binding data of HTML form input fields
to the model object ($scope).
• Can leverage the two-way Binding of Angular
• ng-model
– Directive is used to bind an input field to a model property
• <input type="text" id=“userName" ng-model=“form1.userName">
95

Binding HTML Elements
• Binding Checkboxes
– The model property will be set to true if the checkbox is checked,
and false if not.
• Can Set other than boolean Values
– ng-true-value and ng-false-value
• <input type="checkbox" ng-model="
myForm.wantNewsletter"
ng-true-value="yes"
ng-false-value="no" >
96

• Binding Select Boxes
• ng-options
– Can create option elements based on data from the $scopeobject.
– ng-options directive is used inside the select element.
div ng-controller="MyController" >
<form>
<select ng-model="myForm.items"
ng-options="obj.id as obj.name for obj in
myForm.options">
</select>
</form>
</div>
97

angular.module("myapp", []) .
controller("MyController", function($scope) {
$scope.myForm = {};
$scope.myForm.items = “phone";
$scope.myForm.options = [
{ id : “phone", name: "Nokia" } ,
{ id : "tv", name: “LG" } ,
{ id : “pc" , name: “Lenova" } ];
} );
98

Field Validation State
• Form elements are to the $scope object as a property with form
Name.
• Angular form creates an instance of FormController.
– It has methods and properties
• The State can be pristine, dirty, valid, invalid.
• Can use these properties to set a matching CSS class on the input
fields.

CSS classes
• ng-valid
– is set if the form is valid.
• ng-invalid
– is set if the form is invalid.
• ng-pristine
– is set if the form is pristine.
• ng-dirty
– is set if the form is dirty.
• ng-submitted
– is set if the form was submitted.

Form Properties
• Can use the validation properties to show or hide validation
messages.
• $pristine
– True => if the form or form fields has NOT been CHANGED
– false => if form fields or form HAVE been CHANGED.
• $dirty - reverse of $pristine
– true => if the form has CHANGED .
– false => if the form has NOT been CHANGED
• $valid
– True => if the form field or the whole form is VALID.
– False=> if the form field or the whole form is NOT VALID.
• $invalid-reverse of the $valid
– true => if the field or a single field in the for is NOT VALID.
– false => if the field or all fields in the form is VALID,

Form Properties-Example
• <input type="email" name="email" ng-model="email" required>
• <span style="color:red" ng-show="myForm.email.$pristine &&
myForm.email.$invalid“> * </span>
<input type="email" name="email" ng-model="email" required>
<span style="color:red" ng-show="myForm.email.$dirty &&
myForm.email.$invalid">
<span ng-show="myForm.email.$error.required">Email is
required.</span>
<span ng-show="myForm.email.$error.email">Invalid email
address.</span>
</span>
102

Submitting Forms
• Forms can be submitted in two ways:
– Using a button element with an ng-click attribute.
– Using an ng-submit attribute (directive) on the form element.
• In both cases a JavaScript function is called on the $scope object.
• Function Can send the data from the form to your server via AJAX

Form Validation
• Validation is done on fields before copying their value into
the $scope
• If a form field is invalid, its value is not copied into
the$scope property
– Instead the corresponding $scope property is cleared.
– That is done to prevent the$scope properties from containing invalid
values.
• This example sets the ng-minglength to 5 and ng-maxlength to 12.
• That means that if the text in the input field is less than 5 or more
than 12 characters long, the value from the input field will not be
copied into the$scope.myForm.name property.

Form Validation & Submission
<script>
var validationApp = angular.module('validationApp', []);
validationApp.controller('mainController', function ($scope) {
$scope.submitForm = function (isValid) {
if (isValid) {
alert('Angular Forms are amazing');
}
};
});
</script>
105

<body ng-app="validationApp" ng-controller="mainController">
<div class="page-header"><h1>AngularJS Form Validation</h1></div>
<form name="userForm" ng-submit="submitForm(userForm.$valid)"
novalidate>
<div>
<label>Name</label>
<input type="text" name="name" class="form-control"
ng-model="name" required>
<p ng-show="userForm.name.$invalid && !userForm.name.$pristine">
Name is required.</p>
</div>
106

<div>
<label>Username</label>
<input type="text" name="username" ng-model="user.username"
ng-minlength="3" ng-maxlength="8">
<p ng-show="userForm.username.$error.minlength" >Too
short.</p>
<p ng-show="userForm.username.$error.maxlength" >Too
long.</p>
</div>
107

<div >
<label>Email</label>
<input type="email" name="email" class="form-control"
ng-model="email">
<p ng-show="userForm.email.$invalid &&
!userForm.email.$pristine">Enter a valid
email.</p>
</div>
<button type="submit"
ng-disabled="userForm.$invalid">Submit</button>
</form>
108

AngularJS Services
• Services are stateless singleton objects or functions that carry out
specific tasks.
• Used hold some business logic.
• Service are injected by Its Name
• Example for Service
– The business logic or logic to call HTTP url to fetch data from server
can be put within a service object.
• Putting business and other logic within services has following
advantages.
– fulfills the principle of separation of concern or segregation of duties.
– Each component is responsible for its own work making application
more manageable.

AngularJS internal services
• AngularJS internally provides many services that we can use in our
application.
– Internal services starts with $ sign
– $http ,$route,$window, $location are other services
• Services can be used within any Controller using dependencies.
• The Most poplular was of defining services are.
– module.service.
– module.factory

Services –Example I
var app = angular.module("usingServices", []);
app.service("gs", function () {
this.sayHello = function (text) {
return "Service says "Hello " + text + """;
};
});
app.controller('greetController', function invoke($scope, gs) {
$scope.fromService = gs.sayHello("World");
});
<div ng-app="usingServices" ng-controller="greetController">
{{fromService}}
</div>

Services-Example-II
angular.module('myApp‘).service('UserService', ['$http',function($http)
{
var service = this;
this.user = {};
this.login = function(email, pwd) {
$http.get('/auth',{ username: email, password:
pwd}).success(function(data){
service.user = data;
});
};
this.register = function(newuser) {
return $http.post('/users', newuser);
};
}]);
113

Factories
• Functionality can be encapsulated into services, factories, and
providers.
• The Object returned by factory can be used to work with data,
validate business rules, or perform a variety of other tasks.
• They are singletons by default so the object returned by a factory is
re-used by the application.
– angular.module(‘YourModule"’).factory()

Factory
angular.module('myApp‘).factory('UserService', ['$http',function($http) {
var service = {
user: {},
login: function(email, pwd) {
$http.get('/auth',{ username: email, password:
pwd}).success(function(data){
service.user = data;
});
},
register: function(newuser) {
return $http.post('/users', newuser);
}
};
return service;
}]);
115

AngularJS Service vs Factory
• Services are application wide singleton objects.
– once created can be used within any other services or controllers etc.
• When declaring serviceName as an injectable argument you will
be provided with an instance of the function.
– In other words new Function You PassedToService().
– This object instance becomes the service object that AngularJS
registers and injects later to other services / controllers if required.
• When declaring factoryName as an injectable argument you will be
provided with the value that is returned by invoking the function
reference passed to module.factory.

Routing
• Routes enable us to create different URLs for different content
• A route is specified in the URL after the # sign.
• Routes create different URLs for different content in your
application.
• User can to specific content,
• Each such bookmarkable URL is called a route.
• Routes enables to show different content depending on what route
is chosen.
• A route is specified in the URL after the # sign.

Routing
• Different URL's all point to the same AngularJS application, but
each point to different routes:
• When the browser loads the links application will be loaded
• However, AngularJS will look at the route (the part of the URL after
the #) and decide what HTML template to show.
• Use different views for different URL fragments
• Makes use of template partials
– Templates that are not a whole web page (i.e. part of a page)
– Used in conjunction with the ng-view directive
• ng-view determines where the partial will be placed
• Can only have one ng-view per page

Adding Routing
• Including the AngularJS Route Module
– Route module is contained in its own JavaScript file.
– Need to add to the AngularJS application
<script src="Scripts/angular-route.js"></script>
• Declaring Routing as a Dependency
– Its declared as a dependency in the application Module
var module = angular.module("sampleApp", ['ngRoute']);

Routing
• ngView Directive : <div ng-view></div>
– Inside the HTML template specific to the given route will be displayed.
– Used as a container to switch between views.
– Will look to the route provider to find which template needs to be
rendered
– Config function is Injected with $routeProvider and not $route.
• myApp = angular.module(‘myApp’, [‘ngRoute’]);
• myApp.config([‘$routeProvider’, function($routeProvider) { … }]);

RouteProvider
• $routeProvider provides methods like when() and otherwise()
– use to define the routing for application.
• when()
– Routes are configured by using this function
– $routeProvider.when(<path>, {<route>});
• Path:
– A String matched to a url pattern of the a view
– Path matched against $location.path.
• Route
– An Object with two typical properties
• controller = The name of the controller that should be used
• templateUrl = A path to the template partial that should be used
• otherwise()
– To render a view when there is no match to a url pattern.

Routing
• URL parameters
– $routeParams service
• To access the parameters in the URL,
• will have a field with the same name as the parameter
– $routeProvider
• will match the route against /:message,
• value of :message can be injected into the controller as $routeParams,
• retrieved with a key of the same name.
• The route parameters can be stacked and accessed

route parameters
app.config(function ($routeProvider) {
$routeProvider .when('/:map/:country/:state/:city',
{ templateUrl: "app.html", controller: "AppCtrl" } ) });
app.controller("AppCtrl", function ($scope, $routeParams) {
$scope.model = { message: "Address: " + $routeParams.country + ",
" + $routeParams.state + ", " +
$routeParams.city } });

AngularJS

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to AngularJS (20)

Recently uploaded (20)

AngularJS