Put IT in High Gear - Engage!

All Fun and No Play Makes for a Boring Website – Gamification

engage — Wed, 16 May 2012 00:53:14 +0000

I have a website, but my web analytics indicate I am getting a consistently low volume of web traffic to my website and not many users are staying long on my website, what can I do to re-energize and engage user’s to my website? Simply put, gamification!
Many people when they here this instantly think, am I hooking up an Xbox to my website? Whereas this sounds a bit off the wall, there is a part of this that is somewhat true. Gamification is the use of game design techniques, game thinking and game mechanics to enhance non-game contexts on websites.

Typically, the concept of gamification applies to non-game applications and processes, in order to encourage people to adopt them, or to influence how they are used. Gamification works by making technology more engaging, by encouraging users to engage in desired behaviors, by showing a path to mastery and autonomy, by helping to solve problems and not being a distraction, and by taking advantage of humans’ psychological predisposition to engage in gaming. The technique can encourage people to perform chores that they ordinarily consider boring, such as completing surveys, shopping, filling out tax forms, or reading web sites. Available data from gamified websites, applications, and processes indicate potential improvements in areas like user engagement, ROI, data quality, timeliness, or learning.

Engage Relativity offers a gamification function called Motiv8 ™. Relativity Motiv8™, an extension of Engage, Inc.’s Relativity™ Platform, provides a framework integrating ‘Game Layer’ functionality with line of business application logic, transforming the result into a system for tracking, incenting and rewarding site member and/or employee behaviors through assigned or arbitrary status symbols(i.e. badges, levels and the like) – i.e. ‘behavior-steering game dynamics’. The baseline features focus on the tracking and management of achievements while other components may optionally surface this data on a community portal, within SharePoint, Silverlight or other similar dashboards.

At the highest level, the Relativity Motiv8™ framework works within the Relativity™ Platform to integrate external data and systems, purpose built plugins, and custom integration services; creating “actions” within line of business applications (Microsoft Dynamics CRM 2011). Each action is assigned a type. Administrators configure promotion paths, personalization levels and requisite conditions as badges and badge conditions. Scheduled services review the users and contacts, all of their actions and matching conditions and determines if they qualify for any new badges, promotions or levels.
As an example, an employee who completes X cases at a certain approval level in a given month may win the “Customer Satisfaction” badge, or may be promoted from a “Level 1 Customer Service Rookie” to a “Level 8 Customer Serenity Guru.” Badges are earned and levels achieved when a user has a score in a given category meeting badge conditions. Whenever a new action is created, badge conditions tied to the action’s category are checked and new achievements applied as may be applicable.

The solution can be applied internally for staff and team members (goaling, KPI, telework) as well as externally for customers, constituents and partner organizations.

All Fun and No Play Makes for a Boring Website – Gamification is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

No related posts.

CRM and Object Oriented Javascript Part IV

engage — Wed, 19 Oct 2011 21:19:23 +0000

This is part of a four part series on CRM and object oriented Javascript. Follow the links to parts I, II, and III.

Last post we did a detailed walkthrough of our object oriented form handler . At the end, we promised an explanation of why you might want to take this approach rather than the traditional giant “if-then-else-if” block. Well wait no longer. Here we’ll list a whole host of reasons to take the object oriented approach

Testability

One of the real hassles of CRM javascript development is the edit-publish-debug-edit-publish round trip that happens with every change. With a lot of changes, the time can really add up, especially since it’s easy to make typos in javascript. So one significant advantage of the OOP approach is that we can’t test most of our javascript without a CRM server. Take a look at our code again. Of those four sections we organized the code into, how many of them directly reference CRM fields or objects? One, CreateXrmFormRulesMethods. What we’ve managed to do with this code is separate out the CRM specific stuff from the stuff that deals with the business logic of our application. Which means that we can actually do some basic testing of those parts of our code without a CRM Form.

For this, we rely on the javascript unit testing framework jUnit. We won’t go into detail on jUnit here, because it’s extensively documented elsewhere, but if you’re familiar with other unit testing frameworks like MSTest or Nunit, it’s the same basic idea. In our specific situation, we run the test by mocking the ui object we passed into the form handler constructor. Here’s a basic example of a mock object:

XRM = {};
XRM.executeFormRules = function(formRules){
	var result = [];
	$.each(formRules, function(){
		switch(this.type)
		{
			case "hideSec":
				result.push(this.section + " section in tab " + this.tab +  " was hidden");
				break;
			case "hideTab":
				result.push(this.tab + " tab was hidden");
				break;
			case "hideField":
				result.push(this.field + " field was hidden");
				break;
			case "reNameSec":
				result.push(this.section + " section in tab " + this.tab + " was renamed " + this.newName);
				break;
			case "insertField":
				result.push(this.field + " was inserted " + this.insert + " " + this.moveTo);
				break;
			case "moveSec":
				result.push(this.section + " section was " + this.moveType + "ed to " + this.moveTo);
				break;
		}

	});
	XRM.formResult = result

}

In our case this mock object has it’s own executeFormRules method, but this one just creates an array. We can compare that array to an expected array, and test that our code is working.

In our specific case, this is somewhat overkill, but in situations where you may have more complex business logic, this testability is definitely an advantage. Especially considering that a lot of javascript debugging is a matter of typos and syntax issues, using jUnit can definitely streamline that portion of the debugging.

Portability

The fact that we can test most of our logic without a CRM form means that we can also port our stuff between versions of CRM more easily as well. Again, since the only piece that actually interacts with the form is the object defined CreateXrmFormRulesMethods, we can use most of the same code in CRM 4.0, CRM 2011 and even in whatever comes next. It’s simply a matter of creating an object with the right method names with code that is targeted to CRM 4.0.

Readability

It may seem odd to argue that the OOP version of form manipulation is more readable, since it uses code and concepts that may not be familiar to a lot of developers, but if we focus on the part of the code that actually has the business logic, it’s extremely readable. It’s just a an array with section names and actions. It makes the parts of the code most relevant and likely to see the most updates very readable.

Maintainability

Along with that readability comes great maintainability. Adding new business logic is simply a matter of a new entry in the array. With simpler syntax, there’s less room for typos, making updates very easy.

Conclusion

In some cases, going with a full OOP set up for your CRM javascript is probably overkill, but in a lot of cases it can streamline development and improve maintainability. Even if you don’t use a full OOP setup like we did in this series you can take some of the ideas and improve your CRM code significantly.

CRM and Object Oriented Javascript Part IV is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

CRM and Object Oriented Javascript Part III

engage — Tue, 13 Sep 2011 16:15:34 +0000

This is part three of a multi-part series on CRM and object oriented javascript. Follow the links for parts I and II

In this post, we will digg a little deeper into the functions we outlined last time. We’ll tackle the code in the order it’s written.

FormHandlerBaseClassSetup

Last time we mentioned that this section was responsible for setting up the equivalent of an abstract class for our form handlers. There’s actually a little bit more going on here than that. This function also handles setting up our namespace. Recognize this bit of code here?

if (typeof CRM == "undefined" || !CRM) {

	CRM = {};

};

CRM.namespace = function() {
	var a=arguments, o=null, i, j, d;
	for (i=0; i<a.length; i=i+1) {
		d=a[i].split(".");
		o=window;
		for (j=0; j<d.length; j=j+1) {
			o[d[j]]=o[d[j]] || {};
			o=o[d[j]];
		}
	}
	return o;

This was from our first post in this series, the namespacing function. So the first thing we’re doing in this class is setting up our global namespace.

After that, we take on the task of actually setting up our abstract class

ns = CRM.namespace('CRM.FormHandlers');
ns.AbstractFormHandler = function(ui, data){ 

	this.formRules = [];
	this.executeFormRules = function(){ ui.executeFormRules(this.formRules)};
};

There’s not much here, just a couple of stubbed out methods and properties. There are a few little thins worth noticing though. Take a look at our constructor. You’ll notice it’s got two parameters, “ui” and “data.” Our absract class isn’t using data at all, but we are using the “ui” object. We’ll get into the logic behind this later in this post.

SetupFormHandlers

In SetupFormHandlers, we’re creating classes that implement the abstract class we defined above. As we talked about in the first post, creating a class is just a matter of adding a new method to our namespace. To make this class inherit, from our base, we use the jQuery extend function.

There are a couple key things to notice here. First, you’ll see that the class names are the combination of the entity type, and the value of the new_type field. This naming convention becomes important in the last section of our program. You’ll also see that the only thing that these implementations do is override the formRules property of our abstract class. Basically for each formHandler, we list the actual changes we want to have happen to the form. However, we don’t actually put the code that makes those changes in place until the next section.

CreateXrmFormRulesMethods

In this section, we’re defining the algorithms that actually handle manipulating the form. We actually store the algorithm’s inside of CRM 2011′s Xrm.Page.ui namespace, creating a new object and subnamespace, “FormRules.” There’s no reason we can’t extend the Xrm object or subobjects like this, so long as we’re careful that our names of our namespace objects don’t clash with those of Microsoft.

This custom FormRules object is basically just a container for a series of functions that manipulate the form in very specific ways. Each one of these methods takes the same parameter, an object named rule. Each rule is one of the formRules we defined in SetUpFormHandlers.

Aside from defining our functions that manipulate the form, there’s also this snippet of code.

Xrm.Page.ui.executeFormRules = function(formRules)
{
	$.each(formRules, function(){
		if(this.type)
			Xrm.Page.ui.FormRules[this.type](this);
	});
};

Here we’re adding a new method to the ui object, executeFormRules. This code employees the strategy pattern we talked about the first post. The method takes in a list of rules from one of our form handlers, loops through each rule, checks that it has a property “type” and then finds an executes the method from FormRules that has the same name as the type, passing in the rule as a parameter.

ExecuteFormRules

Now we come to the final part, that ties it all together. There’s so little code, so let’s just copy it all here and go line by line.

ns = CRM.namespace("CRM.FormHandlers");
handlerName = Xrm.Page.data.entity.getEntityName() + "_Type" + Xrm.Page.getAttribute("new_type").getValue();
handler = new ns[handlerName](Xrm.Page.ui);

handler.executeFormRules();

First, we put ourselves in the CRM.FormHandlers namespace where we defined all the FormHandlers. Then we build a string that will end up matching the name of the appropriate form handler. We use that string to select the right form handler object from our CRM.FormHandlers namespace and we generate a new instance of that object, passing in the Xrm.Page.ui object. Finally we call the executeFormRules() object on that handler.

The executeFormRules method is the method defined earlier in our abstract class, consisting of the following one line of code.

ui.executeFormRules(this.formRules)

That line simply calls the executeFormRules method the first parameter passed into our form handler constructor. In this case, that is the Xrm.Page.ui object. In the CreateXrmFormRulesMethods section, we added an executeFormRules method to that object, so it’s our new custom method that get’s executed at this point. As we discussed above, that method loops through the list of rules passed in as a parameter, and actually executes the algorithms that will hide, move, or rename the form elements as appropriate.

Wrap Up

This basically offers a solid example of how to build an Object Oriented form handler. I’m sure the question a lot of you have though is why. We’ll talk through the advantages of and reasons for this kind of architecture in our next post.

CRM and Object Oriented Javascript Part III is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

Dynamics CRM Forms and Object Oriented Javascript Part II

engage — Sat, 21 May 2011 22:30:39 +0000

This is a continuation of a series on using Object Oriented Javascript with Dynamics CRM. For Part I, go here

Okay, so now that we’re all experts on Object Oriented Javascript, let’s try to apply this problem to the matter at hand; showing and hiding fields on a CRM form. Let’s start off by establishing some requirements and context around this task

Requirements

Let’s assume we’re dealing with the native CRM account form. Our requirement is to display a different form depending on the value of a crm field with the name new_type.
For each value of new_type, we’re going to make a slew of different form changes. Fields will show and hide, move around, and may even have different names.
You’re business users are always requesting the addition of new choices to that type field, along with custom forms. You need to make sure it’s easy to add a new type and customize it’s form.

If you’re on CRM 2011 you’re first inclination might be to try and use the multi form features, that let you have different forms based on security roles. However, in our experience, trying to have the right form load at runtime based off of a CRM field type is more trouble than it’s worth, slowing the process down with lots of refreshes, and requiring some frustrating maintenance. In fact this set of requirements is really perfect for Object Oriented Javascript.

You’ve Got to Have a Strategy

A Non-OOP Javascript veteran is likely to attach this problem with a giant switch statement, or a whole slew of is -elseifs. This will get the job done, but it’s not pretty or easily maintainable. The code will be long, with lots of repetition, and probably difficult to read.

Leveraging Object Oriented Javascript, we can come up with a much more elegant and straightforward solution. The key concepts in this solution are smart namespacing (discussed in part one) and something called “The Strategy Pattern.”

At it’s heart, the strategy pattern is basically a programming technique where some your program can select an appropriate algorithm for a given behavior from a whole set of algorithms. Generally implementations of the strategy pattern try to rely on “convention” rather than “configuration.” That is they try to use inherit properties of the context to handle the algorithm selection, rather than relying on explicit configuration.

It all sounds very abstract, but it starts to make a lot of sense, when you see it in action. Let’s take a quick look at a full OOP javascript program that does this. Just a quick warning, you’re about to see a lot of code, so you may want to scroll to the end when we start dissecting the explanation.

function FormHandlerBaseClassSetup(){ if (typeof CRM == "undefined" || !CRM) {

CRM = {};


};
CRM.namespace = function() {

var a=arguments, o=null, i, j, d;

for (i=0; i
d=a[i].split(".");

o=window;

for (j=0; j
o[d[j]]=o[d[j]] || {};

o=o[d[j]];

}

}

return o;

};
ns = CRM.namespace('CRM.FormHandlers');

ns.AbstractFormHandler = function(ui, data){
this.formRules = [];

this.executeFormRules = function(){ ui.executeFormRules(this.formRules)};

};

}
function SetupFormHandlers()

{

ns = CRM.namespace('CRM.FormHandlers');
ns.account_Type1 = function (ui,data){$.extend(true, this, new ns.AbstractFormHandler(ui,data))
this.formRules =[

{ type: "hideSec", tab: "detailsTab" , section: "detailsTab_ContactInformation"},

{ type: "hideSec", tab: "detailsTab" , section: "detailsTab_FamilyInformation"}

];

}
ns.account_Type2 = function (ui,data){$.extend(true, this, new ns.AbstractFormHandler(ui,data))
this.formRules = [

{ type: "hideTab", tab: "detailsTab"}

];

}
ns.account_Type3 = function (ui,data){$.extend(true, this, new ns.AbstractFormHandler(ui,data))
this.formRules = [

{ type: "hideField", field: "new_salutation"},

{ type: "reNameSec" , tab: "detailsTab", section: "detailsTab_Roles", newName:"Roles and Responsibilities"}

];
}

}
function CreateXrmFormRulesMethods()

{

if (typeof(Xrm.Page.ui) != "undefined")

{

ns = Xrm.Page.ui.FormRules = {};
ns.hideSec = function(rule){

window.Xrm.Page.ui.tabs.get(rule.tab).sections.get(rule.section).setVisible(false);
};
ns.hideTab = function(rule){

window.Xrm.Page.ui.tabs.get(rule.tab).setVisible(false);

};
ns.hideField = function(rule){

window.Xrm.Page.ui.controls.get(rule.field).setVisible(false);
};
ns.reNameSec = function(rule){

window.Xrm.Page.ui.tabs.get(rule.tab).sections.get(rule.section).setLabel(rule.newName);

};

}

}

function ExecuteFormRules() { ns = CRM.namespace("CRM.FormHandlers"); handlerName = Xrm.Page.data.entity.getEntityName() + "_Type" + Xrm.Page.getAttribute("new_type").getValue(); handler = new ns[handlerName](Xrm.Page.ui, Xrm.Page.data); handler.executeFormRules(); }

Don’t say I didn’t warn you. That’s a full 91 lines of code that has everything we need to manipulate forms based on our type field. Now we’re going to spend some time dissecting it in detail. What I’d recommend is that you copy the code into an editor that does code folding so you can look at it piece by piece (Notepad ++ is a favorite for javascript editing here.)

Breaking It Down

If you’re used to programming in traditional OOP languages like C#, then you probably approach most programs like this;

Set up reusable classes and methods
Chain them together in a main method that actually drives the program flow.

Generally javascript is no different, and the code above is architected in just that way. If you’ve got the code open in an editor with folding, you’ll be able to collapse the program down and see that it’s really made up of 4 functions.

function FormHandlerBaseClassSetup()

function SetupFormHandlers()

function CreateXrmFormRulesMethods()

function ExecuteFormRules()

The first three fit into category one, “Set up reusable classes and methods.” The last one is the equivalent of our main method that actually controls program flow. To implement the full program, we basically call these four methods in order, generally by using CRM 2011 built in functions for calling methods in javascript libraries.

So what exactly are those first three methods setting up? Well at a high level, it looks like this.

FormHandlerBaseClassSetup – Establishes an abstract class for an object we’re calling a FormHandler. A FormHandler is basically an object that has a series of rules that describe how a form should be modified. At this point we’re creating the equivalent of a C# abstract class, that defines some methods and basic logic, but leaves the specifics unimplemented.

SetupFormHandlers – Here we create actual implementations of our abstract form handler, where each implementation corresponds to the value of the new_type field. These implementations actually have specific rules that define how the form should look for each value.

CreateXrmFormRulesMethods – In the SetupFormHandlers function you see each form handler has a series of form rules, each one with a time. In the CreateXrmFormRulesMethods we actually define how that rule is actually accomplished in code. Essentially, we define all the methods and functions that handle doing the actual hiding, moving, and renaming of our form fields. One thing to note is that you can easily change the code in the class to target CRM 4.0 or CRM 2011, without changing either of the first two functions

ExecuteFormRules – This is the function that actually drives program flow. As you can see it’s fairly simple. All we do is create a new instance the appropriate form handler, based on the value of the new_type field, and then call that handler’s execute form function.

Next post, we’ll take a look at what each of these functions do specifically, and walk through the architectural decisions of how and why they were structured as they were.

Dynamics CRM Forms and Object Oriented Javascript Part II is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

Dynamics CRM Forms and Object Oriented Javascript

engage — Sun, 08 May 2011 02:09:52 +0000

Javascipt inside of CRM has historically been essential, but a bit of a messy affair. Things have improved in CRM 2011 with the advent of form libraries, but I think most CRM developers will admit they’ve worked on CRM projects where they wrote some scary spaghetti JavaScript. Sure, it got the job done, but it wasn’t pretty, and there was always the fear that the code was far more fragile than your well architected C# plugins and services; with there always being the hassle with CRM’s test-change-publish javascript debugging module, making javascript often something CRM developers actively look for ways to avoid.

The good news, is that with a little bit of object oriented magic, it’s possible to take a lot of the pain out of using Javascript and CRM, especially now in CRM 2011. Over several of our next few month’s posts, we’ll be walking you through using object oriented javascript to achieve a fairly common CRM goal: showing different forms for an entity based on the value of a certain field. We’ll start out this post by looking at the basics of object oriented javascript.

Object Oriented What?

That javascript can be written in an object oriented manner at all is somewhat of a little known fact in the web world. For the most part, developers really only use javascript in a procedural fashion, for simple little website flourishes. That’s starting to change with the advent of HTML5 and the growth of powerful web apps, but for many JavaScript’s object oriented capabilities are a well kept secret.

Part of the problem is that object oriented programming (OOP) in javascript looks very different than languages like C# and Java. There are no built in class declarations, no ready made inheritance. In fact, at a fundamental level JavaScript is ridiculously simple. It has less than a dozen built in types of objects, no built in name spacing, and no type declaration. But this apparently simplicity hides some incredible emergent capabilities.

Objects, Objects Everywhere

Let’s take a look at the basics of OOP in javascript. As we noted earlier, Javascript doesn’t have a lot of the pieces of OOP that we usually expect, like class declarations. So how do we do the javascript equivalent? Like this

Foo = function(){

//Insert constructor logic here

}

Now if we want a new instance of the Foo class we write

myFoo = new Foo();

Alright, but then what about properties, or methods, or passing parameters in the constructor? Easy, just declare them in your constructor, like so.

Ninja = function(weapon){

this.weapon = weapon;

this.sneak = function(){

alert(“The ninja is sneaking!”)

};

this.attack=function(){

alert(“The ninja attacks you with his ” + this.weapon);

};

}

Now we’ve got a Ninja class that can sneak, and attack with a weapon. It behaves just like we would expect a good object to behave

myNinja = new Ninja(“katana”);

myNinja.sneak();

//outputs “The ninja is sneaking”

myNinja.attack();

//outputs “The ninja attacks you with his katanta”

Javascript even supports private properties, with accessors. Let’s imagine we want to make our ninja more PC and allow the user to declare a gender for the ninja, but not change the gender after the Ninja’s been created.

Ninja = function(weapon, gender){

this.weapon = weapon;

var gender = gender;

this.Gender = function() { return gender};

this.sneak = function(){

alert(“The ninja is sneaking!”)

};

this.attack=function(){

var pronoun;

If (gender == “male”)

{

pronoun = “his”;

}

else if( gender ==”female”)

{

prounoun = “her”;

}

alert(“The ninja attacks you with ” + pronoun + ” ” + this.weapon);

};

}

Simply by leaving off the “this” when we declare the gender variable, we ensure it’s only available in the Ninja class. If a user developer wants to retrieve the Ninja’s gender, they just call Gender().

guyNinja = new Ninja(“katana”,”male”);

alert(guyNinja.Gender());

//outputs “male”

guyNinja.attack();

//outputs “The ninja attacks you with his katana”

girlNinja = new Ninja(“dagger”, “female”);

girlNinja.attack();

//outputs “The ninja attacks you with her dagger”

More Inheritance than you can shake an object at

So we have classes, but what about the next key to OOP, inheritance? Here’s where things get a little more complicated. There’s no built in syntax for inheritance in Javascript, instead you roll your own. The basic idea is to create an instance of the base object, copy all of it’s properties and methods to your inherited object, and then override the specific methods as needed. Of course, there are about 15 different ways you can do this, depending on what you need, or what javascript frameworks you’re working in.

For this series, I’ll show you a simple inheritance strategy based on jquery. It’s certainly not the only method, but it’s one that met our set of specific needs. When we came up with this method for inheritance, we were looking for something that didn’t require us to use anything beyond jquery (because we were already using that for other purposes) and could express the details of the inheritance on a single line, so that you could still see class relationships even when we were using code folding in our editor.

Bar = function (){$.extend(true, this, new Foo());

//rest of our constructor logic here

}

Although there are a lot of parenthesis, what’s going on here is pretty simple. We’re declaring a new class named Bar. Whenever someone creates a instance of bar by calling new Bar() the first thing we do is call the $.extend() method. $.extend() is a jquery method that simply copies all of the properties and methods of one object to another. In this case we’re copying all of the properties and methods of a new instance of the Foo class, to “this” the object being instantiated by our Bar constructor. The true parameter tells the extend method to do a recursive copy, to copy any properties and methods of child objects that are themselves a property of our Foo object.

So going back to our ninja, example, let’s create a class named Samurai that inherits from Ninja. Samurai, attack just like Ninja do, but they don’t sneak. We need to override the sneak method to make sure everyone understands that.

Samurai = function(weapon, gender){$.extend(true, this, new Ninja(weapon, gender);

this.sneak = function(){

alert(“Samurai don’t sneak! They’re noble warriors.”);

}

If we create a new Samurai, and call it’s methods, we get this.

mySamurai = new Samurai(“female”, “katana”);

mySamurai.sneak();

//outputs “Samurai don’t sneak! They’re noble warriors”

mySamurai.attack();

//outputs “The ninja attacks you with her katana”

Order out of Object Chaos

So we’ve hit on most of the big pieces of object oriented programming, but what about some of the nice to haves, like namespacing? Well again, Javascript doesn’t have anything built in, but you can create your own namespace system out of objects. In this series will be using the same namespacing strategy used by Yahoo in their popular YUI javascript framework. To do that, first we declare a namespace global variable.

if (typeof MyNamespace== “undefined”) {

var MyNamespace= {};

}

Here, we’re checking to make sure no one else is using the variable name, MyNamespace, and then assigning an empty object to it. Next, we’ll create the function that handles creating the namespace

MyNamespace.namespace = function() {

var a = arguments, o = null, i, j, d;

for (i = 0; i < a.length; i = i + 1) {

d = a[i].split(“.”);

o = window;

for (j = 0; j < d.length; j = j + 1) {

o[d[j]] = o[d[j]] || {};

o = o[d[j]];

}

return o;

};

There’s a lot going on in those lines of code, but basically, this function expects a lists of strings. For each string it gets, it splits the string into an array based on the “.” character. For each item in that array, it creates an object tree, or assigns new objects as properties to existing ones. So calling

MyNamespace.namespace(“MyNamespace.Fighters”) will first check to see if a MyNamespace object already exists. Since it does, it will move onto to the next part of the namespace, “Fighters.” Once it sees that “Fighters” doesn’t exist it will create a new empty object at MyNamespace.Fighters and return that object.

If you want to use a certain namespace, just capture the output of the namespace function.

ns = MyNamespace.namespace(“MyNamespace.Fighters”);

Then if you want to make sure the Ninja class is under the Fighters namespace, just do this

ns.Ninja = function(weapon,gender){

//constructor logic here.

}

Sociologist Need Apply – Gaming CRM

Tue, 12 Apr 2011 11:00:00 +0000

Adding a Game Layer for Better Participation

All of those hours spent in an arcade were not wasted. Can you believe it? If you reflect on your playing habits and reflect on why you did what you did or if you put your sociology hat on and go and visit Las Vegas you can improve the data in your CRM system and improve your customer participation in your website / blog or Facebook site.

People tend to be lazy or distrusting when filling in online forms. They will give you what you require if you make the fields mandatory IF the payoff is worth it. How many times did you want to see what was in a PDF but then were asked to fill out a form? Sometimes you filled it out and other times you clicked out of the site and moved on. If you trusted the site, you would have been more likely to fill in the information. If the payoff – the data in the PDF – was good enough you would have filled the form out. Now what if you were offered some other benefit to filing out the form or if you fill out the entire form you will get an additional PDF of equal or grater value.

The gaming layer enters the picture.

Creating a raving fan base needs a unique set of rules added to the relationship that will encourage them to introduce their friends to your business. The key to creating these raving fans and advocates is offering unique program for them and not a generic one size fits all campaign. Allowing your customers to adapt the “game” to best fit them will create a stronger relationship. Chris Brogan uses the analogy of people adapting how they play the game Monopoly in his book Trust Agents. Some people start off the game with $500 in the middle for those that land on “free parking” or others allow you to go again if you roll doubles but on the third roll of doubles you go to “jail”. By personalizing or “hacking” the game loyalty increases as well as fan buy-in into your company and product. A new culture will grow and then this culture will encourage new fans.

Your employees will do their best when time permits. When they get busy, they will prioritize their tasks in order to get their job done. One of the first things to go will be filling in customer data CRM consistently and completely. As all business owners know, your CRM system is only as good as the data that is inside. A simple badge or status symbol that is then attached to a perceived benefit to the employee could be introduced into the system to encourage more of an effort in entering up to date and accurate data. Allowing your employees to play a game while doing their job will increase their interest and satisfaction. Giving them a new “status” at work will encourage them to continue doing the best they can do. Allowing them to add onto the game and “compete” against other employees or departments will improve your culture.

How are you encouraging more participation by your employees and customers? Are they Fans?

Photo by Richard Heaven

Sociologist Need Apply – Gaming CRM is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

18 Ways to Have a Great Convergence 2011

Mon, 04 Apr 2011 21:25:16 +0000

Who to meet and what to say at Convergence 2011

When you come to Atlanta this year for another fantastic Convergence show you should have a game plan. Convergence is a big event and a great way to meet some of the most influential people in the Microsoft Dynamics CRM business. So while you are here in Atlanta enjoying all of the presentations and the showroom floor, please take some time to seek out these Microsoft Dynamics CRM industry leaders {Not in any particular order}. Here is who I would like to meet and what I would say:

Anne Stanton – Where to Find her – Presenting: IDCRM83-R1 Achieving Customer Service Excellence: Tips & Tricks with Microsoft Dynamics CRM 2011 What to say? – “Thanks for all of the great content and community contributions you have made.”
Larry Lentz – Where to Find him – Show room floor, at presentations, with the smart people. What to say? – “Thanks for all of the great content and community contributions you have made. Love your Twitter humor”
Todd Sharp – Where to Find him – Presenting: CSCRM37 Streamlining Citizen Services with Microsoft Dynamics CRM Online for Governments What to say? – “Thanks for all of your efforts to help our Government cut costs by using MSCRM for Correspondence Management solutions.”
Julie Yack – Where to Find her -Presenting: IDCRM21-R1 Microsoft Dynamics CRM Online: Your Questions Answered What to say? – “Thank you for all your hard work with the XRMVirtual Users Group.”
Donna Edwards- Where to Find her- Show room floor, at presentations, with the smart people. What to say? – “Thanks for all of the great content and community contributions you have made. Loved your post on SSRS Custom Reports.“
Erik van Hoof – Where to Find him – Show room floor in the CWR booth, at presentations, with the smart people. What to say? – “Thanks for a fantastic CRM mobile solution and for the pizza and beer.”
Mark Corley – Where to Find him – Presenting: CSBL03 Get Your TTV & ROI Mojo Going! What to say? – “Thanks for bringing us great products from CWRMobility“
Scott Sewell- Where to Find him – Show room floor, at presentations, with the smart people . What to say? – “Thanks for all of the great content and community contributions you have made.”
David Yack- Where to Find him – Show room floor, at presentations, with the smart people. What to say? – “Thanks for helping us extend CRM with Silverlight.“
Shan McArthur – Where to Find him – Presenting: CSCRM23-R1 Harnessing Cloud Technologies with Microsoft Dynamics CRM 2011 What to say? – “Thanks for all of your great content on building MSCRM solutions in Azure.”
Reuben Krippner - Where to Find him – presenting: CSCRM61 Microsoft Dynamics Labs: Graduating from Accelerators to Solutions What to say? – “Thanks for all of those CRM 4.0 accelerators. They saved us a bunch of time and made us look great.”
Joel Lindstrom- Where to Find him – Show room floor, at presentations, with the smart people. What to say? – “Thanks for all of the great content and community contributions you have made.”
Ben Vollmer – Where to Find him – Presenting: DDCRM62 Microsoft Dynamics CRM 2011 + Microsoft Technologies = Business Value What to say? – “Thanks for keeping MSCRM in the front of everyone’s mind when it comes to business solutions.”
Girish Raja – Where to Find him – Presenting: CSCRM23-R1 Harnessing Cloud Technologies with Microsoft Dynamics CRM 2011 What to say? – “Thanks for all of those great Channel 9 videos.”
Sanjay Jain – Where to Find him – Presenting: CSCRM37 Streamlining Citizen Services with Microsoft Dynamics CRM Online for Governments What to say? – “Thanks for all of those great Channel 9 videos.”
Gharun Hester Where to Find him – Presenting: CSCRM37 Streamlining Citizen Services with Microsoft Dynamics CRM Online for Governments What to say? – “Thanks for helping us keep MSCRM as the best solution for the public sector.”
Barry Givens – Where to Find him – Presenting: CSCRM02-R1 Advanced Analytics for Microsoft Dynamics CRM 2011 What to say? – “Thanks for pushing the developers and making MSCRM even better than before.”
Marc Wolenik – Where to Find him – Presenting: CSCRM85 The Social Enterprise: Real-World Customer Stories What to say? – “Thanks for keeping us informed with your CRM Unleashed books.

If you don’t get a chance to meet all of these CRM leaders, please take the time to look them up on Twitter or on their blog sites. Each one of them has provided me directly or indirectly with a wealth of information over the past few years.

Did I miss anyone? If I did, I’m sorry. Who you would add to the list?

18 Ways to Have a Great Convergence 2011 is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

No related posts.

Windows 7 Hidden Features

Dale Hulburt — Wed, 24 Nov 2010 12:38:18 +0000

I’m sure you’ve done this. You are using a well-known application and stumble on to some ‘hidden’ functionality it has and thought “Wow, this is Cool” why didn’t I know about it earlier. Well, that just happened to me with the Windows 7 Calculator tool.

Maybe many of you already know about these features and that’s great, but for everyone else – this is what I stumbled on.

Scenario:
Okay, I needed to do some minor addition; so I clicked Start and typed calc in search to bring up the calculator tool. After completing my task I started looking around the View menu and found some things I never knew were there.

The Standard Calculator stuff:
Under the View menu there is what you would expect to find – the various types of calculators such as Scientific.

But Wait There’s More:
So what’s this other stuff; Unit conversion, Date calculation and Worksheets.

Unit Conversion:

Want to know how many square feet in an Acre?

Date Calculation:

This is a good one for kids, big and small. Want to know how many days until Christmas?

Worksheets:

There are 4 Worksheets, all self-explanatory with the coolest being Mortgage.

The mortgage calculator has 4 different options, all easy to use and intuitive.

Are there other cool, hidden features in Windows 7? Let us know what you like about Windows 7?

Also, please see our events page for upcoming webinars on OCS, CRM, xRM, SharePoint and Business Intelligence.

Windows 7 Hidden Features is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

No related posts.

Using Microsoft Office Communicator – Jelly Beans

Dale Hulburt — Tue, 09 Nov 2010 12:25:43 +0000

What’s you’re status?

“Where are you?” and “What are you doing?” is usually followed up with, “Do you have time for …..?” With the simple Microsoft Office Communicator indicators you can easily tell. Some folks call them ‘jelly beans’, but at any rate below is a guide to their meaning.

We would recommend contacting Engage, Inc for any questions on Microsoft Office Communicator and its possibilities. Also, please see our events page for upcoming webinars on OCS, CRM, xRM, SharePoint and Business Intelligence.

Using Microsoft Office Communicator – Jelly Beans is a post from: Put IT in High Gear - Engage!
Put IT in High Gear - Engage! - Microsoft Gold Certified ISV Integrator and Cloud Hosting Provider delivering Microsoft Dynamics x/CRM, Unified Communications and a whole lot more.

CRM 2011 Beta – IFD/AD FS problem: The organization could not be identified

Scott Barr — Thu, 04 Nov 2010 12:46:45 +0000

Microsoft Dynamics CRM 2011 IFD and AD FS

As a Microsoft Partner, Gold certified, and experienced Dynamics CRM ISV since v 1.0, we set out to integrate one of our CRM 4.0 projects into CRM 2011 Beta. We quickly stood up a single server system to get the developers started and would follow-up with IFD afterwards. Since IFD setup is different than it was for CRM 4.0, we had to also setup an AD FS 2.0 server.

Downloading AD FS 2.0 was straightforward and seemed to install and configure by the book. The problem we ran into was deciphering the documentation for CRM 2011 Beta and Claims based authentication and IFD configuration.

We managed to get fairly close to a working IFD solution. AD FS 2.0 appeared to be doing its job by allowing a login but upon redirecting to CRM we were presented with the ubiquitous error “Invalid User Authorization” which translated to the organization could not be identified - also depicted in the URL below.

Invalid User Authorization

A review of the CRM Trace log in its default location C:\Program Files\Microsoft Dynamics CRM\Trace revealed the following errors – trimmed for brevity:

and this from the Application log in Event Viewer (also trimmed)

Log Name:      Application
Source:        ASP.NET 4.0.30319.0
Date:          10/24/2010 10:42:29 PM
Event ID:      1309
Task Category: Web Event
Level:         Warning
Keywords:      Classic
User:          N/A
Computer:      CRM2011B.devdomain.net
Description:
Event code: 3005
Event message: An unhandled exception has occurred.
Event time: 10/24/2010 10:42:29 PM
Event time (UTC): 10/25/2010 2:42:29 AM
Event ID: e89163e8f686404c960b18b0a357cca5
Event sequence: 5
Event occurrence: 1
Event detail code: 0

Application information:
Application domain: /LM/W3SVC/1/ROOT-1-129324480343019563
Trust level: Full
Application Virtual Path: /
Application Path: C:\Program Files\Microsoft Dynamics CRM\CRMWeb\
Machine name: CRM2011B

Process information:
Process ID: 4800
Process name: w3wp.exe
Account name: DEVDOMAIN\crm2011betasvc

Exception information:
Exception type: CrmException
Exception message: The current organization id could not be determined.
at Microsoft.Crm.Application.Security.UserInformationIdentity.get_OrganizationId()
at Microsoft.Crm.Web.Default..ctor()
at __ASP.FastObjectFactory_app_web_0qwmtita.Create_ASP_default_aspx()
at System.Web.Compilation.BuildManager.CreateInstanceFromVirtualPath(VirtualPath virtualPath, Type requiredBaseType, HttpContext context, Boolean allowCrossApp)
at System.Web.UI.PageHandlerFactory.GetHandlerHelper(HttpContext context, String requestType, VirtualPath virtualPath, String physicalPath)
at System.Web.HttpApplication.MapHttpHandler(HttpContext context, String requestType, VirtualPath path, String pathTranslated, Boolean useAppConfig)
at System.Web.HttpApplication.MapHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute()
at System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously)

The real clue here being the Organization and User data was null so no real attributes were being passed from AD FS to CRM so troubleshooting AD FS was a good starting point.

Searching the internet revealed clues here and there until we ran across a couple of posts in the Microsoft CRM 2011 Beta forum where Matios suggested using an LDAP Claims rule and his suggestion was reinforced by Zegor so we concluded his solution worked more than once and in different environments. We set out on a path of trying different permutations of LDAP claims rules to no avail.

We dialed up AD FS 2.0 Tracing by following this article on Diagnostics in AD FS:

When editing the Microsoft.IdentityServer.ServiceHost.Exe.Config file change the switch value from ‘Off’ to ‘Verbose’. These values are case SeNsiTiVE by the way because we received a flurry of errors when we tried setting the values to ‘verbose’ instead of ‘Verbose’ and restarting ADFS service.

In the meantime, we replied to the aforementioned forum post and asked for some detail on the LDAP claims rule – Patrick Verbeeten was in the thread and he replied very quickly, on a Saturday nonetheless. By this time we felt we were well versed in AD FS claim rules, at least, enough to know his response made sense, unfortunately it did not have immediate positive results.

Upon reviewing the AD FS 2.0 Tracing Debug Log:

LDAPAttributeStoreReader: No results were returned for LDAP query with filter ‘samAccountName=sbarr_engage2day.com’.

Ad FS 2.0 LDAP Warning

We found that the samAccountName attribute was not yielding results when the LDAP query was initiated against the Attribute Store (Active Directory). We tried to get more detail by running Process Monitor and Wireshark (my long time favorites for troubleshooting) but could not see a valid response; however, we did see the LDAP traffic between the AD FS server and the domain controller.

Finally, it dawned on me that the AD FS 2.0 service account must not have permissions to execute an LDAP query. Upon applying ‘List Contents’ permissions (actually dropping the service account into the Pre-Windows 2000 Compatible Group since it already had those permissions) the result was immediately positive. We were able to login successfully to the CRM 2011 organization on the first attempt following a restart of the ADFS service.

The LDAP rule that ultimately worked was as follows:

In Ad FS 2.0 | Trust Relationships | Claims Provider Trusts, right-click Active Directory, select Edit Claims Rules

Add Rule… |enter appropriate Claim rule name | Select attribute store Active Directory

Under Mapping of LDAP attributes to outgoing claim types: set the LDAP Attribute to User-Principal-Name and set the Outgoing Claim Type to UPN

Click OK

The only necessary Relying Party Trust claim rule necessary from the IG is the Pass through rule for UPN.

The net result is that IFD works as advertised when using the undocumented LDAP claims rule. Don’t forget to modify the CRM web.config file element from “OnPremise” to “ServiceProviderLicenseAgreement” and restart IIS.