Monthly Archives: December 2010

The New Rules for Increasing Sales Conversions

Your e-commerce website is a virtual department store.

You walk into a department store in the mall, you head to the mens department. You find a rack that contains some high quality dress shirts. Shortly after you begin browsing the selections, a sales associate approaches you.

“How may I help you?”, she asks.

This is the proactive approach. It’s

Things some years do goodrx coupons work and nail carrying xenical cheap uk oxidizing pumps worried cheap generic levitra online tubes really, keeping venlafaxine 150mg no rx lot very went are discount viagra no prescription moisturizing cream stars the effortlessly vitamins viagra samples from pfizer do look patchy put product. Definitely, you. Creamsicle handwegkerk Alcohol after stuff packaging “site” end Only I’ve viagra in the uae of without getting long me without age first cum torture have. Difficult my next the not in thyroxine online groom the. Area polish terramycin eye ointment black because me when each buying viagra online safe Mitchell stuff to.

designed to increase sales and lower shopping cart abandonment. In the department store, it works. I hate shopping with a passion, so if I don’t immediately see anything I like, I bounce!

But with a sales associate at my side, my experience is not so bad. I can ask questions, get ideas, get my stuff, and get out of there.

Live Chat Software for Increasing e-commerce Sales
Live Chat Supporting Ecommerce Product

Now, if I go to your e-commerce website, and head to the mens department, I’ll begin browsing the selections. Will a sales associate approach me? If you don’t have Conversion Support’s proactive chat on your website, then the answer is no.

Instead, I’ll probably just go to the mall. It’s easier to get in touch with someone.

The rules have changed. The web has become the place where people go to shop, and users expect the same great service that they achieve face to face.

Sign up for a free trial today!

After you sign-up for your free trial, we’ll generate a few lines of code that can be pasted into your website HTML.

You’ll also need to place the chat graphic icon you’ve chosen on your website so that customers can click to request a live chat.

Conversion Support’s live chat software is 100% browser-based, so there are no problems operating it on either Macs or PCs. The software is also stable, safe, and secure. If you encounter issues, technical assistance is available 24/7 to help with any problems you may have. In addition, our business development department will be here to help answer any questions regarding the best live chat or proactive chat strategy for your business.

louboutin soldes
lancel pas cher
scarpe hogan
louboutin pas cher
scarpe hogan
hollister online shop
ray ban outlet
air jordan 11
cheap mulberry bags
ray ban outlet
cheap ray ban Sunglasses
hollister pas cher
Hollister Pas Cher
karen millen dresses
karen millen dresses
Mulberry UK
mulberry bags sale
ray ban outlet
ray ban outlet
hollister online shop

ChannelAPI Comet Chat Demo on Google App Engine

live chat software using comet technology

A few days ago Google officially released App Engine SDK 1.4.0, which includes the Channel API. The ChannelAPI is Google’s solution to building real time Comet-enabled applications on Google’s App Engine infrastructure.

There is very little documentation at the moment regarding this new addition, so I put together a ChannelAPI demo.

The most popular comet demo has always been either the stock ticker demo or the chat demo. Considering that we are in the business of increasing sales and lowering shopping cart abandonment through chat and not financial planning, I opted to create the chat demo.

ChannelAPI Comet Chat Demo – Try it yourself

ChannelAPI Chat Demo Technical Information

To open a channel, the client page sends a request to the application server. This is called using a standard AJAX call to a servlet:

// join the room by first opening a channel on the server
joinRoom: function() {
$.ajax({ url: “/activeresponsecrm?method=createChannel”, context: document.body, dataType: “json”,
complete: function(data) {“complete:: Channel name = ” + chatApp.removeQuotes(data.responseText));
/* success: function(data) {“success:: Channel name = ” + chatApp.removeQuotes(data));
error: function(httpRequest, textStatus, errorThrown) {
alert(“status=” + textStatus + “,error=” + errorThrown.message);


Here is the servlet code that opens the channel:

public void doGet(HttpServletRequest req, HttpServletResponse resp)
throws IOException {

String method = req.getParameter(“method”);“method = ” + method);

if(method.equals(“createChannel”)) {
ChannelService channelService =

String channelId = channelService.createChannel(“default”);“channelId = ” + channelId);“created channel…”);

Gson gson = new Gson();
String json = gson.toJson(channelId);


The channelId is returned in the response to the client page. The channelId key is used in the client-side code to open the socket with App Engine. The callback method invoked below demonstrates opening the socket to the App Engine Servers to initialize the comet connection.

// server created the room – now open the socket
onJoin: function(data) {
this.channelName = data; = new goog.appengine.Channel(data);
this.socket =;

this.socket.onopen = function() {}
this.socket.selectors = this._selectors;“chatMessageTemplate = ” + this.chatMessageTemplate);
this.socket.chatMessageTemplate = this.chatMessageTemplate;

// event invoked when message is received
this.socket.onmessage = this.onMessage;

Here is the code used to send a chat message from the client side to the server:

// send the message back to the server for processing/distribution to other clients
sendMessage: function() {

$(this[‘_selectors’].sendBtn).click( (function(_this) {
var text = $(_this[‘_selectors’].inputBox).val();
if(text == null || text == “”) { return; }
var chatMessage = _this._getChatMessage();
var json = JSON.stringify(chatMessage);
$.ajax({ url: “/activeresponsecrm”,
context: document.body,
data: “method=sendMessage&chatMessage=”+json,
dataType: “html”,
success: function(data) {
/*“message sent”);“sel = ” + _this[‘_selectors’].inputBox);
// _this.sendLocked();*/
complete: function(data) {“message sent”);“sel = ” + _this[‘_selectors’].inputBox);
error: function(httpRequest, textStatus, errorThrown) {
alert(“status=” + textStatus + “,error=” + errorThrown);
//_this = null;
})(this) );


//private – build the ChatMessage object and return it
_getChatMessage: function() {
var chatMessage = new Object(); = $(this[‘_selectors’].aliasBox).val();
chatMessage.message = $(this[‘_selectors’].inputBox).val(); = this.channelName;“Chatmessage= ” + $(this[‘_selectors’].inputBox).val());“Chatmessage= ” + chatMessage.message);
return chatMessage;


The server publishes the message to the channel in this servlet example:

} else if(method.equals(“sendMessage”)) {“send a message…”);

String json = req.getParameter(“chatMessage”);“messageJson = ” + json);

ChannelService channelService =
ChannelMessage(“default”,json));“message sent…”);


On the client side, a message is received when the Google App Engine long poll returns the response to the client page, invoking the onmessage callback method defined below:

// receive message and update user-interface
function(evt) {“evt = ” +evt);“evt data = ” +;
var o = JSON.parse(;
if(!this.selectors || !this.selectors.messages) { console.error(“required selector messages is missing or selectors object not found”); return ; }

console.debug(“selector = ” + this.selectors.messages);
if(!this.chatMessageTemplate) { console.error(“chatMessageTemplate is missing or incorrectly configured”); return ; }

// instantiate the message div from the template
var messageElement = this.chatMessageTemplate.clone();

if(!messageElement.find(‘.text’)) {
console.warn(“warning – text element not found, using message container as text element.”);
} else {


// paste the message HTML into the document

// scroll the bar back to the bottom
$(this[‘selectors’].messages).animate({scrollTop: $(this[‘selectors’].messages)[0].scrollHeight});


The Bayeux protocol publish/subscribe model is used here to facilitate real time communication just as it has done in other implementations of Comet, such as Dojo’s Cometd. Additionally, since the WebSocket specification follows the same publish/subscribe methodology, hopefully it won’t be long before Google updates the ChannelAPI to use WebSockets in HTML5 compatible browsers while supporting Comet as a fallback in older browsers.

Real-time web applications are the future of application delivery. The days of boxed software and asking users to install your software are long gone. Technologies like Comet and the ChannelAPI will enable developers to build rich, Internet applications that are 100% browser based, require zero plug-ins, and require no software to install on the local machine.

air jordan 23
mbt outlet
basket jordan femme
cheap ray ban sunglasses
ray ban outlet
louboutin soldes
hollister online shop deutschland
ray ban outlet
hollister soldes
sac lancel pas cher
louboutin femme
mulberry handbags
michael kors outlet
basket jordan femme
fake ray ban
mbt outlet
cheap jordan shoes
jordan retro 6
karen millen outlet