Fix creation of transport orders with wrapping sequences

Allow any type of transport order to be added to order sequences that
contain the _any type_ (i.e. "*") in their set of allowed order types.

Merged-by: Stefan Walter <stefan.walter@iml.fraunhofer.de>

Author: martingr

opentcs-documentation/src/docs/release-notes/changelog.adoc

@@ -16,6 +16,11 @@ The openTCS developers
 This change log lists the most relevant changes for past releases in reverse chronological order.
 (Note that the openTCS project adheres to https://semver.org/[Semantic Versioning].)
 
+== Version 7.2.1 (2026-02-03)
+
+* Bugs fixed:
+** Allow any type of transport order to be added to order sequences that contain the _any type_ (i.e. "*") in their set of allowed order types.
+
 == Version 7.2 (2026-02-02)
 
 * New features and enhancements:

opentcs-kernel/src/main/java/org/opentcs/kernel/workingset/TransportOrderPoolManager.java

@@ -32,6 +32,7 @@
 import org.opentcs.data.model.Vehicle;
 import org.opentcs.data.order.DriveOrder;
 import org.opentcs.data.order.DriveOrder.Destination;
+import org.opentcs.data.order.OrderConstants;
 import org.opentcs.data.order.OrderSequence;
 import org.opentcs.data.order.TransportOrder;
 import org.opentcs.util.event.EventHandler;
@@ -703,7 +704,7 @@ private TCSObjectReference<OrderSequence> getWrappingSequence(TransportOrderCrea
     );
     checkArgument(!sequence.isComplete(), "Order sequence %s is already complete", sequence);
     checkArgument(
-        sequence.getOrderTypes().contains(to.getType()),
+        typeAllowedBySequence(sequence, to.getType()),
         "Order sequence %s does not allow type of order %s: %s not in %s",
         sequence.getName(),
         to.getName(),
@@ -803,6 +804,11 @@ private String getIntendedVehicleName(OrderSequence sequence) {
     return sequence.getIntendedVehicle() == null ? null : sequence.getIntendedVehicle().getName();
   }
 
+  private boolean typeAllowedBySequence(OrderSequence sequence, String type) {
+    return sequence.getOrderTypes().contains(OrderConstants.TYPE_ANY)
+        || sequence.getOrderTypes().contains(type);
+  }
+
   @Nonnull
   private String nameFor(
       @Nonnull

opentcs-kernel/src/test/java/org/opentcs/kernel/workingset/TransportOrderPoolManagerTest.java

@@ -29,6 +29,7 @@
 import org.opentcs.access.to.order.OrderSequenceCreationTO;
 import org.opentcs.access.to.order.TransportOrderCreationTO;
 import org.opentcs.data.model.Vehicle;
+import org.opentcs.data.order.OrderConstants;
 import org.opentcs.data.order.OrderSequence;
 import org.opentcs.data.order.TransportOrder;
 import org.opentcs.util.event.SimpleEventBus;
@@ -258,6 +259,76 @@ void assignProcessingVehicleToOrderSequenceIfDifferentToPreviousOne() {
     assertThat(seqAfterThirdAssignment, is(sameInstance(seqAfterSecondAssignment)));
   }
 
+  @Test
+  void allowAssigningTransportOrderToOrderSequenceWithAnyType() {
+    OrderSequence sequence = orderPoolManager.createOrderSequence(
+        new OrderSequenceCreationTO("some-sequence")
+            .withOrderTypes(Set.of(OrderConstants.TYPE_ANY))
+    );
+
+    orderPoolManager.createTransportOrder(
+        new TransportOrderCreationTO(
+            "some-order",
+            List.of(new DestinationCreationTO("some-location", "NOP"))
+        )
+            .withType("some-type")
+            .withWrappingSequence(sequence.getName())
+    );
+
+    assertThat(objectRepo.getObjects(OrderSequence.class), is(not(empty())));
+    assertThat(objectRepo.getObjects(TransportOrder.class), is(not(empty())));
+  }
+
+  @Test
+  void allowAssigningTransportOrdersToOrderSequenceWithMatchingType() {
+    OrderSequence sequence = orderPoolManager.createOrderSequence(
+        new OrderSequenceCreationTO("some-sequence")
+            .withOrderTypes(Set.of("some-type", "some-other-type"))
+    );
+
+    orderPoolManager.createTransportOrder(
+        new TransportOrderCreationTO(
+            "some-order",
+            List.of(new DestinationCreationTO("some-location", "NOP"))
+        )
+            .withType("some-type")
+            .withWrappingSequence(sequence.getName())
+    );
+    orderPoolManager.createTransportOrder(
+        new TransportOrderCreationTO(
+            "some-other-order",
+            List.of(new DestinationCreationTO("some-location", "NOP"))
+        )
+            .withType("some-other-type")
+            .withWrappingSequence(sequence.getName())
+    );
+
+    assertThat(objectRepo.getObjects(OrderSequence.class), is(not(empty())));
+    assertThat(objectRepo.getObjects(TransportOrder.class), hasSize(2));
+  }
+
+
+  @Test
+  void disallowAssigningTransportOrderToOrderSequenceWithNonMatchingType() {
+    OrderSequence sequence = orderPoolManager.createOrderSequence(
+        new OrderSequenceCreationTO("some-sequence")
+            .withOrderTypes(Set.of("some-type"))
+    );
+
+    TransportOrderCreationTO creationTO = new TransportOrderCreationTO(
+        "some-order",
+        List.of(new DestinationCreationTO("some-location", "NOP"))
+    )
+        .withType("some-other-type")
+        .withWrappingSequence(sequence.getName());
+
+    assertThat(objectRepo.getObjects(OrderSequence.class), is(not(empty())));
+    Assertions.assertThrows(
+        IllegalArgumentException.class,
+        () -> orderPoolManager.createTransportOrder(creationTO)
+    );
+  }
+
   @Test
   void removeSingleOrderSequence() {
     OrderSequence sequence = orderPoolManager.createOrderSequence(