Inlined Projections class. Added ETA method to Itinerary.

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

 
 import org.apache.commons.lang.Validate;
 import se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent;
+import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.tracking.core.domain.model.location.CustomsZone;
 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
 import se.citerus.dddsample.tracking.core.domain.patterns.entity.EntitySupport;
 
 import java.util.Date;
+import java.util.Iterator;
 
 /**
  * A Cargo. This is the central class in the domain model,
    * @return Estimated time of arrival.
    */
   public Date estimatedTimeOfArrival() {
-    return Projections.estimatedTimeOfArrival(delivery, itinerary, routeSpecification);
+    if (onTrack()) {
+      return itinerary.estimatedTimeOfArrival();
+    } else {
+      return null;
+    }
   }
 
   /**
    * @return Next expected activity.
    */
   public HandlingActivity nextExpectedActivity() {
-    return Projections.nextExpectedActivity(delivery, itinerary, routeSpecification);
+    /*
+     TODO 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()) {
+      return null;
+    }
+
+    final Location lastKnownLocation = delivery.lastKnownLocation();
+
+    switch (delivery.transportStatus()) {
+      case IN_PORT:
+        if (itinerary.firstLeg().loadLocation().sameAs(lastKnownLocation)) {
+          final Leg firstLeg = itinerary.firstLeg();
+          return new HandlingActivity(LOAD, firstLeg.loadLocation(), firstLeg.voyage());
+        } else {
+          for (Iterator<Leg> it = itinerary.legs().iterator(); it.hasNext();) {
+            final Leg leg = it.next();
+            if (leg.unloadLocation().sameAs(lastKnownLocation)) {
+              if (it.hasNext()) {
+                final Leg nextLeg = it.next();
+                return new HandlingActivity(LOAD, nextLeg.loadLocation(), nextLeg.voyage());
+              } else {
+                return new HandlingActivity(CLAIM, leg.unloadLocation());
+              }
+            }
+          }
+
+          return null;
+        }
+
+      case NOT_RECEIVED:
+        final Leg leg = itinerary.firstLeg();
+        return new HandlingActivity(RECEIVE, leg.loadLocation());
+
+      case ONBOARD_CARRIER:
+        for (Leg leg1 : itinerary.legs()) {
+          if (leg1.loadLocation().sameAs(lastKnownLocation)) {
+            return new HandlingActivity(UNLOAD, leg1.unloadLocation(), leg1.voyage());
+          }
+        }
+
+        return null;
+
+      case CLAIMED:
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * @return True if the cargo is assigned to a route and is following that route.
+   */
+  public boolean onTrack() {
+    return delivery.onTrack(itinerary, routeSpecification);
   }
 
   /**
   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
+    // Delivery is a value object, so it's replaced with a new one
     this.delivery = Delivery.whenHandled(handlingActivity);
   }
 

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

   }
 
   /**
+   * @return Estimated time of arrival
+   */
+  public Date estimatedTimeOfArrival() {
+    return new Date(finalUnloadTime().getTime());
+  }
+
+  /**
    * @param location a location
    * @return Unload time at this location, or null if the location isn't on this itinerary.
    */
     // Needed by Hibernate
     legs = null;
   }
-
 }

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

-package se.citerus.dddsample.tracking.core.domain.model.cargo;
-
-import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.*;
-import se.citerus.dddsample.tracking.core.domain.model.location.Location;
-import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
-import se.citerus.dddsample.tracking.core.domain.patterns.valueobject.ValueObjectSupport;
-
-import java.util.Date;
-import java.util.Iterator;
-
-/**
- * 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.
- */
-class Projections extends ValueObjectSupport<Projections> {
-
-  private static final Date ETA_UNKOWN = null;
-  private static final HandlingActivity NO_ACTIVITY = null;
-
-  /**
-   * @param delivery delivery
-   * @param itinerary itinerary
-   * @param routeSpecification routeSpecification
-   * @return Estimated time of arrival, or null if not known.
-   */
-  static Date estimatedTimeOfArrival(final Delivery delivery, final Itinerary itinerary, final RouteSpecification routeSpecification) {
-    if (delivery.onTrack(itinerary, routeSpecification)) {
-      return new Date(itinerary.finalUnloadTime().getTime());
-    } else {
-      return ETA_UNKOWN;
-    }
-  }
-
-  /**
-   * @param delivery delivery
-   * @param itinerary itinerary
-   * @param routeSpecification routeSpecification 
-   * @return The next expected handling activity.
-   */
-  static HandlingActivity nextExpectedActivity(final Delivery delivery, final Itinerary itinerary, final RouteSpecification routeSpecification) {
-    /*
-     TODO 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 (!delivery.onTrack(itinerary, routeSpecification)) {
-      return NO_ACTIVITY;
-    }
-
-    final Location lastKnownLocation = delivery.lastKnownLocation();
-    switch (delivery.transportStatus()) {
-      case IN_PORT:
-        if (itinerary.firstLeg().loadLocation().sameAs(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 static HandlingActivity receiveInFirstLocation(final Itinerary itinerary) {
-    final Leg leg = itinerary.firstLeg();
-    return new HandlingActivity(RECEIVE, leg.loadLocation());
-  }
-
-  private static HandlingActivity loadInFirstLocation(final Itinerary itinerary) {
-    final Leg leg = itinerary.firstLeg();
-    return new HandlingActivity(LOAD, leg.loadLocation(), leg.voyage());
-  }
-
-  private static 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().sameAs(activityLocation)) {
-        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;
-  }
-
-  private static HandlingActivity unloadInNextLocation(final Itinerary itinerary, final Location activityLocation) {
-    for (final Leg leg : itinerary.legs()) {
-      if (leg.loadLocation().sameAs(activityLocation)) {
-        return new HandlingActivity(UNLOAD, leg.unloadLocation(), leg.voyage());
-      }
-    }
-
-    return NO_ACTIVITY;
-  }
-
-  Projections() {
-    // Needed by Hibernate
-  }
-
-}

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

       <property name="id" column="tracking_id"/>
     </component>
 
-    <component name="projections">
-      <property name="estimatedTimeOfArrival" column="eta" not-null="false"/>
-      <component name="nextExpectedActivity" update="true">
-        <many-to-one name="location" column="next_expected_location_id" foreign-key="next_expected_location_fk" cascade="none"/>
-        <property name="type" column="next_expected_handling_event_type">
-          <type name="org.hibernate.type.EnumType">
-            <param name="enumClass">se.citerus.dddsample.tracking.core.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" cascade="none"/>
-      </component>
-    </component>
-
     <component name="delivery" lazy="true">
       <property name="calculatedAt" column="calculated_at" not-null="true"/>
       <component name="mostRecentHandlingActivity">

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

 public class DeliveryTest extends TestCase {
 
   Delivery delivery;
-  Projections projections;
   Itinerary itinerary;
   RouteSpecification routeSpecification;
 
       Leg.deriveLeg(DALLAS_TO_HELSINKI, DALLAS, STOCKHOLM)
     );
     delivery = Delivery.initial();
-    projections = new Projections(delivery, itinerary, routeSpecification);
     Thread.sleep(1);
   }
 
     assertEquals(Location.UNKNOWN, delivery.lastKnownLocation());
     assertEquals(NOT_RECEIVED, delivery.transportStatus());
     assertTrue(delivery.calculatedAt().before(new Date()));
-
-    assertEquals(new HandlingActivity(RECEIVE, HANGZOU), projections.nextExpectedActivity());
-    assertEquals(DALLAS_TO_HELSINKI.schedule().arrivalTimeAt(STOCKHOLM), projections.estimatedTimeOfArrival());
   }
 
   public void testUpdateOnHandlingHappyPath() {
 
     HandlingActivity handlingActivity = new HandlingActivity(RECEIVE, HANGZOU);
     Delivery newDelivery = Delivery.whenHandled(handlingActivity);
-    Projections newProjections = new Projections(newDelivery, itinerary, routeSpecification);
 
     // Changed on handling
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(IN_PORT, newDelivery.transportStatus());
 
     // Changed on handling and/or (re-)routing
-    assertEquals(new HandlingActivity(LOAD, HANGZOU, HONGKONG_TO_NEW_YORK), newProjections.nextExpectedActivity());
     assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(newDelivery.isUnloadedAtDestination(routeSpecification));
 
     // Changed on (re-)routing
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
-    assertEquals(DALLAS_TO_HELSINKI.schedule().arrivalTimeAt(STOCKHOLM), newProjections.estimatedTimeOfArrival());
 
     // Updated on every calculation
     assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
 
     handlingActivity = new HandlingActivity(LOAD, HANGZOU, HONGKONG_TO_NEW_YORK);
     newDelivery = Delivery.whenHandled(handlingActivity);
-    newProjections = new Projections(newDelivery, itinerary, routeSpecification);
 
     assertEquals(HONGKONG_TO_NEW_YORK, newDelivery.currentVoyage());
     assertEquals(HANGZOU, newDelivery.lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, newDelivery.transportStatus());
 
-    assertEquals(new HandlingActivity(UNLOAD, NEWYORK, HONGKONG_TO_NEW_YORK), newProjections.nextExpectedActivity());
     assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(newDelivery.isUnloadedAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
-    assertEquals(DALLAS_TO_HELSINKI.schedule().arrivalTimeAt(STOCKHOLM), newProjections.estimatedTimeOfArrival());
 
     assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
 
 
     handlingActivity = new HandlingActivity(UNLOAD, STOCKHOLM, DALLAS_TO_HELSINKI);
     newDelivery = Delivery.whenHandled(handlingActivity);
-    newProjections = new Projections(newDelivery, itinerary, routeSpecification);
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
     assertEquals(IN_PORT, newDelivery.transportStatus());
 
-    assertEquals(new HandlingActivity(CLAIM, STOCKHOLM), newProjections.nextExpectedActivity());
     assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertTrue(newDelivery.isUnloadedAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
-    assertEquals(DALLAS_TO_HELSINKI.schedule().arrivalTimeAt(STOCKHOLM), newProjections.estimatedTimeOfArrival());
 
     assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
 
 
     handlingActivity = new HandlingActivity(CLAIM, STOCKHOLM);
     newDelivery = Delivery.whenHandled(handlingActivity);
-    newProjections = new Projections(newDelivery, itinerary, routeSpecification);
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
     assertEquals(CLAIMED, newDelivery.transportStatus());
 
-    assertNull(newProjections.nextExpectedActivity());
     assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertTrue(newDelivery.isUnloadedAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
-    assertEquals(DALLAS_TO_HELSINKI.schedule().arrivalTimeAt(STOCKHOLM), newProjections.estimatedTimeOfArrival());
 
     assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
   }
     // Unload in Hamburg, which is the wrong location
     HandlingActivity handlingActivity = new HandlingActivity(UNLOAD, HAMBURG, DALLAS_TO_HELSINKI);
     Delivery newDelivery = Delivery.whenHandled(handlingActivity);
-    Projections newProjections = new Projections(newDelivery, itinerary, routeSpecification);
 
     assertEquals(Voyage.NONE, newDelivery.currentVoyage());
     assertEquals(HAMBURG, newDelivery.lastKnownLocation());
     assertEquals(IN_PORT, newDelivery.transportStatus());
 
     // Next handling activity is undefined. Need a new itinerary to know what to do.
-    assertNull(newProjections.nextExpectedActivity());
-    
+
     assertTrue(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(newDelivery.isUnloadedAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    // ETA is undefined at this time
-    assertNull(newProjections.estimatedTimeOfArrival());
-
     assertTrue(delivery.calculatedAt().before(newDelivery.calculatedAt()));
 
     // New route specification, old itinerary
     RouteSpecification newRouteSpecification = routeSpecification.withOrigin(HAMBURG);
-    newProjections = new Projections(newDelivery, itinerary, newRouteSpecification);
     assertEquals(MISROUTED, newDelivery.routingStatus(itinerary, newRouteSpecification));
 
     // TODO is it really misdirected at this point?
     assertTrue(newDelivery.isMisdirected(itinerary, newRouteSpecification));
 
-    assertNull(newProjections.nextExpectedActivity());
-
     Itinerary newItinerary = new Itinerary(
       Leg.deriveLeg(DALLAS_TO_HELSINKI, HAMBURG, STOCKHOLM)
     );
 
-    newProjections = new Projections(newDelivery, newItinerary, newRouteSpecification);
-
     assertEquals(ROUTED, newDelivery.routingStatus(newItinerary, newRouteSpecification));
     // TODO is it really misdirected here?
     assertTrue(newDelivery.isMisdirected(newItinerary, newRouteSpecification));
     assertEquals(IN_PORT, newDelivery.transportStatus());
-    //assertEquals(new HandlingActivity(LOAD, HAMBURG, DALLAS_TO_HELSINKI), newProjections.nextExpectedActivity());
-    assertNull(newProjections.nextExpectedActivity());
   }
 
 }