Check out our new training course on AngularJS for Flex Developers

Turning the ESRI Map Component into an Angular Directive

A client of mine builds a lot of mapping applications using the ESRI API. The ESRI HTML5 Map components are built on top of the DOJO toolkit, a JavaScript framework and UI library. DOJO has its' own way of doing things. My client likes the Angular approach better than DOJO, so they wanted to be able to use the DOJO Mapping component as an Angular directive. How do we do that?

There are lots of blog posts on using the ESRI Mapping components inside an Angular application. This was the best one I found, however I could not find any ready to go samples. This article intends to explain exactly my approach to make the DOJO component work as an Angular directive.

Why is there a problem?

DOJO is JavaScript code, right? Any JavaScript code can be wrapped up in an Angular directive, right? Why does the ESRI mapping component present problems? The problem is that DOJO uses a “load on demand” approach, and that brings out issues where the AngularJS Directive is created in the browser before the DOJO object is loaded. Getting Angular and DOJO to sync up was the root of my problem.

Create the Main Index

The main index will be an HTML page that will display the map using the Angular directive we will create. First create a basic outline:


<html>
<head lang="en">
<meta charset="UTF-8">
<link rel="stylesheet" href="http://js.arcgis.com/3.9/js/esri/css/esri.css" />
<script src="http://js.arcgis.com/3.9/"></script>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.3.0-beta.10/angular.min.js"></script>
<script src="js/ESRIDirective.js" ></script>
</head>
<body >
</body>
</html>

There are four important elements of the HTML header. The first is a link tag to load the ESRI style sheet. This is loaded directly from the ESRI servers. The second loads the ESRI libraries, also loaded from the ESRI servers. The third library loads the Angular library from the Google CDN. The final script tag will load our local ESRIDirective.js file. This directive will include the finished Angular library, which will be built later in this article.

Next, create an AngularJS module and controller for testing the application:


<script>
var mapTest = angular.module('mapTest',['map']);
mapTest.controller('mapTestController',['$scope', function($scope){
$scope.title = "Hello Map";
}]);
</script>

This creates a new AngularJS Module named mapTest. One custom directive is passed into it, named map. This is the directive that will be defined in the ESRIDirective.js script. A single controller is created, named mapTestController. It creates a single variable in the $scope, named title.

We flesh out the body of the HTML page to load the map:


<body ng-app="mapTest" >
<div ng-controller="mapTestController">
<h1>{{title}}</h1>
<esri-map zoom="4" basemap="streets" id="mapID">
</esri-map>
</div> -
</body>

I modified the body tag to add the ngApp directive on it. Then I added a div which points to the mapTestController with the ngController directive. The title from the directive's $scope is displayed. Then the map directive is used. Three attributes are specified directly on the esriMap directive: zoom, basemap, and id. These relate to specifics of the ESRI mapping API.

Trying to load this app in a browser will just give you errors, because the ESRIDirective.js file has not yet been created. We can tackle that next.

Write the JavaScript Code

Create the JavaScript file ESRIDirective.js in a js directory relative to the main index file. This is the file that will contain the Angular mapping directive based on the ESRI DOJO component. First create an Angular module:


var esriMap = angular.module('map', []);

When you want to create Angular directives that can be shared across different modules, it is a common approach to create the directive in a separate module. The module is passed into the main angular application as part of the dependency array.

Next, I want to create a mapObjectWrapper:


var mapObjectWrapper = function(){
this.map = undefined
}

This is a variable that will exist as part of the HTML page. It exists outside of AngularJS and independent of DOJO. This object will wrap the DOJO map object, however it is undefined in its default state.

Next, create an AngularJS factory to wrap the mapObjectWrapper:


esriMap.factory('esriMapService',function(){
return mapObjectWrapper;
})

This factory allows us to use the mapObjectWrapper inside of an Angular controller without breaking the dependency injection principle of AngularJS that allows for easy module testing.

Now create the directive:


esriMap.directive('esriMap', function () {
return {
restrict: 'EA',
controller: 'MapController',
link: function (scope, element, attrs, ctrl) {
ctrl.init(element);
}
};
});

The restrict property of the directive allows the directive to be used as an entity, or as an attribute. In the code we shared in the previous section it was used as an Entity, like this:


<esri-map>
</esri-map>

However, the could also have been used as an attribute, like this:


<div esri-map>
</div>

This directive specifies both a controller and a link function. The controller refers to MapController, something we haven't created yet. The link function does not contain any code other than to execute an init() method on the controller. This approach is used so that the controller is separate from the directive and can be tested independently.

The real meat of this directive is in the controller, so let's create that next:


esriMap.controller('MapController',
['$rootScope', '$scope', '$attrs','esriMapService',
function ($rootScope, $scope, $attrs, esriMapService) {
$scope.mapService = esriMapService;
$scope.mapService.scope = $scope;
}

The previous code block creates a controller on the esriMap module. The controller is named MapController. There are four services passed into it:

  • $rootScope: The $rootScope service will be used for broadcasting evnts to other aspects of the application.
  • $scope: The angular $scope service is used for sharing data between a view and controller.
  • $attrs: The $attrs service will contain all the attributes on our custom HTML element. It will allow us to introspect the attributes if need be.
  • esriMapService: The esriMapService is the custom service we created, which wraps the mapObjectWrapper.The mapService is saved to the local $scope, and the local $scope is saved as a property on the mapService object. This is so that our DOJO code can execute a function on the the directive’s $scope once it is loaded. You'll see this code later.

Here is the init() function:


this.init = function (element) {
if (!$attrs.id) { throw new Error('\'id\' is required for a map.'); }
$scope.$element = element;
if(!$scope.mapService.map){
return;
}
$scope.recreateMap();
};

The init() function is called from the link in the directive's controller. The first piece of code in the the method is to make sure that an id attribute exists on the directive's tag. The ID is required by the ESRI map component. The element argument represents the tag that created the directive. The element is stored into the controller’s $scope for later reference.

If the mapService.map variable is not yet defined, then the method’s execution stops. Otherwise, a recreateMap() method is called in the controller:


$scope.recreateMap = function(){
createDiv();
createMap();
}

This method just calls two other methods. The createDiv() method is used to create a separate div required by the mapping component. The createMap() component will create a map on that div. First, create a variable to contain the map div:


var mapDiv

Now, we can examine the method:


var createDiv = function () {
if(mapDiv){
return;
}
mapDiv = document.createElement('div');
mapDiv.setAttribute('id', $attrs.id);
$scope.$element.removeAttr('id');
$scope.$element.append(mapDiv);
};

If the mapDiv already exists, then the function processing is terminated. If the mapDiv doesn't exist, then a new div is created. It is given the same ID that is specified as an attribute. The id attribute is removed from the main tag. This is so that the map component does not get confused by two separate divs identically named. Finally the new map div is added to the DOM as a child of the main element.

Here is the createMap function:


var createMap = function () {
if(!$scope.mapService.map){
return;
}
if(!mapDiv){
return;
}
var options = {
center: $attrs.center ? JSON.parse($attrs.center) : [-56.049, 38.485],
zoom: $attrs.zoom ? parseInt($attrs.zoom) : 10,
basemap: $attrs.basemap ? $attrs.basemap : 'streets'
};
$scope.map = new $scope.mapService.map($attrs.id, options);
$scope.map.on('load', function () { $rootScope.$broadcast('map-load'); });
$scope.map.on('click', function (e) { $rootScope.$broadcast('map-click', e); });
};

First, the method checks to see if the mapService is loaded and if the mapDiv is created. If either of these conditions is false, then the code is not executed.

Next the code creates an options object. This options object properties are created by introspecting the attributes on the directive's main tag, and uses those attributes to create a options object to send to the map. In this case, only three are implemented: center, zoom, and basemap.

I'm unsure how I feel about the code examining the attributes to create the options object. I’d rather pass this responsibility back to the directive user, so they can add or remove properties as needed. The current approach will need to change the directive code if we want to add, or remove, option parameters. In my Angular travels it is more common to see an options object passed into the directive, and that options object contains all the relevant parameters. I’d much prefer that to introspecting the attributes however I did not have time to change that for this proof of principle demo.

The next line of the method uses the DOJO mapService’s map() method to create the map on the screen. The last two lines add load and click event handlers on the map. This uses the $rootScope to broadcast events, essentially telling anyone listening that these actions occurred on the map.

The final piece of code is the DOJO statement to load ESRI’s map function. This should exist outside of any Angular code:


require(['esri/map'], function (Map) {
mapObjectWrapper.map = Map;
mapObjectWrapper.scope.recreateMap();
});

The DOJO component is loaded using the require() method. That means it is not loaded immediately, but queued up to be loaded as it is needed. Once loaded, this method accesses the mapObjectWrapper directly. It saves the map as a parameter inside the object, and then executes the recreateMap() function on the controller's scope. Remember when we added the scope to the esriMapService? This is why. It provides a hook so that the DOJO code can communicate with the Angular directive.

Final Thoughts

You can view a working demo here. The client I built this prototype for also put the code in their GitHub account. My own fork is here.

Sign up for DotComIt's Monthly Technical Newsletter

Pizza Dough

Someone asked for my Pizza Dough recipe, so here it is. I got this from my brother primarily, but have tweaked it slightly

Ingredients

  • 2.5 Tablespoons of Active Dry Yeast
  • 1/4 Teaspoon of Sugar
  • 1.5 cups of warm water
  • 3.5 cups of Flour
  • 1.5 teaspoons of salt
  • 1 Tablespoons of Olive Oil

Make the Dough

  1. Dissolve Yeast and Sugar in warm water
  2. Sift Flour (I sift it directly into my Kitchen aid mixer bowl)
    • My siblings add extra Gluten here. For each cup of Flour, remove one tablespoon of Flour and add in one Tablespoon of Gluten. I do not do this.
  3. Add salt to Sifted Flour
  4. Add Olive Oil to Flour Mixture
  5. Add Yeast/Sugar/Water mixture to Flour Mixture
    • If you're adventurous you can add extra seasoning to the dough at this stage; Basil works really well.
    • If you saved a small dough ball from your last batch; add it to this batch to give this batch a sour dough taste.
  6. Mix in Kitchen Aid Mixer with Dough Hook. I usually run this for 10 minutes or so, usually on mid-speed. You can watch the dough as it mixes. If it looks too stiff; I may add more water; or if it is too watery I may add more flour.
  7. Coat a separate bowl in Olive Oil. I eyeball it, but roughly use a tablespoon and then use a basting brush to coat the inside of the bowl.
  8. When dough is ready; move from KitchenAid mixer to Olive Oil Bowl. I'll roll around the dough in the bowl.
  9. Cover and put someplace warm for 2+ hours. This will let the dough rise; it will probably double in size.
  10. Punch dough down and break into 2-3 dough balls. Store in the refrigerator. [I use a large Lock and Lock box; although that brand is no more]

Make the Pizza

  1. Heat Oven to 550 degrees
  2. Put Flour on Counter; roll out dough with a rolling pin. Add additional flour to rolling pin / on top of dough if dough sticks to Rolling pin (or counter)
  3. Roll up Sides of Dough (I do two rolls to make the edge of the pizza)
  4. Add sauce, cheese and toppings
  5. Cook for about 10 minutes

How do I run code on Browser Resize with AngularJS?

I was working on a client application and wanted to execute code inside a controller whenever the browser resized.

My purpose was to change a ng-class value, based on the available width. I had it all working great on the initial application load, but the client wanted to make sure this display update would take place if the browser resized and without having to reload the app.

How can I run code when the browser resizes? I imagine there are a bunch of ways, but in the context of AngularJS this is how I did it.

First add the $window service to your controller:


function someCtrl($scope, $window) {
}

With the $window service and the Angular element, you can get a reference to the JQuery object:


var w = angular.element($window);

I believe this should work even if you don't have the full JQuery version loaded into your app, because AngularJS has a version of JQuery under the hood.

Then you can use bind() on resize.


w.bind('resize', function () {
console.log('resize');
});

The bind() function, in this case, will execute the function whenever the browser resizes.

Here is a Plunkr to demo this.

Sign up for DotComIt's Monthly Technical Newsletter

What technology should I add to Life After Flex?

If you don't know, I put together a training course on AngularJS for Flex Developers. It includes some free books, and a bunch of additional (non-free) content including six hours of screencasts.

I'd like to extend the series to include more technologies, and have put together this quiz to collect your feedback. It is only three questions and should take less than a minute, so go in and throw your two cents.

I'd welcome the feedback.

Watch my AngularJS For Flex Developer's Presentation from 360|Flex

The 360|Flex team has posted a video of my AngularJS for Flex Developers presentation.

The audio has a bit of an echo, but otherwise I thought it went pretty well.

Why didn't my Angular View update after changing the $Scope variable?

Binding in AngularJS works magically. When an element in the controller changes the view is updated automatically. When an input in the view is updated, the controller value is automatically updated.

This is because every time the user interacts with the app, AngularJS automatically runs the $digest() method which automatically updates all bindings.

I am working on an app for a client that needed to execute JavaScript code when a binding changes. I had one view, and controller, which displayed some data filtering options to the user. A second view, and controller, displayed data loaded from the remote services, based on the filtering options. When the filtering elements were changed, a remote service call was made in the filtering view, and the results needed to modify the data view.

However, I discovered that when the results came back from the service call, the view was not updating with the new data. Why is that?

There are a few things at play here and I'm going to start with some simple examples of binding, then expand to discuss $watch(), and finally I'll talk about how to use $apply() to solve the problem.

Setting up a Simple Application with Binding

To demonstrate watches I'm going to start with a simple application. It will take two inputs from a user; a first name and a last-name. Then it will display the values to the user, updating as the user types.

First, create a simple HTML page. Then import the Angular library:


<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.0/angular.min.js" ></script>

Then create another script block, with a module and controller:


<script>
var watchTest = angular.module('WatchTest',[]);

watchTest.controller('watchTestCtrl',['$scope', function($scope){
}]);
</script>

Inside the controller, add some scope variables. One for the first name and one for the last name:


$scope.firstName = "Jeffry";
$scope.lastName = "Houser";

I'm also going to add a reset function:


$scope.onReset = function(){
$scope.firstName = "";
$scope.lastName = "";
}

The HTML behind this application will put the ng-app tag on the body, and point the watchTestCtrl on the div tag:


<body ng-app="WatchTest">
<div ng-controller="watchTestCtrl">
First Name: <input type="text" ng-model="firstName" /><br/>
Last Name: <input type="text" ng-model="lastName" /><br/>
Hello: {{firstName}} {{lastName}}<br/>
<Br/>
<button ng-click="onReset()" >Reset</button>
</div>
</body>

See this app in action or play with the Plunker.

Setting up a Simple Watch

AngularJS binding, with ng-model and the double curly bracket syntax, does not allow you to run JavaScript code when a value changes. Thankfully, it does provide a $scope function, $watch(), for this purpose.

Let's set up a simple watch to show how we can run additional code when values change.

Inside the controller, add the watch:


$scope.$watch( 'firstName',
function(newValue, oldValue){
console.log('firstName Changed');
console.log(newValue);
console.log(oldValue);
}
);

$scope.$watch( 'lastName',
function(newValue, oldValue){
console.log('lastName Changed');
console.log(newValue);
console.log(oldValue);
}
);

The $watch() is a function on the $scope service. It accepts two arguments. The first is a string, representing the value that you want to watch for changes. This could also be a function that returns the value you want to watch. The second is a function which is executed whenever the value changes. The arguments for the change function are the newValue and the oldValue.

For the sake of the example, I just logged the new and old values to the console; however you could perform other functionality, such as instigating a remote service call or other processing.

You can try to run this app or play with the Plunker. You'll need to keep the web developer console of your browser open to see the log statements.

The problem with Binding and Asynchronous calls

For binding, or the $watch() method, to execute the variable change must happen within the context of an AngularJS $digest(). Angular automatically runs $digest() whenever user interaction takes places which affects the $scope. However, the $digest() will not occur without user interaction. When retrieving, or changing, data asynchronously, the $digest() will not be triggered, the bindings will not update, and the $watch() method never fires.

To demonstrate the problem, I am going to use the JavaScript setTimeout() function instead building out a full remote service call. First, I'm going to add a JavaScript method to change the firstName with the setTimeout() function:


$scope.triggerChange = function () {
setTimeout(function(){
console.log('First name being reset');
$scope.firstName = '';
}, 1000);
};

I'm also going to add a button to trigger that change:


<button ng-click="triggerChange()" >Trigger Change</button>

So, when you click the "Trigger Change" button in the UI; the triggerChange() method will be executed, queuing up the timeout function to run in 1 second. When it runs, we see a console.log() and the value is changed. Try this and you'll see that the values in the UI are not updated even though you can see the log in the console, proving that the element did execute.

As a helper, you can add a method to log the user information:


$scope.logName = function () {
console.log($scope.firstName);
console.log($scope.lastName);
}

And add a button to trigger this:


<button ng-click="logName()" >Log Name</button>

Click the logName button, and you'll see that the values in the UI automatically get updated. This is because the user interaction forced the $digest() method to execute, which updated the bindings, and also caused the $watch() function to execute.

You can Test the app or play with the Plunker

Forcing the update with $apply() method on $scope

The simplest solution to this is to use Angular's $apply() method on the $scope. The $apply() method accepts a single argument, which is a function. The function executes, then the $digest() functionality will be executed for the variables that changed. We can change the trigger function, like this:


$scope.triggerChangeWithApply = function () {
setTimeout(function(){
console.log('First name being reset');
$scope.$apply(function(){
$scope.firstName = ''
}
)
}, 1000);
};

Instead of changing the $scope.firstName directly in the timeout function, it is done inside he $apply() function. The $apply() function makes sure that Angular's bindings update. Retest the code, and you'll see that after the timeout function runs, the UI is automatically updated. Play with the Plunker

What do you do when all your code is encapsulated into an Angular Service?

The original use case I mentioned was when a remote service responded with asynchronous events. If you're building a larger application, there is a good chance that your remote service code will be encapsulated out of a controller and into an AngularJS Service. AngularJS Services do not have access to a $scope service because they do not have a view. As such, you cannot directly use $apply() to update bindings. What do you do when you want to update the view in response to an event handler inside of an Angular service?

I have two solutions, and I'm not sure which is better. The first is to add a callback to the function which resides inside the controller. Pass the callback as an argument into the service, and execute the callback when you get results. The callback method can call $apply() on the $scope. Something like this would work:


var callback = function(){
$scope.$apply()
}

In this case, a function is not used as an argument to $apply(). Angular will automatically figure out everything that has changed. The second solution is to grab a UI Element and find the scope on that, something like this.


var element = angular.element($('#MyElementWithController'));
element.scope().$apply();

This method works, and prevents the need for a callback just to update, however I'm unclear if it is the best approach. Ideally you wouldn't want the services trying to access the HTML directly for any reason.

Final Thoughts

I've had a lot of fun with this; but

Did I mention that you should all check out the free AngularJS training books I wrote at training course on AngularJS? You can get some books I wrote for free.

Sign up for DotComIt's Monthly Technical Newsletter

Get my Training Course on AngularJS for Flex Developers

I've spent a lot of the past year putting together a training course on AngularJS for Flex Developers. Today is the release day.

The base of this are two books that work together, one builds an application in Flex. The next builds an application in AngularJS. I found that this was a great way to compare and contrast the two technologies. The main books are available under a pay what you want scheme; however I put together a lot of extras including bonus articles and a full screencast series.

Check out the packages; and choose one that works for you. You can use the discount code 'jhblog' to get a 10% discount.

7 Random Facts About Me

This showed up on Facebook and I thought I'd make it into a blog post for no particular reason.

OK, I'm doing the random fact game. Here are 7 random facts about me you might not know.

  1. Early names suggestions for my last 'major' band, Far Cry Fly, were Ampersand, Kermit's Children, and Fozzie's Malaise.
  2. I have taken saxophone lessons, piano lessons, and voice lessons. I have taught myself guitar, bass, and drums. Other musicians say I have a great sense of timing and I accredit that to Steve Chetcuti, my saxophone teacher.
  3. My house is full of Cabbage Patch Kids, Webkins, and other random stuffed animals. We call them our "Imaginary perfect children." Someday I want to write a book about them and it will be a "Rugrats meet Winnie the Pooh" sort of thing.
  4. I have written 3 books that were published by Osborne McGrawhill. I am currently working on the fourth. These are technical books.
  5. I have participated in February Album Writing Month for four years straight; writing and recording 14 songs during the month of February. If you Google my name, some may come up on the Internet. But I'm not sure. I posted some songs on some music sites; but I forget the names.
  6. I make my own Dairy Free ice cream. Since it is Dairy Free perhaps it shouldn't be called ice cream? But, it is the same concept made with an ice cream maker.
  7. My band, Far Cry Fly, once got kicked off stage a few songs into our set. The owner walked up and said "play one more song and get off." because people were not dancing to us.

Calling a ColdFusion CFC from AngularJS

I have been working on my HTML5/AngularJS book and ran into a problem integrating AngularJS with ColdFusion. I wanted to be able to reuse the same ColdFusion services in my Angular project as they did with my Flex project. This didn't work quite as elegantly as I thought, so I thought I'd blog about the problems, and my solution.

Setting up the CFC

ColdFusion allows you to easily create a web service inside a CFC. Each method can be set with an access of remote and that makes the method available to AMF, SOAP, and REST calls. The AngularJS code will use REST. I put together a simple CFC for demonstration purposes:

<cfcomponent displayName="TestService" hints="I am a Test Service for an AngularJS Article">
 <cffunction name="sum" returnformat="plain" access="remote" output="true" hint="I am a Sample CFC" >    
  <cfargument name="num1" type="numeric" required="true"  />         
  <cfargument name="num2" type="numeric" required="true"  />         
  <cfreturn arguments.num1 + arguments.num2 />
 </cffunction>
</cfcomponent>

The CFC starts with a cfcomponent tag.  It has a single method inside of it, named sum.  The sum method accepts two numeric arguments, adds them together, and returns the result.  This is pretty simple. 

A ColdFusion Sample for creating a Post Call

There are two ways to call a CFC method as a REST service, either through an HTTP get call or an HTTP post call.  This is well documented in the ColdFusion docs. The problem with get approach is that all the values are put in the URL; and URLs have a character limit depending upon the browser. As such, I prefer to make calls using an HTTP post.  The name of the method and the arguments must be specified as form parameter in order for ColdFusion to determine how to process the call.

Here is a sample ColdFusion template to test the call:

<cfhttp url="http://#cgi.SERVER_NAME#/com/dotComIt/samples/callingCFC/TestService.cfc" method="post" result="results" >
                <cfhttpparam name="method" value="sum" type="formfield">
                <cfhttpparam name="num1" value="1" type="formfield">
                <cfhttpparam name="num2" value="2" type="formfield">
</cfhttp>
<Cfdump var="#results.filecontent#" />

This uses the CFHTTP tag to make the remote call.  It specifies three separate form fields:

  • method: This is the name of the method to call on the URL, named sum.
  • num1: This is the first argument value of the CFC’s method, and it is hard coded to the value 1.
  • num2: This is the second argument value into the CFC method, and it is hard coded to the value 2.

If you run this template, you'll see that you get a result of 3.0 displayed to the screen.  So, we have created a CFC and proved the method can be executed using an HTTP Post call.  The next step is to make this call from AngularJS.

Setting up the AngularJS App

To make a post call from AngularJS, you can use $http.post(), which is a helper function to make post calls easier.  Before we jump into that we’ll need to set up our Angular app.  Start with a simple HTML page:

<html>
<head>
    <script src="/AngularApp/js/libraries/angular.js"></script>
</head>
<body ng-app="testCalls">
</body>
</html>

This page imports the Angular framework and creates a single app; named testCalls.  Start another script block in the header and use it to define the application.  We'll be putting more JavaScript in this block later:

<script>
 testCalls = angular.module('testCalls', []);
</script>

Next, we'll need a div for our content:

<div ng-controller="testCallsCtrl">
</div>

The content is just going to be buttons that trigger calls to the remote service and display the results.  The content will be filled in shortly.  Create the controller in your JavaScript block:

function testCallsCtrl($scope, $http){
}

For now the controller is empty.  If you load your app in a browser, and check the console you should see no errors yet, but you also have no functionality.

Calling the Service with a Parameter object, and why it didn’t work

Most of the documentation I read about AngularJS has people making post calls and sending an object as the parameter, so that was my first approach.  First, add the button to the HTML Div:

<input type="button" value="Sum Via Post Object" ng-click="onPostObject()" />
<b>Post No Header Result</b>: {{postResultObject}}<br/>

This HTML Snippet will call the function onPostObject(), and through the use of binding display the results from the postResultObject variable. 

In your controller code, create the result variable:

$scope.postResultObject = 0;

Next, create a function to make the call:

$scope.onPostObject = function onPostObject(){<br />
}

Create an object to contain the three parameters:

var parameters = {
 num1 : 1,
 num2 : 2,
 method   : "sum"
}

This parameter object contains the method, sum, and values for the two input parameters to the method: num1, and num2.  As with our ColdFusion sample, both num1 and num2 are hardcoded values.  This is done for simplicity purposes of this sample.

Finally, use the $http.post() method to call the remote service:

$http.post('/com/dotComIt/samples/callingCFC/TestService.cfc', parameters).success(onPostObjectSuccess).error(onError);

The first argument of the post method is the endpoint of the service to call. In this case, it calls our TestService.cfc.  Then the parameter object is added.  On a success response from the server, an onPostObjectSuccess() method will be executed.  If the server has an error; then the onError() method is called.

The onError method is re-used for all our subsequent examples, so this is it:

var onError = function onError(data, status, headers, config){
 console.log('failure');
 console.log(data);
}

It simple logs the data to the console.  In a real app you would want to display information to the user, but that Is not needed here.  This is the onPostObjectSuccess() method:

var onPostObjectSuccess = function onPostObjectSuccess(data, status, headers, config){
 console.log('success');
 console.log(data);
 $scope.postResultObject = data;
}

This logs the returned data to the console, and uses it to set the controller’s postResultObject variable, which will in turn update the display.

If you set this up and try to execute, you will get unexpected results returned from the server. 

Instead of the number 3, you’ll see a bunch of HTML.  The ColdFusion server does not the parameter object as individual form variables, instead they are sent as a single object.  Since there is no method variable, ColdFusion does not try to execute the service method, but instead tries to load the CFC, which redirects to an Administrator login page.  The HTML of the login page is what is returned.

For comparison’s sake, this is what is shown in ServiceCapture for the call:

The ‘text’ is sent as one big JSON object.  That is not what we want.

Calling the Service with a Query String, and why it didn't work

The next approach I tried was to send the parameters along as if they were a query string.  First, let’s add the UI elements, the button and the place for the header:

<input type="button" value="Sum Via Post String" ng-click="onPostString()" />
<b>Post No Header Result</b>: {{postResultString}}<br/>

Back to the JavaScript block, and add the variable to hold the results from this:

$scope.postResultString = 0;

Next create the onPostString() method:

$scope.onPostString = function onPostString(){
 console.log('onPostStringNoHeader');
 parameters =    "num1" + '=' + 1 + '&'
 parameters +=   "num2" + '=' + 2 + "&"
 parameters +=   "method" + "=" + "sum" ;
 $http.post('/com/dotComIt/samples/callingCFC/TestService.cfc', parameters).success(onPostStringSuccess).error(onError);
}

The code uses string concatenation to create a parameter string, which will look like 'num1=1&num2=2&method=sum'. This is very similar to using a Query string.

The onPostStringSuccess() method just outputs the results to the console and updates the postResultString variable:

var onPostStringSuccess = function onPostStringSuccess(data, status, headers, config){
 console.log('success');
 console.log(data);
 $scope.postResultString = data;
}

If set this up and try it, the same thing will happen:

This is the same problem we previously saw.  ColdFusion doesn’t see the method name in the request and tries to launch the CFC in the CFC Explorer.  The page returned is asking for an administrator login.  This is the ServiceCapture information:

Although, we can see our parameter string as part of the call, there are no formal parameters attached to it; so ColdFusion can’t determine how to handle the call.

Calling the Service with a Query String, and getting expected results

The problem with the two previous calls is that the parameters are not being added to the call with the correct content type to create, what is essentially, a form post.  To solve this, we’ll need to specify the appropriate header.  First, add this to your HTML:

<input type="button" value="sum Via Post String w/ Header" ng-click="onPostStringWithHeader()" />
<b>Post Result With Header</b>: {{postResultStringWithHeader}}<br/>

This code snippet will call a method on the controller, and then display the results.  It works just like our previous two samples.

Create the postResultStringWithHeader variable in the Angular Controller:

$scope.postResultStringWithHeader = 0;

Next, create the method for making the remote call:

$scope.onPostStringWithHeader = function onPostStringWithHeader(){
 parameters =    "num1" + '=' + 1 + '&'
 parameters +=   "num2" + '=' + 2 + "&"
 parameters +=   "method" + "=" + "sum" ;
 $http.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
 $http.post('/com/dotComIt/samples/callingCFC/TestService.cfc', parameters).success(onPostStringWithHeaderSuccess).error(onError);
}

This code is almost, identical to the previous approach.  The most important change is that it sets the header for the HTTP calls to ‘application/x-www-form-urlencoded’.  This is the secret sauce that made the remote calls magically work.  This is the result method:

var onPostStringWithHeaderSuccess = function onPostStringWithHeaderSuccess(data, status, headers, config){
 console.log('success');
 console.log(data);
 $scope.postResultStringWithHeader = data;
}

The result method displays the returned data to the console and stores it for display in the HTML template.

These are the successful results, displayed in the browser:

This is the request from service capture:

You can see that this request has a formal parameter tab as part of the call.  When this request gets to the server, ColdFusion is able to correctly discern the request and determine which method should be called and how to handle the parameters.  We have achieved success.

Final Thoughts

A more in depth solution to what is going on under the hood is written up here. It also provides additional details on handling arrays and objects, which are important to many aspects of development.  I have spent a couple days researching the different methods to communicate between Angular and ColdFusion without rewriting code, or adding JQuery Dependencies, and this has been the most elegant.

Sign up for DotComIt's Monthly Technical Newsletter

How to Fail Fantastically: My 360|Stack Session Results + Video

At 360|Stack I gave a presentation entitled "How to Fail Fantastically" session results. I recently got the results from my survey. Only three people provided results this time; and there was only one comment.

I got two 5 ratings and one 4. I assume the ratings are out of 5; so that is pretty good. There was one comment left:

A very good presentation of things to watch out for if you want to run your own company, or for almost any venture you want to be a part of.

The comment is pretty complimentary. I do notice that since the went digital in their session survey's the ratings are fewer, as are the comments. I think people are less likely to type long comments into a smartphone.

And I promised a video, so you can view the presentation here.

More Entries

All Content Copyright 2005, 2006, 2007, 2008, 2009 Jeffry Houser. May not be reused without permission
BlogCFC was created by Raymond Camden. This blog is running version 5.9.2.002.