Process Path Bounded Context - Domain-Driven Design

1
2
3
4
5
6
7
8
9
10
11
public class ProcessPath {
    private String pathId;
    private String pathName;
    private PathType pathType;          // SINGLES, AFE, BATCH_FLOW, CUSTOM
    private PathStatus status;          // ACTIVE, INACTIVE, MAINTENANCE, RETIRED
    private String warehouseId;
    private List<String> capabilities;
    private PathConstraints constraints;
    private PathScoringCriteria scoringCriteria;
    private Long version;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class PathAssignment {
    private String assignmentId;
    private String orderId;
    private String shipmentId;
    private String warehouseId;
    private ShipmentProfile shipmentProfile;
    private OrderComposition orderComposition;
    private boolean slaEmergency;
    private String assignedPathId;
    private PathType assignedPathType;
    private PathScore assignmentScore;
    private List<PathCandidate> evaluatedPaths;
    private AssignmentStatus status;    // PENDING, ASSIGNED, COMPLETED, CANCELLED
    private List<EvaluationRecord> evaluationHistory;
    private List<RerouteRecord> rerouteHistory;
    private LocalDateTime assignedAt;
}

1
2
3
4
5
6
7
8
9
10
11
12
public class PathCapacity {
    private String capacityId;
    private String pathId;
    private String warehouseId;
    private int maxThroughputUnitsPerHour;
    private int currentThroughputUnitsPerHour;
    private double utilizationPercent;
    private CapacityState capacityState;  // NORMAL, CONSTRAINED, CRITICAL
    private int activeStations;
    private int maxStations;
    private CapacityThresholds thresholds;
}

1
2
3
4
5
6
7
public class WorkloadDistribution {
    private String distributionId;
    private String warehouseId;
    private DistributionPeriod distributionPeriod;
    private Map<String, PathWorkload> pathWorkloads;
    private DistributionStatus status;  // ACTIVE, REBALANCING, COMPLETED
}

1
2
3
4
5
6
7
8
9
10
11
public class AFEBatch {
    private String batchId;
    private String warehouseId;
    private String waveId;
    private List<String> orderIds;
    private int totalItems;
    private AFEBatchStatus status;
    private String assignedInductStation;
    private LocalDateTime inductStartedAt;
    private LocalDateTime inductCompletedAt;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class SinglesSession {
    private String sessionId;
    private String orderId;
    private String shipmentId;
    private String itemSku;
    private SinglesStatus status;
    private String workerId;
    private String stationId;
    private String assignedPickLocation;
    private String assignedPackStation;
    private LocalDateTime startedAt;
    private LocalDateTime completedAt;
}

1
2
3
4
5
6
7
8
9
10
11
12
public class PickBatch {
    private String batchId;
    private String warehouseId;
    private String waveId;
    private List<String> orderIds;
    private int totalItems;
    private int totalUnits;
    private PickBatchStatus status;
    private String assignedPicker;
    private LocalDateTime pickingStartedAt;
    private LocalDateTime pickingCompletedAt;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public record ShipmentProfile(
    Dimensions dimensions,
    Weight weight,
    String hazmatClass,
    FragilityLevel fragilityLevel,
    SortabilityClass sortabilityClass,
    TemperatureRequirement temperatureRequirement,
    boolean giftWrap
) {
    public boolean requiresSpecialHandling() {
        return hazmatClass != null ||
               fragilityLevel == ULTRA_FRAGILE ||
               temperatureRequirement != null ||
               giftWrap;
    }

    public boolean fitsStandardAFETray() {
        return dimensions.length() <= 18 && dimensions.width() <= 18;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
public record OrderComposition(
    int itemCount,
    int uniqueSkuCount,
    boolean hasGiftWrap,
    String specialPackaging,
    ConsolidationRequirement consolidationRequirement,
    ShipmentType shipmentType
) {
    public boolean hasHighSkuDiversity() {
        return uniqueSkuCount > (itemCount * 0.8);
    }
}

1
2
3
4
5
6
7
8
9
10
11
public record PathScoringCriteria(
    double utilizationWeight,      // 0.4
    double bufferAvailabilityWeight,  // 0.3
    double laborAvailabilityWeight,   // 0.2
    double affinityWeight          // 0.1
) {
    // Total Score = (100 - utilization%) × 0.4 +
    //               buffer_availability × 0.3 +
    //               labor_availability × 0.2 +
    //               path_affinity × 0.1
}

1
2
3
4
5
6
public record PathConstraints(
    Dimensions maxDimensions,
    Weight maxWeight,
    int maxItemsPerShipment,
    boolean hazmatRestricted
) {}

1
2
3
4
5
6
7
8
public interface PathAssignmentService {
    PathAssignment assignPath(String orderId, String shipmentId, String warehouseId,
                              ShipmentProfile profile, OrderComposition composition, boolean slaEmergency);
    PathAssignment reroutePath(String assignmentId, String newPathId, String reason);
    List<PathCandidate> evaluatePaths(ShipmentProfile profile, OrderComposition composition, String warehouseId);
    PathCandidate selectBestPath(List<PathCandidate> candidates);
    PathCandidate selectFastestPath(List<PathCandidate> candidates);  // SLA emergency
}

1
2
3
4
5
6
7
public interface CapacityManagementService {
    void monitorCapacity(String warehouseId);
    SurgeDetectedEvent detectSurge(String warehouseId);
    WorkloadRebalancedEvent rebalanceWorkload(String warehouseId);
    void escalateSLAPriority(String shipmentId);
    void trackSLABreach(String shipmentId);
}