Pega CPSSA cheat sheet

Case lifecycle stages: Create, Process, Resolve, and optional Alternate stages; a stage can allow multiple processes to run in parallel, and the primary stage gates case resolution.

A case type inherits from a parent class; pyDefault, pySetFieldDefaults, and pyPostProcessing are the standard extension points for pre-processing and post-processing data transforms.

A flow's shapes: Start, Assignment, Decision, Subprocess, Utility, End, and Connector; connectors can carry a when-condition and a Likelihood value used by flow analysis.

Service level agreements (SLAs) attach to assignments, processes, or stages; each goal/deadline/passed-deadline interval fires an escalation action and can be configured by urgency.

Routing options: work queue, work group, workbasket, skill-based, or to a specific operator; a work queue is a container processed by a work group rather than an individual.

Declare rules: Declare Expression (forward/backward chaining), Declare OnChange, Declare Trigger, and Declare Index; triggers fire on database events, not on in-memory property changes.

A subprocess shape calls another flow and returns to the parent; a Spin-off flow runs asynchronously and creates a separate assignment context.

Case dependencies: a child case is created via the Create Case shape or a data transform calling pxCreateTopCase; parent status is controlled by the dependency configuration.

Class group structure: the work class group (e.g., MyApp-Work) and the data class group (MyApp-Data); pattern inheritance flows upward through the class hierarchy, directed inheritance follows the configured parent.

Data pages are named by structure: D_ for page list, D_ for page, and Declare Page rules; a data page with Scope=Thread is per-interaction, Scope=Request is per-request, and Scope=Application is shared.

A data page can be a read-only (snapshot) or editable source; editable data pages require a savable data page configuration and a matching Data Transform or activity for save.

Property types: Text, Integer, Decimal, Date, DateTime, Boolean, Page, Page List, Page Group, and Java Object; Page Group is a keyed map of pages.

Circumstancing: a rule can be qualified by property values (e.g., pyStatusWork), by date range, or by template; circumstanced rules override the base rule when the condition matches.

A data transform maps source to target; the Append to and Set actions differ in whether they merge or overwrite page content, and the To clipboard action persists the result.

Report definitions draw from the PegaRULES database; a report can use joined classes, and the class join is defined in the report rule, not the section.

Optimistic locking uses the pxUpdateDateTime and pzPVStream properties; the obj-save method checks the version and raises a conflict when the row changed.

A harness (pyDefault is the standard harness) wraps a section; the harness supplies the header, navigation, and action area, while the section supplies the content.

Section rule types: Section (standard), Section Include, and the newer Full Section; layout types include Dynamic Layout, Repeating Dynamic Layout, and the legacy Column Layout.

A repeating dynamic layout renders a Page List or Page Group; the Repeat grid property controls pagination, and the row-level actions are configured per layout.

Skin and theme: a skin (pySkin rule) sets the portal look; the theme (Cosmos) is the modern UI kit; the theme can be overridden at the component level with a style preset.

Responsive breakpoints are defined in the skin; the layout's column width settings (e.g., 12-column grid) determine stacking on small screens.

Action sets on a control fire events (click, change, blur); a control's action set can call a local action, a data transform, or a flow action.

A flow action (pyAction) defines the form a user sees for an assignment; the flow action's section and its pre/post-processing activities control the user interaction.

Accessibility: every input must have a label, and the section's field label must be associated with the control; the standard harness provides a skip-to-content link.

Authentication vs authorization: authentication verifies identity (LDAP, SAML, OpenID Connect, or Pega native), authorization controls access via roles and privileges.

Access of Role to Object (ARO) rules grant a role access to a class and its instances; the access mode (read, write, delete, execute) is set per ARO.

Access of Role to Object combined with Access When rules and Access Control Policies; an Access Control Policy can be conditional and is evaluated at runtime.

A privilege is a named capability checked by a When rule or an Access When; a role must be granted the privilege in the ARO or the policy.

Attribute-based access control (ABAC) uses Access Control Policies with conditions on properties (e.g., pyStatusWork), evaluated before the ARO.

Password policy and account lockout are configured in the operator ID and the security policies; failed logins increment the lockout counter.

Sensitive data: property-level encryption uses a cipher (e.g., AES) and is configured on the property; the value is encrypted at rest and decrypted on read.

Audit and logging: the PegaRULES log and the audit trail (pxAuditTrail) record changes; the security event log records authentication and authorization failures.