SAP MRP Automated Data Generator

Overview

MRP (Material Requirements Planning) automated data generator that creates end-to-end demand-to-production-order documents via JCo RFC: planned independent requirements (PIR), MRP run, stock/requirements review, and planned-order-to-production-order conversion. Generates realistic SAP MRP transaction data on S/4HANA IDES using the bike finished goods family (MZ-FG-*).

Same SAP system as OTC, PP, and P2P. All programs connect to the same S/4HANA IDES instance. MRP creates demand via PIR and lets the MRP run generate planned orders, which are then converted to production orders. The bike family materials (MZ-FG-*, MZ-RM-*) are shared with the PP generator.

SAP System

System: S/4HANA IDES (SID: S4H)
Release: 758 (HANA DB)
Client: 100
System Number: 03 (port 3303)
Company Code: 1710
Plant: 1710
Currency: USD

MRP Configuration

MRP Type: PD (deterministic)
Lot Size: EX (lot-for-lot)
Procurement: BESKZ=E (in-house production)
Finished Goods: 9 bike models (MZ-FG-*)
BOM Components: 7–10 per FG (MZ-RM-*)
Java Class: SAPMRPWorkflow.java
Connection: JCo RFC from local Mac

Local Connectivity

Everything runs from the local Mac — no need to SSH into sapidess4 or sapidesecc8. Client 100 is used for all operations.

Two connection methods are available: JCo RFC for BAPIs and function modules (used by the generator), and HANA SQL for direct database queries (useful for verification and debugging).

SAP RFC via JCo (BAPIs)

The generator connects directly to SAP over the network using the JCo 3 library. No SSH tunnel needed.

Parameter	Value
Host	`sapidess4.fivetran-internal-sales.com`
System Number	`03` (port 3303)
Client	`100`
User	`IDES`
Password	`(see vault)`
Language	`EN`

Required local files

`../SAPjco/sapjco3.jar`	Java JCo library
`../SAPjco/libsapjco3.dylib`	macOS ARM64 native library

# Run the generator locally
java -Xmx512m -cp .:../SAPjco/sapjco3.jar \
  -Djava.library.path=../SAPjco SAPMRPWorkflow full 1

HANA Database (direct SQL)

Connect to HANA via SSH tunnel for direct SQL queries. Only the tunnel uses SSH — you never log into the server.

Parameter	Value
Tunnel	`localhost:30015` → `sapidess4:30015`
Database	`FIV` (S/4HANA tenant)
User	`SAPHANADB`
Password	`(see vault)`
Python lib	`pip3 install hdbcli`

# Step 1: Start SSH tunnel (runs in background, one-time)
ssh -f -N -L 30015:127.0.0.1:30015 root@sapidess4

# Step 2: Query HANA via Python
python3 -c "
from hdbcli import dbapi
conn = dbapi.connect(address='localhost', port=30015,
    user='SAPHANADB', password='(see vault)', databaseName='FIV')
cur = conn.cursor()
cur.execute(\"SELECT PLNUM, MATNR, GSMNG FROM PLAF WHERE MATNR LIKE 'MZ%'\")
for row in cur.fetchall(): print(row)
"

Useful HANA queries for MRP

-- PIR demand
SELECT * FROM PBIM WHERE MATNR LIKE 'MZ-FG%' AND WERKS = '1710';

-- Planned orders
SELECT PLNUM, MATNR, GSMNG, PSTTR, PEDTR
FROM PLAF WHERE MATNR LIKE 'MZ%' AND PLWRK = '1710';

-- Production orders from conversion
SELECT AUFNR, OBJNR FROM AUFK
WHERE AUFNR IN ('000001002166', '000001002167');

Finished Goods (Bike Family)

All 9 finished goods are FERT materials with BOM + Routing in plant 1710, MRP type PD (deterministic planning), lot size EX (lot-for-lot), BESKZ='E' (in-house production).

Material	Description	MRP Type	Lot Size	Components
`MZ-FG-C900`	C900 BIKE	PD	EX	7 ROH
`MZ-FG-C950`	C950 BIKE	PD	EX	7 ROH
`MZ-FG-C990`	C990 Bike	PD	EX	7 ROH
`MZ-FG-M500`	M500 BIKE	PD	EX	7 ROH
`MZ-FG-M525`	M525 BIKE	PD	EX	7 ROH
`MZ-FG-M550`	M550 BIKE	PD	EX	7 ROH
`MZ-FG-R100`	R100 BIKE	PD	EX	7 ROH
`MZ-FG-R200`	R200 Bike	PD	EX	7 ROH
`MZ-FG-R300`	R300 Bike	PD	EX	7 ROH

Raw Material Components (MZ-RM-*)

Each bike has 7–10 ROH components following the naming pattern MZ-RM-{model}-01 through MZ-RM-{model}-07. These are the same components used by the PP generator and appear as dependent requirements when MRP explodes the BOM.

#	Part	Example (R100)	UoM
01	Frame	`MZ-RM-R100-01`	ST
02	Handle Bars	`MZ-RM-R100-02`	ST
03	Seat	`MZ-RM-R100-03`	ST
04	Wheels	`MZ-RM-R100-04`	ST
05	Forks	`MZ-RM-R100-05`	ST
06	Brakes	`MZ-RM-R100-06`	ST
07	Drive Train	`MZ-RM-R100-07`	ST

End-to-End Flow

Step 0 Create PIR

MD61
PBIM / PBHI

→

Step 1 Run MRP

MD01/MD02
PLAF / MDKP

→

Step 2 Review

MD04
Stock/Req List

→

Step 3 Convert

Planned → Prod Order
AUFK / AFKO

PIR Demand → MRP creates Planned Orders → Converted to Production Orders

Document Flow: PIR (PBIM/PBHI) → MRP Run (MDKP/MDTB) → Planned Orders (PLAF) → Production Orders (AUFK/AFKO). After conversion, MRP re-run cleans up the consumed planned order (PLAF deletion).

Why PIR + MRP instead of BAPI_PLANNEDORDER_CREATE? BAPI_PLANNEDORDER_CREATE does NOT persist via RFC because the V2 collective update never completes in the RFC session. The workaround is to create demand via PIR, then let the MRP run generate planned orders in PLAF naturally.

Step 0 — Create PIR (Planned Independent Requirements)

Create Forecast Demand (MD61)

Creates Planned Independent Requirements (PIR) for bike finished goods. PIR represents forecast demand that MRP will convert into planned orders. Uses requirement type VSF (standard forecast) with auto-incrementing version 00–09.

Transaction Codes

Tcode	Purpose
`MD61`	Create Planned Independent Requirements
`MD62`	Change Planned Independent Requirements
`MD63`	Display Planned Independent Requirements

BAPI

Function Module	Purpose
`BAPI_REQUIREMENTS_CREATE`	Create PIR with material, plant, version, qty, date
`BAPI_TRANSACTION_COMMIT`	Persist changes (WAIT='X')

Key Parameters

Field	Value	Notes
`REQU_TYPE`	`VSF`	Standard forecast requirement
`VERSION`	`00`–`09`	Auto-increments if version already exists
`MATERIAL`	e.g. `MZ-FG-M500`	Random bike from pool of 9
`PLANT`	`1710`
`REQ_QTY`	Quantity (e.g. 2000)	Configurable via `--qty`
`REQ_DATE`	Today + lead days	Configurable via `--lead-days`

Note: The BAPI returns an empty REQMTSPLANNUMBER via RFC, but the demand IS created in SAP. This is normal SAP behavior — the PIR number is assigned internally and can be verified in PBIM/PBHI.

Tables Populated

Table	Description	Key Fields Written
`PBIM`	PIR Header (Independent Requirements)	BESSION (version), BEDID (req type), MATNR, WERKS
`PBHI`	PIR Schedule Lines (Period Quantities)	BESSION, PDATU (req date), PLNMG (planned qty)

Verification Query

-- Check PIR for bike materials
SELECT h.MATNR, h.WERKS, h.BESSION, i.PDATU, i.PLNMG
FROM PBIM h
JOIN PBHI i ON h.BESSION = i.BESSION AND h.BEDID = i.BEDID
WHERE h.MATNR LIKE 'MZ-FG%' AND h.WERKS = '1710'
ORDER BY h.MATNR, i.PDATU;

Step 1 — Run MRP

Material Requirements Planning (MD01/MD02)

Executes single-item MRP for a material. MRP reads PIR demand, checks available stock, explodes the BOM, and creates planned orders in PLAF to cover the net requirement. Uses net change planning (PROC_TYPE='1') with BOM re-explosion (PLANNING_MODE='3').

Transaction Codes

Tcode	Purpose
`MD01`	MRP Run (Total Planning)
`MD02`	MRP Run (Single-Item, Single-Level)
`MD04`	Stock/Requirements List
`MD05`	MRP List (Individual)

BAPI

Function Module	Purpose
`BAPI_MATERIAL_PLANNING`	Run single-item MRP
`BAPI_TRANSACTION_COMMIT`	Persist changes (WAIT='X')

Key Parameters

Field	Value	Notes
`MATERIAL`	e.g. `MZ-FG-R100`	Single material or loop all 9
`PLANT`	`1710`
`PROC_TYPE`	`1`	Net change planning
`PLANNING_MODE`	`3`	Re-explode BOM and routing

MRP Logic: Planned Order Qty = Demand (PIR) − Available Stock. With lot size EX (lot-for-lot), MRP creates exactly one planned order per net requirement. If stock already covers the demand, MRP creates 0 planned orders — this is not an error.

Tables Populated

Table	Description	Key Fields Written
`PLAF`	Planned Orders	PLNUM (planned order #), MATNR, GSMNG (order qty), PEDTR (end date)
`MDKP`	MRP Document Header	DTNUM (document #), MATNR, WERKS, DTART
`MDTB`	MRP Document Items	DTNUM, DTPOS, MRP element details
`EBAN`	Purchase Requisitions	BANFN, MATNR (for externally procured components)
`RESB`	Reservations (dependent requirements)	Planned order component reservations

MRP Element Types (MD04 View)

Code	Description	Source
`PA`	Planned Order	MRP-generated (PLAF)
`PP`	Planned Independent Requirement (PIR)	Step 0 (PBIM/PBHI)
`FE`	Production Order	Converted from planned order
`VJ`	Sales Order	From OTC generator
`BE`	Purchase Requisition	For externally procured items

Verification Query

-- Planned orders from MRP run
SELECT PLNUM, MATNR, GSMNG, PEDTR, PSTTR, PLSCN
FROM PLAF
WHERE MATNR LIKE 'MZ-FG%' AND WERKS = '1710'
ORDER BY PLNUM DESC;

Step 2 — Review Stock/Requirements

Stock/Requirements List (MD04)

Read-only step that displays the current stock situation and all MRP elements for a material. Shows planned orders, PIR demand, production orders, sales orders, and current stock levels. Useful for verifying MRP results before conversion.

BAPI

Function Module	Purpose
`BAPI_MATERIAL_STOCK_REQ_LIST`	Read stock/requirements list (equivalent to MD04)

Key Parameters

Field	Value	Notes
`MATERIAL`	e.g. `MZ-FG-R100`	Material to review
`PLANT`	`1710`

Output Elements

Element	Description	Meaning
`PA`	Planned Order	MRP-generated supply (to be converted)
`PP`	PIR	Forecast demand from Step 0
`FE`	Production Order	Firm supply (converted from PA)
`VJ`	Sales Order	Customer demand (from OTC)
`Stock`	Current available stock	Unrestricted use inventory

No commit needed. This step is purely read-only — no BAPI_TRANSACTION_COMMIT is called.

Step 3 — Convert Planned Order to Production Order

Planned Order Conversion

Reads a planned order from PLAF, creates a production order using the planned order details, then re-runs MRP to clean up the consumed planned order. The profile PLDORD_PROFILE='LA' is required for in-house production materials (BESKZ=E), as defined in T460C.

Transaction Codes

Tcode	Purpose
`CO40`	Convert Planned Order to Production Order
`CO41`	Convert Planned Orders (Collective)
`MD04`	Verify conversion (PA → FE)

BAPIs (Two-Step Process)

Function Module	Purpose	Step
`BAPI_PLANNEDORDER_GET_DETAIL`	Read planned order details from PLAF	Read
`BAPI_PRODORD_CREATE`	Create production order from planned order data	Create
`BAPI_TRANSACTION_COMMIT`	Persist production order (WAIT='X')	Commit
`BAPI_MATERIAL_PLANNING`	Re-run MRP to clean up consumed planned order	Cleanup
`BAPI_TRANSACTION_COMMIT`	Persist MRP cleanup (WAIT='X')	Commit

Key Parameters (BAPI_PRODORD_CREATE)

Field	Value	Notes
`MATERIAL`	From planned order	Material from PLAF
`PLANT`	`1710`
`ORDER_TYPE`	From planned order or default	Production order type
`QUANTITY`	From planned order (GSMNG)
`BASIC_START_DATE`	From planned order
`BASIC_END_DATE`	From planned order

MRP cleanup is essential. After converting a planned order to a production order, MRP must be re-run to delete the now-consumed planned order from PLAF. Without the cleanup run, the planned order remains as a phantom supply element.

PLDORD_PROFILE='LA' is required for in-house production materials (BESKZ=E). This profile is defined in configuration table T460C and controls how planned orders are converted.

Tables Populated

Table	Description	Impact
`AUFK`	Production Order Header	New order created with AUFNR
`AFKO`	Production Order Master	PLNBEZ (material), GAMNG (qty)
`PLAF`	Planned Orders	Deleted by MRP cleanup run

Verification Query

-- Production order created from planned order
SELECT a.AUFNR, k.PLNBEZ, k.GAMNG, k.GMEIN
FROM AUFK a
JOIN AFKO k ON a.AUFNR = k.AUFNR
WHERE k.PLNBEZ LIKE 'MZ-FG%'
ORDER BY a.AUFNR DESC;

-- Verify planned order was deleted
SELECT PLNUM, MATNR, GSMNG FROM PLAF
WHERE PLNUM = '0004000XXXXX';

SAP Tables Reference

MRP Core Tables

Table	Description	Category	Populated By
`PBIM`	PIR Header (Independent Requirements)	Demand	Step 0
`PBHI`	PIR Schedule Lines (Period Quantities)	Demand	Step 0
`PLAF`	Planned Orders	Supply	Step 1 (created), Step 3 (deleted)
`MDKP`	MRP Document Header	MRP Run	Step 1
`MDTB`	MRP Document Items	MRP Run	Step 1
`EBAN`	Purchase Requisitions	Procurement	Step 1
`RESB`	Reservations (Dependent Requirements)	Components	Step 1

Production Order Tables (from Conversion)

Table	Description	Category	Populated By
`AUFK`	Order Master (Header)	Order Header	Step 3
`AFKO`	Order Header Data (PP specific)	Order Master	Step 3

Material Master Tables

Table	Description	Category
`MARA`	Material General Data	General
`MARC`	Material Plant Data (MRP, Production)	Plant
`MARD`	Storage Location Stock	Stock
`MAKT`	Material Descriptions	Texts
`MBEW`	Material Valuation	Valuation

Configuration Tables

Table	Description	Purpose
`T001`	Company Codes	Company code 1710
`T001W`	Plants	Plant definitions
`T460C`	Planned Order Profiles	PLDORD_PROFILE='LA' for BESKZ=E
`T438M`	MRP Type Customizing	PD = deterministic planning

CDS Views Reference

Planned Independent Requirements (PIR) CDS Views

CDS View	Description	Base Tables
`I_PlannedIndepRqmt`	PIR header	PBIM
`I_PlannedIndepRqmtItem`	PIR schedule lines	PBHI
`I_PlndIndepRqmtAPI01`	PIR header (API)	PBIM
`I_PlndIndepRqmtItemAPI01`	PIR schedule line (API)	PBHI

Planned Order CDS Views

CDS View	Description	Base Tables
`I_PlannedOrder`	Planned order header	PLAF
`I_PlannedOrderAPI01`	Planned order header (API)	PLAF
`I_PlannedOrderComponent`	Planned order components	RESB
`C_PlannedOrder`	Consumption: Manage Planned Orders	PLAF

MRP CDS Views

CDS View	Description	Base Tables
`I_MRPDocument`	MRP document header	MDKP
`I_MRPElement`	MRP element (stock/requirements list)	MDTB
`I_MRPMaterial`	Material MRP data	MARC
`C_MRPStockRequirementList`	Consumption: Stock/Requirements List (MD04)	MDTB
`C_MRPMaterial`	Consumption: MRP material overview	MARC

Purchase Requisition CDS Views (from MRP)

CDS View	Description	Base Tables
`I_PurchaseRequisition`	PR header composite	EBAN
`I_PurchaseRequisitionItem`	PR item with all fields	EBAN
`I_PurReqnItemPurOrdRef`	PR item to PO reference	EBAN
`C_PurchaseReqnHeader`	Consumption: Manage PRs	EBAN

Production Order CDS Views (from Conversion)

CDS View	Description	Base Tables
`I_ProductionOrder`	Production order header	AUFK, AFKO
`I_ProductionOrderAPI01`	Production order (API)	AUFK, AFKO
`I_ProductionOrderItem`	Production order item	AFPO
`I_ProductionOrderComponent`	Order BOM components	RESB
`I_ProductionOrderOperation`	Order routing operations	AFVV
`C_ProdOrdConfirmation`	Consumption: Order confirmations	AFRU

Master Data CDS Views

CDS View	Description	Base Tables
`I_Product`	Product/material general	MARA
`I_ProductPlantBasic`	Product plant data (MRP params)	MARC
`I_ProductPlantMRPArea`	MRP area data	MARC
`I_ProductPlantProcurement`	Product procurement data	MARC
`I_ProductValuation`	Product valuation	MBEW
`I_MaterialStock`	Material stock overview	MARD
`I_BillOfMaterial`	BOM header	STKO
`I_BillOfMaterialItem`	BOM components	STPO
`I_ProductionRoutingHeader`	Routing header	PLKO
`I_ProductionRoutingOperation`	Routing operations	PLPO

BAPI Reference

Step	BAPI	Purpose	Commit?
0	`BAPI_REQUIREMENTS_CREATE`	Create PIR demand	Yes
1	`BAPI_MATERIAL_PLANNING`	Run single-item MRP	Yes
2	`BAPI_MATERIAL_STOCK_REQ_LIST`	Read stock/requirements list	No
3	`BAPI_PLANNEDORDER_GET_DETAIL`	Read planned order details	No
3	`BAPI_PRODORD_CREATE`	Create production order	Yes
3	`BAPI_MATERIAL_PLANNING`	MRP cleanup (delete consumed PA)	Yes
*	`BAPI_TRANSACTION_COMMIT`	Commit changes (WAIT='X')	—

Scripts & Usage

Quick Start (mrpgen.sh)

Generate N MRP cycles with configurable pipeline depth:

# PIR + MRP only (create demand and planned orders)
./mrpgen.sh 10 mrp

# Full pipeline: PIR + MRP + Convert (100 cycles)
./mrpgen.sh 100 convert

Individual Steps (mrpwf.sh)

./mrpwf.sh step0-pir 5              # Create 5 PIR demands
./mrpwf.sh step1-mrp MZ-FG-R100     # Run MRP for one material
./mrpwf.sh step1-mrp                 # Run MRP for all 9 finished goods
./mrpwf.sh step2-review MZ-FG-R100  # Review stock/requirements (MD04)
./mrpwf.sh step3-convert 4000001463  # Convert planned order to prod order
./mrpwf.sh full 3                    # 3 full cycles (PIR+MRP+Convert)
./mrpwf.sh list                      # List planned orders from PLAF
./mrpwf.sh status 4000001463         # Show planned order details

Stages (mrpgen.sh)

Stage	Pipeline	SAP Tables Created
`mrp`	PIR → MRP Run	PBIM, PBHI, PLAF, MDKP
`convert`	PIR → MRP → Convert → Cleanup	+ AUFK, AFKO (PLAF deleted)

Options

Flag	Description
`--verbose`	Print BAPI details and all return messages
`--dry-run`	Validate only (no BAPI_TRANSACTION_COMMIT)
`--qty N`	Fixed PIR quantity (default: random)
`--pause N`	Seconds between steps (default: 3)
`--lead-days N`	Days ahead for PIR requirement date
`--stop-at STAGE`	Stop after stage: pir, mrp, review, convert

Project Structure

.
├── SAPMRPWorkflow.java              # Main automation program
├── mrpwf.sh                         # Workflow wrapper (individual steps)
├── mrpgen.sh                        # Bulk data generator (batch mode)
├── compile.sh                       # Compilation helper
├── docs/
│   └── SAP_MRP_Workflow_Documentation.html  # This document
└── skill/
    └── mrp-planning.md              # Claude Code skill file

Integration with Other Generators

The MRP generator sits at the center of the SAP data ecosystem, connecting demand from sales to supply via production and procurement. All generators share the same S/4HANA IDES instance.

OTC (Order-to-Cash)

Sales Orders → MRP Demand
OTC creates sales orders (VA01) which appear as VJ elements in MD04. MRP sees these as customer demand and generates planned orders to fulfill them.

MRP (This Generator)

PIR → Planned Orders → Prod Orders
Creates forecast demand via PIR, runs MRP to generate planned orders, converts to production orders. The central planning hub.

PP (Plan-to-Produce)

Production Order Execution
PP picks up where MRP Step 3 leaves off: release, GI, confirmation, GR. MRP creates the production order; PP executes it through the shop floor.

OTC: Sales Order → MRP: Plan & Convert → PP: Execute & Confirm → P2P: Procure RM

P2P (Procure-to-Pay) handles the procurement of raw materials (MZ-RM-*) that MRP identifies as shortages during BOM explosion. When MRP finds insufficient component stock, it creates purchase requisitions (EBAN) which P2P converts into purchase orders and goods receipts.

Troubleshooting

Common Errors

Error	Cause	Fix
Empty REQMTSPLANNUMBER	BAPI_REQUIREMENTS_CREATE returns blank PIR number via RFC	Normal SAP behavior. Demand IS created. Verify in PBIM/PBHI.
"Requirement already exists"	PIR version 00 already used for material/plant/period	Auto-increments version 00 → 09. If all 10 used, pick different date or material.
MRP creates 0 planned orders	Existing stock covers PIR demand (net requirement = 0)	Not an error. Increase PIR qty or consume stock first.
BAPI_PLANNEDORDER_CREATE fails	V2 collective update does not complete in RFC session	Do NOT use this BAPI. Use PIR + MRP run instead (the approach this generator uses).
"Cannot be changed manually"	MRP-generated planned orders are system-managed	Use MRP re-run to delete/modify planned orders, not manual changes.
Conversion fails (no profile)	PLDORD_PROFILE not set for in-house production materials	Set `PLDORD_PROFILE='LA'` (from T460C) for BESKZ=E materials.
Planned order not found	PLAF record already deleted by previous MRP cleanup	Run `list` to see current planned orders. Each can only be converted once.

MRP Configuration Prerequisites

Setting	Table	Required Value	Purpose
MRP Type	`MARC.DISMM`	`PD`	Deterministic planning (reacts to PIR)
Lot Size	`MARC.DISLS`	`EX`	Lot-for-lot (exact quantity)
Procurement Type	`MARC.BESKZ`	`E`	In-house production
MRP Controller	`MARC.DISPO`	Set	Required for MRP to process the material
BOM	`MAST/STKO/STPO`	Exists	Required for BOM explosion in MRP

BAPI Parameter Gotchas

BAPI	Gotcha	Correct Approach
`BAPI_REQUIREMENTS_CREATE`	REQMTSPLANNUMBER always empty via RFC	Ignore the empty return; verify demand in PBIM
`BAPI_MATERIAL_PLANNING`	Returns statistics (plaf_ins, plaf_del) but no order numbers	Query PLAF after commit to get planned order numbers
`BAPI_PRODORD_CREATE`	RETURN is export structure, not table	`getExportParameterList().getStructure("RETURN")`
`BAPI_PRODORD_CREATE`	Date fields are BASIC_START_DATE / BASIC_END_DATE	Not BASIC_START / BASIC_END
`BAPI_PLANNEDORDER_GET_DETAIL`	Planned order number must be 10-digit zero-padded	Pad with leading zeros before calling

Test Results

Step 0 — PIR Creation

Test	Result	Details
Create PIR for MZ-FG-M500	PASS	2,000 units, version 00 → demand created in PBIM/PBHI

Step 1 — MRP Run

Test	Result	Details
MRP for MZ-FG-M500	PASS	plaf_ins=1, planned order 4000001463 (1,129 units = 2,000 demand − 871 stock)

Step 3 — Conversion

Test	Result	Details
Convert planned 4000001463	PASS	Production order 000001002167 created
MRP cleanup run	PASS	plaf_del=1 — consumed planned order removed

Full Pipeline

Step	Result	Details
PIR (Step 0)	PASS	Demand created
MRP (Step 1)	PASS	Planned order generated
Review (Step 2)	PASS	PA + PP elements visible
Convert (Step 3)	PASS	Prod order created, PLAF cleaned

All tests performed on SAP S/4HANA IDES, client 100, plant 1710. MRP uses BAPI_MATERIAL_PLANNING with PROC_TYPE='1' and PLANNING_MODE='3'.