Using "notifyOf..." naming convention in ApplicationEvents.

HandlingEvents now have a unique sequence number, and CargoUpdater looks events based on that to update the cargo in question.

First version of pessimistic locking of cargo during rerouting.

Cargo is now a facade for aggregate-internal classes Delivery and Projections.

Delivery calculates current voyage, last known location and transport status on the fly.

Introduced a tracking id generator domain service for getting next tracking id, instead of doing it in the cargo repository.

dddsample/src/main/java/se/citerus/dddsample/application/CargoLockingService.java

@@ -0,0 +1,16 @@
+package se.citerus.dddsample.application;
+
+import se.citerus.dddsample.domain.model.cargo.TrackingId;
+
+/**
+ *
+ */
+public interface CargoLockingService {
+
+  void assertLocked(TrackingId trackingId);
+
+  void unlock(TrackingId trackingId);
+
+  void lock(TrackingId trackingId);
+
+}

dddsample/src/main/java/se/citerus/dddsample/application/CargoLockingServiceInMem.java

@@ -0,0 +1,51 @@
+/**
+ * Purpose
+ * @author peter
+ * @created 2009-sep-07
+ * $Id$
+ */
+package se.citerus.dddsample.application;
+
+import se.citerus.dddsample.domain.model.cargo.TrackingId;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class CargoLockingServiceInMem implements CargoLockingService {
+
+  private final Map<TrackingId, Lock> locks = new HashMap<TrackingId, Lock>();
+
+  @Override
+  public void assertLocked(final TrackingId trackingId) {
+    final Lock lock = getLockFor(trackingId);
+    if (!lock.tryLock()) {
+      throw new RuntimeException("Lock not held");
+    }
+  }
+
+  @Override
+  public void unlock(final TrackingId trackingId) {
+    final Lock lock = getLockFor(trackingId);
+    lock.unlock();
+  }
+
+  @Override
+  public void lock(final TrackingId trackingId) {
+    final Lock lock = getLockFor(trackingId);
+    if (!lock.tryLock()) {
+      throw new RuntimeException("Could not lock");
+    }
+  }
+
+  private Lock getLockFor(final TrackingId trackingId) {
+    Lock lock = locks.get(trackingId);
+    if (lock == null) {
+      lock = new ReentrantLock();
+      locks.put(trackingId, lock);
+    }
+    return lock;
+  }
+
+}

dddsample/src/main/java/se/citerus/dddsample/application/event/ApplicationEvents.java

@@ -17,13 +17,13 @@ public interface ApplicationEvents {
    *
    * @param event handling event
    */
-  void cargoWasHandled(HandlingEvent event);
+  void notifyOfHandlingEvent(HandlingEvent event);
 
   /**
    * Cargo delivery has been updated.
    *
    * @param cargo cargo
    */
-  void cargoDeliveryWasUpdated(Cargo cargo);
+  void notifyOfCargoUpdate(Cargo cargo);
 
 }

dddsample/src/main/java/se/citerus/dddsample/application/event/CargoDeliveryUpdater.java

@@ -1,43 +0,0 @@
-package se.citerus.dddsample.application.event;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.transaction.annotation.Transactional;
-import se.citerus.dddsample.domain.model.cargo.Cargo;
-import se.citerus.dddsample.domain.model.cargo.CargoRepository;
-import se.citerus.dddsample.domain.model.cargo.TrackingId;
-import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
-
-public class CargoDeliveryUpdater {
-
-  private ApplicationEvents applicationEvents;
-  private CargoRepository cargoRepository;
-  private HandlingEventRepository handlingEventRepository;
-  private final Log logger = LogFactory.getLog(getClass());
-
-  public CargoDeliveryUpdater(final ApplicationEvents applicationEvents,
-                              final CargoRepository cargoRepository,
-                              final HandlingEventRepository handlingEventRepository) {
-    this.applicationEvents = applicationEvents;
-    this.cargoRepository = cargoRepository;
-    this.handlingEventRepository = handlingEventRepository;
-  }
-
-  @Transactional
-  public void updateDelivery(final TrackingId trackingId) {
-    final Cargo cargo = cargoRepository.find(trackingId);
-    final HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(cargo);
-
-    // TODO still doesn't sound right...cargo.updateDelivery()?
-    cargo.handled(handlingEvent.handlingActivity());
-
-    cargoRepository.store(cargo);
-    applicationEvents.cargoDeliveryWasUpdated(cargo);
-    logger.info("Updated delivery of cargo " + cargo + ": " + cargo.delivery());
-  }
-
-  CargoDeliveryUpdater() {
-  }
-
-}

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

@@ -0,0 +1,59 @@
+package se.citerus.dddsample.application.event;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.transaction.annotation.Transactional;
+import se.citerus.dddsample.domain.model.cargo.Cargo;
+import se.citerus.dddsample.domain.model.cargo.CargoRepository;
+import se.citerus.dddsample.domain.model.handling.HandlingEvent;
+import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
+import se.citerus.dddsample.domain.model.shared.EventSequenceNumber;
+import se.citerus.dddsample.domain.model.shared.HandlingActivity;
+
+public class CargoUpdater {
+
+  private ApplicationEvents applicationEvents;
+  private CargoRepository cargoRepository;
+  private HandlingEventRepository handlingEventRepository;
+  private final Log logger = LogFactory.getLog(getClass());
+
+  public CargoUpdater(final ApplicationEvents applicationEvents,
+                      final CargoRepository cargoRepository,
+                      final HandlingEventRepository handlingEventRepository) {
+    this.applicationEvents = applicationEvents;
+    this.cargoRepository = cargoRepository;
+    this.handlingEventRepository = handlingEventRepository;
+  }
+
+  @Transactional
+  public void updateCargo(final EventSequenceNumber eventSequenceNumber) {
+    final HandlingEvent handlingEvent = handlingEventRepository.find(eventSequenceNumber);
+    final HandlingActivity activity = handlingEvent.activity();
+    final Cargo cargo = handlingEvent.cargo();
+
+    // TODO create domain events and deal with them as a result of the handling
+    cargo.handled(activity);
+
+    /*
+    Here's an idea:
+
+    ResultOfHandling result = cargo.effectOf(activity);
+    cargo.apply(result);
+
+    or
+
+    cargo.handled(activity);
+    Delivery delivery = cargo.currentDelivery();
+    send all delivery.events();
+
+    */
+
+    cargoRepository.store(cargo);
+    applicationEvents.notifyOfCargoUpdate(cargo);
+    logger.info("Updated delivery of cargo " + cargo);
+  }
+
+  CargoUpdater() {
+  }
+
+}

dddsample/src/main/java/se/citerus/dddsample/application/event/MisdirectedNotifier.java

@@ -27,7 +27,7 @@ public class MisdirectedNotifier {
   public void alertIfMisdirected(final TrackingId trackingId) {
     final Cargo cargo = cargoRepository.find(trackingId);
 
-    if (cargo.delivery().isMisdirected()) {
+    if (cargo.isMisdirected()) {
       LOG.info("Cargo " + cargo + " is misdirected!");
     }
   }

dddsample/src/main/java/se/citerus/dddsample/application/event/ReadyToClaimNotfier.java

@@ -26,7 +26,11 @@ public class ReadyToClaimNotfier {
   public void alertIfReadyToClaim(final TrackingId trackingId) {
     final Cargo cargo = cargoRepository.find(trackingId);
                                                       
-    if (cargo.delivery().isUnloadedAtDestination()) {
+    if (cargo.isReadyToClaim()) {
+      /**
+       * At this point, a real system would probably send an email or SMS
+       * or something, but we simply log a message.
+       */
       LOG.info("Cargo " + cargo + " is ready to be claimed");
     }
   }

dddsample/src/main/java/se/citerus/dddsample/application/impl/BookingServiceImpl.java

@@ -5,6 +5,8 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.transaction.annotation.Transactional;
 import se.citerus.dddsample.application.BookingService;
+import se.citerus.dddsample.application.CargoLockingService;
+import se.citerus.dddsample.application.CargoLockingServiceInMem;
 import se.citerus.dddsample.domain.model.cargo.*;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
@@ -21,6 +23,7 @@ public final class BookingServiceImpl implements BookingService {
   private final CargoFactory cargoFactory;
   private final CargoRepository cargoRepository;
   private final LocationRepository locationRepository;
+  private final CargoLockingService cargoLockingService;
   private final Log logger = LogFactory.getLog(getClass());
 
   public BookingServiceImpl(final RoutingService routingService,
@@ -31,6 +34,7 @@ public final class BookingServiceImpl implements BookingService {
     this.cargoFactory = cargoFactory;
     this.cargoRepository = cargoRepository;
     this.locationRepository = locationRepository;
+    this.cargoLockingService = new CargoLockingServiceInMem();
   }
 
   @Override
@@ -46,7 +50,7 @@ public final class BookingServiceImpl implements BookingService {
   }
 
   @Override
-  @Transactional
+  @Transactional(readOnly = true)
   public List<Itinerary> requestPossibleRoutesForCargo(final TrackingId trackingId) {
     final Cargo cargo = cargoRepository.find(trackingId);
 
@@ -60,19 +64,23 @@ public final class BookingServiceImpl implements BookingService {
   @Override
   @Transactional
   public void assignCargoToRoute(final Itinerary itinerary, final TrackingId trackingId) {
-    // TODO locking semantics
+    cargoLockingService.assertLocked(trackingId);
+
     final Cargo cargo = cargoRepository.find(trackingId);
     Validate.notNull(cargo, "Can't assign itinerary to non-existing cargo " + trackingId);
     cargo.assignToRoute(itinerary);
     cargoRepository.store(cargo);
 
     logger.info("Assigned cargo " + trackingId + " to new route");
+
+    cargoLockingService.unlock(trackingId);
   }
 
   @Override
   @Transactional
   public void changeDestination(final TrackingId trackingId, final UnLocode unLocode) {
-    // TODO locking semantics
+    cargoLockingService.assertLocked(trackingId);
+
     final Cargo cargo = cargoRepository.find(trackingId);
     Validate.notNull(cargo, "Can't change destination of non-existing cargo " + trackingId);
     final Location newDestination = locationRepository.find(unLocode);
@@ -82,13 +90,17 @@ public final class BookingServiceImpl implements BookingService {
 
     cargoRepository.store(cargo);
     logger.info("Changed destination for cargo " + trackingId + " to " + routeSpecification.destination());
+
+    cargoLockingService.unlock(trackingId);
   }
 
   @Override
-  @Transactional
+  @Transactional(readOnly = true)
   public Cargo loadCargoForRouting(final TrackingId trackingId) {
-    // TODO locking semantics
     final Cargo cargo = cargoRepository.find(trackingId);
+    if (cargo != null) {
+      cargoLockingService.lock(trackingId);
+    }
     return cargo;
   }
 

dddsample/src/main/java/se/citerus/dddsample/application/impl/HandlingEventServiceImpl.java

@@ -37,6 +37,7 @@ public final class HandlingEventServiceImpl implements HandlingEventService {
                                     final VoyageNumber voyageNumber,
                                     final UnLocode unLocode,
                                     final HandlingEvent.Type type) throws CannotCreateHandlingEventException {
+
     final Date registrationTime = new Date();
     /* Using a factory to create a HandlingEvent (aggregate). This is where
        it is determined wether the incoming data, the attempt, actually is capable
@@ -52,7 +53,7 @@ public final class HandlingEventServiceImpl implements HandlingEventService {
     handlingEventRepository.store(event);
 
     /* Publish an event stating that a cargo has been handled. */
-    applicationEvents.cargoWasHandled(event);
+    applicationEvents.notifyOfHandlingEvent(event);
 
     logger.info("Registered handling event");
   }

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

@@ -50,48 +50,48 @@ public class SampleDataGenerator implements ServletContextListener {
 
   private static void loadHandlingEventData(JdbcTemplate jdbcTemplate) {
     String handlingEventSql =
-      "insert into HandlingEvent (completionTime, registrationTime, type, location_id, voyage_id, cargo_id) " +
-        "values (?, ?, ?, ?, ?, ?)";
+      "insert into HandlingEvent (sequence_number, completionTime, registrationTime, type, location_id, voyage_id, cargo_id) " +
+        "values (?, ?, ?, ?, ?, ?, ?)";
 
     Object[][] handlingEventArgs = {
       //XYZ (SESTO-FIHEL-DEHAM-CNHKG-JPTOK-AUMEL)
-      {ts(0), ts((0)), "RECEIVE", 1, null, 1},
-      {ts((4)), ts((5)), "LOAD", 1, 1, 1},
-      {ts((14)), ts((14)), "UNLOAD", 5, 1, 1},
-      {ts((15)), ts((15)), "LOAD", 5, 1, 1},
-      {ts((30)), ts((30)), "UNLOAD", 6, 1, 1},
-      {ts((33)), ts((33)), "LOAD", 6, 1, 1},
-      {ts((34)), ts((34)), "UNLOAD", 3, 1, 1},
-      {ts((60)), ts((60)), "LOAD", 3, 1, 1},
-      {ts((70)), ts((71)), "UNLOAD", 4, 1, 1},
-      {ts((75)), ts((75)), "LOAD", 4, 1, 1},
-      {ts((88)), ts((88)), "UNLOAD", 2, 1, 1},
-      {ts((100)), ts((102)), "CLAIM", 2, null, 1},
+      {1, ts(0), ts((0)), "RECEIVE", 1, null, 1},
+      {2, ts((4)), ts((5)), "LOAD", 1, 1, 1},
+      {3, ts((14)), ts((14)), "UNLOAD", 5, 1, 1},
+      {4, ts((15)), ts((15)), "LOAD", 5, 1, 1},
+      {5, ts((30)), ts((30)), "UNLOAD", 6, 1, 1},
+      {6, ts((33)), ts((33)), "LOAD", 6, 1, 1},
+      {7, ts((34)), ts((34)), "UNLOAD", 3, 1, 1},
+      {8, ts((60)), ts((60)), "LOAD", 3, 1, 1},
+      {9, ts((70)), ts((71)), "UNLOAD", 4, 1, 1},
+      {10, ts((75)), ts((75)), "LOAD", 4, 1, 1},
+      {11, ts((88)), ts((88)), "UNLOAD", 2, 1, 1},
+      {12, ts((100)), ts((102)), "CLAIM", 2, null, 1},
 
       //ZYX (AUMEL - USCHI - DEHAM -)
-      {ts((200)), ts((201)), "RECEIVE", 2, null, 3},
-      {ts((202)), ts((202)), "LOAD", 2, 2, 3},
-      {ts((208)), ts((208)), "UNLOAD", 7, 2, 3},
-      {ts((212)), ts((212)), "LOAD", 7, 2, 3},
-      {ts((230)), ts((230)), "UNLOAD", 6, 2, 3},
-      {ts((235)), ts((235)), "LOAD", 6, 2, 3},
+      {13, ts((200)), ts((201)), "RECEIVE", 2, null, 3},
+      {14, ts((202)), ts((202)), "LOAD", 2, 2, 3},
+      {15, ts((208)), ts((208)), "UNLOAD", 7, 2, 3},
+      {16, ts((212)), ts((212)), "LOAD", 7, 2, 3},
+      {17, ts((230)), ts((230)), "UNLOAD", 6, 2, 3},
+      {18, ts((235)), ts((235)), "LOAD", 6, 2, 3},
 
       //ABC
-      {ts((20)), ts((21)), "CLAIM", 2, null, 2},
+      {19, ts((20)), ts((21)), "CLAIM", 2, null, 2},
 
       //CBA
-      {ts((0)), ts((1)), "RECEIVE", 2, null, 4},
-      {ts((10)), ts((11)), "LOAD", 2, 2, 4},
-      {ts((20)), ts((21)), "UNLOAD", 7, 2, 4},
+      {20, ts((0)), ts((1)), "RECEIVE", 2, null, 4},
+      {21, ts((10)), ts((11)), "LOAD", 2, 2, 4},
+      {22, ts((20)), ts((21)), "UNLOAD", 7, 2, 4},
 
       //FGH
-      {ts(100), ts(160), "RECEIVE", 3, null, 5},
-      {ts(150), ts(110), "LOAD", 3, 3, 5},
+      {23, ts(100), ts(160), "RECEIVE", 3, null, 5},
+      {24, ts(150), ts(110), "LOAD", 3, 3, 5},
 
       // JKL
-      {ts(200), ts(220), "RECEIVE", 6, null, 6},
-      {ts(300), ts(330), "LOAD", 6, 3, 6},
-      {ts(400), ts(440), "UNLOAD", 5, 3, 6}  // Unexpected event
+      {25, ts(200), ts(220), "RECEIVE", 6, null, 6},
+      {26, ts(300), ts(330), "LOAD", 6, 3, 6},
+      {27, ts(400), ts(440), "UNLOAD", 5, 3, 6}  // Unexpected event
     };
     executeUpdate(jdbcTemplate, handlingEventSql, handlingEventArgs);
   }
@@ -136,16 +136,16 @@ public class SampleDataGenerator implements ServletContextListener {
 
   private static void loadCargoData(JdbcTemplate jdbcTemplate) {
     String cargoSql =
-      "insert into Cargo (id, tracking_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, transport_status, current_voyage_id, last_known_location_id, is_misdirected, routing_status, calculated_at, unloaded_at_dest) " +
-        "values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+      "insert into Cargo (id, tracking_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, is_misdirected, routing_status, calculated_at, unloaded_at_dest) " +
+        "values (?, ?, ?, ?, ?, ?, ?, ?, ?)";
 
     Object[][] cargoArgs = {
-      {1, "XYZ", 1, 2, ts(10), "IN_PORT", null, 1, false, "ROUTED", ts(100), false},
-      {2, "ABC", 1, 5, ts(20), "IN_PORT", null, 1, false, "ROUTED", ts(100), false},
-      {3, "ZYX", 2, 1, ts(30), "IN_PORT", null, 1, false, "NOT_ROUTED", ts(100), false},
-      {4, "CBA", 5, 1, ts(40), "IN_PORT", null, 1, false, "MISROUTED", ts(100), false},
-      {5, "FGH", 3, 5, ts(50), "IN_PORT", null, 1, false, "ROUTED", ts(100), false},  // Cargo origin differs from spec origin
-      {6, "JKL", 6, 4, ts(60), "IN_PORT", null, 1, true, "ROUTED", ts(100), false}
+      {1, "XYZ", 1, 2, ts(10), false, "ROUTED", ts(100), false},
+      {2, "ABC", 1, 5, ts(20), false, "ROUTED", ts(100), false},
+      {3, "ZYX", 2, 1, ts(30), false, "NOT_ROUTED", ts(100), false},
+      {4, "CBA", 5, 1, ts(40), false, "MISROUTED", ts(100), false},
+      {5, "FGH", 3, 5, ts(50), false, "ROUTED", ts(100), false},  // Cargo origin differs from spec origin
+      {6, "JKL", 6, 4, ts(60), true, "ROUTED", ts(100), false}
     };
     executeUpdate(jdbcTemplate, cargoSql, cargoArgs);
   }
@@ -254,7 +254,7 @@ public class SampleDataGenerator implements ServletContextListener {
         }
 
         final HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(abc123);
-        abc123.handled(handlingEvent.handlingActivity());
+        abc123.handled(handlingEvent.activity());
         session.update(abc123);
 
         // Cargo JKL567
@@ -298,7 +298,7 @@ public class SampleDataGenerator implements ServletContextListener {
         }
 
         HandlingEvent handlingEvent1 = handlingEventRepository.mostRecentHandling(jkl567);
-        jkl567.handled(handlingEvent1.handlingActivity());
+        jkl567.handled(handlingEvent1.activity());
         session.update(jkl567);
       }
     });

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

@@ -2,13 +2,15 @@ package se.citerus.dddsample.domain.model.cargo;
 
 import org.apache.commons.lang.Validate;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import se.citerus.dddsample.domain.model.location.CustomsZone;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.shared.HandlingActivity;
+import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 import se.citerus.dddsample.domain.shared.Entity;
 
+import java.util.Date;
+
 /**
  * A Cargo. This is the central class in the domain model,
  * and it is the root of the Cargo-Itinerary-Leg-Delivery-RouteSpecification aggregate.
@@ -59,7 +61,7 @@ public class Cargo implements Entity<Cargo> {
     this.trackingId = trackingId;
     this.routeSpecification = routeSpecification;
     this.delivery = Delivery.initial(routeSpecification, itinerary);
-    this.projections = new Projections(delivery, itinerary, routeSpecification);
+    this.projections = new Projections(delivery, itinerary);
   }
 
   /**
@@ -72,13 +74,6 @@ public class Cargo implements Entity<Cargo> {
   }
 
   /**
-   * @return The delivery. Never null.
-   */
-  public Delivery delivery() {
-    return delivery;
-  }
-
-  /**
    * @return The itinerary. Never null.
    */
   public Itinerary itinerary() {
@@ -92,11 +87,32 @@ public class Cargo implements Entity<Cargo> {
     return routeSpecification;
   }
 
-  /**
-   * @return The projections for this cargo.
-   */
-  public Projections projections() {
-    return projections;
+  public Date estimatedTimeOfArrival() {
+    return projections.estimatedTimeOfArrival();
+  }
+
+  public HandlingActivity nextExpectedActivity() {
+    return projections.nextExpectedActivity();
+  }
+
+  public boolean isMisdirected() {
+    return delivery.isMisdirected();
+  }
+
+  public TransportStatus transportStatus() {
+    return delivery.transportStatus();
+  }
+
+  public RoutingStatus routingStatus() {
+    return delivery.routingStatus();
+  }
+
+  public Voyage currentVoyage() {
+    return delivery.currentVoyage();
+  }
+
+  public Location lastKnownLocation() {
+    return delivery.lastKnownLocation();
   }
 
   /**
@@ -109,8 +125,8 @@ public class Cargo implements Entity<Cargo> {
 
     this.routeSpecification = routeSpecification;
     // Handling consistency within the Cargo aggregate synchronously
-    this.delivery = delivery.withRoutingChange(this.routeSpecification, this.itinerary);
-    this.projections = new Projections(delivery, itinerary, routeSpecification);
+    this.delivery = delivery.withRoutingChange(routeSpecification, itinerary);
+    this.projections = new Projections(delivery, itinerary);
   }
 
   /**
@@ -123,8 +139,8 @@ public class Cargo implements Entity<Cargo> {
 
     this.itinerary = itinerary;
     // Handling consistency within the Cargo aggregate synchronously
-    this.delivery = delivery.withRoutingChange(this.routeSpecification, this.itinerary);
-    this.projections = new Projections(delivery, itinerary, routeSpecification);
+    this.delivery = delivery.withRoutingChange(routeSpecification, itinerary);
+    this.projections = new Projections(delivery, itinerary);
   }
 
   public CustomsZone customsZone() {
@@ -136,6 +152,10 @@ public class Cargo implements Entity<Cargo> {
     return customsZone().entryPoint(itinerary.locations());
   }
 
+  public boolean isReadyToClaim() {
+    return delivery.isUnloadedAtDestination();
+  }
+
   /**
    * Updates all aspects of the cargo aggregate status
    * based on the current route specification, itinerary and handling of the cargo.
@@ -146,30 +166,17 @@ public class Cargo implements Entity<Cargo> {
    * <p/>
    * {@link RouteSpecification} and {@link Itinerary} are both inside the Cargo
    * aggregate, so changes to them cause the status to be updated <b>synchronously</b>,
-   * but changes to the delivery history (when a cargo is handled) cause the status update
-   * to happen <b>asynchronously</b> since {@link HandlingEvent} is in a different aggregate.
+   * but handling cause the status update to happen <b>asynchronously</b>
+   * since {@link HandlingEvent} is in a different aggregate.
    *
-   * @param handlingHistory handling history
+   * @param handlingActivity handling activity
    */
-  // TODO Under migration, this method will be removed and replaced with the handled() method
-  public void deriveDeliveryProgress(final HandlingHistory handlingHistory) {
-    Validate.isTrue(this.sameIdentityAs(handlingHistory.cargo()),
-      "Handling history must refer to this cargo, " + this + ". " +
-        "Given handlig history refers to cargo " + handlingHistory.cargo());
-
-    final HandlingEvent handlingEvent = handlingHistory.mostRecentPhysicalHandling();
-    if (handlingEvent != null) {
-      HandlingActivity handlingActivity = handlingEvent.handlingActivity();
-      handled(handlingActivity);
-    }
-  }
-
   public void handled(final HandlingActivity handlingActivity) {
     Validate.notNull(handlingActivity, "Handling activity is required");
 
     // Delivery and Projections are value object, so they are replaced with new or derived ones
     this.delivery = delivery.whenHandled(routeSpecification, itinerary, handlingActivity);
-    this.projections = new Projections(delivery, itinerary, routeSpecification, handlingActivity);
+    this.projections = new Projections(delivery, itinerary);
   }
 
   @Override

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/CargoFactory.java

@@ -14,16 +14,16 @@ import java.util.Date;
 
 public class CargoFactory {
 
-  private final CargoRepository cargoRepository;
   private final LocationRepository locationRepository;
+  private final TrackingIdGenerator trackingIdGenerator;
 
-  public CargoFactory(CargoRepository cargoRepository, LocationRepository locationRepository) {
-    this.cargoRepository = cargoRepository;
+  public CargoFactory(LocationRepository locationRepository, TrackingIdGenerator trackingIdGenerator) {
     this.locationRepository = locationRepository;
+    this.trackingIdGenerator = trackingIdGenerator;
   }
 
   public Cargo newCargo(UnLocode originUnLocode, UnLocode destinationUnLocode, Date arrivalDeadline) {
-    final TrackingId trackingId = cargoRepository.nextTrackingId();
+    final TrackingId trackingId = trackingIdGenerator.nextTrackingId();
     final Location origin = locationRepository.find(originUnLocode);
     final Location destination = locationRepository.find(destinationUnLocode);
     final RouteSpecification routeSpecification = new RouteSpecification(origin, destination, arrivalDeadline);

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/CargoRepository.java

@@ -35,8 +35,4 @@ public interface CargoRepository {
    */
   void store(Cargo cargo);
 
-  /**
-   * @return A unique, generated tracking Id.
-   */
-  TrackingId nextTrackingId();
 }

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

@@ -3,13 +3,14 @@ package se.citerus.dddsample.domain.model.cargo;
 import org.apache.commons.lang.Validate;
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
-import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
-import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import se.citerus.dddsample.domain.model.handling.HandlingHistory;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.ROUTED;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.derivedFrom;
+import static se.citerus.dddsample.domain.model.cargo.TransportStatus.ONBOARD_CARRIER;
+import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.CLAIM;
+import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.UNLOAD;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.shared.HandlingActivity;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
-import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 import se.citerus.dddsample.domain.shared.ValueObject;
 
 import java.util.Date;
@@ -20,13 +21,13 @@ import java.util.Date;
  */
 public class Delivery implements ValueObject<Delivery> {
 
-  private TransportStatus transportStatus;
-  private Location lastKnownLocation;
-  private Voyage currentVoyage;
+  private HandlingActivity mostRecentHandlingActivity;
+  private Date calculatedAt;
+
+  // TODO these will be replaced by domain events
   private boolean misdirected;
   private boolean isUnloadedAtDestination;
   private RoutingStatus routingStatus;
-  private Date calculatedAt;
 
   /**
    * Derives a new delivery snapshot to reflect changes in routing, i.e.
@@ -40,10 +41,10 @@ public class Delivery implements ValueObject<Delivery> {
   Delivery withRoutingChange(final RouteSpecification routeSpecification, final Itinerary itinerary) {
     Validate.notNull(routeSpecification, "Route specification is required");
 
-    final RoutingStatus newRoutingStatus = RoutingStatus.derivedFrom(itinerary, routeSpecification);
+    final RoutingStatus newRoutingStatus = derivedFrom(itinerary, routeSpecification);
     boolean misdirected = false;
 
-    return new Delivery(transportStatus, lastKnownLocation, currentVoyage, misdirected, isUnloadedAtDestination, newRoutingStatus);
+    return new Delivery(mostRecentHandlingActivity, misdirected, isUnloadedAtDestination, newRoutingStatus);
   }
 
   /**
@@ -58,44 +59,33 @@ public class Delivery implements ValueObject<Delivery> {
     Validate.notNull(routeSpecification, "Route specification is required");
     Validate.notNull(itinerary, "Itinerary is required");
 
+    final boolean newMisdirected = misdirectionStatus(itinerary, handlingActivity);
+    final boolean newUnloadedAtDestination = unloadedAtDestination(routeSpecification, handlingActivity);
     final RoutingStatus newRoutingStatus = this.routingStatus;
-    final TransportStatus newTransportStatus = TransportStatus.derivedFrom(handlingActivity);
-    final boolean newMisdirected = Calculate.misdirectionStatus(itinerary, handlingActivity);
-    final Location newLastKnownLocation = Calculate.lastKnownLocation(handlingActivity);
-    final Voyage newCurrentVoyage = Calculate.currentVoyage(handlingActivity, newTransportStatus);
-    final boolean newUnloadedAtDestination = Calculate.unloadedAtDestination(routeSpecification, handlingActivity);
 
-    return new Delivery(newTransportStatus, newLastKnownLocation, newCurrentVoyage, newMisdirected, newUnloadedAtDestination, newRoutingStatus);
+    return new Delivery(handlingActivity, newMisdirected, newUnloadedAtDestination, newRoutingStatus);
   }
 
   /**
-   *
-   * @param routeSpecification
-   * @param itinerary
-   * @return
+   * @param routeSpecification route specification
+   * @param itinerary itinerary
+   * @return Initial delivery, before any handling has taken place
    */
   static Delivery initial(final RouteSpecification routeSpecification, final Itinerary itinerary) {
     Validate.notNull(routeSpecification, "Route specification is required");
 
-    final TransportStatus newTransportStatus = TransportStatus.derivedFrom(null);
-    final Location newLastKnownLocation = Calculate.lastKnownLocation(null);
-    final Voyage newCurrentVoyage = Calculate.currentVoyage(null, newTransportStatus);
-    final boolean newMisdirected = Calculate.misdirectionStatus(itinerary, null);
-    final boolean newUnloadedAtDestination = Calculate.unloadedAtDestination(routeSpecification, null);
-    final RoutingStatus newRoutingStatus = RoutingStatus.derivedFrom(itinerary, routeSpecification);
+    final boolean newMisdirected = misdirectionStatus(itinerary, null);
+    final boolean newUnloadedAtDestination = unloadedAtDestination(routeSpecification, null);
+    final RoutingStatus newRoutingStatus = derivedFrom(itinerary, routeSpecification);
 
-    return new Delivery(newTransportStatus, newLastKnownLocation, newCurrentVoyage, newMisdirected, newUnloadedAtDestination, newRoutingStatus);
+    return new Delivery(null, newMisdirected, newUnloadedAtDestination, newRoutingStatus);
   }
 
-  private Delivery(final TransportStatus transportStatus,
-                   final Location lastKnownLocation,
-                   final Voyage currentVoyage,
+  private Delivery(final HandlingActivity mostRecentHandlingActivity,
                    final boolean misdirected,
                    final boolean unloadedAtDestination,
                    final RoutingStatus routingStatus) {
-    this.transportStatus = transportStatus;
-    this.lastKnownLocation = lastKnownLocation;
-    this.currentVoyage = currentVoyage;
+    this.mostRecentHandlingActivity = mostRecentHandlingActivity;
     this.misdirected = misdirected;
     this.isUnloadedAtDestination = unloadedAtDestination;
     this.routingStatus = routingStatus;
@@ -106,21 +96,29 @@ public class Delivery implements ValueObject<Delivery> {
    * @return Transport status
    */
   public TransportStatus transportStatus() {
-    return transportStatus;
+    return TransportStatus.derivedFrom(mostRecentHandlingActivity);
   }
 
   /**
    * @return Last known location of the cargo, or Location.UNKNOWN if the delivery history is empty.
    */
   public Location lastKnownLocation() {
-    return DomainObjectUtils.nullSafe(lastKnownLocation, Location.UNKNOWN);
+    if (mostRecentHandlingActivity != null) {
+      return mostRecentHandlingActivity.location();
+    } else {
+      return Location.UNKNOWN;
+    }
   }
 
   /**
    * @return Current voyage.
    */
   public Voyage currentVoyage() {
-    return DomainObjectUtils.nullSafe(currentVoyage, Voyage.NONE);
+    if (mostRecentHandlingActivity != null && transportStatus().equals(ONBOARD_CARRIER)) {
+      return mostRecentHandlingActivity.voyage();
+    } else {
+      return Voyage.NONE;
+    }
   }
 
   /**
@@ -159,12 +157,30 @@ public class Delivery implements ValueObject<Delivery> {
     return new Date(calculatedAt.getTime());
   }
 
+  /**
+   * @return True if the cargo is routed and not misdirected
+   */
+  boolean onTrack() {
+    return routingStatus().sameValueAs(ROUTED) && !isMisdirected();
+  }
+
+  private static boolean misdirectionStatus(Itinerary itinerary, HandlingActivity handlingActivity) {
+    return handlingActivity != null &&
+           handlingActivity.type().isPhysical() &&
+           !itinerary.isExpected(handlingActivity);
+  }
+
+  // TODO name this: "arrived" or something
+  private static boolean unloadedAtDestination(RouteSpecification routeSpecification, HandlingActivity handlingActivity) {
+    return handlingActivity != null &&
+          (CLAIM.sameValueAs(handlingActivity.type()) || UNLOAD.sameValueAs(handlingActivity.type()) &&
+           routeSpecification.destination().sameIdentityAs(handlingActivity.location()));
+  }
+
   @Override
   public boolean sameValueAs(final Delivery other) {
     return other != null && new EqualsBuilder().
-      append(this.transportStatus, other.transportStatus).
-      append(this.lastKnownLocation, other.lastKnownLocation).
-      append(this.currentVoyage, other.currentVoyage).
+      append(this.mostRecentHandlingActivity, other.mostRecentHandlingActivity).
       append(this.misdirected, other.misdirected).
       append(this.isUnloadedAtDestination, other.isUnloadedAtDestination).
       append(this.routingStatus, other.routingStatus).
@@ -185,9 +201,7 @@ public class Delivery implements ValueObject<Delivery> {
   @Override
   public int hashCode() {
     return new HashCodeBuilder().
-      append(transportStatus).
-      append(lastKnownLocation).
-      append(currentVoyage).
+      append(mostRecentHandlingActivity).
       append(misdirected).
       append(isUnloadedAtDestination).
       append(routingStatus).
@@ -199,39 +213,4 @@ public class Delivery implements ValueObject<Delivery> {
     // Needed by Hibernate
   }
 
-  private static class Calculate {
-
-    private static Location lastKnownLocation(HandlingActivity handlingActivity) {
-      if (handlingActivity != null) {
-        return handlingActivity.location();
-      } else {
-        return null;
-      }
-    }
-
-    private static Voyage currentVoyage(HandlingActivity handlingActivity, TransportStatus transportStatus) {
-      if (transportStatus.equals(ONBOARD_CARRIER) && handlingActivity != null) {
-        return handlingActivity.voyage();
-      } else {
-        return null;
-      }
-    }
-
-    private static boolean misdirectionStatus(Itinerary itinerary, HandlingActivity handlingActivity) {
-      if (handlingActivity == null) {
-        return false;
-      } else {
-        return !itinerary.isExpected(handlingActivity);
-      }
-    }
-
-    private static boolean unloadedAtDestination(RouteSpecification routeSpecification, HandlingActivity handlingActivity) {
-      return handlingActivity != null &&
-        (HandlingEvent.Type.CLAIM.sameValueAs(handlingActivity.type()) ||
-          HandlingEvent.Type.UNLOAD.sameValueAs(handlingActivity.type()) &&
-            routeSpecification.destination().sameIdentityAs(handlingActivity.location()));
-    }
-
-  }
-
 }

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/Projections.java

@@ -1,197 +1,165 @@
 package se.citerus.dddsample.domain.model.cargo;
 
-import se.citerus.dddsample.domain.shared.ValueObject;
-import se.citerus.dddsample.domain.model.shared.HandlingActivity;
-import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.ROUTED;
+import org.apache.commons.lang.builder.EqualsBuilder;
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.domain.model.location.Location;
-import se.citerus.dddsample.domain.model.voyage.Voyage;
-import se.citerus.dddsample.domain.model.handling.HandlingEvent;
+import se.citerus.dddsample.domain.model.shared.HandlingActivity;
+import se.citerus.dddsample.domain.shared.ValueObject;
 
 import java.util.Date;
 import java.util.Iterator;
 
-import org.apache.commons.lang.builder.EqualsBuilder;
-import org.apache.commons.lang.builder.HashCodeBuilder;
-
 /**
  * These are projections about the future handling of the cargo,
  * when it will arrive and what the next step is.
- *
+ * <p/>
  * It is updated on routing changes as well as handling.
- *
  */
-public class Projections implements ValueObject<Projections> {
+class Projections implements ValueObject<Projections> {
 
-    private Date estimatedTimeOfArrival;
-    private HandlingActivity nextExpectedActivity;
+  private Date estimatedTimeOfArrival;
+  private HandlingActivity nextExpectedActivity;
 
-    private static final Date ETA_UNKOWN = null;
-    private static final HandlingActivity NO_ACTIVITY = null;
+  private static final Date ETA_UNKOWN = null;
+  private static final HandlingActivity NO_ACTIVITY = null;
 
-    Projections(final Delivery delivery, final Itinerary itinerary, final RouteSpecification routeSpecification) {
-        this(delivery, itinerary, routeSpecification, null);
-    }
+  Projections(final Delivery delivery, final Itinerary itinerary) {
+    this.estimatedTimeOfArrival = calculateEstimatedTimeOfArrival(delivery, itinerary);
+    this.nextExpectedActivity = calculateNextExpectedActivity(delivery, itinerary);
+  }
 
-    Projections(final Delivery delivery, final Itinerary itinerary, final RouteSpecification routeSpecification, final HandlingActivity handlingActivity) {
-        this.estimatedTimeOfArrival = calculateEstimatedTimeOfArrival(delivery, itinerary);
-        this.nextExpectedActivity = calculateNextExpectedActivity(delivery, itinerary, routeSpecification, handlingActivity);
+  /**
+   * @return Estimated time of arrival, or null if not known.
+   */
+  Date estimatedTimeOfArrival() {
+    if (estimatedTimeOfArrival != ETA_UNKOWN) {
+      return new Date(estimatedTimeOfArrival.getTime());
+    } else {
+      return ETA_UNKOWN;
     }
+  }
 
-    Projections(final Date estimatedTimeOfArrival, final HandlingActivity nextExpectedActivity) {
-        this.estimatedTimeOfArrival = estimatedTimeOfArrival;
-        this.nextExpectedActivity = nextExpectedActivity;
-    }
+  /**
+   * @return The next expected handling activity.
+   */
+  HandlingActivity nextExpectedActivity() {
+    return nextExpectedActivity;
+  }
 
-    /**
-     * @return Estimated time of arrival, or null if not known.
-     */
-    public Date estimatedTimeOfArrival() {
-        if (estimatedTimeOfArrival != ETA_UNKOWN) {
-            return new Date(estimatedTimeOfArrival.getTime());
-        } else {
-            return ETA_UNKOWN;
-        }
+  private Date calculateEstimatedTimeOfArrival(final Delivery delivery, final Itinerary itinerary) {
+    if (delivery.onTrack()) {
+      return itinerary.finalUnloadTime();
+    } else {
+      return ETA_UNKOWN;
     }
+  }
 
-    /**
-     * @return The next expected handling activity.
-     */
-    public HandlingActivity nextExpectedActivity() {
-        return nextExpectedActivity;
-    }
+  private HandlingActivity calculateNextExpectedActivity(final Delivery delivery, final Itinerary itinerary) {
+
+    /*
+     Capture:
 
-    private Date calculateEstimatedTimeOfArrival(final Delivery delivery, final Itinerary itinerary) {
-        if (onTrack(delivery.routingStatus(), delivery.isMisdirected())) {
-            return itinerary.finalUnloadTime();
+     Cargo is misdirected but has been rerouted. Next expected acivity should be to load according to first leg
+     of new itinerary.
+
+     and
+
+     even if a cargo is misdirected, we expect it to be unloaded at next stop.
+
+    */
+    if (!delivery.onTrack()) return NO_ACTIVITY;
+
+    final Location lastKnownLocation = delivery.lastKnownLocation();
+    switch (delivery.transportStatus()) {
+      case IN_PORT:
+        if (itinerary.firstLeg().loadLocation().sameIdentityAs(lastKnownLocation)) {
+          return loadInFirstLocation(itinerary);
         } else {
-            return ETA_UNKOWN;
+          return loadOrClaimInNextLocation(itinerary, lastKnownLocation);
         }
-    }
 
-    private boolean onTrack(final RoutingStatus routingStatus, final boolean misdirected) {
-        return routingStatus.sameValueAs(ROUTED) && !misdirected;
-    }
+      case NOT_RECEIVED:
+        return receiveInFirstLocation(itinerary);
+
+      case ONBOARD_CARRIER:
+        return unloadInNextLocation(itinerary, lastKnownLocation);
 
-    private HandlingActivity calculateNextExpectedActivity(final Delivery delivery, final Itinerary itinerary, final RouteSpecification routeSpecification, final HandlingActivity handlingActivity) {
-        return calculateNextExpectedActivity(routeSpecification, itinerary, handlingActivity, delivery.routingStatus(), delivery.transportStatus(), delivery.lastKnownLocation(), delivery.currentVoyage(), delivery.isMisdirected());
+      case CLAIMED:
+      default:
+        return NO_ACTIVITY;
     }
+  }
 
-    private HandlingActivity calculateNextExpectedActivity(final RouteSpecification routeSpecification,
-                                                           final Itinerary itinerary,
-                                                           final HandlingActivity handlingActivity,
-                                                           final RoutingStatus routingStatus,
-                                                           final TransportStatus transportStatus,
-                                                           final Location lastKnownLocation,
-                                                           final Voyage currentVoyage,
-                                                           final boolean misdirected) {
-        /*
-         Capture:
-
-         Cargo is misdirected but has been rerouted. Next expected acivity should be to load according to first leg
-         of new itinerary.
-
-         and
-
-         even if a cargo is misdirected, we expect it to be unloaded at next stop.
-
-        */
-        if (!onTrack(routingStatus, misdirected)) return NO_ACTIVITY;
-
-        switch (transportStatus) {
-            case IN_PORT:
-                if (itinerary.firstLeg().loadLocation().sameIdentityAs(lastKnownLocation)) {
-                    return loadInFirstLocation(itinerary);
-                } else {
-                    return loadOrClaimInNextLocation(itinerary, lastKnownLocation);
-                }
-            case NOT_RECEIVED:
-                return receiveInFirstLocation(itinerary);
-            case ONBOARD_CARRIER:
-                return unloadInNextLocation(itinerary, lastKnownLocation);
-            case CLAIMED:
-            default:
-                return NO_ACTIVITY;
-        }
+  private HandlingActivity receiveInFirstLocation(final Itinerary itinerary) {
+    final Leg leg = itinerary.firstLeg();
+    return new HandlingActivity(RECEIVE, leg.loadLocation());
+  }
 
-        /*
-        switch (handlingActivity.type()) {
-          case LOAD:
-            return unloadInNextLocation(itinerary, handlingActivity);
-          case UNLOAD:
-            return loadOrClaimInNextLocation(itinerary, handlingActivity);
-          case RECEIVE:
-            return receiveInFirstLocation(itinerary);
-          case CLAIM:
-          default:
-            return NO_ACTIVITY;
-        }
-        */
-    }
+  private HandlingActivity loadInFirstLocation(final Itinerary itinerary) {
+    final Leg leg = itinerary.firstLeg();
+    return new HandlingActivity(LOAD, leg.loadLocation(), leg.voyage());
+  }
 
-    private HandlingActivity receiveInFirstLocation(final Itinerary itinerary) {
-        final Leg leg = itinerary.firstLeg();
-        return new HandlingActivity(HandlingEvent.Type.RECEIVE, leg.loadLocation());
-    }
+  private HandlingActivity loadOrClaimInNextLocation(final Itinerary itinerary, final Location activityLocation) {
+    for (final Iterator<Leg> it = itinerary.legs().iterator(); it.hasNext();) {
+      final Leg leg = it.next();
+      if (leg.unloadLocation().sameIdentityAs(activityLocation)) {
+        if (it.hasNext()) {
+          final Leg nextLeg = it.next();
 
-    private HandlingActivity loadInFirstLocation(final Itinerary itinerary) {
-        final Leg leg = itinerary.firstLeg();
-        return new HandlingActivity(HandlingEvent.Type.LOAD, leg.loadLocation(), leg.voyage());
-    }
+          //return leg.loadActivity(); { return new HandlingActivity(voyage, loadLocation); }
 
-    private HandlingActivity loadOrClaimInNextLocation(final Itinerary itinerary, final Location activityLocation) {
-        for (final Iterator<Leg> it = itinerary.legs().iterator(); it.hasNext();) {
-            final Leg leg = it.next();
-            if (leg.unloadLocation().sameIdentityAs(activityLocation)) {
-                if (it.hasNext()) {
-                    final Leg nextLeg = it.next();
-                    return new HandlingActivity(HandlingEvent.Type.LOAD, nextLeg.loadLocation(), nextLeg.voyage());
-                } else {
-                    return new HandlingActivity(HandlingEvent.Type.CLAIM, leg.unloadLocation());
-                }
-            }
-        }
+          //return HandlingActivity.loadOnto(nextLeg.voyage()).in(nextLeg.loadLocation());
 
-        return NO_ACTIVITY;
+          return new HandlingActivity(LOAD, nextLeg.loadLocation(), nextLeg.voyage());
+        } else {
+          return new HandlingActivity(CLAIM, leg.unloadLocation());
+        }
+      }
     }
 
-    private HandlingActivity unloadInNextLocation(final Itinerary itinerary, final Location activityLocation) {
-        for (final Leg leg : itinerary.legs()) {
-            if (leg.loadLocation().sameIdentityAs(activityLocation)) {
-                return new HandlingActivity(HandlingEvent.Type.UNLOAD, leg.unloadLocation(), leg.voyage());
-            }
-        }
+    return NO_ACTIVITY;
+  }
 
-        return NO_ACTIVITY;
+  private HandlingActivity unloadInNextLocation(final Itinerary itinerary, final Location activityLocation) {
+    for (final Leg leg : itinerary.legs()) {
+      if (leg.loadLocation().sameIdentityAs(activityLocation)) {
+        return new HandlingActivity(UNLOAD, leg.unloadLocation(), leg.voyage());
+      }
     }
 
+    return NO_ACTIVITY;
+  }
 
-    @Override
-    public boolean sameValueAs(final Projections other) {
-        return other != null && new EqualsBuilder().
-                append(this.estimatedTimeOfArrival, other.estimatedTimeOfArrival).
-                append(this.nextExpectedActivity, other.nextExpectedActivity).
-                isEquals();
-    }
 
-    @Override
-    public boolean equals(final Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+  @Override
+  public boolean sameValueAs(final Projections other) {
+    return other != null && new EqualsBuilder().
+      append(this.estimatedTimeOfArrival, other.estimatedTimeOfArrival).
+      append(this.nextExpectedActivity, other.nextExpectedActivity).
+      isEquals();
+  }
 
-        final Projections other = (Projections) o;
-        return sameValueAs(other);
-    }
+  @Override
+  public boolean equals(final Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
 
-    @Override
-    public int hashCode() {
-        return new HashCodeBuilder().
-                append(estimatedTimeOfArrival).
-                append(nextExpectedActivity).
-                toHashCode();
-    }
+    final Projections other = (Projections) o;
+    return sameValueAs(other);
+  }
 
-    Projections() {
-        // Needed by Hibernate
-    }
+  @Override
+  public int hashCode() {
+    return new HashCodeBuilder().
+      append(estimatedTimeOfArrival).
+      append(nextExpectedActivity).
+      toHashCode();
+  }
+
+  Projections() {
+    // Needed by Hibernate
+  }
 
 }

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/TrackingId.java

@@ -1,5 +1,6 @@
 package se.citerus.dddsample.domain.model.cargo;
 
+import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang.Validate;
 import se.citerus.dddsample.domain.shared.ValueObject;
 
@@ -22,6 +23,11 @@ public final class TrackingId implements ValueObject<TrackingId>, Serializable {
     this.id = id;
   }
 
+  public TrackingId(final long sequenceValue) {
+    Validate.isTrue(sequenceValue > 0, "Sequence value must be larger than 0");
+    this.id = "C" + StringUtils.leftPad(String.valueOf(sequenceValue), 8, "0");
+  }
+
   /**
    * @return String representation of this tracking id.
    */

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/TrackingIdGenerator.java

@@ -0,0 +1,10 @@
+package se.citerus.dddsample.domain.model.cargo;
+
+/**
+ * Generates tracking ids for cargos. This is a domain service.
+ */
+public interface TrackingIdGenerator {
+
+  TrackingId nextTrackingId();
+
+}

dddsample/src/main/java/se/citerus/dddsample/domain/model/handling/HandlingEvent.java

@@ -5,6 +5,7 @@ import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.location.Location;
+import se.citerus.dddsample.domain.model.shared.EventSequenceNumber;
 import se.citerus.dddsample.domain.model.shared.HandlingActivity;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.shared.DomainEvent;
@@ -31,7 +32,8 @@ import java.util.Date;
  */
 public final class HandlingEvent implements DomainEvent<HandlingEvent> {
 
-  private HandlingActivity handlingActivity;
+  private EventSequenceNumber sequenceNumber;
+  private HandlingActivity activity;
   private Date completionTime;
   private Date registrationTime;
   private Cargo cargo;
@@ -41,21 +43,24 @@ public final class HandlingEvent implements DomainEvent<HandlingEvent> {
    * association, it's never optional.
    */
   public enum Type implements ValueObject<Type> {
-    LOAD(true),
-    UNLOAD(true),
-    RECEIVE(false),
-    CLAIM(false),
-    CUSTOMS(false);
+    LOAD(true, true),
+    UNLOAD(true, true),
+    RECEIVE(false, true),
+    CLAIM(false, true),
+    CUSTOMS(false, false);
 
     private final boolean voyageRequired;
+    private final boolean physical;
 
     /**
      * Private enum constructor.
      *
      * @param voyageRequired whether or not a voyage is associated with this event type
+     * @param physical whether or not this event type is physical
      */
-    private Type(final boolean voyageRequired) {
+    private Type(final boolean voyageRequired, boolean physical) {
       this.voyageRequired = voyageRequired;
+      this.physical = physical;
     }
 
     /**
@@ -72,6 +77,13 @@ public final class HandlingEvent implements DomainEvent<HandlingEvent> {
       return !requiresVoyage();
     }
 
+    /**
+     * @return True if this is a physical handling.
+     */
+    public boolean isPhysical() {
+      return physical;
+    }
+
     @Override
     public boolean sameValueAs(Type other) {
       return other != null && this.equals(other);
@@ -104,10 +116,11 @@ public final class HandlingEvent implements DomainEvent<HandlingEvent> {
       throw new IllegalArgumentException("Voyage is not allowed with event type " + type);
     }
 
-    this.completionTime = (Date) completionTime.clone();
-    this.registrationTime = (Date) registrationTime.clone();
+    this.sequenceNumber = EventSequenceNumber.next();
+    this.completionTime = new Date(completionTime.getTime());
+    this.registrationTime = new Date(registrationTime.getTime());
     this.cargo = cargo;
-    this.handlingActivity = new HandlingActivity(type, location, voyage);
+    this.activity = new HandlingActivity(type, location, voyage);
   }
 
   /**
@@ -133,22 +146,27 @@ public final class HandlingEvent implements DomainEvent<HandlingEvent> {
       throw new IllegalArgumentException("Voyage is required for event type " + type);
     }
 
+    this.sequenceNumber = EventSequenceNumber.next();
     this.completionTime = new Date(completionTime.getTime());
     this.registrationTime = new Date(registrationTime.getTime());
     this.cargo = cargo;
-    this.handlingActivity = new HandlingActivity(type, location);
+    this.activity = new HandlingActivity(type, location);
+  }
+
+  public EventSequenceNumber sequenceNumber() {
+    return sequenceNumber;
   }
 
-  public HandlingActivity handlingActivity() {
-    return handlingActivity;
+  public HandlingActivity activity() {
+    return activity;
   }
 
   public Type type() {
-    return handlingActivity.type();
+    return activity.type();
   }
 
   public Voyage voyage() {
-    return DomainObjectUtils.nullSafe(handlingActivity.voyage(), Voyage.NONE);
+    return DomainObjectUtils.nullSafe(activity.voyage(), Voyage.NONE);
   }
 
   public Date completionTime() {
@@ -160,7 +178,7 @@ public final class HandlingEvent implements DomainEvent<HandlingEvent> {
   }
 
   public Location location() {
-    return handlingActivity.location();
+    return activity.location();
   }
 
   public Cargo cargo() {
@@ -182,7 +200,7 @@ public final class HandlingEvent implements DomainEvent<HandlingEvent> {
     return other != null && new EqualsBuilder().
       append(this.cargo, other.cargo).
       append(this.completionTime, other.completionTime).
-      append(this.handlingActivity, other.handlingActivity).
+      append(this.activity, other.activity).
       isEquals();
   }
 
@@ -191,14 +209,14 @@ public final class HandlingEvent implements DomainEvent<HandlingEvent> {
     return new HashCodeBuilder().
       append(cargo).
       append(completionTime).
-      append(handlingActivity).
+      append(activity).
       toHashCode();
   }
 
   @Override
   public String toString() {
     return "Cargo: " + cargo +
-      "\nActivity: " + handlingActivity +
+      "\nActivity: " + activity +
       "\nCompleted on: " + completionTime +
       "\nRegistered on: " + registrationTime;
   }

dddsample/src/main/java/se/citerus/dddsample/domain/model/handling/HandlingEventRepository.java

@@ -1,6 +1,7 @@
 package se.citerus.dddsample.domain.model.handling;
 
 import se.citerus.dddsample.domain.model.cargo.Cargo;
+import se.citerus.dddsample.domain.model.shared.EventSequenceNumber;
 
 /**
  * Handling event repository.
@@ -8,13 +9,18 @@ import se.citerus.dddsample.domain.model.cargo.Cargo;
 public interface HandlingEventRepository {
 
   /**
+   * @param eventSequenceNumber event sequence number
+   * @return The handling event with this sequence number, or null if not found
+   */
+  HandlingEvent find(EventSequenceNumber eventSequenceNumber);
+
+  /**
    * Stores a (new) handling event.
    *
    * @param event handling event to save
    */
   void store(HandlingEvent event);
 
-
   /**
    * @param cargo cargo
    * @return The handling history of this cargo
@@ -27,5 +33,4 @@ public interface HandlingEventRepository {
    * @return The most recent handling of the cargo, or null if it has never been handled.
    */
   HandlingEvent mostRecentHandling(Cargo cargo);
-
 }

dddsample/src/main/java/se/citerus/dddsample/domain/model/shared/EventSequenceNumber.java

@@ -0,0 +1,51 @@
+package se.citerus.dddsample.domain.model.shared;
+
+import se.citerus.dddsample.domain.shared.ValueObject;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+public class EventSequenceNumber implements ValueObject<EventSequenceNumber> {
+
+  private long value;
+  private static final AtomicLong SEQUENCE = new AtomicLong(System.currentTimeMillis());
+
+  private EventSequenceNumber(final long value) {
+    this.value = value;
+  }
+
+  public static EventSequenceNumber next() {
+    return new EventSequenceNumber(SEQUENCE.getAndIncrement());
+  }
+
+  public long longValue() {
+    return value;
+  }
+
+  @Override
+  public boolean sameValueAs(final EventSequenceNumber other) {
+    return false;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    return sameValueAs((EventSequenceNumber) o);
+  }
+
+  @Override
+  public int hashCode() {
+    return Long.valueOf(value).hashCode();
+  }
+
+  @Override
+  public String toString() {
+    return String.valueOf(value);
+  }
+
+  EventSequenceNumber() {
+    // Needed by Hibernate
+  }
+
+}

dddsample/src/main/java/se/citerus/dddsample/infrastructure/messaging/jms/JmsApplicationEventsImpl.java

@@ -18,10 +18,10 @@ public final class JmsApplicationEventsImpl implements ApplicationEvents {
 
   private JmsOperations jmsOperations;
   private Destination cargoHandledDestination;
-  private Destination cargoDeliveryUpdateDestination;
+  private Destination cargoUpdateDestination;
 
   @Override
-  public void cargoWasHandled(final HandlingEvent event) {
+  public void notifyOfHandlingEvent(final HandlingEvent event) {
     final Cargo cargo = event.cargo();
     jmsOperations.send(cargoHandledDestination, new MessageCreator() {
       public Message createMessage(final Session session) throws JMSException {
@@ -31,8 +31,8 @@ public final class JmsApplicationEventsImpl implements ApplicationEvents {
   }
 
   @Override
-  public void cargoDeliveryWasUpdated(final Cargo cargo) {
-    jmsOperations.send(cargoDeliveryUpdateDestination, new MessageCreator() {
+  public void notifyOfCargoUpdate(final Cargo cargo) {
+    jmsOperations.send(cargoUpdateDestination, new MessageCreator() {
       public Message createMessage(Session session) throws JMSException {
         return session.createObjectMessage(cargo.trackingId());
       }
@@ -47,8 +47,8 @@ public final class JmsApplicationEventsImpl implements ApplicationEvents {
     this.cargoHandledDestination = cargoHandledDestination;
   }
 
-  public void setCargoDeliveryUpdateDestination(Destination cargoDeliveryUpdateDestination) {
-    this.cargoDeliveryUpdateDestination = cargoDeliveryUpdateDestination;
+  public void setCargoUpdateDestination(Destination cargoUpdateDestination) {
+    this.cargoUpdateDestination = cargoUpdateDestination;
   }
 
 }

dddsample/src/main/java/se/citerus/dddsample/infrastructure/persistence/DatabaseTrackingIdGenerator.java

@@ -0,0 +1,32 @@
+/**
+ * Purpose
+ * @author peter
+ * @created 2009-sep-17
+ * $Id$
+ */
+package se.citerus.dddsample.infrastructure.persistence;
+
+import org.hibernate.SessionFactory;
+import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import se.citerus.dddsample.domain.model.cargo.TrackingIdGenerator;
+
+public class DatabaseTrackingIdGenerator implements TrackingIdGenerator {
+
+  private final SessionFactory sessionFactory;
+  private static final String SEQUENCE_NAME = "TRACKING_ID_SEQ";
+
+  public DatabaseTrackingIdGenerator(final SessionFactory sessionFactory) {
+    this.sessionFactory = sessionFactory;
+  }
+
+  @Override
+  public TrackingId nextTrackingId() {
+    final Long seq = (Long) sessionFactory.getCurrentSession().
+      createSQLQuery("select next_value from system_sequences where sequence_name = ?").
+      setParameter(1, SEQUENCE_NAME).
+      uniqueResult();
+
+    return new TrackingId(seq);
+  }
+
+}

dddsample/src/main/java/se/citerus/dddsample/infrastructure/persistence/TrackingIdGeneratorInMem.java

@@ -0,0 +1,23 @@
+/**
+ * Purpose
+ * @author peter
+ * @created 2009-sep-07
+ * $Id$
+ */
+package se.citerus.dddsample.infrastructure.persistence;
+
+import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import se.citerus.dddsample.domain.model.cargo.TrackingIdGenerator;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+public class TrackingIdGeneratorInMem implements TrackingIdGenerator {
+
+  private static final AtomicLong SEQ = new AtomicLong(1);
+
+  @Override
+  public TrackingId nextTrackingId() {
+    return new TrackingId(SEQ.getAndIncrement());
+  }
+
+}

dddsample/src/main/java/se/citerus/dddsample/infrastructure/persistence/hibernate/CargoRepositoryHibernate.java

@@ -7,7 +7,6 @@ import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 
 import java.util.List;
-import java.util.UUID;
 
 /**
  * Hibernate implementation of CargoRepository.
@@ -15,6 +14,7 @@ import java.util.UUID;
 @Repository
 public class CargoRepositoryHibernate extends HibernateRepository implements CargoRepository {
 
+  @Override
   public Cargo find(TrackingId tid) {
     return (Cargo) getSession().
       createQuery("from Cargo where trackingId = :tid").
@@ -33,21 +33,15 @@ public class CargoRepositoryHibernate extends HibernateRepository implements Car
       list();
   }
 
+  @Override
   public void store(Cargo cargo) {
     getSession().saveOrUpdate(cargo);
     // Delete-orphan does not seem to work correctly when the parent is a component
     getSession().createSQLQuery("delete from Leg where cargo_id = null").executeUpdate();
   }
 
-  public TrackingId nextTrackingId() {
-    // TODO use an actual DB sequence here, UUID is for in-mem
-    final String random = UUID.randomUUID().toString().toUpperCase();
-    return new TrackingId(
-      random.substring(0, random.indexOf("-"))
-    );
-  }
-
   @SuppressWarnings("unchecked")
+  @Override
   public List<Cargo> findAll() {
     return getSession().createQuery("from Cargo").list();
   }

dddsample/src/main/java/se/citerus/dddsample/infrastructure/persistence/hibernate/HandlingEventRepositoryHibernate.java

@@ -5,6 +5,7 @@ import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
+import se.citerus.dddsample.domain.model.shared.EventSequenceNumber;
 
 import java.util.List;
 
@@ -15,14 +16,22 @@ import java.util.List;
 public class HandlingEventRepositoryHibernate extends HibernateRepository implements HandlingEventRepository {
 
   @Override
+  public HandlingEvent find(EventSequenceNumber eventSequenceNumber) {
+    return (HandlingEvent) getSession().
+      createQuery("from HandlingEvent where sequenceNumber = :sn").
+      setParameter("sn", eventSequenceNumber).
+      uniqueResult();
+  }
+
+  @Override
   public void store(final HandlingEvent event) {
     getSession().save(event);
   }
 
   @Override
   public HandlingHistory lookupHandlingHistoryOfCargo(final Cargo cargo) {
-    final List handlingEvents = getSession().createQuery(
-      "from HandlingEvent where cargo.trackingId = :tid").
+    final List handlingEvents = getSession().
+      createQuery("from HandlingEvent where cargo.trackingId = :tid").
       setParameter("tid", cargo.trackingId()).
       list();
 
@@ -35,8 +44,8 @@ public class HandlingEventRepositoryHibernate extends HibernateRepository implem
 
   @Override
   public HandlingEvent mostRecentHandling(Cargo cargo) {
-      return (HandlingEvent) getSession().createQuery(
-        "from HandlingEvent where cargo = :cargo order by completionTime desc").
+      return (HandlingEvent) getSession().
+        createQuery("from HandlingEvent where cargo = :cargo order by completionTime desc").
         setParameter("cargo", cargo).
         setMaxResults(1).
         uniqueResult();

dddsample/src/main/java/se/citerus/dddsample/interfaces/booking/facade/internal/assembler/CargoRoutingDTOAssembler.java

@@ -20,7 +20,7 @@ public class CargoRoutingDTOAssembler {
       cargo.routeSpecification().origin().unLocode().stringValue(),
       cargo.routeSpecification().destination().unLocode().stringValue(),
       cargo.routeSpecification().arrivalDeadline(),
-      cargo.delivery().routingStatus().sameValueAs(RoutingStatus.MISROUTED));
+      cargo.routingStatus().sameValueAs(RoutingStatus.MISROUTED));
     for (Leg leg : cargo.itinerary().legs()) {
       dto.addLeg(
         leg.voyage().voyageNumber().stringValue(),

dddsample/src/main/java/se/citerus/dddsample/interfaces/tracking/CargoTrackingViewAdapter.java

@@ -2,7 +2,6 @@ package se.citerus.dddsample.interfaces.tracking;
 
 import org.springframework.context.MessageSource;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
-import se.citerus.dddsample.domain.model.cargo.Delivery;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.shared.HandlingActivity;
@@ -60,16 +59,15 @@ public final class CargoTrackingViewAdapter {
    * @return A translated string describing the cargo status.
    */
   public String getStatusText() {
-    final Delivery delivery = cargo.delivery();
-    final String code = "cargo.status." + delivery.transportStatus().name();
+    final String code = "cargo.status." + cargo.transportStatus().name();
 
     final Object[] args;
-    switch (delivery.transportStatus()) {
+    switch (cargo.transportStatus()) {
       case IN_PORT:
-        args = new Object[]{getDisplayText(delivery.lastKnownLocation())};
+        args = new Object[]{getDisplayText(cargo.lastKnownLocation())};
         break;
       case ONBOARD_CARRIER:
-        args = new Object[]{delivery.currentVoyage().voyageNumber().stringValue()};
+        args = new Object[]{cargo.currentVoyage().voyageNumber().stringValue()};
         break;
       case CLAIMED:
       case NOT_RECEIVED:
@@ -104,7 +102,7 @@ public final class CargoTrackingViewAdapter {
   }
 
   public String getEta() {
-    Date eta = cargo.projections().estimatedTimeOfArrival();
+    Date eta = cargo.estimatedTimeOfArrival();
 
     if (eta == null) return "?";
     else {
@@ -116,7 +114,7 @@ public final class CargoTrackingViewAdapter {
   }
 
   public String getNextExpectedActivity() {
-    HandlingActivity activity = cargo.projections().nextExpectedActivity();
+    HandlingActivity activity = cargo.nextExpectedActivity();
     if (activity == null) {
       return "";
     }
@@ -140,7 +138,7 @@ public final class CargoTrackingViewAdapter {
    * @return True if cargo is misdirected.
    */
   public boolean isMisdirected() {
-    return cargo.delivery().isMisdirected();
+    return cargo.isMisdirected();
   }
 
   /**
@@ -195,7 +193,7 @@ public final class CargoTrackingViewAdapter {
      * @return True if the event was expected, according to the cargo's itinerary.
      */
     public boolean isExpected() {
-      return cargo.itinerary().isExpected(handlingEvent.handlingActivity());
+      return cargo.itinerary().isExpected(handlingEvent.activity());
     }
 
     public String getDescription() {

dddsample/src/main/resources/context-application.xml

@@ -17,7 +17,7 @@
     <constructor-arg ref="locationRepository"/>
   </bean>
 
-  <bean id="cargoDeliveryUpdater" class="se.citerus.dddsample.application.event.CargoDeliveryUpdater">
+  <bean id="cargoUpdater" class="se.citerus.dddsample.application.event.CargoUpdater">
     <constructor-arg ref="cargoRepository"/>
     <constructor-arg ref="applicationEvents"/>
     <constructor-arg ref="handlingEventRepository"/>

dddsample/src/main/resources/context-domain.xml

@@ -11,7 +11,7 @@
   </bean>
 
   <bean id="cargoFactory" class="se.citerus.dddsample.domain.model.cargo.CargoFactory">
-    <constructor-arg ref="cargoRepository"/>
+    <constructor-arg ref="trackingIdGenerator"/>
     <constructor-arg ref="locationRepository"/>
   </bean>
 

dddsample/src/main/resources/context-infrastructure-messaging.xml

@@ -14,12 +14,12 @@
   <amq:connectionFactory id="jmsConnectionFactory" brokerURL="vm://localhost?broker.persistent=false&amp;broker.useJmx=false"/>
 
   <amq:queue id="cargoHandledQueue" name="CargoHandledQueue" physicalName="CargoHandledQueue"/>
-  <amq:topic id="cargoDeliveryUpdateTopic" name="CargoDeliveryUpdateTopic" physicalName="CargoDeliveryUpdateTopic"/>
+  <amq:topic id="cargoUpdateTopic" name="CargUpdateTopic" physicalName="CargoUpdateTopic"/>
 
   <jms:listener-container connection-factory="jmsConnectionFactory">
     <jms:listener destination="CargoHandledQueue" ref="listener3"/>
-    <jms:listener destination="CargoDeliveryUpdateTopic" ref="listener1"/>
-    <jms:listener destination="CargoDeliveryUpdateTopic" ref="listener2"/>
+    <jms:listener destination="CargoUpdateTopic" ref="listener1"/>
+    <jms:listener destination="CargoUpdateTopic" ref="listener2"/>
   </jms:listener-container>
 
   <bean id="jmsOperations" class="org.springframework.jms.core.JmsTemplate">
@@ -29,7 +29,7 @@
   <bean id="applicationEvents" class="se.citerus.dddsample.infrastructure.messaging.jms.JmsApplicationEventsImpl">
     <property name="jmsOperations" ref="jmsOperations"/>
     <property name="cargoHandledDestination" ref="cargoHandledQueue"/>
-    <property name="cargoDeliveryUpdateDestination" ref="cargoDeliveryUpdateTopic"/>
+    <property name="cargoUpdateDestination" ref="cargoUpdateTopic"/>
   </bean>
 
   <bean id="listener1" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
@@ -43,8 +43,8 @@
   </bean>
 
   <bean id="listener3" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
-    <constructor-arg ref="cargoDeliveryUpdater"/>
-    <property name="defaultListenerMethod" value="updateDelivery"/>
+    <constructor-arg ref="cargoUpdater"/>
+    <property name="defaultListenerMethod" value="updateCargo"/>
   </bean>
 
 </beans>

dddsample/src/main/resources/context-infrastructure-persistence.xml

@@ -52,4 +52,6 @@
     <property name="sessionFactory" ref="sessionFactory"/>
   </bean>
 
+  <bean id="trackingIdGenerator" class="se.citerus.dddsample.infrastructure.persistence.TrackingIdGeneratorInMem"/>
+  
 </beans>

dddsample/src/main/resources/se/citerus/dddsample/infrastructure/persistence/hibernate/Cargo.hbm.xml

@@ -30,25 +30,27 @@
     </component>
 
     <component name="delivery" lazy="true">
-      <property name="misdirected" column="is_misdirected" not-null="true"/>
       <property name="calculatedAt" column="calculated_at" not-null="true"/>
-      <property name="isUnloadedAtDestination" column="unloaded_at_dest" not-null="true"/>
 
+      <property name="misdirected" column="is_misdirected" not-null="true"/>
       <property name="routingStatus" column="routing_status" not-null="true">
         <type name="org.hibernate.type.EnumType">
           <param name="enumClass">se.citerus.dddsample.domain.model.cargo.RoutingStatus</param>
           <param name="type">12</param><!-- 12 is java.sql.Types.VARCHAR -->
         </type>
       </property>
+      <property name="isUnloadedAtDestination" column="unloaded_at_dest" not-null="true"/>
 
-      <property name="transportStatus" column="transport_status" not-null="true">
-        <type name="org.hibernate.type.EnumType">
-          <param name="enumClass">se.citerus.dddsample.domain.model.cargo.TransportStatus</param>
-          <param name="type">12</param><!-- 12 is java.sql.Types.VARCHAR -->
-        </type>
-      </property>
-      <many-to-one name="currentVoyage" column="current_voyage_id" not-null="false" cascade="none" foreign-key="current_voyage_fk"/>
-      <many-to-one name="lastKnownLocation" column="last_known_location_id" not-null="false" cascade="none" foreign-key="last_known_location_fk"/>
+      <component name="mostRecentHandlingActivity">
+        <many-to-one name="location" column="most_recent_location_id" foreign-key="most_recent_location_fk" cascade="none"/>
+        <property name="type" column="most_recent_handling_event_type">
+          <type name="org.hibernate.type.EnumType">
+            <param name="enumClass">se.citerus.dddsample.domain.model.handling.HandlingEvent$Type</param>
+            <param name="type">12</param><!-- 12 is java.sql.Types.VARCHAR -->
+          </type>
+        </property>
+        <many-to-one name="voyage" column="most_recent_voyage_id" foreign-key="most_recent_voyage_fk" cascade="none"/>
+      </component>
     </component>
 
     <component name="routeSpecification">

dddsample/src/main/resources/se/citerus/dddsample/infrastructure/persistence/hibernate/HandlingEvent.hbm.xml

@@ -9,10 +9,13 @@
     <id name="id" column="id">
       <generator class="org.hibernate.id.IdentityGenerator"/>
     </id>
+    <component name="sequenceNumber" update="false">
+      <property name="value" column="sequence_number" not-null="true"/>
+    </component>
     <many-to-one name="cargo" column="cargo_id" not-null="true" cascade="none" foreign-key="cargo_fk"/>
     <property name="completionTime" column="completionTime" not-null="true"/>
     <property name="registrationTime" column="registrationTime" not-null="true"/>
-    <component name="handlingActivity">
+    <component name="activity">
       <many-to-one name="voyage" column="voyage_id" not-null="false" cascade="none" foreign-key="event_voyage_fk"/>
       <many-to-one name="location" column="location_id" not-null="true" cascade="none" foreign-key="location_fk"/>
       <property name="type" column="type" not-null="true">

dddsample/src/test/java/se/citerus/dddsample/application/BookingServiceTest.java

@@ -3,10 +3,7 @@ package se.citerus.dddsample.application;
 import junit.framework.TestCase;
 import static org.easymock.EasyMock.*;
 import se.citerus.dddsample.application.impl.BookingServiceImpl;
-import se.citerus.dddsample.domain.model.cargo.Cargo;
-import se.citerus.dddsample.domain.model.cargo.CargoFactory;
-import se.citerus.dddsample.domain.model.cargo.CargoRepository;
-import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import se.citerus.dddsample.domain.model.cargo.*;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.CHICAGO;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
@@ -21,12 +18,15 @@ public class BookingServiceTest extends TestCase {
   CargoRepository cargoRepository;
   LocationRepository locationRepository;
   RoutingService routingService;
+  TrackingIdGenerator trackingIdGenerator;
 
   protected void setUp() throws Exception {
     cargoRepository = createMock(CargoRepository.class);
     locationRepository = createMock(LocationRepository.class);
     routingService = createMock(RoutingService.class);
-    bookingService = new BookingServiceImpl(routingService, new CargoFactory(cargoRepository, locationRepository), cargoRepository, locationRepository);
+    trackingIdGenerator = createMock(TrackingIdGenerator.class);
+    CargoFactory cargoFactory = new CargoFactory(locationRepository, trackingIdGenerator);
+    bookingService = new BookingServiceImpl(routingService, cargoFactory, cargoRepository, locationRepository);
   }
 
   public void testRegisterNew() {
@@ -34,19 +34,19 @@ public class BookingServiceTest extends TestCase {
     UnLocode fromUnlocode = new UnLocode("USCHI");
     UnLocode toUnlocode = new UnLocode("SESTO");
 
-    expect(cargoRepository.nextTrackingId()).andReturn(expectedTrackingId);
+    expect(trackingIdGenerator.nextTrackingId()).andReturn(expectedTrackingId);
     expect(locationRepository.find(fromUnlocode)).andReturn(CHICAGO);
     expect(locationRepository.find(toUnlocode)).andReturn(STOCKHOLM);
 
     cargoRepository.store(isA(Cargo.class));
 
-    replay(cargoRepository, locationRepository);
+    replay(cargoRepository, locationRepository, trackingIdGenerator);
 
     TrackingId trackingId = bookingService.bookNewCargo(fromUnlocode, toUnlocode, new Date());
     assertEquals(expectedTrackingId, trackingId);
   }
 
   protected void tearDown() throws Exception {
-    verify(cargoRepository, locationRepository);
+    verify(cargoRepository, locationRepository, trackingIdGenerator);
   }
 }

dddsample/src/test/java/se/citerus/dddsample/application/HandlingEventServiceTest.java

@@ -48,7 +48,7 @@ public class HandlingEventServiceTest extends TestCase {
     expect(voyageRepository.find(CM001.voyageNumber())).andReturn(CM001);
     expect(locationRepository.find(STOCKHOLM.unLocode())).andReturn(STOCKHOLM);
     handlingEventRepository.store(isA(HandlingEvent.class));
-    applicationEvents.cargoWasHandled(isA(HandlingEvent.class));
+    applicationEvents.notifyOfHandlingEvent(isA(HandlingEvent.class));
 
     replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, applicationEvents);
 

dddsample/src/test/java/se/citerus/dddsample/domain/model/cargo/CargoFactoryTest.java

@@ -12,14 +12,14 @@ import org.junit.Test;
 import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HONGKONG;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.ROTTERDAM;
-import se.citerus.dddsample.infrastructure.persistence.inmemory.CargoRepositoryInMem;
+import se.citerus.dddsample.infrastructure.persistence.TrackingIdGeneratorInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
 
 public class CargoFactoryTest {
 
   @Test
   public void createNewCargo() {
-    CargoFactory cargoFactory = new CargoFactory(new CargoRepositoryInMem(), new LocationRepositoryInMem());
+    CargoFactory cargoFactory = new CargoFactory(new LocationRepositoryInMem(), new TrackingIdGeneratorInMem());
     Cargo cargo = cargoFactory.newCargo(
       HONGKONG.unLocode(), ROTTERDAM.unLocode(), toDate("2009-07-01")
     );

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

@@ -5,9 +5,10 @@ import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import static se.citerus.dddsample.domain.model.cargo.TransportStatus.NOT_RECEIVED;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import se.citerus.dddsample.domain.model.handling.HandlingHistory;
+import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.domain.model.location.Location;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+import se.citerus.dddsample.domain.model.shared.HandlingActivity;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 
@@ -52,10 +53,10 @@ public class CargoTest extends TestCase {
 
     Cargo cargo = new Cargo(trackingId, routeSpecification);
 
-    assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
-    assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
-    assertEquals(Location.UNKNOWN, cargo.delivery().lastKnownLocation());
-    assertEquals(Voyage.NONE, cargo.delivery().currentVoyage());
+    assertEquals(NOT_ROUTED, cargo.routingStatus());
+    assertEquals(NOT_RECEIVED, cargo.transportStatus());
+    assertEquals(Location.UNKNOWN, cargo.lastKnownLocation());
+    assertEquals(Voyage.NONE, cargo.currentVoyage());
   }
 
   public void testRoutingStatus() throws Exception {
@@ -71,43 +72,43 @@ public class CargoTest extends TestCase {
 
     cargo.specifyNewRoute(acceptOnlyGood);
 
-    assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
+    assertEquals(NOT_ROUTED, cargo.routingStatus());
 
     cargo.assignToRoute(bad);
-    assertEquals(MISROUTED, cargo.delivery().routingStatus());
+    assertEquals(MISROUTED, cargo.routingStatus());
 
     cargo.assignToRoute(good);
-    assertEquals(ROUTED, cargo.delivery().routingStatus());
+    assertEquals(ROUTED, cargo.routingStatus());
   }
 
   public void testlastKnownLocationUnknownWhenNoEvents() throws Exception {
     Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
-    assertEquals(Location.UNKNOWN, cargo.delivery().lastKnownLocation());
+    assertEquals(Location.UNKNOWN, cargo.lastKnownLocation());
   }
 
   public void testlastKnownLocationReceived() throws Exception {
     Cargo cargo = populateCargoReceivedStockholm();
 
-    assertEquals(STOCKHOLM, cargo.delivery().lastKnownLocation());
+    assertEquals(STOCKHOLM, cargo.lastKnownLocation());
   }
 
   public void testlastKnownLocationClaimed() throws Exception {
     Cargo cargo = populateCargoClaimedMelbourne();
 
-    assertEquals(MELBOURNE, cargo.delivery().lastKnownLocation());
+    assertEquals(MELBOURNE, cargo.lastKnownLocation());
   }
 
   public void testlastKnownLocationUnloaded() throws Exception {
     Cargo cargo = populateCargoOffHongKong();
 
-    assertEquals(HONGKONG, cargo.delivery().lastKnownLocation());
+    assertEquals(HONGKONG, cargo.lastKnownLocation());
   }
 
   public void testlastKnownLocationloaded() throws Exception {
     Cargo cargo = populateCargoOnHamburg();
 
-    assertEquals(HAMBURG, cargo.delivery().lastKnownLocation());
+    assertEquals(HAMBURG, cargo.lastKnownLocation());
   }
 
   public void testEquality() throws Exception {
@@ -126,171 +127,113 @@ public class CargoTest extends TestCase {
 
   public void testIsUnloadedAtFinalDestination() throws Exception {
     Cargo cargo = setUpCargoWithItinerary(HANGZOU, TOKYO, NEWYORK);
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    assertFalse(cargo.isReadyToClaim());
 
     // Adding an event unrelated to unloading at final destination
-
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(
-      new HandlingEvent(cargo, new Date(10), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU));
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU));
+    assertFalse(cargo.isReadyToClaim());
 
     Voyage voyage = new Voyage.Builder(new VoyageNumber("0123"), HANGZOU).
       addMovement(NEWYORK, new Date(), new Date()).
       build();
 
     // Adding an unload event, but not at the final destination
-    events.add(
-      new HandlingEvent(cargo, new Date(20), new Date(), HandlingEvent.Type.UNLOAD, TOKYO, voyage));
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    cargo.handled(new HandlingActivity(UNLOAD, TOKYO, voyage));
+    assertFalse(cargo.isReadyToClaim());
 
     // Adding an event in the final destination, but not unload
-    events.add(
-      new HandlingEvent(cargo, new Date(30), new Date(), HandlingEvent.Type.CUSTOMS, NEWYORK));
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    cargo.handled(new HandlingActivity(CUSTOMS, NEWYORK));
+    assertFalse(cargo.isReadyToClaim());
 
     // Finally, cargo is unloaded at final destination
-    events.add(
-      new HandlingEvent(cargo, new Date(40), new Date(), HandlingEvent.Type.UNLOAD, NEWYORK, voyage));
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-    assertTrue(cargo.delivery().isUnloadedAtDestination());
+    cargo.handled(new HandlingActivity(UNLOAD, NEWYORK, voyage));
+    assertTrue(cargo.isReadyToClaim());
   }
 
-  // TODO: Generate test data some better way
   private Cargo populateCargoReceivedStockholm() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
-
-    HandlingEvent he = new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.RECEIVE, STOCKHOLM);
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(he);
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-
+    cargo.handled(new HandlingActivity(RECEIVE, STOCKHOLM));
     return cargo;
   }
 
   private Cargo populateCargoClaimedMelbourne() throws Exception {
     final Cargo cargo = populateCargoOffMelbourne();
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(new HandlingEvent(cargo, toDate("2007-12-09"), new Date(), HandlingEvent.Type.CLAIM, MELBOURNE));
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
+    cargo.handled(new HandlingActivity(CLAIM, MELBOURNE));
     return cargo;
   }
 
   private Cargo populateCargoOffHongKong() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
-
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, crazyVoyage));
-
-    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, crazyVoyage));
-
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
+    
+    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));
     return cargo;
   }
 
   private Cargo populateCargoOnHamburg() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
-
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, crazyVoyage));
-
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
+    
+    cargo.handled(new HandlingActivity(LOAD, STOCKHOLM, crazyVoyage));
+    cargo.handled(new HandlingActivity(UNLOAD, HAMBURG, crazyVoyage));
+    cargo.handled(new HandlingActivity(LOAD, HAMBURG, crazyVoyage));
     return cargo;
   }
 
   private Cargo populateCargoOffMelbourne() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
 
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, crazyVoyage));
-
-    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, crazyVoyage));
+    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));
 
-    events.add(new HandlingEvent(cargo, toDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-07"), new Date(), HandlingEvent.Type.UNLOAD, MELBOURNE, crazyVoyage));
-
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-    return cargo;
-  }
-
-  private Cargo populateCargoOnHongKong() throws Exception {
-    final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
-
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, crazyVoyage));
-
-    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, crazyVoyage));
-    events.add(new HandlingEvent(cargo, toDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, crazyVoyage));
-
-    events.add(new HandlingEvent(cargo, toDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, crazyVoyage));
-
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     return cargo;
   }
 
   public void testIsMisdirected() throws Exception {
     //A cargo with no itinerary is not misdirected
     Cargo cargo = new Cargo(new TrackingId("TRKID"), new RouteSpecification(SHANGHAI, GOTHENBURG, new Date()));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertFalse(cargo.isMisdirected());
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
 
     //A cargo with no handling events is not misdirected
-    assertFalse(cargo.delivery().isMisdirected());
+    assertFalse(cargo.isMisdirected());
 
     //Happy path
     List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(new HandlingEvent(cargo, new Date(10), new Date(20), HandlingEvent.Type.RECEIVE, SHANGHAI));
-    events.add(new HandlingEvent(cargo, new Date(30), new Date(40), HandlingEvent.Type.LOAD, SHANGHAI, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(50), new Date(60), HandlingEvent.Type.UNLOAD, ROTTERDAM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(70), new Date(80), HandlingEvent.Type.LOAD, ROTTERDAM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(90), new Date(100), HandlingEvent.Type.UNLOAD, GOTHENBURG, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(110), new Date(120), HandlingEvent.Type.CLAIM, GOTHENBURG));
-    events.add(new HandlingEvent(cargo, new Date(130), new Date(140), HandlingEvent.Type.CUSTOMS, GOTHENBURG));
 
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-    assertFalse(cargo.delivery().isMisdirected());
+    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));
+    assertFalse(cargo.isMisdirected());
 
     //Try a couple of failing ones
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
-    events.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU));
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
-    assertTrue(cargo.delivery().isMisdirected());
+    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU));
+    assertTrue(cargo.isMisdirected());
 
-    cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
 
-    events.add(new HandlingEvent(cargo, new Date(10), new Date(20), HandlingEvent.Type.RECEIVE, SHANGHAI));
-    events.add(new HandlingEvent(cargo, new Date(30), new Date(40), HandlingEvent.Type.LOAD, SHANGHAI, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(50), new Date(60), HandlingEvent.Type.UNLOAD, ROTTERDAM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(70), new Date(80), HandlingEvent.Type.LOAD, ROTTERDAM, crazyVoyage));
-
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
-
-    assertTrue(cargo.delivery().isMisdirected());
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
 
-    events.add(new HandlingEvent(cargo, new Date(10), new Date(20), HandlingEvent.Type.RECEIVE, SHANGHAI));
-    events.add(new HandlingEvent(cargo, new Date(30), new Date(40), HandlingEvent.Type.LOAD, SHANGHAI, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(50), new Date(60), HandlingEvent.Type.UNLOAD, ROTTERDAM, crazyVoyage));
-    events.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CLAIM, ROTTERDAM));
-
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
+    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));
 
-    assertTrue(cargo.delivery().isMisdirected());
+    assertTrue(cargo.isMisdirected());
   }
 
   public void testCustomsClearancePoint() {

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

@@ -1,17 +1,16 @@
 package se.citerus.dddsample.domain.model.cargo;
 
 import junit.framework.TestCase;
-import static se.citerus.dddsample.application.util.DateTestUtil.*;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.DALLAS;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.MISROUTED;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.ROUTED;
+import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
+import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.domain.model.location.Location;
-import se.citerus.dddsample.domain.model.voyage.Voyage;
-import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.*;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.shared.HandlingActivity;
-import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
-import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
-import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
+import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.*;
+import se.citerus.dddsample.domain.model.voyage.Voyage;
 
 import java.util.Date;
 
@@ -31,7 +30,7 @@ public class DeliveryTest extends TestCase {
       Leg.deriveLeg(DALLAS_TO_HELSINKI, DALLAS, STOCKHOLM)
     );
     delivery = Delivery.initial(routeSpecification, itinerary);
-    projections = new Projections(delivery, itinerary, routeSpecification);
+    projections = new Projections(delivery, itinerary);
     Thread.sleep(1);
   }
 
@@ -53,7 +52,7 @@ public class DeliveryTest extends TestCase {
 
     HandlingActivity handlingActivity = new HandlingActivity(RECEIVE, HANGZOU);
     Delivery newDelivery = delivery.whenHandled(routeSpecification, itinerary, handlingActivity);
-    Projections newProjections = new Projections(newDelivery, itinerary, routeSpecification, handlingActivity);
+    Projections newProjections = new Projections(newDelivery, itinerary);
 
     // Changed on handling
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
@@ -76,7 +75,7 @@ public class DeliveryTest extends TestCase {
 
     handlingActivity = new HandlingActivity(LOAD, HANGZOU, HONGKONG_TO_NEW_YORK);
     newDelivery = newDelivery.whenHandled(routeSpecification, itinerary, handlingActivity);
-    newProjections = new Projections(newDelivery, itinerary, routeSpecification, handlingActivity);
+    newProjections = new Projections(newDelivery, itinerary);
 
     assertEquals(HONGKONG_TO_NEW_YORK, newDelivery.currentVoyage());
     assertEquals(HANGZOU, newDelivery.lastKnownLocation());
@@ -97,7 +96,7 @@ public class DeliveryTest extends TestCase {
 
     handlingActivity = new HandlingActivity(UNLOAD, STOCKHOLM, DALLAS_TO_HELSINKI);
     newDelivery = newDelivery.whenHandled(routeSpecification, itinerary, handlingActivity);
-    newProjections = new Projections(newDelivery, itinerary, routeSpecification, handlingActivity);
+    newProjections = new Projections(newDelivery, itinerary);
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
@@ -116,7 +115,7 @@ public class DeliveryTest extends TestCase {
 
     handlingActivity = new HandlingActivity(CLAIM, STOCKHOLM);
     newDelivery = newDelivery.whenHandled(routeSpecification, itinerary, handlingActivity);
-    newProjections = new Projections(newDelivery, itinerary, routeSpecification, handlingActivity);
+    newProjections = new Projections(newDelivery, itinerary);
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
@@ -136,7 +135,7 @@ public class DeliveryTest extends TestCase {
     // Unload in Hamburg, which is the wrong location
     HandlingActivity handlingActivity = new HandlingActivity(UNLOAD, HAMBURG, DALLAS_TO_HELSINKI);
     Delivery newDelivery = delivery.whenHandled(routeSpecification, itinerary, handlingActivity);
-    Projections newProjections = new Projections(newDelivery, itinerary, routeSpecification, handlingActivity);
+    Projections newProjections = new Projections(newDelivery, itinerary);
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(HAMBURG, newDelivery.lastKnownLocation());
@@ -158,7 +157,7 @@ public class DeliveryTest extends TestCase {
     // New route specification, old itinerary
     RouteSpecification newRouteSpecification = routeSpecification.withOrigin(HAMBURG);
     newDelivery = newDelivery.withRoutingChange(newRouteSpecification, itinerary);
-    newProjections = new Projections(newDelivery, itinerary, newRouteSpecification);
+    newProjections = new Projections(newDelivery, itinerary);
     assertEquals(MISROUTED, newDelivery.routingStatus());
 
     // TODO is it misdirected at this point?
@@ -172,7 +171,7 @@ public class DeliveryTest extends TestCase {
     );
 
     newDelivery = newDelivery.withRoutingChange(newRouteSpecification, newItinerary);
-    newProjections = new Projections(newDelivery, newItinerary, newRouteSpecification);
+    newProjections = new Projections(newDelivery, newItinerary);
 
     assertEquals(ROUTED, newDelivery.routingStatus());
     assertFalse(newDelivery.isMisdirected());

dddsample/src/test/java/se/citerus/dddsample/infrastructure/TrackingIdGeneratorTest.java

@@ -0,0 +1,22 @@
+package se.citerus.dddsample.infrastructure;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import se.citerus.dddsample.domain.model.cargo.TrackingIdGenerator;
+import se.citerus.dddsample.infrastructure.persistence.TrackingIdGeneratorInMem;
+
+public class TrackingIdGeneratorTest extends TestCase {
+
+  TrackingIdGenerator trackingIdGenerator = new TrackingIdGeneratorInMem();
+
+  public void testNextTrackingId() {
+    TrackingId trackingId = trackingIdGenerator.nextTrackingId();
+    Assert.assertNotNull(trackingId);
+
+    TrackingId trackingId2 = trackingIdGenerator.nextTrackingId();
+    Assert.assertNotNull(trackingId2);
+    Assert.assertFalse(trackingId.equals(trackingId2));
+  }
+
+}

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/CargoRepositoryTest.java

@@ -46,8 +46,6 @@ public class CargoRepositoryTest extends AbstractRepositoryTest {
     assertEquals(HONGKONG, cargo.routeSpecification().origin());
     assertEquals(HELSINKI, cargo.routeSpecification().destination());
 
-    assertNotNull(cargo.delivery());
-
     final List<HandlingEvent> events = handlingEventRepository.lookupHandlingHistoryOfCargo(cargo).distinctEventsByCompletionTime();
     assertEquals(2, events.size());
 
@@ -161,15 +159,6 @@ public class CargoRepositoryTest extends AbstractRepositoryTest {
     assertEquals(6, all.size());
   }
 
-  public void testNextTrackingId() {
-    TrackingId trackingId = cargoRepository.nextTrackingId();
-    assertNotNull(trackingId);
-
-    TrackingId trackingId2 = cargoRepository.nextTrackingId();
-    assertNotNull(trackingId2);
-    assertFalse(trackingId.equals(trackingId2));
-  }
-
   public void testFindCargosOnVoyage() {
     Voyage voyage = voyageRepository.find(new VoyageNumber("0101"));
     List<Cargo> cargos = cargoRepository.findCargosOnVoyage(voyage);

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/HandlingEventRepositoryTest.java

@@ -65,7 +65,7 @@ public class HandlingEventRepositoryTest extends AbstractRepositoryTest {
     HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(cargo);
     assertEquals(cargo, handlingEvent.cargo());
     assertEquals(toDate("2007-09-27", "05:00"), handlingEvent.completionTime());
-    assertEquals(new HandlingActivity(HandlingEvent.Type.CLAIM, MELBOURNE), handlingEvent.handlingActivity());
+    assertEquals(new HandlingActivity(HandlingEvent.Type.CLAIM, MELBOURNE), handlingEvent.activity());
   }
 
 }

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/CarrierMovementRepositoryTest.java → dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/VoyageRepositoryTest.java

@@ -4,7 +4,7 @@ import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 
-public class CarrierMovementRepositoryTest extends AbstractRepositoryTest {
+public class VoyageRepositoryTest extends AbstractRepositoryTest {
 
   VoyageRepository voyageRepository;
 

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/inmemory/CargoRepositoryInMem.java

@@ -4,7 +4,6 @@ import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.CargoRepository;
 import se.citerus.dddsample.domain.model.cargo.RouteSpecification;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
-import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import se.citerus.dddsample.domain.model.location.Location;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
@@ -38,7 +37,7 @@ public class CargoRepositoryInMem implements CargoRepository {
   public List<Cargo> findCargosOnVoyage(Voyage voyage) {
     List<Cargo> onVoyage = new ArrayList<Cargo>();
     for (Cargo cargo : cargoDb.values()) {
-      if (voyage.sameIdentityAs(cargo.delivery().currentVoyage())) {
+      if (voyage.sameIdentityAs(cargo.currentVoyage())) {
         onVoyage.add(cargo);
       }
     }
@@ -51,14 +50,6 @@ public class CargoRepositoryInMem implements CargoRepository {
   }
 
   @Override
-  public TrackingId nextTrackingId() {
-    String random = UUID.randomUUID().toString().toUpperCase();
-    return new TrackingId(
-      random.substring(0, random.indexOf("-"))
-    );
-  }
-
-  @Override
   public List<Cargo> findAll() {
     return new ArrayList<Cargo>(cargoDb.values());
   }
@@ -87,7 +78,6 @@ public class CargoRepositoryInMem implements CargoRepository {
 
     final RouteSpecification routeSpecification = new RouteSpecification(origin, destination, new Date());
     final Cargo cargo = new Cargo(trackingId, routeSpecification);
-    cargo.deriveDeliveryProgress(HandlingHistory.emptyForCargo(cargo));
 
     return cargo;
   }

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/inmemory/HandlingEventRepositoryInMem.java

@@ -5,6 +5,7 @@ import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
+import se.citerus.dddsample.domain.model.shared.EventSequenceNumber;
 
 import java.util.*;
 
@@ -20,6 +21,19 @@ public class HandlingEventRepositoryInMem implements HandlingEventRepository {
   };
 
   @Override
+  public HandlingEvent find(EventSequenceNumber eventSequenceNumber) {
+    for (List<HandlingEvent> handlingEvents : eventMap.values()) {
+      for (HandlingEvent handlingEvent : handlingEvents) {
+        if (handlingEvent.sequenceNumber().sameValueAs(eventSequenceNumber)) {
+          return handlingEvent;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  @Override
   public void store(HandlingEvent event) {
     final TrackingId trackingId = event.cargo().trackingId();
     List<HandlingEvent> list = eventMap.get(trackingId);

dddsample/src/test/java/se/citerus/dddsample/interfaces/tracking/CargoTrackingViewAdapterTest.java

@@ -6,9 +6,9 @@ import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.RouteSpecification;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HANGZOU;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HELSINKI;
+import se.citerus.dddsample.domain.model.shared.HandlingActivity;
 import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
 
 import java.util.*;
@@ -27,18 +27,15 @@ public class CargoTrackingViewAdapterTest extends TestCase {
 //  events as "expected", whereas an empty itinerary should actually consider
 //  any event unexpected. (ie empty itinerary means nothing happens.)
 
-    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
-    events.add(new HandlingEvent(cargo, new Date(1), new Date(2), HandlingEvent.Type.RECEIVE, HANGZOU));
-
-    events.add(new HandlingEvent(cargo, new Date(3), new Date(4), HandlingEvent.Type.LOAD, HANGZOU, CM001));
-    events.add(new HandlingEvent(cargo, new Date(5), new Date(6), HandlingEvent.Type.UNLOAD, HELSINKI, CM001));
-
-    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
+    cargo.handled(new HandlingActivity(HandlingEvent.Type.RECEIVE, HANGZOU));
+    cargo.handled(new HandlingActivity(HandlingEvent.Type.LOAD, HANGZOU, CM001));
+    cargo.handled(new HandlingActivity(HandlingEvent.Type.UNLOAD, HELSINKI, CM001));
 
     StaticApplicationContext applicationContext = new StaticApplicationContext();
     applicationContext.addMessage("cargo.status.IN_PORT", Locale.GERMAN, "In port {0}");
     applicationContext.refresh();
 
+    List<HandlingEvent> events = new ArrayList<HandlingEvent>();
     CargoTrackingViewAdapter adapter = new CargoTrackingViewAdapter(cargo, applicationContext, Locale.GERMAN, events);
 
     assertEquals("XYZ", adapter.getTrackingId());

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

@@ -23,6 +23,7 @@ import static se.citerus.dddsample.domain.model.voyage.Voyage.NONE;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 import se.citerus.dddsample.domain.service.RoutingService;
+import se.citerus.dddsample.infrastructure.persistence.TrackingIdGeneratorInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.CargoRepositoryInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.HandlingEventRepositoryInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
@@ -44,11 +45,11 @@ public class CargoLifecycleScenarioTest {
   VoyageRepository voyageRepository = new VoyageRepositoryInMem();
 
   HandlingEventFactory handlingEventFactory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
-  CargoFactory cargoFactory = new CargoFactory(cargoRepository, locationRepository);
+  CargoFactory cargoFactory = new CargoFactory(locationRepository, new TrackingIdGeneratorInMem());
 
   /**
    * This is a domain service interface, whose implementation
-   * is part of the infrastructure layer (remote call to external system).
+   * is part of the infrastructure layer (re mote call to external system).
    * <p/>
    * It is stubbed in this test.
    */
@@ -98,11 +99,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterUnloadInLongBeach() {
     Cargo cargo = cargoRepository.find(trackingId);
 
-    assertThat(cargo.delivery().currentVoyage(), is(NONE));
-    assertThat(cargo.delivery().lastKnownLocation(), is(LONGBEACH));
-    assertThat(cargo.delivery().transportStatus(), is(IN_PORT));
-    assertFalse(cargo.delivery().isMisdirected());
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(LOAD, LONGBEACH, v250)));
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(LOAD, LONGBEACH, v250)));
   }
 
   private void loadInLongBeach() throws CannotCreateHandlingEventException {
@@ -112,11 +113,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterLoadInLongBeach() {
     Cargo cargo = cargoRepository.find(trackingId);
 
-    assertThat(cargo.delivery().currentVoyage(), is(v250));
-    assertThat(cargo.delivery().lastKnownLocation(), is(LONGBEACH));
-    assertThat(cargo.delivery().transportStatus(), is(ONBOARD_CARRIER));
-    assertFalse(cargo.delivery().isMisdirected());
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(UNLOAD, NEWYORK, v250)));
+    assertThat(cargo.currentVoyage(), is(v250));
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, NEWYORK, v250)));
   }
 
   private void unloadInNewYork() throws CannotCreateHandlingEventException {
@@ -126,11 +127,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterUnloadInNewYork() {
     Cargo cargo = cargoRepository.find(trackingId);
 
-    assertThat(cargo.delivery().currentVoyage(), is(NONE));
-    assertThat(cargo.delivery().lastKnownLocation(), is(NEWYORK));
-    assertThat(cargo.delivery().transportStatus(), is(IN_PORT));
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(LOAD, NEWYORK, v200)));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(NEWYORK));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(LOAD, NEWYORK, v200)));
+    assertFalse(cargo.isMisdirected());
   }
 
   private void loadInNewYork() throws CannotCreateHandlingEventException {
@@ -140,11 +141,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterLoadInNewYork() {
     Cargo cargo = cargoRepository.find(trackingId);
 
-    assertThat(cargo.delivery().currentVoyage(), is(v200));
-    assertThat(cargo.delivery().lastKnownLocation(), is(NEWYORK));
-    assertThat(cargo.delivery().transportStatus(), is(ONBOARD_CARRIER));
-    assertFalse(cargo.delivery().isMisdirected());
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(UNLOAD, STOCKHOLM, v200)));
+    assertThat(cargo.currentVoyage(), is(v200));
+    assertThat(cargo.lastKnownLocation(), is(NEWYORK));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, STOCKHOLM, v200)));
   }
 
   @Test
@@ -211,20 +212,20 @@ public class CargoLifecycleScenarioTest {
   public void checkDeliveryAfterBooking() throws Exception {
     Cargo cargo = cargoRepository.find(trackingId);
 
-    assertThat(cargo.delivery().transportStatus(), is(NOT_RECEIVED));
-    assertThat(cargo.delivery().routingStatus(), is(NOT_ROUTED));
-    assertFalse(cargo.delivery().isMisdirected());
-    assertNull(cargo.projections().estimatedTimeOfArrival());
-    assertNull(cargo.projections().nextExpectedActivity());
+    assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
+    assertThat(cargo.routingStatus(), is(NOT_ROUTED));
+    assertFalse(cargo.isMisdirected());
+    assertNull(cargo.estimatedTimeOfArrival());
+    assertNull(cargo.nextExpectedActivity());
   }
 
   public void checkDeliveryAfterRouting() throws Exception {
     Cargo cargo = cargoRepository.find(trackingId);
 
-    assertThat(cargo.delivery().transportStatus(), is(NOT_RECEIVED));
-    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(RECEIVE, HONGKONG)));
-    assertNotNull(cargo.projections().estimatedTimeOfArrival());
+    assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
+    assertThat(cargo.routingStatus(), is(ROUTED));
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(RECEIVE, HONGKONG)));
+    assertNotNull(cargo.estimatedTimeOfArrival());
   }
 
   public void receiveInHongkong() throws CannotCreateHandlingEventException {
@@ -233,8 +234,8 @@ public class CargoLifecycleScenarioTest {
 
   private void checkDeliveryAfterReceiveInHongkong() {
     Cargo cargo = cargoRepository.find(trackingId);
-    assertThat(cargo.delivery().transportStatus(), is(IN_PORT));
-    assertThat(cargo.delivery().lastKnownLocation(), is(HONGKONG));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.lastKnownLocation(), is(HONGKONG));
   }
 
   public void loadInHongkong() throws CannotCreateHandlingEventException {
@@ -245,11 +246,11 @@ public class CargoLifecycleScenarioTest {
     // Check current state - should be ok
     Cargo cargo = cargoRepository.find(trackingId);
 
-    assertThat(cargo.delivery().currentVoyage(), is(v100));
-    assertThat(cargo.delivery().lastKnownLocation(), is(HONGKONG));
-    assertThat(cargo.delivery().transportStatus(), is(ONBOARD_CARRIER));
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(UNLOAD, LONGBEACH, v100)));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.currentVoyage(), is(v100));
+    assertThat(cargo.lastKnownLocation(), is(HONGKONG));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, LONGBEACH, v100)));
+    assertFalse(cargo.isMisdirected());
   }
 
   public void unloadInTokyo() throws CannotCreateHandlingEventException {
@@ -260,11 +261,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterUnloadInTokyo() {
     Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - cargo is misdirected!
-    assertThat(cargo.delivery().currentVoyage(), is(NONE));
-    assertThat(cargo.delivery().lastKnownLocation(), is(TOKYO));
-    assertThat(cargo.delivery().transportStatus(), is(IN_PORT));
-    assertTrue(cargo.delivery().isMisdirected());
-    assertNull(cargo.projections().nextExpectedActivity());
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(TOKYO));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertTrue(cargo.isMisdirected());
+    assertNull(cargo.nextExpectedActivity());
   }
 
   public void specifyNewRouteFromTokyoToStockholm() {
@@ -281,8 +282,8 @@ public class CargoLifecycleScenarioTest {
     Cargo cargo = cargoRepository.find(trackingId);
 
     // The old itinerary does not satisfy the new specification
-    assertThat(cargo.delivery().routingStatus(), is(MISROUTED));
-    assertNull(cargo.projections().nextExpectedActivity());
+    assertThat(cargo.routingStatus(), is(MISROUTED));
+    assertNull(cargo.nextExpectedActivity());
   }
 
   public void assignToNewRouteFromTokyoToStockholm() {
@@ -300,9 +301,9 @@ public class CargoLifecycleScenarioTest {
     Cargo cargo = cargoRepository.find(trackingId);
 
     // New itinerary should satisfy new route
-    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
-    assertFalse(cargo.delivery().isMisdirected());
-    assertEquals(new HandlingActivity(LOAD, TOKYO, v300), cargo.projections().nextExpectedActivity());
+    assertThat(cargo.routingStatus(), is(ROUTED));
+    assertFalse(cargo.isMisdirected());
+    assertEquals(new HandlingActivity(LOAD, TOKYO, v300), cargo.nextExpectedActivity());
   }
 
   public void loadInTokyo() throws CannotCreateHandlingEventException {
@@ -312,11 +313,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterLoadInTokyo() {
     Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
-    assertThat(cargo.delivery().currentVoyage(), is(v300));
-    assertThat(cargo.delivery().lastKnownLocation(), is(TOKYO));
-    assertThat(cargo.delivery().transportStatus(), is(ONBOARD_CARRIER));
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(UNLOAD, HAMBURG, v300)));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.currentVoyage(), is(v300));
+    assertThat(cargo.lastKnownLocation(), is(TOKYO));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, HAMBURG, v300)));
+    assertFalse(cargo.isMisdirected());
   }
 
   public void unloadInHamburg() throws CannotCreateHandlingEventException {
@@ -327,11 +328,11 @@ public class CargoLifecycleScenarioTest {
     Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
 
-    assertThat(cargo.delivery().currentVoyage(), is(NONE));
-    assertThat(cargo.delivery().lastKnownLocation(), is(HAMBURG));
-    assertThat(cargo.delivery().transportStatus(), is(IN_PORT));
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(LOAD, HAMBURG, v400)));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(HAMBURG));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(LOAD, HAMBURG, v400)));
+    assertFalse(cargo.isMisdirected());
   }
 
   public void loadInHamburg() throws CannotCreateHandlingEventException {
@@ -342,11 +343,11 @@ public class CargoLifecycleScenarioTest {
     Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
 
-    assertThat(cargo.delivery().currentVoyage(), is(v400));
-    assertThat(cargo.delivery().lastKnownLocation(), is(HAMBURG));
-    assertThat(cargo.delivery().transportStatus(), is(ONBOARD_CARRIER));
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(UNLOAD, STOCKHOLM, v400)));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.currentVoyage(), is(v400));
+    assertThat(cargo.lastKnownLocation(), is(HAMBURG));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, STOCKHOLM, v400)));
+    assertFalse(cargo.isMisdirected());
   }
 
   public void unloadInStockholmOffOf(Voyage voyage) throws CannotCreateHandlingEventException {
@@ -356,11 +357,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterUnloadInStockholm() {
     Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
-    assertThat(cargo.delivery().currentVoyage(), is(NONE));
-    assertThat(cargo.delivery().lastKnownLocation(), is(STOCKHOLM));
-    assertThat(cargo.delivery().transportStatus(), is(IN_PORT));
-    assertThat(cargo.projections().nextExpectedActivity(), is(new HandlingActivity(CLAIM, STOCKHOLM)));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(CLAIM, STOCKHOLM)));
+    assertFalse(cargo.isMisdirected());
   }
 
   private void claimInStockholm() throws CannotCreateHandlingEventException {
@@ -370,11 +371,11 @@ public class CargoLifecycleScenarioTest {
   private void checkDeliveryAfterClaimInStockholm() {
     Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
-    assertThat(cargo.delivery().currentVoyage(), is(NONE));
-    assertThat(cargo.delivery().lastKnownLocation(), is(STOCKHOLM));
-    assertThat(cargo.delivery().transportStatus(), is(CLAIMED));
-    assertFalse(cargo.delivery().isMisdirected());
-    assertNull(cargo.projections().nextExpectedActivity());
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
+    assertThat(cargo.transportStatus(), is(CLAIMED));
+    assertFalse(cargo.isMisdirected());
+    assertNull(cargo.nextExpectedActivity());
   }
 
   private void createHandlingEventAndUpdateAggregates(Date completionTime, Voyage voyage, Location location, HandlingEvent.Type type) throws CannotCreateHandlingEventException {
@@ -391,7 +392,7 @@ public class CargoLifecycleScenarioTest {
   private void updateCargoAggregate() {
     Cargo cargo = cargoRepository.find(trackingId);
     HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(cargo);
-    cargo.handled(handlingEvent.handlingActivity());
+    cargo.handled(handlingEvent.activity());
     cargoRepository.store(cargo);
   }
 

dddsample/src/test/java/se/citerus/dddsample/scenario/VoyageRescheduledScenarioTest.java

@@ -21,7 +21,7 @@ import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
-import se.citerus.dddsample.infrastructure.persistence.inmemory.CargoRepositoryInMem;
+import se.citerus.dddsample.infrastructure.persistence.TrackingIdGeneratorInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
 
 import java.util.Date;
@@ -39,7 +39,7 @@ public class VoyageRescheduledScenarioTest {
     voyage1 = new Voyage(new VoyageNumber("V1"), HONGKONG_TO_NEW_YORK.schedule());
     voyage2 = new Voyage(new VoyageNumber("V2"), NEW_YORK_TO_DALLAS.schedule());
     voyage3 = new Voyage(new VoyageNumber("V3"), DALLAS_TO_HELSINKI.schedule());
-    CargoFactory cargoFactory = new CargoFactory(new CargoRepositoryInMem(), new LocationRepositoryInMem());
+    CargoFactory cargoFactory = new CargoFactory(new LocationRepositoryInMem(), new TrackingIdGeneratorInMem());
     cargo = cargoFactory.newCargo(HANGZOU.unLocode(), STOCKHOLM.unLocode(), toDate("2008-12-23"));
     Itinerary itinerary = new Itinerary(
       Leg.deriveLeg(voyage1, HANGZOU, NEWYORK),
@@ -51,7 +51,7 @@ public class VoyageRescheduledScenarioTest {
 
   @Test
   public void voyageIsRescheduledWithMaintainableRoute() {
-    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
+    assertThat(cargo.routingStatus(), is(ROUTED));
 
     Date oldDepartureTime = toDate("2008-10-24", "07:00");
 
@@ -73,12 +73,12 @@ public class VoyageRescheduledScenarioTest {
 
     // Now the cargo aggregate is updated to reflect the scheduling change!
     assertThat(cargo.itinerary().loadTimeAt(NEWYORK), is(newDepartureTime));
-    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
+    assertThat(cargo.routingStatus(), is(ROUTED));
   }
 
   @Test
   public void voyageIsRescheduledWithUnmaintainableRoute() {
-    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
+    assertThat(cargo.routingStatus(), is(ROUTED));
 
     // Voyage1 arrives in NYC at 2008-10-23 23:10
     // Now rescheduling the departure of voyage2 to BEFORE
@@ -86,6 +86,8 @@ public class VoyageRescheduledScenarioTest {
     // keep the latter part of the old itinerary, and the new itinerary
     // is therefore truncated after unload in NYC.
 
+    // TODO delay the arrival instead of advancing the departure
+
     Date newDepartureTime = toDate("2008-10-23", "18:30");
     voyage2.departureRescheduled(NEWYORK, newDepartureTime);
 
@@ -93,9 +95,13 @@ public class VoyageRescheduledScenarioTest {
     Itinerary truncatedItinerary = cargo.itinerary().withRescheduledVoyage(voyage2);
     assertThat(truncatedItinerary.lastLeg().unloadLocation(), is(NEWYORK));
 
+    //Or... The Itinerary is created with an 'Illegal Connection' based on a coomparison of
+    //each transfer with a Location.minimumAllowedConnectionTime(). Since Loation is an entity
+    //we don't allow Itinerary to dynamically use the property directly because it is not immutable.
+    
     // The cargo enters MISROUTED state
     cargo.assignToRoute(truncatedItinerary);
-    assertThat(cargo.delivery().routingStatus(), is(MISROUTED));
+    assertThat(cargo.routingStatus(), is(MISROUTED));
   }
 
 }