c# wpf free pdf viewer : Extract pages from pdf file Library SDK component asp.net .net web page mvc ATGCommProgGuide40-part2119

ATG  C om mer ce P ro g ramm in g   Gui d e 
38 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 
μ
3.
Create a new class that extends 
atg.commerce.payment.processor.ProcCreateCreditCardInfo
. In this class, 
extend the 
addDataToCreditCardInfo
method to call the superclass, followed by 
code that adds your new properties (added in step 1) to the 
CreditCardInfo
object. 
4.
Modify the class of 
CreditCreditCardInfo.properties
to point to your new 
subclass. 
Extending the Payment System Integration 
The final part of the process of adding a new credit card type is to extend the credit card processor for 
your payment system to use your new card type’s properties in its validation mechanisms. The payment 
system integration will have an implementation of 
atg.payment.creditcard.CreditCardProcessor
For example, if you are integrating with CyberSource, the class 
atg.integrations.cybersource.CyberSourceCreditCard
uses the credit card info in the 
authorize,
credit
and 
debit
methods. All of these methods get data from the ATG Commerce 
creditCardInfo
object, build a CyberSource request, and send the request to CyberSource. This means 
that you need to extend this class and recreate most of the methods, adding logic to use the new 
properties you added. 
In addition, the $class line in the properties file for the credit card processor must be changed to use your 
new subclass. If using CyberSource, 
/atg/commerce/payment/CyberSourceCreditCard
must be 
changed. 
Extending the Purchase Process 
Extending the purchase process is necessary when you want to store purchasing information that is not 
included in the out-of-the-box functionality of ATG Commerce. For example, if you want to allow 
customers to specify a box size for their purchases, you could extend the purchase process to store that 
information. 
You extend the purchase process by first subclassing an existing object in the commerce object hierarchy 
to add new properties and then integrating that new class into ATG Commerce. See the following 
sections for details: 
Adding a Subclass with Primitive Data Type Properties 
Adding a Subclass with Object Data Type Properties 
Manipulating Extended Objects 
Note: For information on extending the ATG Commerce payment process to support a new payment 
method or additional operations for an existing payment method, see the Processing Payment of Orders 
section in the Configuring Purchase Process Services chapter. 
Adding a Subclass with Primitive Data Type Properties 
You can extend the commerce object hierarchy by subclassing an existing object and adding new 
primitive data type properties. When you add primitive data type properties, you don’t need to write any 
Extract pages from pdf file - Library SDK component: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 file - Library SDK component: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 
38 4  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
code to save the properties to or load the properties from the Order Repository. Using introspection, the 
processors in the 
updateOrder
and 
loadOrder
pipelines handle this automatically for primitive data 
type properties. 
As an example, the following code creates a new class called 
MyCommerceItemImpl
. It extends 
CommerceItemImpl
and adds a new 
String
property called 
shortDescription
import atg.commerce.order.CommerceItemImpl; 
public class MyCommerceItemImpl extends CommerceItemImpl { 
public MyCommerceItemImpl() { 
// property: shortDescription 
private String mShortDescription = null; 
public String getShortDescription() { 
return (String) getPropertyValue("shortDescription"); 
public void setShortDescription(String pShortDescription) { 
setPropertyValue("shortDescription", pShortDescription); 
In the code example above, note the calls to 
getPropertyValue()
and 
setPropertyValue()
. These 
methods retrieve and set the values of properties directly on the repository item objects; they are part of 
the 
atg.commerce.order.ChangedProperties
interface. In a commerce object that supports the 
ChangedProperties
interface, every 
get()
method needs to call the 
getPropertyValue()
method, 
and similarly every 
set()
method needs to call the 
setPropertyValue()
method. In ATG Commerce, all 
commerce objects implement the 
ChangedProperties
interface except for 
atg.commerce.order.AuxiliaryData
and all subclasses of 
atg.commerce.pricing.AmountInfo
The 
ChangedProperties
interface enhances performance when saving an 
Order
to the Order 
Repository. In the example above, the call to 
setPropertyValue("shortDescription",
pShortDescription)
in the 
setShortDescription()
method causes the 
shortDescription
repository item property to be set directly when the method is called. This approach reduces the amount 
of processing when 
OrderManager.updateOrder()
is called to save the 
Order
to the repository. 
Performance is enhanced because you set the values directly to the repository item and only save the 
properties that have actually been changed in the class. The call to 
getPropertyValue("shortDescription"
) retrieves the property directly from the repository item and 
eliminates the need to create a member variable in the class to store the value. 
With the 
MyCommerceItemImpl
subclass created, you now need to integrate the new commerce object 
into ATG Commerce. You can do so using one of two approaches: 
(Recommended) Add the new properties to an existing item descriptor and then map 
the new object to that item descriptor. This approach is recommended because it 
eliminates the need to change property values that contain item descriptor names 
Library SDK component:C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
File: Merge PDF; C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Text Extract; C# Read: PDF Image
www.rasteredge.com
Library SDK component:C# PDF Text Extract Library: extract text content from PDF file in
to C#: Extract Text Content from PDF File. textMgr = PDFTextHandler.ExportPDFTextManager( doc); // Extract text content for text extraction from all PDF pages.
www.rasteredge.com
ATG  C om mer ce P ro g ramm in g   Gui d e 
38 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 
throughout ATG Commerce. For more information, see Integrating a New Commerce 
Object: Using an Existing Item Descriptor, which continues the example of 
MyCommerceItemImpl
Create a new item descriptor subtype that includes the new properties and map the 
new object to it. For more information, see Integrating a New Commerce Object: Using 
a New Item Descriptor, which continues the example of 
MyCommerceItemImpl
Note: You can also extend the commerce object hierarchy by subclassing 
AuxiliaryData
, which holds 
auxiliary data for a 
CommerceItem
. If you do so, you can integrate the new class into ATG Commerce 
using either process described in this section. (Recall that 
AuxiliaryData
does not implement the 
ChangedProperties
interface.) However, you should take the following additional steps: 
Override the 
createAuxiliaryData()
method in the subclass so that it creates an 
instance of that new class, as follows: 
protected void createAuxiliaryData() { 
if (mAuxiliaryData == null) { 
mAuxiliaryData = new MyAuxiliaryData(getRepositoryItem()); 
Ensure the new properties of the subclass are defined within the XML definition for the 
new commerce object. 
Ensure the database columns that store the new properties of the subclass go into the 
table that represents the new commerce object. 
Integrating a New Commerce Object: Using an Existing Item Descriptor 
To integrate 
MyCommerceItemImpl
into ATG Commerce using an existing item descriptor, follow these 
steps: 
Step 1 of 3 - Extend the Order Repository Definition File 
Extend the Order Repository definition file, 
orderrepository.xml
, to add the new properties in 
MyCommerceItemImpl
to the existing 
commerceItem
item descriptor. In this example, the new property 
to add is the 
shortDescription
property. 
The 
orderrepository.xml
file is found in the CONFIGPATH at 
/atg/commerce/order/orderrepository.xml
. To extend the file, create a new 
orderrepository.xml
file at 
/atg/commerce/order/
in your 
localconfig
directory. The new file 
should define the 
shortDescription
property for the 
commerceItem
item descriptor. 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 
orderrepository.xml
file that you create might look as follows: 
<gsa-template xml-combine="append"> 
<item-descriptor name="commerceItem"> 
Library SDK component:VB.NET PDF Text Extract Library: extract text content from PDF
Extract and get partial and all text content from PDF file. Extract highlighted text out of PDF document. Extract Text Content from PDF File in VB.NET.
www.rasteredge.com
Library SDK component:C# PDF Page Insert Library: insert pages into PDF file in C#.net
Add and Insert Blank Pages to PDF File in C#.NET. This C# demo explains how to insert empty pages to a specific location of current PDF file.
www.rasteredge.com
ATG  C om merce  P ro gra mm in g  G ui d e 
38 6  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
<table name="dcspp_my_item" id-column-name="commerce_item_id"> 
<property name="shortDescription" column-name="short_description" 
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 the 
shortDescription
property of a 
commerceItem
repository item, as well as 
the database table and column that store that property. 
For more information on setting up a repository and defining item descriptors, see the ATG API Reference
Step 2 of 3 – Modify the Order Repository Database Schema 
In step 1, you defined the new 
shortDescription
property of the 
commerceItem
item descriptor, 
specifying the database table and column that store that property. Now you need to modify accordingly 
the Order Repository database schema. 
The following DDL statement creates the database table and columns specified in the 
orderrepository.xml
file that you created in step 1. 
CREATE TABLE dcspp_my_item ( 
commerce_item_id          VARCHAR(40)          NOT NULL 
REFERENCES dcspp_item(commerce_item_id), 
short_description         VARCHAR(254)         NULL, 
PRIMARY KEY(commerce_item_id) 
); 
Step 3 of 3 – Modify the 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 
MyCommerceItemImpl
class. 
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 might look as follows: 
beanNameToItemDescriptorMap-=\ 
atg.commerce.order.CommerceItemImpl=commerceItem 
beanNameToItemDescriptorMap+=\ 
Library SDK component:VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Moreover, you may use the following VB.NET demo code to insert multiple pages of a PDF file to a PDFDocument object at user-defined position.
www.rasteredge.com
Library SDK component:C# PDF File Split Library: Split, seperate PDF into multiple files
note, PDF file will be divided from the previous page of your defined page number which starts from 0. For example, your original PDF file contains 4 pages.
www.rasteredge.com
ATG  C om mer ce P ro g ramm in g   Gui d e 
38 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 
my.class.dir.MyCommerceItemImpl=commerceItem 
commerceItemTypeClassMap+=\ 
default=my.class.dir.MyCommerceItemImpl 
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 first removes the out-of-the-box configuration, then remaps 
the existing 
commerceItem
item descriptor to the new Bean class, 
MyCommerceItemImpl
. The 
my.class.dir
prefix specifies some Java package in which the class exists. 
Because you can have more than one type of 
CommerceItem
object, the 
commerceItemTypeClassMap
property maps 
CommerceItem
types to class names. This mapping is used by the 
createCommerceItem()
method in the 
CommerceItemManager
; 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 
createCommerceItem()
methods that does not take a type parameter is called, the method 
constructs and returns an instance of the type specified in 
OrderTools.defaultCommerceItemType
. By 
default, the 
defaultCommerceItemType
property is set to the type 
default
, which, in turn, is mapped 
to the new 
MyCommerceItemImpl
class in the 
commerceItemTypeClassMap
property in the 
configuration file above. The 
my.class.dir
prefix indicates some Java package in which the class exists. 
Integrating a New Commerce Object: Using a New Item Descriptor 
To integrate 
MyCommerceItemImpl
into ATG Commerce using a new item descriptor subtype, follow 
these steps: 
Step 1 of 4 - Extend the Order Repository Definition File 
Extend the Order Repository definition file, 
orderrepository.xml
, to create a new item descriptor 
subtype that supports the new properties in 
MyCommerceItemImpl
The 
orderrepository.xml
file is found in the CONFIGPATH at 
/atg/commerce/order/orderrepository.xml
. To extend the file, create a new 
orderrepository.xml
file at 
/atg/commerce/order/
in your 
localconfig
directory. The new file 
should define the new item descriptor subtype. 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 a new item descriptor named 
myCommerceItem
. As a 
subtype of the 
commerceItem
item descriptor, 
myCommerceItem
inherits all of the properties of 
commerceItem
. Additionally, it defines one new property, 
shortDescription
<gsa-template xml-combine="append"> 
<item-descriptor name="commerceItem"> 
<table name="dcspp_item"> 
Library SDK component:C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Page, a Region on a Page, and PDF Document. C#.NET extract image from multiple page adobe PDF file library for Visual Studio .NET.
www.rasteredge.com
Library SDK component:VB.NET PDF Image Extract Library: Select, copy, paste PDF images
By using RsterEdge XDoc PDF SDK for .NET, VB.NET users are able to extract image from PDF page or file and specified region on PDF page, then get image
www.rasteredge.com
ATG  C om merce  P ro gra mm in g  G ui d e 
38 8  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
<property name="type"> 
<option value="myCommerceItem" code="1"/> 
</property> 
</table> 
</item-descriptor> 
<item-descriptor name="myCommerceItem" super-type="commerceItem" 
sub-type-value="myCommerceItem"> 
<table name="dcspp_my_item" id-column-name="commerce_item_id"> 
<property name="shortDescription" column-name="short_description" 
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 
myCommerceItem
as a subtype of the 
commerceItem
item descriptor. You do 
this by adding a new string value for 
myCommerceItem
to the 
type
enumerated property of 
commerceItem
. In this case, the new type is called 
myCommerceItem
, and its corresponding integer value 
is 1. The base 
orderrepository.xml
file contains the other options for the 
type
property of 
commerceItem
The last section of the XML file defines the 
myCommerceItem
item descriptor, specifying 
commerceItem
as the 
super-type
(or parent item descriptor) and 
myCommerceItem
as the 
sub-type-value
. The 
section then specifies the properties of a 
myCommerceItem
repository item, as well as the database table 
and columns that store those properties. In this case, a single property, 
shortDescription
, is specified. 
However, recall that 
myCommerceItem
inherits all of the properties of 
commerceItem
, its parent item 
descriptor. 
For more information on setting up a repository and defining item descriptors, see the ATG Repository 
Guide
Step 2 of 4 – Modify the Order Repository Database Schema 
In step 1, you created the new 
myCommerceItem
item descriptor, defining both its properties and the 
database table and columns that store those properties. Now you need to modify accordingly the Order 
Repository database schema. 
The following DDL statement creates the database table and columns specified in the 
orderrepository.xml
file that you created in step 1. 
CREATE TABLE dcspp_my_item ( 
commerce_item_id          VARCHAR(40)          NOT NULL 
REFERENCES dcspp_item(commerce_item_id), 
short_description         VARCHAR(254)         NULL, 
ATG  C om mer ce P ro g ramm in g   Gui d e 
38 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 
PRIMARY KEY(commerce_item_id) 
); 
Step 3 of 4 – Modify the 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 
MyCommerceItemImpl
class and 
myCommerceItem
item descriptor. 
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 might look as follows: 
beanNameToItemDescriptorMap+=\ 
my.class.dir.MyCommerceItemImpl=myCommerceItem 
commerceItemTypeClassMap+=\ 
default=my.class.dir.MyCommerceItemImpl 
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 a new entry, mapping the 
myCommerceItem
item 
descriptor that you created in step 1 to the 
MyCommerceItemImpl
class. The 
my.class.dir
prefix 
specifies some Java package in which the class exists. 
Because you can have more than one type of 
CommerceItem
object, the 
commerceItemTypeClassMap
property maps 
CommerceItem
types to class names. This mapping is used by the 
createCommerceItem()
method in the 
CommerceItemManager
; 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 
createCommerceItem()
methods that does not take a type parameter is called, the method 
constructs and returns an instance of the type specified in 
OrderTools.defaultCommerceItemType
. By 
default, the 
defaultCommerceItemType
property is set to the type 
default
, which, in turn, is mapped 
to the new 
MyCommerceItemImpl
class in the 
commerceItemTypeClassMap
property in the 
configuration file above. The 
my.class.dir
prefix indicates some Java package in which the class exists. 
Step 4 of 4 – Extend the ID Spaces Definition File 
Note: Because the example provided throughout this section involves an item descriptor subtype rather 
than a root item descriptor, this step is not required for the example. It is provided here for information 
when defining root item descriptors. 
When an ID is requested for a new repository item, it is requested from the appropriate 
IdSpace
for that 
repository item. The item descriptor’s 
id-space-name
attribute specifies which 
IdSpace
supplies 
repository IDs for items of that item type. By default, all items use the item descriptor’s name as the ID 
space unless their item type inherits from another item type. In the latter case, the items use the ID space 
name of the root item descriptor in the super-type hierarchy. 
ATG  C om merce  P ro gra mm in g  G ui d e 
39 0  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
If the new item descriptor that you’ve defined is a root item descriptor, you need to extend the ID spaces 
definition file, 
idspaces.xml
, in order to define an ID space for that item descriptor. The ATG Commerce 
IdGenerator
guarantees that IDs within a named ID space are unique, and each root item descriptor 
defines the characteristics of its ID space in the 
idspaces.xml
definition file. 
Because the example used throughout this section involves the 
myCommerceItem
item descriptor 
subtype, which is a subtype of the 
commerceItem
item descriptor, it doesn’t require a defined ID space. 
However, if 
myCommerceItem
were a root item descriptor, you would define an ID space for it by creating 
a new 
idspaces.xml
file at 
/atg/dynamo/service/
in your 
localconfig
directory. During 
deployment, the ATG platform uses XML file combination to combine the 
idspaces.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 
idspaces.xml
file might look as follows: 
<id-spaces xml-combine="append"> 
<id-space name="myCommerceItem" seed="1" batch-size="10000" 
prefix="mci"/> 
</id-spaces> 
For more information on defining ID spaces and its impact on repository item IDs, see the ID Generators 
section of the Core Dynamo Services chapter in the ATG Programming Guide
Adding a Subclass with Object Data Type Properties 
You can extend the commerce object hierarchy by subclassing an existing commerce object and adding 
new object data type properties. Unlike with adding new primitive data type properties (see Adding a 
Subclass with Primitive Data Type Properties), adding new object data type properties requires that you 
write code to save and load the object’s properties. 
As an example, the following code creates a new class called 
OrderData
. It extends 
CommerceIdentifierImpl
and adds a new 
String
property called 
miscInformation
. A subsequent 
code example creates a new class called 
MyOrder
, which extends 
OrderImpl
and adds a new 
OrderData
property named 
orderData
Note that the 
OrderData
class implements the 
ChangedProperties
interface, which is explained in 
detail after the code example. 
package my_package; 
import atg.commerce.order.ChangedProperties; 
import atg.commerce.order.CommerceIdentifierImpl; 
import java.util.Set; 
import java.util.HashSet; 
import java.util.Observable; 
import atg.repository.MutableRepositoryItem; 
public class OrderData extends CommerceIdentifierImpl 
ATG  C om mer ce P ro g ramm in g   Gui d e 
39 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 
implements ChangedProperties 
public OrderData() { 
super(); 
// property: miscInformation 
public String getMiscInformation() { 
return (String) getPropertyValue("miscInformation"); 
public void setMiscInformation (String pMiscInformation) { 
setPropertyValue("miscInformation", pMiscInformation); 
// 
// Observer implementation 
// 
public void update(Observable o, Object arg) { 
if (arg instanceof String) { 
addChangedProperty((String) arg); 
else { 
throw new RuntimeException("Observable update for " + 
getClass().getName() + " was received with arg type " + 
arg.getClass().getName() + ":" + arg); 
// 
// ChangedProperties implementation 
// 
// property: saveAllProperties 
private boolean mSaveAllProperties = false; 
public boolean getSaveAllProperties() { 
return mSaveAllProperties; 
public void setSaveAllProperties(boolean pSaveAllProperties) { 
mSaveAllProperties = pSaveAllProperties; 
// property: changed 
private boolean mChanged = false; 
public boolean isChanged() { 
return (mChanged || (mChangedProperties != null 
&& ! getChangedProperties().isEmpty())); 
ATG  C om merce  P ro gra mm in g  G ui d e 
39 2  
17  -  C u s to m iz in g   th e  P u rchas e  P roce ss   Ex t ern als  
public void setChanged(boolean pChanged) { 
mChanged = pChanged; 
// property: changedProperties 
private HashSet mChangedProperties = new HashSet(7); 
public Set getChangedProperties() { 
return mChangedProperties; 
public void addChangedProperty(String pPropertyName) { 
mChangedProperties.add(pPropertyName); 
public void clearChangedProperties() { 
mChangedProperties.clear(); 
// property: repositoryItem 
private MutableRepositoryItem mRepositoryItem = null; 
public MutableRepositoryItem getRepositoryItem() { 
return mRepositoryItem; 
public void setRepositoryItem(MutableRepositoryItem pRepositoryItem) { 
mRepositoryItem = pRepositoryItem; 
// setPropertyValue/getPropertyValue methods 
public Object getPropertyValue(String pPropertyName) { 
MutableRepositoryItem mutItem = getRepositoryItem(); 
if (mutItem == null) 
throw new RuntimeException("Null repository item: " + getId()); 
return mutItem.getPropertyValue(pPropertyName); 
public void setPropertyValue(String pPropertyName, 
Object pPropertyValue) 
MutableRepositoryItem mutItem = getRepositoryItem(); 
if (mutItem == null) 
throw new RuntimeException("Null repository item: " + getId()); 
mutItem.setPropertyValue(pPropertyName, pPropertyValue); 
setChanged(true); 
Documents you may be interested
Documents you may be interested