aspdotnetstorefront » Page 2

Tag: aspdotnetstorefront

AspDotNetStorefront Tip to Expose Keywords to Internal Search Engine

AspDotNetStorefront BlogThe newly launched AspDotNetStorefront blog launched with a bang recently. In addition to taking advantage of the opportunity to introduce the world to some of their unsung heroes in the Sales and Support department, their first programming tip is something that proved to be quite timely to one of our clients who was experiencing a particular problem with the internal full-text search.

Read more

Launching Your eCommerce Store

So you’ve gotten the keys to your eCommerce storefront from your designers and developers, but what comes next? Well, this question will depend largely upon how much work was done by the aforementioned boffins and artists but we’ll take a stab at outlining the required steps before you go live.

Just keep in mind that if you’ve found that some of this has already been taken care of for you, all the better. We will also be talking specifically about AspDotNetStorefront-based eCommerce sites but the principals are the same across just about any eCommerce storefront.

  • We’ll assume that your selected design has been integrated and all of the cogs and gears (and databases) have been fitted together to make it operate.
  • In many cases, if the site is on a temporary or staging server, you will need to find a suitable hosting company. We recommend Applied Innovations for our AspDotNetStorefront customers. Once you’ve selected your host, communicate the necessary account information (site URL, SQL server address, site IP address, FTP address, login and password (for cpanel, ftp and SQL) to your developer so they can move the site from staging environment into what will shortly become the live site environment.
  • You’ll need to determine how you are going to accept payment on your website. 
    – For many customers, this will mean nothing more than a PayPal account. The best level of PayPal service is PayPal Pro which enables you to not only accept payment from a customer’s PayPal account (which many customers prefer since they don’t need to give the retailer any financial information) as well as accept credit cards within your website AND have a virtual terminal available as well.
    – Another option to investigate is Google Checkout. This offers many of the same features as PayPal but with the exception of AspDotNetStorefront, most eCommerce websites don’t fully support Google Checkout. Google Checkout is a bit harder to implement into the website than PayPal but is not too hard once you’ve created your merchant account. One of the biggest problems with Google Checkouts comes when you don’t use an authorized/approved SSL Certificate on your website. Please see “API authentication and security : Accepted SSL certificates …” for more information.
    – You could also use a traditional payment gateway. Merchants with existing merchant credit card accounts, especially if they do higher volumes, may find this a better option on a pricing standpoint. It is best to talk with your developer to determine which gateways are supported by your site software.
  • I’ve touched briefly on SSL certificates above under Google Checkout. If you think you will ever want to offer Google Checkout (as a primary or a secondary payment option), you’ll want to ensure that your SSL certificate is up to snuff. See the link above and talk with your contact at your hosting provider about getting a certificate installed on your website. If your storefront uses standard PayPal and hands off to them to collect billing information, you won’t need an SSL certificate. However, the price paid for an SSL certificate to keep the transaction on your site is a small price to pay in comparison to the confidence that little lock in the browser window has for many consumers.
  • You’ll need to start thinking about how you want to handle shipping the items that you are going to sell. This can be as simple as setting a flat-rate or as complex as setting up zones for weight-based pricing or setting up RealTime Shipping which will do weight-based lookups against any number of shippers to come up with options for your customers. The latter is probably the most complex since it requires getting various licenses and keys from your shipping companies but will be most reliable. AspDotNetStorefront offers pretty comprehensive directions on how to set up RealTime Shipping but someone who’s experienced can help make this go quicker.
  • Lastly, you should be looking at content on your website. This includes “traditional” content (text on pages) as well as search engine settings like Keywords, Page Titles, Descriptions and such. Some areas to look for specifically are:
    • Physical and Email Address needs to be updated on Contact and About pages as well as in outbound emails
    • Descriptions and SE fields (Page Title, Meta Keywords and Meta Descriptions) need to be set sitewide (in many eCommerce sites the default is applied to any page that doesn’t specifically define it’s own values) as well as  for all Categories and Manufacturers (if any)
    • Product names, images, descriptions, prices and inventory counts (if you are tracking inventory) will need to be added to the site and mapped to their appropriate categories. You will want to keep your Search Engine target keywords in mind as you craft the various parts of your product offerings.
    • Content for the various topics used through out the site (primarily items found off the customer service menu link)
    • If they will be doing drop shipping, distributors will need to be added to the system.

This may seem like a daunting task but it shouldn’t be. We are of the opinion that it is more important to get your site out there in a timely manner with a partial offering of your wares than to wait to launch while you meticulously craft every one of your product descriptions and other information. By launching early with a subset of your products and the bare minimum of content you

  • Start the clock on your domain aging. Research has shown that links and domains that have a greater age will outperform and outrank similar sites and terms that have a shorter “time in service” in search engine results page (SERP) rankings.
  • Condition the search engines to come back to your site regularly as you add items to your site over the coming weeks. The more frequently that the search engine spiders see changes to the content on your site, the more frequently they will come back and look for new content.The more new content they find, the more they will like you.
  • Launch your search engine optimization program. Sure you want to have the basics covered but you really can’t start your linking campaigns and advertising until you have something that you can direct traffic to.
  • Can start driving income through your site to help offset the time and effort involved to continue populating your site with product and information

So, if you have categories that you haven’t added any products to (provided they aren’t direct linked from a non-dynamic navigation structure, unpublish them until you have product underneath them. If they are linked from your primary navigation structure AND that navigation structure isn’t generated automatically from the data base (there are many reasons to do this but that is fodder for a different post) you should craft the description for that category quite well with your keyword strategy in mind and update the standard “No Products Found message” to be something more witty so you don’t upset your customers when they see the message too often.

Similarly if you have products that don’t have images attached yet or you haven’t had time to write a good description of the product that works well with your keyword strategy, unpublish them until you have the time to correct these items.

In the coming days/weeks, I hope to follow this blog posting up with screencasts that will address many of these points specifically for AspDotNetStorefront to help customers learn some of the tips and tricks for moving around in the admin interface and complete these goals so they can concentrate more on making money and less on being a “content monkey.”

As always, if you have any LEGITIMATE questions or comment, please feel free to use the comments section below.

Updated Breadcrumb Post Tip

In the blog posting entitled SEO And ASPDotNetStorefront, I presented a way to modify the breadcrumbs automatically created in ASPDotNetStorefront. Well, it appears that I left out one potential way that the breadcrumbs could be presented.

When a top level entity entity (Section, Category, Genre, etc) are displayed the top level is wrapped in a span tag with a class of SectionTitleText. Unfortunately, given my earlier code, this will end up presenting the Section_Title in the same size text rather than the size defined in your H1 tag since H1 tags would end up around the previously mentioned span.

Instead of :

if (SectionTitle.LastIndexOf(sep) == -1) // if there is no arrows in bread crumb
    s = s.Replace("(!SECTION_TITLE!)", String.Format("<h1>{0}</h1>",
        SectionTitle));
else


I now use:
if (SectionTitle.LastIndexOf(sep) == -1) // if there is no arrows in bread crumb
    if (SectionTitle.Contains("<span class=\"SectionTitleText\">")) // This is the root of an entity so strip off this span tag
    {
        tmpS = SectionTitle.Replace("<span class=\"SectionTitleText\">", "");
        tmpS = tmpS.Replace("</span>", "");
        s = s.Replace("(!SECTION_TITLE!)", String.Format("<h1>{0}</h1>",
            tmpS));
    }
    else // this is some other thipe of page
        s = s.Replace("(!SECTION_TITLE!)", String.Format("<h1>{0}</h1>",
            SectionTitle));
else…

This will trap instances of the SectionTitleText span and removes them from the SectionTitle (if found) before doing the token replacement.

Which Version of AspDotNetStorefront Should I Choose?

Many of my customers are having to ask themselves this same question. They know they want to have the best e-commerce platform out there (who doesn’t?) but the struggle in deciding which of the 4 platforms to choose from. perhaps I can help guide you through the decision process.

Are you planning on running your store inside of DotNetNuke? If the answer to this is yes, then you will for sure want the ML/DotNetNuke version of the software. If not, let’s move on.

Will your site be hosted on a 64-bit version of Windows Server in order to accommodate the volume of traffic your site is expected? If yes, keep in mind that the ML/64-bit version of ASPDNSF will not support certain payment gateways (Bank of America via Cybersource, CyberSource, IATS TicketMaster and PlugNPay). Also note that if are running your site on a 64-bit server, you can still run any of the other versions, you just won’t gain the speed that comes along with the full 64-bit system.

This narrows your search down to either ML/Express and ML version of AspDotNetStorefront. To make things easier, I’ll list a series of functions that if you can’t live without any ONE of them, then you should step up to the full ML version. We’ll start with what I think are the most important first.

  • Will you always be shipping physical (as opposed to digital) products? Express version will not support digital download products like the full version will.
  • Will your site never grow beyond 500 items? This is the cap on the number of products you can have in your store. Of course, with ASPDNSF’s variants, size and color options, this can represent a large number of items.
  • Can you live without offering Google Checkout to your customers? This is a significant question if you intend to do AdWords advertising. If your site offers GC, then your AdWord ads can have the Google Checkout logo next to them making them stand out from other options.
  • Speaking of Google, will you be able to live without conversion tools in Google Analytics? You should be able to embed the raw Analytics code into your templates but you won’t be able to do more in-depth e-commerce conversion tracking.
  • Can you live with no more than 100 topics in your site? For most sites, this is probably true but for many, in particular those who are looking to do many landing pages on their site, this might be a deal killer.
  • Can your site survive without any modifications to the source code (including code-behinds)? The XMLPackages that ASPDNSF uses to control the display of data on web pages gives you a great deal of flexibility but it appears that the Express version comes pre-compiled which removes access to “mid-range” changes to the code-behinds as well as significant changes that require access to the full source code.
  • If you need to work with drop shippers, plan on working a little harder. The full version has a series of very handy tools to work with drop shippers that you’ll have to do manually in the Express version of ASPDNSF.
  • Other features you’ll have to live without are Product Ratings & Reviews, Customer Levels (including wholesale), Affiliate programs, Recently Viewed Products and Customers who Bought X also bought Y type features.
  • If you feel that your site can live without kits or packs, then you should be good to go. If not, then it is time to step up.
  • Only need simple shipping options? Great. If you need more complex shipping rules such as calculating by Order weight & Zone or Order Total & Zone, then you will need ML. You will also give up shipping calculations from DHL International, Australia Post and Canada Post. You also will not be able to set up customer levels that allow for free shipping or use multiple ship-to addresses per order.
  • Given that you have less than 500 products, you should be ok with not having XML imports, Web Services Automation Imports or Event Notifications or callbacks to external web services.
  • You will similarly have to give up the Gift Registry and Wish Lists. If your business model requires these features, then Express is not for you.
  • Se habla e-commerce? If you are looking to build a store that supports multiple languages, then look to the full ML version.
  • Will you be using PayPal for your CC transactions? If so, you should be good as the Express version only supports 7 other credit card gateways while the full ML supports over 40 different gateways.

To see the complete list you can see it at http://www.aspdotnetstorefront.com/t-features.aspx but we’ve found most of our customers can make a decision pretty quickly by working their way through the list shown above.

SEO And ASPDotNetStorefront

In almost all respects, this is a FANTASTIC product in terms of providing the webmaster/merchant/developer with a great set of tools for SEO purposes. You define, on a page by page, product by product basis not only the page name but also the title, product image alt tag, meta keywords and description but the process is also painless to boot!

There is one aspect of the site that has left me “wanting more” and that is the operation of the breadcrumbs. This is a must-have feature for any e-commerce website and ASPDNSF does a good job of this. However, they don’t necessarily make it easy to modify the display string format without having to have a source code license as the generation of this string is compiled into one of the site DLLs.

A recent post in the great support forums for ASPDNSF inspired me to revisit this issue.

What I’ve always wanted to do, from a display and from an SEO standpoint, was to set up my client’s sites so that the primary keywords on any given page are used in the URL and that first occurrence of the keywords on a page are formatted as the only occurrence of Heading 1 (<h1>) as well as sprinkling them in the content. ASDNSF, by carefully naming products (and topics and sections and categories) appropriately, will automatically take care of most of this EXCEPT the Heading 1 tag. I can modify a product page so that they Name of the product is set up as Heading 1 but the challenge is that the first occurrence of this phrase is in the page is in the breadcrumb and has no emphasis, thereby discounting it in the eyes of the almighty search engine bots. (See below)

breadcrumb example, out of the box

However, by going in and doing a little string manipulation in the SkinBase.cs file (which is thankfully NOT compiled into the DLLs) I’ve gone in and broken apart the breadcrumb and made the name of the item (product, category, section, etc) into a Heading 1 giving it primary importance on the page.

image

The code to do this isn’t particularly elegant, nor is it difficult. I’ll outline the logic and then show the complete code at the end.

The idea is to find out if the SectionTitle (the value used by ASPDNSF as the breadcrumb and created in one of the DLLs)  contains the string used as a breadcrumb separator. If not, this is a either a stand-alone page (topic, system page, etc) or it is the root level of one of the entities (product, category, section, etc). If so, we just slap <h1> tags around it and be done with it.

string sep = AppLogic.AppConfig("BreadcrumbSeparator");
if (SectionTitle.LastIndexOf(sep) == -1)
s = s.Replace("(!SECTION_TITLE!)",String.Format("<h1>{0}</h1>",SectionTitle));
else

Otherwise, we know it is a traditional breadcrumb and we’ll need to determine where to insert the tags at specific points in the string. We again look for the last instance of the breadcrumb separator and add 1 to it’s own length (‘cause it has a trailing space). The end tag location is determined by subtracting 7 (the length of a space and the closing span tag).

int insertOpening = SectionTitle.LastIndexOf(sep) + sep.Length + 1;int insertClosing = SectionTitle.Length – 7;

Once we have these, we can insert the appropriate Heading 1 tags into a string.

string newSectionTitle = String.Format("{0}<h1>{1}</h1>{2}",
SectionTitle.Substring(0, insertOpening), SectionTitle.Substring(insertOpening, insertClosing – insertOpening),
SectionTitle.Substring(insertClosing));

So, instead of using

s = s.Replace("(!SECTION_TITLE!)", SectionTitle);

which is the default code for this function, we’ll use the following instead:

string sep = AppLogic.AppConfig("BreadcrumbSeparator");
if (SectionTitle.LastIndexOf(sep) == -1) s = s.Replace("(!SECTION_TITLE!)", String.Format("<h1>{0}</h1>",SectionTitle));
else{
int insertOpening = SectionTitle.LastIndexOf(sep) + sep.Length + 1;
int insertClosing = SectionTitle.Length – 7;
string newSectionTitle = String.Format("{0}<h1>{1}</h1>{2}",
SectionTitle.Substring(0, insertOpening),
SectionTitle.Substring(insertOpening, insertClosing – insertOpening),
SectionTitle.Substring(insertClosing));

s = s.Replace("(!SECTION_TITLE!)", newSectionTitle);
}

I've found this code to be helpful to resolve the problem described at the top of this blog post. Hopefully you will as well. Please leave us comments below if you agree or disagree with me.

Adding Bar Codes to Receipts in AspDotNetStorefront

Sample Administrative Notification ReceiptA recent posting in the AspDotNetStorefront forums got my brain spinning on how best to accomplish this. The technology to do this, once written, should be able to be leveraged in other areas that clients of mine have been looking to do. So, out comes Visual Studio and Google to come up for some starting points on how to accomplish this.

Research pointed me at an article by Zach Smith on TechRepublic that provided the basis for this project.  With this, I created a class file to place in the site’s /App_Code directory containing the following code:

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Text;

namespace BarCode{public class BarCode
{
public static Bitmap CreateBarcode(string data)
{
// Create the Bitmap we'll be using.
Bitmap barCode = new Bitmap(1, 1);
// Get a reference to the Free 3 of 9 font. We'll use this to generate the barcode.
// Found at http://www.squaregear.net/fonts/free3of9.shtml
Font threeOfNine = new Font("Free 3 of 9", 60, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
// Get a graphics object to work with
Graphics graphics = Graphics.FromImage(barCode);
// Now we need to get the width and height that our data will cover 
// after is is rendered with the Free 3 of 9 font
SizeF dataSize = graphics.MeasureString(data, threeOfNine);
// Now we base the Bitmap's size off of this data
barCode = new Bitmap(barCode, dataSize.ToSize());
// Refresh our Graphics object with the new bitmap
graphics = Graphics.FromImage(barCode);
// Make the Graphic object's drawing surface white
graphics.Clear(Color.White);
// Set the rendering hint to SingleBitPerPixel
graphics.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
// Draw the string onto the Graphics ojbect
graphics.DrawString(data, threeOfNine, new SolidBrush(Color.Black), 0, 0);
// Force the graphics object to execute any pending operations
graphics.Flush();
// Dispose of our objects
threeOfNine.Dispose();
graphics.Dispose();
// Return the finished barcode
return barCode;
}
}
}

One of the key features of this code is the font that is used to create the barcode. Matthew Welch has released a number of freely available TrueType fonts at his site I Shot the Serif. The font in question is his “Free 3 of 9” which will produce a 3 of 9, or Code 39, barcode that is scannable by my hand-held scanners. You will need to download the fonts and install them into the %windir%\font directory on the server running the storefront. One thing that is very important is that the font won’t be available until either the server is rebooted or you’ve run IISRESET on the server. Normally the font is available immediately as soon as it is added to the server’s font directory to most applications but working with IIS6 on a Win2k3 server and IIS7 on a Vista box required an IISRESET to enable the font.

Next, we need to create a file in the website that will will actually generate the barcode image on the fly. This is done in the code-behind of the CreateBarCode.aspx file:

// ------------------------------------------------------------------------------------------
// Copyright Exhibit A Communications, 2009.
// Portions copyright Zach Smith, http://blogs.techrepublic.com.com/howdoi/?p=173
// 
// THE ABOVE NOTICE MUST REMAIN INTACT. 
// ------------------------------------------------------------------------------------------
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using AspDotNetStorefrontCommon;
using BarCode;
namespace AspDotNetStorefront {
/// <summary>
/// Summary description for createbarcode.
/// </summary>
public partial class createbarcode : System.Web.UI.;color: #2b91af">Page
{
protected void Page_Load(object sender, System.EventArgs e)
{
string data = Request.QueryString["data"];
Response.ContentType = "image/gif";
Response.Clear();
Bitmap barCode = BarCode.BarCode.CreateBarcode("*" + data + "*");
barCode.Save(Response.OutputStream, ImageFormat.Gif);
Response.End();
barCode.Dispose();
}
}
}

You’ll notice that in the call to BarCode.BarCode.CreateBarcode() includes an asterisk before and after the actual code to be encoded into the barcode. This is because Code39 barcodes are supposed to be enclosed in asterisks in order for scanners to identify the barcode type. This simple file just takes the querystring value named “data” and passes it (after enclosing it in *) to the CreateBarcode() function in the BarCode class in the BarCode namespace.

Lastly we will need modify the XMLPackage to generate the call to this image. In my client’s case, they want this to show up in the administrative notification email which is printed for the order pickers. As such, I added the following code to the appropriate location in the notification.adminneworder.xml.config file that generates this email.

<tr>
<td colspan="2" align="center">
<img src="{/root/System/StoreUrl}createbarcode.aspx?data={$OrderInfo/OrderNumber}" alt="Order Number {/root/QueryString/ordernumber}" />
</td>
</tr>

In this case, the table row is inserted into the tblOrderHeader table generated by the order ID. Please note that I’ve used two different
methods to pull in the order number into the <img> tag for illustrative purposes; either one will work

Hopefully someone else will find this handy. If so, please leave a note in the comments field below. Of course, if the work to implement this is beyond your abilities or the time available to you, please feel free to contact us and we’ll contract to do the work for you.

Webgains, ASPDotnetStorefront and Google Checkout, Oh My!

I got a Google Alert about an article posted recently by UK Developers over at WebOpius. The put together a nice little piece about how to get all three of these technologies up and running, and better yet, playing nicely together. This is the first of many posts by them on this subject. I very much look forward to seeing how the progress on this project as it may prove beneficial to my customers as well!

In case you aren’t familiar, ASPDotNetStorefront (ASPDNSF) is the leading e-commerce solution for the ASP.NET platform. Google Checkout is a competitor (of sorts) to PayPal while WebGains is an affiliate facilitator where merchants can create and manage an affiliate network to help sell more.

Some of you may be saying, but wait, doesn’t ASPDNSF have an affiliate program built in? Yes Virginia, it does. However, it is really more of a framework upon which to build your own affiliate program. Not only will an affiliate program like WebGains help you manage your relationship with your affiliates, but you will also have access to a ready market of engaged affiliates rather than having to drum them up and vet them yourself.

Here’s a link to the original article: http://www.webopius.com/content/249/integrating-webgains-affiliate-network-with-aspdotnetstorefront/

Do you have experience working with affiliates with your e-commerce platform? If so, please feel free to share your experiences, good and bad!