ATG Product Catalog overview

The product catalog is a collection of repository items (categories, products, media, etc.) that provides the organizational framework for your commerce site. ATG Commerce includes a standard catalog implementation, based on the ATG SQL Repository, that you can use or extend as necessary.

You can create and edit all of your repository items through the ATG Control Center, which also allows you to create page templates to display these items.

Custom Catalogs. You can display different versions of your product catalog for different viewers. For example, if a corporate customer only wants its employees to order certain items from your store, you can confine them to viewing and ordering only those products.

Configurable Commerce Items. This feature allows you to sell items with variable components, such as a computer that can be purchased with different hard drive capacities.

ACC-Workflows : ATG

Workflows are graphical tools that are designed to help you manage the online automation of many types of business process or activity. Like scenarios, workflows track the progress of a subject through a specific process. In the case of scenarios, the subject is a site visitor, and the process is a series of events that define some form of activity on or related to your Web site. Workflows use a similar concept, except the subject is an entity such as a customer support case or a sales inquiry, and the process is a series of events that define the lifecycle of that entity. For example, you could design a workflow in which the subject is an online expense report and the stages of its lifecycle (the elements in the workflow) are submission, approval, and reimbursement.

The following illustration shows a workflow for an expense report. (Note that the illustration is broken into two parts, but the workflow itself contains no break.)

This workflow contains two tasks: Submission and Approval. The Submission task is completed by an employee, and the Approval task is completed by a manager. If the manager approves the expense report, the Reimburse Employee custom action is triggered; this action reads relevant information, such as the employee’s identity and the amount to reimburse, from the expense report repository, and it initiates the payment. The report’s status property in the repository is then set to “Reimbursed.” If the manager rejects the expense report, the report’s status is set to “Rejected,” and the workflow reverts to the Submission task, allowing the employee to revise his or her expenses.

You design the workflow in the ATG Control Center, and a page developer sets up any relevant site pages; including any forms necessary for completion of the different stages of the workflow. In the example of the expense report, the page developer could create a site page accessible by employees that includes an online version of a report and also contains a Submit button; and a page accessible by managers that includes a list of pending expense reports as well as Approve and Reject buttons.

The key differences between workflows and scenarios can be summarized as follows:

·                     The subjects that progress through scenarios are site visitors; the subjects that progress through workflows represent other entities such as documents. (The subjects of scenarios are user profiles, but the subjects of workflows can be any repository item.)

·                     Scenarios are used to track and respond to Web site activities such as page visit or login events. Workflows are used to track business activities that are completed either fully or partially through a Web site.

·                     Scenarios are frequently used on extranets and commercial Web sites; workflows are frequently used on intranets or other Web sites that support a community of users.

·                     The subjects progressing through a scenario have no direct interaction with it (participation in a scenario is completely transparent to the site visitor). Site users can, however, interact directly with a workflow.

·                     Scenarios and workflows are derived from the same base package of code (atg.process), but they use different subclasses of this code, and the sets of elements available for building scenarios and workflows in the ATG Control Center are different.

Important: You can create workflows only if your application developers have created custom workflow elements for your organization. You cannot create a workflow from a default set of elements as you can for scenarios. For more information on this restriction, see Creating a Workflow.

Scheduled Task Example

Overview

There are a few simple things to watch out for when writing a Scheduled Task in Dynamo. This example can be used as a boiler plate for your own tasks.

The code shown in gray is specific to this example, so copy the whole file and simply modify the bits you don't need.

Source Code and Configuration Files

Repeater.java - imagescript.atg.schedule.Repeater

package imagescript.atg.schedule;

import atg.nucleus.GenericService;

import atg.service.scheduler.*;

import atg.servlet.*;

public class Repeater

               extends GenericService

               implements Schedulable

{

  Schedule mSchedule;

  Scheduler mScheduler;

  int mJobId;

  String mMessage;

  public String getMessage(){ return mMessage; }

  public void setMessage(String s){ mMessage = s; }

  public void performScheduledTask(Scheduler sch, ScheduledJob job)

  {

    if(isLoggingDebug())

    {

      logDebug("Job Name = " + job.getJobName());

      logDebug("Job Desc = " + job.getJobDescription());

      logDebug("Job Id = " + job.getJobId());

      logDebug("Job Source = " + job.getSourceName());

    }

    if(isLoggingInfo())

    {

      logInfo(getMessage());

    }

  }

 

  //Demonstration of using the value parser to manipulate the

  // schedule programmatically

  public String getScheduleString()

  {

    String str;

    if(getSchedule() != null)

    {

      str = getSchedule().scheduleString();

    }

    else

    {

      str = "No Schedule Specified";

    }

    return str;

  }

  public void setScheduleString(String s)

  {

     SchedulePropertyValueParser parser = new SchedulePropertyValueParser();

     try

     {

       setSchedule((Schedule)parser.parsePropertyValue(s, Schedule.class));

     }

     catch(Exception e)

     {

       if(isLoggingError()){ logError(e); }

     }

  }

  public void setSchedule(Schedule s){ mSchedule = s; }

  public Schedule getSchedule(){ return mSchedule; }

  public void setScheduler(Scheduler s){ mScheduler = s; }

  public Scheduler getScheduler(){ return mScheduler; }

  public int getJobId(){ return mJobId; }

  public Repeater()

  {

    mJobId = 0;

    mMessage = "Default Message";

  }

  public void doStartService()

  {

    startJob();

  }

  public void doStopService()

  {

    stopJob();

  }

  void restartJob()

  {

    stopJob();

    startJob();

  }

  void startJob()

  {

    if(getScheduler() != null)

    {

      if(mJobId == 0)

      {

         ScheduledJob job = new ScheduledJob("repeater",

                                             "Demonstrates schedule",

                                             getAbsoluteName(),

                                             getSchedule(),

                                             (Schedulable)this,

                                             ScheduledJob.SCHEDULER_THREAD);

         mJobId = getScheduler().addScheduledJob(job);

      }

      else

      {

        if(isLoggingError())

        {

          logError("Attempted to start job without stopping it first");

        }

      }

    }

    else

    {

        if(isLoggingError())

        {

          logError("Scheduler not specified");

        }

    }

  }

  void stopJob()

  {

      if(getScheduler() != null)

      {

        if(mJobId != 0)

        {

           getScheduler().removeScheduledJob(mJobId);

           mJobId = 0;

        }

        else

        {

          if(isLoggingError())

          {

            logError("Attempted to stop job without starting it first");

          }

        }

      }

      else

      {

          if(isLoggingError())

          {

            logError("Scheduler not specified");

          }

      }

    }

  public boolean handleRestart(DynamoHttpServletRequest req,

                              DynamoHttpServletResponse res)

  {

    restartJob();

    return true;

  }

}

Repeater.properties

This is an example configuration file for the task

$class=imagescript.atg.schedule.Repeater

$scope=global

schedule=every\ 1\ minute

scheduler=/atg/dynamo/service/Scheduler

How to make sure the job starts automatically with Dynamo

Add your component to one of the inital arrays in an Initial component. Dynamo has an Initial component on the root /Initial. Usually we want to create our own Initial component for our application in a sub directory, /example/Initial and add that component to the /Initial initial list. Then add your component to your /example/Initial initial components list

Installing Search : ATG SEARCH

Installing Search

This section describes the actual installation process of ATG Search.

To install ATG Search:

1.             Download the ATG Search installation executable.

2.             Start the installer.

3.             On the start page, click Next to begin the installation.

4.             Read the license agreement. Select “I accept the terms of the license agreement” and click Next.

5.             Select Search Administration + Search Engine for the installation type. Click Next.

Enter an installation location, or accept the default. Click Next.

6.             Select locations for product icons and shortcuts.

7.             Review your selections, and click Install to begin the installation.

8.             Enter a Deployment Share folder. This is the scalable, shared directory you created before beginning        the installation.

9.             When the installation is finished, click Done.

Deploy Java code/ ATG components on JBoss

Pretty simple, on a production environment you start JBoss with its run file and a series of commands, which then picks up your EAR file from the deployment directory. Which is a fine process to go through, but what if you’re developing code and you don’t want to wait the several minutes for a build and deployment – on a windows system this can take well over 20 minutes to achieve if you’re running things locally.

We want to do hot deployment so that when you make small changes in your java class/ ATG component you don’t have to rebuild and restart JBoss each time and you save yourself a lot of time.

We can do this by starting JBoss in the following way:

To avoid building an EAR file each time rather than using JBoss’s run file (/JBoss/bin/run.bat or run.sh) ATG provides a way to start JBoss and build the EAR on the fly from your working directory. This means that you can make changes to JSP’s etc… and see the changes instantly. To do this from your command prompt/shell go to your ATG home directory (/ATG/ATG22007.1/home/bin/) and in the bin run this file: StartDynamoOnJBoss.

In order for this to work and hot deployments to work we need to pass in a few parameters for this to work. Firstly the dynamo server to use – if you’re using one. Next set the name of the jBoss server using the -c flag. Then set the modules you want to load so your projects bin/ code source directory, ATG modules etc… and finally set the most important command -f -run-in-place which tells jBoss to compile and run the code from your projects directory rather than look for an EAR file in its deploy directory. So the start command looks like this:

startDynamoOnJBoss MY_DYNAMO_SERVER_NAME -c MY_JBOSS_SERVER_NAME -m MYPROJECT.core -f -run-in-place

And thats it. Now you can make changes to your files in Eclipse and you won’t need to restart jBoss. But there is one last thing – make sure to set your project in Eclipse to build automatically – you can set this under the project menu at the top.

ATG Components Examples

/atg/dynamo/service/CurrentDate

Ever need access to the current date from your application? Well then this is the component for you. Properties of this component include year, month, monthName, shortMonthName, dayOfWeek, dayOfWeekName, hour, minute, second and of course date.

/atg/dynamo/service/random/SecureRandom

The SecureRandom component is a pseudo-random number service. The component extends the java.security.SecureRandom class. Calling the nextDouble() method returns a uniform random number between 0.0 and 1.0. Other methods provide random integers, floats or bytes.

/atg/dynamo/service/Scheduler

If you need to schedule a component in nucleus to run periodically then the scheduler component can be used. Just register a nucleus component with the scheduler by calling the addScheduledJob() method. Your nucleus component will need to implement the atg.service.schedule.Schedulable interface which contains a single method call performScheduledTask() which is invoked by the scheduler when its time to run.

/atg/dynamo/service/SMTPEmail

This component can be used to send an email from nucleus. The component implements the atg.service.email.EmailSender interface. Variants of the sendEmailMessage() method allow one to send email to a recipient or group of recipients.

/atg/dynamo/service/jdbc/JTDataSource

High performance applications require connection pooling. The JTDataSource component provides access to a pool of JDBC connections. This component implements the standard javax.sql.DataSource interface. To checkout a connection from the pool of connections call the getConnection() method. Closing the connection returns the connection to the pool.

This just gives you a taste of some of the components available as part the the nucleus component framework. ATG applications such as its flagship eCommerce application provide additional application specific componets such as order management and pricing components. And of course you could always write your own components and integrate them into the framework.

In our next addition we’ll talk about one of the characteristics that make nucleus truely unique: layered configuration.

ATG Nucleus An Overview

Nucleus - The heart of the (dark) matter

Nucleus is what lies at the heart of ATG. It’s essentially an object container that manages the lifecycle of POJOs using reflection and dependency injection. It's responsible for instantiating objects and setting their properties based on a very flexible but well defined configuration layering hierarchy using simple properties text files. In ATG world, these objects are called components (basically named JavaBeans and Servlets) that can be linked together via these configuration files by a developer to create an ATG application. Nucleus also maintains a name hierarchy and is responsible for resolving these names to components, which can be request, session or globally scoped.

Configuration layering is quite a useful feature of Dynamo. It lets you easily override settings in different application modules you are using, by e.g. creating a component properties file with the same path and name as that component in the corresponding folder in your own module, or in a corresponding folder in a localconfig folder. You can also use thislocalconfig folder to specify environment specific settings, allowing for the creation of environment agnostic builds without having to store all environment specific information in e.g. some database, or doing different builds for different environments. Another nice feature of Nucleus is that it comes with several web based tools that let you browse components in a running application and inspect properties or change their values on the fly, or invoke methods on those components (somewhat similar to a JMX console).

The following diagram gives an example of setting (and overriding) component properties at different layers on the configuration path. The first two files would be part of the application build, but the third file would be placed directly on the production file system to over-write some prebuilt settings.

DropletS / DSP examples

Droplets / DSP tag library

Droplets are ATG servlet beans that are used to dynamically generate HTML. ATG provides numerous droplets to perform lots of common tasks (e.g. display all the error messages for a form), but it’s possible to write your own custom ones also. The DSP (dynamo server pages) tag library is somewhat equivalent to JSTL but with the added ability that they naturally interact with Nucleus components.

Droplets tend to be a bit verbose. For example, compare the following piece of hypothetical code to display the contents of a shopping cart written using ATG droplets with what it might look like if written in a bespoke JEE application.

<h1>ATG shopping cart example</h1>

<dsp:droplet name="/atg/dynamo/droplet/ForEach">  <dsp:param name="array"

    bean="/atg/commerce/ShoppingCart.current.commerceItems" />

  <dsp:param name="elementName" value="commerceItem" />

  <dsp:oparam name="output">

    <dsp:getvalueof var="commerceItemId" param="commerceItem.id" />

    <dsp:droplet name="SkuLookupDroplet">

      <dsp:param name="id" param="commerceItem.catalogRefId" />

      <dsp:param name="elementName" value="sku" />

      <dsp:oparam name="output">

        <dsp:getvalueof param="sku.displayName" var="skuDisplayName" />

      </dsp:oparam>

    </dsp:droplet>

    <td><dsp:valueof param="skuDisplayName" />&nbsp; <dsp:valueof

      param="commerceItem.priceInfo.amount" converter="currency"

      locale="${someCustomlocale}">0.00</dsp:valueof></td>

    <td><dsp:a href="deliveryOptions.page"

      bean="DeliveryOptionsFormHandler.value.itemId"

      value="${commerceItemId}">Delivery Options</dsp:a></td>

  </dsp:oparam>

</dsp:droplet>

<h1>Bespoke shopping cart example</h1>

<c:forEach var="commerceItem"

  items="${shoppingCart.current.commerceItems}">

  <td><customtag:getSkuDisplayName id="${commerceItem.catalogRefId}" />

  <fmt:formatNumber type="currency" minFractionDigits="2"

    value="${commerceItem.priceInfo.amount}" /></td>

  <td><a href="deliveryOptions?itemId=${commerceItem.id}">Delivery Options</a></td>

</c:forEach>

Of course, there is no reason why you can't mix and match tag libraries and only use the ATG tags and droplets where necessary.

ATG Commerce Overview

2 versions: ATG Consumer Commerce is used for developing standard business-to-consumer (B2C) online stores. ATG Business Commerce is used for sites oriented more toward business-to-business (B2B) uses.

1) Product Catalog & Custom Catalog:
The product catalog is a collection of repository items (categories, products, media, etc.) that provides the organizational framework for your commerce site. ATG Commerce includes a standard catalog implementation, based on the ATG SQL Repository, that you can use or extend as necessary.

The structure is built on Catalog –> Category –> Product –> Sku
Where you can modify the features of each level.
The most important is to have the parent flag in the top categories
Each level has parent/child attributes, eg. parentCategories, childSku’s for product level.
You can have a linked template to display the element using it.
Some dropletes are dedicated on loading these elements: ItemLookupDroplet (generic) versus CategoryLookupDroplet, ProductLookupDroplet and SKULookupDroplet.
They take id as input and product the item/elements as output.

MediaLookupDroplet for Media , 2 types exist: Media Internal and External (internally referenced versus URL/File)
The data property is either binary (for media-internal-binary items) or text (for media-internal-text items)

ATG catalogs use several batch and dynamic services to perform catalog updates and to verify catalog relationships. These services are collectively referred to as the Catalog Maintenance System (CMS). The CMS updates property values that enable navigation and hierarchical search. It also verifies the relationships of catalog repository items and properties.
**Batch Services : as
• AncestorGeneratorService
• CatalogVerificationService
• CatalogUpdateService
• CatalogMaintenanceService
Each service creates a global lock at the start of execution, using the global lock management, and releases it upon completion. This prevents services that use the same lock name from executing simultaneously on the same server, or other servers in the cluster.
**Dynamic Services : as
• CatalogChangesListener
• CatalogCompletionService
• StandardCatalogCompletionService

Note that some of these services are available only for custom catalogs; others for both standard and
custom catalogs.

2) Order Management:
A session scoped component which is ShoppingCart (atg/commerce/ShoppingCart) manage the current order (+last order and saved orders), order stored in memory and persisted frequently..
You can configure and customize it using orderrepositiory.xml (where you can define its components, cache size and lock mode).
Once Sku is added to the order–>it become CommerceItem that is related to ShoppingGroup that is related to ShippingAddress and ShippingMethod.
Once order is submitted , it become in incomplete status —> further processing –> fulfilled.
In case of B2B, order is hold for the needed approvals.
Once good feature exist in ATG Commerce, is the ability to have scheduled order.

Payment methods include: Credit card, Store credit, gift certificate, invoice request (in B2B)

CartModifierFormHandler: Request scope
A form handler to handle adding items to order, remove items, change quantity, move the order forward (payment, shipping info),

StoreCartFormHandler:
Handles continue shopping, expressCheckout, update, ….etc…

*Business Layer:
-CommerceItemManager:
Create, add to order, remove from order..
Once sku is added to the order : sku id–> catalog ref Id in CommerceItem object, quantity , priceInfo , paymentGroup and shippingGroup are taken as well.

-OrderManager:
load/save, create , allocate order to payment group.
These operations are handled by pipelines as mentioned before when we discuss the pipelines.
-OrderTools:
Provides low level raw operations..
-PurchaseProcessHelper:
Centralized functionality for purchase operations.

*Best Practise for Order Updating:
1.Acquire lock-manager write lock on profile id from the /atg/commerce/order/LocalLockManager
2.Begin Transaction
3.Synchronize on the Order object.
4.Modify Order
5.Call ((OrderImpl) pOrder).updateVersion();
6.Call OrderManager.updateOrder()
7.Release Order synchronization
8.End Transaction
9.Release lock-manager write lock on profile id from the /atg/commerce/order/LocalLockManager

3) Purchasing and Fulfillment Services :
ATG Commerce provides tools to handle pre-checkout order-processing tasks such as adding items to a shopping cart, ensuring items are shipped by the customer’s preferred method, and validating credit card information. The system is designed for flexibility and easy customization; you can create sites that support multiple shopping carts for a single user, multiple payment methods and shipping addresses.
You can integrate with third-party authorization and settlement tools such as Payflow Pro, CyberSource, and TAXWARE.

4) Inventory Management :
The inventory framework facilitates inventory querying and inventory management for your site.
InventoryManager
The InventoryManager is a public interface that contains all of the Inventory system functionality. Each method described below returns an integer status code. All successful return codes should be greater than or equal to zero, all failure codes should be less than zero. By default, the codes are:
INVENTORY_STATUS_SUCCEED=0 There was no problem performing the operation.
INVENTORY_STATUS_FAIL=-1 There was an unknown/generic problem performing the operation.
INVENTORY_STATUS_INSUFFICIENT_SUPPLY = -2 The operation couldn’t be completed because there were not enough of the item in the inventory system.
INVENTORY_STATUS_ITEM_NOT_FOUND = -3 The operation could not be completed
because a specified item could not be found in the inventory system.

ATG Commerce includes the following implementations of the InventoryManager out of the box.
• AbstractInventoryManagerImpl
• NoInventoryManager
• RepositoryInventoryManager
• CachingInventoryManager
• LocalizingInventoryManager

Preventing Inventory Deadlocks
InventoryManager includes the acquireInventoryLocks and releaseInventoryLocks methods.
acquireInventoryLocks acquires locks for the inventory items that apply to the given IDs.
releaseInventoryLocks releases locks for the inventory items that apply to the given IDs.

5) Pricing Services :
ATG Commerce pricing services revolve around pricing engines and pricing calculators.
**The pricing engine determines the correct pricing model for an order, individual item, shipping charge, or tax, based on a customer’s profile.
**The pricing calculator performs the actual price calculation based on information
from the pricing engine.

Pricing engines are responsible for three tasks:
• Retrieving any promotions that are available to the site visitor.
• Determining which calculators generate the price.
• Invoking the calculators in the correct order.

Pricing calculators are responsible for the following:
• Looking up the price in the catalog by priceList.
• Invoking a qualifier service that identifies the objects to discount.
• Using information they receive from the engines and from the qualifier service to
perform the actual process of determining prices.

By default, ATG Commerce can perform dynamic pricing for the following types of pricing object:
• Items. Each item has a list price that can be specified in the listPrice property of the Product Catalog repository.(Note that an “item” is a CommerceItem, which represents a quantity of a SKU or a product).
• Orders.
• Shipping price.
• Tax.

Terminology:
-Qualifier : This is a service that interprets a PMDL rule and decides what, if
anything, may be discounted. The term qualifier also refers to the first part of a PMDL rule. This rule defines when something can receive a discount.
- Target : The second part of a PMDL rule is called the target. This rule
defines which part of an order receives a discount.

4 Types of PriceInfo objects:
OrderPriceInfo,ItemPriceInfo, ShippingPriceInfo, and TaxPriceInfo

How this works?
1-Invokation to price engine from business-layer logic, such as a PriceItem servlet
bean in a page or from the ATG Commerce PricingTools class.
2-Pricing engine applies its configured precalculators. A precalculator modifies a
price without using any associated promotions.
3-Pricing engine accesses the current customer’s profile and retrieves any
promotions listed in the activePromotions property of the profile
4-Pricing engine builds a list of global promotions and concatenate them.
5-Pricing engine applies promotions by priority (each promotion has pricingCalculatorService property that specifies the calculator that the system must use to apply it)
6-The pricing engine applies its configured PostCalculators.
7-The pricing engine modifies the PriceInfo object of the object being discounted.

-When building a product catalog, you must decide whether your site requires dynamic product pricing and, if so, how granular you need it to be. Using dynamic pricing on a product page can cause a significant decrease in performance compared to using static pricing..

-With static pricing, each item in the catalog has a list price stored in the listPrice property of the catalog repository.
Volume Pricing: Bulk 100 at 10, 200 at 9, …etc..
or Tiered: 1st 100->10 , 2nd 100 –>9 , …
Static uses 2 droplets: PriceDroplet and PriceRangeDroplet.

**PriceEngine:
atg.commerce.pricing.PricingEngine is the main interface for interacting with the
atg.commerce.pricing package. Extensions of this interface describe objects that calculate a price for a specific class of object. For example, OrderPricingEngine extends PricingEngine and calculates prices for orders passed to it.

All PricingEngine implementations process promotions. The PricingEngine interface itself contains only one method, getPricingModels, which extracts a collection of promotions from an input profile. (Price Model can be customized by priceModel.xml).
The PricingEngine interface itself does not describe any functionality other than the promotion extraction API because of the wide range of information that different PricingEngine implementations might require to calculate a price for their specific class of object. For example, the ItemPricingEngine implementation needs one set of input parameters, while the OrderPricingEngine needs a different set.

The individual extensions of the PricingEngine interface contain the API methods for generating a given type of price. There is a Java object type for each type of price that is generated. For example,atg.commerce.pricing.OrderPricingEngine inherits the promotion extraction API from PricingEngine and defines one new method, priceOrder, to generate a price for an order in a given context.

ATG Commerce provides the following four extensions of the main PricingEngine interface:
• atg.commerce.pricing.ItemPricingEngine
Provides a price for atg.commerce.order.CommerceItem objects.
• atg.commerce.pricing.OrderPricingEngine
Provides a price for atg.commerce.order.Order objects.
• atg.commerce.pricing.ShippingPricingEngine
Provides a price for atg.commerce.order.ShippingGroup objects.
• atg.commerce.pricing.TaxPricingEngine
Determines tax for atg.commerce.order.Order objects.

PricingTools Class
The atg.commerce.pricing.PricingTools class performs a variety of pricing functions for different types of pricing engines. It also has a number of static, currency-related methods for use by all pricing engines.
The PricingTools class is the main way that business-layer logic interacts with the pricing engines and the other classes in the atg.commerce.pricing package.

The properties of PricingTools are as follows:
• itemPricingEngine: The pricing engine that calculates prices for items, both
individually and in groups. An item is identified as a set quantity of a SKU or product.
• orderPricingEngine: The pricing engine that calculates prices for orders. Typically,
the price is just the sum of the prices of the items in the order. However, the order
might be discounted separately from the constituent items.
• shippingPricingEngine: The pricing engine that calculates prices for shipping
groups. An order contains one or more shipping groups when the contents of the
order require shipping for delivery. An order has no shipping groups when it is
delivered online, and shipping is therefore not calculated for this type of order.
• taxPricingEngine: The pricing engine that calculates tax for orders. Tax is calculated
on the order total.
• roundingDecimalPlaces: Specifies the number of decimal places to which the an
input price is rounded . This property is used by the round, roundDown and
needsRounding methods.

Important Methods:
priceEachItem, priceItem, priceItemsForOrderTotal, priceOrderForOrderTotal, priceOrderTotal, priceShippingForOrderTotal, priceTaxForOrderTotal, needsRounding, round.

The Pricing Servlet Beans : You can insert on site pages as required and use to
perform dynamic pricing.
• AvailableShippingMethods Servlet Bean
• ItemPricingDroplet Servlet Bean
• PriceEachItem Servlet Bean
• PriceItem Servlet Bean
• PriceDroplet Servlet Bean
• ComplexPriceDroplet Servlet Bean

*Price Lists:
Price Lists allow you to target a specific set of prices to a specific group of customers.
The PriceListManager class maintains the price lists. A price may be retrieved from the PriceListManager from a given price list by product, by SKU, or by a product/SKU pair.
The most important method in PriceListManager is getPrice. This is used during pricing of an order to get the correct price for a given product/SKU pair.

It is configured using priceList.xml

6) Targeted Promotions :
Business managers can use ATG Commerce promotions to highlight products and offer discounts as a way of encouraging customers to make purchases.

Promotions 3 types: ItemDiscount, OrderDiscount and ShippingDiscount.

Pricing Model Description Language (PMDL): rule describing the conditions under which this promotion should take effect. The rule is created in the ATG Control Center using the interface designed for promotion creation.

7) Order Management Web Services :
All order management web services are included in commerceWebServices.ear in the
orderManagement.war web application.