Your multi-level BOM update blocking issue requires addressing relationship constraints, change order processing logic, and workflow configuration comprehensively:
Understanding Relationship Constraints:
The EBOM relationship in ENOVIA has constraints that protect data integrity based on connected objects’ lifecycle states. These constraints define when relationships can be created, modified, or deleted. For Released assemblies, the default constraints prevent BOM modifications to ensure released product structures remain stable.
The constraint rules follow this pattern:
- Parent in Released state + Child in Released state = No modifications allowed
- Parent in Released state + Child in Preliminary state = Cannot add relationship
- Parent in In Work state = Modifications allowed regardless of child state
Multi-Level BOM Update Strategy:
To enable multi-level BOM updates within change orders, implement this approach:
- Change context configuration: Configure your change order type to establish a modification context. In the Change Order policy definition, add a setting that temporarily relaxes EBOM constraints for objects within the change scope:
mod policy "Change Order" add property "AllowBOMModification" value "true";
mod relationship EBOM add rule "AllowModificationInChangeContext";
- State transition sequencing: Before modifying BOMs, your change order processing must transition all affected items to compatible states. Implement this sequence:
Pseudocode - State transition logic:
// Step 1: Collect all affected items across all BOM levels
List<Part> affectedParts = changeOrder.getAffectedItems();
// Step 2: Transition all items to In Change state (bottom-up)
for (int level = maxLevel; level >= 0; level--) {
for (Part part : getPartsAtLevel(level)) {
part.demoteToState("In Change");
}
}
// Step 3: Apply BOM modifications
applyBOMChanges();
// Step 4: Promote all items back to Released (top-down)
for (int level = 0; level <= maxLevel; level++) {
for (Part part : getPartsAtLevel(level)) {
part.promoteToState("Released");
}
}
- Relationship constraint modification: Adjust EBOM relationship constraints to allow modifications when either end is in a change-related state:
mod relationship EBOM modify constraint "from.current != 'Released' || to.current != 'Released' || changeContext.active";
This allows modifications when:
- Parent is not Released, OR
- Child is not Released, OR
- A change context is active
Change Order Processing:
Implement robust change order processing that handles multi-level BOMs:
- BOM level analysis: Before processing changes, analyze the BOM structure to determine dependency order:
Pseudocode - BOM level calculation:
// Calculate level for each part in affected items
Map<Part, Integer> partLevels = new HashMap<>();
for (Part part : affectedParts) {
int level = calculateBOMLevel(part);
partLevels.put(part, level);
}
// Sort by level (bottom-up for demotion, top-down for promotion)
List<Part> sortedParts = sortByLevel(partLevels);
- Transaction management: Wrap multi-level updates in a single transaction to ensure atomicity:
Pseudocode - Transaction handling:
try {
transaction.begin();
// Demote all affected parts (bottom-up)
demoteAffectedParts(sortedParts.reverse());
// Apply all BOM changes
for (BOMChange change : changeOrder.getBOMChanges()) {
applyChange(change);
}
// Promote all affected parts (top-down)
promoteAffectedParts(sortedParts);
transaction.commit();
} catch (ConstraintException e) {
transaction.rollback();
// Log specific constraint violation
// Notify user of blocking constraint
}
- Constraint validation: Before attempting changes, validate that all constraints can be satisfied:
Pseudocode - Pre-validation:
// Validate all proposed changes against constraints
for (BOMChange change : changeOrder.getBOMChanges()) {
Part parent = change.getParent();
Part child = change.getChild();
if (!canModifyRelationship(parent, child)) {
// Identify blocking constraint
// Suggest resolution (state transitions needed)
throw new ValidationException("Constraint blocks modification");
}
}
Workflow Configuration:
Configure your change management workflow to support multi-level processing:
-
Add pre-processing task: Include a workflow task that prepares all affected items for modification by transitioning them to appropriate states.
-
Implement change isolation: While a change order is active, mark affected BOMs as “Under Change” to prevent concurrent modifications that could conflict with constraint management.
-
Add validation gates: Include workflow gates that verify all relationship constraints are satisfied before allowing change order promotion.
-
Configure rollback handling: If constraint violations occur during processing, implement automatic rollback that restores all affected items to their previous states.
Best Practices:
- Document the state transition sequence required for multi-level BOM changes
- Train users on the relationship between lifecycle states and BOM editability
- Implement clear error messages that explain which constraint is blocking and how to resolve it
- Consider implementing a “dry run” mode that validates all constraints before attempting actual changes
- Monitor change order processing performance - multi-level state transitions can be slow for deep BOM structures
- Implement logging that tracks each step of the multi-level update process for troubleshooting
This comprehensive approach allows multi-level BOM updates within change orders while maintaining data integrity through proper constraint management and sequenced processing.
This draft is based on general ENOVIA knowledge. It has not been verified against your specific version and environment. Practitioners: verify the steps and share your experience below.