Access group in Pega
Pega is a powerful Business Process Management (BPM) tool for creating and managing business applications. Within Pega, understanding the distinction between rule and data instances is crucial for efficient application development and management. This article delves into the differences between these two types of instances, highlighting their unique characteristics and roles within Pega, and also discusses relevant concepts such as access group in Pega and Pega rulesets.
We create anything in PRPC, like sections, flow action, flow, operator, access group, workgroup, etc. These are called rules.
Rules are categorized into two types of instances.
1.Rule Instances.
2.Data Instance.
Rule instances will be associated with rule sets and versions. These will have check-in and check-out options available.
The above rule instance is associated with rule set + version. It has check-in and check-out.
Properties, sections, flow actions, flows, reports, etc. are rule instances.
For rule instances, the top parent class is “rule-“.
Property: Rule-Obj-Property
Section: Rule-HTML-Section
Flow Action: Rule-Obj-Flow Action
Data Instance: Data instances will be associated with only a rule set, but no version.
Ex: Operator, Work Group, Work Basket, Access Group, etc.
Data instance: The instance class is Data; all data instances top class is Data.
Operator: Data-Admin-Operator-ID
Access Group: Data-Admin-Operator-Access Group
If you see the operator rule form, it will be associated with the rule set but not the version.
- Data instances will not have a check-in and put-out feature.
- Data instances can be directly opened, modified, and saved back.
- In production, we can also directly modify the data instance.
- Data instances get saved into tables under “Data Schema.”.
In total, we have two schemas available in Rule Base. This is called Split-Schema Architecture for Rule Base.
1.Rule Instances in Pega
2.Definition and Purpose:
Additionally, rule instances in Pega are configurations or instructions that define the behavior of an application. These instances govern the application’s logic, processes, and user interface elements. Essentially, rules are the building blocks that determine how an application operates.
Key Characteristics:
Types of Rules:
Decision Rules: Define the logic for making decisions (e.g., decision tables, decision trees).
Process Rules: Define the workflows and processes (e.g., flow rules, case types).
User Interface Rules: Define the presentation layer (e.g., harnesses, sections, flow actions).
Declarative Rules: Automatically maintain consistency within the application (e.g., constraints, declare expressions).
Versioning and Reusability:
- Rules can have multiple versions, allowing for iterative development and testing.
- They are stored in rulesets, which are versioned containers enabling rule reuse across different parts of the application.
Scope and Inheritance:
- Scope rules to specific classes and inherit behaviors from parent classes.
- This inheritance promotes reuse and consistency across the application.
Execution Context:
However, rules are executed in the context of the user session and the application, which includes considerations for access control and security.
Examples:
- A flow rule that defines the sequence of steps in a business process.
- A decision table that evaluates conditions to determine outcomes.
Data instances in Pega
Definition and Purpose:
Moreover, data instances in Pega represent the static or dynamic data used by the application. These instances store information that the application needs to function but do not define behavior. They are akin to database records that provide the necessary data inputs for the application’s rules to process.
Key Characteristics:
Information Tables: Represent static reference data (e.g., list of countries, product catalog).
Data Pages: Represent dynamic data sourced from external systems or internal computations.
Data Transforms: Define how data is mapped and transformed between different structures.
Persistence:
- However, pega typically stores data instances in the database.
- You can load them on-demand or preload them into the system’s memory for quick access.
Configuration and Management:
- Moreover, users can create, update, and delete data instances through standard Pega interfaces.
- They support versioning and associate with specific environments (e.g., development, staging, and production).
Examples:
- A data page that fetches customer information from an external CRM system.
- A data table listing all the available shipping options for an e-commerce application.
Key Differences Between Rule Instances and Data Instances
Purpose and Functionality:
Rule Instances: Define how the application behaves.
Data Instances: Provide the information needed for the application to function.
Storage and Management:
Rule Instances: Stored in rulesets, managed through the rule repository.
Data Instances: Stored in the Pega database, managed as data records.
Versioning and Reuse:
Rule Instances: Support versioning and designers use them for reuse across different parts of the application.
Data Instances: Users can also version them, but they primarily store specific pieces of information.
Scope and Execution:
Rule Instances: Scoped to classes and executed wit hin the user session and application context.
Data Instances: Scoped to the data model and accessed as needed by the application.
Access Group in Pega
Definition:
An access group in Pega is a configuration that defines a set of permissions and access rights for users. It controls which parts of the application a user can access and what actions they can perform.
Key Characteristics:
Role-Based Access Control:
- However, access group in pega assign users to roles that determine their access level within the application.
- They define the primary ruleset and additional rulesets available to the user.
Customization:
You can customize access groups to provide different levels of access based on user roles (e.g., developer, manager, end-user).
Security:
Moreover, access groups enforce security by restricting access to sensitive data and critical application functionality.
Pega Rulesets
Definition:
A ruleset in Pega is a container that holds a set of related rules. It is a key element of Pega’s version control and rule management system.
Key Characteristics:
Version Control:
- Additionally, pega versions rulesets, allowing multiple versions of a rule to exist simultaneously.
- This enables iterative development and testing without affecting the production environment in pega rulesets.
Modularity and Reuse:
- Rulesets promote modularity by grouping related rules together.
- They facilitate the reuse of rules across different applications and parts of the same application.
Deployment and Distribution:
- Developers can package and deploy rulesets across different environments (e.g., from development to production).
- They support the distribution of application updates and enhancements.
Conclusion
In conclusion, Pega rule instances and data instances play distinct yet complementary roles in application development and management. Rule instances define the behavior and logic of the application, while data instances provide the necessary information for these rules to operate. Furthermore, understanding the differences between these two types of instances is crucial for creating efficient, maintainable, and scalable Pega applications. However, access group in Pega ensure secure and appropriate access to application features, and rulesets facilitate version control and reuse of application logic. Together, these elements form the foundation of a robust Pega application.