Catch up on stories from the past week (and beyond) at the Slashdot story archive


Forgot your password?

Selling Online with Drupal e-Commerce 68

Michael J. Ross writes "Many Web developers wish to create e-commerce sites that also support collaborative editing of content, community forums, and other features that can increase traffic to the sites. But most shopping cart products do not include those capabilities, or, if such third-party add-ons exist, they may be quite limited in functionality. Similarly, most if not all content management systems (CMSs) lack native e-commerce capabilities. Yet that barrier is being overcome, because a handful of e-commerce modules have been created for the most popular CMSs. Perhaps the most promising pairing, at this time, is Drupal and the e-Commerce module — a combination covered in the book Selling Online with Drupal e-Commerce by Michael Peacock." Keep reading for the rest of Michael's review.
Selling Online with Drupal e-Commerce
author Michael Peacock
pages 264
publisher Packt Publishing
rating 7/10
reviewer Michael J. Ross
ISBN 1847194060
summary A thorough guide to the Drupal e-Commerce
This title was published by Packt Publishing on 31 March 2008, under the ISBNs 1847194060 and 978-1847194060, and is a recent addition to their growing lineup of books focusing on Drupal and Joomla. The firm hosts the book's Web page, where readers can download the sample code, submit feedback, post a question about the book, read an online excerpt, and download a sample chapter (number 8) on "Creating a Better Selling Experience," as a PDF file. In addition, readers can purchase the handy e-book version, which contains everything found in the print version.

The first chapter serves as an introduction to Drupal and the e-Commerce module, and also explains how to download the two of them, as well as the additional module (Token) upon which the latter depends. The author explains the purpose of each area within Drupal's "Site configuration" section, and what changes the reader should make, if any. Also, he provides the background story for the sample e-commerce Web site that is built throughout the book — in this case, a dinosaur model shop. It should be noted that the diagram on page 6 does an effective job of explaining the basic idea of how a CMS works (better than the similar figures seen in other CMS books), and it is followed by an explanation of what e-commerce is. However, it is doubtful that any developer who purchased this book would need to be told what are CMSs and e-commerce.

In the second chapter, the author briefly reviews the steps for adding content and navigation to a Drupal-powered site, by adding pages and menus, respectively. Also, some additional modules are enabled, for creating a contact form and a blog, for the sample site. Up to this point in the book, readers will have become accustomed to the author explicitly guiding them through the steps necessary for creating the sample site. Thus it may come as a surprise to such readers when they see the second figure on page 40, showing the navigation menu, including new sections for dinosaurs and the museum, and a link to a contact page. The two new sections were briefly mentioned three pages earlier, but the steps for creating them were not; the steps for adding the contact page link were apparently not mentioned anywhere. However, any experienced Drupal developer should have no difficulty figuring out how to add these navigation menu items.

With the third chapter, the book shifts focus from Drupal basics to implementing an e-commerce site. Aspects of running an online business — such as site accessibility laws, legal issues, and privacy laws — are mentioned, though readers outside of the United Kingdom will most likely not be pleased by the UK-centricity of the material. Other topics covered include product types, groupings, details, photos, and advertising, as well as customer service.

In Chapter 4, readers learn about the e-Commerce product types and their corresponding modules, and how to add products to the store catalog — including specialized types of products, such as apparel, services, and bundled products ("parcels"). Chapter 5 briefly covers users, rules, permissions, settings, rules, registration, e-mail messages to users, users' pictures, taxonomy, requiring registration, customer management, user orders, contacting users, and adding your business's staff to your site. It also touches upon taxonomy and how to use it for controlling user access to content. But the author fails to explain why this is needed for the online store. Providing such a rationale up front is especially important when asking readers to work their way through potentially daunting subjects such as taxonomy, and implementing them in their own test sites, if they are following what the author is doing.

The sixth chapter begins with an unneeded review of the themes built into Drupal version 5.x, with even more space taken up describing three red-based color schemes. This is followed by a discussion of how to modify whichever of those themes is enabled, and, very briefly, how to create a new theme. In this chapter and many others, the author frequently reminds us that the hypothetical client, Doug of Doug's Dinos, is "really pleased" with the "great looking site." Readers can judge for themselves just how great is the site's design. Admittedly, in a book such as this that does not focus on Web design, a sample site can be quite basic. But the constant praise is unwarranted.

Allowing customer checkout and payment are critical to any e-commerce site, and those topics are explored in Chapter 7. The topic coverage is fairly complete, though occasionally the author does not make clear where in the Drupal administration section the reader will find the particular topic under discussion, e.g., the global anonymous purchase policy. Chapter 8 offers a lot of valuable information, including how to: add shopping cart and search elements to every page, automatically create user accounts, add images to product listings, offer discounts based on customer role, provide coupons, allow bulk purchasing, set up auction and donation products, and automatically adjust charge prices based on various conditions.

Chapter 9 delves into the particulars of calculating taxes and shipping costs, as well as accepting payments through various gateways, including PayPal, which is explored in detail. The only part that will be misleading to readers, is the claim that PayPal's IPN "pings" your server for each customer transaction. Actually, their server does not ping yours, but instead posts transaction data that you can use for updating your online database.

Chapter 10 presents a number of modules and techniques for making an e-commerce site more secure, and also covers domain name, Web hosting, and site maintenance issues. The security modules discussed are definitely worth considering. Some readers may be confused by the Backups section of cPanel mentioned by the author, since not all cPanel installations offer it.

The last two chapters of the book address invoicing, CRM, and marketing one's site. The discussions of search engine optimization, viral marketing, newsletters, etc., are quite cursory, and readers interested in those topics would fare better by consulting books, online articles, and other resources that are much more thorough. The chapter's topic that will probably be of most value to e-commerce developers, is the demonstration of how to significantly customize the layout of invoices, using CSS. The book's sole appendix explains how to install WampServer.

All the chapters conclude with brief summaries, which, without exception, are a waste of space — especially considering the brevity of most of the chapters. The old oratory principle of "tell them what you're going to tell them; tell them; tell them what you told them" may be terrific for speeches, but not for books. That is primarily because someone in an audience listening to a live speech does not have the luxury of looking into the past to hear a portion of the speech again, nor of looking into the future to anticipate what the speaker will say next. Readers of books, on the other hand, can of course jump backward and forward quickly to review or preview material, as needed.

The quality of the book's writing is noticeably weak, with countless awkward phrases and run-on sentences. Some are downright puzzling, e.g., "Thanks for your custom!" (page 125); did the author mean "order?" Throughout the book, one finds a remarkable underuse of commas, frequent mixing up of "that" and "which," misplacement of commas and parentheses, misuse of commas in place of semicolons and even periods (e.g., page 124), semicolons in place of colons, and missing hyphens from adjective phrases. Most noticeable — and at times laughable — is the excessive use of exclamation marks, reflecting a common misconception that they jazz up otherwise dull material. For example, page 49 contains three completely unnecessary exclamation marks, not counting the two contained within a customer testimonial. In addition, the book contains several errata, such as: "loose" (should read "lose"; pages 8 and 195), "leads customers" (should read "leads to customers"; page 57), "products" (should read "product's"; page 62), "customers' role" (should read "customers' roles"; page 88), "to mentioned" (should read "to mention"; page 131), "its does" (page 159), "If a more" (should read "If more"; page 202), "businesses" (should read "business's"; page 221), and many more.

An additional blemish of the book, albeit minor, is that there is little consistency in how the author describes to the reader the navigation steps for going to a particular area of Drupal administration. Sometimes he presents a breadcrumb-style menu path, starting with the highest level menu item. (The majority of readers would probably find this to be the most logical format.) On other occasions, he reverses the order and describes it narratively. Least useful is his listing of the URL, such as "http://localhost/drupal-5.7/admin/users/roles," which may not even match the Drupal root URL that the reader has set up in their development environment.

Despite the aforementioned problems, Selling Online with Drupal e-Commerce is a welcome addition to the growing list of more specialized Drupal titles, and is currently the premier resource for anyone who wishes to use Drupal and the e-Commerce module for creating a virtual store.

Michael J. Ross is a Web developer, writer, and freelance editor.

You can purchase Selling Online with Drupal e-Commerce from Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.
This discussion has been archived. No new comments can be posted.

Selling Online with Drupal e-Commerce

Comments Filter:
  • by telbij ( 465356 ) on Monday July 21, 2008 @10:28PM (#24283631)

    Drupal is my favorite open source CMS. Despite legitimate critiques it is an amazingly engineered piece of software; the customizability is unparalleled for a such a capable out-of-the-box package. Drupal makes many projects possible which would otherwise not be possible at all. Unfortunately Drupal is no panacea because all of this costs in terms of complexity.

    This is why you use drupal. No one should be building websites, ecommerce or not, from scratch anymore.

    No, this is why you use a framework. A good framework enables best practices with minimal overhead. Even a framework may be overkill because there are tons of websites that are extremely simple in nature, and maybe only need a dab of PHP here or there to add the necessary dynamic elements.

    You use Drupal when you need a ton of boiler-plate functionality, and no budget to build from scratch using a framework. If you do have a reasonable budget you better think hard for several reasons:

    • Drupal starts you off with huge overhead. You will be running tons of code you aren't using from the get-go. You're basically starting off with quite a low ceiling.
    • You will be sacrificing design for ease of development. As customizable as Drupal is, there are still very simple user interface concepts that just don't mesh well with the huge engine powering everything. In these cases you are faced with the uncomfortable position of knowingly creating an inferior UI not because of some inherit complexity in the problem, but because Drupal has painted you into a corner.
    • Drupal makes it hard to optimize your database usage. Sure there are work-arounds, but consider the fact that many developers these days are trying to ditch relational databases in general because there are fundamentally hard to scale. It's still a common opinion despite the fact that the relational model is about as perfect a mix of flexibility and performance as you can get, backed by a theoretical basis that applies to all data in all domains. People are willing to throw out a huge amount of flexibility in terms of ad-hoc querying and data integrity because for many applications managing the data via hastily written application code is much easier than scaling an RDBMS. Drupal itself imposes many constraints that makes the relational model even harder to scale, and fundamentally ties your site to those assumptions so you'd better hope caching will give you the performance you need.
    • Drupal requires an expert to really make it sing. Without being intimately familiar with it, many things that Drupal was designed to do easily will be time consuming, even for a skilled PHP developer. With web frameworks, the issues you have to deal with are basically well known even across languages and platforms. The solutions may be different, but they are easy to learn if you understand the web because they all solve the same fundamental problems. Drupal on the other hand introduces a ton of concepts to allow for rapid and flexible development, but are not intuitive in and of themselves for a web programmer.

    SQL injection, XSS, etc are reason enough. Thats why Sony BMG, AOL, MTV, etc are starting to roll out web platforms based on drupal. Using the Ecommerce package in drupal will insure security, and for the most part, usability.

    First of all SQL injection is trivial to prevent. XSS is a little trickier, but is pretty manageable without a lot of mental overhead for the sufficiently paranoid developer. Of course things get trickier with XSRF and such. But look at the reality, if a security vulnerability is discovered in Drupal, pretty soon the bots are going to be out in force, and you'll be forced to upgrade. But what if your modules aren't compatible or you have other difficult to migrate upgrades? With a local XSS exploit at least someone has to write a custom script to attack you. Bottom line is you choose your poison.

    Since 2005 I have been wo

"Hey Ivan, check your six." -- Sidewinder missile jacket patch, showing a Sidewinder driving up the tail of a Russian Su-27