Best way to evaluate a condition set on N objects (depending on their state)

Considering two objects:

1. Order
2. Bag

And each object has a status field:

Order: [INITIALIZED, PICKED_UP, IN_TRANSIT, DELIVERED]

Bag: [INITIALIZED, ACQUIRED, DAMAGED, DELIVERED]

Finally, each order has a set of bags assigned.

When updating the status of an Order object, I need to check that N conditions are respected, like: when updating an Order status to "PICKED_UP", all the bags associated must be in turn, in the "ACQUIRED" status.

This is the simplest example that I can do, but I'm looking for some hints about these topics:

1. Writing code that can be easily maintained, without rewriting the whole set of conditions (conditions can be nested sometimes!)
2. Avoid long lists of "if, else if, else if...."
3. Keeping all the logic involved into these evaluations in the same class, in order to give to the person that is reading the code, a quick glance about the purpose of the code, and in case, how to implement a new logic.

I hope that the question is not too generic!
Thank you!

One way to model this is to delegate the decision of whether an order is allowed to be of a certain state to that state. In the below, the OrderStatus enum has method 'isValidStatusForOrder(Order)' which returns true if the order can be moved to that status. Then the Order class has method moveOrderToStatus which first checks if it can be moved before moving the status.

	public static class Order
	{
		public List<Bag> bags = new ArrayList<>();
		public OrderStatus currentStatus = OrderStatus.INITIALIZED;
		public void moveOrderToStatus(OrderStatus status)
		{
			if(!status.isValidStatusForOrder(this)) throw new IllegalStateException("Invalid status");
			currentStatus = status;
		}
	}

	public static class Bag
	{
		public BagStatus status = BagStatus.INITIALIZED;
	}

	public enum OrderStatus
	{
		INITIALIZED(order -> { throw new UnsupportedOperationException(); }),
		PICKED_UP(order -> { return order.bags.stream().allMatch(bag -> bag.status == BagStatus.ACQUIRED); }),
		IN_TRANSIT(order -> { throw new UnsupportedOperationException(); }),
		DELIVERED(order -> { throw new UnsupportedOperationException(); });
		private final OperationValidator validator;
		OrderStatus(OperationValidator validator){ this.validator = validator; }
		public boolean isValidStatusForOrder(Order order){ return validator.isValid(order); }
	}

	public enum BagStatus { INITIALIZED, ACQUIRED, DAMAGED, DELIVERED }

	@FunctionalInterface
	public interface OperationValidator{ boolean isValid(Order order); }

As an alternative, order state may be modelled in different classes. Ex: represent the different order stages using InitializedOrder, PickedUpOrder, InTransitOrder, etc. This may make it easier to prevent orders from being used improperly/entering invalid logic.