You are previewing BizTalk 2010 Recipes: A Problem-Solution Approach.
O'Reilly logo
BizTalk 2010 Recipes: A Problem-Solution Approach

Book Description

BizTalk 2010 Recipes provides ready-made solutions to BizTalk Server 2010 developers. The recipes in the book save you the effort of developing your own solutions to common problems that have been solved many times over. The solutions demonstrate sound practice, the result of hard-earned wisdom by those who have gone before.

Presented in a step-by-step format with clear code examples and explanations, the solutions in BizTalk 2010 Recipes help you take advantage of new features and deeper capabilities in BizTalk Server 2010. You'll learn to provide rich mapping support, extended EDI and trading partner management capabilities, and to deploy the growing range of adapters for integrating with the different systems and technologies that you will encounter.

Author Mark Beckner doesn't overlook core functionality either. You'll find recipes covering all the core areas: schemas, maps, orchestrations, messaging and more. BizTalk Server 2010 is Microsoft's market-leading platform for orchestrating process flow across disparate applications. BizTalk 2010 Recipes is your key to unlocking the full power of that platform.

Table of Contents

  1. Copyright
  2. Foreword
  3. About the Author
  4. About the Technical Reviewer
  5. Acknowledgments
  6. 1. What's New in BizTalk 2010
    1. 1.1. Using the Relevance Tree View
      1. 1.1.1. Problem
      2. 1.1.2. Solution
      3. 1.1.3. How It Works
    2. 1.2. Navigating the Mapping Surface
      1. 1.2.1. Problem
      2. 1.2.2. Solution
      3. 1.2.3. How It Works
    3. 1.3. Correcting Errors in Functoids
      1. 1.3.1. Problem
      2. 1.3.2. Solution
      3. 1.3.3. How It Works
    4. 1.4. Indicating Matches in Maps
      1. 1.4.1. Problem
      2. 1.4.2. Solution
      3. 1.4.3. How It Works
    5. 1.5. Configuring Core Server Settings
      1. 1.5.1. Problem
      2. 1.5.2. Solution
      3. 1.5.3. How It Works
    6. 1.6. Transfering Files Using SFTP
      1. 1.6.1. Problem
      2. 1.6.2. Solution
      3. 1.6.3. How It Works
    7. 1.7. Accessing the EDI Version 5010 HIPAA Schemas
      1. 1.7.1. Problem
      2. 1.7.2. Solution
      3. 1.7.3. How It Works
    8. 1.8. Configuring EDI Trading Partners
      1. 1.8.1. Problem
      2. 1.8.2. Solution
      3. 1.8.3. How It Works
    9. 1.9. Zooming out on an Orchestration
      1. 1.9.1. Problem
      2. 1.9.2. Solution
      3. 1.9.3. How It Works
    10. 1.10. Installing BizTalk Server RFID 2010
      1. 1.10.1. Problem
      2. 1.10.2. Solution
      3. 1.10.3. How It Works
  7. 2. Document Schemas
    1. 2.1. Creating Simple Document Schemas
      1. 2.1.1. Problem
      2. 2.1.2. Solution
      3. 2.1.3. How It Works
    2. 2.2. Creating a Schema Based on an Existing XML Document
      1. 2.2.1. Problem
      2. 2.2.2. Solution
      3. 2.2.3. How It Works
    3. 2.3. Creating Schema Namespaces
      1. 2.3.1. Problem
      2. 2.3.2. Solution
      3. 2.3.3. How It Works
    4. 2.4. Promoting Properties
      1. 2.4.1. Problem
      2. 2.4.2. Solution
      3. 2.4.3. How It Works
    5. 2.5. Creating Property Schemas
      1. 2.5.1. Problem
      2. 2.5.2. Solution
      3. 2.5.3. How It Works
    6. 2.6. Importing Schemas
      1. 2.6.1. Problem
      2. 2.6.2. Solution
      3. 2.6.3. How It Works
    7. 2.7. Referencing Schemas
      1. 2.7.1. Problem
      2. 2.7.2. Solution
      3. 2.7.3. How It Works
    8. 2.8. Creating Envelopes to Split Inbound Data
      1. 2.8.1. Problem
      2. 2.8.2. Solution
      3. 2.8.3. How It Works
    9. 2.9. Creating Complex Types
      1. 2.9.1. Problem
      2. 2.9.2. Solution
      3. 2.9.3. How It Works
    10. 2.10. Defining Regular Expressions
      1. 2.10.1. Problem
      2. 2.10.2. Solution
      3. 2.10.3. How It Works
    11. 2.11. Creating Flat File Schemas
      1. 2.11.1. Problem
      2. 2.11.2. Solution
      3. 2.11.3. How It Works
    12. 2.12. Creating Flat File Schemas via the Wizard
      1. 2.12.1. Problem
      2. 2.12.2. Solution
      3. 2.12.3. How It Works
    13. 2.13. Creating SOAP Header Schemas
      1. 2.13.1. Problem
      2. 2.13.2. Solution
      3. 2.13.3. How It Works
  8. 3. Document Mapping
    1. 3.1. Creating Simple Maps
      1. 3.1.1. Problem
      2. 3.1.2. Solution
      3. 3.1.3. How It Works
    2. 3.2. Organizing Maps
      1. 3.2.1. Problem
      2. 3.2.2. Solution
      3. 3.2.3. How It Works
    3. 3.3. Adding and Configuring Mapping Constants
      1. 3.3.1. Problem
      2. 3.3.2. Solution
      3. 3.3.3. How It Works
    4. 3.4. Mapping Any Element Nodes
      1. 3.4.1. Problem
      2. 3.4.2. Solution
      3. 3.4.3. How It Works
    5. 3.5. Using the Value Mapping Functoids
      1. 3.5.1. Problem
      2. 3.5.2. Solution
      3. 3.5.3. How It Works
    6. 3.6. Using the Table Looping Functoid
      1. 3.6.1. Problem
      2. 3.6.2. Solution
      3. 3.6.3. How It Works
    7. 3.7. Using the Database Lookup Functoid
      1. 3.7.1. Problem
      2. 3.7.2. Solution
      3. 3.7.3. How It Works
      4. 3.7.4. Security Considerations
      5. 3.7.5. Architecture Considerations
      6. 3.7.6. Advanced Database Lookup Functoid Usage
    8. 3.8. Seeding Cross-Reference Tables with ID Cross-References
      1. 3.8.1. Problem
      2. 3.8.2. Solution
      3. 3.8.3. How It Works
    9. 3.9. Seeding Cross-Reference Tables with Value Cross-References
      1. 3.9.1. Problem
      2. 3.9.2. Solution
      3. 3.9.3. How It Works
    10. 3.10. Using the ID Cross-Reference Functoids
      1. 3.10.1. Problem
      2. 3.10.2. Solution
      3. 3.10.3. How It Works
    11. 3.11. Using the Value Cross-Reference Functoids
      1. 3.11.1. Problem
      2. 3.11.2. Solution
      3. 3.11.3. How It Works
    12. 3.12. Using the Looping Functoid
      1. 3.12.1. Problem
      2. 3.12.2. Solution
      3. 3.12.3. How It Works
    13. 3.13. Using the Iteration Functoid
      1. 3.13.1. Problem
      2. 3.13.2. Solution
      3. 3.13.3. How It Works
    14. 3.14. Creating a Custom Functoid
      1. 3.14.1. Problem
      2. 3.14.2. Solution
      3. 3.14.3. How It Works
    15. 3.15. Using the Date and Time Functoids
      1. 3.15.1. Problem
      2. 3.15.2. Solution
      3. 3.15.3. How It Works
    16. 3.16. Creating Functoid If-Then-Else Logic
      1. 3.16.1. Problem
      2. 3.16.2. Solution
      3. 3.16.3. How It Works
    17. 3.17. Calling Compiled Assemblies
      1. 3.17.1. Problem
      2. 3.17.2. Solution
      3. 3.17.3. How It Works
    18. 3.18. Using Inline C#
      1. 3.18.1. Problem
      2. 3.18.2. Solution
      3. 3.18.3. How It Works
    19. 3.19. Passing Orchestration Variables into Maps
      1. 3.19.1. Problem
      2. 3.19.2. Solution
      3. 3.19.3. How It Works
    20. 3.20. Using Inline XSLT
      1. 3.20.1. Problem
      2. 3.20.2. Solution
      3. 3.20.3. How It Works
    21. 3.21. Using XSLT Call Templates
      1. 3.21.1. Problem
      2. 3.21.2. Solution
      3. 3.21.3. How It Works
    22. 3.22. Using XSLT Group-By
      1. 3.22.1. Problem
      2. 3.22.2. Solution
      3. 3.22.3. How It Works
    23. 3.23. Using an External XSLT File for a Map
      1. 3.23.1. Problem
      2. 3.23.2. Solution
      3. 3.23.3. How It Works
    24. 3.24. Testing Maps
      1. 3.24.1. Problem
      2. 3.24.2. Solution
      3. 3.24.3. How It Works
    25. 3.25. Debugging a Map Using Visual Studio
      1. 3.25.1. Problem
      2. 3.25.2. Solution
      3. 3.25.3. How It Works
  9. 4. Messaging and Pipelines
    1. 4.1. Configuring Receive Ports and Locations
      1. 4.1.1. Problem
      2. 4.1.2. Solution
      3. 4.1.3. How It Works
    2. 4.2. Configuring Send Ports
      1. 4.2.1. Problem
      2. 4.2.2. Solution
      3. 4.2.3. How It Works
    3. 4.3. Configuring Port Maps
      1. 4.3.1. Problem
      2. 4.3.2. Solution
      3. 4.3.3. How It Works
    4. 4.4. Using Send Port Groups
      1. 4.4.1. Problem
      2. 4.4.2. Solution
      3. 4.4.3. How It Works
    5. 4.5. Creating Validation Pipelines
      1. 4.5.1. Problem
      2. 4.5.2. Solution
      3. 4.5.3. How It Works
    6. 4.6. Creating Encryption Pipelines
      1. 4.6.1. Problem
      2. 4.6.2. Solution
      3. 4.6.3. Send an Encrypted Message
      4. 4.6.4. Receive an Encrypted Message
      5. 4.6.5. How It Works
    7. 4.7. Creating Flat File Send and Receive Pipelines
      1. 4.7.1. Problem
      2. 4.7.2. Solution
      3. 4.7.3. How It Works
    8. 4.8. Creating Custom Pipeline Components
      1. 4.8.1. Problem
      2. 4.8.2. Solution
      3. 4.8.3. How It Works
      4. 4.8.4. Attributes and Class Declaration
      5. 4.8.5. Design-Time Properties
      6. 4.8.6. Implementation of the Four Pipeline Interfaces
        1. 4.8.6.1. IBaseComponent
        2. 4.8.6.2. IComponentUI
        3. 4.8.6.3. IPersistPropertyBag
        4. 4.8.6.4. IComponent
    9. 4.9. Handling Pipeline Errors
      1. 4.9.1. Problem
      2. 4.9.2. Solution
      3. 4.9.3. How It Works
    10. 4.10. Subscribing to Suspended Messages
      1. 4.10.1. Problem
      2. 4.10.2. Solution
      3. 4.10.3. How It Works
  10. 5. Orchestrations
    1. 5.1. Receiving Messages
      1. 5.1.1. Problem
      2. 5.1.2. Solution
      3. 5.1.3. How It Works
    2. 5.2. Sending Messages
      1. 5.2.1. Problem
      2. 5.2.2. Solution
      3. 5.2.3. How It Works
    3. 5.3. Creating Multipart Messages
      1. 5.3.1. Problem
      2. 5.3.2. Solution
      3. 5.3.3. How It Works
    4. 5.4. Binding Orchestrations
      1. 5.4.1. Problem
      2. 5.4.2. Solution
      3. 5.4.3. How It Works
    5. 5.5. Configuring a Send Port at Runtime
      1. 5.5.1. Problem
      2. 5.5.2. Solution
      3. 5.5.3. How It Works
    6. 5.6. Creating Branching Logic in an Orchestration
      1. 5.6.1. Problem
      2. 5.6.2. Solution
      3. 5.6.3. How It Works
    7. 5.7. Receiving Multiple Message Formats in a Single Orchestration
      1. 5.7.1. Problem
      2. 5.7.2. Solution
      3. 5.7.3. How It Works
    8. 5.8. Calling External Assemblies
      1. 5.8.1. Problem
      2. 5.8.2. Solution
      3. 5.8.3. How It Works
    9. 5.9. Receiving Untyped Messages
      1. 5.9.1. Problem
      2. 5.9.2. Solution
      3. 5.9.3. How It Works
    10. 5.10. Using the Parallel Action Shape
      1. 5.10.1. Problem
      2. 5.10.2. Solution
      3. 5.10.3. How It Works
    11. 5.11. Using the Loop Shape
      1. 5.11.1. Problem
      2. 5.11.2. Solution
      3. 5.11.3. How It Works
    12. 5.12. Using the Transform Shape
      1. 5.12.1. Problem
      2. 5.12.2. Solution
      3. 5.12.3. How It Works
    13. 5.13. Using the Call Orchestration and Start Orchestration Shapes
      1. 5.13.1. Problem
      2. 5.13.2. Solution
      3. 5.13.3. How It Works
    14. 5.14. Configuring Basic Correlations
      1. 5.14.1. Problem
      2. 5.14.2. Solution
      3. 5.14.3. How It Works
    15. 5.15. Maintaining Message Order
      1. 5.15.1. Problem
      2. 5.15.2. Solution
      3. 5.15.3. How It Works
        1. 5.15.3.1. Working with Sequential Convoys
        2. 5.15.3.2. Fine-Tuning Sequential Convoys
    16. 5.16. Configuring Parallel Convoys
      1. 5.16.1. Problem
      2. 5.16.2. Solution
      3. 5.16.3. How It Works
    17. 5.17. Using XPath Queries on Messages
      1. 5.17.1. Problem
      2. 5.17.2. Solution
      3. 5.17.3. How It Works
    18. 5.18. Using Nontransactional Orchestration Scopes
      1. 5.18.1. Problem
      2. 5.18.2. Solution
      3. 5.18.3. How It Works
        1. 5.18.3.1. Error Information
        2. 5.18.3.2. Multiple Exception Handlers
    19. 5.19. Creating Atomic Scopes
      1. 5.19.1. Problem
      2. 5.19.2. Solution
      3. 5.19.3. How It Works
        1. 5.19.3.1. Atomic Scope Considerations
        2. 5.19.3.2. Atomic Scope Benefits
        3. 5.19.3.3. Exception Handling
        4. 5.19.3.4. Compensation Handling
        5. 5.19.3.5. MSDTC Transactions
    20. 5.20. Using Long-Running Transactions
      1. 5.20.1. Problem
      2. 5.20.2. Solution
      3. 5.20.3. How It Works
    21. 5.21. Catching Exceptions Consistently
      1. 5.21.1. Problem
      2. 5.21.2. Solution
      3. 5.21.3. How It Works
        1. 5.21.3.1. Exception Handler Buffer Call Request Schema
        2. 5.21.3.2. Exception Handler Buffer Call Response Schema
        3. 5.21.3.3. Task Processing Logic Call Schema
        4. 5.21.3.4. Task Processing Logic Response Schema
        5. 5.21.3.5. Error To Administrator Schema
    22. 5.22. Creating Role Links
      1. 5.22.1. Problem
      2. 5.22.2. Solution
        1. 5.22.2.1. Create the BizTalk Solution
        2. 5.22.2.2. Create the Orchestration Role Links
        3. 5.22.2.3. Create the Role Link Send Port Type
        4. 5.22.2.4. Create Parties and Physical Send Ports
        5. 5.22.2.5. Test the Role Links
      3. 5.22.3. How It Works
    23. 5.23. Calling Web Services
      1. 5.23.1. Problem
      2. 5.23.2. Solution
      3. 5.23.3. How It Works
    24. 5.24. Exposing an Orchestration as a Service
      1. 5.24.1. Problem
      2. 5.24.2. Solution
      3. 5.24.3. How It Works
    25. 5.25. Calling Pipelines from Within an Orchestration
      1. 5.25.1. Problem
      2. 5.25.2. Solution
      3. 5.25.3. How It Works
        1. 5.25.3.1. Mainline Process
        2. 5.25.3.2. Exception Handling
  11. 6. Adapters
    1. 6.1. Configuring File Sends
      1. 6.1.1. Problem
      2. 6.1.2. Solution
      3. 6.1.3. How It Works
    2. 6.2. Configuring File Receives
      1. 6.2.1. Problem
      2. 6.2.2. Solution
      3. 6.2.3. How It Works
    3. 6.3. Configuring SMTP Send Ports
      1. 6.3.1. Problem
      2. 6.3.2. Solution
      3. 6.3.3. How It Works
    4. 6.4. Configuring MSMQ Sends
      1. 6.4.1. Problem
      2. 6.4.2. Solution
      3. 6.4.3. How It Works
      4. 6.4.4. MSMQ Send Options
      5. 6.4.5. MSMQ Queue Name Formats
    5. 6.5. Configuring MSMQ Receives
      1. 6.5.1. Problem
      2. 6.5.2. Solution
      3. 6.5.3. How It Works
      4. 6.5.4. MSMQ Receive Options
      5. 6.5.5. MSMQ Queue Name Formats
    6. 6.6. Sending Updategrams
      1. 6.6.1. Problem
      2. 6.6.2. Solution
      3. 6.6.3. Task 1: Create Supporting Artifacts
      4. 6.6.4. Task 2: Create BizTalk Solution Artifacts
      5. 6.6.5. Task 3: Create Physical BizTalk Ports
      6. 6.6.6. Task 4: Test the Solution
      7. 6.6.7. How It Works
    7. 6.7. Calling Stored Procedures
      1. 6.7.1. Problem
      2. 6.7.2. Solution
      3. 6.7.3. Task 1: Create Supporting Artifacts
      4. 6.7.4. Task 2: Create BizTalk Solution Artifacts
      5. 6.7.5. Task 3: Create Physical BizTalk Ports
      6. 6.7.6. Task 4: Test the Solution
      7. 6.7.7. How It Works
    8. 6.8. Receiving Messages with the SQL Adapter
      1. 6.8.1. Problem
      2. 6.8.2. Solution
      3. 6.8.3. Task 1: Create Supporting Artifacts
      4. 6.8.4. Task 2: Create BizTalk Solution Artifacts
      5. 6.8.5. Task 3: Create Physical BizTalk Ports
      6. 6.8.6. Task 4: Test the Solution
      7. 6.8.7. How It Works
      8. 6.8.8. Stored Procedure Configuration
      9. 6.8.9. Adapter Configuration
    9. 6.9. Configuring HTTP Sends
      1. 6.9.1. Problem
      2. 6.9.2. Solution
      3. 6.9.3. How It Works
    10. 6.10. Configuring HTTP Receives
      1. 6.10.1. Problem
      2. 6.10.2. Solution
      3. 6.10.3. How It Works
    11. 6.11. Configuring SOAP Sends and Receives
      1. 6.11.1. Problem
      2. 6.11.2. Solution
      3. 6.11.3. How It Works
    12. 6.12. Creating Ports Through C# Applications
      1. 6.12.1. Problem
      2. 6.12.2. Solution
      3. 6.12.3. How It Works
  12. 7. Business Rules Framework
    1. 7.1. Creating a Business Policy
      1. 7.1.1. Problem
      2. 7.1.2. Solution
      3. 7.1.3. How It Works
    2. 7.2. Creating and Testing Rules
      1. 7.2.1. Problem
      2. 7.2.2. Solution
      3. 7.2.3. How It Works
    3. 7.3. Creating Facts
      1. 7.3.1. Problem
      2. 7.3.2. Solution
      3. 7.3.3. How It Works
    4. 7.4. Setting Rule Priorities
      1. 7.4.1. Problem
      2. 7.4.2. Solution
      3. 7.4.3. How It Works
    5. 7.5. Creating Custom Fact Retrievers
      1. 7.5.1. Problem
      2. 7.5.2. Solution
      3. 7.5.3. How It Works
    6. 7.6. Calling the Business Rules Engine from .NET
      1. 7.6.1. Problem
      2. 7.6.2. Solution
      3. 7.6.3. How It Works
      4. 7.6.4. Executing a Policy
      5. 7.6.5. Passing Data Connection Facts
    7. 7.7. Calling the Business Rules Engine from an Orchestration
      1. 7.7.1. Problem
      2. 7.7.2. Solution
      3. 7.7.3. How It Works
    8. 7.8. Deploying and Undeploying Policies
      1. 7.8.1. Problem
      2. 7.8.2. Solution
      3. 7.8.3. How It Works
  13. 8. EDI Solutions
    1. 8.1. Adding an EDI Schema to a Project
      1. 8.1.1. Problem
      2. 8.1.2. Solution
      3. 8.1.3. How It Works
    2. 8.2. Creating an EDI Map
      1. 8.2.1. Problem
      2. 8.2.2. Solution
      3. 8.2.3. How It Works
    3. 8.3. Defining Complex Mappings in External XSLT
      1. 8.3.1. Problem
      2. 8.3.2. Solution
      3. 8.3.3. How It Works
    4. 8.4. Creating and Configuring a Trading Partner
      1. 8.4.1. Problem
      2. 8.4.2. Solution
      3. 8.4.3. How It Works
    5. 8.5. Configuring an EDI Envelope
      1. 8.5.1. Problem
      2. 8.5.2. Solution
      3. 8.5.3. How It Works
    6. 8.6. Configuring Automatic Acknowledgements
      1. 8.6.1. Problem
      2. 8.6.2. Solution
      3. 8.6.3. How It Works
    7. 8.7. Configuring EDI Validation with Pipelines
      1. 8.7.1. Problem
      2. 8.7.2. Solution
      3. 8.7.3. How It Works
    8. 8.8. Creating Custom EDI Pipelines
      1. 8.8.1. Problem
      2. 8.8.2. Solution
      3. 8.8.3. How It Works
    9. 8.9. Subscribing to EDI Promoted Properties
      1. 8.9.1. Problem
      2. 8.9.2. Solution
      3. 8.9.3. How it Works
  14. 9. Deployment
    1. 9.1. Exporting Applications
      1. 9.1.1. Problem
      2. 9.1.2. Solution
      3. 9.1.3. How It Works
        1. 9.1.3.1. Exporting Application Subsets
        2. 9.1.3.2. Exporting Bindings
        3. 9.1.3.3. Exporting Policies
    2. 9.2. Importing Applications
      1. 9.2.1. Problem
      2. 9.2.2. Solution
      3. 9.2.3. How It Works
    3. 9.3. Manually Deploying Updates
      1. 9.3.1. Problem
      2. 9.3.2. Solution
      3. 9.3.3. How It Works
    4. 9.4. Deploying a BizTalk Solution from Visual Studio
      1. 9.4.1. Problem
      2. 9.4.2. Solution
      3. 9.4.3. How It Works
    5. 9.5. Enlisting and Starting Send Ports
      1. 9.5.1. Problem
      2. 9.5.2. Solution
      3. 9.5.3. How It Works
    6. 9.6. Enabling Receive Locations
      1. 9.6.1. Problem
      2. 9.6.2. Solution
      3. 9.6.3. How It Works
    7. 9.7. Enlisting and Starting Orchestrations
      1. 9.7.1. Problem
      2. 9.7.2. Solution
      3. 9.7.3. How It Works
  15. 10. Administration and Operations
    1. 10.1. Troubleshooting Suspended Services
      1. 10.1.1. Problem
      2. 10.1.2. Solution
      3. 10.1.3. How It Works
    2. 10.2. Resubmitting Messages
      1. 10.2.1. Problem
      2. 10.2.2. Solution
      3. 10.2.3. How It Works
    3. 10.3. Managing BizTalk Applications
      1. 10.3.1. Problem
      2. 10.3.2. Solution
      3. 10.3.3. How It Works
    4. 10.4. Debugging Orchestrations
      1. 10.4.1. Problem
      2. 10.4.2. Solution
      3. 10.4.3. How It Works
    5. 10.5. Tracking Messages
      1. 10.5.1. Problem
      2. 10.5.2. Solution
        1. 10.5.2.1. Configure Tracking
        2. 10.5.2.2. Access Tracked Messages
      3. 10.5.3. How It Works
    6. 10.6. Restarting the BizTalk Host Instance(s)
      1. 10.6.1. Problem
      2. 10.6.2. Solution
      3. 10.6.3. How It Works
    7. 10.7. Throttle Orchestration Memory Usage
      1. 10.7.1. Problem
      2. 10.7.2. Solution
      3. 10.7.3. How It Works
    8. 10.8. Resuming Inbound Message Processing
      1. 10.8.1. Problem
      2. 10.8.2. Solution
      3. 10.8.3. How It Works
  16. 11. Business Activity Monitoring
    1. 11.1. Creating BAM Activities and Views
      1. 11.1.1. Problem
      2. 11.1.2. Solution
        1. 11.1.2.1. Create the BAM Activity Workbook
        2. 11.1.2.2. Outline the BAM View
        3. 11.1.2.3. Identify Aggregations, Dimensions, and Measures
        4. 11.1.2.4. Construct the Pivot Table
      3. 11.1.3. How It Works
        1. 11.1.3.1. Create the BAM Activity Workbook
        2. 11.1.3.2. Outline the BAM View
        3. 11.1.3.3. Identify Aggregations, Dimensions, and Measures
        4. 11.1.3.4. Construct the Pivot Table
        5. 11.1.3.5. Activity Grouping and Multiple Processes
        6. 11.1.3.6. Summary
    2. 11.2. Deploying BAM Activities and Views
      1. 11.2.1. Problem
      2. 11.2.2. Solution
      3. 11.2.3. How It Works
    3. 11.3. Using the BAM Portal
      1. 11.3.1. Problem
      2. 11.3.2. Solution
        1. 11.3.2.1. Accessing the BAM Portal
        2. 11.3.2.2. Performing an Activity Search
        3. 11.3.2.3. Viewing Aggregations
      3. 11.3.3. How It Works
    4. 11.4. Setting Up BAM Alerts
      1. 11.4.1. Problem
      2. 11.4.2. Solution
      3. 11.4.3. How It Works
    5. 11.5. Using the BAM Interceptor
      1. 11.5.1. Problem
      2. 11.5.2. Solution
      3. 11.5.3. How It Works
    6. 11.6. Creating a BAM Service Request
      1. 11.6.1. Problem
      2. 11.6.2. Solution
      3. 11.6.3. How It Works
    7. 11.7. Creating a Tracking Profile
      1. 11.7.1. Problem
      2. 11.7.2. Solution
        1. 11.7.2.1. Select the Activity and Artifacts
        2. 11.7.2.2. Map Events and Data Items
        3. 11.7.2.3. Save and Apply the Tracking Profile
      3. 11.7.3. How It Works
        1. 11.7.3.1. Select the Activity and Artifacts
        2. 11.7.3.2. Map Events and Data Items
        3. 11.7.3.3. Save and Apply the Tracking Profile
          1. 11.7.3.3.1. Activity Tree Items
          2. 11.7.3.3.2. Activity Continuation
          3. 11.7.3.3.3. Activity Relationships