You are previewing Oracle BPM Suite 12c Modeling Patterns.
O'Reilly logo
Oracle BPM Suite 12c Modeling Patterns

Book Description

Design and implement highly accurate Business Process Management solutions with Oracle BPM Patterns

In Detail

This book gives you an exemplary and comprehensive exposure to Oracle BPM modeling and implementation patterns. During the journey, it will walk you through various BPM patterns based on real-life examples. It offers projects to download with each chapter, which allows you to design, model, and analyze the patterns discussed in each chapter, providing you with an interactive way to learn and implement BPM patterns.

With this title in hand, you will gain practical experience in using Oracle BPM effectively, while using the most useful modeling patterns for your implementations. The book also covers topics that demonstrate different BPM patterns including flow control and advance patterns, invocation and interaction patterns, correlation and integration patterns, human interaction, collaboration patterns, and case management patterns. The book also provides an insight on patterns for strategic alignment, business-IT collaboration, sharing of processes and architecture assets, and infusing business context.

What You Will Learn

  • Examine patterns of flow control, branching, synchronization, multi-instance, structured loop, cancellation and completion, milestone, iteration and termination
  • Blend workflow patterns with human interactions and task modeling using Oracle BPM human workflow
  • Use correlation patterns and discover exception handling strategies in Oracle BPM and the patterns around it
  • Learn patterns of invocation, and witness interaction and integration
  • Use adaptive case management to handle unpredictable, unstructured, ad hoc flows
  • Get to grips with milestone patterns, case interaction, holistic view, and event-based features
  • Use Process Asset Management (PAM) to uncover process and business architecture asset sharing for Business-IT collaboration
  • Learn strategic patterns of alignment and develop models for strategy, Enterprise, and value chain and align them together
  • Explore predictive analysis and KPIs
  • Downloading the example code for this book. You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the files e-mailed directly to you.

    Table of Contents

    1. Oracle BPM Suite 12c Modeling Patterns
      1. Table of Contents
      2. Oracle BPM Suite 12c Modeling Patterns
      3. Credits
      4. Disclaimer
      5. About the Author
      6. Acknowledgments
      7. About the Reviewers
      8. www.PacktPub.com
        1. Support files, eBooks, discount offers, and more
          1. Why subscribe?
          2. Free access for Packt account holders
          3. Instant updates on new Packt books
      9. Preface
        1. What this book covers
        2. What you need for this book
        3. Who this book is for
        4. Conventions
        5. Reader feedback
        6. Customer support
          1. Downloading the example code
          2. Errata
          3. Piracy
          4. Questions
      10. 1. Flow Control Patterns
        1. Sequence flow pattern
          1. Working with the sequence flow pattern
          2. Elucidating the sequence flow pattern
        2. Getting ready for executing use cases
        3. Exclusive choice and simple merge pattern
          1. Working with exclusive choice and simple merge pattern
          2. Knowing about the exclusive choice pattern
          3. Elucidating the simple merge pattern
        4. Multichoice and synchronizing merge pattern
          1. Demonstrating multichoice and synchronization with the OR gateway
          2. The working of multichoice and synchronization pattern
          3. Structured synchronizing merge pattern
          4. Local synchronizing merge pattern
        5. The parallel split and synchronization pattern
          1. Parallel split pattern
          2. Synchronization pattern
        6. Conditional parallel split and parallel merge pattern
          1. Working with conditional parallel split and merge
          2. Antipattern – the conditional parallel split and merge
        7. Multimerge pattern
          1. Exploring multimerge
        8. Discriminator and partial join pattern
          1. Structured discriminator pattern
          2. Structured partial join
          3. Working with a complex gateway to implement the discriminator and partial join pattern
            1. Testing a process by failing the complex gateway exit expression
            2. Testing process as success by the complex gateway exit expression
        9. Complex synchronization pattern
          1. Canceling discriminator pattern
          2. Canceling partial join pattern
        10. Summary
      11. 2. Multi-instance and State-based Patterns
        1. Multiple instances with prior design-time knowledge pattern
          1. Executing the multi-instance subprocess with prior design-time knowledge
        2. Multiple instances with prior runtime knowledge pattern
          1. Demonstrating MI with prior runtime knowledge
          2. Understanding how MI with prior runtime knowledge work
        3. Multiple instances without prior runtime knowledge pattern
          1. Working on MI without prior runtime knowledge
          2. Testing the use case
        4. Static partial join for multiple instances pattern
          1. Testing the use case
          2. Understanding how static partial join for MI works
            1. There's more
        5. Canceling partial join pattern
        6. Dynamic partial join for multiple instances pattern
          1. Working with dynamic partial join
          2. Understanding the functionality behind partial join for MI
        7. Structured loop pattern
          1. Working with structured loops
            1. Demystifying do-while
              1. Understanding the structured loop functionality
            2. Demystifying while-do
        8. Arbitrary cycle pattern
          1. Exploring arbitrary cycle
          2. Understanding the functionality of the arbitrary cycle
        9. Trigger patterns
          1. Transient trigger pattern
          2. Persistent trigger pattern
        10. Implicit termination pattern
          1. Amalgamating implicit termination in the process flow
        11. Explicit termination pattern
          1. Learning how explicit termination works
        12. Cancelation patterns
          1. Cancel multi-instance task pattern
        13. Summary
      12. 3. Invocation Patterns
        1. Web service pattern
          1. Asynchronous request-response (request-callback) pattern
          2. Request-response pattern
          3. One request, one of the two possible responses pattern
          4. Two request a pattern
          5. Exposing the BPM process using Receive and Send Tasks
            1. Loan Origination over Send and Receive tasks
        2. One-way invocation pattern
          1. Implementing one-way invocation using a timer
          2. Implementing one-way invocation using an e-mail
            1. The Loan Origination process over e-mail
            2. Testing the flow to instantiate a process over e-mail
        3. Publish-subscribe pattern – initiating the business process through an event
          1. Loan origination over an event
        4. Multievent instantiation pattern – process instantiation over multiple events
          1. Loan origination over multiple event occurrence
        5. Human task initiator pattern – initiating processes through human tasks
          1. Loan origination via the human task form
            1. Testing the process
        6. Guaranteed delivery pattern – process instantiation over JMS – Queue/Topic
          1. Loan origination over JMS – Queue/Topic
            1. Creating JMS resources
              1. Creating a JMS server
              2. Creating a JMS module
              3. Creating a JMS subdeployment
              4. Creating a Connection Factory
              5. Creating a queue
              6. Creating a topic
              7. Configuring the connection pool
              8. Redeploying the JMS adapter
            2. Creating the publisher process
            3. Developing the consumer process
            4. Testing the process
              1. Publish-subscribe pattern using topics
        7. Understanding multiple start events
        8. Summary
      13. 4. Human Task Patterns
        1. Learning about human tasks
        2. Milestone pattern
          1. Modeling in a human task versus a BPMN process
        3. Routing pattern
        4. Task assignment pattern
        5. List builder pattern
          1. Absolute or nonhierarchical list builders
          2. Hierarchical list builders
          3. Rule-based list builders
        6. Parallel routing pattern
          1. Getting ready to test sample use cases
          2. Parallel routing pattern with name and expression list builders
          3. Parallel routing pattern with approval group list builder
          4. Parallel routing pattern with lane participant list builder
          5. Parallel routing pattern with rule-based list builder
          6. Parallel routing pattern with management chain
        7. Serial routing pattern
          1. Serial routing pattern with list builder – name and expression
            1. Participant identification type – users
            2. Participant identification type – groups
            3. Participant identification type – application role
          2. Serial routing pattern with list builder – approval group
          3. Serial routing pattern with list builder – management chain
          4. Serial routing pattern with list builder – job level
            1. Modifying participant lists using list modification
            2. Substituting participants using list substitution
          5. Serial routing pattern with list builder – position
          6. Serial routing pattern with list builder – supervisory
          7. Serial routing pattern with list builder – rules
        8. Single routing pattern
          1. Single approver pattern with list builder – name and expression
          2. Single approver pattern with list builder – approval group
          3. Single approver pattern with list builder – management chain
        9. Notify/FYI pattern
          1. FYI approver pattern with list builder – job level
          2. FYI approver pattern with list builder – name and expression
        10. Task aggregation pattern
        11. Dispatching pattern
        12. Escalation pattern
        13. Rule-based reassignment and delegation pattern
        14. Ad hoc routing pattern
        15. Request information feature
        16. Reassignment and delegation pattern
        17. Force completion pattern
          1. Enabling early completion in parallel subtasks
        18. Routing rule pattern
        19. Deadlines
        20. Escalation, expiry, and renewal feature
        21. Exclusion feature
        22. Error assignee and reviewers
        23. Notifications
          1. Configuring driver properties and attributes
          2. Configuring the notification definition
        24. Content access policy and task actions
        25. Enterprise content management for task documents
        26. Summary
      14. 5. Interaction Patterns
        1. Defining use cases to demonstrate interaction patterns
          1. The BackOffice process
          2. The Loan origination process
          3. The CatchFraudDetails and Feedback processes
        2. Conversation pattern
        3. Asynchronous interaction pattern
          1. Interacting with an asynchronous process using the Message Throw and Catch events
          2. Interacting with an asynchronous service using the Message Throw and Catch Events
          3. Enabling external services interaction
          4. Interacting with an asynchronous process and service using Send and Receive Tasks
          5. Attaching boundary events on Send and Receive Tasks
          6. Interacting with a process defined with Receive Task as a start activity
        4. Synchronous request-response pattern
          1. The business catalog
        5. Subprocess interaction patterns
          1. Reusable process interaction pattern
          2. Use case scenario for reusable process interaction pattern
        6. Embedded subprocess interaction pattern
          1. Interrupting a boundary event
            1. Boundary event on an activity
        7. Event-driven interaction pattern
          1. Defining an event-based interaction pattern scenario
        8. Summary
      15. 6. Correlation Patterns
        1. Correlation mechanism
          1. Types of correlations
          2. Components of correlation
          3. Configuring the environment
          4. Defining correlation properties
          5. Defining correlation keys and configuring the correlation definition
          6. Understanding the correlation behavior
        2. Message-based correlation pattern
          1. Testing the message-based correlation pattern
        3. Cancel instance pattern
          1. Understanding the components
          2. Testing cancelation pattern
          3. Restart instance pattern
            1. Testing the Loan Origination process to restart a loan
            2. Testing the restart scenario
        4. Update task pattern
          1. Demonstrating the update task functionality
        5. Query pattern
          1. Testing the query pattern
        6. Suspend process pattern
        7. Suspend activity pattern
        8. Cancel activity pattern
          1. How a boundary event based activity correlation works
          2. Testing the cancelation pattern on an activity
        9. Summary
      16. 7. Exception Handling Patterns
        1. Classifying exceptions
        2. Business process state
        3. Reassigned Exception Handling Pattern
        4. Allocated Exception Handling Pattern
        5. Changing the Boundary Catch Event from Interrupting to Non-interrupting
        6. Force-Terminate Exception Handling Pattern
        7. Force-Error Exception Handling Pattern
        8. Force-Complete Exception Handling Pattern
        9. Invoked Exception Handling Pattern
        10. Invoked State Exception Handling Pattern
        11. Continue Execution Exception Handling Pattern
        12. Force-Terminate Execution Exception Handling Pattern
        13. Force-Error Execution Exception Handling Pattern
          1. Allocated state – External Exception Handling Pattern
            1. Implementing Allocated state – External Exception Handling Pattern
          2. Allocated state – Internal Exception Handling Pattern
            1. Implementing Allocated state – Internal Exception Handling Pattern
              1. Internal Complete Exception Handling Pattern
              2. Internal Terminate Exception Handling Pattern
              3. Internal Error Exception Handling Pattern
                1. Testing the Restarted scenario
          3. Reallocated Exception Handling Pattern
        14. External Exception Handling Pattern
        15. Process-Level Exception Handling Pattern
          1. Implementing Process-Level Exception Handling Pattern
          2. Testing Process-Level Exception Handling Pattern
        16. System-Level exception handling pattern
        17. External Triggers
        18. Summary
      17. 8. Adaptive Case Management
        1. Defining adaptive case management
          1. Case
          2. Case management
          3. Dynamic case management
          4. Mechanism of adaptive case management
          5. Process versus case
          6. Case management offerings
          7. The building blocks of adaptive case management
        2. Exploring ACM use case scenarios
          1. The building blocks of the Insurance Claim use case
          2. Testing the use case
        3. Case stage
        4. Event pattern
        5. Milestone pattern
        6. Case interaction pattern
        7. Localization feature
        8. Holistic view pattern
        9. Ad hoc feature
          1. Ad hoc inclusion of stakeholders
          2. Ad hoc inclusion of activities
          3. Ad hoc inclusion of documents
          4. Association of a case with subcases
          5. Ad hoc inclusion of rules and activities
        10. Summary
      18. 9. Advanced Patterns
        1. Strategic Alignment Pattern
          1. The Value Chain Model
          2. The Strategy Model
          3. Mapping goals to an organization
          4. Defining KPIs in a BPMN project
          5. Defining KPIs in a BA project
            1. Defining KPIs in a child Value Chain Model
              1. KPIs in the Value Chain Step level
              2. KPIs in the Value Chain Model level
            2. Defining KPIs in the master Value Chain Model
              1. KPIs in the Value Chain Step level
              2. KPIs in the Value Chain Model level
          6. Publishing report data
        2. Capturing the business context
        3. Emulating Process Behavior
        4. The Debugger feature
        5. Round Trip and Business-IT Collaboration
        6. Summary
      19. A. Installing Oracle BPM Suite 12c
        1. Installing JDK
        2. Installing BPM suite
        3. Configuring the default domain
        4. Enabling the demo user community
        5. Custom domain creation
        6. The BPM/SOA configuration
        7. Summary
      20. Index