c# wpf free pdf viewer : Extract pages from pdf on ipad SDK Library API wpf .net asp.net sharepoint ATGCommProgGuide39-part2117

ATG  C om mer ce P ro g ramm in g   Gui d e 
37 3  
16  -  C o n fi g u rin g   Pu rch as e  Pro ces s  S ervices  
μ
These stages are defined in the 
stageNames
property of the 
/atg/commerce/bp/ShoppingProcessConfiguration
component. 
The 
ShoppingProcessConfiguration
component also specifies the duplication mode for the shopping 
process. The duplication mode determines what happens if an order reaches a business stage for the 
second or subsequent time. By default, the duplication mode of the 
ShoppingProcessConfiguration
component is NO_DUPLICATES, which means an order is marked as having reached a new stage in the 
shopping process only the first time it reaches that stage. No change is made if the order reaches the 
same stage again. 
Every commerce site is different. The business process stages that are defined by default in ATG 
Commerce may not fit the needs of your sites. You can define whatever business process stages you want 
by setting the 
stageNames
property of the 
/atg/commerce/bp/ShoppingProcessConfiguration
component. Whether you use the default business process stages or define your own, you need to track 
them by adding servlet beans to your checkout pages or defining scenarios to mark when a stage is 
reached, as described in the rest of this section. 
Working with Shopping Process Stages 
ATG includes page-based and scenario-based tools that let you add, remove, and check for business 
process stages. For the shopping process, these include the following servlet beans and scenario 
elements: 
Task 
Servlet Bean 
Scenario Element 
Add a shopping process 
stage 
AddShoppingProcessStageDroplet 
Add Stage Reached 
Remove a shopping process 
stage 
RemoveShoppingProcessStageDroplet 
Remove Stage(s) Reached 
Check if a shopping process 
stage has been reached 
HasShoppingProcessStageDroplet 
Has Reached Stage 
Check the most recent 
shopping process stage that 
has been reached 
MostRecentShoppingProcessStage 
Droplet 
Most Recent Stage 
Reached 
These servlet beans are instances of classes in the 
atg.markers.bp.droplets
package, each with the 
default process name set to 
ShoppingProcess
. See Appendix: ATG Commerce Servlet Beans in the ATG 
Commerce Guide to Setting Up a Store for reference information about these servlet beans. You can use the 
servlet beans to the checkout pages of an ATG Commerce application to add, remove, and check 
shopping process stages. You can as an alternative use the corresponding scenario elements in a 
scenario. For example, you could create a scenario like this: 
Extract pages from pdf on ipad - SDK Library API:C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use C# Code to Extract PDF Pages, Copy Pages from One PDF File and Paste into Others
www.rasteredge.com
Extract pages from pdf on ipad - SDK Library API:VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Detailed VB.NET Guide for Extracting Pages from Microsoft PDF Doc
www.rasteredge.com
ATG  C om merce  P ro gra mm in g  G ui d e 
37 4  
16  -  C o n fi g uri n g  P u rch as e P ro ces s  Serv ices  
The business stage scenario elements are described in the Creating Scenarios chapter of the ATG 
Personalization Guide for Business Users
Shopping Process Recorder 
Data about stages reached in the shopping process is recorded by the 
shoppingprocess
scenario 
recorder: 
This recorder makes a record in the Shopping Process Stage Reached Dataset whenever an order reaches 
a new stage in the shopping process. Note that by default the shopping process is configured with the 
NO_DUPLICATES setting, which means that we only track the first time an order reaches a stage in the 
shopping process. 
Turning Off Recording of Shopping Process Tracking 
If you don’t want to generate reports on the shopping process, you can disable shopping process events 
by setting the 
generateEvents
property of the 
/atg/commerce/bp/ShoppingProcessConfiguration
component to 
false
Troubleshooting Order Problems 
If you modify the functionality of the 
OrderManager
or its related components, you should make sure to 
follow these guidelines: 
When making changes to an 
Order
, you must call the 
updateOrder()
method. (For 
more information on the 
updateOrder()
method, see Updating an Order with the 
Order Manager in the Saving Orders section of this chapter.) 
updateOrder()
must always be called within a transaction. (For more information on 
transactions, see the Transaction Management chapter in the ATG Programming Guide.) 
SDK Library API:VB.NET PDF: Create PDF Mobile Viewer in VB.NET Doc Image Program
you will not need to view and browse your PDF document on your computers for it is available for you to read PDF document in your iPhone or iPad devices at any
www.rasteredge.com
ATG  C om mer ce P ro g ramm in g   Gui d e 
37 5  
16  -  C o n fi g u rin g   Pu rch as e  Pro ces s  S ervices  
If errors occur when a user logs in, set the 
persistOrders
property of the 
ShoppingCart
component to true. 
The 
handleMoveToPurchaseInfoByRelId
method and all other handle methods of 
atg.commerce.order.purchase.CartModifierFormHandler
provide good examples of how and 
when to call 
getOrderManager.updateOrder()
Handling Returned Items 
In ATG Commerce, you can use the 
CommerceItemManager
(class 
atg.commerce.order.CommerceItemManager
) to manage the return of items in an 
Order
. Call 
CommerceItemManager.returnCommerceItem()
to mark a given 
CommerceItem
as returned. This 
method does the following: 
Reduces the 
quantity
property in the 
CommerceItem
by the quantity returned. 
Reduces the 
quantity
property in the 
ShippingGroupCommerceItemRelationship
by the quantity returned. 
Increases the 
returnedQuantity
property in the 
ShippingGroupCommerceItemRelationship
by the quantity returned. 
After the item is returned, the 
quantity
of the 
CommerceItem
reflects the final quantity that was 
purchased. The 
quantity
property of the 
ShippingGroupCommerceItemRelationship
reflects the 
quantity that was shipped, and its 
returnedQuantity
reflects that quantity of the 
CommerceItem
that 
was returned. 
The store credit system in ATG Commerce can also manage the return of items. The Claimable Repository 
contains a 
storeCreditClaimable
item that includes the following properties: 
amount
(double) – the original amount of the credit 
amountAuthorized
(double) – the amount of credit authorized for use 
amountRemaining
(double) – the current amount of the store credit 
ownerId
(String) – the ID of the user or organization for which the credit was issued 
lastUsed
(date) – the date the credit was last accessed 
To modify an existing store credit account (for example, to increase the amount of remaining credit), call 
the 
ClaimableManager.updateClaimableStoreCredit()
method. To create a new store credit 
account for a user or organization, call the 
ClaimableManager.createClaimableStoreCredit()
method (
atg.commerce.claimable.ClaimableManager
) to create the new store credit and then call 
the 
ClaimableManager.initializeClaimableStoreCredit()
method to set its initial values. 
Note that only one store credit account can exist for a given user or organization. 
For more information on the Claimable Repository, including gift certificates, see the Configuring 
Commerce Services chapter. 
ATG  C om merce  P ro gra mm in g  G ui d e 
37 6  
16  -  C o n fi g uri n g  P u rch as e P ro ces s  Serv ices  
Managing Transactions in ATG Commerce 
Most of the ATG Commerce form handlers extend 
atg.commerce.order.purchase.PurchaseProcessFormHandler
. This form handler, which is a 
subclass of 
atg.droplet.GenericFormHander
, is an abstract class which implements a transaction 
management pattern that should be followed by any custom form handlers. This transaction 
management pattern is implemented through the form handler’s 
beforeSet
afterSet
, and handler 
methods provided as part of the ATG Commerce form handlers. 
beforeSet Method 
This method is called once before any form handler property is set or handler method is called. It 
implements the following transactional steps: 
1.
If the form handler’s 
useLocksAroundTransactions
property is 
true
(the default), 
obtain a transaction lock before the transaction is created. 
This prevents a user from modifying an order in multiple concurrent threads. The lock 
name used defaults to the current profile ID. For more information, see 
atg.commerce.util.TransactionLockFactory
. (Note that use of locking has a 
small performance impact.) 
2.
Check for an existing transaction and, if no transaction exists, create one. 
Handler Methods 
The handler methods implement the following transactions steps: 
1.
Synchronize on the 
Order
object. 
2.
Execute logic for modifying the 
Order
object. 
For example, the 
CartModifierFormHandler
subclass has a 
handleAddItemToOrder
method that executes the logic of adding an item to an 
order. 
3.
Call the 
OrderManager
object’s 
updateOrder
method to save the order data to the 
repository. 
4.
End the synchronization. 
afterSet Method 
This method is called once after all form handler processing is completed. It implements the following 
transactional steps: 
1.
Commit or roll back any transaction that was created in the 
beforeSet
method. 
If the transaction was already in place before the 
beforeSet
method was called, the 
afterSet
method does not end the transaction automatically; this is the application’s 
responsibility. 
2.
If a transaction lock was acquired in the 
beforeSet
method, release the lock. 
If you’re extending an ATG Commerce form handler and your code makes its own decisions about errors, 
you can mark a transaction for rollback by calling the 
setTransactionToRollbackOnly
method. 
ATG  C om mer ce P ro g ramm in g   Gui d e 
37 7  
16  -  C o n fi g u rin g   Pu rch as e  Pro ces s  S ervices  
For more information on 
PurchaseProcessFormHandler
and its subclasses, you can examine the 
source files at 
<ATG10dir>\DCS\src\Java\atg\commerce\order\purchase
and refer to the ATG API 
Reference
Extending the ATG Commerce Form Handlers 
If you write a form handler that modifies the 
Order
object, you should implement the transaction-
handling pattern described above. The easiest way to do this is to extend either 
PurchaseProcessFormHandler
or a subclass of 
PurchaseProcessFormHandler
. Your form handler 
will then inherit the 
beforeSet
and 
afterSet
methods, so you won’t need to replicate their portion of 
the transaction logic. However, any new handler methods you write will need to implement the 
transaction logic described in the Handler Methods section. 
Note that the handleXXX methods of the ATG Commerce form handlers invoke preXXX and postXXX 
methods before and after any computation is performed. For example, when a customer adds an item to 
their shopping cart using 
CartModifierFormHandler
, the submit button on the form submits to the 
handleAddItemToOrder
method. Before any computation is done, the 
handleAddItemToOrder
method invokes the 
preAddItemToOrder
method. Additionally, after all computation is complete but 
before returning any information, the 
handleAddItemToOrder
method invokes the 
postAddItemToOrder
method. 
By default these preXXX and postXXX methods have no functionality. They are provided so you can easily 
extend the form handlers to support additional functionality. However, be aware that these methods do 
not take any input parameters. 
ATG  C om merce  P ro gra mm in g  G ui d e 
37 8  
16  -  C o n fi g uri n g  P u rch as e P ro ces s  Serv ices  
ATG  C om mer ce P ro g ramm in g   Gui d e 
37 9  
17  -  C u s t o mi zi ng   t he  P u rch ase  P ro ces s  Ex t ern al s 
17
Customizing the Purchase Process 
Externals 
This chapter contains information on ATG Commerce features that operate outside the actual process of 
creating and placing orders. It also contains information on how to extend the existing purchase 
framework. 
Purchase Process Event Messages 
Describes the event messages sent by the purchase process. 
Integrating with Purchase Process Services 
Describes the integration points in the purchase process and how to add a new credit 
card type to a payment system integration. 
Extending the Purchase Process 
Describes how to store purchasing information that is not included in the out-of-the-
box functionality of ATG Commerce. 
Merging Orders 
Describes how to merge orders when you’ve extended ATG Commerce classes to store 
additional information. 
Purchase Process Event Messages 
The event messages generated by the purchase process are sent at various points in the purchase 
process. These include messages that are sent when a product or category is browsed, when an item is 
added or removed from the order and when an order has been submitted for fulfillment (checkout 
complete). 
Note: This section is for reference. These messages are generated automatically during the purchase 
process. 
Event 
Description 
ItemAddedToOrder
Sent when an item is added to an order. Includes order ID, 
commerce item ID, site ID, and JMS message type 
ItemRemovedFromOrder
Sent when an item is removed from an order. Includes the 
order ID, commerce item ID and the JMS message type 
ATG  C om merce  P ro gra mm in g  G ui d e 
38 0  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
SubmitOrder
Sent when an order has been submitted for fulfillment 
(checkout complete). Includes the serialized order, the JMS 
message type 
ViewItem
Sent when a product or a category is browsed, includes the 
repository name, the item type, the repository id and the 
serialized repository item object. 
ATG Commerce actions include giving promotions to customers when they add a particular item to their 
order or browse a particular product or category. Additionally, confirmation e-mail is sent through a 
scenario that is listening for the 
Submitorder
message. 
Integrating with Purchase Process Services 
This section contains the following information: 
Purchase Process Integration Points 
Adding Credit Card Types to ATG Commerce 
Purchase Process Integration Points 
There are several points in the purchase process where specialized components can be integrated into 
the system. To integrate a component, configure a property of a Nucleus component to reference an 
object that implements an interface (as described below). 
The following list describes the integration points in the purchase process: 
PaymentManager.creditCardProcessor
Use this property of the 
PaymentManager
to integrate with a credit card processing 
system. The credit card processing system must implement the 
atg.payment.creditcard.CreditCardProcessor
interface. By default, the 
PaymentManager
is configured to use a dummy processing system, 
atg.commerce.payment.DummyCreditCardProcessor
The 
PaymentManager
is located in Nucleus at 
/atg/commerce/payment/
PaymentManager.giftCertificateProcessor
Use this property of the 
PaymentManager
to integrate with a gift certificate 
processing system. The gift certificate processing system must implement the 
atg.payment.giftcertificate.GiftCertificateProcessor
interface. By 
default, the 
PaymentManager
is configured to use the ATG Commerce gift certificate 
processing system, 
atg.commerce.payment.GiftCertificateProcessorImpl
The 
PaymentManager
is located in Nucleus at 
/atg/commerce/payment/
VerifyOrderAddresses.addressVerificationProcessor
ATG  C om mer ce P ro g ramm in g   Gui d e 
38 1  
17  -  C u s t o mi zi ng   t he  P u rch ase  P ro ces s  Ex t ern al s 
Use this property of the 
ProcVerifyOrderAddresses
object to integrate with an 
address verification system. The address verification system must implement the 
atg.payment.avs.AddressVerificationProcessor
interface. By default, the 
VerifyOrderAddresses
component, which is located in Nucleus at 
/atg/commerce/order/processor/
, is configured to use a dummy processing 
system, 
atg.commerce.payment.DummyAddressVerificationProcessor
For more information on integrating ATG Commerce with Payflow Pro, CyberSource, and TAXWARE, see 
the Integrating Third-Party Software With ATG Commerce  chapter of this manual. 
Adding Credit Card Types to ATG Commerce 
This section describes how to extend ATG Commerce and a payment system integration (such as 
CyberSource) to use the additional credit card types that the payment system might accept. 
By default, ATG Commerce considers only common credit cards valid. These cards include Visa, 
MasterCard, etc. Many payment systems handle many other credit and debit cards, such as Switch/Solo. 
Many of these other cards have more validation parameters than the standard cards. If your commerce 
site needs to accept these cards, you can extend ATG Commerce to handle these card types. 
The following sections describe the three parts to extending ATG Commerce to include new credit card 
types: 
1.
Extending the ATG Commerce CreditCard Class 
2.
Extending the ATG Commerce CreditCardInfo Class 
3.
Extending the Payment System Integration 
Extending the ATG Commerce CreditCard Class 
The following steps describe how to extend the 
CreditCard
class and modify ATG Commerce to use the 
new class. For general information on extending a class and modifying the ATG Commerce purchase 
process, see the Extending the Purchase Process section of this chapter. 
1.
Create a subclass of 
atg.commerce.order.CreditCard
and include any new 
properties you need for the credit card type. Add get/set methods for each of these 
properties. The get and set methods need to use 
super.getPropertyValue()
and 
super.setPropertyValue()
, so that the underlying repository item is updated 
correctly. 
For example, the following code sample creates a property for the issue number of the 
credit card: 
//------------------------------------------------------ 
// property:IssueNumber 
//------------------------------------------------------ 
public void setIssueNumber(String pIssueNumber) { 
setPropertyValue("issueNumber", 
(pIssueNumber == null ? pIssueNumber : 
StringUtils.removeWhiteSpace(pIssueNumber))); 
ATG  C om merce  P ro gra mm in g  G ui d e 
38 2  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
/** 
* The issue number of this credit card 
* @beaninfo description: The issue number of this credit card 
**/ 
public String getIssueNumber() { 
return (String) getPropertyValue("issueNumber"); 
2.
Add columns to the 
dcspp_credit_card
table to store your new properties for the 
CreditCard
subclass. 
3.
Extend 
orderrepository.xml
to add the new properties in your 
CreditCard
subclass to the existing 
creditCard
item descriptor. 
4.
Modify 
/atg/commerce/order/OrderTools
to make ATG Commerce use your new 
CreditCard
subclass instead of the default class. For example: 
beanNameToItemDescriptorMap+=\ 
my.class.dir.myCreditCard=creditCard 
paymentTypeClassMap+=\ 
creditCard=my.class.dir.myCreditCard 
5.
Modify 
/atg/commerce/payment/PaymentManger.paymentGroupToChainNameMap
to 
contain a pointer to your new class: 
paymentGroupToChainNameMap+=\ 
my.class.dir.myCreditCard=creditCardProcessorChain 
6.
Edit the following properties of 
/atg/commerce/payment/ExtendableCreditCardTools
to include appropriate 
values for your new 
CreditCard
cardCodesMap
cardLengthsMap
cardPrefixesMap
cardTypesMap
Extending the ATG Commerce CreditCardInfo Class 
The following steps describe how to extend the 
CreditCardInfo
class to accommodate the new credit 
card type. 
1.
Create a subclass of 
atg.payment.creditcard.GenericCreditCardInfo
, with any 
necessary new properties. Refer to the payment system’s documentation for 
information on what properties it needs to process the new credit card type. 
2.
Modify 
/atg/commerce/payment/processor/CreateCreditCardInfo.creditCardInfo
Class
to point to the new subclass. 
Documents you may be interested
Documents you may be interested