Renamed DeliveryHistory to HandlingHistory.

Made next expected activity persistent and derived on handling.

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

@@ -22,6 +22,10 @@ public interface HandlingEventService {
    * @param unLocode UN locode for the location where the event occurred
    * @param type type of event
    */
-  void registerHandlingEvent(Date completionTime, TrackingId trackingId, VoyageNumber voyageNumber, UnLocode unLocode, HandlingEvent.Type type);
+  void registerHandlingEvent(Date completionTime,
+                             TrackingId trackingId,
+                             VoyageNumber voyageNumber,
+                             UnLocode unLocode,
+                             HandlingEvent.Type type);
 
 }

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

@@ -9,10 +9,8 @@ import se.citerus.dddsample.application.CargoInspectionService;
 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;
-
-import java.util.List;
+import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 
 public class CargoInspectionServiceImpl implements CargoInspectionService {
 
@@ -40,9 +38,9 @@ public class CargoInspectionServiceImpl implements CargoInspectionService {
       return;
     }
 
-    final List<HandlingEvent> handlingEvents = handlingEventRepository.findEventsForCargo(trackingId);
+    final HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId);
 
-    cargo.deriveDeliveryProgress(handlingEvents);
+    cargo.deriveDeliveryProgress(handlingHistory);
 
     if (cargo.isMisdirected()) {
       applicationEvents.cargoWasMisdirected(cargo);

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

@@ -12,10 +12,7 @@ import org.springframework.web.context.WebApplicationContext;
 import org.springframework.web.context.support.WebApplicationContextUtils;
 import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import se.citerus.dddsample.domain.model.cargo.*;
-import se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException;
-import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import se.citerus.dddsample.domain.model.handling.HandlingEventFactory;
-import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
+import se.citerus.dddsample.domain.model.handling.*;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
 import se.citerus.dddsample.domain.model.location.SampleLocations;
@@ -31,7 +28,6 @@ import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import static java.util.Arrays.asList;
 import java.util.Date;
-import java.util.List;
 
 /**
  * Provides sample data.
@@ -254,8 +250,8 @@ public class SampleDataGenerator implements ServletContextListener {
           throw new RuntimeException(e);
         }
 
-        List<HandlingEvent> handlingEvents = handlingEventRepository.findEventsForCargo(trackingId);
-        abc123.deriveDeliveryProgress(handlingEvents);
+        HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId);
+        abc123.deriveDeliveryProgress(handlingHistory);
 
         session.update(abc123);
 
@@ -299,8 +295,8 @@ public class SampleDataGenerator implements ServletContextListener {
           throw new RuntimeException(e);
         }
 
-        List<HandlingEvent> handlingEvents1 = handlingEventRepository.findEventsForCargo(trackingId1);
-        jkl567.deriveDeliveryProgress(handlingEvents1);
+        HandlingHistory handlingHistory1 = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId);
+        jkl567.deriveDeliveryProgress(handlingHistory1);
 
         session.update(jkl567);
       }

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

@@ -5,13 +5,12 @@ import se.citerus.dddsample.domain.model.Entity;
 import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
+import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 
-import java.util.Collections;
 import java.util.Date;
 import java.util.Iterator;
-import java.util.List;
 
 /**
  * A Cargo. This is the central class in the domain model,
@@ -49,6 +48,7 @@ public class Cargo implements Entity<Cargo> {
   private Delivery delivery;
   private RouteSpecification routeSpecification;
   private RoutingStatus routingStatus;
+  private HandlingActivity nextExpectedActivity;
   private boolean misdirected;
   private Date eta;
   
@@ -65,7 +65,7 @@ public class Cargo implements Entity<Cargo> {
     this.origin = routeSpecification.origin();
     this.routeSpecification = routeSpecification;
 
-    deriveDeliveryProgress(Collections.<HandlingEvent>emptyList());
+    deriveDeliveryProgress(HandlingHistory.EMPTY);
   }
 
   /**
@@ -130,6 +130,7 @@ public class Cargo implements Entity<Cargo> {
     // Handling consistency within the Cargo aggregate synchronously
     this.routingStatus = deriveRoutingStatus();
     this.misdirected = deriveMisdirectionStatus();
+    this.nextExpectedActivity = deriveNextExpectedActivity();
     this.eta = deriveEta();
   }
 
@@ -180,46 +181,7 @@ public class Cargo implements Entity<Cargo> {
    * @return the next expected activity
    */
   public HandlingActivity nextExpectedActivity() {
-    if (!onTrack()) return NO_ACTIVITY;
-
-    final HandlingEvent lastEvent = delivery().lastEvent();
-
-    if (lastEvent == null) return new HandlingActivity(RECEIVE, origin());
-
-    switch (lastEvent.type()) {
-
-      case LOAD:
-        for (Leg leg : itinerary().legs()) {
-          if (leg.loadLocation().sameIdentityAs(lastEvent.location())) {
-            return new HandlingActivity(UNLOAD, leg.unloadLocation(), leg.voyage());
-          }
-        }
-
-        return NO_ACTIVITY;
-
-      case UNLOAD:
-        for (Iterator<Leg> it = itinerary().legs().iterator(); it.hasNext();) {
-          final Leg leg = it.next();
-          if (leg.unloadLocation().sameIdentityAs(lastEvent.location())) {
-            if (it.hasNext()) {
-              final Leg nextLeg = it.next();
-              return new HandlingActivity(LOAD, nextLeg.loadLocation(), nextLeg.voyage());
-            } else {
-              return new HandlingActivity(CLAIM, leg.unloadLocation());
-            }
-          }
-        }
-
-        return NO_ACTIVITY;
-
-      case RECEIVE:
-        final Leg firstLeg = itinerary().legs().iterator().next();
-        return new HandlingActivity(LOAD, firstLeg.loadLocation(), firstLeg.voyage());
-
-      case CLAIM:
-      default:
-        return NO_ACTIVITY;
-    }
+    return nextExpectedActivity;
   }
 
   /**
@@ -235,15 +197,16 @@ public class Cargo implements Entity<Cargo> {
    * 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.
    *
-   * @param handlingEvents all handling events for this cargo
+   * @param handlingHistory delivery history
    */
-  public void deriveDeliveryProgress(final List<HandlingEvent> handlingEvents) {
+  public void deriveDeliveryProgress(final HandlingHistory handlingHistory) {
     // Delivery is a value object, so we can simply discard the old one
     // and replace it with a new
-    this.delivery = Delivery.derivedFrom(handlingEvents);
+    this.delivery = Delivery.derivedFrom(handlingHistory);
     this.routingStatus = deriveRoutingStatus();
     this.misdirected = deriveMisdirectionStatus();
     this.eta = deriveEta();
+    this.nextExpectedActivity = deriveNextExpectedActivity();
   }
 
   /**
@@ -285,11 +248,54 @@ public class Cargo implements Entity<Cargo> {
     }
   }
 
+  private HandlingActivity deriveNextExpectedActivity() {
+    if (!onTrack()) return NO_ACTIVITY;
+
+    final HandlingEvent lastEvent = delivery().lastEvent();
+
+    if (lastEvent == null) return new HandlingActivity(RECEIVE, origin());
+
+    switch (lastEvent.type()) {
+
+      case LOAD:
+        for (Leg leg : itinerary().legs()) {
+          if (leg.loadLocation().sameIdentityAs(lastEvent.location())) {
+            return new HandlingActivity(UNLOAD, leg.unloadLocation(), leg.voyage());
+          }
+        }
+
+        return NO_ACTIVITY;
+
+      case UNLOAD:
+        for (Iterator<Leg> it = itinerary().legs().iterator(); it.hasNext();) {
+          final Leg leg = it.next();
+          if (leg.unloadLocation().sameIdentityAs(lastEvent.location())) {
+            if (it.hasNext()) {
+              final Leg nextLeg = it.next();
+              return new HandlingActivity(LOAD, nextLeg.loadLocation(), nextLeg.voyage());
+            } else {
+              return new HandlingActivity(CLAIM, leg.unloadLocation());
+            }
+          }
+        }
+
+        return NO_ACTIVITY;
+
+      case RECEIVE:
+        final Leg firstLeg = itinerary().legs().iterator().next();
+        return new HandlingActivity(LOAD, firstLeg.loadLocation(), firstLeg.voyage());
+
+      case CLAIM:
+      default:
+        return NO_ACTIVITY;
+    }
+  }
+
   /**
    * @return true if cargo is on track, i.e. routed and not misdirected
    */
   private boolean onTrack() {
-    return routingStatus().equals(ROUTED) && !misdirected;
+    return routingStatus.equals(ROUTED) && !misdirected;
   }
   
   @Override

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

@@ -6,31 +6,29 @@ import org.apache.commons.lang.builder.HashCodeBuilder;
 import se.citerus.dddsample.domain.model.ValueObject;
 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 se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import static java.util.Collections.EMPTY_SET;
-import static java.util.Collections.sort;
-import java.util.HashSet;
-import java.util.List;
-
 /**
- * The actual result of the cargo transportation, as opposed to
+ * The actual transportation of the cargo, as opposed to
  * the customer requirement (RouteSpecification) and the plan (Itinerary). 
  *
  */
 public class Delivery implements ValueObject<Delivery> {
 
-  public static final Delivery EMPTY_DELIVERY = Delivery.derivedFrom(EMPTY_SET);
+  public static final Delivery EMPTY_DELIVERY = Delivery.derivedFrom(HandlingHistory.EMPTY);
 
   private TransportStatus transportStatus;
   private Location lastKnownLocation;
   private Voyage currentVoyage;
   private HandlingEvent lastEvent;
 
+  private Delivery(HandlingEvent lastEvent) {
+    this.lastEvent = lastEvent;
+  }
+
   /**
    * @return Transport status
    */
@@ -53,19 +51,15 @@ public class Delivery implements ValueObject<Delivery> {
   }
 
   /**
-   * @param handlingEvents handling events
+   * @param handlingHistory delivery history
    * @return An up to date Delivery derived from this collection of handling events.
    */
-  static Delivery derivedFrom(final Collection<HandlingEvent> handlingEvents) {
-    Validate.notNull(handlingEvents, "Handling events are required");
+  static Delivery derivedFrom(HandlingHistory handlingHistory) {
+    Validate.notNull(handlingHistory, "Delivery history is required");
     
-    final List<HandlingEvent> eventsByCompletionTime =
-      new ArrayList<HandlingEvent>(
-        new HashSet<HandlingEvent>(handlingEvents));
-    sort(eventsByCompletionTime, HandlingEvent.BY_COMPLETION_TIME_COMPARATOR);
-
-    final Delivery delivery = new Delivery();
-    delivery.calculateLastEvent(eventsByCompletionTime);
+    final Delivery delivery = new Delivery(
+      handlingHistory.mostRecentlyCompletedEvent()
+    );
     delivery.calculateTransportStatus();
     delivery.calculateLastKnownLocation();
     delivery.calculateCurrentVoyage();
@@ -79,14 +73,6 @@ public class Delivery implements ValueObject<Delivery> {
     return lastEvent;
   }
 
-  private void calculateLastEvent(final List<HandlingEvent> handlingEvents) {
-    if (handlingEvents.isEmpty()) {
-      lastEvent =  null;
-    } else {
-      lastEvent = handlingEvents.get(handlingEvents.size() - 1);
-    }
-  }
-
   private void calculateTransportStatus() {
     if (lastEvent == null) {
       transportStatus = NOT_RECEIVED;

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

@@ -81,4 +81,8 @@ public class HandlingActivity implements ValueObject<HandlingActivity> {
     return sameValueAs(other);
   }
 
+  HandlingActivity() {
+    // Needed by Hibernate
+  }
+  
 }

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

@@ -12,7 +12,6 @@ import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 
-import java.util.Comparator;
 import java.util.Date;
 
 /**
@@ -33,16 +32,6 @@ import java.util.Date;
  */
 public final class HandlingEvent implements DomainEvent<HandlingEvent> {
 
-  /**
-   * Comparator used to be able to sort HandlingEvents according to their completion time
-   */
-  public static final Comparator<HandlingEvent> BY_COMPLETION_TIME_COMPARATOR =
-    new Comparator<HandlingEvent>() {
-      public int compare(final HandlingEvent he1, final HandlingEvent he2) {
-        return he1.completionTime().compareTo(he2.completionTime());
-      }
-    };
-
   private Type type;
   private Voyage voyage;
   private Location location;

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

@@ -2,8 +2,6 @@ package se.citerus.dddsample.domain.model.handling;
 
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 
-import java.util.List;
-
 /**
  * Handling event repository.
  */
@@ -19,8 +17,8 @@ public interface HandlingEventRepository {
 
   /**
    * @param trackingId cargo tracking id
-   * @return All handling events for this cargo
+   * @return The handling history of this cargo
    */
-  List<HandlingEvent> findEventsForCargo(TrackingId trackingId);
+  HandlingHistory lookupHandlingHistoryOfCargo(TrackingId trackingId);
 
 }

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

@@ -0,0 +1,74 @@
+package se.citerus.dddsample.domain.model.handling;
+
+import org.apache.commons.lang.Validate;
+import se.citerus.dddsample.domain.model.ValueObject;
+
+import java.util.*;
+import static java.util.Collections.sort;
+
+/**
+ * The handling history of a cargo.
+ *
+ */
+public class HandlingHistory implements ValueObject<HandlingHistory> {
+
+  private final List<HandlingEvent> handlingEvents;
+
+  public static final HandlingHistory EMPTY = new HandlingHistory(Collections.<HandlingEvent>emptyList());
+
+  public HandlingHistory(Collection<HandlingEvent> handlingEvents) {
+    Validate.notNull(handlingEvents, "Handling events are required");
+
+    this.handlingEvents = new ArrayList<HandlingEvent>(handlingEvents);
+  }
+
+  /**
+   * @return A distinct list (no duplicate registrations) of handling events, ordered by completion time.
+   */
+  public List<HandlingEvent> distinctEventsByCompletionTime() {
+    final List<HandlingEvent> ordered = new ArrayList<HandlingEvent>(
+      new HashSet<HandlingEvent>(handlingEvents)
+    );
+    sort(ordered, BY_COMPLETION_TIME_COMPARATOR);
+    return Collections.unmodifiableList(ordered);
+  }
+
+  /**
+   * @return Most recently completed event, or null if the delivery history is empty.
+   */
+  public HandlingEvent mostRecentlyCompletedEvent() {
+    final List<HandlingEvent> distinctEvents = distinctEventsByCompletionTime();
+    if (distinctEvents.isEmpty()) {
+      return null;
+    } else {
+      return distinctEvents.get(distinctEvents.size() - 1);
+    }
+  }
+
+  @Override
+  public boolean sameValueAs(HandlingHistory other) {
+    return other != null && this.handlingEvents.equals(other.handlingEvents);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    final HandlingHistory other = (HandlingHistory) o;
+    return sameValueAs(other);
+  }
+
+  @Override
+  public int hashCode() {
+    return handlingEvents.hashCode();
+  }
+
+  private static final Comparator<HandlingEvent> BY_COMPLETION_TIME_COMPARATOR =
+    new Comparator<HandlingEvent>() {
+      public int compare(final HandlingEvent he1, final HandlingEvent he2) {
+        return he1.completionTime().compareTo(he2.completionTime());
+      }
+    };
+
+}

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

@@ -23,10 +23,12 @@ public class CargoRepositoryHibernate extends HibernateRepository implements Car
 
   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("-"))

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

@@ -4,8 +4,7 @@ import org.springframework.stereotype.Repository;
 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 java.util.List;
+import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 
 /**
  * Hibernate implementation of HandlingEventRepository.
@@ -15,16 +14,17 @@ import java.util.List;
 public class HandlingEventRepositoryHibernate extends HibernateRepository implements HandlingEventRepository {
 
   @Override
-  public void store(HandlingEvent event) {
+  public void store(final HandlingEvent event) {
     getSession().save(event);
   }
 
   @Override
-  public List<HandlingEvent> findEventsForCargo(TrackingId tid) {
-    return getSession().createQuery(
+  public HandlingHistory lookupHandlingHistoryOfCargo(final TrackingId trackingId) {
+    return new HandlingHistory(getSession().createQuery(
             "from HandlingEvent where cargo.trackingId = :tid").
-            setParameter("tid", tid).
-            list();
+            setParameter("tid", trackingId).
+            list()
+    );
   }
 
 }

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

@@ -56,7 +56,7 @@ public final class CargoTrackingController extends SimpleFormController {
     if (cargo != null) {
       final MessageSource messageSource = getApplicationContext();
       final Locale locale = RequestContextUtils.getLocale(request);
-      final List<HandlingEvent> handlingEvents = handlingEventRepository.findEventsForCargo(trackingId);
+      final List<HandlingEvent> handlingEvents = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
       model.put("cargo", new CargoTrackingViewAdapter(cargo, messageSource, locale, handlingEvents));
     } else {
       errors.rejectValue("trackingId", "cargo.unknown_id", new Object[]{trackCommand.getTrackingId()}, "Unknown tracking id");

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

@@ -23,6 +23,17 @@
       </type>
     </property>
 
+    <component name="nextExpectedActivity" update="true">
+      <many-to-one name="location" column="next_expected_location_id" foreign-key="next_expected_location_fk"/>
+      <property name="type" column="next_expected_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="next_expected_voyage_id" foreign-key="next_expected_voyage_fk"/>
+    </component>
+
     <component name="trackingId" unique="true" update="false">
       <property name="id" column="tracking_id"/>
     </component>

dddsample/src/main/webapp/WEB-INF/jsp/pub/track.jsp

@@ -41,33 +41,7 @@
       <p class="notify"><img src="${rc.contextPath}/images/error.png" alt="" />Cargo is misdirected</p>
     </c:if>
     <c:if test="${not empty cargo.events}">
-      <h3>Delivery History</h3>
-      <%--
-      <table cellspacing="4">
-        <thead>
-          <tr>
-            <td>Event</td>
-            <td>Location</td>
-            <td>Time</td>
-            <td>Voyage number</td>
-            <td></td>
-          </tr>
-        </thead>
-        <tbody>
-          <c:forEach items="${cargo.events}" var="event">
-            <tr class="event-type-${event.type}">
-              <td>${event.type}</td>
-              <td>${event.location}</td>
-              <td>${event.time}</td>
-              <td>${event.voyageNumber}</td>
-              <td>
-                <img src="${rc.contextPath}/images/${event.expected ? "tick" : "cross"}.png" alt=""/>
-              </td>
-            </tr>
-          </c:forEach>
-        </tbody>
-      </table>
-      --%>
+      <h3>Handling History</h3>
         <ul style="list-style-type: none;">
             <c:forEach items="${cargo.events}" var="leg">
             <li>
@@ -76,8 +50,6 @@
             </li>
             </c:forEach>
         </ul>
-
-
     </c:if>
   </div>
   </c:if>

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

@@ -5,6 +5,7 @@ import se.citerus.dddsample.application.util.DateTestUtil;
 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 se.citerus.dddsample.domain.model.location.Location;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
@@ -118,7 +119,7 @@ public class CargoTest extends TestCase {
     // Adding an event unrelated to unloading at final destination
     events.add(
       new HandlingEvent(cargo, new Date(10), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU));
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     assertFalse(cargo.isUnloadedAtDestination());
 
     Voyage voyage = new Voyage.Builder(new VoyageNumber("0123"), HANGZOU).
@@ -128,19 +129,19 @@ public class CargoTest extends TestCase {
     // 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(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     assertFalse(cargo.isUnloadedAtDestination());
 
     // 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(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     assertFalse(cargo.isUnloadedAtDestination());
 
     // Finally, cargo is unloaded at final destination
     events.add(
       new HandlingEvent(cargo, new Date(40), new Date(), HandlingEvent.Type.UNLOAD, NEWYORK, voyage));
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     assertTrue(cargo.isUnloadedAtDestination());
   }
 
@@ -150,7 +151,7 @@ public class CargoTest extends TestCase {
 
     HandlingEvent he = new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.RECEIVE, STOCKHOLM);
     events.add(he);
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
     return cargo;
   }
@@ -159,7 +160,7 @@ public class CargoTest extends TestCase {
     final Cargo cargo = populateCargoOffMelbourne();
 
     events.add(new HandlingEvent(cargo, getDate("2007-12-09"), new Date(), HandlingEvent.Type.CLAIM, MELBOURNE));
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
     return cargo;
   }
@@ -174,7 +175,7 @@ public class CargoTest extends TestCase {
     events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
     events.add(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, voyage));
 
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     return cargo;
   }
 
@@ -185,7 +186,7 @@ public class CargoTest extends TestCase {
     events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
     events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
 
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     return cargo;
   }
 
@@ -201,7 +202,7 @@ public class CargoTest extends TestCase {
     events.add(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, voyage));
     events.add(new HandlingEvent(cargo, getDate("2007-12-07"), new Date(), HandlingEvent.Type.UNLOAD, MELBOURNE, voyage));
 
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     return cargo;
   }
 
@@ -216,7 +217,7 @@ public class CargoTest extends TestCase {
 
     events.add(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, voyage));
 
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     return cargo;
   }
 
@@ -242,7 +243,7 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(130), new Date(140), HandlingEvent.Type.CUSTOMS, GOTHENBURG));
 
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
     assertFalse(cargo.isMisdirected());
 
     //Try a couple of failing ones
@@ -252,7 +253,7 @@ public class CargoTest extends TestCase {
 
     handlingEvents.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU));
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
     assertTrue(cargo.isMisdirected());
 
@@ -266,7 +267,7 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(70), new Date(80), HandlingEvent.Type.LOAD, ROTTERDAM, voyage));
 
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
     assertTrue(cargo.isMisdirected());
 
@@ -280,7 +281,7 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CLAIM, ROTTERDAM));
 
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
     assertTrue(cargo.isMisdirected());
   }

dddsample/src/test/java/se/citerus/dddsample/domain/model/handling/HandlingHistoryTest.java

@@ -0,0 +1,45 @@
+package se.citerus.dddsample.domain.model.handling;
+
+import junit.framework.TestCase;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
+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 static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+import se.citerus.dddsample.domain.model.voyage.Voyage;
+import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
+
+import static java.util.Arrays.asList;
+import java.util.Date;
+
+
+public class HandlingHistoryTest extends TestCase {
+  Cargo cargo;
+  Voyage voyage;
+  HandlingEvent event1;
+  HandlingEvent event1duplicate;
+  HandlingEvent event2;
+  HandlingHistory handlingHistory;
+
+  protected void setUp() throws Exception {
+    cargo = new Cargo(new TrackingId("ABC"), new RouteSpecification(SHANGHAI, DALLAS, toDate("2009-04-01")));
+    voyage = new Voyage.Builder(new VoyageNumber("X25"), HONGKONG).
+      addMovement(SHANGHAI, new Date(), new Date()).
+      addMovement(DALLAS, new Date(), new Date()).
+      build();
+    event1 = new HandlingEvent(cargo, toDate("2009-03-05"), new Date(100), HandlingEvent.Type.LOAD, SHANGHAI, voyage);
+    event1duplicate = new HandlingEvent(cargo, toDate("2009-03-05"), new Date(200), HandlingEvent.Type.LOAD, SHANGHAI, voyage);
+    event2 = new HandlingEvent(cargo, toDate("2009-03-10"), new Date(150), HandlingEvent.Type.UNLOAD, DALLAS, voyage);
+
+    handlingHistory = new HandlingHistory(asList(event2, event1, event1duplicate));
+  }
+
+  public void testDistinctEventsByCompletionTime() {
+    assertEquals(asList(event1, event2), handlingHistory.distinctEventsByCompletionTime());
+  }
+
+  public void testMostRecentlyCompletedEvent() {
+    assertEquals(event2, handlingHistory.mostRecentlyCompletedEvent());
+  }
+  
+}

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

@@ -46,7 +46,7 @@ public class CargoRepositoryTest extends AbstractRepositoryTest {
 
     assertNotNull(cargo.delivery());
 
-    final List<HandlingEvent> events = handlingEventRepository.findEventsForCargo(trackingId);
+    final List<HandlingEvent> events = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
     assertEquals(2, events.size());
 
     HandlingEvent firstEvent = events.get(0);

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

@@ -52,7 +52,8 @@ public class HandlingEventRepositoryTest extends AbstractRepositoryTest {
   }
 
   public void testFindEventsForCargo() throws Exception {
-    List<HandlingEvent> handlingEvents = handlingEventRepository.findEventsForCargo(new TrackingId("XYZ"));
+    TrackingId trackingId = new TrackingId("XYZ");
+    List<HandlingEvent> handlingEvents = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
     assertEquals(12, handlingEvents.size());
   }
 

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

@@ -5,8 +5,8 @@ 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.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
+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.*;
 
@@ -59,22 +59,22 @@ public class CargoRepositoryInMem implements CargoRepository {
   public void init() throws Exception {
     final TrackingId xyz = new TrackingId("XYZ");
     final Cargo cargoXYZ = createCargoWithDeliveryHistory(
-      xyz, STOCKHOLM, MELBOURNE, handlingEventRepository.findEventsForCargo(xyz));
+      xyz, STOCKHOLM, MELBOURNE, handlingEventRepository.lookupHandlingHistoryOfCargo(xyz));
     cargoDb.put(xyz.idString(), cargoXYZ);
 
     final TrackingId zyx = new TrackingId("ZYX");
     final Cargo cargoZYX = createCargoWithDeliveryHistory(
-      zyx, MELBOURNE, STOCKHOLM, handlingEventRepository.findEventsForCargo(zyx));
+      zyx, MELBOURNE, STOCKHOLM, handlingEventRepository.lookupHandlingHistoryOfCargo(zyx));
     cargoDb.put(zyx.idString(), cargoZYX);
 
     final TrackingId abc = new TrackingId("ABC");
     final Cargo cargoABC = createCargoWithDeliveryHistory(
-      abc, STOCKHOLM, HELSINKI, handlingEventRepository.findEventsForCargo(abc));
+      abc, STOCKHOLM, HELSINKI, handlingEventRepository.lookupHandlingHistoryOfCargo(abc));
     cargoDb.put(abc.idString(), cargoABC);
 
     final TrackingId cba = new TrackingId("CBA");
     final Cargo cargoCBA = createCargoWithDeliveryHistory(
-      cba, HELSINKI, STOCKHOLM, handlingEventRepository.findEventsForCargo(cba));
+      cba, HELSINKI, STOCKHOLM, handlingEventRepository.lookupHandlingHistoryOfCargo(cba));
     cargoDb.put(cba.idString(), cargoCBA);
   }
 
@@ -85,11 +85,11 @@ public class CargoRepositoryInMem implements CargoRepository {
   public static Cargo createCargoWithDeliveryHistory(TrackingId trackingId,
                                                      Location origin,
                                                      Location destination,
-                                                     Collection<HandlingEvent> events) {
+                                                     HandlingHistory handlingHistory) {
 
     final RouteSpecification routeSpecification = new RouteSpecification(origin, destination, new Date());
     final Cargo cargo = new Cargo(trackingId, routeSpecification);
-    cargo.deriveDeliveryProgress(new ArrayList<HandlingEvent>(events));
+    cargo.deriveDeliveryProgress(handlingHistory);
 
     return cargo;
   }

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

@@ -6,16 +6,15 @@ import se.citerus.dddsample.domain.model.cargo.Cargo;
 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.voyage.CarrierMovement;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
-import java.util.List;
 
 public class HandlingEventRepositoryInMem implements HandlingEventRepository {
   private final Log logger = LogFactory.getLog(getClass());
@@ -86,8 +85,9 @@ public class HandlingEventRepositoryInMem implements HandlingEventRepository {
     eventDB.put(event.cargo().trackingId().idString(), event);
   }
 
-  public List<HandlingEvent> findEventsForCargo(TrackingId trackingId) {
-    return new ArrayList();
+  @Override
+  public HandlingHistory lookupHandlingHistoryOfCargo(TrackingId trackingId) {
+    return HandlingHistory.EMPTY;
   }
 
   /**

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

@@ -6,6 +6,7 @@ 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 static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
@@ -23,7 +24,7 @@ public class CargoTrackingViewAdapterTest extends TestCase {
     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(events);
+    cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
     StaticApplicationContext applicationContext = new StaticApplicationContext();
     applicationContext.addMessage("cargo.status.IN_PORT", Locale.GERMAN, "In port {0}");

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

@@ -9,11 +9,13 @@ import se.citerus.dddsample.application.impl.BookingServiceImpl;
 import se.citerus.dddsample.application.impl.CargoInspectionServiceImpl;
 import se.citerus.dddsample.application.impl.HandlingEventServiceImpl;
 import se.citerus.dddsample.domain.model.cargo.*;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.domain.model.handling.HandlingEventFactory;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
+import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
@@ -103,7 +105,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
     Cargo cargo = cargoRepository.find(trackingId);
     assertNotNull(cargo);
     assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
-    assertEquals(RoutingStatus.NOT_ROUTED, cargo.routingStatus());
+    assertEquals(NOT_ROUTED, cargo.routingStatus());
     assertFalse(cargo.isMisdirected());
     assertNull(cargo.estimatedTimeOfArrival());
     assertNull(cargo.nextExpectedActivity());
@@ -120,7 +122,8 @@ public class CargoLifecycleScenarioTest extends TestCase {
     Itinerary itinerary = selectPreferedItinerary(itineraries);
     cargo.assignToRoute(itinerary);
 
-    assertEquals(RoutingStatus.ROUTED, cargo.routingStatus());
+    assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
+    assertEquals(ROUTED, cargo.routingStatus());
     assertNotNull(cargo.estimatedTimeOfArrival());
     assertEquals(new HandlingActivity(RECEIVE, HONGKONG), cargo.nextExpectedActivity());
 
@@ -142,6 +145,9 @@ public class CargoLifecycleScenarioTest extends TestCase {
       new Date(100), trackingId, null, HONGKONG.unLocode(), RECEIVE
     );
 
+    assertEquals(IN_PORT, cargo.delivery().transportStatus());
+    assertEquals(HONGKONG, cargo.delivery().lastKnownLocation());
+    
     // Next event: Load onto voyage CM003 in Hongkong
     handlingEventService.registerHandlingEvent(
       new Date(200), trackingId, CM003.voyageNumber(), HONGKONG.unLocode(), LOAD
@@ -160,7 +166,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
       because there is no voyage with the specified voyage number,
       and there's no location with the specified UN Locode either.
 
-      This attempt will be rejected and will not affet the cargo delivery in any way.
+      This attempt will be rejected and will not affect the cargo delivery in any way.
      */
     final VoyageNumber noSuchVoyageNumber = new VoyageNumber("XX000");
     final UnLocode noSuchUnLocode = new UnLocode("ZZZZZ");
@@ -190,7 +196,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
     cargo.specifyNewRoute(fromTokyo);
 
     // The old itinerary does not satisfy the new specification
-    assertEquals(RoutingStatus.MISROUTED, cargo.routingStatus());
+    assertEquals(MISROUTED, cargo.routingStatus());
     assertNull(cargo.nextExpectedActivity());
 
     // Repeat procedure of selecting one out of a number of possible routes satisfying the route spec
@@ -199,7 +205,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
     cargo.assignToRoute(newItinerary);
 
     // New itinerary should satisfy new route
-    assertEquals(RoutingStatus.ROUTED, cargo.routingStatus());
+    assertEquals(ROUTED, cargo.routingStatus());
 
     // TODO we can't handle the face that after a reroute, the cargo isn't misdirected anymore
     //assertFalse(cargo.isMisdirected());
@@ -323,6 +329,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
     handlingEventRepository = new HandlingEventRepository() {
       Map<TrackingId, List<HandlingEvent>> eventMap = new HashMap<TrackingId, List<HandlingEvent>>();
 
+      @Override
       public void store(HandlingEvent event) {
         final TrackingId trackingId = event.cargo().trackingId();
         List<HandlingEvent> list = eventMap.get(trackingId);
@@ -333,8 +340,9 @@ public class CargoLifecycleScenarioTest extends TestCase {
         list.add(event);
       }
 
-      public List<HandlingEvent> findEventsForCargo(TrackingId trackingId) {
-        return eventMap.get(trackingId);
+      @Override
+      public HandlingHistory lookupHandlingHistoryOfCargo(TrackingId trackingId) {
+        return new HandlingHistory(eventMap.get(trackingId));
       }
     };