Renamed DeliveryHistory to HandlingHistory.

Made next expected activity persistent and derived on handling.

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

    * @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

 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 {
 
       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

 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;
 import java.text.SimpleDateFormat;
 import static java.util.Arrays.asList;
 import java.util.Date;
-import java.util.List;
 
 /**
  * Provides sample data.
           throw new RuntimeException(e);
         }
 
-        List<HandlingEvent> handlingEvents = handlingEventRepository.findEventsForCargo(trackingId);
-        abc123.deriveDeliveryProgress(handlingEvents);
+        HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId);
+        abc123.deriveDeliveryProgress(handlingHistory);
 
         session.update(abc123);
 
           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

 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,
   private Delivery delivery;
   private RouteSpecification routeSpecification;
   private RoutingStatus routingStatus;
+  private HandlingActivity nextExpectedActivity;
   private boolean misdirected;
   private Date eta;
   
     this.origin = routeSpecification.origin();
     this.routeSpecification = routeSpecification;
 
-    deriveDeliveryProgress(Collections.<HandlingEvent>emptyList());
+    deriveDeliveryProgress(HandlingHistory.EMPTY);
   }
 
   /**
     // Handling consistency within the Cargo aggregate synchronously
     this.routingStatus = deriveRoutingStatus();
     this.misdirected = deriveMisdirectionStatus();
+    this.nextExpectedActivity = deriveNextExpectedActivity();
     this.eta = deriveEta();
   }
 
    * @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;
   }
 
   /**
    * 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();
   }
 
   /**
     }
   }
 
+  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

 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
    */
   }
 
   /**
-   * @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();
     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

     return sameValueAs(other);
   }
 
+  HandlingActivity() {
+    // Needed by Hibernate
+  }
+  
 }

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

 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 
-import java.util.Comparator;
 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

 
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 
-import java.util.List;
-
 /**
  * Handling event repository.
  */
 
   /**
    * @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

+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

 
   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

 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.
 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

     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

       </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

       <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>
             </li>
             </c:forEach>
         </ul>
-
-
     </c:if>
   </div>
   </c:if>

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

 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;
     // 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).
     // 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());
   }
 
 
     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;
   }
     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;
   }
     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;
   }
 
     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;
   }
 
     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;
   }
 
 
     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;
   }
 
     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
 
     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());
 
     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());
 
     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

+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

 
     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

   }
 
   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

 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.*;
 
   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);
   }
 
   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

 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());
     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

 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;
     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

 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.*;
     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());
     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());
 
       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
       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");
     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
     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());
     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);
         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));
       }
     };