How to create an online store with Drupal

Document technical information

Format pdf
Size 1.7 MB
First found Jun 9, 2017

Document content analysis

Language
English
Type
not defined
Concepts
no text concepts found

Persons

Angela Byron
Angela Byron

wikipedia, lookup

Jeff Robbins
Jeff Robbins

wikipedia, lookup

Organizations

Places

Transcript

How to create an online
store with Drupal
Your purchase of this theme from TopNotchThemes
includes a licensed copy of the Online Store chapter
from the book Using Drupal.
This chapter will help you to set up your store using
the Ubercart module for Drupal.
Using Drupal
Angela Byron, Addison Berry, Nathan Haug, Jeff Eaton,
James Walker, and Jeff Robbins
Beijing • Cambridge • Farnham • Köln • Sebastopol • Taipei • Tokyo
Using Drupal
by Angela Byron, Addison Berry, Nathan Haug, Jeff Eaton, James Walker, and Jeff Robbins
Copyright © 2009 Angela Byron, Heather Berry, Nathan Haug, Jeff Eaton, James Walker, and Jeff Robbins. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions
are also available for most titles (http://safari.oreilly.com). For more information, contact our corporate/
institutional sales department: (800) 998-9938 or [email protected]
Editor: Julie Steele
Production Editor: Loranah Dimant
Copyeditor: Nancy Kotary
Proofreader: Sada Preisch
Indexer: Fred Brown
Cover Designer: Karen Montgomery
Interior Designer: David Futato
Illustrator: Robert Romano
Printing History:
December 2008:
First Edition.
Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of
O’Reilly Media, Inc. Using Drupal, the image of a dormouse, and related trade dress are trademarks of
O’Reilly Media, Inc.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a
trademark claim, the designations have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the publisher and authors assume
no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein.
TM
This book uses RepKover™, a durable and flexible lay-flat binding.
ISBN: 978-0-596-51580-5
[M]
1227635090
CHAPTER 10
Online Store
Many businesses both large and small would like to take better advantage of their web
presence by selling their products or services directly online. Setting up e-commerce,
however, can be a very daunting task. There are several options with varying complexity. Many hosting providers offer e-commerce or “shopping cart” packages that may
be either included with your web hosting plan or available for purchase. Other services,
such as PayPal, offer simple ways of including means for simple purchases using an
HTML form that submits to their processing system. There are other options still for
using dedicated e-commerce packages, both open source and proprietary, that you host
and configure. The biggest issue with all of these methods tends to be the lack of integration with the rest of the website—all shopping cart functions and checkout take
place within the other, external system.
The other complication with e-commerce implementations is that there is real money
involved for both you and your customers. Customers will be providing credit card
details and other sensitive information, so we need to be aware of security implications.
This chapter will introduce the following module:
Ubercart (http://drupal.org/project/ubercart)
Provides a full e-commerce package for running an online store
To follow along with the hands-on example in this chapter, install Drupal using the
Online Store install profile, which installs Drupal with a few sample users and basic
settings, as shown in Figure 10-1 and found at http://store.usingdrupal.com. For more
information on using the book’s sample code, see the Preface.
339
Figure 10-1. Sweet Tees’ completed website
Case Study
Sweet Tees is a local T-shirt store that sells wildly popular, custom-printed T-shirts.
They have a physical storefront, and the owners enjoy running a small store and love
their current location. However, they get frequent mail order requests for their shirts
and stickers, and would like to grow that end of the business. Taking orders on the
phone and tracking sales has proven to be inefficient and time-consuming for both
them and their customers.
In order to increase sales, we will equip the Sweet Tees website with an online store
that has integrated shopping cart functionality, where visitors to the site can add items
to their cart without the hassle of having to create an account first. A shopping cart
should be visible on all pages with a link to “check out” at any time. The store needs
to flow seamlessly with the existing website so that customers have a consistent experience. Sweet Tees would like to make the checkout process as simple as possible, so
we will also need to make sure we provide them with a single-page checkout, without
requiring customers to create a user account. Finally, they wish to accept credit cards
on their orders, so we will need to set up a payment gateway for this purpose.
Implementation Notes
Sweet Tees has several options to manage their online store; however, they really want
to provide a seamless, user-friendly experience for their customers. They are looking
for a solution that is simple and elegant, yet also comprehensive.
340 | Chapter 10: Online Store
For Drupal, there are two primary e-commerce solutions, both of which consist of
several modules, to implement the various features required.
The e-Commerce module (http://drupal.org/project/ecommerce) is the oldest and more
flexible of the options. The package is designed to be a highly modular framework for
building e-commerce solutions in Drupal. In a way, it is a development framework of
its own on top of Drupal’s existing framework. The principal benefit of the e-Commerce
package is ultimate control and extensibility. Because of the high number of variable
components in an online store (payment processor, shipping calculations, taxes, and
so on), this flexibility is incredibly useful. The downside, however, is that the flexibility
increases the level of complexity, thus making it more time-consuming to set up and
configure. Also, again due to its architecture, the checkout process for the e-Commerce
package takes several pages and requires that customers register accounts on the website. This violates two of the client’s primary requirements.
Ubercart (http://drupal.org/project/ubercart) is a much newer solution that was initially
intended to provide a much more simplified installation, configuration, and management process than e-Commerce. Although arguably less flexible than e-Commerce,
Ubercart is designed to accommodate 80–90% of online stores. Ubercart also has some
nice features that make it attractive for our implementation: a single-page checkout
process, anonymous user purchases, and a nice administration interface.
For Sweet Tees, we will be using Ubercart to bring the simple, elegant feel of their
physical storefront to the Internet.
The Ubercart project has its own website that is separate from
Drupal.org where you can find support forums, documentation, and
add-on modules. Check out http://www.ubercart.org.
Spotlight: Ubercart Packages
Ubercart is a complete package for running an online store. As such, it actually contains
more than 30 individual modules that implement each of the various features required
for running an online store. These modules range from basic framework modules such
as Payment or Cart to very specialized modules that implement specific features. Navigating the giant list of modules (which is more than Drupal core itself includes!) can
be confusing, so in this section we’ll look at each module and outline its purpose and
where it fits.
The modules that make up the Ubercart package are broken into five packages under
Administer→Site building→Modules (admin/build/modules). We’ll look at what the
modules in each package include in this section.
Spotlight: Ubercart Packages | 341
Ubercart—core
The Ubercart—core package represents the base framework components for our online
store. There are five modules in this section: Cart, Conditional Actions, Order, Product,
and Store. Each of these modules is required for running an online store. Following is
a brief description of each:
• Cart handles the shopping cart, pictured in Figure 10-2, with features such as
tracking which products a customer has selected and the quantity of each product
that has been ordered. The Cart module is also responsible for the “checkout”
procedure. In addition to the basic functionality, the Cart module also provides
options for extensibility in the shopping cart and checkout functions for other
modules.
Figure 10-2. Shopping cart provided by the Cart module
• Conditional Actions provides a mechanism for the rest of Ubercart to use for providing configurable, rules-based actions for things like taxes and shipping. This
module makes use of the core Actions system and is an advanced alternative to the
Trigger module in Drupal core, which was covered in Chapter 6.
• Order is responsible for recording, tracking, and managing individual orders to the
store. Figure 10-3 shows an order generated by the Order module. The Order
module provides features for manual, backend creation of orders (that is, those
taken over the phone), and invoicing, as well as an interface for viewing and editing
existing orders. Like the Cart module, Order also serves as a framework module
for the rest of the package by providing hooks for automated fulfillment and payment processing.
• Product serves as the base information for all items available in the store. It creates
a “product” node type that can be extended via “product classes” that we can
define. Figure 10-4 shows some of the properties supplied by Ubercart’s Product
module.
342 | Chapter 10: Online Store
Figure 10-3. An order view courtesy of Order module
Figure 10-4. Product information supplied by Product module
Spotlight: Ubercart Packages | 343
• Store governs the administration of the entire Ubercart package. It creates the basic
management interface at Administer→Store administration (admin/store), pictured in Figure 10-5, and also provides common helper functions such as unit
conversions and country-specific features.
Figure 10-5. Administration panel provided by the Store module
Ubercart—core (optional)
The Ubercart—core (optional) package of modules consists of several modules that
most, but not all, stores will require. There are also some interesting and oftenrequested features made available by the modules in this section.
• Attribute allows products to have slightly different variations so that customers
may select from a group of options rather than having entirely separate products
listed for minor variations. We’ll use the Attributes module later to allow customers
to choose a size when ordering our T-shirts.
• Catalog provides categorization of products via Drupal’s core taxonomy system by
creating a predefined “Product Categories” vocabulary. Catalog also provides some
additional features, such as associating an image with each category (as shown in
Figure 10-6) and providing some additional browsing options for products in the
catalog.
344 | Chapter 10: Online Store
Figure 10-6. The first page of a product catalog with a few categories
• File Downloads allows products to have associated downloadable files. Ideal for
selling software or digital media, the File Downloads module automatically sends
a customer an email with a link to a secure download. Customers can also download any purchased items again by logging into their account.
• Notify enables features for sending email notifications to customers upon checkout
or to notify of order updates.
• Payment is a framework-style module that enables and manages third-party payment processor integration with Ubercart. During checkout, it allows customers
to choose a payment method from a list of enabled Payment processors, as shown
in Figure 10-7. The Payment Module also includes a test gateway, which is very
useful for testing the checkout process (without the use of any specific third party).
The modules in the Ubercart—payment package all integrate with the Payment
module’s framework. Most provide integration with specific payment processors
such as 2Checkout, Authorize.net, CyberSource, and PayPal, with a few
exceptions:
— Test Gateway provides a simple, dummy payment-processing interface, which
is very useful for testing and when setting up the store to make sure that orders
and reports are all working properly. The test gateway does not make actual
charges to a credit card.
— Payment Method Pack adds the “Other” options for payment such as COD,
checks, or money orders. This module doesn’t actually collect any funds
directly.
— Recurring Payments does not collect any payments itself, but can add recurring
charges to specified products, thus enabling the creation of subscription-based
services for Ubercart stores.
— Credit Card is a base module that adds a “pay by credit card” method to the
checkout process and provides hooks for specific third-party integration modules to integrate with credit cart payments. By itself, the Credit Card module
does not actually generate a charge to a credit card.
Spotlight: Ubercart Packages | 345
Figure 10-7. A variety of payment methods in Ubercart
• Reports provides a reporting console for sales reports and general activity within
the store, as shown in Figure 10-8. This module also allows downloading the reports as a comma-separated values (CSV) file for importing into a spreadsheet
program or other reporting tool.
Figure 10-8. An example report generated with the Reports module
• Roles allows users who purchase certain configured products to be granted a
specified role—either indefinitely or for a specified duration. This module is great
for enabling membership features or other subscription-style services.
• Shipping, much like the Payment module, is an API or base module that provides
general management related to preparing purchased products for shipping. Modules listed in the Ubercart—fulfillment package all integrate with the Shipping and/
or the Shipping Quotes modules. Their purpose is to provide service-specific integration for calculating shipping costs, generating shipping labels, or creating
tracking numbers. The two primary services included with Ubercart are integration
346 | Chapter 10: Online Store
Figure 10-9. Shipping options for a product
with the U.S. Postal Service, via their XML web service, and integration with UPS,
via their similar service. There are also additional modules included to do both flatrate shipping costs (which can be defined per product) and weight-based quotes
that work similarly to flat rates, but using the weight of each product. Figure 10-9 illustrates some of the shipping options that Ubercart provides.
Additional shipping integration modules can be downloaded from
the Ubercart site under the “Contributions” section at http://www
.ubercart.org/contrib.
• Shipping Quotes also provides a basic means of generating quotes or estimates
around shipping costs. Other fulfillment modules, listed in the Ubercart fulfillment
section, can then provide their unique calculations based on the customer’s selected shipping method.
• Taxes enables an interface for creating tax rules specific to certain regions based
on product types.
Spotlight: Ubercart Packages | 347
Ubercart—extra
Although our site will not make use of most of the modules contained in the Ubercart
- extra section, there are some interesting options available. The distinction between
“extra” and “core (optional)” modules is a bit fuzzy, but in general the “core (optional)”
modules are things that directly affect the online shopping experience or provide
additional, extensible framework elements. The extra modules, on the other hand,
enable additional functionality:
• Cart Links allows administrators to construct URLs that will add certain quantities
of specified products (along with additional details). These links could then be
used on external sites—blogs, affiliate sites, or within other content on the store
site—to provide quick “buy now” links. Although there is no user interface for
generating the links, you can read more about the Cart Links module at Administer→Store administration→Help→Creating cart links (admin/store/help/
cart_links) when the module is enabled.
• Google Analytics for Ubercart acts as an integration point between Ubercart and
Google Analytics and can be used to track conversion rates and marketing campaigns versus sales. This module requires that the Google Analytics module be
installed (http://drupal.org/project/google_analytics).
• Importer is a very useful module for exchanging Ubercart data with external systems. Importer actually provides import and export of product information via an
XML format.
• Product Kit enables a feature for grouping products together to be sold as a single
unit. The kit can then have its own (discounted) price for the collection of products.
• Repeater provides the functionality to update product information on remote
Ubercart stores. This module is very useful if Ubercart is working in a multisite
setup, with related or dependent stores. The updates to product information are
sent using the same format as the Importer module.
• Stock provides tools for tracking and managing stock levels of items in the store.
Store administrators can set thresholds for products, below which they will be
notified via email to indicate low stock levels. The Stock module also integrates
with the Reports module to provide stock levels reporting.
Spotlight: Ubercart’s Administration Panel
Ubercart, due largely to its complexity and vast number of modules, has its own administration section, which is found at Administer→Store administration (admin/
store), as seen in Figure 10-10. All subsequent Ubercart features will be managed under
this new section.
The main panel shows a listing of all available actions to perform on the store, and
includes managing the product catalog, viewing and filling store orders, viewing reports
348 | Chapter 10: Online Store
Figure 10-10. The Ubercart administration panel
on store activity, and adjusting the configuration of any setting. Additional sublinks of
each section are hidden by default and expanded by clicking the “Show links” link.
Below the main panel is a list of status messages that may indicate problems or missing
configuration steps. It’s a good spot to check if things aren’t working correctly.
The Orders, Customers, and Products links each point to a section where you can
create, manage, and search existing records. This is where day-to-day store maintenance happens.
The Reports section allows you to answer questions about how well the store’s performing overall. What products are selling well? Are there plenty of products in stock,
Spotlight: Ubercart’s Administration Panel | 349
or is it time to order more? How is the store’s bottom line? All of these questions and
more can be answered with the tools available here.
The Configuration section contains oodles and oodles of settings for everything from
where users get redirected after they add something to their shopping cart, to what the
input form looks like for entering a shipping address and how many orders should be
displayed in the order overview form. If there’s a particular behavior of Ubercart you
really wish you could change, chances are good that you’ll find it here. Unlike most
Drupal administration sections, the “Store settings” section provides an outline that
lists all the currently set values grouped in sections. To edit any of the values, just click
on a section (which will highlight on mouseover), as seen in Figure 10-11.
Figure 10-11. The Ubercart settings pages display a summary of options, which take you to
appropriate edit forms when clicked
350 | Chapter 10: Online Store
And finally, the Help section takes you to a listing of Ubercart resources, as well as links
to help pages for specific modules in the Ubercart suite: it’s a great place to go if you
are stuck and want advice from other Ubercart users or experts.
Hands-On: Setting Up the Store
To begin setting up the online T-shirt store, we must first establish some basic information about the store that later features will be able to use. Let’s get started with the
essentials: the store information that will be used in invoices and to calculate shipping
costs.
Initial Setup Tasks
1. Log in to the Sweet Tees site as the admin user if you have not done so already.
2. Go to Administer→Site building→Modules (admin/build/modules) and enable the
following module:
• Ubercart—core package
— Store
3. Go to Administer→Store administration→Configuration→Store settings (admin/
store/settings/store).
4. Click on the “Name and contact information” section, which brings up the “Contact settings” form (admin/store/settings/store/edit). Complete this form as shown
in Table 10-1, and click the “Save configuration” button when done. When you
return to the “Store settings” Overview page, it should look as pictured in Figure 10-12.
Table 10-1. Contact settings
Setting
Value
Store name
Sweet Tees
Store owner
Stephen Sweet
E-mail address
[email protected]
Phone number
800-555-1234
Fax number
110-555-4321
Street address 1
123 Example St
Street address 2
City
Example City
Country
United States
Zone
California
Postal code
90210
Hands-On: Setting Up the Store | 351
Figure 10-12. Store name and contact information
Although Ubercart defaults to supporting North American conventions,
these are all fully configurable. The “Format settings” tab (admin/store/
settings/store/edit/format) allows us to configure the display of various
measurements such as currency, weight, length, and dates. And under
the Country settings form at Administer→Store administration→Country settings (admin/store/settings/countries), you can import additional
country data and set up country-specific address forms.
Spotlight: Products, Product Classes, and Attributes
Before we get to the next step—adding products to our store—it’s worth taking some
time to discuss how Ubercart treats products within the system.
Products in Ubercart are nodes, which means that you can do anything with products
that we’ve done with nodes in the rest of this book: you can add comments or ratings,
tag them, add CCK fields to hold additional properties, display products in listings with
352 | Chapter 10: Online Store
Views module, and so on. This seamless integration of store products with the rest of
the content that Drupal can manage is a “killer” feature of Ubercart.
Ubercart’s Product module defines a single “Product” node type, which comes prebuilt
with fields such as SKU and sale price, as pictured in Figure 10-13. These fields interact
directly with other parts of the system, such as sales reports and shipping calculations.
Figure 10-13. Product information supplied by the Product module
A single-product node type is sufficient if you are only selling one style of product in
your store, such as a club membership. Many online stores are more complex, however.
Amazon.com sells books, movies, and, as we saw in Chapter 4, kitchen utensils. Books
have properties like “author” and “ISBN number,” and movies might have properties
like “rating” and “movie studio.” Can you imagine how long the product node form
would be if it needed to provide a field for every single one of these properties for all
possible types of products? No thanks.
Luckily, the Ubercart developers have a solution to this predicament: special node types
called product classes. Product classes are slightly different than standard content types,
as they need to inherit the base product fields. However, once a product class is created,
Spotlight: Products, Product Classes, and Attributes | 353
it will then look and behave like a normal Drupal content type—there will be an entry
form for it under “Create content” (node/add), and we can edit fields and properties
via Administer→Content management→Content types (admin/content/types). Each
product class may be customized without affecting other products. You can create a
product class for “Book” and a product class for “Movie” and use CCK to give each its
own specific properties. We’ll make use of product classes later on for creating our
T-shirt and sticker products.
In order for Ubercart to recognize a node type as a product, it must be
either the “Product” node type supplied by Product module, or created
as a “product class” node type. Without this, the various product properties won’t appear to enter required fields such as SKU and sale price.
But what about products like T-shirts, which are fundamentally the same product type,
but for which there are multiple variations of the same product, such as different colors
and sizes? These variations, though important distinctions for order fulfillment and
sometimes price, aren’t really separate products, but rather different options for a single
product. It would surely be tedious to create one product for “Red, Small Drupal logo
T-shirt” and another for “Red, Large Drupal logo T-shirt” and yet another for “White,
Small, Drupal logo T-shirt,” and so on.
Ubercart refers to these sorts of minor variations as attributes, which are supplied by
the Attribute module. Each attribute, such as “Color,” is given a series of options, such
as “Red,” “Blue,” and “Plaid,” which a customer may select when adding the product
to his shopping cart. Attributes may be shared across different product classes (both
stickers and T-shirts might have a color), or specific to one type of product. You can
even set different pricing for different attribute options, as that Plaid T-shirt requires
hand-sewing from the local tailor. Figure 10-14 shows an example of a “Media format”
attribute, which might be applied to albums. CDs are physical entities, and therefore
have an associated cost and weight. MP3s, on the other hand, are digital and have
neither of these properties.
Figure 10-14. Example of an attribute with different options
354 | Chapter 10: Online Store
Hands-On: Creating Products
In this section, we will be setting up the product information for Sweet Tees, which is
the first piece required to put together our online store. Ubercart’s Product module
provides a Product content type for us on installation, and the FileField (http://drupal
.org/project/filefield),
ImageField
(http://drupal.org/project/imagefield),
and
ImageCache (http://drupal.org/project/imagecache) modules that we covered in Chapter 7 will allow us to display and collect images on products.
As Ubercart uses the ImageField and ImageCache modules for all product image handling, we can modify any of the default settings using the
techniques outlined in Chapter 7 to customize them for our purposes.
Initial Setup Tasks
Go to Administer→Site building→Modules (admin/build/modules) and enable the following modules:
• CCK package
— Content
— FileField
— ImageField
• Core package
— Path
• ImageCache package
— ImageAPI
— ImageAPI GD2
— ImageCache
— ImageCache UI
• Other package
— Token
• Ubercart—core package
— Product
• Ubercart—core (optional) package
— Attribute
— Catalog
After enabling these modules, we can see that our store administration section has
changed dramatically. Going to Administer→Store administration (admin/store) now
Hands-On: Creating Products | 355
shows messages in the “Status messages” list and two new sections, Products and Attributes, as seen in Figure 10-15.
Figure 10-15. Store administration panel, after enabling Product-related modules
Configuring Product Classes
When we enabled the modules in the previous step, Ubercart automatically added a
Product content type and associated it with an Image field so that we can attach pictures
to our products. However, Sweet Tees sells two kinds of products: T-shirts and stickers.
In order to accomplish this requirement, we’ll create two product classes, as shown in
Figure 10-16.
Figure 10-16. Product classes for T-shirts and stickers
356 | Chapter 10: Online Store
1. Go to Administer→Store administration→Products→Manage classes (admin/store/
products/classes).
2. You will be presented with a form to add a class. Create the first class, for T-shirts,
according to Table 10-2 and click “Submit.”
Table 10-2. Adding a “T-shirt” class
Setting
Value
Class ID
T-shirt
Class name
T-shirt
Description
Our award-winning T-shirts
3. Now add a second product class for stickers as shown in Table 10-3.
Table 10-3. Adding a “sticker” class
Setting
Value
Class ID
sticker
Class name
Sticker
Description
A sticker with a witty phrase
Configuring Product Attributes
For the Sweet Tees online store, customers need to be able to select the T-shirt size that
they wish to order, as well as the colors of their shirts and stickers. To implement this,
we will make use of Ubercart’s product attributes feature. Figure 10-17 shows an example of the Size attribute.
Figure 10-17. The Size attribute and its options
Hands-On: Creating Products | 357
1. Go to Administer→Store administration→Attributes (admin/store/attributes) and
click on the “Add an attribute” tab (admin/store/attributes/add).
2. On this page, we can create attributes and options for our products. Initially, we
need to provide a bit of information about the attribute. Enter the values according
to Table 10-4.
Table 10-4. Settings for the Size attribute
Field
Value
Name
Size
Help text
Pick a T-shirt size
Make this attribute required
Checked
Display type
Select box
3. Clicking Submit takes us back to the Attributes Overview tab (admin/store/attributes). Click the “options” link in the Operations column of the Size row.
4. This gives us the options overview page, which will list all options available for this
attribute. Click the “Add an option” tab (admin/store/attributes/1/options/add).
5. This form allows us to add an option for the Size attribute. Complete this form for
each of our sizes using the values in Table 10-5. Note that you can also offer Cost,
Price, and Weight adjustments for each option. For our purposes, we will assume
that all T-shirt sizes cost and weigh the same.
Table 10-5. Options for the Size attribute
Name
Order
S
0
M
1
L
2
XL
3
6. Let’s also create a color attribute for both T-shirts and stickers. Return to Administer→Store administration→Attributes (admin/store/attributes) and click on the
“Add an attribute” tab (admin/store/attributes/add). Enter the values in Table 10-6.
Table 10-6. Settings for the Color attribute
Field
Value
Name
Color
Help text
Select a color
Make this attribute required
Checked
Display type
Select box
358 | Chapter 10: Online Store
7. Back at the overview screen, click “options” in the Color row, choose “Add an
option,” and enter the values in Table 10-7.
Table 10-7. Options for the Color attribute
Name
Order
White
–1
Dark blue
0
Light blue
0
Plaid
0
8. We now need to associate our new attributes with our product classes. Return to
Administer→Store administration→Products→Manage classes (admin/store/products/classes) and click the “edit” operation in the T-shirt row (admin/store/
products/classes/T-shirt/edit).
9. Click on the Attributes tab (admin/store/products/classes/T-shirt/attributes) and
click on the “add attributes to this class” link in the help text (admin/store/
products/classes/T-shirt/attributes/add).
10. In the Attributes select list, select both Size and Color, and click “Add attributes.”
11. Click the Options tab (admin/store/products/classes/T-shirt/options).
12. Select all four colors and all four sizes by checking the checkbox next to each. Pick
White as the default color, and M as the default size. Your configuration screen
should look as pictured in Figure 10-18. Click Submit when finished.
13. Stickers, on the other hand, don’t have a size, and come only in white and light
blue. Head back to Administer→Store administration→Products→Manage classes
(admin/store/products/classes) and click the “edit” operation in the sticker row
(admin/store/products/classes/sticker/edit).
14. Click on the Attributes tab (admin/store/products/classes/T-shirt/attributes) and
click on the “add attributes to this class” link in the help text (admin/store/products/classes/T-shirt/attributes/add). In the Attributes select list, select Color, and
click “Add attributes.”
15. Click the Options tab (admin/store/products/classes/T-shirt/options) and make
sure both White and Light blue are checked. Make White the default color, and
click Submit.
Hands-On: Creating Products | 359
Figure 10-18. T-shirt attribute options
Configuring Product Settings
Before we move on to the catalog area, let’s configure some basic product settings:
1. Go to Administer→Store administration→Configuration→Product settings (admin/
store/settings/products) and click on the “Product settings” section.
2. This page lets us configure some default settings for products, such as the number
of products to show on listing pages and how “Add to cart” links are handled. The
defaults will work here, except we’d like to check the “Display an optional quantity
field in the Add to Cart form checkbox.” Click “Save configuration.”
3. Click on the “Product fields” tab (admin/store/settings/products/edit/fields).
Here, we have a selection of optional fields we can expose on all of our products.
These fields are common to all products in our online store. In addition to the
defaults, click the checkbox next to Weight and click “Save configuration.”
Because Ubercart products are a Drupal content type, we can add additional fields via CCK the same way we do with any other type, by
visiting Administer→Content management→Content types (admin/
content/types) and clicking “manage fields” for Product. The product
fields used by Ubercart are common fields used by all products.
Configuring the Catalog
The Catalog module that we enabled will allow category-based browsing of our products, as pictured in Figure 10-19. The entire catalog system is built on Drupal’s core
360 | Chapter 10: Online Store
taxonomy system; therefore, adding and manipulating the hierarchy of the catalog is
done via the standard taxonomy interface. However, Ubercart adds several additional
nice features for browsing and listing products in the categories for us.
Figure 10-19. The Sweet Tees product catalog
Before beginning this section, double-check that the “Catalog” vocabulary has been properly created by checking on the status messages at
Administer→Store administration (admin/store). If all goes well, there
should be a status message claiming “Vocabulary Catalog has been
identified as the Ubercart catalog.” This means that the catalog vocabulary has been created successfully. If you do not receive this message,
create a new vocabulary by hand, and head to Administer→Store
administration→Configuration→Catalog settings (admin/store/settings/catalog) to mark it for use by the Catalog.
1. Let’s start by adding some categories for our catalog. Go to Administer→Content
management→Taxonomy (admin/content/taxonomy).
2. Click “add terms” for the Catalog vocabulary and add the product categories listed
below. Use the term Advanced options “Parents” and “Weight” settings to place
them in the following hierarchy:
• Stickers
• T-shirts
— Men’s
— Women’s
— Kids’
Hands-On: Creating Products | 361
3. Go to Administer→Store administration→Configuration→Catalog settings (admin/
store/settings/catalog).
4. Click on the “Catalog” section (admin/store/settings/catalog/edit/catalog) to open
the edit form. Note that you can select any taxonomy vocabulary to serve as the
Catalog vocabulary (if you have an existing vocabulary that you would like to use).
5. We will leave the default settings here for the most part. Change the settings as
indicated in Table 10-8 and click “Save configuration.”
Table 10-8. Catalog display settings
Field
Value
Catalog products list
Product nodes per page
12
Catalog block settings
Always expand categories in the catalog block
Checked
6. Click the Grid tab (admin/store/settings/catalog/edit/grid).
7. Here, we can have our catalog pages laid out in a grid rather than a standard table
listing view. Complete this form according to Table 10-9 and click “Save
configuration.”
Table 10-9. Catalog grid settings
Setting
Value
Display products in grid
Checked
Display product model (SKU)
Unchecked
Display product add to cart
Unchecked
8. Let’s add some products to our catalog! Go to Create Content→T-shirt (node/add/
T-shirt) and complete the form as per Table 10-10, and click the Save button to
create the product. There are T-shirt images provided for you in the book’s source
code in the assets/ch10-store folder, or you can use some of your own! When finished, your product upload will look similar to Figure 10-20.
Table 10-10. Create T-shirt form
Field
Value
Name
Druplicon
Catalog
Men’s, Women’s
SKU
T-shirt001
Sell price
14.99
Weight
2 Pounds
Description
Drupal’s logo
362 | Chapter 10: Online Store
Field
Value
Image
[Upload a T-shirt image]
If an image field doesn’t show up for you here, check back at the
status messages on the main Ubercart administration page at
Administer→Store administration (admin/store) and follow the instructions next to Images. You may have forgotten to enable a few
of the required modules earlier.
Figure 10-20. A sample T-shirt product
9. Add a few more products to fill out the catalog a little. Note that each product can
have per-product Attributes, Options, or Adjustments. You can adjust these by
clicking on the node’s Edit tab and then using the tabs that show under the View
and Edit tabs. For instance, if we have a T-shirt that is unavailable in certain sizes,
we can click the Options tab and uncheck the sizes that are not available.
10. Now, let’s view the results of what we’ve made. Enable the catalog block by visiting
Administer→Site building→Blocks (admin/build/block) and dragging the Catalog
block to the top of the left sidebar region. When the block is in place, click “Save
blocks.” We can now look through the product catalog by clicking on the links in
the Catalog block in the sidebar.
11. Finally, let’s set up the permissions for the items we’ve configured so far. Go to
Administer→User management→Permissions (admin/user/permissions), enter the
settings in Table 10-11, and click “Save permissions.”
Hands-On: Creating Products | 363
Table 10-11. Permissions for the event content type
Permission
anonymous user
authenticated user
editor
site administrator
uc_catalog module
administer catalog
view catalog
Checked
Checked
Checked
uc_product module
administer product classes
Checked
administer products
Checked
create products
Checked
edit all products
Checked
uc_store module
administer store
Checked
view customers
Checked
Checked
view store reports
Checked
Checked
Spotlight: The Ordering Process
We now have an online store that can be populated with the entire Sweet Tees inventory. However, at the moment customers can only browse the catalog and see information about the products. Most e-commerce sites are concerned with actually selling
something, and that means getting into the ordering process.
Figure 10-21 depicts the typical workflow for a store such as our client’s. It begins when
a customer adds products to her online shopping cart and clicks the “Checkout” button. The customer is presented with a form in which to fill out basic customer information, such as billing and shipping address, credit card information, and preferred
shipping method. The customer then has a chance to review the order, including its
total price, with taxes and shipping calculated based on the information provided earlier. Once the order is submitted, a payment gateway validates the entered billing information to determine if the credit card is legitimate. If all goes well, the order is placed
and the store fulfills its end of the bargain by packing the products up and shipping
them where they need to go.
Although this is typical for a “traditional” e-commerce store, many types of stores have
very different needs. Ubercart’s module suite allows for many flexible ways to configure
a customized ordering process. Want to sell downloadable products, which have no
need to be shipped anywhere? No problem. Turn on the Downloads module, and turn
off the Shipping module. Need to calculate complex international tax rules? The Conditional Actions module combined with the Taxes module will do what you need. Does
an order in your system take lots of steps on its way to being completed, such as “Pending various red-tape paperwork” or “Needs invoice”? The Orders module has the ability
364 | Chapter 10: Online Store
Figure 10-21. Ubercart’s typical ordering process
to define custom workflow states for your orders, so you always know the current state
of open orders in the system.
Although there are far too many configuration options to get into all of them in detail
here, we’ll discuss some of the settings pages that impact ordering, found underneath
Administer→Store administration→Configuration (admin/store/settings):
Cart settings
Various shopping behaviors, such as where customers are directed after adding
products, and what information shows up on the shopping cart page
Order settings
Settings for how invoices appear, an order’s workflow states, and the display of
order information in the administration panel
Spotlight: The Ordering Process | 365
Checkout settings
Field visibility on the checkout page and the text of various system messages
Payment settings
Payment tracking options, types of payments to accept, and payment gateway
configuration
Shipping quote settings
Default pickup address and shipping methods
Tax rates and settings
Creation of specific tax rate rules
Often, the default settings are fine, but it pays to familiarize yourself with some of the
options found here in case your store’s needs ever change.
Hands-On: Processing Orders
The remaining element of our site is actually implementing the e-commerce portions:
an online shopping cart and the ability to process orders, as well as reporting tools to
tell us how our store is doing. We will now complete our store configuration.
To complete this section, we must first enable one final set of modules. Go to Administer→Site building→Modules (admin/build/modules) and enable the following:
• Ubercart—core package
— Cart
— Conditional Actions
— Order
• Ubercart—core (optional) package
— Payment
— Reports
— Shipping
— Shipping Quotes
— Taxes
• Ubercart—fulfillment package
— Flatrate
• Ubercart—payment package
— Credit Card
— Payment Method Pack
— Test Gateway
366 | Chapter 10: Online Store
Figure 10-22. Ubercart’s shopping cart, along with a sidebar block
Because the precise instructions for implementing payment systems vary
widely between various services (Paypal, Authorize.net, and so on), in
this chapter, we’ll be setting up credit cards only with a test gateway.
On a “real” e-commerce site, you’ll want to use an actual payment gateway that can accept and process credit card transactions for you. Ubercart’s website contains a list of its supported payment systems, along
with documentation on how to set them up: http://www.ubercart.org/
payment.
Shopping Cart
In this section, we will configure the site’s shopping cart, as pictured in Figure 10-22.
Once we get the cart set up, we will be able to browse to an individual T-shirt page,
select options such as color and quantity, and add the customized products to our cart.
The vast majority of our work for this section is completed by simply enabling the Cart
module. The cart settings come with very workable defaults, but there are a couple
settings we want to change:
1. Go to Administer→Store administration→Configuration→Cart settings (admin/
store/settings/cart) and click the “Cart settings” section (admin/store/settings/
cart/edit).
2. The default setting for the “Continue shopping link URL” is to return the user to
the site’s front page. We should change this to be the full catalog. Enter “catalog”
and click “Save configuration.”
Hands-On: Processing Orders | 367
3. We can also create a Shopping Cart block so that shoppers have ready access to
their cart from any page on the site. Go to Administer→Site building→Blocks
(admin/build/block).
4. Drag the Shopping Cart block to the top of the left sidebar region and click “Save
blocks.”
We now have our shopping cart ready to go. That was easy! Next, we’ll talk about what
happens when someone clicks the Checkout button.
Taxes
Before we can open up our store to the public, we need to ensure that all applicable
sales taxes are being applied to our items. As Sweet Tees is based in California, we will
need to charge sales tax on all products sold.
This example is for illustrative purposes only: determine what types of
taxes you need to charge to sell products in your own store. The Conditional Actions module, part of Ubercart core, allows setting all sorts
of complex tax rules to calculate different rates depending on whether
purchasers are from the same state or a different state, for different
product types, or for international orders.
1. Go to Administer→Store administration→Configuration→Tax rates and settings
(admin/store/settings/taxes) and click the “Make a new tax rule” link (admin/
store/settings/taxes/edit).
2. Complete the “Edit tax rule” form using the values from Table 10-12.
Table 10-12. Edit tax rule form
Field
Value
Name
Sales tax
Rate
7.25%
Taxed product types
T-shirt, Sticker
3. Click Submit to save the sales tax settings.
Shipping
Because we are selling physical goods, or “shippable items,” in our store, we need to
account for the costs involved to ship our products. For simplicity, we will use a flat
rate to provide a single set of shipping costs, assuming no base shipping cost and a
default shipping rate of $5.99 for all T-shirts.
368 | Chapter 10: Online Store
1. Go to Administer→Store administration→Configuration→Shipping quote settings
(admin/store/settings/quotes) and click on the “Quote methods” section (store/
settings/quotes/methods).
2. Click on the “Flat rate” tab (admin/store/settings/quotes/methods/flatrate) and
click the “Add a new flat rate shipping method” link.
3. Complete the form using the values from Table 10-13.
Table 10-13. Flat rate method settings
Field
Value
Shipping method title
Default shipping
Line item label
Shipping
Base price
0.00
Default product shipping rate
5.99
Payment
We can now configure the final piece for our site: payments. There are a lot of options
for how to accept payment via Ubercart. We will be taking checks or money orders as
well as processing credit cards (via the test gateway).
1. Go to Administer→Store administration→Configuration→Payment settings
(admin/store/settings/payment) and click on the “Payment methods” section (admin/store/settings/payment/edit/methods).
2. In the Payment methods table, ensure that “Check” and “Credit card” are checked,
and that the default gateway is set to “Test Gateway.” Click “Save configuration.”
3. You should see an error at the top that says “Credit card encryption must be configured to accept credit card payments.” Let’s fix that.
There are several security implications involved in accepting credit
card payments online. You should always use a proper, valid SSL
certificate for accepting the information and, when possible, avoid
storing the card numbers in Ubercart. For more information about
secure credit card handling with Ubercart, please see the online
documentation:
http://www.ubercart.org/docs/user/2731/credit
_card_settings#security.
4. Create a directory in the filesystem called keys, which will be used to encrypt credit
card data, in a place that is not web accessible. For example, if your main website
page points to /home/username/www, create the directory at /home/username/keys.
5. Temporarily make the directory writable, for example with the command chmod a
+w /home/username/keys.
6. Expand the “Credit card settings” fieldset, and in “Card number encryption key
filepath,” enter the path to the keys file; for example, /home/username/keys.
Hands-On: Processing Orders | 369
7. In the “Checkout workflow” section, ensure that “Attempt to process credit card
payments at checkout” is checked.
8. Also expand the “Check settings” fieldset, and enter some address information for
the store.
9. Click “Save configuration.”
10. On the file system, reset the directory’s permissions to prevent write access, for
example with the command chmod a-w /home/username/keys.
Placing a Test Order
We are now ready to make our first test order! Here’s how:
1. Browse the catalog to find our “Example T-shirt” product. We must select a Color
and a Size and then click “Add to cart.” We will then be redirected to the cart view.
Note that the “Shopping cart” block on the left instantly reflects the number of
items (1) and total amount of our current selection.
2. From the shopping cart view, we could choose to “Continue shopping,” which will
redirect us back to the catalog overview, or we can make changes to our cart by
removing items or updating the quantity of any product (by making changes and
clicking “Update cart”). However, we would like to see the order process in action,
so let’s click Checkout.
3. We are now on the Ubercart checkout screen. The top portion of the page, shown
in Figure 10-23, displays the contents of our shopping cart for confirmation followed by a customer information section, which—as we are currently logged in—
will display our email address.
Figure 10-23. The order summary and delivery details of the Ubercart checkout screen
370 | Chapter 10: Online Store
4. Complete the delivery information and billing information sections with your
information.
5. Continue down to the payment method. By default, “Check or money order” is
selected as the payment method, with the address we provided earlier. Click on
the “Credit card” option and the section dynamically updates to include a credit
card entry form, as shown in Figure 10-24.
Figure 10-24. The shipping and payment section of the checkout screen
Hands-On: Processing Orders | 371
Figure 10-25. The review order screen, where customers can make final adjustments
6. As we are using the Test gateway, we don’t need to enter a valid credit card number
to complete the order. We do, however, need to enter credit card information in a
valid format. The Credit Card module will check to ensure that there are the proper
number of digits in the card number and that the expiration date is still valid.
Complete this section with the settings in Table 10-14.
Table 10-14. Credit card form
Field
Value
Card Number
4111111111111111 (that’s 15 1s)
Expiration Date
July 2017
CVV
123
7. Upon clicking the “Review order” button, we are presented with a final confirmation screen, pictured in Figure 10-25, to review all the entered information. If there
are errors, click the Back button and you will return to the checkout screen, where
you can make corrections. Clicking “Submit order” will complete the transaction,
send the email confirmation, and create the order record for store administrators.
8. When finished, the customer is presented with a thank-you page, with a link to
view the current order status from the Orders section of his user profile.
372 | Chapter 10: Online Store
Fulfilling an Order
Our test order has been successfully placed. Let’s now turn our attention to what happens afterward: the order shipping and order fulfillment process, and viewing reports
of the overall health of the store.
1. Go to Administer→Store administration→Orders (admin/store/orders) to view a
list of all of the orders in the system. Our order shows “Payment received,” because
our test gateway payment went through properly. Click the View icon to display
the order, which should look something like Figure 10-26. From here, you can do
things such as print and mail invoices, view a log of changes to the order, and view
payment details.
Figure 10-26. Viewing an order in the order system
2. You can also ship products from here, which is what we’ll do next. Click the Packages tab and click the “Create packages” link to arrive at the screen depicted in
Figure 10-27.
Hands-On: Processing Orders | 373
Figure 10-27. Organizing product shipments into packages
3. Check the T-shirt and click “Create one package.” This screen also allows you to
do things like ship two products together and another one separately.
4. Next, click the Shipments tab, and the “Make a new shipment” link. Check off the
package, choose “Ship manually” as the shipment type, and click “Ship packages.”
5. A form will appear where additional details may be entered, such as tracking number, ship date, and delivery date. Simply click “Save shipment” to accept the
defaults.
6. Finally, we should edit our order to reflect that it is now complete, and the order
has successfully shipped. Click the View tab to return to the order view.
7. At the bottom of the order is a drop-down for order status. Change its setting to
Completed, and click Update.
8. Now that we’ve completed our first order, it’s as good a time as any to look at some
of the system reports that Ubercart provides. Go to Administer→Store administration→Reports (admin/store/reports). Click on “Sales reports” to view a summary
of the store’s performance, as seen in Figure 10-28. Feel free to explore some of the
other reports under this section as well.
374 | Chapter 10: Online Store
Figure 10-28. Sales reports show overall health of the store
Access Control
Finally, let’s configure the permissions for the new modules that we enabled in this
section. Go to Administrator→User management→Permissions (admin/user/permissions), set them as indicated in Table 10-15, and click “Save permissions.” Most of
these are similar to what we’ve already seen or their function can be guessed by the
name, but a few deserve special attention, as it’s not immediately clear what they entail:
• Under uc_credit module, there are two credit card-related permissions: “view cc
details” and “view cc numbers.” “view cc details” allows a user to see what type of
card was used and how much it was charged, so we’ll give that to the editor role.
However, a credit card number is very sensitive information. Although Ubercart
will normally store only the last four digits of a credit card, it’s better to be safe
than sorry. We’ll give these permissions only to site administrators.
• Under the uc_order module section, there are two similarly named permissions:
“delete orders” and “delete any orders.” The difference is that users with “delete
any orders” permissions can even remove already-completed orders in the system,
and bypass any additional checks that might otherwise prevent an order from being
removed. As a result, we give this permission only to the site administrator role.
Hands-On: Processing Orders | 375
Table 10-15. Permissions for Ubercart order processing modules
Permission
anonymous user
authenticated user
editor
site administrator
ca module
administer conditional actions
Checked
uc_credit module
administer credit cards
Checked
process credit cards
Checked
Checked
view cc details
Checked
Checked
view cc numbers
Checked
uc_order module
administer order workflow
create orders
Checked
Checked
delete any order
Checked
Checked
delete orders
Checked
Checked
edit orders
Checked
Checked
view all orders
Checked
Checked
uc_payment module
delete payments
Checked
manual payments
Checked
Checked
view payments
Checked
Checked
uc_quote module
configure quotes
Checked
uc_reports module
view reports
Checked
Checked
Checked
Checked
Checked
Checked
uc_shipping module
fulfill orders
uc_store module
view store reports
uc_taxes module
configure taxes
Checked
Taking It Further
In this chapter, we have covered the basics of setting up an online storefront and shopping cart using the Ubercart package for Drupal. However, there are several additional
modules that you will likely want to consider before taking your online store live:
376 | Chapter 10: Online Store
Secure Pages (http://drupal.org/project/securepages)
When collecting sensitive, personal information online—particularly credit card
information—it is highly recommended that you do it via a secure, SSL connection.
The Secure Pages module allows you to specify certain Drupal paths that should
be visited only via HTTPS. The recommended paths to protect are user/* and
cart/*.
PayPal (included with Ubercart)
Although the PayPal module is not required, you will likely want to use some payment gateway for processing payments (recall that we used the Test Gateway in
this chapter). PayPal’s merchant services are easy to set up and well supported by
Ubercart.
Stock (included with Ubercart)
Particularly when selling something like T-shirts, it is a good idea to keep track of
the current available stock level to avoid selling someone a product that is not
available. The stock module (found in Ubercart—extra) updates a given stock level
for each product every time a purchase is made. When new stock arrives, simply
add the new quantity to the current level. Also included with the module is a
threshold setting which, when reached, will trigger an email notification that inventory is getting low.
Summary
In this chapter, we were able to set up a complete online store for our customer, Sweet
Tees. Although there are a lot of modules, configuration screens, and chances to override the features in Ubercart, the sane default options and helpers for common tasks
such as setting up ImageCache presets make Ubercart fairly easy to get running.
Here are the modules we referenced in this chapter:
•
•
•
•
•
•
•
•
•
CCK: http://drupal.org/project/cck
e-Commerce: http://drupal.org/project/ecommerce
FileField: http://drupal.org/project/filefield
Google Analytics: http://drupal.org/project/google_analytics
ImageAPI: http://drupal.org/project/imageapi
ImageCache: http://drupal.org/project/imagecache
ImageField: http://drupal.org/project/imagefield
Token: http://drupal.org/project/token
Ubercart: http://drupal.org/project/ubercart
Summary | 377
Here are the additional resources that we referenced in this chapter:
• Ubercart official site: http://www.ubercart.org
• Ubercart contributions: http://www.ubercart.org/contrib
• Ubercart credit card security: http://www.ubercart.org/docs/user/2731/credit_card
_settings#security
• Ubercart payment systems: http://www.ubercart.org/payment
378 | Chapter 10: Online Store

Similar documents

×

Report this document