- 7 minutes to read

Generate O2C Demo Data - PowerShell Script

Automate realistic Order-to-Cash demo data generation with 7 integration steps, multi-format support, and BPM metadata. This PowerShell script generates complete order flows for testing, visualization, and integration landscape demonstration.

  • ✅ Generate 7-step O2C flows (Steps 0-6) with 90% probabilistic progression
  • ✅ Multi-format messages (JSON, XML, CSV, PSV) across different systems
  • ✅ BPM metadata included for integration landscape visualization
  • ✅ 100 orders generating ~653 Log Events in < 2 seconds

Quick Facts

  • Location: Generate-O2C-Demo-Data.ps1 (Demo folder)
  • Default: 100 orders, base time 06:00 UTC, output to file or Log API
  • Data: Each order generates 14 events minimum (2 per step), completes in 90-120 minutes simulation time
  • First Order: Always completes all 7 steps for guaranteed demo content

Use Cases and Execution

Use Case 1: Quick Preview (Dry Run)

Scenario: Test the script locally and review generated structure before full execution.

.\Generate-O2C-Demo-Data.ps1 -DryRun

Output: Generates first order only. Result: ~14 events in memory, displayed as preview.

Use Case 2: Export Demo Dataset to File

Scenario: Generate complete dataset and export to JSON file for testing/documentation.

.\Generate-O2C-Demo-Data.ps1 -OrderCount 100 -ExportToFile -OutputFile "C:\Temp\O2C-Demo.json"

Output: JSON file with ~653 events (~200-300 KB). Use: Import into Postman, integrate with logging systems, or analyze BPM flows.

Use Case 3: Small Batch (Development/Testing)

Scenario: Generate fewer orders for rapid testing cycles.

.\Generate-O2C-Demo-Data.ps1 -OrderCount 10 -ExportToFile -OutputFile "C:\Temp\O2C-10.json"

Output: 10 orders (~65 events, ~50-70 KB). Use: Quick validation, local testing, CI/CD pipeline smoke tests.

Use Case 4: Large Batch (Production Demo)

Scenario: Generate comprehensive dataset for BPM visualization and integration landscape demo.

.\Generate-O2C-Demo-Data.ps1 -OrderCount 500 -ExportToFile -OutputFile "C:\Temp\O2C-500.json"

Output: 500 orders (~3,265 events, ~1-1.5 MB). Use: Demonstrate integration scale, BPM visualization, landscape topology.

Use Case 5: Direct API Integration (Production)

Scenario: Send events directly to Nodinite Log API endpoint.

.\Generate-O2C-Demo-Data.ps1 `
  -LogApiUrl "https://your-nodinite-instance/api/v2/LogEvents" `
  -ApiKey "your-api-key-here" `
  -OrderCount 100

Output: Events sent directly to Log API. Use: Live BPM visualization, real-time integration landscape updates, production demonstrations.

Parameters

Parameter Type Default Description
LogApiUrl string https://localhost:5001/api/v2/LogEvents Nodinite Log API endpoint
ApiKey string YOUR_API_KEY_HERE API authentication key
OutputFile string C:\Temp\O2C-Demo-Data.json Output file path for export
OrderCount int 100 Number of orders to generate
ExportToFile switch $false Export to JSON file instead of calling API
DryRun switch $false Preview mode (first order only)

Key Features

7-Step O2C Process: Steps 0-6 with 90% progression probability per step. First order always completes all steps.

Multi-Format Support: JSON (Steps 0, 3, 6), XML (Steps 1, 4), CSV (Step 2), PSV (Step 5) - demonstrates format diversity.

Correlation ID Format: {PREFIX}-{YYYYMMDD}-{HHMM}-{SEQUENCE} (e.g., PIC-20251024-0930-0001) for end-to-end traceability.

BPM Metadata: Each event includes RepositoryBinding with Service, ExternalServiceRelations, InternalServiceRelations, and BPM topology data.

Realistic Timing: Base time 06:00 UTC, 0.5-5 minute increments per step, 2-10 minute order spacing, processing times 5-300ms.

Output: ~653 events from 100 orders (~200-300 KB), ~65 events per order average, generated in < 2 seconds.

  • Step 5: 59 events (59% probability)
  • Step 6: 53 events (53% probability)

Average Events per Order: 6.53 Full Happy-Path Orders: ~53 (53%) Incomplete Orders: ~47 (47%) First Order: Always completes all 7 steps (100% complete for testing)

Data Volume

  • File Size (JSON): ~200-300 KB
  • Generation Time: < 2 seconds
  • Each Log Event: ~1-2 KB
  • Each RepositoryBinding: ~3-5 KB (includes BPM metadata)

Output Examples

Export Format

When exported to file with -ExportToFile, the output is a JSON array of log events. Each event includes the RepositoryBinding with BPM metadata:

[
  {
    "LogAgentValueId": 5,
    "EndPointName": "Portal-OrderReceived-Drop",
    "EndPointUri": "C:\\Integration\\Portal\\Orders\\In",
    "EndPointDirection": 0,
    "EndPointTypeId": 60,
    "OriginalMessageTypeName": "O2C.Order.Received/1.0",
    "LogDateTime": "2025-10-14T06:05:30.123Z",
    "ProcessName": "O2C-Order-Reception",
    "Context": {
      "FileName": "ORD-10001-order-received-from-customer.json",
      "OrderNumber": "ORD-10001",
      "CustomerId": "CUST-001",
      "CustomerName": "Acme Corporation",
      "OrderAmount": "99.95",
      "ExtendedProperties/1.0#RepositoryBinding": "{\"Name\":\"Standard Transport Contract\",\"Service\":{\"Name\":\"INT1337-RCV-Order-Incoming\",\"Direction\":\"Receive\",\"System\":{\"Name\":\"Portal\"},\"Integration\":{\"Name\":\"INT1337 - Order-to-Cash\"},\"BPMs\":[{\"Name\":\"INT1337 - Order-to-Cash Flow\",\"ArtifactRenaming\":\"Order Received\",\"Domain\":{\"Name\":\"Sales\",\"Index\":0},\"Step\":0,\"ServiceRelations\":[...]}]}}"
    },
    "Body": "eyJnZW5lcmF0ZWRBdCI6IjIwMjUtMTAtMTRUMDY6MDU6MzAuMDAwMDAwMFoiLCJjdXJyZW5jeSI6IlVTRCIsImJhdGNoSWQiOiJiYXRjaC0yMDI1LTEwLTE0LTAwMSIsIm9yZGVyRGF0ZSI6IjIwMjUtMTAtMTRUMDY6MDU6MzAuMDAwMDAwMFoiLCJvcmRlcklkIjoiT1JELTEwMDAxIiwib3JkZXJUb3RhbCI6OTkuOTUsIm9yZGVyUm93cyI6W3sicm93SWQiOjEsImxpbmVUb3RhbCI6OTkuOTUsInVuaXRQcmljZSI6OTkuOTUsInF1YW50aXR5IjoxLCJza3UiOiJTS1UtREVNTy0wMDEiLCJkZXNjcmlwdGlvbiI6IkRlbW8gV2lkZ2V0In1dLCJjdXN0b21lciI6eyJjdXN0b21lcklkIjoiQ1VTVC0wMDEiLCJuYW1lIjoiQWNtZSBDb3Jwb3JhdGlvbiIsImVtYWlsIjoib3JkZXJzQGFjbWUuZXhhbXBsZS5jb20ifX0="
  },
  ...
]

Note: The Body field contains the base64-encoded message (JSON/XML/CSV/PSV). The ExtendedProperties/1.0#RepositoryBinding in Context contains the integration metadata for visualization.

Execution Steps

Step 1: Open PowerShell as Administrator 

# Open Windows Terminal or PowerShell ISE

Step 2: Navigate to Demo Directory 

cd "c:\Code\Docs\products-documentation\Integration Manager\Documentation\Core Services\Log API\Troubleshooting\Demo"

Step 3: Set Execution Policy (if needed) 

Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process

Step 4: Run the Script 

# Option A: Preview (dry run - first order only)
.\Generate-O2C-Demo-Data.ps1 -DryRun

# Option B: Export 100 orders to file
.\Generate-O2C-Demo-Data.ps1 -ExportToFile -OutputFile "C:\Temp\O2C-Demo.json"

# Option C: Export custom count to file
.\Generate-O2C-Demo-Data.ps1 -OrderCount 500 -ExportToFile -OutputFile "C:\Temp\O2C-500.json"

Step 5: View Results 

# Inspect the generated file
Get-Content "C:\Temp\O2C-Demo.json"|ConvertFrom-Json|Measure-Object
Get-Item "C:\Temp\O2C-Demo.json"|Select-Object Length

Integration with Nodinite

Using Generated Data in Log API

Option 1: Import JSON File to Postman

  1. Export data: .\Generate-O2C-Demo-Data.ps1 -ExportToFile
  2. Use Postman Collection to batch import the JSON
  3. Or parse JSON and call Log API in a loop

Option 2: Direct API Call (Future Enhancement)

The script includes framework for direct API calls. To implement:

# Add to script after log event creation:
$headers = @{
    "Content-Type" = "application/json"
    "x-ms-client-tracking-id" = $correlationId
    "Authorization" = "Bearer $ApiKey"
}

$response = Invoke-RestMethod -Uri $LogApiUrl `
                              -Method Post `
                              -Headers $headers `
                              -Body ($logEvent | ConvertTo-Json)

Performance Considerations

Generation Performance

  • Small batch (50 orders): < 1 second
  • Medium batch (100 orders): < 2 seconds
  • Large batch (500 orders): ~5 seconds
  • Very large batch (1000 orders): ~10 seconds

Memory Usage

  • Approximately 20-50 MB RAM for 100 orders
  • Approximately 100-200 MB RAM for 1000 orders
  • JSON serialization uses efficient approach

Network Considerations

If sending to Log API:

  • Each event: ~1-2 KB (plus ~3-5 KB RepositoryBinding in Context)
  • Total for 100 orders: 100 orders × 6.5 events × 4 KB avg = ~2.6 MB
  • Recommend batching: 50-100 events per API call

Troubleshooting

Issue: "Cannot find path"

Solution: Ensure PowerShell working directory is correct:

Get-Location
cd "c:\Code\Docs\products-documentation\Integration Manager\Documentation\Core Services\Log API\Troubleshooting\Demo"

Issue: Execution Policy Error

Solution: Set execution policy for current process:

Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process

Issue: JSON Parse Error

Solution: Validate generated file is valid JSON:

$json = Get-Content "C:\Temp\O2C-Demo.json"|ConvertFrom-Json
$json|Measure-Object  # Should show count of events

Next Steps