c# wpf free pdf viewer : Copy web page to pdf SDK control API wpf azure web page sharepoint ATGCommProgGuide41-part2120

ATG  C om mer ce P ro g ramm in g   Gui d e 
39 3  
17  -  C u s t o mi zi ng   t he  P u rch ase  P ro ces s  Ex t ern al s 
μ
As previously mentioned, the code above creates a new 
OrderData
class that extends 
CommerceIdentifierImpl
, implements the 
ChangedProperties
interface, and adds a new 
String
property called 
miscInformation
The 
CommerceIdentifierImpl
class is an abstract class that contains a single property called 
id
; it is the 
base class for all commerce object classes. The class contains the 
getId()
and 
setId()
methods and 
implements the 
CommerceIdentifier
interface, which contains only the 
getId()
method. The purpose 
of the 
id
property is to store the repository ID for the given commerce object. The 
CommerceIdentifier
interface provides a standard way for ATG Commerce systems to access the repository IDs of items. 
The 
ChangedProperties
interface enhances performance when saving the object by allowing the 
object’s property values to be set directly to the repository item. The interface contains the properties 
described in the following table. 
Property 
Description 
changed 
boolean
property that returns true if the object has changed 
since the last update and returns false if it has not. 
changedProperties 
Set
that contains the names of all changed properties. The 
property is implemented as a 
Set
to include each property only 
once. 
repositoryItem 
Contains the repository item that refers to the object. Having the 
object contain the repository item eliminates the need to look up 
the item in the repository when saving it. 
saveAllProperties 
boolean
property that marks all properties as changed. This 
causes all properties to be saved to the repository, regardless of 
whether or not they have changed. 
With the 
OrderData
class created, the next step is to add the 
OrderData
property to the 
Order
. The 
following code creates a new class called 
MyOrder
, which extends 
OrderImpl
and adds a new 
OrderData
property called 
orderData
package my_package; 
import atg.commerce.order.OrderImpl; 
import atg.repository.MutableRepositoryItem; 
public class MyOrder extends OrderImpl { 
public MyOrder() { 
Copy web page to pdf - SDK control 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
Copy web page to pdf - SDK control 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 
39 4  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
// property: orderData 
private OrderData mOrderData = null; 
public OrderData getOrderData() { 
if (mOrderData == null) { 
mOrderData = new OrderData(); 
setRepositoryItem((MutableRepositoryItem) getPropertyValue("orderData")); 
return mOrderData; 
public void setOrderData(OrderData pOrderData) { 
mOrderData = pOrderData; 
setPropertyValue("orderData", pOrderData.getRepositoryItem()); 
With the 
MyCommerceItemImpl
subclass created, you now need to integrate the new commerce object 
into ATG Commerce. 
With the 
OrderData
and 
MyOrder
classes created, you now need to integrate the new commerce objects 
into ATG Commerce. To do so, perform the following steps: 
Step 1 of 7 – Extend the Order Repository Definition File 
First, extend the Order Repository definition file, 
orderrepository.xml
, to create new item descriptors 
that support the new properties in 
OrderData
and 
MyOrder
The 
orderrepository.xml
file is found in the CONFIGPATH at 
/atg/commerce/order/orderrepository.xml
. To extend it, add a new 
orderrepository.xml
file at 
/atg/commerce/order/
in your 
localconfig
directory. The new file should define the new item 
descriptors. During deployment, the ATG platform uses XML file combination to combine the 
orderrepository.xml
files in the CONFIGPATH into a single composite XML file. (For more information 
on XML file combination, see the Nucleus: Organizing JavaBean Components chapter in the ATG 
Programming Guide.) 
The following 
orderrepository.xml
file defines an item descriptor named 
myOrder
. As a subtype of 
the 
order
item descriptor, 
myOrder
inherits all of the properties of 
order
. Additionally, it defines one 
new property, 
orderData
. The definition file also defines a root item descriptor named 
orderData
which supports the 
miscInformation
property in 
OrderData
<gsa-template xml-combine="append"> 
<item-descriptor name="order"> 
<table name="dcspp_order"> 
<property name="type"> 
<option value="myOrder" code="1"/> 
</property> 
SDK control API:C#: How to Add HTML5 Document Viewer Control to Your Web Page
for this example we will work with a new page. Then, copy the following lines of code to the head load the necessary resources for creating web document viewer
www.rasteredge.com
SDK control API:C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
for C# .NET is an advanced web viewer of freehand annotation, lines, figures and highlight annotations to PDF page. can select PDF text region, copy and paste
www.rasteredge.com
ATG  C om mer ce P ro g ramm in g   Gui d e 
39 5  
17  -  C u s t o mi zi ng   t he  P u rch ase  P ro ces s  Ex t ern al s 
</table> 
</item-descriptor> 
<item-descriptor name="myOrder" super-type="order" 
sub-type-value="myOrder"> 
<table name="dcspp_my_order" id-column-name="order_id"> 
<property name="orderData" column-name="order_data" 
item-type="orderData"/> 
</table> 
</item-descriptor> 
<item-descriptor name="orderData" sub-type-property="type" 
version-property="version"> 
<table name="dcspp_order_data" type="primary" 
id-column-name="order_data_id"> 
<property name="type" column-name="type" data-type="enumerated" 
default="orderData" 
writable="false"> 
<attribute name="useCodeForValue" value="false"/> 
<option value="orderData" code="0"/> 
</property> 
<property name="version" column-name="version" data-type="int" 
writable="false"/> 
<property name="miscInformation" column-name="misc_information" 
data-type="string"/> 
</table> 
</item-descriptor> 
</gsa-template> 
The first line in the above XML example begins the GSA template and instructs the XML combiner to 
append the contents of the tags in this file to the contents of the tags in the file with which it is combined. 
The next section defines 
myOrder
as a subtype of the 
order
item descriptor. You do this by adding a new 
string value for 
myOrder
to the 
type
enumerated property of 
order
. In this case, the new type is called 
myOrder
, and its corresponding integer value is 1. The base 
orderrepository.xml
file contains the 
other options for the 
type
property. The subsequent section of XML defines the 
myOrder
item descriptor, 
declaring 
order
as the 
super-type
(or parent item descriptor) and 
myOrder
as the 
sub-type-value
The 
sub-type-value
refers to the 
type
property in the 
order
item descriptor. Subsequent lines define 
the name of the table in the database schema that stores the properties of 
myOrder
and then define 
those properties. In this case, the table is called 
dcspp_my_order
, and it stores a single property named 
orderData
The last section of the XML file defines 
orderData
as a root item descriptor. The section then specifies the 
properties of an 
orderdata
repository item, as well as the database table and columns that store those 
properties. (Note that each property of a repository item is stored in a database column that has the same 
name as the property, unless otherwise specified using the 
column-name
attribute.) In this case, the 
following properties are specified: 
type
version
, and 
miscInformation
. The 
type
and 
version
properties are defined as 
readonly
(
writable="false"
in the XML) because they are used primarily by 
SDK control API:VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
using RasterEdge.XDoc.PDF; This professional .NET solution that is designed to convert PDF file to HTML web page using VB.NET code efficiently.
www.rasteredge.com
SDK control API:C# Image: How to Integrate Web Document and Image Viewer
RasterEdgeImagingDeveloperGuide8.0.pdf: from this user manual, you can Please copy these directories to the root of Embed Document Viewer to Your ASPX Web Page.
www.rasteredge.com
ATG  C om merce  P ro gra mm in g  G ui d e 
39 6  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
the repository. All three properties are stored in the 
dcspp_my_order
database table. The 
dcspp_my_order
table is declared a primary table, meaning it defines a column that stores repository 
IDs. In this case, that column is 
order_data_id
Step 2 of 7 – Modify the Order Repository Database Schema 
In step 1, you created the new 
orderData
and 
myOrder
item descriptors, defining both their properties 
and the database tables and columns that store those properties. Now you need to modify accordingly 
the Order Repository database schema. 
The following DDL statements create the database tables and columns specified in the 
orderrepository.xml
file that you created in step 1. 
CREATE TABLE dcspp_my_order ( 
order_id          VARCHAR(40)          NOT NULL 
REFERENCES dcspp_order(order_id), 
order_data          VARCHAR(40)          NULL, 
PRIMARY KEY(order_id) 
); 
CREATE TABLE dcspp_order_data ( 
order_data_id         VARCHAR(40)           NOT NULL, 
type                  integer               NOT NULL, 
version               integer               NOT NULL, 
misc_information      VARCHAR(254)          NULL, 
PRIMARY KEY(order_data_id) 
); 
Step 3 of 7 - Subclass OrderTools and SimpleOrderManager to Create the New Object 
When an 
Order
is created, the new 
OrderData
object must also be created and added to the 
Order
object. This functionality requires the following two steps: 
1.
Subclass 
atg.commerce.order.OrderTools
and add a new 
createOrderData()
method that instantiates an 
OrderData
object and creates an 
OrderData
repository 
item in the Order Repository. 
2.
Subclass 
atg.commerce.order.SimpleOrderManager
(which extends 
atg.commerce.order.OrderManager
) and override its 
createOrder()
method. 
The new 
createOrder()
method should first call the 
createOrder()
method of the 
superclass to create the 
Order
object, then call the 
createOrderData()
method that 
you created in step 1 to create the 
OrderData
object, and finally add the 
OrderData
object to the 
Order
. (For more information on the 
SimpleOrderManager
, see the 
Using the SimpleOrderManager section of the Working With Purchase Process Objects 
chapter.) 
The following code example subclasses 
OrderTools
and adds a new 
createOrderData()
method. 
SDK control API:C# Word: How to Create Word Online Viewer in C# Application
want to add C#.NET Word Web Viewer to your web page, you should add a new Web Form to Please copy the following demo code to the head of Default.aspx to
www.rasteredge.com
SDK control API:C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
Easily define a PDF page from multi-page PDF document and convert it to SVG Perform high-fidelity PDF to SVG conversion in both ASP.NET web and WinForms
www.rasteredge.com
ATG  C om mer ce P ro g ramm in g   Gui d e 
39 7  
17  -  C u s t o mi zi ng   t he  P u rch ase  P ro ces s  Ex t ern al s 
package my_package; 
import atg.commerce.*; 
import atg.commerce.order.*; 
import atg.repository.*; 
public class MyOrderTools extends OrderTools 
public MyOrderTools() { 
public OrderData createOrderData() throws ObjectCreationException 
// instantiate the orderData object 
OrderData orderData = new OrderData(); 
if (orderData instanceof ChangedProperties) 
((ChangedProperties) orderData).setSaveAllProperties(true); 
// create the OrderData in the repository and set its id to the 
// repository's id 
try { 
MutableRepository mutRep = (MutableRepository) getOrderRepository(); 
MutableRepositoryItem mutItem = mutRep.createItem("orderData"); 
orderData.setId(mutItem.getRepositoryId()); 
if (orderData instanceof ChangedProperties) 
((ChangedProperties) orderData).setRepositoryItem(mutItem); 
catch (RepositoryException e) { 
throw new ObjectCreationException(e); 
return orderData; 
The following code example subclasses 
SimpleOrderManager
, overriding its 
createOrder()
method in 
order to call the 
createOrderData()
method in the 
OrderTools
object. 
package my_package; 
import atg.commerce.*; 
import atg.commerce.order.*; 
import atg.commerce.pricing.*; 
public class MyOrderManager extends SimpleOrderManager 
public MyOrderManager() { 
SDK control API:VB.NET PDF - VB.NET HTML5 PDF Viewer Deployment on IIS
This page will navigate users how to deploy HTML5 PDF Document IIS server .NET framework is 4.0 or higher, please copy the content in the Web(for .net4
www.rasteredge.com
SDK control API:C# HTML5 PDF Viewer SDK deployment on IIS in .NET
This page will navigate users how to deploy HTML5 PDF Document IIS server .NET framework is 4.0 or higher, please copy the content in the Web(for .net4
www.rasteredge.com
ATG  C om merce  P ro gra mm in g  G ui d e 
39 8  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
public Order createOrder(String pProfileId, String pOrderId, 
OrderPriceInfo pOrderPriceInfo, TaxPriceInfo pTaxPriceInfo, 
ShippingPriceInfo pShippingPriceInfo, String pOrderType) 
throws CommerceException 
MyOrder order = (MyOrder)super.createOrder( 
pProfileId, pOrderId, pOrderPriceInfo, 
pTaxPriceInfo, pShippingPriceInfo, pOrderType); 
OrderData orderData = ((MyOrderTools)getOrderTools()).createOrderData(); 
order.setOrderData(orderData); 
return order; 
Step 4 of 7 – Modify the OrderTools and OrderManager Configuration Files 
In step 3, you subclassed 
OrderTools
and 
SimpleOrderManager
to create the new 
OrderData
object 
and add it to the 
Order
. Now you need to configure instances of these new classes in Nucleus. 
First, configure an instance of 
MyOrderManager
in Nucleus by modifying the existing 
OrderManager
configuration file. To do so, layer on a configuration file by creating an 
OrderManager.properties
file 
at 
/atg/commerce/order/
in your 
localconfig
directory. The 
OrderManager.properties
file should 
look as follows (Note that no properties need to be configured.): 
$class=my_package.MyOrderManager 
Second, configure an instance of 
MyOrderTools
in Nucleus by modifying the existing 
OrderTools
configuration file. The 
OrderTools
component controls many aspects of the purchase process, such as 
mapping between commerce object types and class names, defining the default commerce object types, 
and mapping between commerce objects and item descriptors. You need to modify the 
OrderTools
configuration file to support the new commerce objects and item descriptors that you have created. 
To modify the 
OrderTools
configuration file, layer on a configuration file by creating an 
OrderTools.properties
file at 
/atg/commerce/order/
in your 
localconfig
directory. The 
OrderTools.properties
file should look as follows: 
$class=my_package.MyOrderTools 
beanNameToItemDescriptorMap+=\ 
my.class.dir.OrderData=orderData,\ 
my.class.dir.MyOrder=myOrder 
orderTypeClassMap+=\ 
default=my.class.dir.MyOrder 
SDK control API:C# PDF Page Insert Library: insert pages into PDF file in C#.net
Support to create new page to PDF document in both web server-side application and Windows Forms. Ability to add PDF page number in preview.
www.rasteredge.com
SDK control API:C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
within .NET projects, including ASP.NET web and Window Copy demo code below to achieve fast conversion PDFDocument(inputFilePath); // Get the first page of PDF
www.rasteredge.com
ATG  C om mer ce P ro g ramm in g   Gui d e 
39 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 
The 
beanNameToItemDescriptorMap
property maps Order Repository item descriptors to Bean names. 
In ATG Commerce, the processors that save and load an 
Order
look for an item descriptor that is mapped 
to the corresponding commerce object class; the 
beanNameToItemDescriptorMap
property contains 
this mapping. The configuration file above adds two new entries, mapping the 
orderData
and 
myOrder
item descriptors that you created in step 1 to their corresponding classes. The 
my.class.dir
prefix 
specifies the Java package in which the class exists. 
Because you can have more than one type of 
Order
object, the 
orderTypeClassMap
property maps 
Order
types to class names. This mapping is used by the 
createOrder()
method in the 
OrderManager
by passing it a type parameter (such as the string “default”), the method constructs and returns an 
instance of the corresponding class. When one of the 
createOrder()
methods that does not take a type 
parameter is called, the method constructs and returns an instance of the type specified in 
OrderTools.defaultOrderType
. By default, the 
defaultOrderType
property is set to the type 
“default,” which, in turn, is mapped to the new 
MyOrder
class in the 
orderTypeClassMap
property in the 
configuration file above. The 
my.class.dir
prefix indicates some Java package in which the class exists. 
Step 5 of 7 – Add a Processor to Save the New Object 
You do not need to write new code to save the 
orderData
reference in the 
MyOrder
object. The 
processors in the 
updateOrder
pipeline, which perform the actual saving of the 
Order
object to the 
Order Repository, use the Dynamic Beans mechanism to read and write the values of a bean using their 
property names. However, to save the data in the 
OrderData
object itself, you must create a new 
processor that saves the 
OrderData
object to the Order Repository and insert that new processor into the 
updateOrder
pipeline. (For more information on the 
updateOrder
pipeline, see Saving Orders in the 
Configuring Purchase Process Services chapter.) 
First, write the Java source code for the new processor. The following Java source file, 
ProcSaveOrderDataObject.java
, serves as an example. 
package my_package; 
import atg.repository.*; 
import atg.commerce.order.*; 
import atg.commerce.CommerceException; 
import atg.service.pipeline.*; 
import atg.beans.*; 
import atg.commerce.order.processor.*; 
import java.util.*; 
/* 
This class extends a class called SavedProperties. SavedProperties provides a set 
of properties and a way to retrieve a mapped property. This functionality 
corresponds to the savedProperties property and the 
propertyDescriptorToBeanPropertyMap property in the properties file which 
corresponds the this object. 
This class also implements the PipelineProcessor interface. This interface 
includes the runProcess() and getRetCodes() methods. All pipeline processors must 
ATG  C om merce  P ro gra mm in g  G ui d e 
40 0  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
implement this interface. 
*/ 
public class ProcSaveOrderDataObject extends SavedProperties 
implements PipelineProcessor 
// These are the two valid return codes for this pipeline processor 
private final int SUCCESS = 1; 
private final int FAILURE = 2; 
// The constructor 
public ProcSaveOrderDataObject() { 
// Returns the set of all valid return codes for this processor. 
public int[] getRetCodes() 
int[] ret = {SUCCESS, FAILURE}; 
return ret; 
// property: orderDataProperty 
// This is the order data property. 
private String mOrderDataProperty = "orderData"; 
public String getOrderDataProperty() { 
return mOrderDataProperty; 
public void setOrderDataProperty(String pOrderDataProperty) { 
mOrderDataProperty = pOrderDataProperty; 
public int runProcess(Object pParam, PipelineResult pResult) 
throws Exception 
/* 
The pParam parameter contains the data   required for executing this pipeline 
processor. This code extracts the required parameters for this processor. 
*/ 
HashMap map = (HashMap) pParam; 
Order order = (Order) map.get(PipelineConstants.ORDER); 
OrderManager orderManager = (OrderManager) 
map.get(PipelineConstants.ORDERMANAGER); 
Repository repository = (Repository) 
map.get(PipelineConstants.ORDERREPOSITORY); 
OrderTools orderTools = (OrderTools) orderManager.getOrderTools(); 
MutableRepository mutRep = null; 
MutableRepositoryItem mutItem = null; 
Object value = null; 
ATG  C om mer ce P ro g ramm in g   Gui d e 
40 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 
Object[] savedProperties = null; 
String mappedPropName = null; 
// Check for null parameters 
if (order == null) 
throw new InvalidParameterException(); 
if (repository == null) 
throw new InvalidParameterException(); 
if (orderManager == null) 
throw new InvalidParameterException(); 
/* 
Try to cast the repository and make sure that it is a MutableRepository. 
In most cases it will be a GSA Repository which is mutable. 
*/ 
try { 
mutRep = (MutableRepository) repository; 
catch (ClassCastException e) { 
throw e; 
/* 
This code is taking advantage of the ChangedProperties interface methods. The 
first check is checking whether this processor is configured to save all 
properties always, or take advantage of ChangedProperties. The 
saveChangedPropertiesOnly property is inherited from SavedProperties. If 
getSaveChangedPropertiesOnly() returns false, then the local variable 
savedProperties is set to the entire list of properties defined in the 
SaveOrderDataObject.properties file. If it returns true, then a check is done to 
determine whether the orderData object implements ChangedProperties. If so, then 
it gets the list of properties whose value has changed, otherwise it sets the list 
of properties to save to the savedProperties property. 
*/ 
CommerceIdentifier orderData = (CommerceIdentifier) 
DynamicBeans.getPropertyValue(order, getOrderDataProperty()); 
if (getSaveChangedPropertiesOnly()) { 
if (orderData instanceof ChangedProperties 
&& (! ((ChangedProperties) orderData).getSaveAllProperties())) 
savedProperties = 
((ChangedProperties) orderData).getChangedProperties().toArray(); 
else 
savedProperties = getSavedProperties(); 
else { 
savedProperties = getSavedProperties(); 
/* 
Next a check is done to get the repositoryItem property from the object if it has 
ATG  C om merce  P ro gra mm in g  G ui d e 
40 2  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
a repositoryItem property defined. If it does not have the repositoryItem property 
or its value is null, then a lookup is done in the repository for the item and set 
if it has the property. 
*/ 
boolean hasProperty = false; 
if (DynamicBeans.getBeanInfo(orderData).hasProperty("repositoryItem")) 
hasProperty = true; 
mutItem = (MutableRepositoryItem) 
DynamicBeans.getPropertyValue(orderData, "repositoryItem"); 
if (mutItem == null) { 
mutItem = mutRep.getItemForUpdate(orderData.getId(), 
orderTools.getMappedItemDescriptorName( 
orderData.getClass().getName())); 
if (hasProperty) 
DynamicBeans.setPropertyValue(orderData, "repositoryItem", 
mutItem); 
/* 
This section loops through all the properties in the savedProperties array and if 
they exist in the object being saved, then the property will be saved to the 
repository. The OrderRepositoryUtils class provides functionality which parses 
mapped property values and either gets the property values, determines if the 
property exists, etc. This code is preserved so it will allow classes created for 
DCS 5.0 to still work. If your classes do not use the addChangedProperties() 
method in the set() methods of your beans, then this for loop can be eliminated. 
*/ 
for (int i = 0; i < savedProperties.length; i++) { 
mappedPropName = getMappedPropertyName((String) savedProperties[i]); 
if (! OrderRepositoryUtils.hasProperty(order, orderData, 
mappedPropName)) 
continue; 
try { 
value = OrderRepositoryUtils.getPropertyValue(order, orderData, 
mappedPropName); 
catch (PropertyNotFoundException e) { 
continue; // should not happen 
if (orderManager.isLoggingDebug()) 
orderManager.logDebug("save property[" + (String) 
savedProperties[i] + ":" + value + ":" + 
orderData.getClass().getName() + ":" + 
orderData.getId() + "]"); 
Documents you may be interested
Documents you may be interested