# Process Layer > The `src//…` paths used throughout this document are drawn from a > representative CG Mobile customer workspace. Your workspace may use different > module names, but the folder structure (`DS/`, `BO/`, `LO/`, `PR/`, `UI/`) > and naming conventions are identical. ## Overview Processes (PR) orchestrate the application flow by coordinating Business Objects, ListObjects, and UI screens. They define the sequence of actions, decision logic, and data transformations that occur when users interact with the application. ## Process Fundamentals ### Purpose Processes (PR) serve as the orchestration layer that: - Coordinate loading and saving of Business Objects and ListObjects - Define navigation flow between screens - Implement decision logic and conditional branching - Execute business logic methods at the right time - Manage process-level state and variables - Connect the business layer (BO/LO) to the presentation layer (UI) - Handle user actions and events ### Directory Structure ``` src/ ├── Call/ │ └── PR/ │ ├── Call_AccountReceivables/ │ │ ├── Call_AccountReceivablesProcess.processflow.xml │ │ └── Call_AccountReceivablesUI.userinterface.xml │ └── Call_LoadCall/ │ ├── Call_LoadCallProcess.processflow.xml │ └── [UI files] └── Visit/ └── PR/ ├── Visit_Info/ │ ├── Visit_InfoProcess.processflow.xml │ └── Visit_InfoUI.userinterface.xml └── [other processes]/ ``` ## Process XML Structure ### Root Element ```xml defaultAction="ShowView" schemaVersion="0.0.0.5" > ``` ### Key Elements | Element | Description | Required | | ------------------ | ------------------------------------------------ | ------------------------------- | | `` | Process initialization section | No, but functionally required¹ | | `` | Declares variables and parameters | Yes (inside ``) | | `` | Process-level variables (BOs, LOs, simple types) | No | | `` | Input parameters passed to process | No | | `` | Actions executed on process entry | Yes (inside ``)² | | `` | Main process actions and flow | No, but functionally required¹ | | `` | Collection of action definitions | Yes (inside ``) | > ¹ Per `ProcessFlow.xsd` `ProcessType`, both `` and `` are > `minOccurs="0"` at the `` root, but a functioning process needs > both. When either is present, its required children apply as noted. > > ² Per `ProcessFlow.xsd` `EntryType`, `` must contain > `` followed by `` in sequence. Use > `` (self-closing) when there is no work to do on entry. ## Example 1: Simple Process - Call_AccountReceivablesProcess **Location:** `src/Call/PR/Call_AccountReceivables/Call_AccountReceivablesProcess.processflow.xml` **Purpose:** Display a list of account receivables **Complexity:** Minimal (single view action) ### Complete Process XML ```xml Call::AccountReceivablesUI ``` ### Analysis #### ProcessContext **Parameters:** ```xml ``` - **name:** Variable name accessible via `ProcessContext::AccountReceivableList` - **type:** LoAccountReceivables (the ListObject) - **Direction:** Input (passed from calling process) This means the list is loaded _before_ entering this process and passed in as a parameter. #### Body Actions **Single VIEW Action:** ```xml Call::AccountReceivablesUI ``` - **actionType:** VIEW (display a UI screen) - **name:** ShowView (action identifier) - **UIDescription:** References the UI definition file - **No events:** No user interaction handlers in this simple example **Flow:** ``` Process starts | defaultAction="ShowView" | Display Call::AccountReceivablesUI screen (UI binds to ProcessContext::AccountReceivableList) | User views list | Process remains active while UI is visible ``` ## Example 2: Complex Process with Loading - Visit_InfoProcess **Location:** `src/Visit/PR/Visit_Info/Visit_InfoProcess.processflow.xml` **Purpose:** Load and display visit information with retail store details **Complexity:** Moderate (multiple loads, BO method calls) ### Complete Process XML ```xml Visit::InfoUI ``` ### Analysis #### Declarations (Process Variables) ```xml ``` **Purpose:** Define process-level variables to hold loaded data **Access:** Via `ProcessContext::VariableName` throughout the process **Types:** Can be BOs, LOs, or simple types (String, Object, DomPKey, etc.) #### EntryActions (Initialization) **1. Load Visit BO** ```xml ``` - **actionType:** LOAD (load a Business Object) - **type:** BoVisit (which BO to load) - **Parameters:** Pass VisitPKey to load specific visit - **Return:** Store result in ProcessContext::VisitBo **2. Load Related Retail Store (Chained LOAD)** ```xml ``` - Loads BoRetailStore using StoreId from the visit - Demonstrates data chaining: first load's result used in second load **3. Call BO Method** ```xml ``` - **actionType:** LOGIC (execute business logic) - **call:** Method on the loaded BO - **Return:** Store result in process variable **Process Flow:** ``` Process starts with parameters (VisitPKey, ResponsiblePKey) | EntryActions execute sequentially: 1. Load BoVisit by pKey 2. Load BoRetailStore using Visit's StoreId 3. Get retail store address from BoRetailStore 4. Filter completed tasks from Visit's assessment tasks 5. Filter not-started tasks 6. Filter in-progress tasks | All data loaded into ProcessContext | defaultAction="showVisitInfo" executes | Display Visit::InfoUI (UI binds to ProcessContext::VisitBo, RetailStoreDetail, task collections) ``` ## Example 3: Complex Process with Decisions **Location:** `src/Call/PR/Call_LoadCall/Call_LoadCallProcess.processflow.xml` **Purpose:** Load a call and handle various start conditions **Complexity:** High (multiple decisions, validations, conditional branching) ### Process XML (Excerpt) ```xml ``` **Process Flow (Simplified):** ``` Load BoCall | IsDSD_Decision +-- true --> DSDActionDecision +-- false --> CheckActionName +-- "Start" --> DSDActionDecision +-- else --> ShouldShowStartVisitInfo | ShowStartVisitInfoDecision +-- true --> ShowStartVisitInfo (dialog) +-- false --> DSDActionDecision | ProcessValidationInProgressAction | ValidateInProgressBeforeStart_Decision +-- false --> ProcessValidationGeoLocationAction +-- true --> CheckIfTimeCardIsAvailable ``` ## Action Types ### Core Action Types | Action Type | Purpose | Example | | -------------- | ------------------------------------ | ----------------------------------------------------- | | **VIEW** | Display a UI screen | `` | | **LOAD** | Load a Business Object or ListObject | `` | | **SAVE** | Save a Business Object or ListObject | `` | | **LOGIC** | Execute business logic method | `` | | **DECISION** | Conditional branching | `` | | **CONFIRM** | Show user confirmation dialog | `` | | **PROCESS** | Invoke a sub-process | `` | | **VALIDATION** | Validate a Business Object | `` | ### Action Type Details #### VIEW Action ```xml Call::AccountReceivablesUI ``` #### LOAD Action ```xml ``` #### LOGIC Action ```xml ``` #### DECISION Action ```xml ``` #### CONFIRM Action ```xml ``` **confirmType values:** - `Ok` - Single OK button - `YesNo` - Yes and No buttons - `OkCancel` - OK and Cancel buttons #### VALIDATION Action ```xml ``` ## Process Context Access ### Accessing Variables **From Process Actions:** ```xml ``` **From BO Properties:** ```xml ``` **From LO Methods:** ```xml ``` ### Variable Scope ``` ProcessContext +-- Parameters (Input) | +-- VisitPKey | +-- ResponsiblePKey | +-- ActionName +-- Declarations (Process Variables) +-- VisitBo (BoVisit) | +-- .pKey | +-- .name | +-- .status | +-- .loAssessmentTasks (child LO) +-- RetailStoreDetail (BoRetailStore) +-- CompletedTasks (Object) ``` ## Process Lifecycle ### Entry Phase ``` Process invoked with parameters | ProcessContext initialized - Declarations created (empty) - Parameters populated | EntryActions execute sequentially - Load BOs/LOs - Call initialization methods - Populate process variables | All EntryActions complete | Body actions begin ``` ### Body Phase ``` defaultAction executed | Action processes based on type: - VIEW: Display UI, wait for events - LOAD: Query datasource, populate BO/LO - LOGIC: Execute method, store result - DECISION: Evaluate, branch to next action - CONFIRM: Show dialog, wait for user response | TransitionTo next action (if specified) | Repeat until: - VIEW action (process waits) - No TransitionTo (process ends) - Exit action ``` ## Common Process Patterns ### Pattern 1: Simple View Process **Purpose:** Display a pre-loaded list ```xml Simple::ViewUI ``` ### Pattern 2: Load and View Process **Purpose:** Load data then display ```xml LoadAndView::ViewUI ``` ### Pattern 3: Validation and Save Process **Purpose:** Validate then save with error handling ```xml ``` ### Pattern 4: Conditional Loading **Purpose:** Load different data based on condition ```xml ``` ### Pattern 5: Sub-Process Communication Invoke another process with `actionType="PROCESS"` and reference the target process by fully-qualified name via the `process` attribute (`Namespace::Name`). Inputs are passed via ``, and named outputs come back via `` with each `` mapping a child variable to a `ProcessContext::…` slot in the parent. **Parent Process:** ```xml ``` ## Event Handling ### UI Events to Process ```xml List::UI ``` ## Best Practices ### 1. Load Data in EntryActions Data should be ready before the UI displays: ```xml ``` ### 2. Use Descriptive Action Names **Good:** `LoadCustomerDetails`, `ValidateOrderItems`, `SaveAndClose` **Bad:** `Action1`, `DoStuff`, `Process` ### 3. Chain Actions Explicitly ```xml ``` ### 4. Keep Processes Focused **Good:** One process per screen/workflow **Bad:** Giant process handling multiple unrelated screens ### 5. Use Declarations for Intermediate Results ```xml ``` ### 6. Handle Errors Gracefully ```xml ``` ## Key Takeaways 1. **Processes orchestrate** the flow between BOs, LOs, and UI 2. **EntryActions** execute sequentially before UI displays 3. **Action types** include VIEW, LOAD, SAVE, LOGIC, DECISION, CONFIRM 4. **ProcessContext** holds all process variables and parameters 5. **DECISION actions** enable conditional branching 6. **LOGIC actions** execute BO/LO methods 7. **TransitionTo** explicitly chains actions together 8. **Parameters** pass data from caller to process 9. **Declarations** define process-level variables 10. **defaultAction** specifies first action to execute ## Files Referenced | File Path | Purpose | | ---------------------------------------------------------------------------------- | ---------------------- | | src/Call/PR/Call_AccountReceivables/Call_AccountReceivablesProcess.processflow.xml | Simple process example | | src/Visit/PR/Visit_Info/Visit_InfoProcess.processflow.xml | Multiple loads example | | src/Call/PR/Call_LoadCall/Call_LoadCallProcess.processflow.xml | Complex decision flow | --- _This documentation is maintained by the Modeler CLI plugin and refreshed on workspace upgrade._