Nothing particularly wrong with the idea but it is generated as a series of <a> tags without css id or class names. As a result, it offers limited capability for styling to match your store and more importantly, if you have many pages, the standard ASPDotNetStorefront control can get quite wide because all pages available are shown.

An improved, styled ASPDotNetStorefront paging control

Webopius have developed a new paging control that will be familiar to users of sites such as FlickR, it looks like this:

I hope you agree, it looks better? More importantly, it only shows the first page, the last page and a maximum of two available pages either side of the current page. If your store’s category has a lot of product results, the control never gets too large. Also, the control is rendered as an unordered list <ul> with the class name ‘paginator’. The current page is identified with the class name ‘thispage’.

The result is a much more elegant paging control that can easily be styled with CSS to suit your store.

A direct replacement for the existing ASPDotNetStorefront paging control

Our new paging control can be inserted as a direct replacement for the existing ASPDotNetStorefront page control by replacing the existing line in your XSL templates:

<xsl:value-of select="aspdnsf:PagingControl($BaseURL, $CurrentPage, /root/Products2/Product/pages)" disable-output-escaping="yes" />

With this:

<xsl:value-of select="Webopius:CustPagingControl($BaseURL, $CurrentPage, /root/Products2/Product/pages, 12, $TotalProducts)" disable-output-escaping="yes" />

No source code required

This new control has been implemented as a stand-alone library and just needs copying into your store with a one line change to the web.config file. You do not need the ASPDotNetStorefront source code to implement this control on your site.

If you would like a copy of this paging control installed into your store to improve your ASPDotNetStorefront site’s visitor experience, please contact us. We can usually have it installed and tested within an hour.

Other ASPDotNetStorefront Enhancements available

You might also be interested in other enhancements we have available for your ASPDotNetStorefront store, including:

• iPhone and mobile versions of ASPDotNetStorefront templates for your store
• Sort ASPDotNetStorefront product results by price and name
• For multi-language sites, sort product results based on the language the user is viewing the site in
• Overlay product images with icons such as ‘Sale’, ‘Top seller’, ‘Rare!’ - you choose the icon, you set a flag on the product and the icons are automatically generated
• Featured product, random product or latest product shown at the top of your category results
• Featured product carousel on your ASPDotNetStorefront site home page
• Custom styling of the shopping cart without requiring the source code
• Multi-language product import module
• Bulk image resizing system for ASPDotNetStorefront - scans all your large images and automatically creates icon and medium images
• Custom product fields and custom product to product relationships

…and the list goes on. We have worked with ASPDotNetStorefront for many years and believe we provide one of the best ASPDotNetStorefront development and support services for your business. Why not try Webopius?

Writing a new ASPDotNetStorefront payment gateway

In developing this new gateway, we spent a lot of time working in the payment processing system used in ASPDNSF and took advantage of the excellent, modular way in which you can easily extend the available number of payment methods. We thought it would be useful to share the method used.

If you are developing a new gateway, you will need to have purchased the ASPDotNetStorefront source code because it involves modifying the ASPDNSFGateways.dll library and making changes to the Checkout Payment pages.

The payment gateway process in ASPDotNetStorefront

An overview of the Consorzio Triveneto gateway process within ASPDNSF is shown to the right.

It works in a slightly different way to a gateway like Worldpay, in that before you are taken to the Triveneto Payment screen, you need to send the gateway the payment details and you receive back the URL for making payment. The final step is also different in that you have to pass back a URL to Triveneto informing it which page to send the customer to (Error or Order Confirmation).

In addition to making changes to the gateway library and checkout payment pages, we created three new aspx pages specific to the Triveneto Gateway: trivenetoprocess, trivenetoerror and trivenetosuccess.

The basic approach in writing the gateway was:

Step 1 - Tell the ASPDotNetStorefront configuration wizard about your new gateway

The first step in creating a new gateway is to give it a unique identifier and update the ASPDotNetStorefront admin system’s configuration wizard so that it offers the new gateway as a configuration choice.

In our example, we used the identifier ‘TRIVENETO’ for our new gateway and edited the admin directory file wizard.aspx with a new line:

<asp:ListItem Value="TRIVENETO">Consorzio Triveneto</asp:ListItem>

Step 2 - Update the ASPDotNetStorefront Gateway library

Next, we modified the ASPSNDSF Gateway library to recognize ‘TRIVENETO’ as a valid gateway and added code in to receive information during a Make Payment request. If the order is successful, the gateway simply returns and the customer is sent to the order confirmation page. If unsuccessful, the gateway creates a record in the failed transactions table with the technical details of the failure and the customer is taken to the error page before returning to the shopping cart.

Step 3 - Update the Checkout payment page

The next stage is to update the checkout payment page so that it can send a payment request to the hosted payment page. This is a case of creating a form containing the payment elements (currency, language, amount, tracking id etc).

You will need to edit the source of checkoutpayment.aspx.cs and create a new if statement for your gateway. In our case, we created an ‘if {GW== Gateway.ro_GWTRIVENTO} …’ section.

Triveneto requires URLs to be passed for both error and standard response conditions. We created new AppConfig values for these and also added support for both Test and Live payment processing.

In our model, the checkout payment form sends the payment information to the new page called ‘trivenetoprocess.aspx’.

Step 4 - Capture the payment

trivenetoprocess.aspx takes the payment information received from checkoutpayment.aspx and creates a URL format specific to the Consorzio Triveneto gateway specification. This URL is then sent to the Live/Test payment URL which returns a unique Payment ID and Payment URL, or an Error message.

The Customer is then sent to the Payment URL to enter their credit card details.

Step 5 - Handle errors

If the Customer enters incorrect card details, Triveneto returns them to the error URL on your site, in our case, this is trivenetoerror.aspx. Trivenetoerror.aspx parses the error information and presents a description of the error to the Customer. The Customer then clicks on a link to be taken back to the shopping cart.

Step 6 - Handle payment processing

With correct card details, Triveneto will process the payment and return the Customer to the trivenetosuccess.aspx page. Despite the filename, the transaction may still have been rejected (such as due to an authorisation issue). This page checks the state of the payment and if successful, creates a new order record within ASPDotNetStorefront.

New payment gateways for ASPDotNetStorefront

If you would like to discuss development and installation of new or existing payment gateways for ASPDotNetStorefront, please contact us. Webopius have extensive experience in developing for ASPDotNetStorefront and always spend time understanding your business and requirements.

Related Links…
OpenCart Open Source shopping

This tutorial will show you how to extend OpenCart and retrieve a random product from your product catalogue to display on the homepage. Each time a user refreshes the page, or a new visitor goes to your site, a different product will be shown.

First, a big thank you to the author of article on Gregg Website Development who showed a method for quickly retrieving random rows from MySQL on large datasets with minimal performance impact.

Step 1. Extend your product model with a getRandomProduct() function

The OpenCart MVC model shows it’s power here as we add a new function to the product model. Edit the ‘product.php’ file located in your site’s /catalog/model/catalog/product directory and add a new function called getRandomProduct() to the class as follows:

// Retrieve a random product from the database
public function getRandomProduct() {
   $maxminid = $this->db->query("SELECT MAX(product_id) as max_id, MIN(product_id) as min_id from ". DB_PREFIX . "product p");
   $maxrow = -1;
   $minrow = -1;
   if ($maxminid->num_rows) {
        $maxrow = $maxminid->row['max_id'];
        $minrow = $maxminid->row['min_id'];
    }
   $randomrow = mt_rand($minrow, $maxrow);

   $query = $this->db->query("SELECT DISTINCT *, pd.name AS name, pd.short_description as short_description, p.image, m.name AS manufacturer, ss.name AS stock FROM " . DB_PREFIX . "product p LEFT JOIN " . DB_PREFIX . "product_description pd ON (p.product_id = pd.product_id) LEFT JOIN " . DB_PREFIX . "manufacturer m ON (p.manufacturer_id = m.manufacturer_id) LEFT JOIN " . DB_PREFIX . "stock_status ss ON (p.stock_status_id = ss.stock_status_id) WHERE p.product_id >= '" . (int)$randomrow . "' AND pd.language_id = '" . (int)$this->language->getId() . "' AND ss.language_id = '" . (int)$this->language->getId() . "' AND p.date_available <= NOW() AND p.status = '1' order by p.product_id ASC limit 1");

    if (!$query->row) {
        $query = $this->db->query("SELECT DISTINCT *, pd.name AS name, pd.short_description as short_description, p.image, m.name AS manufacturer, ss.name AS stock FROM " . DB_PREFIX . "product p LEFT JOIN " . DB_PREFIX . "product_description pd ON (p.product_id = pd.product_id) LEFT JOIN " . DB_PREFIX . "manufacturer m ON (p.manufacturer_id = m.manufacturer_id) LEFT JOIN " . DB_PREFIX . "stock_status ss ON (p.stock_status_id = ss.stock_status_id) WHERE p.product_id < '" . (int)$randomrow . "' AND pd.language_id = '" . (int)$this->language->getId() . "' AND ss.language_id = '" . (int)$this->language->getId() . "' AND p.date_available <= NOW() AND p.status = '1' order by p.product_id DESC limit 1");
    }
    return $query->row;
}

What this function does is find the maximum and minimum product ids in your database and generates a random value in this range.

It then looks for a product row with an ID >= the random ID. If none is found, it selects an ID less than the random ID. The product row is returned.

Step 2. Change your homepage controller to ask for a random product

Now, you can change any of your OpenCart controller pages to retrieve a random product. In this example, we will use the homepage controller. Find the file ‘home.php’ in your site’s /catalog/controller/common directory.

Insert the following lines into the code:

$featured = $this->model_catalog_product->getRandomProduct();
$this->data['featuredproduct'] = array(
    'name' => $featured['name'],
    'thumb'   => image_resize($featured['image'], 165, 165),
    'href' => $this->model_tool_seo_url->rewrite($this->url->http('product/product&product_id=' . $featured['product_id']))
);

This example just uses the product’s name, image thumb and URL but you can use any other available product fields returned by the SQL you created earlier. This code will create an array called $featuredproduct[] containing a single random product that can be used on your home page.

Step 3. Add the featured product to your home page

The last step involves rendering the featured product on your home page. How and where you place the product will depend very much on your site’s template and styles. The example below just shows how to display the results - you will probably want to wrap the code with css for styling.

Edit the home.tpl file with your site’s /catalog/view/theme/[your theme]/template/common directory and insert the following lines at the point you want the featured product displayed:

<b>Featured Product...</b>
<?php echo '<a class="image" href="' . $featuredproduct['href'] .'" title="' . $featuredproduct['name'] . '"><img src="'.$featuredproduct['thumb'].'" alt="' . $featuredproduct['name'].'"/></a>'; ?>
<?php echo '<b><a href="' . $featuredproduct['href'] .'" title="' . $featuredproduct['name'] . '">'. $featuredproduct['name'].'</a></b>'; ?>

This code uses the $featuredproduct[] variable that you just created in the controller code and places a featured product thumbnail image, link and description on the home page.

More OpenCart features

This is just one example of how OpenCart can easily be extended. We have also implemented full SEO friendly URLs, news pages, product image watermarks and an updated product export/import system.

If you would like to discuss implementing an e-commerce solution based on OpenCart, please get in touch.

Related Links…
OpenCart Open Source shopping

OpenCart has almost every feature that you need to build an e-commerce solution quickly. More importantly, it can be extended easily and has a strong online community. We’ve recently made a simple enhancement to one of the stores we developed (the Orchid Store) to overlay product images with a watermark like this:

It’s a really simple change and I thought it would be useful to others if I posted how to do it. Please note, this solution is a ‘quick implementation’ and can be enhanced further.

Step 1. Create your watermark overlay image

The first step is to create a small image that will become the watermark overlaying your product images. I would recommend using a transparent PNG format. In the example above, the background of the watermark is transparent and the text is set to 50% opacity.

Save this image as ‘watermark.png’ in your site’s /images/userfiles directory.

Step 2. Create some new OpenCart image functions

The next step is to create a couple of new watermark functions within the OpenCart system area. Open the /system/library/image.php file. You will see that there is already a watermark() function available.

In this example, we are going to create a new watermark function as it makes handling any upgrades of OpenCart slightly easier and you are adding to rather than changing any existing functionality. You may prefer to edit the existing watermark() function directly.

The new function looks like this:

public function addwatermark($position = 'bottomright') {
        $watermark = imagecreatefrompng(DIR_IMAGE . 'userfiles/watermark.png');
        $watermark_width = imagesx($watermark);
        $watermark_height = imagesy($watermark);

        switch($position) {
            case 'topleft':
                $watermark_pos_x = 0;
                $watermark_pos_y = 0;
                break;
            case 'topright':
                $watermark_pos_x = $this->info['width'] - $watermark_width;
                $watermark_pos_y = 0;
                break;
            case 'bottomleft':
                $watermark_pos_x = 0;
                $watermark_pos_y = $this->info['height'] - $watermark_height;
                break;
            case 'bottomright':
                $watermark_pos_x = $this->info['width'] - $watermark_width;
                $watermark_pos_y = $this->info['height'] - $watermark_height;
                break;
           case 'middle':
                $watermark_pos_x = ($this->info['width'] - $watermark_width)/2;
                $watermark_pos_y = ($this->info['height'] - $watermark_height)/2;
                break;
        }

        imagecopy($this->image, $watermark, $watermark_pos_x, $watermark_pos_y, 0, 0, $watermark_width, $watermark_height);
        imagedestroy($watermark);
     }

What the function above is doing is creating an image object from your watermark (use imagecreatefromgif() if you have chosen a gif format) and then placing this watermark over the image (supplied in $this) in a position you specify (topleft, topright, bottomleft, bottomright or middle).

Now, edit /system/helper/image.php and add the following code as an additional function:

function image_watermark($filename) {
	if ( (!file_exists(DIR_IMAGE . $filename)) && (!file_exists(DIR_IMAGE . 'cache/' . $filename)) ) {
		return;
	} 

	if (file_exists(DIR_IMAGE . 'cache/' . $filename)) {
		$old_image = DIR_IMAGE . 'cache/' . $filename;
	} else {
		$old_image = DIR_IMAGE . $filename;
	}

	$new_image = 'cache/' . substr($filename, 0, strrpos($filename, '.')) . '-w.jpg';

	if (!file_exists(DIR_IMAGE . $new_image) || (filemtime($old_image) > filemtime(DIR_IMAGE . $new_image))) {
		$image = new Image($old_image);
		$image->addwatermark('middle');
		$image->save(DIR_IMAGE . $new_image);
	}

	if (isset($_SERVER['HTTPS']) && (($_SERVER['HTTPS'] == 'on') || ($_SERVER['HTTPS'] == '1'))) {
		return HTTPS_IMAGE . $new_image;
	} else {
		return HTTP_IMAGE . $new_image;
	}
}

What the above code is doing is being given a product image filename ($filename). It then checks in both the standard image directory and the cache directory for that product image. This is slightly non standard from the usual OpenCart which only looks in the main image directory. We added the second cache check because we will call this watermark function after the product image has been re-sized and placed in the cache directory.

What the code then does is create a new ‘watermarked’ filename for the image by appending a ‘-w.jpg’ to the existing filename. It then checks the cache to see if a watermark has already been created. If not, it calls the addwatermark() function we just created. The resulting watermarked image filename is then returned.

Step 3. Modify your OpenCart product template to show the watermark

The watermark function can of course be used in any templates and image fields you choose. In this example, we are using the ‘popup’ product image field. Locate the product.php file in your sites /catalog/controller/product directory. Look for a line similar to this in the code:

$this->data['popup']  = image_resize($image, $this->config->get('config_image_popup_width'), $this->config->get('config_image_popup_height'));	

…and change it to this:

$productimage = image_resize($image, $this->config->get('config_image_popup_width'),$this->config->get('config_image_popup_height'));
$wmimage = image_watermark(basename($productimage));
$this->data['popup'] = $wmimage;

This adds an additional step to the process. After resizing the image, the $productimage file will be placed in the cache. Image_watermark() is then called to overlay the product image with your watermark.

Hopefully, if you’ve followed these steps your site will now be showing product images with watermarks added. As I mentioned at the start, this solution can be extended and improved further and it would be good to hear feedback from others.

The OpenCart image library also contains a number of other hidden features including rotation and cropping. We have also extended the OpenCart image helpers further with dynamic image scaling. If anyone is interested in this, please get in touch.

Because Interprise and the ecommerce module are 32-bit applications and this was an install on the 64-bit Windows platform, things didn’t always go smoothly and I thought some tips might help others who are trying to do the same…

Install IIS7 with ASP.NET role services

Step 1 of the install is to use the Windows Server Manager and add a role of ‘Web Server’. This will install IIS7 and during the install you should be asked which Role Services you want to install with IIS7.

Make sure you choose ‘ASP.NET’ at this stage because we found that installing it later can cause problems or conflicts with Windows Process Activation (WPA). If you do get into difficulties, we found that an un-install of the WPA before trying to re-install IIS7 makes life a lot easier.

Along with ASP.NET roles, we also chose:

- Static Content
- Default Document
- HTTP errors
- HTTP redirection
- ISAPI extensions
- ISAPI filters
- HTTP logging
- Request monitor
- Tracing
- Basic authentication
- Windows authentication
- Request filtering
- Static content compression
- IIS Management console

Create a 32-bit application pool

Before you add your ecommerce module website to IIS7, create a new application pool capable of running 32-bit applications.

Basic settings: .NET Framework v2.x.xxxxx
Advanced settings:
Enable 32-bit applications: TRUE
Managed pipeline mode: Classic

Leave all other settings at their defaults

Make sure your Interprise Suite ecommerce site using the new Application Pool

Once you create your website configuration from within the IIS manager, make sure it is using the application pool you created. In your site’s ‘Basic Settings’, set the Application Pool to the correct pool.

Resolve web.config conflicts

IIS7 uses a new method of managing the web.config application settings based on a hierarchy. You may find once you’ve installed Interprise and ASPDotNetStorefront IS that some of your new web.config settings conflict with the default IIS7 settings.

To check this, from within your web site’s configuration in IIS manager, double click on the various configuration icons - for example ‘.NET compilation’. IIS will inform you of any errors as you click through the icons.

Unfortunately, to resolve this, it’s a case of editing your web.config (or the default web.config) and removing conflicts.

Stuck?

If all this sound too much, why not get in touch with Webopius. We can help you get your site installed and running. We also provide ongoing operational support such as hosting, remote backups, site enhancements and other Interprise/ASPDotNetStorefront development services….

They were using a customised version of the product import system to load products into the store database - the import customisation allowed them to import product descriptions in multiple languages which is not part of the standard ASPDotNetStorefront import routine.

They were also using the ImageFileNameOverride feature to allow the image names to match a specific attribute of the product (the ISBN number in this case).

This was all fine - they name the images to match the products, place the images in the /images/products/large folder and then perform the product import with the correct value in the ImageFileNameOverride column.

No automatic creation of Icon and Medium sizes

One challenge with the product import routine is that it doesn’t automatically create all image sizes for you - normally you need a thumbnail image (icon) for products on the category page, a medium sized image when viewing the product page and a large image when you want the user to see more detail.

Automatic image re-sizing is only performed in ASPDotNetStorefront when you manually create/edit a product and upload an image. Of course, when you have thousands of images to load, this is not something you want to do.

An automatic image resizing solution

So, to solve this, we wrote a module that can be called from within the ASPDotNetStorefront admin system that scans through all large images and looks for a matching icon and medium image.

If no image match is found, it automatically creates and icon and/or medium image for you based on the ASPDotNetStorefront application config settings for image resizing.

This saves a huge amount of time for the user and also allows them to re-run the re-sizing routine whenever they upload new images.

ASPDotNetStorefront Development Services

If you would like a this image resizing routine installed on your ASPDotNetStorefront site, or would like to discuss other ASPDotNetStorefront requirements, then please contact us.

For more information on ASPDotNetStorefront development services offered by Webopius, please click here.

The card was not accepted. Please try again

Picture the scenario, your store is receiving thousands of visits and a percentage a these are reaching the goal of adding items to their shopping cart and are moving through the ASPDotNetStorefront checkout process. The Customer enters the correct billing address and credit card number but incorrectly enters their card’s ‘valid until’ date into the start date field.

They confirm the order and because of the problem, ASPDotNetStorefront rejects the order and takes them straight back to the credit card payment form with the message:

The card was not accepted. Please try again

At this point, without any explanation, your Customer may think your store is faulty or that their bank declined the payment. This is the point they may choose to give up and leave your ASPDotNetStorefront site without proceeding with payment.

An improved status message for failed Sage Pay/Protx transactions

There is a good explanation as to why the ‘real’ status message isn’t shown. Often these messages also contain additional technical information that you wouldn’t want your customer to see and some of the messages can be a bit harsh.

However, wouldn’t it be nice if the Customer was at least told that the reason their details were not accepted was because “the start date of the card is in the future. The card is not yet valid”. At least that prompts them that they may have mis-typed the details and prompt them to retry.

Webopius have developed a Web Control that can be embedded within the ASPDotNetStorefront ‘Checkoutpayment.aspx’ page. It sits within the .aspx page and doesn’t make or require any changes to be made to the ASPDotNetStorefront source code.

At the point that a failed transaction error is shown to your Customer, this web control looks in the Failed Transaction table for this Customer and retrieves that Sage Pay/Protx status code. It then performs a lookup to turn this code into a meaningful and readable description of the reason the Customer’s credit card had problems.

If you would like a this control installed into your ASPDotNetStorefront site, we can install for you usually in less than an hour (including testing). Although not tried with other gateways, it should also be possible to modify the control to work with other ASPDotNetStorefront credit card payment gateways - we can look at each on a case by case basis.

ASPDotNetStorefront development and support services

Webopius provide a comprehensive range of ASPDotNetStorefront development and support services. From small fixes, to site deployments and custom ASPDotNetStorefront theming - all at very competitive prices with no charge until the work has been completed.

Please Contact us for more information. For a description of the range of ASPDotNetStorefront services offered, please click here

ASPDotNetStorefront provides a basic method of affiliate tracking and reporting but does not provide commission calculations or affiliate payments. For this reason, many retail sites choose a third party affiliate network and integrate it with ASPDNSF.

Affiliate Window

More recently, a client asked if we could integrate the Affiliate Window affiliate network (see link on right) with ASPDotNetStorefront. Given the previous work with Webgains, this proved to be a straightforward process split into three tasks:

1. Add tracking code to all main site pages
2. Add order confirmation tracking code to the order confirmation page
3. Develop a product feed to send Affiliate Window

Add tracking code to main site pages

To enable Affiliate Window to track clicked links to your site, you need to insert tracking code into your page source code just before the closing </body>.

We developed a simple ASPDotNetStorefront XMLPackage and then from within our skin templates, added a call with one line like this:
(!XmlPackage Name=”affiliatewindow.xml.config”!)

Add order confirmation tracking

If you read our Webgains article, this describes in outline how to develop tracking within the order confirmation page. Affiliate Window order confirmation tracking is done in almost the same way by modifying page.orderconfirmation.xml.

The tracking code enables Affiliate Window to track sales made within your ASPDotNetStorefront site and for the appropriate sales commission to be calculated.

Develop a product feed

Finally, you will need a method to tell the Affiliate Window network partners which products are available on your ASPDNSF store. The best way to do this is to copy one of the existing product feeds such as the ASPDotNetStorefront Google Base feed and to modify it to the format required by Affiliate Window.

Do you require Affiliate Window integration into ASPDotNetStorefront?

If you would like Affiliate Window integrated into your ASPDNSF site, then please contact us.

Are you using ASPDotNetStorefront, or are you thinking of using it for your website? Webopius provide a comprehensive range of ASPDotNetStorefront development services. From small fixes, to site deployments and custom ASPDotNetStorefront theming - all at very competitive prices with no charge until the work has been completed.

Please Contact us for more information. For a description of the range of ASPDotNetStorefront services offered, please click here

The most popular uses are feeds for Amazon, Affiliate Programmes and Google Base. Google Base allows you to upload your products and pricing into Google to make them available within the Google product search system. It’s Google Base that we are covering today as Google have changed their product feed specification and users of ASPDotNetStorefront may find that when they send their feed, Google is reporting that none of their products are loading.

Note for ASPDotNetStorefront version 8 users

If you have ASPDNSF version 8.x, the recommended route to solving the Google Base issue is to contact the ASPDotNetStorefront support team. They have a patch available for v8 versions and the latest release of ASPDotNetStorefront should come shipped with the updated Google Base feed included.

v7 users should also contact the ASPDotNetStorefront support team but if they are unable to provide a Google Base patch, you can follow the simple instructions below to fix your Google Base feed

Updating the ASPDotNetStorefront Google Base feed

Making your existing ASPDotNetStorefront Google Base feed compliant with the latest Google feed specification is actually really simple as long as you are only selling only new or only used products throughout your store and a one line change is required as follows:

1. Edit the file ‘feed.googlebase.xml.config’ in your Admin/XmlPackages directory (Note: for security, you may have previously changed the directory ‘Admin’ to another name)
2. Before the line ‘</item>‘, add this:

<g:condition>new</g:condition>

If you only sell used products, replace ‘new’ with ‘used’.
3. Save the file

Set your file encoding

Sometimes after importing, Google Base may complain about character encoding within the feed. If this happens in your case, it might be worth forcing Google Base to use UTF-8 encoding rather than trying to detect automatically.

To do this, log into your Google Merchant account and click on ‘data feeds’ in the left menu. Find your feed and click on the word ‘edit’ next to the feed name. Change encoding from auto detect to UTF-8.

More Google Base and ASPDotNetStorefront tips

After writing this article, we discovered some more useful information and resources that you might find useful…

Validating your Google Base feed

If you want to do more detailed diagnostics on your Google Base feed without the trouble of submitting to Google directly. There is an excellent online validator here:

http://celebird.googlepages.com/ckbase.htm

Simply generate your feed with auto-ftp set to ‘no’. This will create the feed file in the images directory of your site. Now submit the full feel URL (http://youriste.com/images/yourfeedname.xml) to the above validation site and within about 5 minutes you’ll receive an email back with a very detailed set of diagnostics.

Error “Invalid attribute name: description”

After you’ve submitted your feed to Google Base, you may see Google reporting that some of your products are rejected because of Invalid attribute name: description. Unfortunately, Google doesn’t tell you a great deal more than this and unlike other error types doesn’t show you the products affected.

When we had this error, it was due to a couple of issues. The first was html being included within the product/variant descriptions. The second was related but was caused by a single <br> existing within variant descriptions - even though the ASPDNSF Admin pages showed a blank variant description. Because the Google Base feed looks for a variant description before a product description, this <br> was being used instead of the product description and Google was rejecting it.

A Fix

In our case, we fixed this issue by changing these lines within the feed.googlebase.xml.config:


<xsl:param name="ProductDescr" select="aspdnsf:GetMLValue(description)"></xsl:param>
<xsl:param name="VariantDescr" select="aspdnsf:GetMLValue(VariantDescr)"></xsl:param>


To this:


<xsl:param name="ProductDescr" select="aspdnsf:StripHtml(aspdnsf:GetMLValue(description,$WebConfigLocaleSetting,'FALSE'))"></xsl:param>
<xsl:param name="VariantDescr" select="aspdnsf:StripHtml(aspdnsf:GetMLValue(VariantDescr,$WebConfigLocaleSetting,'FALSE'))"></xsl:param>


This uses the full version of the ASPDotNetStorefront function ‘GetMLValue’ to return the descriptions without HTML Encoding, then the StripHtml() function removes all html tags.

ASPDotNetStorefront Development Services

Are you using ASPDotNetStorefront, or are you thinking of using it for your website? Webopius provide a comprehensive range of ASPDotNetStorefront development services. From small fixes, to site deployments and custom ASPDotNetStorefront theming - all at very competitive prices.

Please Contact us for more information. For a description of ASPDotNetStorefront services offered, please click here.

More recently, we’ve been very impressed with ExpressionEngine as an alternative Content Management System. A friend introduced us to ExpressionEngine and a couple of months ago we downloaded a copy to evaluate.

Like other CMS systems, Expression Engine cleanly separates the templates and content (weblogs) which is dynamically loaded from the database. Unlike many CMS systems, the template design and tagging system is very easy to understand. You can also intermingle php and the tags to create very powerful content relationships within web pages.

One of the other aspects that appealed to us were the minimal updates once sites are deployed. With other CMS platforms, the system is always nagging us about a security patch or module update that is required. This requires downloading new modules, testing them on development boxes, fixing bugs (and looking up issues with clashes between different modules) before the changes can be deployed to a live site. For a company like us, this takes up valuable time and increases the risk of downtime on client sites. With Expression Engine there seem to be far less frequent security and general updates applied - overall it seems a pretty solid system.

The only initial criticism is that there doesn’t appear to be a central repository or directory of plugins, modules and extensions available which usually means spending yet more time in Google looking for a solution or writing your own. While I’m thinking, why have plugin, extension and modules. Just extensions would be fine and less confusing as I can’t see a great deal of difference, certainly between “module” and “extension”!

Currently, we will be using Expression Engine on the new Luzmon.com (www.luzmon.com) owned by Louise Mohn (www.louisemohn.com). As soon as it’s deployed, I’ll write here with our experiences.