pega training with project level Trainingwhatsup@8142976573

Pega ApI:
Pega 7 includes standard activities, flows, and flow actions that you can use to
start and advance flows without using user forms. These rule (collectively known as
the Process API) can support Pega 7 business processing through Service Oriented
Architecture (SOA) facilities including agents and service activities.
Business process management applications can use an external portal or external
system and call Pega 7 services that in turn call Process API rules to create work
items, advance the work items through a flow, perform assignments, and so on.
Do not confuse the Process API with the Engine API, a collection of documented
Java interfaces also known as the Public API
PublicAPI:
his PublicAPI is the official, supported public interface to the rules engine.
Pegasystems intends to maintain backward compatibility in new releases for
the APIs accessible through these packages, although this cannot be
guaranteed. In contrast, other packages and interfaces are subject to
change without notice.
For example, these two PublicAPI Java methods are part of
the ClipboardProperty interface to
the com.pega.pegarules.pub.clipboard package. They get and set
properties on a page:
 public ClipboardProperty getProperty(java.lang.String
propertyreference)
 public boolean ClipboardProperty setValue(ClipboardProperty
avalue)
Pega Base Classes:
Base class is one of twelve standard abstract classes that are immediately
below the top class in the hierarchy. This top class, known as the ultimate
base class, is identified by the symbol @baseclass.
The three base classes of greatest interest to application developers
are Data-, Assign- and Work-
Assign-: Assignment instances, each identifying a step in a workflow that
requires human input or work by an outside organization, person, or
system.
Code-: Classes that directly reference server program code. Pages
belonging to classes derived from the Code- base class exist only
temporarily in memory, and are not saved in the PegaRULES database.
Data-: Parent class of concrete classes containing reference data, including
data for system administration and security.

Embed-
The Embed- base class is parent to other classes that, by design, are never
to be used as top-level structures.
By definition, a class derived from the Embed- base class is used only for
embedded, rather than top-level, clipboard pages. Accordingly, no saved
instances of concrete Embed- classes ever exist.
In many situations, the choice between creating a new Embed- class and a
new Data- class is arbitrary. By choosing an Embed- class, developers
record their intention that the class is never to be used for (top-level) pages
or saved objects. Developers can create rules that apply to embedded
instances,
which execute on the clipboard instances of the Embed- class, but the
embedded instance is never saved, or is saved only as a page within
another object.
For example, the standard
decisiontree EmbedWarning.ShowWarningOnForm applies to instances of
the Embed-Warning class, which hold warnings associated with rules.
History-
The History- base class is an abstract class that is parent to numerous other
classes that define cumulative tracking data about the objects in your
application, including rule instances.
History instances identify date, time, and user who updated a work item,
rule, or other object in the system. A history instance may also contain
attachments, notes made by this user, or an internal copy of the entire
instance as it was before the update. In some cases, the historical copy can
be used to undo changes or roll back an object to its previous values and
state.
For users, the value of the history is to promote accountability and to
identify the sources of automatic and manual processing of the object.
Generally. Application developers do not need to create History- classes
explicitly. When you add a new concrete class under the Work-, Data-,
or Assign- base class, the system automatically creates a similar class to
contain history details of that class, using the new class name as the trailing
portion of the History- class name.
 Work objects — Instances of concrete classes derived from History-
Work- class are created when a work item advanced through a flow,
typically through the Work-.AddHistory activity. Others are added
automatically. History are visible on the work history report, typically
accessed from the History tab on the user form. See the PDN
article How to control history instances written to the audit trail.

 Rules — Instances of the concrete History-Rule class are created when
you create a rule (with Save or Save As after New) when you save a
rule into a ruleset not requiring check-out, and when you check in a
rule into a ruleset that requires check-out. These are visible from
theHistory tab of the rule form. The history instance for a checked-in
rule contains the entire previous contents of the rule before update.
 Data — Instances of concrete classes derived from the History-Data-
class are created when a form (such as the Operator ID form) is
saved or when a Data Table row is saved. Note: Data tables are now
superseded by local data storage.
Index-:
The Index- base class is an abstract class that is the ancestor of other
concrete classes that define indexes, sometimes called secondary or
alternate keys, that are stored in the PegaRULES database.
These alternate keys are used by the system to speed searches and provide
sorted lists. They help users find instances such as work items when the
external key is not known but some other fact or property is known.
For example, the Index-WorkPartyUri class — a standard concrete class
derived from the Index- base class — associates a work party (for example
a customer, supplier, or employee) with a work party role.
Link-:
The Link- base class is an abstract class that is an ancestor class to other
classes that identifies paired object instances in your system.
For example, the Link-Attachment class records the date, time, Operator ID,
and other facts about an attachment and a work item. While each instance
defines only one pair association, the overall relationship between linked
objects can be many-to-many.
In contrast to Index- classes, the Link- classes record overt input from users
or from other systems, and are not primarily defined to speed searches or
retrieval.
Log-:
The Log- base class is an abstract class that is the parent of several
standard classes that record cumulative chronological data about events in
the system.
For example, the Log-PegaRULESMove concrete class contains one instance
for each execution of the Import Archive and Export Archive tools.
Properties in each instance identify the date and time the execution started,
which user ran the tool, a record count, and the name of the ZIP file used.

You can access Log- classes and (for concrete classes) their instances
through the Application Explorer.
For concrete classes derived from the Log- base class, the
property @baseclass.pxCreateDateTime is usually the final (or only) key
part. In some high-volume systems, two log events of one class may occur
during the same millisecond, so additional properties are needed in the key
to ensure uniqueness of the instance.
Rule-:
The Rule- base class is the abstract class that contains all rule classes. Rules
define how an application and the organization that uses that application
run the business.
Rules can change over time, can depend on special circumstances, and can
vary depending on the organizational setting of a user. PRPC supports these
requirements through special properties that support rule resolution. For
example, rules that determine office closing hours may change over time,
may have exceptions, and may be different in different countries.
In contrast to Rule- class instances, Data- class instances usually record
static reference facts that are timeless and valid system-wide. For example,
state codes such as MA for Massachusetts are valid for everyone. Data-
class instances don't need the special processing provided by rule
resolution.
The term rule type identifies a concrete class derived from the Rule- base
class. For example, Rule-Obj-Property is a rule type.
System-:
The System- base class, one of thirteen standard top-level abstract classes,
contains concrete classes that hold real-time status information about the
server software as it runs. For example:
 System-Status-Nodes instances identify other nodes participating in
your system.
 System-Locks instances track locks in force.
 System-User-MyRules instances control the delegated rules facility,
visible in the My Business Rules area of the Process Work
workspace.
These classes are reserved. You cannot define classes derived from
the System- base class.
Work-
The Work- base class, one of thirteen standard top level abstract classes, is
a super class to all the classes that define work items. A work item is the
fundamental unit that records processed work in an application.

Properties, HTML forms, and flows in the Work- class are available to
support the behavior and appearance of every type of work items, including
 Ordinary work items, typically belonging to a class derived from the
standard abstract class Work-Object-
 Covers, typically belonging to a concrete class derived from the Work-
Cover- class
 Folders, typically belonging to a concrete class derived from the Work-
Folder- class
The external key to all work items is recorded in the pyID property, and
typically consists of an alphabetic prefix, a dash, and an arbitrary but
unique number.
In a production system, the number of work item instances may eventually
grow to many thousands or millions, and require more database space than
rules or data instances.
Through directed inheritance, a subclass of the Work- base class may have
a name that does not begin with "Work." For example, the
class PegaSample-CustomerRequest, part of the sample application, is a
work type.
1. 1. 1) We can provide Flow-Wise Local Action in Design Tab of the Flow. E Avulies Tu DLF-
REALSTATE-MATERIALS-wuk-steel K Flow Type Paoeﬂow SI IuvL D§'5|. l'i| J'. iUI I Paul: -
FL-w I-11?‘ K I IIICCPI I)f‘GIfjl'| FPITPCC I I1!‘ I -'ICl‘C Ill‘f| II| Pl‘HIl‘ cazeonrv [ 'uHv: h -. r~.
rr: r.1'n Xrzrx-urn: Xl'I)I H'I-I ] WORK ELISE Thu wJrkI. I¢>-. Llii-. lluw i-. i | LuInJuJ Lu be u-.
uIJ will: Work. Clea: DLF-REALSTATE-MATERIQLS-WurIn-Slag ‘IIIVI II‘: 1. , ‘E FLOW-WIDE
LOCAL ACTIONS Iiiqnl. -w an-inn: In nlphnhnrrnl 'u'rl-. r-‘ F Luxulav these actions Flush’ [-
Ihliul I Nd! In: -931.» . r E . . . . . rn n| |n': *:u rrnnnl": n rhn ﬁnw. This Local Flow action will be
available in all the Assignments in the Flow. 2) List Rule A list rule is an instance of the Rule-
Obj-List rule type. A list defines an ordered array of property names from the class. Lists are
referenced only in activities, using the Obj-List method. A list rule determines which
properties of a specified class are copied into embedded pages when the Obj-List method
runs. When only a fraction of all the properties of an object are needed on the clipboard,
using a list rule improves processing efficiency by reducing memory and disk demand. When
we create a Data Table out of a Data Class, A List rule is created inside our Data Class
(Normally with Name EditList). It Contains the List of properties in the Data Class. 3)
Modifying a Data Table If we modify our Data Class by adding a new property, It'll not reflect
in the Data Table. We need to modify the List Rule (EditList) in our Data Class. Then Open
the Data table with Data Table wizard, the new property will appear in the Data table. 4) Lock
mechanism between cover and covered work objects. If the covered objects are locked, the
Cover object is also locked. Locked means only one requestor can access it at a time. The
Activity that maintains this lock is Determine Lock String in Work- class of Pega-Procom rule-
set. 168
2. 2. 5) How cover work object is resolved automatically. Few important things to note here. >
The covered work objects can be of different work classes (types), but Cover and Covered
work objects should be a part of same workpool. > Locking: By default, locking a covered
work object also locks the cover work object. This is desirable because the cover work object
may contain totals, balances, counts, or other derived values that require single-threaded

access. > Page Names: By convention, a cover work object occupies a clipboard page
named pyCoverPage; the covered work object is on a page named pyNorkPage. Many
standard activities depend on these naming conventions. > Ticket: The standard ticket rule
Work-Cover-. A|| CoveredReso| ved alerts a cover flow that all the member work objects are
resolved. If your application is to incorporate this constraint, include this ticket in the flow rule
or rules for the cover work object. > Flow actions: The standard local flow actions Work-.
AddToCover, Work-. AddCovered, and Work- . RemoveFromCover allow user management
of cover contents. > Harness rules: The Work-. NewCovered harness rule supports entry of a
new cover and cover members. > Process Engine API: Activities Work-. AddCoveredWork,
Work-. AddCovered, and others support operations with covers. Folders: A work object folder
is a work object in a concrete class that inherits from the Work-Fo| der- class. A folder object
holds a collection of one or more other work objects (which themselves may be basic work
objects, other folders, or covers) providing access for analysis and reporting. By convention,
the work object ID of folders has the format F-99999. Covers and folders are two built-in
facilities that allow your application to support collections of work objects. In contrast to
covers: - One work object may be associated with multiple folders, but only with one cover. -
Members of a folder can belong to different work types, which need not belong all in a single
work pool. - The relationships between folder work objects and their contents may be many-
to-many These standard rules support folders: - Work-. AddToFo| der flow action — Add a
work object to a folder - Work-. RemoveFrom Folder flow actions — Remove a work object
from a folder - Work-Folder-. Reviewharness — Show folder work object, includes the View
Folder Contents button ([3) to access contents - Work-Folder-. Perform harness — Update
folder work object and contents 169
3. 3. - Work-Folder-. ReviewforExp| ore harness — Split-screen presentation - Work-Folder-.
Fo| derContents section — Show folder contents - Work-Folder-. NewWork ﬂow — Create a
folder 6) Who decides the pyWorkPage as default page for new W. O ? Standard Activity:
createWorkPage in Work- class of Pega-Procom rule-set. - On the Requestor page of the
clipboard, the property pxRequestor. pxCurrentWorkPoo| holds the value of a user's current
work pool. SYSTEM PULSE The Pega-RULES agent performs periodic processing known
as a system pulse. This processing synchronizes the contents of the in-memory rule cache
on that node with rules stored in the PegaRULES database. The pulse helps each node
coordinate processing and synchronize operations, including the contents of the rule cache.
In a multinode clustered system, a rule updated by a user on node North is retained in the
rule cache on node North, and also committed to the PegaRULES database. For a brief
interval, users at another node in the cluster — for example South — may have a stale copy
of that rule in the rule cache on the South server node. When pulse processing for South
completes, the South rule cache has the current rule. Between pulses, updated rules are
noted in the pr_sys_updatescache table, corresponding to the System-Updates-Cache class.
The Agent Schedule data instance named Pega-RULES. <node> defines the pulse interval.
The default interval is 60 seconds. REQUESTOR A requestor is the process and data
associated with a user (guest or authenticated) of your Process Commander system, or the
processing and data associated with a request into your system started by an outside
system, such as a Web Applications Server or an Active Server Page on a Web site. Each
HTTP response that presents the Process Commander log-in form results in the creation of a
guest requestor, one that is authenticated and has only access to the Ru| eSets and
Versions in the PegaRULES: Unauthenticated access group. To avoid tying up system
resources, the default time-out period for idle guest requestors is a minute. Information about
each type of requestors your system supports is defined in instances of the Data- Admin-
Requestor class. Important facts about the context of each requestor are contained in the
pxRequestor page of the clipboard for that (human or electronic) requestor. 170
4. 4. A requestor ID is a system-generated hash identifier that uniquely identifies a requestor
session. This is sometimes called the connection ID. The first letter of the requestor ID
identifies the requestor type: - H — Interactive, browser-based requestor - B — Background

requestors, such as agents - A — Listeners and services - P — Portlet - When installed,
Process Commander contains four requestor types. Typically, these are all you need. Name
Purpose APP . . . For listeners and for access to Process Commander from an external client
system, such as through a service request (other than JSR-168 requests using Rule-Service-
Portlet rules). Requestor sessions using this requestor type instance have requestor IDs that
start with the letter A. BATCH Background processing, such as performed by, listeners,
services, agents, and daemons. Requestor sessions using this instance have a requestor ID
that starts with the letter B. As initially installed, all BATCH requestors have access to the
PegaRULES: Agents access group. BROWSER For HTTP or HTTPS access to the Process
Commander portal using Microsoft's Internet Explorer Web browser on a Windows
workstation, or from a browser presenting a Pega Composite Application. Requestor
sessions using this instance have a requestor ID that starts with the letter H. As initially
installed, all BROWSER requestors have access to the PegaRULES: Unauthenticated
access group. PORTAL For HTTP access as a portlet in conjunction with Service Portlet
rules. Requestor sessions using this instance have a requestor ID that starts with the letter
P. - Agents can broadly be classified into 2 categories. Task Driven and Schedule Driven. To
avoid overwriting an existing page You may want the activity to check whether a page with a
certain name exists before you open a new page. In the activity step‘s precondition, enter the
following: = @PageExists("myPage", tools) where myPage is the name of the clipboard
page. $NONE AND OTHER CONCEPTS - $NONE - While creating a new page using Page-
New, we may sometimes give $NONE in NewClass. This creates a classless page. 171
5. 5. - $CLASS — While we create a pageList or pageGroup, we give a concrete class name.
But we can also give two things there. A abstract class (But we need to provide the concrete
class later in activity using this property) or $CLASS keyword, here also we have to give a
concrete class later (but it can be any class). E. g Code-Pega-| ist. pxResults uses this
keyword. SHARING PAGES BETWEEN ACTIVITIES The calling activity can provide input
parameters to the called activity, or it can share its own parameter page with the called
activity, an approach known as call-by-reference. The preferred means for passing a single
page from one activity to another is to identify the page in the Step Page field of the calling
activity. The called activity receives this page as its primary page. If you need to pass more
than one page, use the indirect page mechanism: - In the called activity, identify an indirect
page by the keyword prompt as the Mode field in the Pages & Classes tab. D ACTIVITY DU
1 1 -RL/ IL5 III I L -M/ I I LRJALS-work-steel 0 Updatevata/ lcu 1 Slaps Plrfietms
Pagesuclasses socullty Ilstnly IFAGLS AlIIH.2l. A§SI. S Page-. Ilium» I 1.10:. ‘ Mmlo-. 1.
Datanagcll Dlfll-REALSTATE-I-lAT[R. IAL5—Wnrlc-Em| : v )_ pIiIII: I|', 'pel_IjI‘l1 I'Jl F11 RFAI
‘ZTATF MATFRTAI ‘3 '. V:ii| t ‘AH: 1 -13 :3. prompl: Dal3Pagc DII11-REALSTATE-I-
IATERIALS-Wnrlc-Em; Pfllllljll ' El - In steps of the called activity, refer to these pages using
the syntax promptpagename. No corresponding entry is required in the Parameters tab. - In
the calling activity, pass the additional pages as arguments to the Call instruction that
invokes the second activity. if 1, D i_. i_. » ailliipnarruaiannii 1’ _1, if $‘9ArlIvIfy|
I|IdnIeI).1hiAdI| 7 nnnlfinrf on-I. m DIFII RFAISTAIF MA‘lF| !lAlSWm1rStn-I Pins uirrcill
uanilnclu mine‘! '- Parauieler Value jv, -r-nrrrirhthiint indiiwrmgec 5 lune IMIIII‘. vi L'llIflI[Jl.
['dldpdIlE‘ | h'If<‘Il"-"JP , 172
6. 6. - The value supplied for the prompt page must not be blank and must evaluate to a
clipboard page name (top-level or embedded). The keywords primary, top, local, and parent
are not valid with prompt pages; the param keyword is valid. Indirect pages provide a generic
way to pass pages not only between activities, but also to other rule types such as list view
rules and summary view rules. Note: The clipboard page created will be only DataPage not
promptDataPage. Problem Flows and Connection Problem Flow Flow problems are error
conditions that a flow execution encounter as it executes that prevents it from continuing. For
example, the flow may reference a rule that is not found at runtime. This is considered a flow
problems (or a problem flow), and can arise from many different sources. The system halts
the progress of that flow execution and starts a flow named Work-. F|owProb| ems. This flow

normally notifies a user named Administrator@org. com, where org. com is the organization
of the user (requestor) who encountered the problem, and creates an assignment. Your
application can override the standard activity Work-. ToProb| emF| owOperator to designate
a different operator as the recipient of these flow problems. If you can fix the problem
through a change in the flow rule, by modifying a rule, or creating a new rule, the processing
can resume. Your organization can copy and override the F| owProb| ems flow and the
ToProb| emF| owOperator routing activity to meet your needs. Through an Integrator task —
represented by the shape in the Visio diagram of a flow rule — a flow execution can call an
external system such as a relational database, Enterprise JavaBean, or Web service. The
activity referenced in the Integrator shape references a connector rule (for example, a
Connect SOAP rule) that controls the communication and data exchange with the external
system. For various reasons, a tested connector interface may fail or time out, causing work
object processing in the flow rule to halt. To facilitate detection and analysis or repair of such
events, you can designate in your application a flow rule for connector exceptions. Failure of
an Integrator task causes the designated flow rule to start. The flow rule can send out e-mail
correspondence, attempt retries, skip over the integrated step, or send an assignment to
someone. Development See §? Using Error Handler Flows for Connectors, a document on
the Integration area of the Pega Developer Network, for detailed development instructions,
summarized here. To use this facility, specify the second key part — Flow Type — of a ﬂow
rule in the Error Handler Flow field on a connector rule form. Process Commander uses the
Applies To key part of the calling flow as the first key part when retrieving the exception flow
rule. If you leave the Error Handler Flow field blank, a connector problem causes the flow
execution to fail and is reported only as Java exceptions in the Pega log of type: com. pega.
pegarules. pub. services. ConnectorException. 173
7. 7. The standard flow rule Work-. ConnectionProb| em provides a default approach to
exception handling. When you accept the default, a connector exception causes the
following processing: 1. The original flow execution is paused. The ConnectionProb| em flow
is called with seven parameters: - Operator ID of a user to notify (not used) - The Applies To
and Flow Type key parts of the original flow execution - The name of the shape in which the
problem arose - A ConnectorException type ' An error message - An assignment type
(Workbasket or Worklist), indicating where to place a resulting assignment. 2. For all the
exception types other than ResourceUnavai| ab| e, processing continues in a F| owProb|
ems flow. See Working with the Flows with Problems report. 3. If the exception type is
ResourceUnavai| ab| e, up to five retries are attempted, at intervals determined by a service
level rule. 4. A developer accessing the workbasket can cancel the assignment (ending both
the ConnectionProb| em flow and the original flow) or attempt to restart the original flow,
perhaps after taking corrective action. Logging: Each node on a Process Commander
system produces two logs: - The Pega Log — also known as the console log or system log
— contains messages created since the server was most recently started. The log file is
usually named PegaRULES-YYYY- MMM-DD. |og, where the date portion of the name
indicates the date the application server was recently started (on the current node). - The
Alert log contains only alerts and supports performance-related monitoring. Viewing or
downloading the Pega log Select Tools > Log Files to view or download the current Pega log
from the server to your workstation. Listeners operate as Java threads rather than as full
requestors, and so cannot be accessed with the Tracer. Accordingly, use logs to debug
listeners. Follow the steps in the following procedures to configure a listener or service
requestor to send log messages to your workstation. Then, using a modified version of the
LogFactor5 log analysis module, you can review detailed or filtered messages. (LogFactor5
was an open source project of the Apache Software Foundation. ) Install the log4j Remote
Logging package To install remote logging client software on your workstation: 1. Select
Tools > System Management Application to start the System Management application. 2. On
the System Management application window, select a node. Select the Logging and Tracing
> Remote Logging menu item. 174

8. 8. 3. Click the link "here" in the sentence "To download log4j socket server click here. " This
download contains a licensed redistribution from the Apache Software Foundation. 4. Save
the file to a local drive and extract its contents. 5. Note the directory that you extracted it to
so you know where to locate the startSocketServer. cmd file. This file starts the Log Factor5
window that displays the contents of the log. 6. Review Internet Explorer settings to confirm
that your workstation has a Java 1.4.1 or later JVM installed and enabled. 7. Create a
Windows shortcut for the startSocketServer. cmd file and then place it on your desktop. You
then can start LogFactor5 with a mouse click. 1) Adding Headers and Footers in a List View/
Summary View Under Format Tab of the reports. We define two sections for Header and
Footer. SECTION SETTINGS 5 eedei USer'xDetaF. ep3rtHr: a1ei . ooter I PLJ: amaiunfo 2)
List-to-List Summary A List to List control on a work object form allows a user to make
multiple , ... ... .H. .t-i. . ». ... ,.. .i selections from one list of candidates. In this example flow
action from an auto insurance application, , a user selects safety equipment from the left list,
each identified by name, and clicks an arrow to add the selection to the right list. The right list
identiﬁes chosen safety equipment options; the left list contains all of the available options.
4VdIIrIlIP ﬂjulinis flmwil flplimis T , , Sal: -I V filui inn-nl ~> ~: Additional controls (unless
disabled when the rule is configured) allow the user to sort either list, to remove previous
selections, to copy all or remove all selections. The user can make further changes until the
user submits the flow action form. 175
9. 9. The List to List control is supported by two Page List properties, one providing the list of
source values and one providing the list of destination values. As a result, the output of a List
to List operation is not an array of text values (such as can be stored in a Value List
property), but an array of embedded pages, identified by one visible text property such as a
name. This article presents a step-by-step procedure for adding a List to List control to a
harness, section, or flow action form. For full details on all options, consult the Help system
topic. Suggested Approach Preparations Identify or create these parts of the List-to-List
control: o The source property, a Page List property of class Code-Pega-List. o An activity or
other processing to populate the source property. o A Single Value property within each
embedded page that identifies the page, for display o The target property, also a Page List
property, typically part of the work object. (The embedded pages of the target property are
often of the same class as the embedded pages of the source property, but this is not a
requirement. ) o Properties that are needed in the target embedded pages. The source
property structure matches those produced by the Obj-Browse, Obj-List-View, and RDB- List
methods, but your application can create the source property by any means. Unlike the
Dynamic Select control and AutoComp| ete control, the List to List control requires the
source property to be populated before the user sees the form containing the control. Adding
the control To add a List to List control to a flow action, harness, or section rule: ‘ " ' _ _ 2%
Paragraph 1. Open the rule form. Select List to List from the Advanced control ab _ A1110
Complete group‘ Label 2. Drag the List to List icon to a cell on the form, and drop it. The cell
5"" Law may change size to accommodate the large control; you can adjust —» hi Dynamic
Select the size later. .. L. ‘T L. ” R? * B D 3. Click the magnifying glass icon at the upper right
of the cell to open the Cell Properties panel. 4. No changes are needed on the Field tab of
the Cell "- Properties panel. On the Presentation tab, confirm that the ow’ A-£_u—l1} Format
is L, .StTO, _,. St . F-rrna: Iv<r'r1i<t _/ ='. _ 5. Click the magnifying glass to the right of the
Format field to map :7 open the Params pop-up window. R= ad"-‘M: SW 1 6. Complete the
Params window. Identify the source property, L] the target property, and the text property to
appear in the , _,_W m source lists. Include double-quotes around property references war,
23, if they contain a period character. Optionally, enter two captions, to appear above the two
lists. 176
10. 10. Select Copy all properties if, when a user selects an item, the system is to copy all
properties on the embedded source page, creating a page with identical properties on a new
embedded page with the target property. Alternatively, you can define a from-to mapping and
control which properties are copied. , W I Current Fonnat Fornat: List I OLISI in U - Par-

amplrrc Parameter Value Source Property 'Safct'yEquiprrcnI. pxRc: u|ts' Target Prope'ty '.
ChosenEquij: me1t' Di>. Jlav Pi Jpci ly '. pyLaLe| ' First Ttle Avalabe Options Scwi id I'll: CI
imei I Oi. Uuii: Show Actions button vj Maxiiiuiii [turns Ii I T: ii 9:1 Disnlav Irrage Property Wid
U I 100% Copy all P'oparti'es true [V > Available Formats Save Cdl iLeI I By default, the left
list displays at most 200 values, even if the source property contains more than 200
embedded pages. By default, there is no limit on the number of pages that a user can add to
the target property. You can change either limit through parameter settings. 7. Click Save to
close the Params window. 8. Optionally, complete other values on the Presentation tab and
Conditions tab of the Cell Properties panel 9. Click Apply to apply the changes you made to
the Cell Properties panel and Parameters window. Click OK to close the Cell Properties
panel. 10. Save the rule form. 11. Test. Ensure that your application populates the source
property before the work object form (or flow action form) appears. A sample activity This
one-step activity creates a page SafetyEquipment of class Code-Pega-List. (Identify this
page on the Pages & Classes tab of the Activity form. ) 177
11. 11. Steps Pnnmeuis fun I (hues Seuivly Ibbry use '5) oesaipaon . see. Page 6}, scam: I. P
CA7] inns: Ct at-um on mouse ? «minim oldass Abhaitocp oniatn-xysvsoem Purdiaseonkr
Dwunutu Vain * Pogcflanc Sifctytquvwcnl E in Obyllass flbhatovv Ovdcrflata Test 1 El Ma-Rt-
(Ids B Rcixiony F I not label El Sdeot E] fidl E] (ondiioo El Value E] F oytaoei ‘ Value Unly I
When executed, the clipboard contains a page for each piece of safety equipment. 1:: ‘I r; .(.
.q. ,.r, ,.. .,. ... -,i (rm-. .p. U,. .i , ._-pj T Tp'. .d‘ ‘d, e,, ,_. g., .d ‘.91 . 7 -I rune-: .iIr: 7
DXRQSUIKSUI (Al)haCor: >-OrderDa: a-Test' 5ingIo': alue pmpenics nfpnge p‘(Re“§1ll7<| [ I
J orRcsul’. :12]1A|3haIor: i OrdcrDa‘a Test‘. oji : ‘ 5 = -xR= =u| =>r-*1 W vrw-'«»v= --0't=
=vr>~-~-T= -=-= ‘: 5 - v . . w — __I pxResuI:5.(<tJ (; I)har_arD~OrdeiDa'a~fest, ~, ,,(}, J(-j, .,v
Ajr)v‘(‘n", .()"j. .r'), ‘7,. T,. ;1 E1 pxRc: ul'. s(S) (A| :haCom Ord-: rDa'arTcst', Nube 5,ce1,. ,,,
,;_d ; ,,, y,, ,og 4 ptRcsul’. :(6J (A| Jh. :iIor3 Ordc-vDa‘a»Tc5t, ‘ Aj. After a user submits the
flow action form, Process Commander copies pages from the source property to the target
page. Six selections appear as embedded pages to property pyWorkPage. Entrants. rnread:
Aaron Leqerd _ ? ,. S'ngJc‘: iIii¢- properties of page (‘hoscnliqiiipnimti 1 I >. n-, .»». Fq
irpnwm —' ‘ C7‘o5e"EQupmenl(1,l(Alchacorc-0?derDaKa-Test ' ’ : C'"o: r:". [r1 . ipmc'it(2jI
(Alrhotforp Ordv, -r[. ‘at-1 TC? !) " J | ‘JIc'oI{tr-I [l: i.lIc Obi Hi: n>'«: Y. on] 3 , re . -,. .i. ,.. ,¢
(rule vb: rut-mt uni 3 , _np__, ,_w_Ge gp-_‘a_(_| b“A"‘3‘u‘.3n"“ uxobjclass IAIpliaCop-
Oideibata-‘est pytabcl Ifog Lamps rrySeler1i-.1’! Ifalse 1' Ll safe: /Eai Llriicii! i': uue—r‘eqa—
L«; -.i 31 . F4 J Feclaieci Pagez. 3) Adding attachments to work objects. Because many
applications prompt users to attach files such as correspondence to work objects, there are
several standard flow actions that create work object attachments. For example, the
standard Work-. AddAttachments flow action enables users to upload a single file and select
a category for it while Work-. AddMultip| eAttachments enables user to select multiple files
and choose a category for each. 178
12. 12. Using Activities to attach a file. Summary of activity steps Activities that create the
attachment objects and link them to work objects include the following general steps: 1.
Create a page for the work object attachment (Data-WorkAttach-File class). 2 Put the file on
the attachment page. 3. Save the attachment page (Obj-Save method). 4 Create a link object
(Link-Attachment class) that connects the attachment to the work object with the Link-
Objects method. 4) How to create activities that run multiple connectors in parallel By default,
a connector takes control of the requestor session until it returns a response to the connector
activity. However, when the RunlnPara| |e| parameter is selected, the connector runs as a
child requester and the activity, the parent requestor, retains control of the session. The
activity can then call another connector with a subsequent task to accomplish, and the
second connector does not have to wait for the first connector to return a response before it
can start its task. Connector activities that run connectors in parallel should do the following:
1. Because each connector needs its own copy of the step page, create a separate step
page for each connector, even if they share the same applies to class. Each child requestor
(connector) makes a copy of the step page and then returns the results in its copy.

Therefore, if the activity runs each connector on the same step page, the results from the
connector that finishes last oven/ vrite the results from the other connectors. 2. For each
connector that runs in parallel, invoke the appropriate Connect-* method with the RunlnPara|
|e| parameter selected. (For SOAP connectors, use Connect-SOAP; for JMS connectors,
use Connect-JMS; and so on. ) 3. I Invoke the ccnnector DataPage Canned SOAP 45.3.,
Method Connect-SON‘ ? onobjed DataPage aldass Dl. fll-ll[AlSTIT[-MATERIALS-
Empbclallsclassscr l’cII"cI| l|€l. El' Vulue * sciviccuamc EiiipDelai| :’-IeI| iu: l ‘ D * tx~:
~.uIiviiMui. e | <‘. uiiliiPuia| |~: | ' E fnrlPnlntlIR| E] L; 3. After the last Connect-* step, invoke
the Connect-Wait method. This method tells Process Commander how long to wait for all the
child requestors (connectors) to return their responses. This step should use a transition to
check the step status before continuing to the next step. 4. After the Connect-Wait step,
invoke the Page-Merge-Into method to copy the returned values from all the step pages into
the appropriate page. 179
13. 13. 5) How to include an image or link as a report columnHow to include an image or link as
a report column > Create or edit a list or summary view rule. > For a list view, open the
Display Fields tab. For a summary view, open the DrillDown tab and choose Detailed View. >
Locate the property that you would like to display as an image or with a link. > In the HTML
Property field of the property row, choose reporting_image or reporting_Iink from the
dropdown list. . Il‘X I I 11:: luv)! ’ . u. cw uztncofr. " T I: u.<¢. -w-: s1v- T E'u: I:5:'T': ‘ 7
SFOWTIIJI nuns Held Holdnbal nod «I1:-, (Ali! -no |1TMl Pnporlv 1 ml’? , r‘-W 1 , .,'. v -. -3.; I
u-‘. n=-. «.. .. w. 3 . x,. ., wvl an? _ M» m rm 1' e 1:33 vrulu .4 , CL3.wr: .: a 5 9,r. .:w. >.» ,
FV, -Z‘u. v'. - , , Q hr‘ , 71”. ‘ i‘A7U'S 5’: I ': :vw’. ’>; _'v)ge ‘ / ': u=u-V . -vx ‘ ’ 2 91* r-: , ‘ > >
Click the Display Formats icon ( ‘~ ) located to the right of the HTML Property field. In the
Value fields, enter the - ImageS0urceName (reporting_image HTML property only) - name
and location of the image file to display in the report - ActivityName — the name of the
activity that is called when the image or link is clicked. - ActivityClassName - the class name
of the activity - Target - the name of the window. In addition, the following values can be
used: - _b| ank - the HTML is loaded into a new, unnamed window - _parent - the HTML is
loaded into the current frame‘s parent. If the frame has no parent, this value acts like the
value "_seIf" - _se| f - the current document is replaced with the specified HTML - _top - the
HTML replaces any framesets that may be loaded. If there are no framesets defined, this
value acts like the value "_se| f" Note: You can specify the size and other characteristics of
the display using the remaining parameters 180
14. 14. 3 Param Window —— Web Page Dialog >w I Ir— , :1 pg‘: -. ,m. .__. ... J. . . . Vuinna trite
A I‘Ix: '.«: n.'c: ‘.: m nsg: .xiass_<rfo'r:1ar$A! I:Ir_an. ;f Am; rnzme 4!l‘| $ll'$£ Ant; n Zaznnnc .
*sc*-. :rsu: rc: rw~c: .us ‘o'er. ‘Y: f‘| III’«£? JB -4 ‘mm nut Zh>'. §a30): ' I‘ : «:-m: u>. -.- F‘
anus: I? T I L]. - hra . ‘J. 'r ~m. ir'. ' 1r‘wmb. 'PI-ES‘ -.1": -l'r,1 I -- 2) -‘ 1: v; 'I 1- -‘N two § rml
n1I1-r-r 6) How to rename Rule-Set? Select Tools > Rule Management > Copy/ Move
Ruleset. Select the ru| e—set and give new name and save. 7) JavaScript and Client-Side
Validation in Pega. You can make use of client-side scripts as follows: : 1. Create and text a
JavaScript script. Include the validation that you want to do. 2. Create a text file rule (Rule-
File-Text rule type) with "js" as the final key part. Upload the JavaScript file to the rule.
Having the body of the script in a versioned rule file is beneficial. 3. On the Harness rule
form, update the Scripts and Styles tab to specify the text file rule containing the script. 4.
Update the HTML Property rule associated with the specific field. Attach an event such as
OnChange or OnSubmit. 8) Rule Availability Final Use the Availability value of Final to signal
that this rule is the final version and should not be changed. If the Availability of a rule is set
to Final, that means that you may use this version of the Rule, but you cannot save it into the
same RuIeSet, or a different RuIeSet, unless you change its name. Normally, if you wish to
change a rule in a locked RuIeSet version (the activity “Display/ ‘), you would perform a
“Save As" of that Rule into your application RuIeSet, with the same name, and make your
changes. If the rule is marked Final, however, you may only do a “Save As" and copy it with
a different name (activity “DispIaylnvoice"). N0/Draft When a rule is marked No/ Draft, the

system treats it as though it were not present at all; the system ignores the rule and uses
other rules. The Not Available label applies to one rule only. When the system is gathering all
the rules to consider for a rule resolution, any rule marked Not Available is simply discarded.
181
15. 15. This availability is sometimes referred to as the “draft" availability, as it can be used to
test “draft" rules before actually putting them into production. You can create a copy of a rule
you wish to change, make the change, and set availability to “No/ Draft" in the main system,
so the system will ignore that rule. You can then check out the rule into your personal
RuIeSet and change the Availability to “Yes" to test your change locally. This allows you to
verify that the rule displays the behavior you want, before setting the Availability of the
changed rule to “Yes" for all users. Blocked Unlike rules marked “No, " rules marked Blocked
are still considered by rule resolution. If the rule resolution process completes, and the one
rule that is the final result of that process is marked Blocked, then the process returns “not
found. " You can think of Blocked as blocking not just the rule, but the process. Blocked vs.
No When the system is determining which rule to use, the Availability values of BLOCKED
vs. NO will change what rule is chosen. If there were two versions of the activity DISPLAY: o
Acme-. DlSPLAY AcmeCo: O5-O2 o Acme-. DlSPLAY AcmeCo: O5-O1 if the 05-02 version
of the rule were set to NO, the system would use the 05-01 version. if the 05-02 version of
the rule were set to BLOCKED, the system would not use the 05-01 version, but would return
“not found. " Withdrawn Occasionally, you need to delete a rule from an application. If the
incorrect rule is stored in an unlocked RuIeSet version, you can easily delete it. However, if
the application has been moved to other systems, however, or the rule is in a locked RuIeSet
version, it is no longer possible to change or delete that rule. Instead, you can withdraw the
rule. 1) Where we define the WorklDPrefix and Status of New W. O? A: In the pyDefauIt
Model of Work- class. We can override it in our Application Details Tab. a}{. ‘l£l. ”y“. ia<
Mame implementation Fins: Wort I'D Prefix 1 "3 Here we can define different WorklDPrefix
for different class. 2) Pega Portals PRWeb : Used for Development Purpose. We have
developer/ Manager/ User portal here. PRDBUtil: Supports installation and upgrade
processing. It has few functions like 182
16. 16. - Testing the data base connections configured in Appln Server. - Upload Application files
- Setup organization - Download rule utility logs - Complete the Pega Installation process -
Configure JMX settings etc. PRsysmgmt: For SMA. Organization: Can have Access group
and Rule set. Division: Only Access Group. 3) Rule Resolution Takes pattern inheritance as
precedence over direct inheritance. Model chaining does the opposite. 4) pzPVStream: The
only one column in pc_work by default which stores work object as BLOB. 5)
pc_assignment_worklist/ workbasket: The table where W. O assignments related info are
stored. Name of BRE in Pega: PegaRules. Process Commander: It’s an application that
provides a highly interactive graphical development and execution environment with
dashboards for process monitoring also. 3 tier Architecture for Pega. Client Tier (Dev/ Man
Portal) -> Appln Server Tier (Rule cache, BRE, DB Roles, Data Dictionary) -> DB Tier.
Declarative rules are fired automatically -> by Agents. 6) If we create a new page by Page-
New method, we can provide a model to initialize the properties of the method. 7) pzlnsKey:
Combination of Class name + primary key 8) SendEmailNotificationWithAttachment: Activity
that send email with attachment. We have to give attachment page name in parameter.
Difference between Decision Tree/ T able. - Decision table can be edited in excel. - Decision
trees can have nested if and test on multiple properties. - Trees can call other decision rules.
Table can call only tables. Application Server 1) Creating a JDBC Connection 183
17. 17. Go to Admin Console of Websphere. Give username and password. There is a link under
JDBC — Data Sources. You can add a new data source here. 13 Resources §CJE'i: |Inil|
=Rayad-D¢sktopNodo0lC9I. Hodi= Ruyad-DI Scope specifies the | e'. e at . 'h ('1 the
resource deiinitu 3:: -pa ll Ind how: two'-:1. " n ‘I I NL: ~de= Ri‘, Iad4Desl<tc‘p‘. o:eZL.
Server-= gerver1. v E : ’f0f€'if'I-Iii - Del! t!| Tut COFil'Q(fi3'I 1 Manage state. .. | I-, ;§1‘; ir, I;'l'.
;§I'. Gl". -‘ Fl RP". DLlF_'>" hcaprrrt W A". ynrI'rcrc| .'. 3-‘an-' ‘ A A F] Cachrl rflflnfl: Select

Name V JNDI nan-e V Scope V E Mail Default De"eu tE-a'. .=_5our-Le Node= R|yad-
Datesource Desk-topiiodeo URL Resaur: e E1’: rcnment Security Total 1 PH» In Tomcat, we
have datasource description in context. xmI file. We can use them to create resources in
web. xmI The standard function caIIActivity( ) in the Pega-RULES Utilities library calls an
activity, but returns only void, not a value result. You can execute an activity in an
expression, but only for its side effects. Identify the primary page, the activity, and the
parameter page. For example: @Pega-RULES: UtiIities. caIIActivity(pyWorkPage,
MyActivity, tools. getParameterPage()); Agile Software Methodologies Agile software
development is a software development methodologies based on iterative and incremental
development, where requirements and solutions evolve through collaboration between self-
organizing, cross-functional teams. It promotes adaptive planning, evolutionary development
and delivery, a time-boxed iterative approach, and encourages rapid and flexible response to
change. Twelve principles underlie the Agile Manifesto, includingzm - Customer satisfaction
by rapid delivery of useful software - Welcome changing requirements, even late in
development - Working software is delivered frequently (weeks rather than months) -
Working software is the principal measure of progress - Sustainable development, able to
maintain a constant pace 184
18. 18. - Close, daily co-operation between business people and developers - Face-to-face
conversation is the best form of communication (co-location) - Projects are built around
motivated individuals, who should be trusted - Continuous attention to technical excellence
and good design - Simplicity - Self-organizing teams - Regular adaptation to changing
circumstances SCRUM Methodologies Scrum is an iterative incremental framework for
project management often seen in agile software development, a type of software
engineering. Although the Scrum approach was originally suggested for managing product
development projects, its use has focused on the management of software development
projects, and it can be used to run software maintenance teams or as a general project/
program management approach. Characteristics Scrum is a process skeleton that contains
sets of practices and predefined roles. The main roles in Scrum area]: 1. the “ScrumMaster",
who maintains the processes (typically in lieu of a pro'ect manager) 2. the “Product Owner",
who represents the stakeholders and the business (Client's Voice) 3. the “Team", a cross-
functional group who do the actual analysis, design, implementation, testing, etc. Daily
Scrum Meeting. Scrum of Scrums meeting. Story points. About Direct Capture of Objectives
Direct Capture of Objectives (DCO) is a suite of features that enable project team members
to directly capture, organize and manage business specifications inside of Process
Commander and associate them with the specific parts of the application that are
implementing them. Designed as an enabling technology suite, it can be used collaboratively
and productively by project teams that include members of the business analyst, user,
developer, quality assurance and IT communities of your organization. By removing
redundancies and disconnects, it helps close gaps in the development process by fostering a
Build for Change mindset that encourages reuse of application assets, automates common
project activities, and generates on-demand, up to date, accurate project documents. DCO is
not a methodology in and of itself. It is an agile process that is adaptable to any size project
and can be used in conjunction with any implementation methodology. When applied
consistently, DCO saves you time, effort, and budget dollars while improving and maintaining
project and application quality. The end result and benefit of using DCO is a clear 360
degree view of your Process Commander application through a project life-cycle. 185
19. 19. Business / A Objectives / _ ‘ I Project Tean ~_ _/ / Requirenerts & Effort -/ a. Sizirg ‘ Use
Cases ’_L/ ‘ i -‘ ’>_Y__‘ R ‘ ‘ / 39° * / I. " F 7°59“ ' Process 0'1 Demand ‘, PII 3: ll‘ , ' Discovery
Documentation ‘ . I Appﬁcation I, ' & A View , M“p"'"9 . . , , / .4 I _7 r / sﬁ/ , _V ‘ i V
Implementation V Reports Classes 8. & Kulcs Uorrcsponaenct ‘ / r / _, _x / -' Li ( Integration )
g—/ / xi Direct Capture tools include: Application Profiler — captures objectives, use cases,
requirements, processes, interfaces, reports, correspondence, and case type relationships;
estimates project sizings; documents the collected information as an application profile

document; jump starts application development by providing the information as input to the
Application Accelerator. Application Accelerator — jump starts the creation and extension of
your application and automates best practices for application design; consuming information
from an application profile, it creates organization and class structures, case type
relationships, and draft processes and user interface elements so you can see the working
application based on the captured information. Application Document wizard — supports
rapid and iterative documentation of the application as development progresses using your
predefined templates and content settings. Application Use Case — allows business users to
describe at an atomic, granular level the steps required to build an application in business
language; stored as business rules and linked to processes and other application
components to provide development and testing detail and traceability as development
progresses. Application Requirement — allows business users to describe capabilities that
the application must fulfill and define success criteria; stored as business rules and linked to
other rules to provide development and testing detail and traceability. Rational Unified
Process (RUP) Pegasystems implementation methodology is based on Rational Unified
Process. The focus is on project management, 186
20. 20. return on investment, conformance to best practices and compliance requirements,
communication with stakeholders, creation of physical artifacts that help ensure project
success. Advantage of RUP. - Develop software iteratively - Manage Requirements - Use
Component based architecture - Visually model software - Verify the Quality - Control
changes to software. Eusinoss Value Ascassmorl dofn-as the success lactcn: and expected
ROI Pegasystems‘ methodology includes the following phases: UI SGWGI’ GBISIOG DU SI
0655 I Business Value Assessment phase — Assess requrements and so utlons return on
investment, define success criteria, understand high—| eve| requirements. Produces a
project plan, scope document, and project sizing estimate Design solutions tailored inihe husi
mess requiremeris Bu'| d tli: applzation to meet business ' l I Conception phase — Analyze
the problem mqumuws domain, define requirements, establish a scalable architectural
foundation, and identify high—risk elements. Produces a requirements document, a high—
level design document, test plan, and deployment plan. Validate the application for
apcrocriaie implementallm 0‘ business processes Deploy the appicehon. training, and help
desk for final production system I Elaboration phase — Design solutions tailored to the
business requirements I Construction phase — Iterative development following a build order.
Built the application to meet business requirements. I Transition phase — Deploy, validate,
test and use. Typical Interview Questions by Pega PS for Medco Account Technical
Questions 1. What are the various phases in Pega SmartBPM methodology? - http: //pdn.
pega. com/ ba Ianding. asp - Go through both approach “Getting Started with PRPC Using
SmartBPM" & “Getting Started with PRPC Using Pega Scrum". The SmartBPM
implementation methodology (v2) is used within Pegasystems own Professional Services
teams — and by partners and others — to organize and run application development
projects. In contrast to many more prescriptive, rigid methodologies, the SmartBPM
methodology is an adaptable process framework. The methodology is closest in approach to
the popular Rational Unified Process (RUP), and is compatible with Unified Modeling
Language (UML) approaches. 187
21. 21. Flexibility allows the team to adapt the methodology to large and small projects. The
processes can be right-sized to project needs. Experience shows that the SmartBPM
methodology can be followed without conflicting with most organization's existing (post-1990,
non-waterfall) methodologies and project management approaches. Large applications are
subdivided into functional slivers of limited scope, to reduce risk and allow benefits and
return-on-investment to start earlier. Benefits The list of expected benefits from the
methodology may be familiar —~ they are similar to those claimed by almost every
methodology . However, important differences in Pegasystems‘ approach help to realize
these benefits: - Manage projects in a structured, repeatable fashion - Common terms and
language used by all stakeholders - Support iterative, rapid application development -

Generated documentation matches current implementation - Promote and encourage reuse -
Promote and encourage compliance with industry standards - Manage project risks Enabling
tools Wizards and tools built into Process Commander directly support teams during each
phase — not just during the development (Construction) phase — of their projects. By
capturing even preliminary ideas about system objectives, system participants (actors),
assumptions, interaction scenarios or use cases, Process Commander provides value and
useful foundations very quickly. Information is saved in a single repository — a Ru| eSet —
rather than in disparate formats based on Microsoft Word, Excel, Visio, and other general-
purpose tools. Since these early ideas naturally evolve and change, the internal Process
Commander representation of them can be updated too, providing a project history and
avoiding the need to switch tools when "real development" starts. 188
22. 22. Poplicalion Pwfilu fiojoct Pm H 935: Ffi; ‘,‘, ',,9;”; :;‘ stoqboaramg . , , , I . z . . , , _, ,. Test
[- “magemm An: icaflon Frrnowoflu A°°°1“3‘wUnit AUDKGQ As suggested by the diagram,
these features of Process Commander (V5.4+) can directly support the methodology: The
Application Profiler, recording application objectives, requirements, use cases and roles The
Application Document wizard The Enterprise Application Accelerator Auto testing facilities
The Project Explorer and Project Management Framework Phases: The methodology
identifies five major phases: Pre-inception, Inception, Elaboration, Construction, and
Transition. But as suggested by the diagram, these phases overlap both during a single
iterative development of each "slice" of the application, and they overlap because more than
one slice may be developed at once. '3;-, v-r on-ll '1'-‘ LI. ’ I ’ilI]h ¢ EabO| ‘8Ho; , ‘<9 t I ° cg}?
1 0°} )5 k‘ "Q3nsnucfio“ '6') can Iwngialcd lnnl: 'rxpnr'. ‘;nrncu’1Ifcnng< Ahnl nggarg Directly
Capturing Objectives Governance Quality Chocks " . Next 3HUl ” - 1 » .1 189
23. 23. The Pre-Inception Phase The Pre-Inception phase is primarily for knowledge transfer and
education. The goal is to provide the business participants with terminology that will assist
with requirements gathering, objective determination and scope definition. The Inception
Phase During the Inception Phase the team defines the scope of the sliver being
implemented. This phase produces three artifacts: . An Application Profile - A project sizing .
A high-level project plan These three deliverables help to define the scope, effort and
timelines of the application. The tangible result of the Inception phase is an approved
Application Proposal. lmepmn Elaborajon consrucxim Transition ' Expand or‘ use : ases
Ftnnfigms-. Anr unit ‘as? Svslem and we UserTest ‘ , 'pplicationPr3fi| er ‘ Effort 342mg
Enterprise Application Acceleratcr ‘ Rea Tme Document Generation ‘ Iterative Application
Deveiomient ‘ Un t / ~uto Test (oational) Test Mawaoemewt Framework (cptmnal) Project
Management Framework (optional) Status Report ng and Gove'nr. noe The Elaboration and
Construction Phase The Elaboration/ Construction phase is focused on the Direct Capture of
objectives as well as iterative construction tasks associated with requirements and use
cases. Direct Capture of Objectives (DCO) allows information to be entered once and reused
many times — for planning, documentation, and testing. DCO can drastically reduce the
effort and elapsed time othen/ vise needed to keep documentation up to date. During this
phase, business users participate in periodic reviews of the application as it advances and
grows iteratively, identifying at the earliest moment any divergence in requirements and
development efforts. The Enterprise Application Accelerator, Auto Test features, Application
Preflight tool, and Auto Test facilities can be helpful during this phase. 190
24. 24. -. ‘ _, V ( ‘, — bo ti = De oco 3° '3 °" no _ . 00¢’ Sessions i * 1 ace)‘ 4‘ "~SPnstruc}l0 N‘ .
c‘ L ‘ ~. Re-Jm Review PAL Pie-= iig1l Design Review Humri Factor: ‘ Appiisat on
Accelerator‘ ‘ Rule I-orm Updates lhlt Am? ) Test (optktnnl) lest Management I-rran‘evcrI<
ioptianal) ‘ Heal Iin'nl)omrrrn1(, ;ene. -n'i-an Project I‘/ Ianaganert Framewcrk Joptiaral) ‘
Status Heporbng and Governance This phase can be iterated rapidly, without advancing to
the Transition phase. Progress and results can be assessed often, even biweekly. . ..- _
.40». “I FV Qybbolaflon ‘:3 vfitd i , ,.. . uuuu _j‘, :‘ 9,. » .4 .0‘ , »n . o" sunny; ‘; »“ Inception A
D90 «‘ C'onslru¢“ OCSSIOTS -, constr)¢“ Constru¢“°o “Bil-! CHM-2 SHI I| '3|'S| i|O| ' Go—
Live The Transition Phase The Transition phase is used to test and to ensure the quality of

the application. Application quality includes: - System testing . Interface testing -
Performance testing - User acceptance testing (UAT). 191
25. 25. iransition QA iesting Elamraiitinl no 9 Construction ‘.3 (U ‘.7; en 8 a: V Smoke Release Z,
Test dz“ § Candidate > Q pa”; Boun .9 <3 2 if lntegra‘-‘° 3 § :53’ ExceP""°°, ,(8 " “ls, ““
emIP8fi° Create Release Rcgn_3s: c»ri7v; iating Issuenasoiuiior no HAT ‘ Cardidafg IEei/
En/1 ([')P‘Fnv) Candidates yes Plum: -eed Ii) UAT Tasting Go-Live A Go-Live occurs when
an application is moved — often just one sliver at a time — into a production environment
and business users begin using the application to perform real work. 2. What phases have
you worked on in your previous projects? Inception, Elaboration, Construction etc. — Say all
& think of some examples of what you did based on the understanding from above link. 3.
What are the Guardrails in Pega? Mention the guardrails with an explanation of each, some
if not all. — You can find this easily in PDN / Pega Help. The Ten Guardrails to Success are
design guidelines and recommended best practices for Process Commander
implementations. Suggested Approach Following the fundamental principles promoted in the
Ten Guardrails to Success leads to rules-based applications that are well designed,
straightfonivard to maintain, and architected to Build for Change”. They are your keys to
success with Process Commander. 1. Adopt an Iterative Approach - Define an initial project
scope that can be delivered and provide business benefit within 60-90 days from design to
implementation. - Document five concrete use case scenarios up front and evaluate them at
the end to calibrate benefits. - Use your scenarios as story boards and ensure that each
delivers a measurable business benefit. 192
26. 26. 2. Establish a Robust Foundation - Design your class structure complying with the
recommended class pattern. - It should be understandable, be easy to extend, and utilize the
standard work and data classes appropriately. - Use your organization entities as a starting
pattern, and then proceed with class groups. - Lead with work objects. Create the class
structure and “completed work" objects early. - Position rules correctly by class and/ or
Ruleset. - Actively use inheritance to prevent rule redundancy. 3. Do nothing that is Hard -
Use “out of the box" functionality as much as possible, especially in the initial project release.
- Avoid creating custom HTML screens or adding buttons. . Always use the “Auto Generated
HTML" feature for harness sections and flow actions. - Always use the standard rules,
objects, and properties. Reporting, Urgency, Work Status, and other built-in behaviors rely
on standard properties. - Never add a property to control typical work or for managing the
status or timing of work. 4. Limit Custom Java o Avoid Java steps in activities when standard
Process Commander rule types, library functions, or activity methods are available. o
Reserve your valuable time and Java skills for implementing things that do not already exist.
D ACTTVITV Irn(‘oIxI—Pl—NoneP4AWoIh~PolI1 -ciamm. -racy st. -vs Patna: houtm seat: in
(aid 2) ksaflsou ‘4 Sn L D 1-no-: Vrwrnclor lava Q,1-um. 7 cumin: dubs: InKoIp~IlvO| oUI¢9I.
~Wui~IoI(v fl Acn/ m lnscon Pl»Hoi»ePA»| VDvl Polity aflavmnislary ma : ) ouognn L. snug:
Q, and 1 I. D Lime mam >-on cum: , Pnonhtn I 2. D Hap he rewuzem rung: , again. -sci I ; 9
radre vnorrucmv ravage , :anm-5cv ‘ I. D v H-ave-coma: -a: -u Coin! Qtflunjlfiun Wccarrscs ,
5 D Dutch he an page can-go , vagcaama ‘ V Al I Al 9:: (A 5. Build for Change TM - Identify
and define 10-100 specific rules that business users own and will maintain. - Activities should
not be on this list. Use other rule types for business-maintained logic. 193
27. 27. I Con? ‘i: ::. it S“o. '.Cc"io': :crz: -55 E: )a: nE>cel 1 Conditions Appraised Ilarkzt Value
Area < EOOIIHIO '1 250) > I >U. ’t. *JJ < )J. U.“/ J < l§‘)J 6. Design Intent-driven Processes o
Your application control structure must consist of flows and declarative rules, calling activities
only as needed. o Use flow actions to prompt a user for input. - Present fewer than five
connector flow actions for any individual assignment. If you need more than that, you need to
redesign the process. - Create activity rules that implement only a single purpose to
maximize reuse. Insiorp-PL-No ncPA~wor1i-Polcy RIfV0|(W0ItlXli}!1I I I0 WorIll1»>(v'! I /
Work Baukd R1: nvoh(Wor$d‘. crn.10("-"u ! llprtiln <i. n-is End 7. Create Easy-to-Read Flows
o Your flows must fit on one page and must not contain more than 15 SmartShapes

(excluding Routers, Notify shapes and Connectors) per page. - If a flow has more than 15
SmartShapes: o Create a subflow. o Use parallel flows to perform additional functions 194
28. 28. I1.LuIp' n_— mm. -»; i—vv in my DA_V '1’ . y Y Ugul up up, -.i. r.. -i Cu-. <tO‘.9§. .pn§
mm . m Up-‘arc Hut um nmu-u(iy. ma v Inc’: . s A(; vI. :iv' to ,2 um -r£. ip. .-1, }; .,.1.. .i. ioo'~.
lmplitvyvr Int; s. -puo. ..ci»-4.: t(01- (IIPI am. .. 0 lg. ’ v. .-.2 (1 mm ”i’l’V (LIOVOG-Aiavy.
IDOL. V H-‘I, )0 ‘v V i. .-: . 4- i -. ' u, .1.. :.-<. i.n. n Luw,7D’. . . ! . . Y , 7 N. .. l. ... ,. . .. . ... ... ...
... ... WWW. P-—«, A<-Woilhu-i AuiA:1Ii‘Vr#, m‘: rv. fv rv PvL'(c1’oii-: (,1C)’: _ ! i; pdnv sutin (
- 2 in- 8. Monitor Performance Regularly - Evaluate and tune application performance at
least weekly using Performance Analyzer (PAL) to check rule and activity efficiency. - Use
PAL early to establish benchmarks. Compare these readings to follow on readings; correct
application as required. 9. Calculate and Edit Declaratively, Not Procedurally - Whenever the
value of a property is calculated or validated, you must use declarative rules wherever
appropriate. o Create a Declare Expressions rule instead of using a Property-Set method in
an activity. o Use a Declare Constraints rule instead of a Validation rule. 195
29. 29. ﬂ ocumu ua-azssious ii-. .c. .p n Mo: -oeI‘A Hall n. .u. y . .s. ... ..rr». .m. ... . lxpn-unns
fusions Gunship IQ-V ‘F19 F’ "' . ..i. .i. . . .i. . 2. I1 , .. at '~lll! IIl‘iD'.7Vl' liirii-. Surat
Pns£3urs0.Car'wmu1: ﬂ | L'lNllVIrn(orpPI I-ooe'A no H1047 o. ;.. n.ur. .m. .m nun 1) kmpna -
—. any-.9. Q um-a I. D 'x1vaur. '-uwxrwnlnurcus Gum "nun. -'x: S, /umur-on-nvsa Y aoo. -
«vukvdaim i-ucnnnoacunoaukv . nmma—oE on-ominvmea 9 Cs/ v.0-. '|: ®'J ‘ KG‘ fur: -
"1LIC—*A'>u"i r. n:i. w:: : c. ~4.-. ~,. —~. ‘ (5 Q 10. Keep Security Object-Oriented, Too -
Your security design must be rule-based and role-driven based on who should have access
to each type of work. - Never code security controls in an activity. - Use the standard access
roles that ship with Process Commander only as a starting point. - Use Ru| eSets to segment
related work for the purpose of introducing rule changes to the business, not as a security
measure. 4. What are the basic Pega classes? Work-, Data- etc. — You can find this easily
in PDN / Pega Help. A base class is one of twelve standard abstract classes that are
immediately below the top class in the hierarchy. This top class, known as the ultimate base
class, is identified by the symbol @baseclass. The three base classes of greatest interest to
application developers are Data-, Assign- and Work-. The base classes are: Base class
Description Assign- Assignment instances, each identifying a step in a workflow that requires
human input or work by an outside organization, person, or system. Code- Classes that
directly reference server program code. Pages belonging to classes derived from the Code-
base class exist only temporarily in memory, and are not saved in the PegaRULES
database. Data- Parent class of concrete classes containing reference data, including data
for system administration and security. DCOMSOffice— Reserved. DocletGenerator-
Reserved. Embed— Defines the structure of pages embedded within other pages. Pages
belonging to classes derived from the Embed— base class cannot be renamed or directly
saved. 196
30. 30. Wk Append-only instances record the change history of objects in another class. lndex—
Secondary access keys defined to provide fast retrieval of other instances. Q Instances that
record associations between two objects. Q9; Parent of concrete classes containing
cumulative logs of important system—wide events. PegaAccel- Parent of special classes that
support the Application Accelerator tool. Rule- Rule types, for defining applications.
System— Contains operational status information about the entire Process Commander
system. Work- Work objects, covers, and folders. Custom classes that are immediate child
classes of the ultimate base class are known as top-level classes. These are different from
base classes. V V V V Types of classes - Abstract and Concrete, explain about them. — You
can find this easily in PDN / Pega Help. An abstract class is a rule (an instance of the Rule-
Obj-Class class) created to support the definition of rules, including other classes. Such rules
can be inherited by subclasses of the abstract class. Rules with a class as a key part (such
as properties, activities, flows, models, and so on) can apply to an abstract class. In the
Class Explorer display, a Qlshape identifies an abstract class. A class that is not abstract is
concrete. Unlike abstract classes, concrete classes can have instances stored in the

database. A selection on the Class rule form determines whether a new class is abstract or
concrete. An abstract class can be a child — a subclass — of a higher abstract class. A dash
or minus character (-) as the last character in the class name indicates an abstract class. For
example, the Work-Cover- class is an abstract class, while Work-Cover-General is a
concrete class A concrete class can have instances stored in the database. In contrast, an
abstract class cannot have any instances. A selection on the Class form determines whether
a class is concrete or abstract. On the Class Explorer display, the "I3shape identifies a
concrete class. For all but a few classes, a dash or minus sign (-) character as the last
character in the class name indicates that the class is abstract and can contain other
(abstract or concrete) classes. For example, the Rule- class and Work-Cover- class are
abstract classes, while Work-Cover- General is a concrete class. Concrete classes usually
appear near or at the bottom (leaf nodes) of the class hierarchy, but may appear anywhere
below the top level. 197
31. 31. 6. Kinds of inheritance - Pattern/ Direct. which takes precedence and how do you let
Direct take precedence (by un-checking the checkboxin Class form) — You can find this
easily in PDN / Pega Help. Inheritance is a primary benefit of object oriented technology.
Process Commander offers multiple types of inheritance that can maximize reuse of your
rules while allowing localized overriding as appropriate. Also called polymorphism,
inheritance allows a rule created for one class (possibly an abstract class) to be applied to
other classes that inherit from it: Process Commander provides two types of class
inheritance, both of which allow rules of ancestor classes to be inherited: - Directed
inheritance — Allows you to name a parent class, choosing a name that's not related to the
name of this class - Pattern inheritance — The system determines the name of the parent
class is based on an initial portion or substring of the name of the class. Segments of the
name are delimited by a dash (-) character. Pattern inheritance: During rule resolution,
pattern inheritance causes a class to inherit rules first from classes that match a prefix of the
class name. Select the Find by name first (Pattern)? check box on the Class rule form to
instruct the system to use pattern inheritance for this class. The algorithm For a class using
pattern inheritance, the following is a simplified description of the rule resolution algorithm: 1)
Search each class formed by repeatedly truncating the original class name, stopping if the
needed rule is found. 2) If the pattern search finishes without finding a rule, go back to the
original class and use directed inheritance to find the parent of the original class. 3) If the
parent class identified in step 2 was searched during step 1, skip it and skip to step 5. 4) If
the parent class was not previously searched, search it. Stop if the needed rule is found. 5) If
not found, determine whether the parent class uses pattern inheritance. If so, repeat this
algorithm, starting at step 1, with the parent class. Othen/ vise, identify the parent of the
parent. Continue at step 7. What kinds of Declarative rules used with some e. g. — You can
find this easily in PDN / Pega Help. 6 Allow for dynamic processing of property values 0 Do
not need to be explicitly called 0 Declarative rules need / should not be referred from any
rule. They are always in force 198
32. 32. Declarative rules will be in force automatically and hence you need not call these rules
explicitly Types of Declarative Rules: 6 Constraints rules (Rule-Declare-Constraints) Declare
Expression rules (Rule-Declare-Expressions) Declare Index rules (Rule-Declare-Index)
Declare OnChange rules (Rule-Declare-OnChange) Declare Trigger rules (Rule-Declare-
Trigger) 9009 I)Constraints rules : Create constraints rules to define and enforce comparison
relationships among property values. Constraints rules can provide an automatic form of
property validation every time the property's value is "touched", in addition to the validation
provided by the property rule or other means. The system evaluates constraints
automatically each time a property identified in a constraints rule is changed. This technique
is known as forward chaining. Where referenced No other rules explicitly reference
constraints rules. When you save a constraints rule, Process Commander enforces it
immediately and thereafter. The system automatically adds a message to any property that
is present on the clipboard and fails a constraint Delegation After you complete initial

development and testing, you can delegate selected constraints rules to line business
managers. The Constraints tab of the Constraints form provides managers with access to the
fields most often updated. 0 Provide bounds(limits) on the value that a property can hold. For
example: 0 Property cannot be negative 0 Property cannot be greater than a certain value «’
Can target more than one property in a single constraints rule 2) Declare Expression rules:
Purpose Use Declare Expression rules to define automatic computations of property values
based on expressions. 199
33. 33. '-'~‘rDon‘t confuse Declare Expression rules with simple expressions. Expressions — a
syntax that includes constants, function calls, operators, and property references — are used
in many situations in addition to Declare Expression rules. Forward chaining Often, Process
Commander recomputes target property values automatically each time any of the other
input values in the expression change, or when a value for this property is accessed,
changed, or using other criteria. This technique is known as forward chaining. For example,
you can declare that a property named Order. TotalPrice is always the sum of: -
OrderLine(1). TotalPrice - OrderLine(2). TotalPrice - OrderLine(3). TotalPrice and so on. You
can also declare that OrderLine(). TotalPrice is always equal to . Quantity multiplied by.
UnitPrice. Backward chaining In an activity, the Property-Seek-Value method can access the
computational relationships among properties in a Declare Expression rule to identify source
values needed to compute a missing property value. This technique is known as backward
chaining. For example, consider a single Declare Expression rule defining Circumference as
3.1416 times Diameter with Change Tracking set to Whenever used. This rule can be used
in either fon~ard- chaining or backward-chaining mode: - If step 3 of an activity causes the
value of Diameter to be set, an updated value for the Circumference property is available at
the start of step 4 (fon/ vard chaining). - If step 1 of another activity uses the Property-Seek-
Value method with Circumference as the target, and no value for Circumference is found, the
system seeks a value for Diameter (backward chaining). Delegation After you complete initial
development and testing, you can delegate selected Declare Expression rules to line
business managers. The Expressions tab of the form provides managers access to the ﬁelds
most often updated. ** For example, we can declare a R-D-E for property called “Area" , so
that whenever it's value is accessed from clipboard, it's value is equal to the product of
properties, Length and Width. Once the R-D-E is saved for the property “Area", any change
to a Length or Width value, regardless of how it occurs, causes an immediate recomputation
of the value of the Area property. 200
34. 34. 3) Declare OnChange rules: Purpose Create Declare OnChange rules to run an activity
automatically at activity step boundaries(limitations) when the value of a specified property
changes. This capability provides a form of automatic fon/ vard chaining. For example, a
Declare OnChange rule can update a year-to-date counter property (an integer) to track how
many times a work object status changed in value. Another Declare OnChange rule can
compute the average dollar amount of work objects entered by a work group, in real time.
For example If you specify more than one property, they all must be on same page. For
example, we can create a declare onchange to call an activity that send a mail to employee
when ever either HRA or Basic or SpecialAllowance are changed Where referenced No
other rules explicitly reference Declare OnChange rules. After you save a Declare
OnChange rule, Process Commander immediately thereafter runs it when and as needed
nu-wnuuxmwmuu u. --rm-nus —-an : I. . .~ -<. l-.1-v. w»~a-uuswn -son: . ‘aura vno-~nu~: -
um ac: -k: , | Nun 4) Rule-Declare-Index: Declare Index rule are defined for defining criteria
under which Process Commander automatically maintains index instances for faster access.
An index can improve search and reporting access for properties that cannot be exposed as
database columns because they are embedded within an aggregate property. 8. Function
alias. — You can find this easily in PDN / Pega Help. Use an alias function rule to define
prompting for a function rule for users who maintain decision rules. The alias rule provides
an optional natural-language description and prompting that supports certain selection lists
on decision rule forms. 201

35. 35. '-'~‘1’Comp| ete and test the function rule itself before defining a function alias rule that
references it. “. -‘! You cannot define an alias for a function rule that returns a complex Java
type (that is, a type other than a Java. lang. String type or a primitive type such as int).
Where referenced Alias function rules are useful for functions that managers or less
technical developers may use frequently in decision tree rule, when condition rules, Declare
Expression rules, and constraints rules. 9. Utility functions and e. g. of where it is used . This
was asked as an example of Reusability guardrail, question #2. - — You can find this easily
in PDN / Pega Help. http: //pdn. pega. com/ DevNet/ PRPCv5/kb/25016.aspReusable
functions are implemented as instances of the Rule-Utility-Function rule type You can call
these functions in expressions and activities. Rule-Utility-Function instances, when
generated into Java, are public static Java methods which are grouped into libraries (Rule-
Utility-Library rule type). 10. Kinds of performance tools used. - http: //pdn. pega. com/
devnet/ PRPCv5/kb/24219.asp PAL : Use the Performance tool to understand the system
resources consumed by processing of a single requestor session, or the SQL statements
sent to the PegaRULES database by the requestor session. Process Commander always
accumulates cumulative resource statistics for the Performance tool. Use the tool to display
these statistics, and to identify incremental resources (in the delta rows) consumed by your
processing. Because this feature displays existing data, its use does not degrade
processing. The Performance tool is sometimes known as PAL. 11. Question on how to copy
rules from one ruleset to another’? Mention the Ruleset maintenance wizard and specify how
you do it. Have list views, get list of rules in each, check if any rules are checked out etc.
Please take a look at the steps in this wizard. (This question was asked in most of his
interviews) -> Check all the items under Tools -> Rule Maintenance Copy a Version of a
RuleSet to another RuleSet name To copy the contents of a RuleSet version to another
RuleSet name: 1. Select Tools > Rule Management > Copy/ Move RuleSet. a. Move from
the left box to the central box the RuleSet version you want to copy (the Rule Management
wizard allows you to copy versions, but not full RuleSets). Select the Copy radio button. 202
36. 36. (9 -32.: -, {)u: ».r_~ EZNIC3 r«. .». »-; »_-» :1 2:. Yo mt n. _.». ~£o. ~1 Av-lnblo Soul :0 I‘-
luhiotxn) 0: dc M 91 ocodonu nluvlng Ilosotopy 333:’! b. On the right side of the form, specify
the name and version of the RuleSet you wish to copy to. Specify whether source rules are
to overwrite any existing rules in the target RuleSet. Target Ruleset Information NOITD
‘torAdvanocdl‘1anngemc1l: A Version jo14J14J1 ‘K When Source miles conflct with Target
Rules. Ovcrw| "rc Target ’ (5) True 0 False 9 Click Next. A review form appears. If all is as
you want, click Next. . When the process is complete a report will appear. You can review
the list of rules that were copied and those that were skipped. You can export this summary
for further review. When you are finished, click Done. 0. 12. Can a work user access the
clipboard and if so what can he/ she see? -> It's based on the role / privilege. Find out the
role / privilege associated for clipboard. 13. Data-Party classes? Gov, Div, Org etc. — You
can find this easily in PDN / Pega Help. > Work party data classes > You can use data
classes derived from the Data-Party class to organize your role and work party data into
meaningful categories. Using sub-classes enables you to produce reports based on their
classes. You can also associate each class with a model that defines the initial properties
you want to include when you design the PartyDisplay section rule. The system is delivered
with five standard Data-Party sub-classes as follows, which include example definitions for
each: > Data-Party-Com — Business organizations 203
37. 37. Data-Party-Gov — Government organizations Data-Party-Operator— Process
Commander users (who have Operator IDs) Data-Party-Org — Nonprofit organizations Data-
Party-Person — Parties who are not Process Commander users VVVVV You can create
your own sub-class and an associated model. 14. What is used for a non numeric subscript?
Value group/ page group — Go through the property rule details. Value group/ page group —
Go through the property rule details. Page Group and Value Group members/ properties are
retrieved/ identified by using non numeric subscript called keys For Example: Single property
—, Page —, Value List —, Page List--, Value List—, Page Group — Address() Phone street

city Page Zip Address(1) Address(2) Phone(1) street street Page city city List Phone(2) Zip
Zip Address(Home) Address(Work) Phone(Home) street street Page city city Group
Phone(Work) Zip Zip 204
38. 38. 15. Agent calls an activity to start a flow. There's an error and activity doesn't start, what
could be the possible reasons and how will you debug? Check if the activity‘s 'Authenticate‘
checkbox has been checked. Agents are unauthenticated/ guest users. Also check Pega
logs. 16. Which frameworks have you worked on? CPM is used in this project. 17. Question
on Smart Dispute how Q&A kind of questions have been done in SD? 18. Done any CTI
integration? CTI will be used for a future phase. 19. What is REST? Protocol used in HTTP.
Please read on general REST features. REST stands for Representational State Transfer. (It
is sometimes spelled "ReST". ) It relies on a stateless, client-server, cacheable
communications protocol -- and in virtually all cases, the HTTP protocol is used. REST is an
architecture style for designing networked applications. The idea is that, rather than using
complex mechanisms such as CORBA, RPC or SOAP to connect between machines, simple
HTTP is used to make calls between machines. . In many ways, the World Wide Web itself,
based on HTTP, can be viewed as a REST-based architecture. RESTful applications use
HTTP requests to post data (create and/ or update), read data (e. g., make queries), and
delete data. Thus, REST uses HTTP for all four CRUD (Create/ Read/ Update/ Delete)
operations. REST is a lightweight alternative to mechanisms like RPC (Remote Procedure
Calls) and Web Services (SOAP, WSDL, et al. ). Later, we will see how much more simple
REST is. - Despite being simple, REST is fully-featured; there's basically nothing you can do
in Web Services that can't be done with a RESTful architecture. REST is not a "standard".
There will never be a W3C recommendataion for REST, for example. And while there are
REST programming frameworks, working with REST is so simple that you can often ''roll
your own" with standard library features in languages like Perl, Java, or C#. 2. REST as
Lightweight Web Services As a programming approach, REST is a lightweight alternative to
Web Services and RPC. Much like Web Services, a REST service is: - Platform-independent
(you don't care if the server is Unix, the client is a Mac, or anything else), - Language-
independent (C# can talk to Java, etc. ), - Standards-based (runs on top of HTTP), and - Can
easily be used in the presence of firewalls. Like Web Services, REST offers no built-in
security features, encryption, session management, QoS guarantees, etc. But also as with
Web Services, these can be added by building on top of HTTP: - For security, username/
password tokens are often used. - For encryption, REST can be used on top of HTTPS
(secure sockets). 205
39. 39. o etc. One thing that is not part of a good REST design is cookies: The "ST" in "REST"
stands for "State Transfer", and indeed, in a good REST design operations are self-
contained, and each request carries with it (transfers) all the information (state) that the
server needs in order to complete it. 3. How Simple is REST? Let's take a simple web
service as an example: querying a phonebook application for the details of a given user. All
we have is the user's ID. Using Web Services and SOAP, the request would look something
like this: <? xm| version= "1.0"? > <soap: Enve| ope xmInszsoap= "http: //www.
w3.org/2001/12/soap—enve| ope" soap: encodingSty| e="http: //www.
w3.org/2001/12/soap—encoding"> <soap: body pb= "http: //www. acme. com/ phonebook">
<pb: GetUserDetai| s> <pb: User| D>12345</ pb: User| D> </ pb: GetUserDetai| s> </ soap:
Body> </ soap: Enve| ope> (The details are not important; this is just an example. ) The
entire shebang now has to be sent (using an HTTP POST request) to the server. The result
is probably an XML file, but it will be embedded, as the "payload", inside a SOAP response
envelope. And with REST? The query will probably look like this: http: //www. acme. com/
phonebook/ UserDetai| s/12345 Note that this isn't the request body -- it's just a URL. This
URL is sent to the server using a simpler GET request, and the HTTP reply is the raw result
data -- not embedded inside anything, just the data you need in a way you can directly use. o
It's easy to see why Web Services are often used with libraries that create the SOAP/ HTTP
request and send it over, and then parse the SOAP response. o With REST, a simple

network connection is all you need. You can even test the API directly, using your browser. o
Still, REST libraries (for simplifying things) do exist, and we will discuss some of these later.
Note how the URL's "method" part is not called "GetUserDetails", but simply "UserDetails". It
is a common convention in REST design to use nouns rather than verbs to denote simple
resources. The letter analogy A nice analogy for REST vs. SOAP is mailing a letter: with
SOAP, you're using an envelope; with REST, it's a postcard. Postcards are easier to handle
(by the receiver), waste less paper (i. e., consume less bandwidth), and have a short
content. (Of course, REST requests aren't really limited in length, esp. if they use POST
rather than GET. ) 4. More Complex REST Requests The previous section included a simple
example for a REST request -- with a single parameter. REST can easily handle more
complex requests, including multiple parameters. In most cases, you'll just use HTTP GET
parameters in the URL. 206
40. 40. For example: http: //www. acme. com/ phonebook/ UserDetails? firstName= John&|
astName= Doe If you need to pass long parameters, or binary ones, you'd normally use
HTTP POST requests, and include the parameters in the POST body. As a rule, GET
requests should be for read-only queries; they should not change the state of the server and
its data. For creation, updating, and deleting data, use POST requests. (POST can also be
used for read-only queries, as noted above, when complex parameters are required. ) o In a
way, this web page (like most others) can be viewed as offering services via a REST API;
you use a GET request to read data, and a POST request to post a comment -- where more
and longer parameters are required. While REST services might use XML in their responses
(as one way of organizing structured data), REST requests rarely use XML. As shown
above, in most cases, request parameters are simple, and there is no need for the overhead
of XML. o One advantage of using XML is type safety. However, in a stateless system like
REST, you should always verify the validity of your input, XML or otherwise! 20. How do you
use XMLs in Pega? Obj, Parse etc. Parse XML: Use Parse XML rules with services and
connectors to map data from an XML text message into clipboard property values. Each
Parse XML rule contains an array of parsing instructions that let Process Commander
interpret an incoming XML document or message. The incoming message may arrive using
an e-mail protocol or by SOAP over HTTP protocol. The message may be a request for
service or a reply from a connector. Use the Application Explorer to access parse XML rules
that apply to the work types in your application. Use the Rules by Type Explorer to list all
parse XML rules available to you. XML Stream: Use this method to save the contents of an
XML Stream rule after stream processing completes as the value of a Single Value property.
The property value can then be mapped as output and conveyed to an external system. The
target property value is the XML text from an XML Stream rule (Rule-Obj-XML rule type),
after stream processing. Stream processing evaluates directives and clipboard references.
Parameters This method has three parameters: Parameter Description Proper“/ Name
Identify a Single Value target property to receive the value produced by stream processing. If
the property is on the step page, precede the property name with a period. If this property is
on a different page, include the page name in the reference and 207
41. 41. ensure that this page appears on the Pages & Classes tab of the Activity form.
XMLStream Enter the Stream Name key part of an XML Stream rule to process. XMLTWQ
Enter the third key part of an XML Stream rule to process. Cautions - AYou can't use this
method for a property that is also the target property of a Declare Expression rule. You can't
save the Activity form if such a conflict is detected. - 3Don‘t attempt to set the value of a
property that has a name starting with pz; changes to such properties are reserved. - ‘Use
the standard activity Work-. UpdateStatus — not this method — to change the value of a
work object status (pyStatusWork property). 21. UI development what all do you need to do?
Skins, portals, flow actions, sections, harnesses. Mention the Application Skin wizard and
other wizards used in Ul development. About Flow Action rules New Fon'n Help Setup Action
Security Pages & Classes HTML Histog More. .. Purpose A flow action rule controls how
users interact with work object forms to complete assignments. After selecting one flow

action, users may fill in a section of the form to complete (perform) the assignment. Where
referenced In a flow rule, developers can associate flow actions with connectors (arrows)
and with assignment tasks. At runtime, the flow actions associated with an assignment
determine the choices available to users as they perform the assignment. Controls j
Containers _ lllll , It - Basic E-| JV. ’.l_IT'i I I2 I X abc Label 0 l I h 208
42. 42. I, - Advanced 3 llll Short Descriptions Choose the wording for the Short Description field
carefully, so that it is meaningful in context to application users who must select one action
from the list. Starting each Short Description text with an action verb such as "Approve",
"Reject", "Send", or "Transfer" is often helpful to users. This is known as intent-driven
processing. On Perform work object forms presented with the default action section, the form
area created by a flow action normally appears in yellow, headed by an action list: Lcnalvc
thuuwcvlc - Add wart. .. ~| Description field appears as user-visible text in the action
selection list. Two other formats are supported. See Presenting flow actions — Comparing
three approaches. Access . The text in the Short Use the Application Explorer or User
Interface slice ( ) to access the flow action rules that apply to the work types in your
application. Use the Rules by Type Explorer to list all the flow action rules available to you.
Delegation After initial development and testing, selected flow action rules can be maintained
by line business managers rather than by application developers. The Form tab of the form
provides managers access to the fields most often updated. About Harness rules New
Layout Scripts and Styles Pages & Classes HTML Display Options Histog More. .. Purpose
Use harness rules to define the appearance and processing of work object forms used in
your application to create work objects and process assignments. Like section rules, HTML
rules, property rules, and others, harness rules define the structure, appearance, and
behavior of the forms used in applications to create and update work objects and
assignments. Process Commander includes more than a dozen standard harness forms for
entering, reviewing, updating, and processing work objects and assignments. Your
application can override the standard rules to extend and tailor them to specific needs.
Before creating or editing harness, section or flow action forms, set the Skin preference (in
the Run Process area of the General Preferences group) to the skin that application users
are expected to use. This provides the closest approximation during development of the
runtime look and feel of the form. ’-’~‘rBeginning with V5.5, you can use harness rules to
define composite portals, as well as work object forms. For this advanced special use, see
How to create a composite portal. 209
43. 43. Co ntrols Column Re eat Layout j Row Repeat — V &&t lllll , :1 - Basic E-urtu: -n . / 12 I }
abc Label 0 T I h URI A 0- I) Advanced 3 —‘ § ’ < '>h -O -- -— 1: . ... . 5 Applications Without
Work object forms Work object forms defined by harness rules are typical, but not required,
elements of a Process Commander application. Some business process management
applications use an external portal or external system and call Process Commander services
to create work objects, advance them through a flow, perform flow actions, and so on. The
Process Engine API is a collection of standard activities that apply to the Work- base class to
support such headless applications. Where referenced Each flow rule that creates a new
work object identifies a harness rule to capture initial information about that work object.
Standard activities that apply to the Work- class look (using rule resolution) for harness rules
with specific names, such as New, Perform, and Review. To display a work object form
defined by a harness rule, call the standard @baseclass. Show-Harness activity in your
activity. User interaction with Work object forms For basic information about using work
object forms defined by harness rules from an application user perspective, see Using work
ob'ect forms. Rule forms NBeginning with V5.5, a few rule forms are defined through harness
and section rules. This capability is reserved. If your application includes custom rule types,
use the Form Builder tool, not harness rules, to define forms. Access Use the User Interface
slice (l “) or Application Explorer to access the harness rules that apply to the work types in
your application. Use the Rules by Type Explorer to list all the harness rules available to you.
210

pega training with project level Trainingwhatsup@8142976573

pega training with project level Trainingwhatsup@8142976573

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (16)

Similar to pega training with project level Trainingwhatsup@8142976573

Similar to pega training with project level Trainingwhatsup@8142976573 (20)

Recently uploaded

Recently uploaded (20)

pega training with project level Trainingwhatsup@8142976573