Added completion time parameter to cargo.handled() to enable Cargo to determine whether or not the specified activity should refresh the delivery or not.

dddsample/tracking/core/src/main/java/se/citerus/dddsample/tracking/core/application/event/CargoUpdater.java

@@ -2,16 +2,18 @@ package se.citerus.dddsample.tracking.core.application.event;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.stereotype.Service;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import se.citerus.dddsample.tracking.core.domain.model.cargo.Cargo;
 import se.citerus.dddsample.tracking.core.domain.model.cargo.CargoRepository;
+import se.citerus.dddsample.tracking.core.domain.model.handling.EventSequenceNumber;
 import se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEventRepository;
-import se.citerus.dddsample.tracking.core.domain.model.handling.EventSequenceNumber;
 import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
 
+import java.util.Date;
+
 @Service
 public class CargoUpdater {
 
@@ -39,8 +41,9 @@ public class CargoUpdater {
 
     final HandlingActivity activity = handlingEvent.activity();
     final Cargo cargo = handlingEvent.cargo();
+    final Date completionTime = handlingEvent.completionTime();
 
-    cargo.handled(activity);
+    cargo.handled(activity, completionTime);
     cargoRepository.store(cargo);
 
     systemEvents.notifyOfCargoUpdate(cargo);
@@ -48,6 +51,7 @@ public class CargoUpdater {
   }
 
   CargoUpdater() {
+    // Needed by CGLIB
   }
 
 }

dddsample/tracking/core/src/main/java/se/citerus/dddsample/tracking/core/application/util/SampleDataGenerator.java

@@ -253,7 +253,7 @@ public class SampleDataGenerator implements ServletContextListener {
         }
 
         final HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(abc123);
-        abc123.handled(handlingEvent.activity());
+        abc123.handled(handlingEvent.activity(), new Date());
         session.update(abc123);
 
         // Cargo JKL567
@@ -297,7 +297,7 @@ public class SampleDataGenerator implements ServletContextListener {
         }
 
         HandlingEvent handlingEvent1 = handlingEventRepository.mostRecentHandling(jkl567);
-        jkl567.handled(handlingEvent1.activity());
+        jkl567.handled(handlingEvent1.activity(), new Date());
         session.update(jkl567);
       }
     });

dddsample/tracking/core/src/main/java/se/citerus/dddsample/tracking/core/domain/model/cargo/Cargo.java

@@ -121,7 +121,59 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
       return null;
     }
 
-    final Location lastKnownLocation = delivery.lastKnownLocation();
+
+    
+    /*
+    if (delivery.transportStatus() == NOT_RECEIVED) {
+      return itinerary.firstLeg().receive();
+    }
+
+    Leg leg = itinerary.legMatching(delivery.mostRecentHandlingActivity());
+
+    if (leg == null) return null;
+
+    if (onboardCarrier()) return leg.unload();
+    else if (inPort())
+      if (leg.sameValueAs(itinerary.lastLeg())) return leg.claim();
+      else return leg.load();
+    else return null;
+
+  private boolean inPort() {
+    return delivery.transportStatus() == IN_PORT;
+  }
+
+  private boolean onboardCarrier() {
+    return delivery.transportStatus() == ONBOARD_CARRIER;
+  }
+
+
+    */
+
+  /*
+    public Date timeOfNextHandling() {
+      if (notReceived()) {
+        return null;
+      }
+
+      final Leg leg = itinerary.legMatching(delivery.mostRecentHandlingActivity());
+
+      if (leg == null) return null;
+
+      if (onboardCarrier()) return leg.unloadTime();
+      else if (inPort())
+        if (leg.sameValueAs(itinerary.lastLeg())) return null;
+        else return leg.loadTime();
+      else return null;
+    }
+
+  private boolean notReceived() {
+    return delivery.transportStatus() == NOT_RECEIVED;
+  }
+  */
+
+
+
+  final Location lastKnownLocation = delivery.lastKnownLocation();
 
     switch (delivery.transportStatus()) {
       case IN_PORT:
@@ -270,12 +322,22 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
    * since {@link HandlingEvent} is in a different aggregate.
    *
    * @param handlingActivity handling activity
+   * @param completionTime when the activity was completed
    */
-  public void handled(final HandlingActivity handlingActivity) {
+  public void handled(final HandlingActivity handlingActivity, final Date completionTime) {
     Validate.notNull(handlingActivity, "Handling activity is required");
 
+    if (delivery.lastTimestamp().after(completionTime)) {
+      return;
+    }
+
+    // TODO
+    // What if an activity that should logically happen later is entered with
+    // a completion time that's before some other activity?
+    // Who should win - logic or completion time?
+
     // Delivery is a value object, so it's replaced with a new one
-    this.delivery = Delivery.whenHandled(handlingActivity);
+    this.delivery = Delivery.cargoWasHandled(handlingActivity, completionTime);
   }
 
   @Override

dddsample/tracking/core/src/main/java/se/citerus/dddsample/tracking/core/domain/model/cargo/Delivery.java

@@ -24,24 +24,25 @@ class Delivery extends ValueObjectSupport<Delivery> {
    * Derives a new delivery when a cargo has been handled.
    *
    * @param handlingActivity  handling activity
+   * @param completionTime
    * @return An up to date delivery
    */
-  static Delivery whenHandled(final HandlingActivity handlingActivity) {
+  static Delivery cargoWasHandled(final HandlingActivity handlingActivity, Date completionTime) {
     Validate.notNull(handlingActivity, "Handling activity is required");
 
-    return new Delivery(handlingActivity);
+    return new Delivery(handlingActivity, completionTime);
   }
 
   /**
    * @return Initial delivery, before any handling has taken place
    */
   static Delivery initial() {
-    return new Delivery(null);
+    return new Delivery(null, new Date(0L));
   }
 
-  Delivery(final HandlingActivity mostRecentHandlingActivity) {
+  Delivery(final HandlingActivity mostRecentHandlingActivity, final Date completionTime) {
     this.mostRecentHandlingActivity = mostRecentHandlingActivity;
-    this.calculatedAt = new Date();
+    this.calculatedAt = completionTime;
   }
 
   HandlingActivity mostRecentHandlingActivity() {
@@ -100,16 +101,13 @@ class Delivery extends ValueObjectSupport<Delivery> {
     }
 
     if (mostRecentHandlingActivity.type() == CUSTOMS) {
-      return !handledAtDestination(routeSpecification);
+      boolean handledAtDestination = routeSpecification.destination().sameAs(mostRecentHandlingActivity.location());
+      return !handledAtDestination;
     } else {
       return !itinerary.wasExpecting(mostRecentHandlingActivity);
     }
   }
 
-  private boolean handledAtDestination(final RouteSpecification routeSpecification) {
-    return routeSpecification.destination().sameAs(mostRecentHandlingActivity.location());
-  }
-
   /**
    * @return True if the cargo has been unloaded at the final destination.
    * @param routeSpecification route specification
@@ -117,7 +115,7 @@ class Delivery extends ValueObjectSupport<Delivery> {
   boolean isUnloadedAtDestination(final RouteSpecification routeSpecification) {
     if (hasBeenHandled()) {
       return (mostRecentHandlingActivity.type() == CLAIM ||
-              mostRecentHandlingActivity.type() == UNLOAD && handledAtDestination(routeSpecification));
+              mostRecentHandlingActivity.type() == UNLOAD && routeSpecification.destination().sameAs(mostRecentHandlingActivity.location()));
     } else {
       return false;
     }
@@ -143,7 +141,7 @@ class Delivery extends ValueObjectSupport<Delivery> {
   /**
    * @return When this delivery was calculated.
    */
-  Date calculatedAt() {
+  Date lastTimestamp() {
     return new Date(calculatedAt.getTime());
   }
 

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/model/cargo/CargoTest.java

@@ -3,6 +3,7 @@ package se.citerus.dddsample.tracking.core.domain.model.cargo;
 import junit.framework.TestCase;
 import static se.citerus.dddsample.tracking.core.application.util.DateTestUtil.toDate;
 import static se.citerus.dddsample.tracking.core.domain.model.cargo.RoutingStatus.*;
+import static se.citerus.dddsample.tracking.core.domain.model.cargo.TransportStatus.IN_PORT;
 import static se.citerus.dddsample.tracking.core.domain.model.cargo.TransportStatus.NOT_RECEIVED;
 import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
@@ -78,6 +79,22 @@ public class CargoTest extends TestCase {
     assertEquals(ROUTED, cargo.routingStatus());
   }
 
+  public void testOutOrderHandling() throws Exception {
+    final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
+
+    cargo.handled(HandlingActivity.loadedOnto(crazyVoyage).in(STOCKHOLM), toDate("2009-10-01"));
+    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage), toDate("2009-10-01"));
+    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage), toDate("2009-10-02"));
+    cargo.handled(new HandlingActivity(UNLOAD, HONGKONG, crazyVoyage), toDate("2009-10-04"));
+    assertEquals(cargo.transportStatus(), IN_PORT);
+    assertEquals(cargo.lastKnownLocation(), HONGKONG);
+
+    // Out of order handling, does not affect state of cargo
+    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage), toDate("2009-10-03"));
+    assertEquals(IN_PORT, cargo.transportStatus());
+    assertEquals(HONGKONG, cargo.lastKnownLocation());
+  }
+
   public void testlastKnownLocationUnknownWhenNoEvents() throws Exception {
     Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
@@ -127,7 +144,7 @@ public class CargoTest extends TestCase {
     assertFalse(cargo.isReadyToClaim());
 
     // Adding an event unrelated to unloading at final destination
-    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU));
+    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU), new Date());
     assertFalse(cargo.isReadyToClaim());
 
     Voyage voyage = new Voyage.Builder(new VoyageNumber("0123"), HANGZOU).
@@ -135,59 +152,59 @@ public class CargoTest extends TestCase {
       build();
 
     // Adding an unload event, but not at the final destination
-    cargo.handled(new HandlingActivity(UNLOAD, TOKYO, voyage));
+    cargo.handled(new HandlingActivity(UNLOAD, TOKYO, voyage), new Date());
     assertFalse(cargo.isReadyToClaim());
 
     // Adding an event in the final destination, but not unload
-    cargo.handled(new HandlingActivity(CUSTOMS, NEWYORK));
+    cargo.handled(new HandlingActivity(CUSTOMS, NEWYORK), new Date());
     assertFalse(cargo.isReadyToClaim());
 
     // Finally, cargo is unloaded at final destination
-    cargo.handled(new HandlingActivity(UNLOAD, NEWYORK, voyage));
+    cargo.handled(new HandlingActivity(UNLOAD, NEWYORK, voyage), new Date());
     assertTrue(cargo.isReadyToClaim());
   }
 
   private Cargo populateCargoReceivedStockholm() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
-    cargo.handled(new HandlingActivity(RECEIVE, STOCKHOLM));
+    cargo.handled(new HandlingActivity(RECEIVE, STOCKHOLM), new Date());
     return cargo;
   }
 
   private Cargo populateCargoClaimedMelbourne() throws Exception {
     final Cargo cargo = populateCargoOffMelbourne();
 
-    cargo.handled(new HandlingActivity(CLAIM, MELBOURNE));
+    cargo.handled(new HandlingActivity(CLAIM, MELBOURNE), new Date());
     return cargo;
   }
 
   private Cargo populateCargoOffHongKong() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
     
-    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage));
-    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, HONGKONG, crazyVoyage));
+    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, HONGKONG, crazyVoyage), new Date());
     return cargo;
   }
 
   private Cargo populateCargoOnHamburg() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
     
-    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage));
-    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage));
+    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage), new Date());
     return cargo;
   }
 
   private Cargo populateCargoOffMelbourne() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
 
-    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage));
-    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, HONGKONG, crazyVoyage));
-    cargo.handled(new HandlingActivity(LOAD, HONGKONG, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, MELBOURNE, crazyVoyage));
+    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, HONGKONG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(LOAD, HONGKONG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, MELBOURNE, crazyVoyage), new Date());
 
     return cargo;
   }
@@ -203,30 +220,30 @@ public class CargoTest extends TestCase {
     assertFalse(cargo.isMisdirected());
 
     //Happy path
-    cargo.handled(new HandlingActivity(RECEIVE, SHANGHAI));
-    cargo.handled(new HandlingActivity(LOAD, SHANGHAI, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, ROTTERDAM, crazyVoyage));
-    cargo.handled(new HandlingActivity(LOAD, ROTTERDAM, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, GOTHENBURG, crazyVoyage));
-    cargo.handled(new HandlingActivity(CLAIM, GOTHENBURG));
-    cargo.handled(new HandlingActivity(CUSTOMS, GOTHENBURG));
+    cargo.handled(new HandlingActivity(RECEIVE, SHANGHAI), new Date());
+    cargo.handled(new HandlingActivity(LOAD, SHANGHAI, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, ROTTERDAM, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(LOAD, ROTTERDAM, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, GOTHENBURG, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(CLAIM, GOTHENBURG), new Date());
+    cargo.handled(new HandlingActivity(CUSTOMS, GOTHENBURG), new Date());
     assertFalse(cargo.isMisdirected());
 
     //Try a couple of failing ones
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
 
-    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU));
+    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU), new Date());
     assertTrue(cargo.isMisdirected());
 
 
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
 
-    cargo.handled(new HandlingActivity(RECEIVE, SHANGHAI));
-    cargo.handled(new HandlingActivity(LOAD, SHANGHAI, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, ROTTERDAM, crazyVoyage));
-    cargo.handled(new HandlingActivity(CLAIM, ROTTERDAM));
+    cargo.handled(new HandlingActivity(RECEIVE, SHANGHAI), new Date());
+    cargo.handled(new HandlingActivity(LOAD, SHANGHAI, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(UNLOAD, ROTTERDAM, crazyVoyage), new Date());
+    cargo.handled(new HandlingActivity(CLAIM, ROTTERDAM), new Date());
 
     assertTrue(cargo.isMisdirected());
   }

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/model/cargo/DeliveryTest.java

@@ -39,14 +39,14 @@ public class DeliveryTest extends TestCase {
     assertFalse(delivery.isUnloadedAtDestination(routeSpecification));
     assertEquals(Location.UNKNOWN, delivery.lastKnownLocation());
     assertEquals(NOT_RECEIVED, delivery.transportStatus());
-    assertTrue(delivery.calculatedAt().before(new Date()));
+    assertTrue(delivery.lastTimestamp().before(new Date()));
   }
 
   public void testUpdateOnHandlingHappyPath() {
     // 1. Receive
 
     HandlingActivity handlingActivity = new HandlingActivity(RECEIVE, HANGZOU);
-    Delivery newDelivery = Delivery.whenHandled(handlingActivity);
+    Delivery newDelivery = Delivery.cargoWasHandled(handlingActivity, new Date());
 
     // Changed on handling
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
@@ -61,12 +61,12 @@ public class DeliveryTest extends TestCase {
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
     // Updated on every calculation
-    assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
+    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
 
     // 2. Load
 
     handlingActivity = new HandlingActivity(LOAD, HANGZOU, HONGKONG_TO_NEW_YORK);
-    newDelivery = Delivery.whenHandled(handlingActivity);
+    newDelivery = Delivery.cargoWasHandled(handlingActivity, new Date());
 
     assertEquals(HONGKONG_TO_NEW_YORK, newDelivery.currentVoyage());
     assertEquals(HANGZOU, newDelivery.lastKnownLocation());
@@ -77,14 +77,14 @@ public class DeliveryTest extends TestCase {
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
+    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
 
     // Skipping intermediate load/unloads
 
     // 3. Unload
 
     handlingActivity = new HandlingActivity(UNLOAD, STOCKHOLM, DALLAS_TO_HELSINKI);
-    newDelivery = Delivery.whenHandled(handlingActivity);
+    newDelivery = Delivery.cargoWasHandled(handlingActivity, new Date());
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
@@ -95,12 +95,12 @@ public class DeliveryTest extends TestCase {
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
+    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
 
     // 4. Claim
 
     handlingActivity = new HandlingActivity(CLAIM, STOCKHOLM);
-    newDelivery = Delivery.whenHandled(handlingActivity);
+    newDelivery = Delivery.cargoWasHandled(handlingActivity, new Date());
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
@@ -111,13 +111,13 @@ public class DeliveryTest extends TestCase {
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
+    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
   }
 
   public void testUpdateOnHandlingWhenMisdirected() {
     // Unload in Hamburg, which is the wrong location
     HandlingActivity handlingActivity = new HandlingActivity(UNLOAD, HAMBURG, DALLAS_TO_HELSINKI);
-    Delivery newDelivery = Delivery.whenHandled(handlingActivity);
+    Delivery newDelivery = Delivery.cargoWasHandled(handlingActivity, new Date());
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(HAMBURG, newDelivery.lastKnownLocation());
@@ -130,7 +130,7 @@ public class DeliveryTest extends TestCase {
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
+    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
 
     // New route specification, old itinerary
     RouteSpecification newRouteSpecification = routeSpecification.withOrigin(HAMBURG);

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/scenario/CargoLifecycleScenarioTest.java

@@ -390,7 +390,7 @@ public class CargoLifecycleScenarioTest {
   private void updateCargoAggregate() {
     Cargo cargo = cargoRepository.find(trackingId);
     HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(cargo);
-    cargo.handled(handlingEvent.activity());
+    cargo.handled(handlingEvent.activity(), new Date());
     cargoRepository.store(cargo);
   }