You are on page 1of 25

BPM and BRE

• A cover is a work object that is also a parent to one or more related work objects. Typically one work party — such as the customer
party — is present in the cover work object and also present in all of the covered work objects associated with the cover. The
covered work objects are the children in a parent-child relationship.

• By default, the system prevents the resolution of a cover work object unless all of its "member" covered work objects are resolved.

• Ex: Building construction (Cover) -> a) Wood work (WO) b) Plumbing (WO) c) Painting (WO). If all 3 works done (Resolved) then
we can say Building (Cover) is ready to join.

• Cover is a work object that is an instance of a concrete class derived from the Work-Cover- abstract class. Your system
includes harness rules, flow action rules, and activities that support working with covers. The covered work
objects can be of differing work types. However, the work type of the cover and the work type of the covered
objects must all belong to the same work pool.
• The covered work objects can be of differing work types. However, the work type of the cover and the work
type of the covered objects must all belong to the same work pool.
• 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.

• The standard ticket rule Work-Cover-.AllCoveredResolved 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.

• The standard list view rule Work-.WorkInACover.ALL displays the urgency (pyUrgencyWork property), work object ID
(pyID), subject (pyLabel), and status (pyStatusWork) fields as columns, without sorting.

• The standard local flow actions Work-.AddToCover, Work-.AddCovered, and Work-.RemoveFromCover allow user
management of cover contents.

• The Work-.NewCovered harness rule supports entry of a new cover and cover members.

• Activities Work-.AddCoveredWork, Work-.AddCovered, and others support operations with covers.

• One cover work object may cover multiple other work objects. When any one of the covered work objects is
opened, Process Commander by default uses a conservative approach and acquires locks on the covered work
object and the covering work object. This ensures that data can be updated in both objects with transaction
integrity.
• Customize the activity DetermineLockString property-set and update it with no locking
• A flow rule — an instance of the Rule-Obj-Flow rule type — is a network of shapes representing tasks and connectors (directed
arrows), each with associated parameters and values. Flows govern: How work objects are created ,How they progress through one
or more flow executions ,How they become resolved (completed)

• Flows are the fundamental rule instances that represent business processes, identifying who works on a work
object in what sequence, what decisions and processing occur automatically, and many other aspects of the
business process.

Sunday, August 21, 2011 1


BPM and BRE

• Some applications don't require users to interact with work object forms. Flows that implement straight-
through-processing operate without user input. External portals and systems can execute flows through
Active Server Pages, JavaServer Pages, Service Portlet or Service JSR94 rules, or other means. Informally,
these are known as "headless" BPM applications. A collection of standard activities known as the Process
Engine API simplifies building such applications.
• Application developers use Microsoft Visio to create, edit, and evolve a flow. Process Commander uploads the resulting VSD file,
including the Shape Parameters details from the workstation. Both the diagram image (a JPG file) and the rule details are saved with
the flow rule.

• You can't test a flow rule that has Availability set to No/Draft. You can test the flow rule if the Availability is set to Yes, even if the

Visio DRAFT mode ( ) is in force, indicating that not all the activities, properties, or other rules are yet defined.

• At runtime, a user can start the execution of a flow by entering a new work object. The system examines the property pyFlowName,
in the model instance for the class, to determine which flow to start.

• We can think of the flow operating on the data (properties) in the work object until the flow finishes or the work object becomes
resolved

• The system generates a unique work object ID for a new work object. (This occurs for starter flows, those for which the Creates a
new work object? box on the Flow form is selected.)

• Flow creates assignments for human users reflecting the need for more facts, judgments, and places the assignment into an
appropriate user worklist or workbasket. After a user (or in some cases an agent or external participant) perform an assignment, the
work object progresses farther through the flow.

• The Process Explorer tool presents — for the currently selected application — starter flow rules and the subflows they call in a
graphical form.

• A flow rule that contains no assignments, and so can execute from start to end without human input, is known as a straight-through
process.

• A flow rule that consists only of assignments or decisions and meets other criteria is known as a screen flow.

• A flow that creates a new work object is called a starter flow.

• Processing of a subflow is synchronous, meaning that the calling flow execution pauses for the duration of the subflow. When the
subflow execution reaches a Flow End shape, the calling flow can continue.

• The Split/Join facility ( ) supports such asynchronous operation, by allowing processing of two or more subflows to proceed in
parallel. For ex: Loan processing: 1) Loan Credit Process 2) Fraud checking .Both are different subflows. Eg: Standard flow
Work-.ParallelWork

• Use a Split-ForEach ( ) shape to iterate over the pages of a Page List or Page Group property. For each page, you can
conditionally start a flow execution for the work object. Processing can resume after any one, or all, of the subflows end. Eg:
standard flow Work-.StandardApprovalsAll

• We can't use the Split-ForEach shape to create work objects. At runtime, this shape process the work object's
embedded Page List or Page Group properties; the embedded pages must exist before the Split-
ForEach shape is reached.

Sunday, August 21, 2011 2


BPM and BRE

• A Spin-Off task ( ) starts asynchronous execution of a different flow, on the same work object or a
different work object. Processing of the current flow does not pause or wait for results from the other flow.
• Use the Flow shape rather than a Spin-off shape to start a synchronous flow execution, in which the current flow execution pauses
while the subflow executes.

• Identify the objects the flow rule is to update. Select:

1) On Current Work Item to continue processing on the current (unresolved) work object in the next flow.
2) On Another Work Item to start processing on a different work object.
3) On Embedded Page to apply this flow to an embedded page.

• Users can select the standard flow action Work-.AddFlow, Work-.AddCovered, or Work-.AddtoCover to start a new flow execution.

• The integer property @baseclass.pxFlowCount indicates how many flow executions are in process for the work object.

• The Page Group property @baseclass.pxFlow contains a page of facts about each execution:

1) pyFlowType — Second key part of the flow rule

2) pxAssignmentKey — Key of the current assignment instance for this flow execution. typically an instances of the Assign-Workbasket
or Assign-Worklist class.

3) pyLastFlowStep — Internal name of the most recent shape or connector processed

4) pyNextFlowStep — Internal name of the next shape or connector to be processed

5) pyFlowParameters — A classless page containing parameters used to start this flow

• As a best practice, ensure that everyone in your development team is using a common version of
Visio. Process Commander operates identically whether you use Visio 2002 or Visio 2003 (also
called Visio XP).
• Flow rules containing too many shapes can introduce complex, difficult-to-debug processing into
your application. As a best practice, SmartBuild guardrails recommend limiting a flow rule to
contain 15 or fewer shapes, not counting Notify and Router shapes. If your flow grows to contain
more than 15 shapes, revise the flow to call or branch to subflows to handle continuations, special
cases, or non-mainstream processing.
• You can save and run a flow rule in draft mode in systems where the production level is set to a value less than 5.

• After saving a flow rule, review carefully any shapes that turn gray. You can save and execute a
flow rule that contains unreachable shapes, but the tasks corresponding to the unreachable shapes
will never be performed. As a best practice, delete the gray shapes or add a comment as to why
they are present.
• Include tickets and utility tasks to accommodate cancellations, rollbacks (sometimes called compensating transactions), errors, and
similar exceptions.

Sunday, August 21, 2011 3


BPM and BRE

• Choose likelihood values that are initial guesses. After the flow is in use, click the Flow Analysis button on the
Design tab to obtain statistics for comparison.

• Activity rules provide you with one way to automate the processing of work using a procedural, program-like
approach, without requiring Java skills or manually entering Java code. An activity is presented as a series of
steps, with some of the same features as an object-oriented programming language—such as iterations or
conditions.
• Accordingly, use activities only when there are no other, more appropriate rule types. For example, instead of using a series of
activity steps, use a Declare Expression rule to calculate declaratively, rather than procedurally. Similarly, use a when rule, decision
table, map value rule, decision tree rule, or parse rule whenever these rule types capture the business requirements well.

• Don't create an activity in your application when you can call a standard activity to perform the needed
processing.
• When writing activities, keep the following best practices in mind:

Keep activities short. Limit activities you create to fewer than 25 steps.

Limit hand-coded Java. Avoid Java steps in activities when standard rule types, library functions, or activity methods are available.
Reserve your valuable time and Java skills for implementing things that do not already exist.

• In V5.4 and earlier releases, iteration within an activity is limited to a single step. If your processing need
requires two or more steps, you must make a separate activity and include the Call statement in the original
activity.
• Authenticate? Select this check box for all but those specific activities that guests
need to run. In most cases, clear this check box if the activity is for an agent. Agents
are not true authenticated users and by default cannot run activities that are restricted
to authenticated users. However, this check box is ignored by agents for which the
Bypass activity authentication check box (on the Security tab is checked; they can run activities
regardless of the Authenticate? value.

Sunday, August 21, 2011 4


BPM and BRE

Shap Description
e

Assignment — Creates an assignment at runtime associated with work object in a workbasket or worklist. See Assignment tasks.
After you enter an assignment task, you can create an associated Router task.

Optionally, after the assignment task is defined, you can associate a service level rule with it. A clock appears on the diagram, as
shown here. See Associating a Service Level with an Assignment.

Assignment-Service — Waits for an external callback from an external system using Service BPEL rules. See Assignment-Service
task.

FlowStart — Identifies the start task of this flow. See FlowStart tasks.

Comment — Adds explanatory text comments anywhere on the flow diagram. Comments do not affect execution of the flow. See
Comment tasks.

Connector — Associates a task in the flow with another that may follow the first task. Connectors leaving assignment tasks may be
flow actions. Connectors leaving other tasks may be when conditions. See Connectors and Flow Actions.

Decision — Identifies an activity that can make an automated decision about the progress of the work object through this flow. See
Decision tasks.

FlowEnd — Marks the end of the flow. See FlowEnd tasks.

Fork — Supports automatic selection of one connector from two or more. See Fork tasks.

Integrator — Identifies an activity that can connect to an external system to send or receive data. See Integrator tasks.

Notification — Notifies a work party by e-mail or correspondence about the status or progress of this work object as the assignment is
created. See Notification tasks.

Router — Sends an assignment be sent to a user, workbasket, or agent other than the current user. Associate a Router task with an
assignment task. This activity determines which worklist or workbasket is to contain the assignment. See Router tasks.

Spin-off — Starts a new flow execution and does not wait for its completion. See Spin-off tasks.

Split-Join — Sends the work object to two other flows, both of which must complete before the current flow resumes. See Split-Join
tasks.

Split-ForEach — Performs an operation or test on each element in a repeating group. See Split-ForEach tasks.

Pools and swim Lanes — Identifies and groups tasks performed by separate organizational units within one division. See Pool tasks.

Ticket — Marks a business exception that might arise at any point in the flow, such as a cancellation. See Ticket tasks.

Sunday, August 21, 2011 5


BPM and BRE

Utility — Specifies an activity to run at that point in the flow to perform automated processing without any user assignment. See Utility
tasks.

• Flow processing of a work object normally pauses when it reaches an assignment shape until a user completes the assignments.

• Add an assignment task for each place in the business process that requires human judgment and input.
• For every assignment, add at least one flow action. The assignment normally appears on the worklist of the
user who executes the flow.
• Work-.WorkList — Causes the assignment to be placed on the worklist of the current operator (or of another operator identified by a
Router shape). Creates an instance of the Assign-Worklist class.

• Work-.WorkBasket — Causes the assignment to be placed in a workbasket, determined by an associated Router shape. Creates an
instance of the Assign-Workbasket class.

• Work-.External — Starts the directed Web access feature, sending a temporary assignment by e-mail to a party identified in the work
object who is not an interactive Process Commander user.

• Work-.Agent — Sends the assignment to a background process rather than to a person (rarely used, similar to WorkBasket ).

• Another standard assignment activity Assign-.Connect activity is used internally when creating an instance of the Assign-Connect
class and to support BPEL processing. Do not use this for assignments directly.

• Select one or more local flow actions that are to be available at runtime from the assignment.

• For each work object, the system computes the sum of these cost values for the specific path it takes through the flow rule. A
Declare Expression rule records this in property Work-.pyTotalFlowActionCost.

• For example, you may want to define and include local flow actions that let users bypass approvals, exceed normal limits, cancel
assignments, and so on.

• At runtime, the system presents available flow actions in a selection list, with connector flow actions
(sorted by decreasing likelihood) appearing above local flow actions.
By default, when a flow execution completes processing for most shapes, Process Commander automatically adds an instance to the work
object history.

• Execution of the standard Utility activity Work-.AddHistory, and other activities that call the History-Add method for a work object can
add instances to work object history.

• For example, an integrator task can connect to a customer master database to retrieve account balances or
verify account numbers and status. Integrator tasks use activities (with Connect as the Activity Type) that call
connector rules (Rule-Connect- rule types).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.

Sunday, August 21, 2011 6


BPM and BRE

• The standard flow rule Work-.ConnectionProblem provides a default approach to exception handling.A
problem flow execution (or problem flow for short) is a list report of a paused flow rule execution for a
work object. A problem flow can be caused by many different conditions, relating to the flow rule, the
properties in the work object, capabilities of users, and other data.
• By default, privilege ReconcileProblemWork is listed in the Access of Role to Object rule for the role
PegaRULES:SysAdm4.@baseclass, which enables these operators to view reports that contain all flow and assignment errors.

• These list view reports include ProblemAssignments, ProblemFlows, ProblemAsssignmentsForCurrent Organization,


ProblemFlowsForCurrentOrganization, and so on.

• When it detects a problem flow, Process Commander by default starts the standard flow Work-.FlowProblems (using the same work
object ID).

• We can override the standard routing activity Work-.toProblemFlowOperator in each application to send these to a different worklist
or to a workbasket.

• The conditions cause a problem flow execution to start:

The flow rule references a rule that does not exist, or a rule that a user (or agent) executing the flow lacks RuleSets, versions,
access roles, privileges, or other prerequisites to execute. Examples: an activity, service level, decision tree, harness, map value, or
subflows.

The flow rule references a data instance that does not exist. Examples: workbasket, operator, organization, work group, access
group.

The flow execution is stuck, in that following a decision shape, none of the outgoing connectors evaluate to true.

An activity has failed, or a connector rule has failed or timed out.

The work object contains invalid data that causes one of the above conditions.

The database, hardware, network, or system software has failed.

• For flows created or edited with V5.5 or later, the Router shape is optional. If you prefer, you can
record the Router activity directly in the Assignment shape or Router Pool shape ( ) properties
panels.

These activities apply to the Work- class but are not part of the Process Engine API.

Full Name Purpose


Work-.Action Creates simple correspondence.
NotifyQuick
Work-.AddCovered Creates a new cover work object and performs a Commit method, which saves the work object and releases all locks.
Use Work-.AddCoveredWork rather than Work-.AddCovered in situations where the Commit method is not wanted
until later.
Work-.CloseWorkItem Closes the work object, releases the lock and sends back HTML code that closes the work IFRAME.

Work-.CopyAttachment Makes a copy of (the most recent edition of) an existing attachment, in a different attachment category.
To
NewCategory
Work-.CorrUpdate Updates correspondence.
Work-.DoClose Executed when the operator clicks the close button on a work object form. Calls Work-.CloseWorkItem.

Sunday, August 21, 2011 7


BPM and BRE

Work-.getFlow Identifies the operator (by default Administrator@org.com) who receives assignments for flow problems. See flow
ProblemOperator problems.
Work-.GetNextWork Supports the Get Next Work button on the Confirmation harness form. Retrieves an assignment from a user's worklist
or from a workbasket. Can be called by an agent. See Portal basics — Using the Process Work workspace for
advanced notes on this activity.
Work-.RandomSelectio Supports statistical sampling.
n
Work-.ResumeFlow Typically called when a service level deadline or goal is not met, this activity forces completion of an assignment and
advances the flow execution along a specified (connector) flow action.
Work-.StartNewFlow Starts an additional flow execution on the current work object.
Work-.WorkPartyRetrie Refreshes the party identity in a work object. Referenced in standard harness forms.
ve
These standard activities apply to a class other than Work-.

Full Name Purpose


@baseclass.ActivityStatus Presents a form when a top-level activity completes with presenting an HTML display. ("The operation completed
NoContentHandler successfully, but returned no content." with green checkmark.) See How to customize the activity success and
exception windows.
@baseclass.ActivityStatus Presents a form when an activity fails or an uncaught Java exception occurs. ("Please contact your System
ExceptionHandler Administrator ." with red X.) See How to customize the activity success and exception windows.
Code- Supports the Single Sign-on feature.
Security.AppAuthenticate
Code-Security.LogOff Ends a requestor session.
Data-Corr-.EmailSend Sends e-mail correspondence.
Data-Portal.ShowDesktop Causes the portal to be displayed after log in. Typically referenced in an Operator ID instance.

• For an activity in the Work- class or a class derived from Work-, the Activity Type field (on the Security tab) of an activity determines
whether it can be used in a flow shape. A value of Utility, Connect, Assign, Notify, or Route indicates that the activity can
be referenced directly in a flow task of the corresponding type.
• For flows created or edited with V5.5 or later, the Notify shape is optional. If you prefer, you can record the Notification activity directly
in the Assignment shape properties panel.
• Router Pool and Swim Lane shapes to organize and graphically identify a related group of task shapes that are performed within a
specific work context (typically a work group) or business purpose.
For example, an insurance claim application has one assignment instructing operators to collect customer information, another to
verify the information and calculate payments, and a third to issue payments and update financial records. You want each to have its
own work group and workbasket. You create a pool named Insurance Claim Process containing three swim lanes named CSR, Back
Office, and Fulfillment. Each lane has a router activity associated with the assignments within it. During flow processing, the router
assigns the work object to the appropriate workbasket inside the lane.
• You cannot attach a Router shape to an assignment in a swim lane.
• An activity executing anywhere in entire Process Commander application can set or raise this ticket by executing the Obj-Set-Tickets
method with this ticket name as a parameter.
• If the activity uses the TaskStatus-Set method to one of a few possible activity outcomes, the outgoing connectors can depend on
this Status value. For example, a utility activity might return the values "HIRE", "REJECT", and "WAIT"^ through a TaskStatus-Set
method. Using three connectors from the utility, one for each status value, simplifies the flow diagram by eliminating a fork or decision
shape.
• Select for an activity to be executed automatically by a Declare OnChange rule, Such activities must not use any
methods that directly change the properties or the database.
• Declare Expression rules do not evaluate during the execution of an OnChange.activity. OnChange activities
must not perform any forward chaining themselves.
• Select for an activity supporting locatable pages. These pages can be used to find pages referenced in a
when condition, Declare Expression, or constraints rule.
• A capability called locatable pages reduces the need for pages to be explicitly named in the rule. Locatable pages
can be used with these rule types:
Constraints (Rule-Declare-Constraints rule type)

Sunday, August 21, 2011 8


BPM and BRE

Declare Expressions (Rule-Declare-Expressions rule type)

When conditions (Rule-Obj-When rule type)

References to properties on a locatable page use the locate keyword in lowercase as a prefix to or initial portion of the page
name, as in:
locateCustomer.OrderAmount
At runtime, the system uses backward chaining and an activity with type Locate to find and (if necessary) add the proper
page to the clipboard. This eliminates the need for the developer creating the when condition rule to specify the page.

• A declarative page is a clipboard page created by execution of a declare pages rule (Rule-Declare-Pages rule
type).

• Declarative pages can improve performance and reduce memory requirements when
all or many requestors in an application need to access static information or slowly changing
information.
For example, a declarative page may hold last night's closing U.S. stock prices in a Value Group property indexed by ticker
symbol, so that the property reference Declare_Stock.Price("IBM") is the closing price for IBM shared. The first time each
evening (after the 4:30 P.M. New York market close) that a requestor attempts to access the page, the system automatically
loads the page with the latest end-of-day prices. The page can remain unmodified in memory until the next day's closing.

• Declarative pages are not created at system startup; they are created only when first accessed.

• Ordinarily, declarative pages do not persist; they are not saved to the PegaRULES database but are
reconstructed when next accessed and the previous version is expired.

• The Call method instructs the current activity to find and run another activity using Rule Resolution. After the called activity
completes, the calling activity resumes processing. The called activity can use its own parameter page, or share the parameter page of the
calling activity. Configure this by selecting the Pass the current parameter page? option in the method parameters. The main advantage of
being able to call an existing activity is reuse. Instead of rewriting the called activity's steps in the calling activity, you can reference the
activity.

• The Obj-Browse method searches instances of one class and copies specified properties onto the clipboard,
creating a list of instances, each on an embedded page.

• A completed Obj-Browse method is similar to a SQL statement of this form:


Select <FIELDS> from the <OBJCLASS> where <CONDITIONS = A VALUE> and place them on the <PAGENAME> page.

• You can use as selection criteria only those properties that are exposed as database columns. However, the method can retrieve
values of properties that are not exposed as columns, including embedded properties.

• The Obj-Open method returns a single instance stored in the PegaRULES database, or in an external database
table that is linked to an external class. The returned instance is then converted to a clipboard page. This method
differs from the Obj-Browse method by not allowing you to define search criteria; you must identify the key of the
instance.

• The Page-Copy method replicates the entire contents (all properties and embedded properties) of an existing
clipboard page to a new or existing clipboard page.

Sunday, August 21, 2011 9


BPM and BRE

• The Page-Remove method deletes one or more named pages from the clipboard.

• The Show-Page method sends an XML representation of the current page (as specified in the Step Page field)
to your browser window. This method is primarily used for debugging.

• @CurrentDateTime() is a standard function rule that returns the current system date and time

• .pyUserIdentifier property is set to the parameter defined on the Parameters tab of an activity.

• For more complex activities, the Clipboard tool and Tracer tool are valuable debugging aids.
Three tools support developers as they work with activities:

• The Clipboard tool lets developers examine and alter the contents of their clipboard.
• The Tracer tool provides powerful, detailed debugging for activities, even when run by others or in background.
• The Performance tool provides comprehensive statistics about resources consumed by a requestor, and system response

• Use the Branch instruction to cause the current activity to find another specified activity and branch to it
without a return.

• Use the Call instruction to cause the current activity find another specified activity and execute it. When that
activity completes, control returns to the calling activity.

• 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.

• Use of explicit class names can introduce inflexibility, complicate debugging, and reduce opportunities for
rule reuse, avoid this format whenever possible. Eg: Call Data-Admin-Operator-ID.Analyze
• Do not use a local variable to hold an output parameter. Do not enter a constant as the value of an output parameter.

• For a complete list of available PublicAPI Java methods, consult the Public API JavaDocs. By convention, the tools variable
identifies the PublicAPI class.

• Each function rule belongs to a RuleSet. To call a function rule from a Java step, refer to each library by its RuleSet and library
name. For example, a standard library named String is defined in the Pega-RULES RuleSet. To reference this library in your Java, use this
syntax:

pega_rules_string.equalsIgnoreCase ("ABC123DEF", pyWorkPage.Account);

• Flow processing automatically controls locking and transaction boundaries for work objects. Do not use the Commit method (or the
Obj-Save method with the WriteNow parameter selected) in any custom activity called by a flow.

• Optionally, the Utility type activity can use the TaskStatus-Set method to return a text value in the pxTaskStatus property to the flow
as a basis for decisions. Connectors leading from the activity can be based on this status value. Using this method can simplify flow
diagrams by eliminating fork or decision shapes that follow a utility shape.

Process Commander maintains three activity lists for each requestor, stored in Java constructs. The lists are:

• Current list — highest priority


• Activity list — intermediate priority

Sunday, August 21, 2011 10


BPM and BRE

• Workflow list — lowest priority

Use the Clipboard tool when developing and debugging to:

• Examine property values and messages associated with them


• Find the information necessary to reference a property — the page names and the property name
• Quickly create, update, delete, and modify pages using the Action menu
• Quickly start activities and flows using the Action menu

The clipboard has a hierarchical structure based on XML. It resides in memory on the server. As you interact with the Clipboard tool at your
workstation, you see a static snapshot copy.

The Clipboard display shows the contents of the clipboard, but not its size in bytes. Large clipboards can affect performance because
memory in the Java Virtual Machine supporting Process Commander holds the clipboards of all requestors.

• You can use the Performance tool to see the size of your clipboard in bytes, or to track the growth and contraction of your
clipboard over time. Select Run > Performance, then click the Add Reading with Clipboard Size link.

The Clipboard display doesn't include properties with names that start with pz. These standard properties support internal operations.

To see pz properties and other clipboard entries that aren't truly properties, right-click in the left panel and select Show XML. To see the
contents of unnamed pages, use the Tracer.

The Clipboard tool is available only to users who have access to the @baseclass.clipboardViewer privilege. Action menu items that update the
clipboard contents are available only to users who hold the @baseclass.clipboardViewerUpdate privilege. The standard access role
PegaRULES:SysAdm4 provides these privileges.

Use the Tracer to test and debug activities, decision rules, service rules, parse rules, and flows. You can see in summary or detail the
processing that occurs as you or another requestor executes an activity, declarative rule, or flow rule.

You can set break points for specific steps in activities.

Select the Abbreviate Events box to reduce the quantity of detailed clipboard detail sent to the Tracer. This can improve performance of the
requestor session being traced so that elapsed time statistics during tracing are closer to the normal value (when not being traced).

To adjust the size of the Tracer file buffer:

1. Edit the prconfig.xml file to contain two lines:

<env name="tracer/queue/type" value="file" />


<env name="tracer/queue/file/limit" value="nnnnn" />

where nnnnn is a non-negative integer. If you omit the second line, the default limit is 50,000 events.

2. Stop and restart (or redeploy if necessary) the server node to have the changes take effect. Each Tracer session on the node uses a
separate file in the temporary file directory on the server.

To use an in-memory buffer rather than the file buffer, change the value for the type from "file" to "memory":
<env name="tracer/queue/type" value="memory" />

Business Process Management is the organizational activity "that incorporates:

• Planning

• Designing

• Building

• Operating

• Maintaining

Sunday, August 21, 2011 11


BPM and BRE

and improving the business processes and their enabling capabilities forever and for everyone. "

Business processes are capabilities, as important as facilities, people, and technology. Like other assets, they must be
managed from inception to retirement.
Process Commander supports Simply Smart Business Process Management through rules covering flows, assignments,
routing, decisions, and automated processing.
A business rules engine is a software component that allows business rules to be recorded in a non-procedural, non-
programming form, and uses advanced software techniques to compute the consequences and results of rules. The
PegaRULES component of PegaRULES Process Commander provides a powerful rules engine supporting business
process management, and other applications through services.
Developed in Java, highly scalable and reliable, PegaRULES supports declarative rules, multithreaded execution and a large
number of industry interfacing and standards.
The business rules engine can be embedded or called from another system using Service JSR94 rules.
Process Commander supports exceptions management applications and the staff that processes exceptions, by ensuring
compliance with business policies, supporting access to external systems, and giving visibility to work in process.

A service level rule is an instance of the Rule-Obj-ServiceLevel type. Each service level rule defines one to three
time intervals, known as goals, deadlines, and late intervals, that indicate the expected or targeted turnaround time
for the assignment, or time-to-resolve for the work object.
a developer can set a goal of 30 minutes to call a customer back and a deadline of four hours. (The time interval
starts when the assignment is created, not when a user begins processing the assignment.)
For the overall work object, the service level rule is identified in the standard property .pySLAName, typically set up through
a model for the class.

Sunday, August 21, 2011 12


BPM and BRE

The Pega-ProCom agent detects service levels not achieved — unmet goals or deadlines — promptly. If an
assignment is not completed before the time limit, the system can automatically notify one or more parties, escalate
the assignment, cancel the entire flow, and so on.

Service Level Purpose


Advanceflow Push the assignment along a flow action automatically.
Default Imposes a goal of two days and a deadline of five days.
NotifyAssignee Sends an e-mail reminder to assignee upon reaching goal time or deadline time.
NotifyManager Sends e-mail to the assignee's manager upon reaching the deadline time.
TransferToManager Transfer assignment to manager upon reaching the deadline.
NotifyandTransfer Notifies manager when the assignment remains open after one full day (goal time). Transfers the
ToManager assignment to a manager after three days (deadline time).
TransferToWorkbasket Transfer assignment to a workbasket when it is open at deadline time.

Service level rules define three time intervals, known as goal, deadline, and late intervals. The goal time is the smallest time interval, the
deadline time is a longer interval, and the late interval defines post-deadline times. Each time interval is in days, hours, minutes, and seconds.

Service level rules can be associated with a work object or an assignment. When the time interval defined by the service level is reached
without the assignment being performed (or the work object becoming resolved), escalation occurs.

Escalation can change the urgency value of the assignment or work object, send it to someone else, send an alert or e-mail message, cancel
the work, or initiate other processing.

The Pega-ProCom agent — a background requestor — detects goals and deadlines not met and performs escalation processing.
The agents in the Pega-ProCom RuleSet process e-mail, service level rules, and assignments, archive work objects, and so on.
The agents in this rule provide the following types of processing:

• Processing service level events and escalation


• Applying a flow action to assignments in bulk
• Sending out e-mail correspondence
• Archiving and purging work objects, attachments, and history
• Retrieving PDF files from the PegaDISTRIBUTION Manager
• Running tests defined through the optional Automatic Testing facility
• Checking incoming e-mail (deprecated in V5.3)

The activity System-Queue-ServiceLevel.ProcessEvents supports service level processing for both assignments and work objects. Enable this
row of the Agent Schedule form unless your applications use only non-BPM rules-engine facilities.

The activity Assign-.AgentBulkProcessing supports background processing of flow actions in bulk against assignments, when requested
through the bulk processing feature of the Process Work workspace of the WorkUser portal.
The activity Data-Corr-.Send supports outgoing e-mail if your system contains one or more Email Account data instances with a second key
part of Notify.

The activity Assign-Archive.ProcessAssignments performs periodic processing to delete selected work objects, work object history, and work
object attachment, based on schedules
The activity @baseclass.getConvertedPDFsfromPDM requests that the PegaDISTRIBUTION Manager send a converted Portable Document
Format (PDF) file to the Process Commander server.
Five agents in the Pega-IntSvcs RuleSet process queued service and connector requests and perform maintenance for PegaDISTRIBUTION
MANAGER (formerly called Correspondence Output Server, or COS).

• checkPrintErrors
• checkFaxErrors

Sunday, August 21, 2011 13


BPM and BRE

• purgeRequestsTable
• ProcessServiceQueue
• ProcessConnectQueue

PegaDISTRIBUTION Manager is a small, optional Windows server application used to support a Process Commander system for printing and
faxing of Microsoft Word documents. PegaDISTRIBUTION Manager can also convert Word documents to Acrobat PDF format.

The agents in the Pega-RULES RuleSet perform general system housecleaning and periodic processing. The agents in this rule provide the
following processing:

• System Cleaner • Rule Usage Snapshot


• System Pulse • Static Content Cleaner

• System Indexer • System Work Indexer


Log-Usage.UsageCleaner, which trims older rows of the pr_perf_stats table
System pulse processing, defined by the activity Code-.SystemPulse, typically occurs every 60 seconds. Rows of the
pr_sys_updatescache database table (corresponding to the System-Updates-Cache) class form the input queue.

Rows of this table have one of five record types in this table:

• CACHE — Notify all nodes of rules created, deleted, or updated since the most recent pulse.
• INDEX — Records the need to incrementally update Lucene indexes (typically indexes are created and saved only on one
node of a cluster)
• DELLC — Indicates that the Lookup List Cache (LLC) — was deleted on this node, so other nodes are to delete their own
LLC. Deleting this cache is a manual option in the System Management application.
• RFDEL — Indicates that a static-content rule (from one of the Rule-File-* rule types) was deleted, so all nodes are instructed
to delete the extracted static file.
• RUF-X — Indicates that a library was regenerated on one node, so that other nodes are instructed to regenerate this library.

The standard activity Code-.SystemIndexer updates the search index cache that supports Find and Find Content operations of the Advanced
Search facility. Typically, this runs every 60 seconds.
The standard activity Code-.RuleUsageSnapshot normally runs once every 24 hours. If the system has run for at least an hour since startup,
this activity takes a snapshot of the rule assembly cache, writing out instances of the Log-RuleUsage class and Log-RuleUsage-Details class.

The standard activity Code-.StaticContentCleaner deletes (or "prunes") files from the server file system containing static content, such as
images (JPG, PNG, or GIF file type), style sheets (CSS file type) and JavaScript files (JS file types) in the StaticContent folder. Normally
running once an hour, this activity deletes extracted static content that is older than NNN days, where NNN is the value of the following setting
in the prconfig.xml file:

<env name="http/staticcontentminpruningage" value="NNN" />

The SystemWorkIndexer agent periodically updates Lucene indexes to support text-based searches for work objects. Lucene indexes for work
objects are created only when the dynamic system setting PegaRULES:indexwork/enabled is set to true.

Using the System Management application, you can rebuild indexes completely, or consolidate and compact indexes for improved search
performance.
Allowing application users to find work objects using full-text search (in addition to structured searches based on owner, party, or status) has
advantages and costs. Consider these factors:

• Full text searches may reduce the chances that an application user enters a duplicate work object
• Full text searches do not depend on exposed columns; all properties are searched.
• Full text searches can increase operator productivity by providing faster access than structured searches
• Full text searches may produce many "hits" that require further review and qualification

Sunday, August 21, 2011 14


BPM and BRE

• Full text searches may disclose sensitive work object details to uses who otherwise would not be permitted to open or review such
work
• Indexing (performed in the background by the Pega-ProCom agent) and searching (performed on request) can impact system
performance.

Indexing is controlled by settings in standard Dynamic System Settings data instances (Data-Admin-System-Settings class) and by a check
box option on the Advanced tab of the Class form. The Dynamic System Settings are:

• Pega-RULES.indexing/dataenabled — Set to true or false to control whether searching is supported for Data-
instances. Default is false.
• Pega-RULES.indexing/ruleenabled — Set to true or false to control whether searching is supported for Rule-
instances. Default is true.
• Pega-RULES.indexing/workenabled — Set to true or false to control whether searching is supported for Work-
instances. Default is false.
• Pega-RULES.indexing/enabled — Set to false to disable all searching. Default is true.
• Pega-RULES.indexing/explicitindexdir — If not blank, identifies a directory on the server that can hold indexes.
The indexing facility places the index files it creates (with file type .cfs) in subdirectories of this directory.
• Pega-RULES.indexing/hostid — Needed in a multinode cluster, hash node ID of the node on which the indexes
reside. (In a multinode cluster, indexing occurs on only one node; this can reduce processing workloads and disk space
requirements. Through standard SOAP connector rules, search requests from other nodes are forwarded to this node.)
• Pega-RULES.SearchSOAPURI — Needed in a multinode cluster, URI of the node on which searching occurs, in the format:
http://10.60.51.214/prweb/PRSOAPServlet

By default in new installations, only rule indexing is enabled. If no explicit directory name is specified, indexes are created in a subdirectories
of the PegaRULES Web root directory (typically /prweb). The system creates rule indexes in a subdirectory named PegaRULEIndex. The
DataIndex and WorkIndex subdirectories contain CFS files for data instances and work objects respectively

In some cases, a PEGA0004 alert threshold (alerts/database/interactionByteThreshold/errorMB) can cause the indexing
process to fail before completing. Before building indexes on a new installation, make sure no value is set for the errorMB setting.
Instances of the Log-Usage class, which (in the initial PegaRULES database schema) are stored in the pr_perf_stats table, support
system-performance and usage reporting.

Don't confuse Log-Usage data, which covers system and requestor performance of all types. with Log-RuleUsage data, which cover only rules
assembly rules — rules of those rule types that the system converts to Java code.
The first character of the requestor ID identifies a requestor type:

• A — Services (APP requestor types)


• B — Background requestors (BATCH requestor type)
• H — Interactive browser users (BROWSER requestor type)
• P — Portlet users (PORTLET requestor type)

To improve access, the PegaRULES database indexes are defined for the pr_perf_stats table.
You can add the utility activity Work-.AddHistory to a flow to add a history instance at any point in the flow. Others
are added automatically at runtime, or added as a result of values you select for the Audit Note field of flow shapes,
when editing the flow rule in Visio.
Work object history instances are stored as objects in classes derived from the History-Work- class. The name of the class is
History-ZZZZZ, where ZZZZZ is the name of the work object class.
History instances identify date, time, and user who updated a work object, 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.

Sunday, August 21, 2011 15


BPM and BRE

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.
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 the History Details button display (on the History tab). The history instance for a checked-
in rule contains the entire previous contents of the rule before update:

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.

When you delete an empty concrete Work-, Data-, or Assign- class, the system deletes the associated History- class if
it is also empty.

The History-Work-.pyHistoryType property, contained in each history instance, identifies the event that corresponds to the
instance. This property has one of the following values:

• A — A user begins performing an assignment

• F — A user completed and submitted a (connector) flow action, completing an assignment

• L — A user completed and submitted a local flow action (other than a transfer), so the assignment remains open.

• M — A user added a memo to history.

• R — A user completed the transfer of an assignment to a different worklist or workbasket

Process Commander’s correspondence feature is supported by the following:

• Work parties. A work party is a person or organization associated with a work object. Correspondence can be sent only to people
who are identified as work parties.
• Correspondence rules. These rules provide the content and logic that flow processing uses to generate customized correspondence
for the recipient.
• Correspondence flow actions. When the (human) operator working on an assignment needs to specify information about what to
send and who to send to, use correspondence flow actions.
• Correspondence activities. If the same piece of correspondence is to be sent to the same work party for every work object created by
a flow, there’s no reason to make operators do any work. In this case, use flow shapes and standard activities to configure
correspondence to be added programmatically.
• Background correspondence processing. Process Commander’s flow processing and agent activities take care of correspondence
generation and processing in the background.

Five Data-Party- classes that contain properties for holding contact information.

o Data-Party-Operator represents Process Commander users who have operator IDs.


o Data-Party-Person represents individual people who are not Process Commander operators, people such as customers or
applicants or policy holders.
o Data-Party-Com represents for-profit companies and corporations such as vendors
o Data-Party-Gov represents government agencies
o Data-Party-Org represents not-for-profit organizations

By default, there are two standard work parties rules in Process Commander. 1) Work-.Default. 2) Work-Cover-.Default.

Correspondence rules are usually thought of as the top-level rule (or the container template) with fragments as the component parts of the
template.

Correspondence Rules (Rule-Obj-Corr)  Has more than one Fragment Rules (Rule-Corr-Fragment)

Sunday, August 21, 2011 16


BPM and BRE

Eg: Rule-Obj-Corr instance has <pega:include name=”Logo.Email” type=”Rule-Corr-Fragment”>


<pega:include name=”BodyofEmail.Email” type=”Rule-Corr-Fragment”>
<pega:include name=”Footer.Email” type=”Rule-Corr-Fragment”>

There are four standard correspondence types:

• Email
• Fax
• Mail
• PhoneText

If a piece of correspondence will be selected by a human user (rather than generated in the background), you can configure the
correspondence rule to prompt operators for input. The flow actions SendCorrespondence and Notify prompt the user to select a work party
and a correspondence rule.
Type of the correspondence rule:

• Data-Corr-Email
• Data-Corr-Letter (type = Mail)
• Data-Corr-Fax
• Data-Corr-PhoneText

To send automatic notification messages about assignments, use the notify shape with one of the standard notify activities (Work-.Notify,
for example).

To send any other kind of correspondence programmatically, use the utility shape with the Work-.CorrNew activity.

SendCorrespondence starts a screen flow named BuildCorr. BuildCorr is a screen flow that walks the operator step-by-step through the
process of specifying the work party role, selecting a correspondence rule, entering values for any fields the correspondence rule needs input
for, and so on. If the work object has attachments, the operator can select which attachments to use as email attachments.

the AddAttachments flow action enables users to upload a single file and select a category for it while AddMultipleAttachments enables user to
select multiple files and choose a category for each. Correspondence processing can use work object attachments as email attachments.

The following list summarizes the general steps for configuring correspondence generation in your flows.

1. Create the work parties rules that associate work party roles with your work classes.
2. Configure an email account object (Data-EmailAccount) that holds information about the email server and user account flow
processing should use to send outbound email.
3. Create correspondence, correspondence fragment, and HTML stream rules.
4. Configure your flows to call the standard correspondence activities and flow actions at the appropriate places.

A business rules engine is a software component that allows business rules to be recorded in a non-procedural, non-
programming form, and uses advanced software techniques to compute the consequences and results of rules.
The PegaRULES component of PegaRULES Process Commander provides a powerful rules engine supporting
business process management, and other applications through services. Developed in Java, highly scalable and reliable,
PegaRULES supports declarative rules, multithreaded execution and a large number of industry interfacing and standards.
The business rules engine can be embedded or called from another system using Service JSR94 rules.

Java Specification Request 94 (JSR 94) describes an Application Programming Interface (API) for rules engines defined by the
Java Community Process (JCP). The JSR 94 integration interface makes Process Commander processing available to external
Java applications through JSR 94 invocations to JSR94 service rules. This service type enables the Process Commander

Sunday, August 21, 2011 17


BPM and BRE

product to be embedded into, and called directly from, any Java program. A Service JSR94 rule is an instance of the
Rule-Service-JSR94 class.
Process Commander provides three Java-based service interfaces (EJB, Java, and JSR94) that you can use to request
services using a signature-based or an engine API invocation-based
• Signature-based means the external application invokes the Process Commander service rules through the proxy
EJB or Java archive generated by the service package. The proxy publishes the method signatures of the service rules. A
client application sends the input to the service rule by calling a method in the proxy — a method with parameters that
match the service rule. The proxy manages type validation, constructs the URI for the service rule, and so on.

• Engine API invocation means the external application invokes the Process Commander service rules through a
(generic) business delegate, directly through the PRService EJBs, or through an instance of the PegaRULES engine. The client
application calls one Java method no matter which service rule is targeted in Process Commander. The parameters provided
in the invocation identify the service rule and provide the input for the service rule. Unlike the signature-based style, no
compile-time validation of method names and parameters does not occur, because you are not using a proxy compiled by
Process Commander.
Service EJB rules and Service Java rules support both invocation styles. Service JSR94 rules support the engine API
invocation style only, in accord with the JSR 94 specification.

Decision rules perform a calculation or test that often is used to determine the next step in a flow execution or other calculations. V5.4
contains six types of decision rules:

case match decision table decision tree


hierarchy map value when

Declarative rules offer an attractive alternative to procedural calculations. Changes in some property values — from any source — are
automatically propagated forward or backward to change other property values. V5.5 contains six types of declarative rules:

Constraints Declare Expression Declare Index


Declare OnChange Declare Page Declare Trigger

Validation is the processing needed to ensure that inputs (from a user, from an external system, or from a file) meet criteria defined by your
application requirements. You can validate input by various means, including property definitions, client-side JavaScript functions, edit validate
rules, and validate rules.

A declarative rule is an instance in a class derived from the Rule-Declare- class.


You can establish required relationships among properties in a Declare Expression, Constraints, Declare OnChange or
Declare Trigger rule. When the value of a property is involved in any of these declarative rules, the system automatically
checks an internal dependency network for other values that are affected and performs other processing as determined by
the network. This is known as forward 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.
Declarative processing simplifies your application and reduces the number of activities you need to create. The
declarative processing facilities support operation of six rule types:

Sunday, August 21, 2011 18


BPM and BRE

• Constraints rules (Rule-Declare-Constraints rule type)

• Declare Expression rules (Rule-Declare-Expressions rule type)

• Declare Index rules (Rule-Declare-Index rule type)

• Declare OnChange rules (Rule-Declare-OnChange rule type)

• Declare Trigger rules (Rule-Declare-Trigger rule types)

• Declare Pages rules (Rule-Declare-Pages rules type)

Declare Index rules support reporting and belong to the SysAdmin category. Declare Pages rules belong to the
Technical category.

When conditions are the simplest decision rules. A when condition rule evaluates a relationship among one or more
property values, and returns true or false.
a decision tree rule to capture complex IF-THEN situations that involve multiple tests and criteria. Decision tree rules
contain a list of one or more input properties, and can return a property value as a result. You can reference decision
tree rules in flows through a decision task, and in any activity that executes the Property-Map-DecisionTree method.
A map value rule, like a decision tree rule, has inputs and results. Use a map value rule to convert one or two input
values (text, numbers, or dates) into a single resulting value, where the decision criteria fit a table or matrix structure.
This is a straightforward way to present decisions and computations that depend on ranges of the input values.

A Constraints rule records an expected relationship between property values, such as:
ActualExpense("December") is never greater than BudgetExpense("December").
As with expressions, the system monitors whether the constraint is met each time either value changes. If the constraint
becomes false, the system adds a message on the page containing the left-hand property (ActualExpense(), in this case),
marking the page as not valid. Pages that are not valid cannot be saved to the database.

A Declare Trigger rule identifies processing to occur automatically when an instance of a specific class is saved or
deleted.
Create Declare Trigger rules to cause an activity to run when instances of a specific class are created, updated, or deleted
in the database. This implements a form of forward chaining. Declare Trigger rule can implement a form of logging or
audit history for a class, recording the date, time, and other facts.
A Declare OnChange rule causes computation to occur when the value of certain "watched" properties change. This
may cause more frequent updating than a Declare Expression rule. A Declare OnChange rule starts an activity that
can perform more complex or comprehensive computations than can be defined by expressions.

The Declarative Network display conveys relationships among properties that are computed by Declare Expression
rules in the selected application.

Forward chaining

Forward chaining provides the automatic propagation of changes in one property value to cause recomputations of
another property's value.

Sunday, August 21, 2011 19


BPM and BRE

Backward chaining

Backward chaining executes Declare Expression rules when a value is needed for a property, rather than when inputs
change.
Backward chaining applies to Declare Expression rules with the Calculate Value field set to one of the following:

• When used if no value present

• When used, if property is missing

• Whenever used

The Property-Seek-Value method is the foundation of backward-chained processing.


A capability called locatable pages reduces the need for pages to be explicitly named in the rule. Locatable pages can be
used with Constraints rules and Declare Expression rules.

At runtime, the system uses backward chaining and an activity with type Locate to find and (if necessary) add the
proper page to the clipboard. This eliminates the need for the developer creating the when condition rule to specify
the page.

Declarative pages enable developers to define a set of named clipboard pages for an application. They are
created and refreshed on demand as they are needed by other rules. The created pages are treated as
reserved, so other rules (such as activities) cannot be used to update or remove them
Once the page has been populated, it is marked as read-only to maintain data integrity. The page can
easily be shared by multiple requestors. It is for this reason that all of the properties on the page are not
modifiable, and no new properties can be added to the page.
Examples of the data types to be shared are:
• Cached global system settings
• Lookup lists
• Product information
• Any other application wide information that should ideally be shared
A declarative page can be stored at the thread or node level.

Sunday, August 21, 2011 20


BPM and BRE

Thread level pages allow developers to define pages similar to those generated by the existing Locate
Page facility. In other words, the page is accessible to a given requestor’s process. Thread page examples
might include:
o Cache information about the current user
o Credentials
o Personal information (such as address information)
o Customized user preferences
o Information about the process or activity executed

Node pages, on the other hand, are available to all requestors on a given node or application server.
These pages can be used by developers to store common data in one place that is shared by multiple
users of an application. Examples might include:
o Lookup lists
o Code tables
o Organizational information
o Translation tables
o System settings
o External data that changes infrequently
o Any commonly used enterprise information

All declare pages are cached and remain on the clipboard until further notice; hence, improving
performance.
A delegated rule is a link to a rule or data instance that provides a quick shortcut. Click the
link to open the form.
Delegation creates an instance of the System-User-MyRules class.

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.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. 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). Alias function rules are instances of the Rule-Alias-Function
class.

• Obj-Browse — Executes an SQL SELECT statement; with the WHERE condition limited to exposed properties
• Obj-List-View — Executes the selection, retrieval, and sorting capabilities of a list view rule, without report display

Sunday, August 21, 2011 21


BPM and BRE

Obj-Browse:
ReadOnl
Select to mark the embedded pages for the selected instances as read-only, meaning that later processing by the
y
requestor cannot update or delete data in the page. Leave unselected if you plan to update the embedded pages.

As a best practice, select this check box. This records your intent that the embedded pages are not to be altered and can
reduce memory requirements by retaining only specific property values extracted from the Storage Stream (Blob) column.

Marking the embedded pages as read-only with this check box prevents changes to the values of properties on
the embedded pages. It does not affect your ability to remove an embedded page completely (with the Obj-Filter or
Page-Remove method).

If the Select array is empty, the ReadOnly setting is ignored. The result of the method is a Code-Pega-List
structure that contains all rows and all columns of the object, including the Storage Stream (BLOB) column. The
embedded pages are not read-only.

This method can return thousands of database rows and create large clipboard pages. Use care to retrieve only the rows
(instances) and columns (properties) you truly need. Similarly, specify sorting only when needed.

Execution of this method may cause an alert to be added to the Alert log, of type PEGA004-PEGA007, PEGA0025, PEGA0027, or
PEGA0028. Review the Alert log to understand the frequency and sources of such alerts, and for best performance, alter your
application or database to eliminate those alerts that occur frequently. For example, if execution of an Obj-Browse method
accesses properties within the Storage Stream column, a PEGA0025 alert occurs. The alert indicates that exposing one or more
columns in the PegaRULES database table that holds instances of the class is likely to improve performance.

Obj-Filter:
Use the Obj-Filter method to filter the embedded pages of a results page (such as a Code-Pega-List page produced by the
Obj-List, RDB-List, Obj-List-View or Obj-Browse methods) based on one or more when condition rules.

For best performance, use an Obj-Browse method to search and retrieve instances of a class
where the selection criteria involve only Single Value properties exposed as columns in the
PegaRULES database. Use the Obj-Filter method to refine search results by deleting pages
based on when condition tests that involve non-exposed property values, including
aggregate properties.
Obj-List-View:
Use the Obj-List-View method to execute the retrieval and sorting operations, but not the
formatting and display processing, of a list view rule.
Obj-List-View processing can return a smaller set of columns and a more precisely selected
set of rows than the similar Obj-List method, and so can require less memory and less
network traffic than an Obj-List method.

Sunday, August 21, 2011 22


BPM and BRE

ID Category Message text and description


Browser interaction time has exceeded a threshold setting. See How to monitor interactive
PEGA0001 Browser Interaction
response times.
Database commit operation has exceeded a threshold setting. See How to detect lengthy
PEGA0002 DB Commit Time
PegaRULES database operations.
Database rollback operation has exceeded a threshold setting. See How to detect lengthy
PEGA0003 DB Rollback Time
PegaRULES database operations.
Number of bytes received from the database has exceeded threshold. See How to monitor
PEGA0004 DB Bytes Read
Storage Stream operations.
Database query operation has exceeded an elapsed time threshold setting. See How to
PEGA0005 DB Time
detect lengthy PegaRULES database operations.
PEGA0008 PRPC Started PegaRULES engine successfully started.
PEGA0009 PRPC Failed Start PegaRULES engine failed to initialize.
PEGA0010 Agent Disabled Agent processing disabled because of execution errors
Services — One of five time thresholds was exceeded during a service execution See
PEGA0011 Service Total Time
Testing Services and Connectors on the Integration page of the Pega Developer Network.
The number of records in the rule assembly cache, a personal cache, or a property
conclusion cache has reached or exceeded about 75% of the limit specified in the
PEGA0016 Cache Reduced
prconfig.xml file; This causes the system to invalidate older entries in the cache, making
room for newer ones. See Understanding caching.
The number of records in the rule assembly cache, a personal cache, or a property
Cache Force conclusion cache has reached or exceeded a limit specified in the prconfig.xml file. This
PEGA0017
Reduced causes the system to immediately invalidate older entries in the cache, making room for
additions. See Understanding caching.
PEGA0018 PRThreads Limit Number of PRThreads has exceeded the threshold for a requestor.
The master agent has detected a long-running requestor session. See How to detect long-
PEGA0019 Long Requestor
running requestors.

Sunday, August 21, 2011 23


BPM and BRE

A connector call to an external system has exceeded an elapsed time threshold. See How to
PEGA0020 Connect Total Time detect lengthy connector executions and Testing Services and Connectors, located on the
Integration page of the Pega Developer Network.
Declarative Page The total of shared memory to store Node-scope declarative pages has exceeded a
PEGA0021
Memory threshold. See More about Declare Page rules.
Rule Cache The rules cache became disabled, typically by an administrator using the System
PEGA0022
Disabled Management Application.
The rules cache became enabled, typically accomplished by an administrator using the
PEGA0023 Rule Cache Enabled
System Management application.
Loading Declarative Loading declarative network has exceeded an elapsed time threshold. See How to detect
PEGA0024
Network large declarative networks.
Reading Blob Need A list operation (for example, an Obj-Browse method) accessed properties within the
PEGA0025
Columns Storage Stream (blob) column, that is, properties not exposed as individual columns.
Database The elapsed time taken to acquire a database connection exceeded a threshold. See How to
PEGA0026
Connection Time detect long database connection waits.
A list operation returned many rows. See How to detect database list operations that return
PEGA0027 DB Rows Returned
many rows.
JVM Garbage Collection usage threshold exceeded for long-lived object memory pool. A garbage
PEGA0028
Collection collection operation completed, but did not free sufficient virtual memory.
An HTML stream sent to the browser exceeds 2,000 kilobytes (or another threshold setting).
PEGA0029 HTML Stream Size
See How to detect large HTML streams.
The number of requestors on a system node exceeds 200 (or another threshold setting).
PEGA0030 Requestor Limit
See How to detect when the number of requestors exceeds the threshold.
A generated HTML stream was overwritten without being sent to the browser client. See
PEGA0031 Stream Overwritten
How to detect when a generated stream was overwritten but never sent.
Rule change invalidated the specified threshold of entries in the Rule Assembly cache. See
PEGA0032 Invalidated Rules
How to detect when a rule change invalidates many entries in the Rules Assembly cache.
Database query length has exceeded the specified threshold See How to detect when the
PEGA0033 DB Query Length
database query length has exceeds a specified threshold.
The number of declare indexes in a single interaction exceeded threshold. See How to
PEGA0034 Declare Index
detect when the number of declare indexes exceed a threshold.
A Page List property contains more than a specified threshold number of elements. See How
PEGA0035 Clipboard List Size
to detect when a Page List property has many elements.

Security alerts are recorded in the Security log.

ID Category Message text and description


Security alert; an HTTP request referenced an unexpected property. These can arise from
SECU0001 Security
an improperly coded URL JavaServer Page tag.
Security alert; an HTTP POST operation sent an XML document containing clipboard page
SECU0002 Security
details from a web node within a Pega Composite Application.
Security alert. A requestor on a web node, within a Pega Composite Application, attempted
SEC0003 Security to execute an activity or list view rule that is not marked for web node execution. The
attempt was ignored.
Security alert. A URL received from a web node, within a Pega Composite Application,
SEC0004 Security
contained the pyStream parameter. The URL was ignored.

Sunday, August 21, 2011 24


BPM and BRE

Sunday, August 21, 2011 25

You might also like