Code Ciel

JavaScript Object Literal

2012-04-11T08:09:00.005-07:00

JavaScript Object Literal

The latest best practices in javascript recommend that object literal notation be used to create a namespace feature of sorts. Object literal notation is ridiculously easy to use and gives a great deal of power to the developer. Here is an example-laden crash course.

Introduction: Definition and Purpose

What is an object literal? In nontechnical terms, it is a means of containing a lot of data in one tidy package. It is a comma separated list of name value pairs wrapped in curly braces. In JavaScript an object literal is declared or defined as follows:

 var myObject = {}

An object literal with a few properties, from a Rotating Images example:

 var myRotator = {

    path: 'images/',

    speed:  4500,

    images: ["smile.gif", "grim.gif", "frown.gif", "bomb.gif"]

Object literals are used as a means of encapsulating data, avoiding the use of global variables which can cause problems when combining code.

How and Why We Use Object Literals

Objects literals enable us to write code that supports lots of features yet still make it a relatively straightforward for the implementers of our code. No need to invoke constructors directly or maintain the correct order of arguments passed to functions, etc.

Object literals are also useful for unobtrusive event handling, as a way of holding data that would otherwise have been passed to functions called from HTML event handler attributes.

Basic Syntax

Object literals are formed using the following syntax rules:

A colon separates property name from value.
A comma separates each name/value pair from the next.
There should be no comma after the last name/value pair. Firefox won't object if you add it, but Internet Explorer will trigger an error: 'Expected identifier, string or number'.

Values can be of any data type, including array literals and object literals. Referring to themyRotator example above, the images property is an array literal. An array literal is a shortcut to create an array in JavaScript, just as the object literal is the shortcut to object creation:

 var myArray = new Array(); // array literal form: var myArray = [];

An example of an object literal with the value of the properties being object literals, from a Tooltip demo:

 dw_Tooltip.content_vars = {

    link1: {

        img: 'images/dw-btn.gif',

        txt: 'dyn-web button',

        w: 100

},

    link2: {

        img: 'images/dot-com-btn.gif',

        txt: 'dyn-web.com button',

    w: 184

If any of the syntax rules are broken, such as a missing comma or colon or curly brace, a JavaScript error will be triggered. Both Firefox's and Internet Explorer's error messages are helpful in pointing out the general location of object literal syntax errors. They will not necessarily be completely accurate in pointing out the nature of the error though. If you are not sure where to find the error messages, see our tutorial on JavaScript Errors for more information.

Adding Properties to an Object

Once an object literal has been defined you can later add more properties to it as demonstrated below.

 dw_Tooltip.content_vars = {

    // May be empty at this point or already have properties, as shown above

 // Add more properties using the following syntax:

 dw_Tooltip.content_vars['link3'] = 'content for link 3';

 dw_Tooltip.content_vars['link4'] = {

    caption: 'A Heron',

    img: 'images/heron.gif',

    txt: 'A heron image created from a character font.',

    wrapFn: dw_Tooltip.wrapTextByImage,

    w: 210

Be sure to observe the syntax differences when adding properties this way: i.e., an equals sign rather than a colon separates property and value, and an optional semicolon ends the assignment rather than a comma.

Further Resources

For more information on object literals and related issues see the following:

List of links on the subject at ScriptTags.com
Patrick Hunlock's Mastering JSON ( JavaScript Object Notation )
Dustin Diaz on JSON for the Masses
Jonathan Snook on Objectifying JavaScript

Helping increase your SEO - link juice

2012-04-11T06:32:00.000-07:00

Author : alexanderdickson.com
Url : http://www.alexanderdickson.com/articles/jquery-javascript/a-new-way-of-creating-objects-in-javascript/

These days, SEO is very important, and links on your page are an important part of improving your rankings. It is important to know a few things about the links on your page and how to improve them.

It is generally accepted a few major points concerning links on a page.

Links placed higher up in the markup are worth more than those appear closer to the end.
The text used as the anchor text is important (as is the title attribute).
The more links you have on your web page, the less juice they will receive.
You can tell search engines to not give link authority on a page by adding rel="external" to your anchors.

Location of links in markup

The closer to the top your link is in the markup, the better it will be ranked. If you'd like your links closer to the top, but don't want them to appear there in your layout, you can by using CSS to position them.

Anchor text

Look at the 2 examples below.

<p>
    You can now buy the Awesome FooBar by clicking
    <a href="http://www.example.com">here</a>
</p>

Example 1: Poor choice of anchor text.

<p>
    You can now buy the <a href="http://www.example.com">Awesome FooBar</a>.
</p>

Example 2: Better choice of anchor text.

In case it wasn't obvious, the second example is much better for SEO. Your linking text is important. You can also help by adding a title attribute, but remember to not over do it! The more words you try and cram in there, the less important they will become! I have a feeling small words like the, and, a,etc won't be included because they don't provide any real meaning.

Quantity of links per page

To search engines, less is more. When selecting what to link to, make sure you link sparingly to good trusted (and if possible, related) sites.

Delegating link authority with rel="nofollow"

One important thing to know is that if you add rel="nofollow" to an anchor, you've effectively told search engines not to give it any authority. This is very important when accepting user input that may contain links. I have purposely not done this on my own comments, as I am giving the users a chance to show they can be trusted. See the example below of a nofollow'd link.

<a href="http://www.pureevil.com" rel="nofollow">I am an evil spam link.</a>

Disuade spammers: Add rel="nofollow" to user entered links.

On large volume sites, adding the nofollow is very important to disuade spammers. They are far less likely to add links to your comment box or similar if they know the links will be automatically nofollow'd. Another imporant use is to not dilute your link juice. Instead of losing the juice because there are many links on your page, simply nofollow the links you care less about, and return the power to the links you love!

6 Ways Men and Women Communicate Differently

2012-04-10T15:36:00.001-07:00

By YOURTANGO EXPERTS

This guest article from YourTangowas written by Richard Drobnick.
Men and women are different in many ways. They see the world through completely different perspectives. The key to understanding their differences is in the way that men and women communicate.
Here are six important communication differences that you should be aware of, to help improve your communications with your partner and make them smoother and more effective.

1. Why Talk?

He believes communication should have a clear purpose. Behind every conversation is a problem that needs solving or a point that needs to be made. Communication is used to get to the root of the dilemma as efficiently as possible.
She uses communication to discover how she is feeling and what it is she wants to say. She sees conversation as an act of sharing and an opportunity to increase intimacy with her partner. Through sharing, she releases negative feelings and solidifies her bond with the man she loves.

2. How Much Should You Say?

He prioritizes productivity and efficiency in his daily life, and conversation is no exception. When he tells a story he has already sorted through the muck in his own head, and shares only those details that he deems essential to the point of the story. He might wonder, “Why do women need to talk as much as they do?” Often he will interrupt a woman once he has heard enough to offer a solution.
She uses communication to explore and organize her thoughts — to discover the point of the story. She may not know what information is necessary or excessive until the words come spilling out. But a woman isn’t necessarily searching for a solution when she initiates a conversation. She’s looking for someone to listen and understand what she’s feeling.

3. What Does It Mean To Listen?

He is conditioned to listen actively. When a woman initiates conversation he assumes she is seeking his advice or assistance. He engages with the woman, filtering everything she’s saying through the lens of, “What can we actually do about this?” Learning to listen patiently — not just passively — doesn’t come easily to him.
She sees conversation as a productive end in and of itself. If she feels sufficiently heard or understood she may not need to take further action to resolve a problem or “make things better.” The fact that she has been listened to assuages her anxieties and dulls the pangs of negative feelings. Sharing with someone who understands and loves her heals her from the inside and equips her with the emotional tools necessary to handle the trials and tribulations of the outside world.

4. When She Is Feeling Down …

He will want to tackle her problems head on, like a fireman. He feels impatient to put the fire out as quickly as possible. For him, the quickest way to put the fire out is by giving solutions. Because he wants so badly to provide for his spouse, he may take her mood personally and defend himself. He might hear things literally, not realizing that when his spouse is upset she will use words as tools to explore and express difficult emotions.
By using words as tools to explore and express her difficult emotions when she is upset, she is able to process her negative emotions and let them go. She values support and nurture, and is most fulfilled by sharing, cooperation and community. When he shows interest in her by asking caring questions or expressing heartfelt concerns she feels loved and cared for. He is fulfilling her first primary love need.

5. When He Is Feeling Down …

He will often withdraw into his “cave” (becoming quiet and withdrawn) when he’s upset or stressed. A man’s “cave time” is like a short vacation: he reduces stress by forgetting about his problems and focusing on other things like watching television, reading the newspaper, or playing video games.
He might avoid communication with his spouse during times of duress. If she persists with nurturing questions or criticism, he withdraws even further, fearing that his partner doesn’t trust him to take care of business on his own. However, with her support and understanding, a man will return and be more emotionally available, caring, and loving.
She might interpret her spouse’s silence as a sign that she is failing him or that she’s losing him. She instinctively tries to nurture him through his problems by asking an abundance of caring questions. Or she may react defensively out of fear that her own need for healthy open communication is not being respected within the relationship.
Ultimately, she can do more for him by appreciating his space, which shows him that she trusts him to work out the problem on his own. Trusting is one of the greatest gifts she has to offer him. In the meantime she should do something nurturing for herself, so she won’t resent him when he emerges from his “cave time.”

6. Communication Breaks Down When …

He feels like he’s being told what to do. The most important thing to a man is doing a good job. When his competence is questioned he’ll not only feel hurt, but he’ll throw up a wall of resistance, and communication begins to breakdown. He thrives in an environment where he’s the expert. Rather than being told, “You should do X” he is likely to respond better to, “What do you think of X?” The trick to improving him is to resist telling him what to do.
She hears from her spouse that her problems aren’t as real and pressing as they seem in that very moment. Her spouse may mistakenly think he’s being helpful in providing “reality checks” like:“You’re making a mountain out of a mole hill” or “You’re getting overly emotional about it.” To her it feels like he is attempting to minimize her feelings or talk her out of having them.
Men and women desire to satisfy their partners, but they may miss the mark because it is truly difficult to understand and accept our partner’s different ways of communication. Men and women need education on these differences to help their relationships, so they do not end up in a frustrated state of resentment and feel stuck.
If a couple is feeling stuck, I suggest they read or listen to couples self-help books together. If the couple still feels stuck, then they should always seek professional counseling and get back on the road to better understanding and communication.

Introduce to STORM

2012-04-04T04:54:00.004-07:00

Recently I am working with Webservice on Framework .NET and I found a wonderful tool for testing web services. It helps me a lot, so I want to share it with you.

STORM :

is a free and open source tool for testing web services.

It is written mostly in F#

STORM allows you to

1. Test web services written using any technology (.NET , Java, etc.)

2. Dynamically invoke web service methods even those that have input parameters of complex data types

3. Save development time and money. Creating throw-away test client apps just to test the web service is just too wasteful

4. Test multiple web services from within one UI.

5. Edit/Manipulate the raw soap requests.

6 Others (Try out the tool and find out yourself!)

Requirements :

.NET Framework 2.0

F# 1.9.3.14 (OPTIONAL) - Releases labeled with ""standalone" doesn't need F# to be installed on the machine

QUICK GUIDE :

1. Add a web service

Click Add -> type in the wsdl endpoint URL.

Sample URLs

- http://www.deeptraining.com/webservices/weather.asmx

- http://api.google.com/GoogleSearch.wsdl

- http://webservices.imacination.com/distance/Distance.jws?wsdl

2. Select a web method (TreeView on the left side). This will cause the tool to analyze the web method and display the parameters (if any) needed to invoke the method

3. Select a web method parameter and provide the necessary values

4. Click Go (Green arrow button). This will invoke the webmethod.

QUICK Instructions :

Section I.

************************************

LOADING A WEB SERVICE AND TESTING ITS METHODS

************************************

1. CLick ADD in the toolbar.

2. Provide the wsdl endpoint url

3. Click Go (Green arrow)

4. Select a web method. (Or right click and open it in a new tab)

5. Click Send

Section II.

************************************

SAVING SOAP REQUEST AS TEST CASES

************************************

1. Open the web service

2. Select a web method while in "Tree View" (lightning icon)

3. Click Send

4. Switch to "Raw View" or "Xml View" (for the Soap Input)

5. Edit the data.

6. Click Save. Choose "Test Data" option. Provide the test case label, notes. etc. Click OK.

7. The raw soap request message will now be part of the project.

8. To save the soap response as the the expected response, repeat steps 4-7 on response output generated in Step 3.

Section III.

**********************************************

SAVING THE CURRENT SESSION AS A STORM PROJECT

**********************************************

1. Assuming you already have an open web service(s) with or without test cases (see above instructions, section II)

click on the SAVE button in the toolbar

2. Provide the storm project name. CLick OK.

- This will create the following folder structure

{File} StormProject.stormproj

- {Folder} ServiceName

- {Folder} WebMethod

- {Folder} TestCaseName

- {File} TestInputLabel_testinput.xml

- {File} WebMethod_test.config

- {File} ServiceName_ws.config

Section IV.

**********************************************

LOADING A SAVED STORM PROJECT

**********************************************

1. Create a stormproject (See above instructions, section III)

2. Click OPEN from the toolbar. Navigate to the created storm project file

3. Click OK. This will re-load the web service(s) and all the test cases (if any)

Section V.

************************************

EXECUTING SAVED TEST CASES

************************************

1. Open the storm project

2. Right-click a test case node. Select Run/EDIT. This will open up a new tab.

3. Edit the Test input (Click on the edit icon) as needed.

4. Click RUN button to invoke the web method

4. GREEN means the actual response matched the expected response.

Section VI.

**********************************************

SENDING MULTIPLE ARRAY ITEMS

**********************************************

1. Load the web service

2. Select the web method containg an array input parameter.

3. Click "Tree View" (lightning icon). Edit the input tree

4. Click RUN button to invoke the web method

4. Switch to "Raw View". Edit the soap request as needed. You can add as many array items as you like.

- Make sure that after editing the SOAP request it is still a well-formed XML. (You can check this by switching to "XML View". If it is displayed correctly then it is well-formed).

Section VII.

**********************************************

SENDING MULTIPLE MEMBER ARRAY ITEMS

**********************************************

1. Load the web service

2. Select the web method containing a class input parameter. (this class has an array member)

3. Click "Tree View" (lightning icon).

4. Select the class. Object editor pops-up

5. In the object editor, select the array member

6. Add array items

How to develop jQuery Plugins

2012-04-03T08:55:00.000-07:00

Based on "Plugins/Authoring".

jQuery is the most popular JavaScript library and many sites adopt it for dynamic effects and Ajax functionality. However, relatively few developers delve into the depths of plugin development.

This post will outline the basics, best practices, and common pitfalls to watch out for, as you begin writing your plugin.

CONTENTS

Getting Started
Context
The Basics
Maintaining Chainability
Defaults and Options
Namespacing

Plugin Methods
Events
Data

Summary and Best Practices

Getting Started

By extending jQuery, you created reusable components that can be used on any web page. Your code is encapsulated and there is less risk that you will use the same function names elsewhere.

To write a jQuery plugin, start by adding a new function property to the jQuery.fn object where the name of the property is the name of your plugin :

// jQuery.fn = jQuery.prototype = ...  
jQuery.fn.myPlugin = function () {
    // Do your awesome plugin stuff here  
};

However, to make sure that your plugin doesn't collide with other libraries that might use the dollar sign, it's a best practice to pass jQuery to an IIFE(Immediately Invoked Function Expression) that maps it to the dollar sign so it can't be overwritten by another library in the scope of its execution.

(function ($) {
     $.fn.myPlugin = function () {
         // Do your awesome plugin stuff here     
         // Scope Variables     
         //   Closure     
         //     $: function (selector, context) {...   }; 
})(jQuery);

Now within that closure, we can use the dollar sign in place of jQuery as much as we like.

Context

Now that we have our shell we can start writing our actual plugin code. But before we do that, I'd like to say a word about context. In the immediate scope of the plugin function, the this keyword refers to the jQuery object, the plugin was invoked on. This is a common slip up due to the fact that in other instances where jQuery accepts a callback, the this keyword refers to the native DOM element in the callback function. This often leads to developers unnecessarily wrapping the this keyword (again) in the jQuery function.

(function ($) {
    $.fn.myPlugin = function () {
        // there's no need to do $(this) because     
        // "this" is already a jquery object      
        // $(this) would be the same as $($('#element'));      
        // Local      
        //   this: jQuery.fn.jQuery.init[1]     
        //    0: HTMLDivElement     
        //    context: HTMLDocument     
        //    length: 1     
        //    selector: "#element"     
        this.fadeIn('normal', function () {
            // the this keyword is a DOM element        
            // Local       //   this: HTMLDivElement       
            //     id: "element"       var that = this;              
            // Local       
            //   $this: jQuery.fn.jQuery.init[1]       
            //     0: HTMLDivElement       
            //     context : HTMLDivElement       
            //     length: 1       
            var $this = $(this);
        });
    };
})(jQuery);

$('#element').myPlugin();

The Basics

Now that we understand the context of jQuery plugins, let's write a plugin that actually does something.

(function ($) {
    $.fn.maxHeight = function () {
        var max = 0;
        this.each(function () {
            // Closure : max       
            max = Math.max(max, $(this).height());
        });
        return max;
    };
})(jQuery);

var tallest = $('div').maxHeight(); // Returns the height of the tallest div

This is a simple plugin that leverages .height() to return the height of the tallest div in the page.

Maintaining Chainability

The previous example returns an integer value of the tallest div on the page, but often times the intent of a plugin is simply modify the collection of elements in some way, and pass them along to the next method in the chain. This is the beauty of jQuery's design and is one of the reasons jQuery is so popular. So to maintain chainability in a plugin, you must make sure your plugin returns the this keyword.

(function ($) {
    $.fn.lockDimensions = function (type) {
        // .each(function(index, Element))     
        // Iterate over a jQuery object, executing a function for each matched element.     
        // return jQuery     
        return this.each(function () {
            var $this = $(this);
            if (!type || type == 'width') {
                $this.width($this.width());
            }
            if (!type || type == 'height') {
                $this.height($this.height());
            }
        });
    };
})(jQuery);

$('div').lockDimensions('width').css('color', 'red');

Because the plugin returns the this keyword in its immediate scope, it maintains chainability and the jQuery collection can continue to be manipulated by jQuery methods, such as .css. So if your plugin doesn't return an intrinsic value, you should always return the this keyword in the immediate scope of the plugin function. Also, as you might assume, arguments you pass in your plugin invocation get passed to the immediate scope of the plugin function. So in the previous example, the string 'width' becomes the type argument for the plugin function.

Defaults and Options

For more complex and customizable plugins that provide many options, it's a best practice to have default settings that can get extended(using $.extend) when the plugin is invoked. So instead of calling a plugin with a large number of arguments, you can call it with one argument which is an object literal of the settings you would like to override. Here's how you do it.

(function ($) {
    $.fn.tooltip = function (options) {
        // Create some defaults, extending them with any options that were provided     
        // var defaults = {...}; var settings = $.extend({}, defaults, options); works also     
        var settings = $.extend({
            'location': 'top',
            'background-color': 'blue'
        }, options);
        return this.each(function () {
            // Tooltip plugin code here      
        });
    };
})(jQuery);

$('div').tooltip({   'location' : 'left' });

In this example, after calling the tooltip plugin with the given options, the default location setting gets overridden to become 'left', while the background-color setting remains the default 'blue'. So the final settings object ends up looking like this:

{  'location'  : 'left',   'background-color' : 'blue' }

This is a great way to offer a highly configurable plugin without requiring the developer to define all available options.

Namespacing

Properly namespacing your plugin is a very important part of plugin development. Namespacing correctly assures that your plugin will have a very low chance of being overwritten by other plugins or code living on the same page. Namespacing also makes your life easier as a plugin developer because it helps you keep better track of your methods, events and data.

Plugin Methods

Under no circumstance should a single plugin ever claim more than one namespece in the jQuery.fn object.

(function ($) {
    $.fn.tooltip = function (options) {
        // THIS   
    };
    $.fn.tooltipShow = function () {
        // IS   
    };
    $.fn.tooltipHide = function () {
        // BAD   
    };
    $.fn.tooltipUpdate = function (content) {
        // !!!     
    };
})(jQuery);

This is a discouraged because it clutters up the $.fn namespace. To remedy this, you should collect all of your plugin's methods in an object literal and call them by passing the string name of the method to the plugin.

(function ($) {
    var methods = {
        init: function (options) {
            // THIS      
        },
        show: function () {
            // IS     
        },
        hide: function () {
            // GOOD     
        },
        update: function (content) {
            // !!!      
        }
    };
    $.fn.tooltip = function (method) {
        // Method calling logic     
        if (methods[method]) {
            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
        } else if (typeof method === 'object' || !method) {
            return methods.init.apply(this, arguments);
        } else {
            $.error('Method ' + method + ' does not exist on jQuery.tooltip');
        }
    };
})(jQuery);

// calls the init method $('div').tooltip();   
// calls the init method $('div').tooltip({   foo : 'bar' });
// calls the hide method $('div').tooltip('hide');  
// calls the update method $('div').tooltip('update', 'This is the new tooltip content!');

This type of plugin architecture allows you to encapsulate all of your methods in the plugin's parent closure, and call them by first passing the string name of the name of the method, and then passing any additional parameters you might need for that method. This type of method encapsulation and architecture is a standard in the jQuery plugin community and it used by countless plugins, including the plugins and widgets in jQueryUI.

Events

A lesser known feature of the bind method is that is allows for namespacing of bound events. If your plugin binds an event, its a good practice to namespece it. This way, if you need to unbind it later, you can do so without interfering with other events that might have been bound to the same type of event. You can namespace your events by appending ".<namespace>" to the type of event you're binding.

 (function ($) {
     var methods = {
         init: function (options) {
             return this.each(function () {
                 $(window).bind('resize.tooltip', methods.reposition);
             });
         },
         destroy: function () {
             return this.each(function () {
                 $(window).unbind('.tooltip');
             })
         },
         reposition: function () {
             // ...       
         },
         show: function () {
             // ...       
         },
         hide: function () {
             // ...       
         },
         update: function (content) {
             // ...      
         }
     };
     $.fn.tooltip = function (method) {
         if (methods[method]) {
             return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
         } else if (typeof method === 'object' || !method) {
             return methods.init.apply(this, arguments);
         } else {
             $.error('Method ' + method + ' does not exist on jQuery.tooltip');
         }
     };
 })(jQuery);

 $('#fun').tooltip(); // Some time later... $('#fun').tooltip('destroy');

In this example, when the tooltip is initialized with the init method, it binds the reposition method to the resize event of the window under the namespece 'tooltip'. Later, if the developer needs to destroy the tooltip, we can unbind the events bound by the plugin by passing its namespace, in this case 'tooltip', to the unbind method. This allows us to safely unbind plugin events without accidentally unbinding events that may have been bound outside of the plugin.

Data

Often times in plugin development, you may need to maintain state or check if your plugin has already been initialized on a given element. Using jQuery's data method is a great way to keep track of variables on a per element basis. However, rather than keeping track of a bunch of separate data calls with different names, it's best to use a single object literal to house all of your variables, and access that object by a single data namespace.

(function ($) {
    var methods = {
        init: function (options) {
            return this.each(function () {
                // .data(key, value) Returns : jQuery          
                // Store arbitraty data associated with the matched elements.          
                var $this = $(this),
                    data = $this.data('tooltip'),
                    tooltip = $('<div />', {
                        text: $this.attr('title')
                    });
                // If the plugin hasn't been initialized yet          
                if (!data) {
                    /*      Do more setup stuff here     */
                    $(this).data('tooltip', {
                        target: $this,
                        tooltip: tooltip
                    });
                }
            });
        },
        destroy: function () {
            return this.each(function () {
                var $this = $(this),
                    data = $this.data('tooltip');
                // Namespacing FTW          
                $(window).unbind('.tooltip');
                data.tooltip.remove();
                $this.removeData('tooltip');
            })
        },
        reposition: function () {
            // ... 
        },
        show: function () {
            // ... 
        },
        hide: function () {
            // ... 
        },
        update: function (content) {
            // ...
        }
    };
    $.fn.tooltip = function (method) {
        if (methods[method]) {
            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
        } else if (typeof method === 'object' || !method) {
            return methods.init.apply(this, arguments);
        } else {
            $.error('Method ' + method + ' does not exist on jQuery.tooltip');
        }
    };
})(jQuery);

Using data helps you keep track of variables and state across method calls from your plugin. Namespacing your data into one object literal makes it easy to access all of your plugin's properties from one central location, as well as reducing the data namespace which allows for easy removal if need be.

Summary and Best Practices

Writing jQuery plugins allows you to make the most out of the library and abstract your most clever and useful functions out into reusable code that can save you time and make your development even more efficient. Here's a brief summary of the post and what to keep in mind when developing your first or next jQuery plugin :

Always wrap your plugin in a closure: (function( $ ){ /* plugin goes here */ })( jQuery );

Don't redundantly wrap the this keyword in the immediate scope of your plugin's function;

Unless you're returning an intrinsic value from your plugin, always have your plugin's function return the this keyword to maintain chainability;

Rather than requiring a lengthy amount of arguments, pass your plugin settings in an object literal that can be extended over the plugin's defaults;

Don't clutter the jQuery.fn object with more than one namespace per plugin;

Always namespace your methods, events and data.

Make your plugin can initialize itself

Using jQuery Plugin Template

Here's the template code according to this post for creating a new plugin :

(function ($) {
    // Private members or functions      
    //...TODO      
    // Public functions     
    var methods = {
        init: function (options) {
            var defaults = {
                //...TODO            
            };
            var opts = $.extend({}, defaults, options);
            return this.each(function () {
                //...TODO             
            });
        },
        destroy: function () {
            //...TODO         
        },
        update: function () {
            //...TODO         
        }
        // You can add other methods here, but don't forget the comma     
    };
    // Change PLUGIN_NAME to your own plugin name     
    $.fn.PLUGIN_NAME = function (method) {
        if (methods[method]) {
            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
        } else if (typeof method === 'object' || !method) {
            return methods.init.apply(this, arguments);
        } else {
            $.error('Method ' + method + ' does not exist on jQuery.PLUGIN_NAME');
        }
    };
})(jQuery);

Also, you can use a much more simple template created by geetarista, it works well for simple cases but it isn't robust;

 /**
 * jQuery PLUGIN_NAME Plugin
 * Version: x.x.x
 * URL: URL
 * Description: DESCRIPTION
 * Requires: JQUERY_VERSION, OTHER_PLUGIN(S), ETC. 
 * Author: AUTHOR (AUTHOR_URL)
 * Copyright: Copyright 2010 YOUR_NAME
 * License: LICENSE_INFO
 */
// Plugin closure wrapper
(function ($) {
    // Main plugin function
    // Replace PLUGIN with the name of your desired function
    $.fn.PLUGIN = function (options) {
        // Overwrite user options with plugin defaults
        var opts = $.extend({}, $.fn.PLUGIN.defaults, options);
        // Iterate through DOM elements and work your magic
        return this.each(function () {
            // Assign the current object to a variable for easier use
            var $this = $(this);
            // This is where most of your plugin functionality resides
        }); // end return this.each
    }; // end $.fn.PLUGIN
    // Public plugin function
    // Replce PLUGIN with your plugin function's name
    // Replace FUNCT with the name of the public function
    $.fn.PLUGIN.FUNCT = function () {
        // Cool JS action
    }; // end $.fn.PLUGIN.FUNCT
    // Default settings for the plugin
    $.fn.PLUGIN.defaults = {
        property: "value",
        anotherProperty: 10
    };
    // Private function that is used within the plugin
    function privateFunction() {
        // Cool JS action
    }
})(jQuery); // end closure wrapper

To finish this post, i will introduce you a powerful jQuery plugin scaffolding created by Raynos which has best practice, convention, performance and memory impact. However i think you have to need a solid js base to understand the following :

(function ($, jQuery, window, document, undefined) {
    var PLUGIN_NAME = "Identity";
    // default options hash.
    var defaults = {
        // TODO: Add defaults
    };
    // -------------------------------
    // -------- BOILERPLATE ----------
    // -------------------------------
    var toString = Object.prototype.toString,
        // uid for elements
        uuid = 0,
        Wrap, Base, create, main;
    (function _boilerplate() {
        // over-ride bind so it uses a namespace by default
        // namespace is PLUGIN_NAME_<uid>
        $.fn.bind = function _bind(type, data, fn, nsKey) {
            if (typeof type === "object") {
                for (var key in type) {
                    nsKey = key + this.data(PLUGIN_NAME)._ns;
                    this.bind(nsKey, data, type[key], fn);
                }
                return this;
            }
            nsKey = type + this.data(PLUGIN_NAME)._ns;
            return jQuery.fn.bind.call(this, nsKey, data, fn);
        };
        // override unbind so it uses a namespace by default.
        // add new override. .unbind() with 0 arguments unbinds all methods
        // for that element for this plugin. i.e. calls .unbind(_ns)
        $.fn.unbind = function _unbind(type, fn, nsKey) {
            // Handle object literals
            if (typeof type === "object" && !type.preventDefault) {
                for (var key in type) {
                    nsKey = key + this.data(PLUGIN_NAME)._ns;
                    this.unbind(nsKey, type[key]);
                }
            } else if (arguments.length === 0) {
                return jQuery.fn.unbind.call(this, this.data(PLUGIN_NAME)._ns);
            } else {
                nsKey = type + this.data(PLUGIN_NAME)._ns;
                return jQuery.fn.unbind.call(this, nsKey, fn);
            }
            return this;
        };
        // Creates a new Wrapped element. This is cached. One wrapped element 
        // per HTMLElement. Uses data-PLUGIN_NAME-cache as key and 
        // creates one if not exists.
        create = (function _cache_create() {
            function _factory(elem) {
                return Object.create(Wrap, {
                    "elem": {
                        value: elem
                    },
                    "$elem": {
                        value: $(elem)
                    },
                    "uid": {
                        value: ++uuid
                    }
                });
            }
            var uid = 0;
            var cache = {};
            return function _cache(elem) {
                var key = "";
                for (var k in cache) {
                    if (cache[k].elem == elem) {
                        key = k;
                        break;
                    }
                }
                if (key === "") {
                    cache[PLUGIN_NAME + "_" + ++uid] = _factory(elem);
                    key = PLUGIN_NAME + "_" + uid;
                }
                return cache[key]._init();
            };
        }());
        // Base object which every Wrap inherits from
        Base = (function _Base() {
            var self = Object.create({});
            // destroy method. unbinds, removes data
            self.destroy = function _destroy() {
                if (this._alive) {
                    this.$elem.unbind();
                    this.$elem.removeData(PLUGIN_NAME);
                    this._alive = false;
                }
            };
            // initializes the namespace and stores it on the elem.
            self._init = function _init() {
                if (!this._alive) {
                    this._ns = "." + PLUGIN_NAME + "_" + this.uid;
                    this.data("_ns", this._ns);
                    this._alive = true;
                }
                return this;
            };
            // returns data thats stored on the elem under the plugin.
            self.data = function _data(name, value) {
                var $elem = this.$elem,
                    data;
                if (name === undefined) {
                    return $elem.data(PLUGIN_NAME);
                } else if (typeof name === "object") {
                    data = $elem.data(PLUGIN_NAME) || {};
                    for (var k in name) {
                        data[k] = name[k];
                    }
                    $elem.data(PLUGIN_NAME, data);
                } else if (arguments.length === 1) {
                    return ($elem.data(PLUGIN_NAME) || {})[name];
                } else {
                    data = $elem.data(PLUGIN_NAME) || {};
                    data[name] = value;
                    $elem.data(PLUGIN_NAME, data);
                }
            };
            return self;
        })();
        // Call methods directly. $.PLUGIN_NAME(elem, "method", option_hash)
        var methods = jQuery[PLUGIN_NAME] = function _methods(elem, op, hash) {
                if (typeof elem === "string") {
                    hash = op || {};
                    op = elem;
                    elem = hash.elem;
                } else if ((elem && elem.nodeType) || Array.isArray(elem)) {
                    if (typeof op !== "string") {
                        hash = op;
                        op = null;
                    }
                } else {
                    hash = elem || {};
                    elem = hash.elem;
                }
                hash = hash || {}
                op = op || PLUGIN_NAME;
                elem = elem || document.body;
                if (Array.isArray(elem)) {
                    var defs = elem.map(function (val) {
                        return create(val)[op](hash);
                    });
                } else {
                    var defs = [create(elem)[op](hash)];
                }
                return $.when.apply($, defs).then(hash.cb);
            };
        // expose publicly.
        Object.defineProperties(methods, {
            "_Wrap": {
                "get": function () {
                    return Wrap;
                },
                "set": function (v) {
                    Wrap = v;
                }
            },
            "_create": {
                value: create
            },
            "_$": {
                value: $
            },
            "global": {
                "get": function () {
                    return defaults;
                },
                "set": function (v) {
                    defaults = v;
                }
            }
        });
        // main plugin. $(selector).PLUGIN_NAME("method", option_hash)
        jQuery.fn[PLUGIN_NAME] = function _main(op, hash) {
            if (typeof op === "object" || !op) {
                hash = op;
                op = null;
            }
            op = op || PLUGIN_NAME;
            hash = hash || {};
            // map the elements to deferreds.
            var defs = this.map(function _map() {
                return create(this)[op](hash);
            }).toArray();
            // call the cb when were done and return the deffered.
            return $.when.apply($, defs).then(hash.cb);
        };
    }());
    // -------------------------------
    // --------- YOUR CODE -----------
    // -------------------------------
    main = function _main(options) {
        this.options = options = $.extend(true, defaults, options);
        var def = $.Deferred();
        // Identity returns this & the $elem.
        // TODO: Replace with custom logic
        def.resolve([this, this.elem]);
        return def;
    }
    Wrap = (function () {
        var self = Object.create(Base);
        var $destroy = self.destroy;
        self.destroy = function _destroy() {
            delete this.options;
            // custom destruction logic
            // remove elements and other events / data not stored on .$elem
            $destroy.apply(this, arguments);
        };
        // set the main PLUGIN_NAME method to be main.
        self[PLUGIN_NAME] = main;
        // TODO: Add custom logic for public methods
        return self;
    }());
})(jQuery.sub(), jQuery, this, document);

How to Write Maintainable OO JavaScript Code

2012-04-01T17:20:00.000-07:00

Reprint : How to Write Maintainable OO JavaScript Code

Author : Ara Pehlivanian

Writing maintainable Object-Oriented (OO) JavaScript will save you money and make you popular. Don't believe me? Odds are that either you or someone else will come back and work with your code. Making that as painless an experience as possible will save time, which we all know equates to money. It will also win you the favor of those for whom you just saved a headache. But before we dive into writing maintainable OO JavaScript, let's just take a quick look at what OO is all about. If you know already about OO, feel free to skip the next section.

What is OO?

Object-oriented programming basically represents physical, real-world objects that you want to work with in code. In order to create objects, you need to first define them by writing what's called a class. Classes can represent pretty much anything: accounts, employees, navigation menus, vehicles, plants, advertisements, drinks, etc... Then, every time you want to create an object to work with, you instantiate one from a class. In other words, you create an instance of a class which gives you an object to work with. In fact, the best time to be using objects is when you'll be dealing with more than one of anything. Otherwise, a simple functional program will likely do just as well. Objects are essentially containers for data. So in the case of an employee object, you might store their employee number, name, start date, title, salary, seniority, etc... Objects also include functions (called methods) to handle that data. Methods are used as intermediaries to ensure data integrity. They're also used to transform data before storing it. For example, a method could receive a date in an arbitrary format then convert it to a standardized format before storing it. Finally, classes can also inherit from other classes. Inheritance allows you to reuse code across different types of classes. For example, both bank account and video store accountclasses could inherit from a base account class which would provide fields for profile information, account creation date, branch information, etc... Then, each would define its own transactions or rentalshandling data structures and methods.

Warning: JavaScript OO is different

In the previous section I outlined the basics of classical object-oriented programming. I say classical because JavaScript doesn't quite follow those rules. Instead, JavaScript classes are actually written as functions and inheritance is prototypal. Prototypal inheritance basically means that rather than classes inheriting from classes, they inherit from objects using the prototype property.

Object Instantiation

Here's an example of object instantiation in JavaScript:


// Define the Employee class
function Employee(num, fname, lname) {
    this.getFullName = function () {
        return fname + " " + lname;
    }
};
 
// Instantiate an Employee object
var john = new Employee("4815162342", "John", "Doe");
alert("The employee's full name is " + john.getFullName());

There are three important things to note here:

I uppercased the first letter of my "class" function. That important distinction lets people know that it's for instantiation and not to be called as a normal function.
I use the new operator when instantiating. Leaving it out would simply call the function and result in problems.
Though getFullName is publicly available because it's assigned to the this operator, fname and lname are not. The closure created by the Employee function gives getFullName access to fname and lnamewhile allowing them to remain private from everyone else.

Prototypal Inheritance

Now, here's an example of prototypal inheritance in JavaScript:


// Define Human class
function Human() {
    this.setName = function (fname, lname) {
        this.fname = fname;
        this.lname = lname;
    }
    this.getFullName = function () {
        return this.fname + " " + this.lname;
    }
}
 
// Define the Employee class
function Employee(num) {
    this.getNum = function () {
        return num;
    }
};
// Let Employee inherit from Human
Employee.prototype = new Human();
 
// Instantiate an Employee object
var john = new Employee("4815162342");
    john.setName("John", "Doe");
alert(john.getFullName() + "'s employee number is " + john.getNum());

This time, I've created a Human class which contains properties common to humans--I moved fname and lname there since all humans, not just employees have names. I then extended the Employee class by assigning a Human object to its prototype property.

Code Reuse Through Inheritance

In the previous example, I split the original Employee class in two. I moved out all the properties common to all humans into a Human class, and then caused Employee to inherit from Human. That way, the properties laid out in Human could be used by other objects such as Student, Client, Citizen, Visitor, etc... As you may have noticed by now, this is a great way to compartmentalize and reuse code. Rather than recreating all of those properties for every single type of object where we're dealing with a human being, we can just use what's already available by inheriting from Human. What's more, if we ever wanted to add a property like say, middle name, we'd do it once and it would immediately be available to everyone inheriting from Human. Conversely, if we only wanted to add a middle name property to just one object, we could do it directly in that object instead of adding it to Human.

Public and Private

I'd like to touch on the subject of public and private variables in classes. Depending on what you're doing with the data in an object, you'll want to either make it private or public. A private property doesn't necessarily mean that people won't have access to it. You may just want them to go through one of your methods first.

Read-only

Sometimes, you only want a value defined once at the moment the object is created. Once created, you don't want anyone changing that value. In order to do this, you create a private variable and have its value set on instantiation.


function Animal(type) {
    var data = [];
    data['type'] = type;
    this.getType = function () {
        return data['type'];
    }
}
 
var fluffy = new Animal('dog');
fluffy.getType(); // returns 'dog'

In this example, I create a local array called data within the Animal class. When an Animal object is instantiated, a value for type is passed and set in the data array. This value can't be overwritten as it's private (the Animal function defines its scope). The only way to read the type value once an object is instantiated is to call the getType method that I've explicitly exposed. Since getType is defined insideAnimal, it has access to data by virtue of the closure created by Animal. This way, people can read the object's type but not change it.

It's important to note that the "read-only" technique will not work when an object is inherited from. Every object instantiated after the inheritance is performed will share those read-only variables and overwrite each other's values. The simplest solution is to convert the read-only variables in the class to public ones. If however, you must keep them private, you can employ the technique pointed out by Philippe in the comments.

Public

There are times however, that you'll want to be able to read and write a property's value at will. To do that, you need to expose the property using the this operator.


function Animal() {
    this.mood = '';
}
 
var fluffy = new Animal();
fluffy.mood = 'happy';
fluffy.mood; // returns 'happy'

This time our Animal class exposes a property named mood which can be written to and read at will. You can equally assign a function to public properties like the getType function in the previous example. Just be careful not to assign a value to a property like getType or you'll destroy it with your value.

Completely Private

Finally, you might find yourself in scenarios where you need a local variable that's completely private. In this case, you can use the same pattern as the first example and just not create a public method for people to access it.


function Animal() {
    var secret = "You'll never know!"
}
 
var fluffy = new Animal();

Writing a Flexible API

Now that we've covered class creation, we need to future proof them in order to keep up with product requirement changes. If you've done any project work, or maintained a product long-term, you know that requirements change. It's a fact of life. To think otherwise is to doom your code to obsolescence before it's even written. You may suddenly have to animate your tab content, or have it fetch data via an Ajax call. Though it's impossible to truly predict the future, it is possible to write code that's flexible enough to be reasonably future proof.

Saner Parameter Lists

One place where future-proofing can be done is when designing parameter lists. They're the main point of contact for people implementing your code and can be problematic if not well designed. What you want to avoid are parameter lists like this:


function Person(employeeId, fname, lname, tel, fax, email, email2, dob) {
};

This class is very fragile. If you want to add a middle name parameter once you've released the code, you're going to have to do it at the very end of the list since order matters. That makes it awkward to work with. It also makes it difficult to work with if you don't have values for each parameter. For example:


var ara = new Person(1234, "Ara", "Pehlivanian", "514-555-1234", null, null, null, "1976-05-17");

A cleaner, more flexible way of approaching parameter lists is to use this pattern:


function Person(employeeId, data) {
};

The first parameter is there because it's required. The rest is lumped together in an object which can be very flexible to work with.


var ara = new Person(1234, {
    fname: "Ara",
    lname: "Pehlivanian",
    tel: "514-555-1234",
    dob: "1976-05-17"
});

The beauty of this pattern is that it's both easy to read and highly flexible. Note how fax, email andemail2 were completely left out. Also, since objects aren't order specific, adding a middle name parameter is as easy as throwing it in wherever it's convenient:


var ara = new Person(1234, {
    fname: "Ara",
    mname: "Chris",
    lname: "Pehlivanian",
    tel: "514-555-1234",
    dob: "1976-05-17"
});

The code inside the class doesn't care because the values get accessed by index like so:


function Person(employeeId, data) {
this.fname = data['fname'];
};

If data['fname'] returns a value, it gets set. Otherwise, it doesn't, and nothing breaks.

Make It Pluggable

As time goes on, product requirements might demand additional behavior from your classes. Yet often times that behavior has absolutely nothing to do with your class's core functionality. It's also likely that it's a requirement for only one implementation of the class, like fading in the contents of one tab's panel while fetching external data for another. You may be tempted to put those abilities inside your class, but they don't belong there. A tab strip's responsibility is to manage tabs. Animation and data fetching are two completely separate things and should be kept outside the tab strip's code. The only way to future proof your tab strip and keep all that extra functionality external, is to allow people to plug behaviors into your code. In other words, allow people to hook into key moments in your code by creating events like onTabChange, afterTabChange, onShowPanel, afterShowPanel and so on. That way, they can easily hook into your onShowPanel event, write a handler that fades in the contents of that panel and everyone is happy. JavaScript libraries allow you to do this easily enough, but it's not too hard to work it out on your own. Here's a simple example using YUI 3.


<script type="text/javascript" src="http://yui.yahooapis.com/combo?3.2.0/build/yui/yui-min.js"></script>
<script type="text/javascript">
    YUI().use('event', function (Y) {
 
        function TabStrip() {
            this.showPanel = function () {
                this.fire('onShowPanel');
 
                // Code to show the panel
 
                this.fire('afterShowPanel');
            };
        };
 
        // Give TabStrip the ability to fire custom events
        Y.augment(TabStrip, Y.EventTarget);
 
        var ts = new TabStrip();
 
        // Set up custom event handlers for this instance of TabStrip
        ts.on('onShowPanel', function () {
            //Do something before showing panel
        });
        ts.on('onShowPanel', function () {
            //Do something else before showing panel
        });
        ts.on('afterShowPanel', function () {
            //Do something after showing panel
        });
 
        ts.showPanel();
    });
</script>

This example has a simple TabStrip class with a showPanel method. The method fires two events, onShowPanel and afterShowPanel. It's given the ability to do so by augmenting the class with Y.EventTarget. Once that's done, we instantiate a TabStrip object and assign a bunch of event handlers to it. This is our custom code for handling this instance's unique behavior without messing with the actual class.

Summary

If you plan on reusing code either on the same page, website or across multiple projects, consider packaging and organizing it in classes. Object-oriented JavaScript lends itself naturally to better code organization and reuse. What's more, with a little forethought, you can make sure that your code is flexible enough to stay in use long after you've written it. Writing reusable, future-proof JavaScript will save you, your team and your company time and money. That's sure to make you popular.

How To Use HighCharts - Intractive Javascript charts for your web projects

2012-03-29T05:46:00.000-07:00

! this post only include HighCharts but HighStocks, it reprint how to use

Table of contents

Installation
How to set up the options
Preprocessing the options
Live charts
Exporting module
Freeform drawing

1. Installation

Hight charts uses either jQuery, MooTools or Prototype for some common JavaScript tasks. My choice is jQuery, if you want to use others, please check http://www.highcharts.com/documentation/how-to-use

If you already have jQuery included, you can skip the first one. Use this code to include Highcharts with jQuery:

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"></script> 
<script src="/js/highcharts.js" type="text/javascript"></script>

In a script tag in the head of your web page, or in a separate .js file, add the JavaScript code to initialize the chart. Note that the id of the div where you want to put the chart (see # 3) is given in the renderTo option below :

 var chart1;
 // globally available 
 $(document).ready(function () {
     chart1 = new Highcharts.Chart({
         chart: {
             renderTo: 'container',
             type: 'bar'
         },
         title: {
             text: 'Fruit Consumption'
         },
         xAxis: {
             categories: ['Apples', 'Bananas', 'Oranges']
         },
         yAxis: {
             title: {
                 text: 'Fruit eaten'
             }
         },
         series: [{
             name: 'Jane',
             data: [1, 0, 4]
         }, {
             name: 'John',
             data: [5, 7, 3]
         }]
     });
 });

Add a div in your webpage. Give it an id refering to the renderTo option in #2, and set a specific width and height which will be the width and height of your chart.

<div id="container" style="width: 100%; height: 400px"></div>

Optionally, you can apply a global theme to your charts. A theme is just a set of options that are applies globally through the Highcharts. setOptions method. The download package comes with four predefined themes. To apply a theme from one of these files, add this directly after the highcharts.js file inclusion:

<script type="text/javascript" src="/js/themes/gray.js"></script>

2. How to set up the options

Highcharts uses a JavaScript object structure to define the options. The options are nested into categories. The options are mainly strings and numbers, but some are arrays, other objects or even functions. When you initialize the chart using new HighCharts.Chart, the options object is the first parameter you pass.

If you want to apply a set of options to all charts on the same page, use HighCharts.setOptions like shown below.

see small #3 above for an example of an options object. For more examples see the Highcharts demo gallery. For a full reference of the options availables, see the Highcharts options reference.

3. Preprocessing the options

To get the most out of Highcharts, it is important to understand how the configuration object works and how it can be altered programmatically. These are some key concepts on JavaScript objects:

The Highcharts options in the examples are defined as object literals. By notating the configuration this way, we can have a clean, human readable and low space consuming config object.

This complicated code is perhaps more familiar to developers with a background from C-type languages:

 // Bad code: 
 var options = new Object();
 options.chart = new Object();
 options.chart.renderTo = 'container';
 options.chart.type = 'bar';
 options.series = new Array();
 options.series[0] = new Object();
 options.series[0].name = 'Jane';
 options.series[0].data = new Array(1, 0, 4);

As JavaScript object literals, we would write it like below. Note that the two options obje

cts will produce exactly the same result.

 // Good code: 
 var options = {
     chart: {
         renderTo: 'container',
         defaultSeriesType: 'bar'
     },
     series: [{
         name: 'Jane',
         data: [1, 0, 4]
     }]
 };

After an object is created using the object literal notation, we can extend its members by the dot notation. Say we have an object like defined in the "Good code" above. The code below adds another series to it. Remember options.series is an array, so it has a push method.

 options.series.push({
     name: 'John',
     data: [3, 4, 2]
 })

Another fact that can come in handy when working on JavaScript objects, is that the dot notation and square bracket notation are equivalent, so you can access all members by their string names. Which in practice means that

 options.renderTo

is always the same as

 options['renderTo']

3.1 Case study: preprocessing the data from CSV

This example shows how to set up the basic chart options first, then do an Ajax call for the data, parse the data and add them in the proper format to the options. In this example, jQuery is used for handling Ajax. All of the code runs in the $(document).ready event handler. The example can be seen live at data-from-csv.htm.

Create an external CSV file containing only the data. In this example, the file looks like below. The first line lists the categories with a dummy name in the first position. The subsequent lines list the data series name in the first position and values in the subsequent positions. In real life, you will often create the contents of this file using server side programming languages. Or you may choose to use other markup formats like XML or JSON. In those cases, jQuery can also parse the data for you natively.

 Categories, Apples, Pears, Oranges, Bananas
 John, 8, 4, 6, 5
 Jane, 3, 4, 2, 3
 Joe, 86, 76, 79, 77
 Janet, 3, 16, 13, 15

Define the initial, basic options. Note that we create empty arrays for the categories and series objects, so that we can just push values to them later.

 var options = {
     chart: {
         renderTo: 'container',
         defaultSeriesType: 'column'
     },
     title: {
         text: 'Fruit Consumption'
     },
     xAxis: {
         categories: []
     },
     yAxis: {
         title: {
             text: 'Units'
         }
     },
     series: []
 };

Put it all together. We use the jQuery.get method to get the contents of the data.csv.file. In the success callback function, we parse the returned string, add the results to the categories and series members of the options object, and create the chart. Note that we can't create the chart outside the Ajax callback, as we have to wait for the data to be returned from the server.

 $.get('data.csv', function (data) {
     // Split the lines     
     var lines = data.split('\n');
     // Iterate over the lines and add categories or series     
     $.each(lines, function (lineNo, line) {
         var items = line.split(',');
         // header line containes categories         
         if (lineNo == 0) {
             $.each(items, function (itemNo, item) {
                 if (itemNo > 0) options.xAxis.categories.push(item);
             });
         }
         // the rest of the lines contain data with their name in the first position         
         else {
             var series = {
                 data: []
             };
             $.each(items, function (itemNo, item) {
                 if (itemNo == 0) {
                     series.name = item;
                 } else {
                     series.data.push(parseFloat(item));
                 }
             });
             options.series.push(series);
         }
     }); // Create the chart     var chart = new Highcharts.Chart(options); });

3.2 Loading from XML

Loading data from an XML file is similar to the CSV approach. Highcharts does not come with a predefined XML data syntax, it is entirely up to you to write the XML and to define a parsing function for it. The downside of using XML over CSV is that it adds some markup to the data, leaving a larger footprint. How large the extra footprint is depends on how you mark up your data. For example, if you wrap each point with a <point> tag and load 1000 points, it will add some weight. If however you add a comma separated list of point values, it doesn't. The upside to using XML, at least for small data sets, is that you don't have to manually parse the incoming data. You can utiliza jQuery's existing DOM parsing abilities to access the XML tree. We set up a live example for this at data-from-xml.htm. The data can be viewed at data.xml.

4. Live charts

After a chart has been defined by the configuration object, optionally preprocessed and finally initialized and rendered using new Highcharts.Chart(), we have the opportunity to alter the chart using a toolbox of API methods. The chart, axis, series and point objects have a range of methods like update,remove, addSeries, addPoints and so on. The complete list can be seen in the API Reference under "Methods and Properties" at the left.

4.1 Case study: a live connection to the server

The following example shows how to run a live chart with data retrieved from the server each second, or more precisely, one second after the server's last reply. It is done by setting up a custom function, requestData, that initially is called from the chart's load event, and subsequently from its own Ajax success callback function. You can see the results live at live-server.htm.

Set up the server. In this case, we have a simple PHP script returning a JavaScript array with the JavaScript time and a random y value. This is the contents of the live-server-data.php file:

<?php
    // Set the JSON header
    header( "Content-type: text/json");
    // The xvalue is the current JavaScript time, 
    // which is the Unix time multipliedby 1000. 
    $x=t ime() * 1000;
    // The y value is a random number 
    $y=r and(0, 100);
    // Create a PHP array and echo it as JSON 
    $ret=a rray($x, $y); 
    echo json_encode($ret);
?>

Define the chart variable globally, as we want to access it both from the document ready function and our requestData function. If the chart variable is defined inside the document ready callback function, it will not be available in the global scope later.

 var chart; // global

Set up the requestData function. In this case it uses jQuery's $.ajax method to handle the Ajax stuff, but it could just as well use any other Ajax framework. When the data is successfully received from the server, the string is eval'd and added to the chart's first series using the Highcharts addPoint method. If the series length is greater than 20, we shift off the first point so that the series will move to the left rather than just cram the points tighter.

 /**  * Request data from the server, add it to the graph and set a timeout to request again  */

 function requestData() {
     $.ajax({
         url: 'live-server-data.php',
         success: function (point) {
             var series = chart.series[0],
                 shift = series.data.length > 20; // shift if the series is longer than 20              
             // add the point             
             chart.series[0].addPoint(point, true, shift);
             // call it again after one second             
             setTimeout(requestData, 1000);
         },
         cache: false
     });
 }

Create the chart. Notice how our requestData function is initially called from chart's load event. The initial data is an empty array.

 $(document).ready(function () {
     chart = new Highcharts.Chart({
         chart: {
             renderTo: 'container',
             defaultSeriesType: 'spline',
             events: {
                 load: requestData
             }
         },
         title: {
             text: 'Live random data'
         },
         xAxis: {
             type: 'datetime',
             tickPixelInterval: 150,
             maxZoom: 20 * 1000
         },
         yAxis: {
             minPadding: 0.2,
             maxPadding: 0.2,
             title: {
                 text: 'Value',
                 margin: 80
             }
         },
         series: [{
             name: 'Random data',
             data: []
         }]
     });
 });

5. Exporting module

From version 2.0 an exporting module is available for HighCharts, which allow users to download images or PDF's of your charts. This module consists of an extra JavaScript file, exporting.js, and a web service or server module wirtten in PHP. If you include the exporting module in your charts, two buttons will appear in the upper right. One button prints the chart, which is done on the client side only. The other button handles exporting. By default, an SVG representation of the chart is sent by POST to http://export.highcharts.com, where it is converted using Apache's Batik converter to PDF, PNG or JPEG.

See the navigation and exporting reference items for a full documentation for the options available. Also see under "Methods and Properties" in the reference for members releated to exporting.

5.1 Client side setup

Add the exporting module JavaScript file after your highcharts.js file.

 <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js" type="text/javascript"></script>
 <script src="/js/highcharts.js" type="text/javascript"></script>
 <script src="/js/modules/exporting.js" type="text/javascript"></script>

5.2 Server module setup

If you want to set up this web service on your own server, this index.php file that handles the POST is supplied in the download package inside the /exporting-server directory.

Make sure that PHP and Java is installed on your server.
Upload the index.php file from the /exporting-server directory in the download package to your server.
In your FTP program, create directory called temp in the same directory as index.php and chmod this new directory to 777 (Linux/Unix servers only).
Download Batik from http://xmlgraphics.apache.org/batik/#download. Find the binary distribution for your version of jre
Upload batik-rasterizer.jar and the entire lib directory to a location on your web server.
In the options in the top of the index.php file, set the path to batik-rasterier.jar.
In your chart options, set the exporting.url option to match your PHP file location.

As an ASP.NET alternative to our Java/PHP based server module, Clément Agarini has kindly shared his export module for ASP.NET.

6. Freeform drawing

Internally, Highcharts is equipped with a rendering module that acts as a wrapper for JavaScript access to SVG in modern browsers and VML in IE < 9. It has much in common with drawing tools like Raphaël or SVG jQuery. This drawing module can be used either to draw shapes or text on the chart, or even as a standalone drawing tool for HTML pages.

Inside a chart, the chart's renderer object is available as chart.renderer. To instanciate a new SVG drawing outside Highcharts, you call new Highcharts.Renderer(parentNode, width, height), where parentNode is the div or container element where you want the drawing to be placed.

The drawing API is documented in detail at /ref#renderer and /ref#element.

7. API reference

Proceed to the API Reference.

Responsive Web Design: Meta Queries and Viewports

2012-03-28T17:41:00.001-07:00

This article is based on device-width and how not to hate your users and Responsive Web Design: What It Is and How To Use It.

Opening

Almost every new client these days wants a mobile version of their website. It's practically essential after all: one design for the BlackBerry, another for the iPhone, the iPad, netbook, Kindle — and all screen resolutions must be compatible, too. In the next five years, we'll likely need to design for a number of additional inventions. When will the madness stop? It won't, of course.

What's Responsive Web design ?

Responsive Web design is the approach that suggests that design and development should respond to the user's behavior and environment based on screen size, platform and orientation. The practice consists of a mix of flexible grids and layouts, images and an intelligent use of CSS media queries. As the user switches from their laptop to iPad, the website should automatically switch to accommodate for resolution, image size and scripting abilities. In other words, the website should have the technology to automaticallyrespond to the user's preferences. This would eliminate the need for a different design and development phase for each new gadget on the market.

Attention : responsive Web design is not only about adjustable screen resolutions and automatically resizable images, but rather about a whole new way of thinking about design.

What's Responsive Web design for ?

With more devices come varying screen resolutions, definitions and orientations. New devices with new screen sizes are being developed every day, and each of these devices may be able to handle variations in size, functionality and even color. Some are in landscape, others in portrait, still others even completely square.

In addition to designing for both landscape and portrait (and enabling those orientations to possibly switch in an instant upon page load), we must consider the hundreds of different screen sizes.
Below are some of the most common:

So if you want to satisfy your clients, you have to make your sites adjust to almost of above devices.
For example, We should Customize the layout structure for different devices :

Custom layout structure

Another example, sometimes, Show or Hide content according to needs :

Showing or Hiding Content

It's obvious that we can't keep creating custom solutions for each one. So, how do we deal with the situation?

Media queries and Viewports is the answer

But I'm not going to go into the details of responsive enhancement, the references at the end of this post serve that purpose. This post lists what I think are best practices and my reasons for them.

@media queries

As a web designer or developer, we want our page to be easily viewable across different devices and screen sizes. It shouldn't matter whether our user uses a 21" desktop monitor, a 13" laptop, a 10" iPad or a much smaller smartphone. Responsive web design uses @media queries to change the layout of the page using CSS based on browser width. We might have CSS that looks like this:

/* Default wide-screen styles */

@media all and (max-width: 1024px) {

/* styles for narrow desktop browsers and iPad landscape */

}

@media all and (max-width: 768px) {

/* styles for narrower desktop browsers and iPad portrait */

}

@media all and (max-width: 480px) {

/* styles for iPhone/Android landscape (and really narrow browser windows) */

}

@media all and (max-width: 320px) {

/* styles for iPhone/Android portrait */

}

@media all and (max-width: 240px) {

/* styles for smaller devices */

}

And yes, we could go smaller than that, or have intermediate sizes, but I'll cover that later. CSS media queries is really powerful and a bit complex, I don't want to go into details, because all the above codes are enough for Responsive Design. More information about Media Queries, please check relative articles in the section "Footnotes & References".

viewports

Now this works reasonably well when we resize desktop browsers, but not so much for mobile browsers. The problem is that mobile browsers (iPhone/Safari, Android/Chrome and Fennec) assume that the page were designed for a wide screen, and shrink it to fit into the smaller screen. This means that even though users could have had a good customised experience for their smaller devices, they won't because the device doesn't know about this. The trick is to use Apple's viewport6, 7, 8 meta tag in our document's head in conjunction with @media queries:

width=device-width

Most sites that I've seen advise to set the content attribute to width=device-width. This tells the browser to assume that the page is as wide as the device. Unfortunately, this is only true when our device is in the portrait orientation. When we rotate to landscape, the device-width remains the same (eg: 320px), which means that even if our page were designed to work well in a 480px landscape design, it would still be rendered as if it were 320px.

It's tempting to use the orientation media query to solve this problem, but orientation doesn't really tell us the actual width of the device. All it tells us is whether the width is larger than or smaller than the device's height. As someone points out, since most pages tend to scroll vertically, this is irrelevant.

Use this if we use the same page styles in portrait and landscape orientation. Also note that using width=device-width is the only way to tell android devices to use the device's width.

initial-scale=1.0,maximum-scale=1.0

Setting initial-scale=1 tells the browser not to zoom in or out regardless of what it thinks the page width is. This is good when we've designed our page to fit different widths since the browser will use the appropriate CSS rules for its own width, and initial-scale stops the zooming problem that we faced without the viewport meta tag.

Unfortunately a bug, or more likely a mis-feature, in mobile safari messes this up when a device is rotated from portrait to landscape mode. initial-scale is honoured only on full page load. On rotate from portrait to landscape mode, the browser assumes that the page width stays the same and scales accordingly (1.5) to make 320 pixels fit into 480pixels. However, as far as @media queries go, it reports a 480px width, and uses the appropriate CSS rules to render the page. This results in a page designed for 480px rendered scaled up 1.5 times. It's not horrible, but it's not desirable. Fennec claims that it does the right thing in this case.

To get around this bug, the pixel perfection camp suggests also setting maximum-scale=1. This stops the page zoom in on rotate, but it has the undesired side effect of preventing the user from zooming the page. This is a problem from the accessibility point of view. Zooming in is a very valid use case for users with bad eyesight, and in some cases, even users with good eyesight who just want a closer look at some part of our page. Do this only if we hate our users. It goes without saying that setting user-scalable=no should also not be used on most general purpose pages.

A better solution may be design our page to use the same styles in portrait and landscape orientation and set width=device-width. This way even if it does zoom, it will still be proportionate.

width=<actual width>

Some sites advise using a specific viewport width and designing our pages for that width. This is fine if we are building a separate page for each device class, but that doesn't flow with the concept of responsive design. Fixed width layouts are for print. The web is fluid and adapts to its users. Our site should too. Don't use this.

@media all and (device-width:480)

While this is a media query rather than an option to the viewport meta tag, I've seen it at various locations, and don't think it's the best option around. Here's why. According to the CSS3 media queries spec, thedevice-width media feature describes the width of the rendering surface of the output device. For continuous media, this is the width of the screen. For paged media, this is the width of the page sheet size.

We're dealing with continuous media here (on-screen as opposed to printed), in which case the spec states that this is the width of the screen. Unless the browser window is maximised, this might be larger than the viewport with. My tests show that most desktop browsers treat device-width and width as synonyms. Mobile browsers seem a little confused on the matter. As far as the viewport meta tag goes, device-width is the width of the device in portrait orientation only. For a 320x480 device, device-width is always 320px regardless of orientation. For CSS media queries, however, device-width is the width of the screen based on its current orientation.

If we are going to use this, use it in conjunction with the orientation media feature. Never use max-device-width and min-device-width. It's better to use max-width and min-width instead. Also remember that device widths may change with newer models.

Intermediate widths

I'd mentioned above that we could design for any number of widths. The important thing is to test our page for different browser widths. This is fairly easy to do just by resizing our browser window. Test, and whenever we find our page layout break, either fix the layout for all widths, or build a new layout for smaller widths.

As we get smaller, we can reduce the space(Display : none;) used by non-essential content like the footer, the sidebars and the menu at the top, leaving as much space as possible for main content.

Our own site may have a layout that works perfectly at all screen widths, or we may need to design only two or three layouts. It's easy to test and design, so there's no reason not to. Designing for multiple widths took me just a couple of hours, and a lot of it was spent reading the articles below.

Recommendations

So finally, this is what I recommend.

DO use the viewport meta tag
DO use media queries to render our page appropriately for various widths ranging from under 200px to 1024px or more
DO use width=device-width,initial-scale=1 in our viewport meta tag OR use width=device-width alone.
DO NOT use maximum-scale=1 or user-scalable=no
DO NOT use width=<specific width>
DO NOT use @media all and (*-device-width: xxx)

Remember that using initial-scale=1.0 throws we open to a zooming bug in mobile Safari. Push Safari to fix this bug. Finally, David Calhoun has a great summary of all options to the viewport meta tag, and alternate meta tags for older phones. Well worth a read. Also note that Mozilla's documentation of the viewport meta tag is far better than Safari's.

Footnotes & References

Ethan Marcotte. 2010. Responsive Web Design. In A List Apart #306. ISSN: 1534-0295.

Jeremy Keith. 2010. Responsive Enhancement. In adactio.

Kayla Knight. 2011. Responsive Web Design: What It Is and How To Use It. In Smashing Magazine.

Webkit based desktop browsers re-render the page correctly as you resize the browser, however they have a minimum width of 385px (on MacOSX) and I was unable to shrink the browser below this. Firefox 4 re-renders the page correctly until the width gets too narrow to fit the navigation toolbar. At that point the viewport width stays fixed even if you shrink the browser. The page is re-rendered if you type something (anything) into the URL bar. Opera 10/11 re-render correctly at all sizes.

Peter Paul Koch. 2010. A tale of two viewports — part two. In Quirksmode.

Using the Viewport on Safari. In Safari Web Content Guide.

The viewport meta tag. In Safari HTML Reference.

MDC. 2010. Using the viewport meta tag to control layout on mobile browsers. In Mozilla Developer Network.

Peter Paul Koch. 2010. Combining meta viewport and media queries. In Quirksmode.

Willison & Downe. Lanyrd.

Lie et al. 2010. Media Queries. W3C Candidate Recommendation 27 July 2010.

If you design your page for the narrow view and expect it to scale when rotated, then use width=device-width and nothing else. If, instead, you design your page for either width, then use width=device-width,initial-scale=1. This is the only way to get the android browser to render a page with the intended width. Mobile Safari will render the page exactly as if initial-scale=1 were specified alone. You will still end up with the zoom on rotate bug.

David Calhoun. 2010. The viewport metatag (Mobile web part I).

Understanding Module Structure DotNetNuke6

2012-03-28T02:32:00.002-07:00

A module is a pluggable user interface component that processes requests and generates dynamic content. This definition is similar to that of an ASP.NET page, with the exception that a module can appear only on an ASP.NET page, and a page may contain any number of module "instances."

Portal

DotNetNuke needs to perform a number of steps to process a page request. The following steps execute during the initialization of the page and work to dynamically load modules at runtime. The dynamically created modules are then capable of handling their own life cycle including events such as initialization, load, and render.

Figure 1 : Portal Structure

Step 1: Page Configuration Retrieval

The first step is to retrieve the modules for the requested page. The retrieval step comprises a number of important pieces of information, such as the modules that appear on the page, the section of the page on which they will appear (known as content panes), and, finally, the security roles associated with each module.

//Default.aspx.cs//OnInit//load skin control and register UI js
UI.Skins.Skin ctlSkin = UI.Skins.Skin.GetSkin(this);
//add skin to page
SkinPlaceHolder.Controls.Add(ctlSkin);

//DotNetNuke.UI.Skins.Skin.cs : OnInit()
bool success;
//Load the Module Control(s)
success = Globals.IsAdminControl() ? ProcessSlaveModule() : ProcessMasterModules();

//DotNetNuke.UI.Skins.Skin.cs : ProcessMasterModules()
bool success = true;
if (TabPermissionController.CanViewPage())
{
　　//check portal expiry date
　　if (!CheckExpired())
　　{
　　　　if ((PortalSettings.ActiveTab.StartDate < DateAndTime.Now

&& PortalSettings.ActiveTab.EndDate > DateAndTime.Now)

|| TabPermissionController.CanAdminPage() || Globals.IsLayoutMode())

　　　　{
　　　　　　//dynamically populate the panes with modules
　　　　　　if (PortalSettings.ActiveTab.Modules.Count > 0)
　　　　　　{
　　　　　　　　foreach (ModuleInfo objModule in PortalSettings.ActiveTab.Modules)
　　　　　　　　{
　　　　　　　　　　success = ProcessModule(objModule);
　　　　　　　　}
　　　　　　}

Step 2: Security Audit

The second step is to make some decisions about the security information retrieved in the previous step. By examining the current user roles (whether a registered user or anonymous) and the view roles associated with each module, you can form a list of "authorized" modules for the current page.

private Boolean ProcessModule(ModuleInfo module)
{
　　bool success = true;
　　if (ModulePermissionController.CanViewModule(module)

&& module.IsDeleted == false

&&((module.StartDate < DateTime.Now && module.EndDate > DateTime.Now)

|| Globals.IsLayoutMode() || Globals.IsEditMode()))

　　{
　　//...
　　}
　　//...
}

Step 3: Content Injection

The third (and final) step is to inject the "authorized" modules dynamically into the corresponding content panes of the page. After all of the modules have been loaded, each module is then able to execute its own series of events and render content.

Pane pane = GetPane(module);
if (pane != null)
{
　　success = InjectModule(pane, module);
}

Figure 2 illustrates one tab in the portal. Tab itself express a complete markup document, composed by a large number pane, and also contains a large number of modules in each pane.

Figure 2 : Tab

Each module contains a title, a number of decorations and some content generated by the module. The decorations can include a number of buttons, links, and a suspension menu which can change the module status or execute the related features of module.

Module

As mentioned previously, a portal is a web-based application that processes requests and generates dynamic content. Each module produces its own piece of markup (known as afragment) and together with the skin's markup shows a complete document.

Because each module produces its own markup, it can be viewed as a tiny application within a larger application. Usually, users interact with the content produced by each module by clicking links or submitting forms that are then processed by the portal system and the command passed to the corresponding module.

Module Container

The decorations surrounding a module are known as a module container. Through this container, a user is able to interact with the module and perform actions such as minimizing, maximizing, and more advanced features (if the user has edit privileges on that module).

Figure 3 : Container

Entity relationship diagram of the database DotNetNuke Community Edition 5.6.1

2012-03-26T05:43:00.002-07:00

The following diagram shows ERD of DotNetNuke Community Edition 5.6.1. I found it on the site R2i. I think ERD is the key to get clear the whole DNN, and can certainly help us understand the DNN architecture and save development time, so i want to share it with you. Though this version is only 5.6.1, not the newest 6.1.4, but 5.6.x is the latest version before DNN 6. so I think there aren't break changes to the core of DNN.

In the diagram, the tables surrounded by blue is the authentication, by red, the content, by green, the support tables, by black, the configuration tables, by gray, the tables used by third-core modules.

You can zoom the document using your mouse.

The original document in PDF format, and the metadata in XLS format, you can download here : ERD PDF || Metadata XLS.

Must-have Cheat Sheets for Web Development

2012-03-22T03:28:00.002-07:00

Reprint "20 Cheat Sheets for Web Development you must have".

Don't forget to Click to Enlarge !

1) PHP

2) HTML Character Entities

3) CSS

4) Javascript

5) JQuery 1.3

6) Regular Expressions

7) Apache Mod Rewrite

8) WordPress Mind Map

9) SEO

10) Google Analytics Tips

The Huge Collection of Google Analytics Tips

Putting aside all recent arguments and gossip as per privacy issues (yep, nothing is probably totally free and Google Analytics should be using its (your?) data in some way), I should confess, I love the tool and use it.

I’ve been compiling the list of advanced Google Analytics tips that open up plenty of possibilities to track and evaluate. Today I am sharing the list and expect you to share yours too!

Note: I haven’t tried all of these tricks with the new Google Analytics code yet, so if there are any problems with any of them, please report.

Track 404 page (more info here): I’ve been reporting on the importance of handling your 404 page properly. To make sure you take care of your non-existent pages, simply include a piece of code to your 404 page:

Classify your site visitors, e.g. track the browsing and buying behavior of your “customers” (those who subscribed, made a purchase or downloaded your product):

Google Analytics help page gives the following examples of the option usage:

Track visitors that landed on a particular page;
Track visitors that clicked a particular link;
Track visitors according to their form selection.

Track your (outgoing) links: add a code to each link you want to track:

Track your banner ads with the same code as the above one. For Flash banners you should use this code:

on(release) {
getURL(“javascript: pageTracker._trackPageview

(‘/bannerads/advertisername/bannername’);”);

getURL(“http://www.advertisersite.com”);

}

Track your downloads (PDF, AVI, or WMV) with this code:

Track mailto: links with this code:

<a href=”mailto:[email address]“onClick=”javascript:urchinTracker(‘/mailto/jerry’);”>[email address]</a>

For WordPress blogs: use “Ultimate Google Analytics” plugin that also allows for lots of other handy features (easy Google Analytics installation, simple configuration screen, all types of links tracking, etc.). Google Analytics for WordPress is also great for this and and for tracking AdSense clicks, image search keywords, etc. (More information on counting outbound clickswithout the help of plugins.)

Track full referring URLs – set up the advanced filter:

Track e-commerce transactions by monitoring your receipt page. Find additional information on this in “Advanced Google Analytics“:

Set up email alert on a regularly-scheduled basis – go: Analytics Settings => View Reports => Email=> Schedule:

Exclude internal traffic: Analytics Settings => Edit => “+Add Filter”:

Compare traffic / page views over different periods of times, e.g. compare how your two viral campaigns performed compared to each other:

Entity Framework Code First in DotNetNuke 6

2012-03-21T22:17:00.000-07:00

Part One : How to develop a new module for DNN 6

If you don't know what DNN means for, please visit www.dotnetnuke.com

If you don't know how to install DNN 6 on local, please click http://codeciel.blogspot.fr/2012/03/how-to-install-dotnetnuke-6-on-local.html

If you want to know how to develop a new module on your own for DNN6, please just check this post out.

Step 1 : Create desktop module and module definition via DNN6 host

In the view of Database, this step will save necessary information for new module into database, thus, DNN can recognize the new module, and you can add it on any page. There are many tables concerned “module” if you look into the database - dbo.DesktopModules, dbo.Modules, dbo.ModuleDefinitions, dbo.TabModules, dbo.PortalDesktopModules. I can't explain clearly their relations here, if possible, i will write another post specifically for this.
So, just follow the instructions to create your own module :

- Login your DNN6 site with the host account

- Access Host → Extensions

- Then click Manage → Create New Module and you will see

Tips : If you can't find the button Manage, please switch your mode to Edit on the top-right page.

Figure 1 : Create new module

- Fill these textboxes

- Check the option « Add Test Page ? » to simplify our works

- Click « Create Module », then you will see that your new module is already deployed on the page « TestEFCodeFirstPage »

Figure 2 : New page with new module

Step 2 : Hook up the new module to a VS project

- Now open Vs2010 → new project

Tips : The name must be same as the module « EFCodeFirst », but you can choose anywhere to place this project, because we will move it to <Site root directory>/DesktopModules and merge the two folders.

Figure 3 : Create new VS2010 project

- Open again the « EFCodeFirst.csproj » project in VS2010. We have some configurations to do.

- Properties → Compiler → output → output path : <Site root directory>\bin\

- (For some people whose site on the server run in environment of .net framework version 2.0.50727.5448) change site's application pool to ASP.NET V4.0 in IIS

- Add reference of Dotnetnuke.dll which you can find in <Site root directory>\bin\, set copy local to false

- Rename web.config to web.config.old, because the site has already a web.config

- Delete the file « EFView.ascx »

- Add a new element, choose web user control as type and « EFView.ascx » as file name.

- Open file EFView.ascx, write something in it. « This is my first dnn6 module » for example.

- Open file EFView.ascx.cs, change its base class to PortalModuleBase, Save then compile this project.

- Refresh the page http://dnn614/TestEFCodeFirstPage.aspx , and you can get :

Figure 4 : Test page with your own module

Until here, you has created a dnn6 module successfully, then you can build the module on your own.

Part Two : Using EF Code First in DNN6 module

This part is based on Introduction to Entity Framework Code First

Step 3* : Get some information about Entity Framework

Before I directly get right to modules, I want to talk about a bit EF, an ORM framework for the .NET.
EF 4.0 provides two approaches for working with entities, viz. Database First and Model First. In the former case you design a database before starting your application development. Then you use Entity Data Model Designer of Visual Studio to design a data model visually by dragging and dropping tables from the database onto the designer (see Figure 5). In the case of Model First development you use Entity Data Model Designer to design data model classes manually (see Figure 6). You then specify the database connection to be used in the application. In any case you use Entity Data Model Designer to generate your data model classes.

Figure 5 : Designing a model with Database First approach

Figure 6 : Designing a model with Model First approach

EF 4.1 offers one more way of generating model classes – Code First. In the Code First approach you won't use any designer at all. You will create plain .NET Framework classe and then use certain attributes and associated techniques to make them Entity Framework Data Models (see Figure 7) .

Figure 7 : Creating a model with Code First

When you run the application that makes use of the Code First technique for the first time the EF will create a new SQL Express database, based on the model classes. For our case, we shall specify the database existing. If you are still confused, see figure 8, i think you will be clearer. In our project, we will use the last one.

Figure 8 : Approaches of EF

Now let's develop not just create our module, step-by-step, that illustrates the entire process. In the module that follows you will be dealing with a data model that represents a blog post. The actual data resides in a SQL Server table named BlogPosts. You can then read-write data to the table using the model class.

Step 3 : Create a Model

Let's assume that you are dealing with a data model that represents a blog post and a blog post category. To begin developing the models, create a new project of type Class Library in the same solution of project “EFCodeFirst” and name it “EFCodeFirstLib”. The class library project will contain two model classes, viz. BlogPost and Category. These classes are shown below:
Tips : you must put the EFCodeFirstLib folder in the <root site folder>/DesktopModules/, and the compile path should be <root site folder>/bin/.

   1:  public class BlogPost

   2:  {

3:

   4:      public Guid Id { get; set; }

5:

   6:      public string Title { get; set; }

7:

   8:      public string Content { get; set; }

9:

  10:      public DateTime PublishDate { get; set; }

11:

  12:      public virtual Category Category { get; set; }

13:

  14:  }

15:

  16:  public class Category

  17:  {

18:

  19:      public Guid Id { get; set; }

20:

  21:      public string Name { get; set; }

22:

  23:      public virtual ICollection<BlogPost> BlogPosts { get; set; }

24:

  25:  }

The BlogPost class defines five properties namely Id, Title, Content, PublishDate and Category. Notice that Category property represents a foreign key. The Category class has three properties - Id, Name and BlogPosts. The BlogPosts property is a collection property because there can be multiple blog posts belonging to a single category. Remember that under the default scheme, the property that represents a primary key should have data type of int or Guid. In the former case, EF 4.1 will translate the property as an identity column in the database and in the latter case a Unique Identifier. You can, of course, customize this behavior using certain attributes as we will discuss later.

Step 4 : Creating a Data Context

Now that your model classes are ready, let's proceed to creating a data context. A data context allows you to query and work with the entity data in your module. A data context is a class that inherits from DbContext base class. The following class shows how a data context for our example looks:

   1:  public partial class BlogContext : DbContext

   2:  {

   3:      public BlogContext():base("BlogDb")

   4:      {

   5:      }

6:

   7:      public DbSet<BlogPost> BlogPosts { get; set; }

   8:      public DbSet<Category> Categories { get; set; }

   9:  }

The BlogContext class inherits from DbContext base class. The constructor of the BlogContext class calls the base class constructor and passes a desired database name to it. When you run the application for the first time a database with this name is created for you. If you do not pass this information, the name of the database will be the same as the fully qualified name of the DbContext class (EFCodeFirstLib.BlogContext in our example).
The BlogContext class defines two public properties, viz. BlogPosts and Categories. These properties are of type DbSet. The DbSet class represents an entity set (in other words a database table) on which CRUD (Create, Read, Update, Delete) operations can be performed.

Step 5 : Testing Database Generation(optional)

To test the code you wrote so far, add a button in the control “EFView.ascx” in the project “EFCodeFirst” and add a reference to the EFCodeFirstLib project you just created. Then key-in the following code in the Button Click Event method.

   1:  using (var db = new BlogContext())

   2:  {

   3:      Guid id = Guid.NewGuid();

   4:      var cat = new Category { Id = id, Name = "ASP.NET" };

   5:      var post = new BlogPost { Title="Title1", Content="Hello World!", PublishDate=new DateTime(2011,1,1), Category=cat};

   6:      db.Categories.Add(cat);

   7:      db.BlogPosts.Add(post);

   8:      int i = db.SaveChanges();

   9:  }

The above code creates a new instance of BlogContext data context. It then creates an instance of Category and BlogPost classes respectively. The newly created entity instances are added to the DbSets and finally SaveChanges() method of the data context is called. The SaveChanges() method persists the entity data into the database tables and returns the number of records affected by the operation.
Now run the Console application. Since this is your first ever run of the application, EF will create the database and tables for you using SQL Express running on your machine. The name of the database created will be BlogDb (as specified in data context constructor) and two tables - BlogPosts and Categories - will also be created.

Figure 9: Database and tables created after the first click of the button on the page.

Notice how Id column of BlogPosts and Categories table is marked as primary key. Also, notice that BlogPosts table has a foreign key (Category_Id) defined.

Step 6 : Recreating the Database with Every Run

During the testing phase you may want to create the database under consideration with each run of your application so that your application runs on a clean slate. Additionally, you may want to add some test data into the database while it is being created. Database re-creation is desirable under one more scenario - when entities (and thus tables) change during development. By default EF will create the database only during the first run of the application and there after use the same database for further operations. To alter this behavior you need to create what is known as a database initializer. The initializer typically takes a form of a class inherited from DropCreateDatabaseAlways class. As the name suggests, the DropCreateDatabaseAlways class always re-creates the database. The following code shows BlogContextInitializer that does just that.
Tips : You can also make use of DropCreateDatabaseIfModelChanges class in which case the database will be re-created when models change.

   1:  public class BlogContextInitializer : DropCreateDatabaseAlways<BlogContext>

   2:  {

   3:      protected override void Seed(BlogContext context)

   4:      {

   5:          Category cat1 = new Category { Id=Guid.NewGuid(), Name=".NET Framework" };

   6:          Category cat2 = new Category { Id = Guid.NewGuid(), Name = "SQL Server" };

   7:          Category cat3 = new Category { Id = Guid.NewGuid(), Name = "jQuery" };

   8:          context.Categories.Add(cat1);

   9:          context.Categories.Add(cat2);

  10:          context.Categories.Add(cat3);

  11:          context.SaveChanges();

  12:      }

  13:  }

The BlogContextInitializer class inherits from DropCreateDatabaseAlways base class and overrides Seed() method. The Seed() method adds some sample data to the database being created. In the above example you add three categories. Once the initializer is ready you need to add the following line of code in the Main() method.

   1:  protected void Button1_Click(object sender, EventArgs e)

   2:  {

   3:      Database.SetInitializer<BlogContext>(new BlogContextInitializer());

   4:      ...

   5:      ...

   6:  }

Now you will find that with every run the database is re-created and the Categories table is populated with sample data.

Step 7 : Using an Existing Database with Code First

In the above example, you allowed EF to create a database for you. In many cases you may want to use an existing database rather than creating a new one. Because we use EF Code First in DNN, we can’t recreate the whole database used by DNN every time the model is changed. So that we have to use another database instead of the database used by DNN(DNN614 in this case). This can be accomplished by specifying a database connection string in the application configuration file (or web.config file) as shown below:

   1:  <connectionStrings>

   2:      <add name="SiteSqlServer" connectionString="Data Source=(local)\LEGAL;Initial Catalog=DNN614;

User ID=login614;Password=xxx" providerName="System.Data.SqlClient" />

   3:      <add name="BlogDb" connectionString="Data Source=(local)\LEGAL;Initial Catalog=DNN614_BlogDb;

User ID=lgfr;Password=xxx" providerName="System.Data.SqlClient"/>

   4:  </connectionStrings>

Figure 10 : Using an existing database

Note that the name of the database connection string as mentioned in the <connectionStrings> section and the one specified in the data context class must match. If you do not specify anything in the data context class, then the name of the data context itself is assumed. For example, we passed string "BlogDb" in the data context class (BlogContext) in which case EF will first check in the configuration file whether any connection string with name BlogDb is defined; if so, EF will use the database as mentioned in the connection string for further operation. If there is no connection string defined it will proceed and create a new database with name BlogDb under local SQL Express installation. If you do not pass anything to the base class from the data context class then EF will first look for a database connection string with name BlogContext in the configuration file and if found will use that database for further operations.

Step 8 : Using Data Annotations to Specify Table and Key Information

In the above example we used default conventions of EF while creating entity classes. You can use certain data annotations to customize this behavior. For example, consider the BlogPost and Category classes shown below that essentially do the same job as in the previous case but use some data annotation attributes to specify table name, primary key and foreign key information.

   1:  [Table("BlogPosts")]

   2:  public class BlogPost

   3:  {

   4:      [Key]

   5:      public Guid Id { get; set; }

   6:      public string Title { get; set; }

   7:      public string Content { get; set; }

   8:      public DateTime PublishDate { get; set; }

   9:      [ForeignKey("Category")]

  10:      public Guid CategoryId { get; set; }

  11:      public virtual Category Category { get; set; }

  12:  }

13:

  14:  [Table("Categories")]

  15:  public class Category

  16:  {

  17:      [Key]

  18:      public Guid Id { get; set; }

  19:      public string Name { get; set; }

  20:      public virtual ICollection<BlogPost> BlogPosts { get; set; }

  21:  }

As you can see, the [Table] attribute explicitly specifies the name of the table (BlogPosts and Categories respectively). On the same lines, [Key] and [ForeignKey] attributes specify primary key and foreign key information respectively.
The Entity Framework Code First allows you to make use of EF features directly at code level, i.e. without designing any Entity Data Models. This way you create entity classes as plain C# classes. You then define a data context by inheriting from DbContext class. Additionally, you can also use data annotation attributes such as [Key], [ForeignKey] and [Table] to specify the respective pieces of information explicitly. By default, EF creates a database under SQL Express when the application is run for the first time. You can alter this behavior by creating your own database initialization strategy. You can also use an existing database instead of creating a new one by specifying database connection string in the configuration file.

SUMMARY :

In a word, I don’t think it’s a good idea to apply EF into DNN, except that you can accept two databases in the meantime.

Juice UI: Open source ASP.NET Web Forms components for jQuery UI widgets (From Jon Galloway)

2012-03-21T03:00:00.000-07:00

This article is reprinted from Jon Galloway. Why I keep a watchful eye on Juice UI, that’s because it’s a really good idea to integrate jQuery into Asp.net web control components.

This morning at MVP Summit, Scott Hunter just announced a new open source project from appendTo called Juice UI. Juice UI is a collection of Web Forms components which make it incredibly easy to leverage jQuery UI widgets in ASP.NET Web Forms applications. You can start using it right away by adding the JuiceUI NuGet package to your app, and you're welcome to go nuts with the source, which is dual licensed under MIT and GPL.

What Juice UI does

jQuery UI is a library that's built on top of jQuery. It's got a lot of great widgets for common scenarios - things like date pickers, dialogs, and tabs - and they're all built on a really solid widget platform from some of the sharpest Javascript developers in the field. You've always been able to make use of these libraries using jQuery and jQuery UI, but the new Juice UI controls make it that much easier.

Example:

   1:  <asp:TextBox runat="server" ID="_Restrict" />

   2:  <Juice:Datepicker

   3:       runat="server"

   4:       TargetControlID="_Restrict"

   5:       MinDate="-20"

   6:       MaxDate="+1M +10D" />

Gives you this:

Included controls and behaviors

Juice UI is launching with 14 widgets and behaviors. You can see the whole list of controls at http://juiceui.com/controls, and they've all got interactive examples.

Here's the full list, linked to the documentation:

Walkthrough

Add the JuiceUI NuGet package

I'm going to start with a new ASP.NET 4 Web Forms project. I'll right click on the References folder, select Manage NuGet Packages..., and search for "juiceui"

The JuiceUI namespace

The NuGet package adds the JuiceUI namespace to my web.config, like this:

   1:  <configuration>

   2:      <system.web>

   3:          <compilation debug="true" targetFramework="4.0" />

   4:          <pages>

   5:              <controls>

   6:                  <add assembly="JuiceUI" namespace="Juice" tagPrefix="juice" />

   7:              </controls>

   8:          </pages>

   9:      </system.web>

  10:  </configuration>

If needed, I remove that and use the <@Import Namespace="JuiceUI" /> directive to bring that namespace at the page level.

Using the Juice UI controls

You'll first need an <asp:ScriptManager> - you can add one to a page, or you can add one to your site's Master page.

   1:  <asp:ScriptManager id="_Script" runat="server" />

Now I can just start using the controls. These are extender controls, so you use the TargetControlID property to point the Juice UI behavior at an Web Forms server control. Here's a stripped down example that hooks up a DatePicker behavior to a TextBox:

   1:  <asp:TextBox runat="server" ID="DateSample" />

   2:  <Juice:Datepicker runat="server" TargetControlID="DateSample" />

And just because it's fun, I'll add a Draggable behavior that's pointed at a Panel:

   1:  <asp:Panel runat="server" ID="DragBox" Style="border:1px solid; width:100px;">

   2:      Hi. You can drag me around.

   3:  </asp:Panel>

   4:  <Juice:Draggable runat="server" TargetControlID="DragBox" />

Note: I'm keeping this really simple for illustration here - of course the style would go in CSS, etc. There are more sophisticated examples in the Juice UI samples included with the source code.

Running this page shows I've got just what you'd expect - a date picker on the textbox, and a draggable panel.

Here's the complete markup for that page:

   1:  <%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master"

 AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="Juice_Sample._Default" %>

   2:  <asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">

   3:  </asp:Content>

   4:  <asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">

5:

   6:      <asp:ScriptManager id="_Script" runat="server" />

7:

   8:      <asp:TextBox runat="server" ID="DateSample" />

   9:      <Juice:Datepicker runat="server" TargetControlID="DateSample" />

10:

  11:      <asp:Panel runat="server" ID="DragBox" Style="border:1px solid; width:100px;">

  12:          Hi. You can drag me around.

  13:      </asp:Panel>

  14:      <Juice:Draggable runat="server" TargetControlID="DragBox" />

15:

  16:  </asp:Content>

And, in case you're interested, the widgets are hooked up using HTML5 data- attributes:

   1:  <input name="ctl00$MainContent$DateSample" type="text"

   2:          id="MainContent_DateSample"

   3:          data-ui-widget="datepicker" />

   4:  <div id="MainContent_DragBox"

   5:          data-ui-widget="draggable"

   6:          style="border:1px solid; width:100px;">

   7:      Hi. You can drag me around.

   8:  </div>

This seems familiar...

It's a very similar experience to the Ajax Control Toolkit, but using jQuery UI as an underpinning. That is, create Web Forms extender and script controls for all the widgets and effects in jQuery UI. Don't read anything into this - work is still continuing on Ajax Control Toolkit (in fact, there have been quite a few updates lately). The ASP.NET team's long term direction for client side scripting is jQuery, though, and Juice UI helps you to integrate with that really easily.

Finding out more

The best place to find out more about Juice UI is on the Juice UI site, which has interactive examples and documentation.

The source (including a sample project) is in the GitHub repository.

I'd recommend getting help either on StackOverflow (using the juiceui tag) or in the ASP.NET jQuery forum.

On my way to Bootstrap - Overview

2012-03-19T18:24:00.000-07:00

I've been working on DotNetNuke for almost one year. DotNetNuke is an open source CMS on the framework .Net.
Most of my job is in back-end, namely to develop or update some modules to meet clients' needs. But as consultant, I have to design and realize the layout of the site for my clients sometimes.
Fortunately, DotNetNuke offers a powerful solution "Skin" to take in charge of the front-end work , even so, I still find it's complicate and I was always lost in it, especially when dealing with the overriding of CSS and the conflict of Javascript.
In order to get a way out, I started looking up for one CSS framework, because i hoped that it could facilitate my front-end work, what's more, and that it can help me to build a simple, clear and beautiful site.
The goal is not just for DotNetNuke appearance but to enrich my front-end experience.
My first target is Blueprint, a CSS framework, which aims to cut down on your coding time. It offers a solid foundation to build your project on top of, with an easy-to-use grid, sensible typography, useful plug-ins, and even a stylesheet for printing. After several days' trial, I ended up giving up. There were two reasons for my quit :

It is not so easy to get started for me.
It is not so powerful as I thought. In other words, it is just a CSS framework, but front-end works also include javascript.

Recently, i heard that twitter had released a new version of Bootstrap which has some breakthrough upgradings. "So amazing ! "when I looked at it, I couldn't help myself saying that. Based on less, new scaffolding included customization and responsive design for various devices and resolutions, more Components and Javascript plug-ins, all of these new characters make me not hold on for a while.When i read his documentation online, suddenly, I realized it was just the framework i had been looking for.
I trusted my feeling and then I was on the way to Bootstrap. I write this article to record what i saw and thought in my code timeline, what’s more, share with others.

In general, Bootstrap has four parts clearly in above figure. One more thing, which is the most attractive to me : We can customize and extend Bootstrap with LESS, a CSS preprocessor, to take advantages of the variables, mixins, and more used to build Bootstrap's CSS. Of course, this is an advanced character, so we can try it after finish the base things.

P.S. Once I've got all the bases, i will create a template for my cnblogs using Bootstrap.

How to install DotNetNuke 6 on local

2012-03-19T06:51:00.001-07:00

DotNetNuke® is a world class web content management platform (CMS) for building professional websites with dynamic content and interactive features. DNN® makes it quick and affordable to develop a commercial website, a community portal, or an intranet solution. From version 6, they change source code from VB.net to C#.

When I tried to write some opening for this post, but why not give it up and start directly ? Here we go :

My local context : a Windows 7 Professionnel machine running IIS7.5, SQL Server 2005, and .NET Framework 4.0.

In general, only 5 steps can finish a clean install.

Download the New Install .zip from the site http://dotnetnuke.codeplex.com/

Create a database and a SQL Server login for dnn

Create the website folder and unzip the downloaded .zip file.

Create virtual directory in IIS and configure the website

Run the DNN install wizard in the web browser.

Let's talk about it in details :

1. Download the New Install .zip from the site http://dotnetnuke.codeplex.com/

CodePlex is Microsoft's open source projet hosting web site. DotNetNuke as the biggest open source CMS in .Net framework, there is no surprise to move it on CodePlex. Now, the newest stable version is 6.1.4 , so I downloaded DotNetNuke_Community_06.01.04_Install.zip.

2. Create a database and a SQL Server login for dnn

First of all, Make sure that your database server runs in "mixed authentication mode" (SQL Server and Windows Authentication mode is checked.) You can find this option by right-clicking on your sql server in the SQL Server Management Studio, then Properties → Security.

Secondly, Create the Database in your Sql server by using SQL Server Management Studio. For example, my sql server is (local) which has the new empty database named DNN614.

Finally, Create a login for your new database :

Expand the security node of your server

Right-click on Logins

Select "New Login"

Enter a login name, login614 for example

Select "SQL Server Authentication" and enter a password

Uncheck "Enforce Password expiration/User must change password at next login"

Click "User Mapping" on the left

Select/Check the new database you created in top grid "Users mapped to this login"

Select/Check db_owner in the bottom list "Database rôle membership for"

Click OK

Now look in the Security node under you database(DNN614) and you will see a newly created database user listed, meaning we also created a new database user by mapping our SQL Server login to our database(Figure 1).

Figure 1 : New database with new login

3.Create the website folder and unzip the downloaded .zip file.

In this step, we create a folder and unzip the DNN install .zip file to this directory. I used C:\Dev\WebDnnTest\DNN614.

One more thing, we must change the access permissions of your folder. The Windows account that is used to access your site must have full control over your DNN root folder. To set this, right-click on the root folder of your site (C:\Dev\WebDnnTest\DNN614). Click Sharing and Security. Click the Security tab. On the Security tab, you will see a list of users who have access to your folder. Add the NETWORK SERVICE account and give it full control permissions. In my remember, if we run DNN6 on local, we can skip this configuration.

4.Create virtual directory in IIS and configure the website

Now that the database and file system are in place, we can create the virtual directory in IIS

Open IIS and expand the tree Sites

Right click on it

Click « add a new Site »

Enter a name of site, and choose the path to the root directory of your website

Enter a name of host, dnn614 is my choice.

Open the C:\Windows\System32\drivers\etc\hosts file, and add this line « 127.0.0.1 dnn614 » then save

Click OK to finish

PS. If you want your site to run on .net 4.0, please change its application pool to ASP.NET V4.0.

5.Run the DNN install wizard in the web browser.

Open http://dnn614/ in your web browser and you will see :

Programs test the folder permissions when requested :

Enter the information to connect your sql server :

Click Next, you will see the wizard running the script for each version :

Click Next to configure Host Account, then on successful completion, your new DNN-based website appears :

Until now, all the DNN install is finished. You can enjoy it. Allez !!!

.NET Developper Salary Survey 2012 in United States [From Visual Studio Magazine]

2012-03-16T07:00:00.001-07:00

This is my abstract of the salary surveys, if you want to see the whole survey, please click this link : Visual Studio Magazine's 2012 .NET Developer Salary Survey

From this survey, we can get one conclusion : it's a good time to be a developer.

Your Primary Development Environment

Languages Used for Development Projects in the Last 12 Months

Salary by Range

Salary by Education

Average Salary, Male vs. Female

Salary by Job Title

Salary by Microsoft Technology Expertise

Average Salary by Role

Average Salary by Industry

In a word, Developer is a indeed good career, but not in everywhere, France for example...

Restore WordPress on local from a backup of cpanel on Mac

2012-03-14T17:47:00.000-07:00

Restore WordPress on local from a backup of cpanel on Mac

My context :

host : bluehost

domain name : ecca-paris.org

local machine : MacBook

Already create a wordpress sub-site in ecca-paris.org/wppretest/ for testing and developing

Prerequisite :

Whole backup included website and database which is got from Cpanel via bluehost.com

Apache server enabled php module

Mysql server

Steps :

1. Unzip the package of backup, and you will see many files in the backup. But, there are only two folders which are useful - /mysql and /homedir/public_html/wppretest

2. Copy /homedir/public_html/wppretest to the root folder of your apache server.

3. Restore database on local mysql server from the files of folder /mysql :

Open mysql from terminal : mysql -u root -p
Create database : source <your path>/mysql/eccapari_wrd1.create
Restore tables and datas : source <your path>/mysql/eccapari_wrd1.sql

4. Change wordpress configurations :

Find the file wp-config.php in <server path>/wppretest, and open it
Modify the informations "DB_NAME", "DB_USER", "DB_PASSWORD" and "DB_HOST" according to your situation.
Save it.

My example :

5. Open localhost/wppretest in your browser
    IF the page tell you that there a error with the connection to mysql database :
        Please check the file config, and mysql server running environment with your account and password.
        There is a way to test connection to database :

Create a file named "test.php" in the root of apache server folder.

Write the codes below and save it :

<?php
    $dbhost = '127.0.0.1';
     $dbuser = 'root';
    $dbpass = '123';
    $dbname = 'test';
    $conn = mysql_connect($dbhost, $dbuser, $dbpass) or die ('Error connecting to mysql');
    mysql_select_db($dbname);
?>

open localhost/test.php in your browser, if nothing in your page, you get the right connection.

    IF the connection is built, but the presentation of page mass up or the links don't function :
        Please modify your home url in the database, this is because you use localhost/wppretest to enter the site rather than "www.ecca-paris.org/wppretest".
        Follow the instructions to fix problem :

Open database eccapari-wrd1 by taping mysql -u root -p eccapari-wrd1

Check : select * from wp_options where option_name="siteurl" or option_name="home";

+-----------+---------+-------------+-------------------------------------+----------+
| option_id | blog_id | option_name | option_value | autoload |
+-----------+---------+-------------+-------------------------------------+----------+
| 39 | 0 | home | http://www.ecca-paris.org/wppretest | yes |
| 3 | 0 | siteurl | http://www.ecca-paris.org/wppretest | yes |
+-----------+---------+-------------+-------------------------------------+----------+
2 rows in set (0.12 sec)

Modify : update wp_options set option_value="http://localhost/ecca/wppretest" where option_name="siteurl" or option_name="home";
+-----------+---------+-------------+---------------------------------+----------+
| option_id | blog_id | option_name | option_value | autoload |
+-----------+---------+-------------+---------------------------------+----------+
| 39 | 0 | home | http://localhost/ecca/wppretest | yes |
| 3 | 0 | siteurl | http://localhost/ecca/wppretest | yes |
+-----------+---------+-------------+---------------------------------+----------+
2 rows in set (0.00 sec)

6. Finally, your wordpress on local should be functional. Enjoy it.

Powered by Qumana

Swap rows and columns in SQL

2012-03-14T08:54:00.002-07:00

Create a table :

1 CREATE TABLE MyTable(
2 　　A int NOT NULL,
3 　　B nvarchar(50) NOT NULL,
4 　　C nvarchar(50) NOT NULL
5 ) ON PRIMARY

Then insert some datas :

1　　 A           B               C
2 　　--------- ------------- -------------
3 　 1          date           10/10/08
4 　 1          fname          jon
5 　 1          lname          doe
6 　 1          receipt        99999
7 　 1          transnum       123
8 　 55         date           10/10/04
9 　 55         fname          allen
10 　55         lname          smith
11 　55         transnum       345
12 　121        date           10/2/08
13 　121        fname          sandra
14 　121        lname          adams
15 　121        receipt        99998
16 　121        transnum       5465

Now we want to transform it to:

1 　　A      DATE      FNAME  LANME  RECEIPT  TRANSUM
2 　　1     10/10/08   jon    doe    99999    123
3 　　55    10/10/04   allen  smith  NULL     345
4 　　121   10/2/08    sandra adams  99998    5465

There are two simple solutions, and just use CASE and MAX :

　　-- Static SQL :

1 　SELECT A
2     , MAX(CASE B WHEN 'date'     THEN C ELSE ' ' END) AS DATE_COL
3     , MAX(CASE B WHEN 'fname'    THEN C ELSE ' ' END) AS FNAME
4     , MAX(CASE B WHEN 'lname'    THEN C ELSE ' ' END) AS LNAME
5     , MAX(CASE B WHEN 'receipt'  THEN C ELSE ' ' END) AS RECEIPT
6     , MAX(CASE B WHEN 'transnum' THEN C ELSE ' ' END) AS TRANSNUM
7 　FROM MyTable
8 　GROUP BY A

　　
-- Dynamic SQL for B has more than these five rows (Date, fname, lname, receipt, transnum)

1 　-- char(10) : New line
2 　DECLARE @sql varchar(8000)
3 　SET @sql = 'SELECT A ' + char(10)
4 　SELECT @sql = @sql + ', MAX(CASE B WHEN '''+B + ''' THEN C ELSE '' '' END) AS '+ UPPER(B)+ char(10)
5 　FROM (select distinct B from MyTable) as a
6 　SET @sql = @sql + ' FROM MyTable GROUP BY A'
7 　PRINT @sql
8 　EXEC(@sql)

Code Ciel

JavaScript Object Literal

JavaScript Object Literal

Introduction: Definition and Purpose

How and Why We Use Object Literals

Basic Syntax

Adding Properties to an Object

Further Resources

Helping increase your SEO - link juice

Location of links in markup

Anchor text

Quantity of links per page

Delegating link authority with rel="nofollow"

6 Ways Men and Women Communicate Differently

Introduce to STORM

How to develop jQuery Plugins

How to Write Maintainable OO JavaScript Code

Reprint : How to Write Maintainable OO JavaScript Code

What is OO?

Warning: JavaScript OO is different

Object Instantiation

Prototypal Inheritance

Code Reuse Through Inheritance

Public and Private

Read-only

Public

Completely Private

Writing a Flexible API

Saner Parameter Lists

Make It Pluggable

Summary

How To Use HighCharts - Intractive Javascript charts for your web projects

Responsive Web Design: Meta Queries and Viewports

Understanding Module Structure DotNetNuke6

Entity relationship diagram of the database DotNetNuke Community Edition 5.6.1

Must-have Cheat Sheets for Web Development

The Huge Collection of Google Analytics Tips

Entity Framework Code First in DotNetNuke 6

Juice UI: Open source ASP.NET Web Forms components for jQuery UI widgets (From Jon Galloway)

This article is reprinted from Jon Galloway. Why I keep a watchful eye on Juice UI, that’s because it’s a really good idea to integrate jQuery into Asp.net web control components.

What Juice UI does

Included controls and behaviors

Add the JuiceUI NuGet package

The JuiceUI namespace

Using the Juice UI controls

This seems familiar...

Finding out more

On my way to Bootstrap - Overview

How to install DotNetNuke 6 on local

.NET Developper Salary Survey 2012 in United States [From Visual Studio Magazine]

Restore WordPress on local from a backup of cpanel on Mac

Swap rows and columns in SQL