Refactored construction of HandlingEvent instance into a factory, which uses repositories for assembly.

dddsample/src/main/java/se/citerus/dddsample/application/ws/HandlingEventServiceEndpoint.java

    */
   void register(String completionTime, String trackingId, String carrierMovementId, String unlocode, String eventType);
 
+  // TODO structured class that holds these fields, and/or a batching method that accepts a list of those
+  // TODO contract-first instead of code-first (?)
+  
 }

dddsample/src/main/java/se/citerus/dddsample/application/ws/HandlingEventServiceEndpointImpl.java

 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.carrier.CarrierMovementId;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
+import se.citerus.dddsample.domain.model.handling.HandlingEventFactory;
 import se.citerus.dddsample.domain.model.location.UnLocode;
 import se.citerus.dddsample.domain.service.HandlingEventService;
 import se.citerus.dddsample.domain.service.UnknownCarrierMovementIdException;
 @WebService(endpointInterface = "se.citerus.dddsample.application.ws.HandlingEventServiceEndpoint")
 public class HandlingEventServiceEndpointImpl implements HandlingEventServiceEndpoint {
 
+  private HandlingEventFactory handlingEventFactory;
   private HandlingEventService handlingEventService;
   private TransactionTemplate transactionTemplate;
   private final Log logger = LogFactory.getLog(getClass());
         cid = null;
       }
       final HandlingEvent.Type type = parseEventType(eventType);
-
       final UnLocode ul = new UnLocode(unlocode);
 
-      // Using programmatic demarcation here due to weaving conflicts
-      // between jax-ws and Spring transaction annotations
-      transactionTemplate.execute(new TransactionCallbackWithoutResult() {
-          protected void doInTransactionWithoutResult(TransactionStatus status) {
-              try {
-
-                  handlingEventService.register(date, tid, cid, ul, type);
-
-              } catch (UnknownCarrierMovementIdException e) {
-                  handleUnknownCarrierMovementId(e);
-              } catch (UnknownTrackingIdException e) {
-                  handleUnknownTrackingId(e);
-              } catch (UnknownLocationException e) {
-                  handleOtherError(e);
-              }
-          }
-      });
-
+      doRegister(date, tid, cid, type, ul);
     } catch (IllegalArgumentException iae) {
       handleIllegalArgument(iae);
     } catch (ParseException pe) {
     }
   }
 
+  // TODO this entire step would be well suited to move to a consumer of asynchronous messages
+  private void doRegister(final Date date, final TrackingId tid, final CarrierMovementId cid, final HandlingEvent.Type type, final UnLocode ul) {
+    // Using programmatic demarcation here due to weaving conflicts
+    // between jax-ws and Spring transaction annotations
+    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
+        protected void doInTransactionWithoutResult(TransactionStatus status) {
+            try {
+                HandlingEvent event = handlingEventFactory.createHandlingEvent(date, tid, cid, ul, type);
+                handlingEventService.register(event);
+            } catch (UnknownCarrierMovementIdException e) {
+                handleUnknownCarrierMovementId(e);
+            } catch (UnknownTrackingIdException e) {
+                handleUnknownTrackingId(e);
+            } catch (UnknownLocationException e) {
+                handleUnknownLocation(e);
+            }
+        }
+    });
+  }
+
+  private HandlingEvent.Type parseEventType(final String eventType) throws InvalidEventTypeException {
+    try {
+      return HandlingEvent.Type.valueOf(eventType);
+    } catch (IllegalArgumentException e) {
+      throw new InvalidEventTypeException(eventType);
+    }
+  }
+
+  private Date parseIso8601Date(final String completionTime) throws ParseException {
+    return new SimpleDateFormat(ISO_8601_FORMAT).parse(completionTime);
+  }
+
+  // Validation/translation errors
+
   private void handleIllegalArgument(IllegalArgumentException iae) {
     logger.error(iae, iae);
   }
     logger.error("Invalid date format: " + completionTime + ", must be on ISO 8601 format: " + ISO_8601_FORMAT);
   }
 
-  private HandlingEvent.Type parseEventType(final String eventType) throws InvalidEventTypeException {
-    try {
-      return HandlingEvent.Type.valueOf(eventType);
-    } catch (IllegalArgumentException e) {
-      throw new InvalidEventTypeException(eventType);
-    }
+  // Domain errors, don't belong here really
+
+  private void handleUnknownLocation(UnknownLocationException e) {
+    logger.error(e, e);
   }
 
   private void handleUnknownCarrierMovementId(UnknownCarrierMovementIdException e) {
-    logger.info("Placing event in retry queue due to: " + e.getMessage());
+    logger.error(e, e);
   }
 
   private void handleUnknownTrackingId(Exception e) {
-    logger.info("Placing event in retry queue due to: " + e.getMessage());
+    logger.error(e, e);
   }
 
-  private Date parseIso8601Date(final String completionTime) throws ParseException {
-    return new SimpleDateFormat(ISO_8601_FORMAT).parse(completionTime);
-  }
+  // Setters
 
-  public void setHandlingEventService(final HandlingEventService handlingEventService) {
+  public void setHandlingEventService(HandlingEventService handlingEventService) {
     this.handlingEventService = handlingEventService;
   }
 
       transactionTemplate = new TransactionTemplate(transactionManager);
   }
 
+  public void setHandlingEventFactory(HandlingEventFactory handlingEventFactory) {
+    this.handlingEventFactory = handlingEventFactory;
+  }
 }

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

+package se.citerus.dddsample.domain.model.handling;
+
+import org.apache.commons.lang.Validate;
+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.carrier.CarrierMovement;
+import se.citerus.dddsample.domain.model.carrier.CarrierMovementId;
+import se.citerus.dddsample.domain.model.carrier.CarrierMovementRepository;
+import se.citerus.dddsample.domain.model.location.Location;
+import se.citerus.dddsample.domain.model.location.LocationRepository;
+import se.citerus.dddsample.domain.model.location.UnLocode;
+import se.citerus.dddsample.domain.service.UnknownCarrierMovementIdException;
+import se.citerus.dddsample.domain.service.UnknownLocationException;
+import se.citerus.dddsample.domain.service.UnknownTrackingIdException;
+
+import java.util.Date;
+
+/**
+ * Creates handling events.
+ */
+public class HandlingEventFactory {
+
+  private CargoRepository cargoRepository;
+  private CarrierMovementRepository carrierMovementRepository;
+  private LocationRepository locationRepository;
+
+  /**
+   * @param completionTime    when the event was completed, for example finished loading
+   * @param trackingId        tracking id
+   * @param carrierMovementId carrier movement id, if applicable (may be null)
+   * @param unlocode          United Nations Location Code for the location of the event
+   * @param type              type of event
+   * @throws UnknownCarrierMovementIdException
+   *                                    if there's not carrier movement with this id
+   * @throws UnknownTrackingIdException if there's no cargo with this tracking id
+   * @throws UnknownLocationException   if there's no location with this UN Locode
+   * @return A handling event.
+   */
+  public HandlingEvent createHandlingEvent(Date completionTime, TrackingId trackingId, CarrierMovementId carrierMovementId, UnLocode unlocode, HandlingEvent.Type type)
+    throws UnknownTrackingIdException, UnknownCarrierMovementIdException, UnknownLocationException {
+
+    // Carrier movement may be null for certain event types
+    Validate.noNullElements(new Object[]{trackingId, unlocode, type});
+
+    final Cargo cargo = cargoRepository.find(trackingId);
+    if (cargo == null) throw new UnknownTrackingIdException(trackingId);
+
+    final CarrierMovement carrierMovement = findCarrierMovement(carrierMovementId);
+
+    final Location location = findLocation(unlocode);
+    if (location == null) throw new UnknownLocationException(unlocode);
+
+    final Date registrationTime = new Date();
+
+    if (carrierMovement == null) {
+      return new HandlingEvent(cargo, completionTime, registrationTime, type, location);   
+    } else {
+      return new HandlingEvent(cargo, completionTime, registrationTime, type, location, carrierMovement);
+    }
+  }
+
+  private CarrierMovement findCarrierMovement(final CarrierMovementId carrierMovementId)
+    throws UnknownCarrierMovementIdException {
+
+    if (carrierMovementId == null) {
+      return null;
+    }
+    final CarrierMovement carrierMovement = carrierMovementRepository.find(carrierMovementId);
+    if (carrierMovement == null) {
+      throw new UnknownCarrierMovementIdException(carrierMovementId);
+    }
+
+    return carrierMovement;
+  }
+
+  private Location findLocation(final UnLocode unlocode) throws UnknownLocationException {
+    if (unlocode == null) {
+      return Location.UNKNOWN;
+    }
+
+    final Location location = locationRepository.find(unlocode);
+    if (location == null) {
+      throw new UnknownLocationException(unlocode);
+    }
+
+    return location;
+  }
+
+  public void setCargoRepository(final CargoRepository cargoRepository) {
+    this.cargoRepository = cargoRepository;
+  }
+
+  public void setCarrierMovementRepository(final CarrierMovementRepository carrierMovementRepository) {
+    this.carrierMovementRepository = carrierMovementRepository;
+  }
+
+  public void setLocationRepository(final LocationRepository locationRepository) {
+    this.locationRepository = locationRepository;
+  }
+
+
+}

dddsample/src/main/java/se/citerus/dddsample/domain/service/HandlingEventService.java

 package se.citerus.dddsample.domain.service;
 
-import se.citerus.dddsample.domain.model.cargo.TrackingId;
-import se.citerus.dddsample.domain.model.carrier.CarrierMovementId;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import se.citerus.dddsample.domain.model.location.UnLocode;
-
-import java.util.Date;
 
 
 /**
 public interface HandlingEventService {
 
   /**
-   * @param completionTime    when the event was completed, for example finished loading
-   * @param trackingId        tracking id
-   * @param carrierMovementId carrier movement id, if applicable (may be null)
-   * @param unlocode          United Nations Location Code for the location of the event
-   * @param type              type of event
-   * @throws UnknownCarrierMovementIdException
-   *                                    if there's not carrier movement with this id
-   * @throws UnknownTrackingIdException if there's no cargo with this tracking id
-   * @throws UnknownLocationException   if there's no location with this UN Locode
+   * Registers a handling event in the system, and notifies interested
+   * parties that an event has been registered.
+   *
+   * @param event handling event to register
    */
-  void register(Date completionTime, TrackingId trackingId, CarrierMovementId carrierMovementId, UnLocode unlocode, HandlingEvent.Type type)
-  throws UnknownCarrierMovementIdException, UnknownTrackingIdException, UnknownLocationException;
+  void register(HandlingEvent event);
 
 }

dddsample/src/main/java/se/citerus/dddsample/domain/service/impl/HandlingEventServiceImpl.java

 package se.citerus.dddsample.domain.service.impl;
 
-import org.apache.commons.lang.Validate;
-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.carrier.CarrierMovement;
-import se.citerus.dddsample.domain.model.carrier.CarrierMovementId;
-import se.citerus.dddsample.domain.model.carrier.CarrierMovementRepository;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
-import se.citerus.dddsample.domain.model.location.Location;
-import se.citerus.dddsample.domain.model.location.LocationRepository;
-import se.citerus.dddsample.domain.model.location.UnLocode;
-import se.citerus.dddsample.domain.service.*;
-
-import java.util.Date;
+import se.citerus.dddsample.domain.service.DomainEventNotifier;
+import se.citerus.dddsample.domain.service.HandlingEventService;
 
 public final class HandlingEventServiceImpl implements HandlingEventService {
-  private CargoRepository cargoRepository;
-  private CarrierMovementRepository carrierMovementRepository;
+
   private HandlingEventRepository handlingEventRepository;
-  private LocationRepository locationRepository;
   private DomainEventNotifier domainEventNotifier;
 
-  public void register(final Date completionTime, final TrackingId trackingId, final CarrierMovementId carrierMovementId,
-                       final UnLocode unlocode, final HandlingEvent.Type type)
-    throws UnknownCarrierMovementIdException, UnknownTrackingIdException, UnknownLocationException {
-
-    // Carrier movement may be null for certain event types
-    Validate.noNullElements(new Object[]{trackingId, unlocode, type});
-
-    Cargo cargo = cargoRepository.find(trackingId);
-    if (cargo == null) throw new UnknownTrackingIdException(trackingId);
-
-    final CarrierMovement carrierMovement = findCarrierMovement(carrierMovementId);
-    final Location location = findLocation(unlocode);
-    final Date registrationTime = new Date();
-
-    final HandlingEvent event = new HandlingEvent(cargo, completionTime, registrationTime, type, location, carrierMovement);
-
+  public void register(final HandlingEvent event) {
     /*
-      NOTE:
-        The cargo instance that's loaded and associated with the handling event is
-        in an inconsitent state, because the cargo delivery history's collection of
-        events does not contain the event created here. However, this is not a problem,
-        because cargo is in a different aggregate from handling event.
-
-        The rules of an aggregate dictate that all consistency rules within the aggregate
-        are enforced synchronously in the transaction, but consistency rules of other aggregates
-        are enforced by asynchronous updates, after the commit of this transaction.
-     */
+     NOTE:
+       The cargo instance that's loaded and associated with the handling event is
+       in an inconsitent state, because the cargo delivery history's collection of
+       events does not contain the event created here. However, this is not a problem,
+       because cargo is in a different aggregate from handling event.
+
+       The rules of an aggregate dictate that all consistency rules within the aggregate
+       are enforced synchronously in the transaction, but consistency rules of other aggregates
+       are enforced by asynchronous updates, after the commit of this transaction.
+    */
     handlingEventRepository.save(event);
 
     domainEventNotifier.cargoWasHandled(event);
   }
 
-  private CarrierMovement findCarrierMovement(final CarrierMovementId carrierMovementId)
-    throws UnknownCarrierMovementIdException {
-
-    if (carrierMovementId == null) {
-      return null;
-    }
-    final CarrierMovement carrierMovement = carrierMovementRepository.find(carrierMovementId);
-    if (carrierMovement == null) {
-      throw new UnknownCarrierMovementIdException(carrierMovementId);
-    }
-
-    return carrierMovement;
-  }
-
-  private Location findLocation(final UnLocode unlocode) throws UnknownLocationException {
-    if (unlocode == null) {
-      return Location.UNKNOWN;
-    }
-
-    final Location location = locationRepository.find(unlocode);
-    if (location == null) {
-      throw new UnknownLocationException(unlocode);
-    }
-
-    return location;
-  }
-
-  public void setCargoRepository(final CargoRepository cargoRepository) {
-    this.cargoRepository = cargoRepository;
-  }
-
-  public void setCarrierMovementRepository(final CarrierMovementRepository carrierMovementRepository) {
-    this.carrierMovementRepository = carrierMovementRepository;
-  }
-
   public void setHandlingEventRepository(final HandlingEventRepository handlingEventRepository) {
     this.handlingEventRepository = handlingEventRepository;
   }
 
-  public void setLocationRepository(final LocationRepository locationRepository) {
-    this.locationRepository = locationRepository;
-  }
-
   public void setDomainEventNotifier(DomainEventNotifier domainEventNotifier) {
     this.domainEventNotifier = domainEventNotifier;
   }

dddsample/src/test/java/se/citerus/dddsample/application/ws/HandlinEventServiceEndpointTest.java

 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.carrier.CarrierMovementId;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
+import se.citerus.dddsample.domain.model.handling.HandlingEventFactory;
 import se.citerus.dddsample.domain.model.location.UnLocode;
 import se.citerus.dddsample.domain.service.HandlingEventService;
 import se.citerus.dddsample.domain.service.UnknownCarrierMovementIdException;
 
   private HandlingEventServiceEndpointImpl endpoint;
   private HandlingEventService handlingEventService;
+  private HandlingEventFactory handlingEventFactory;
   private SimpleDateFormat sdf;
 
   protected void setUp() throws Exception {
+    handlingEventFactory = new HandlingEventFactory();
     endpoint = new HandlingEventServiceEndpointImpl();
     handlingEventService = createMock(HandlingEventService.class);
     endpoint.setHandlingEventService(handlingEventService);
   public void testRegisterValidEvent() throws Exception {
     Date date = new Date(100);
 
-    handlingEventService.register(date, new TrackingId("FOO"), new CarrierMovementId("CAR_456"), new UnLocode("CNHKG"), HandlingEvent.Type.LOAD);
+    final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, new TrackingId("FOO"), new CarrierMovementId("CAR_456"), new UnLocode("CNHKG"), HandlingEvent.Type.LOAD);
+    handlingEventService.register(event);
     replay(handlingEventService);
 
     // Tested call
     TrackingId trackingId = new TrackingId("NOTFOUND");
     UnLocode unlocode = new UnLocode("SESTO");
 
-    handlingEventService.register(date, trackingId, null, unlocode, HandlingEvent.Type.CLAIM);
+    final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, trackingId, null, unlocode, HandlingEvent.Type.CLAIM);
+    handlingEventService.register(event);
     expectLastCall().andThrow(new UnknownTrackingIdException(trackingId));
     replay(handlingEventService);
 
     TrackingId trackingId = new TrackingId("XYZ");
     CarrierMovementId carrierMovementId = new CarrierMovementId("NOTFOUND");
 
-    handlingEventService.register(date, trackingId, carrierMovementId, new UnLocode("AUMEL"), HandlingEvent.Type.UNLOAD);
+    final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, trackingId, carrierMovementId, new UnLocode("AUMEL"), HandlingEvent.Type.UNLOAD);
+    handlingEventService.register(event);
     expectLastCall().andThrow(new UnknownCarrierMovementIdException(carrierMovementId));
     replay(handlingEventService);
 

dddsample/src/test/java/se/citerus/dddsample/domain/service/HandlingEventServiceTest.java

 import se.citerus.dddsample.domain.model.carrier.CarrierMovementRepository;
 import se.citerus.dddsample.domain.model.carrier.SampleCarrierMovements;
 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.location.LocationRepository;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
   private CarrierMovementRepository carrierMovementRepository;
   private HandlingEventRepository handlingEventRepository;
   private LocationRepository locationRepository;
+  private HandlingEventFactory handlingEventFactory;
 
   private final Cargo cargoABC = new Cargo(new TrackingId("ABC"), HAMBURG, TOKYO);
 
     handlingEventRepository = createMock(HandlingEventRepository.class);
     locationRepository = createMock(LocationRepository.class);
     domainEventNotifier = createMock(DomainEventNotifier.class);
+    handlingEventFactory = new HandlingEventFactory();
 
-    service.setCargoRepository(cargoRepository);
-    service.setCarrierMovementRepository(carrierMovementRepository);
+    handlingEventFactory.setCargoRepository(cargoRepository);
+    handlingEventFactory.setCarrierMovementRepository(carrierMovementRepository);
+    handlingEventFactory.setLocationRepository(locationRepository);
     service.setHandlingEventRepository(handlingEventRepository);
-    service.setLocationRepository(locationRepository);
     service.setDomainEventNotifier(domainEventNotifier);
   }
 
     domainEventNotifier.cargoWasHandled(isA(HandlingEvent.class));
 
     replay(cargoRepository, carrierMovementRepository, handlingEventRepository, locationRepository, domainEventNotifier);
-    
-    service.register(date, trackingId, carrierMovementId, unLocode, HandlingEvent.Type.LOAD);
+
+    final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, trackingId, carrierMovementId, unLocode, HandlingEvent.Type.LOAD);
+    service.register(event);
   }
 
   public void testRegisterEventWithoutCarrierMovement() throws Exception {
 
     replay(cargoRepository, carrierMovementRepository, handlingEventRepository, locationRepository, domainEventNotifier);
 
-    service.register(date, trackingId, null, STOCKHOLM.unLocode(), HandlingEvent.Type.CLAIM);
+    final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, trackingId, null, STOCKHOLM.unLocode(), HandlingEvent.Type.CLAIM);
+    service.register(event);
   }
   
 
     replay(cargoRepository, carrierMovementRepository, handlingEventRepository, locationRepository, domainEventNotifier);
     
     try {
-      service.register(date, trackingId, carrierMovementId, MELBOURNE.unLocode(), HandlingEvent.Type.UNLOAD);
+      final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, trackingId, carrierMovementId, MELBOURNE.unLocode(), HandlingEvent.Type.UNLOAD);
+      service.register(event);
       fail("Should not be able to register an event with non-existing carrier movement");
     } catch (UnknownCarrierMovementIdException expected) {}
   }
     replay(cargoRepository, carrierMovementRepository, handlingEventRepository, locationRepository, domainEventNotifier);
     
     try {
-      service.register(date, trackingId, null, HONGKONG.unLocode(), HandlingEvent.Type.CLAIM);
+      final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, trackingId, null, HONGKONG.unLocode(), HandlingEvent.Type.CLAIM);
+      service.register(event);
       fail("Should not be able to register an event with non-existing cargo");
     } catch (UnknownTrackingIdException expected) {}
   }
     replay(cargoRepository, carrierMovementRepository, handlingEventRepository, locationRepository, domainEventNotifier);
     
     try {
-      service.register(date, trackingId, null, wayOff, HandlingEvent.Type.CLAIM);
+      final HandlingEvent event = handlingEventFactory.createHandlingEvent(date, trackingId, null, wayOff, HandlingEvent.Type.CLAIM);
+      service.register(event);
       fail("Should not be able to register an event with non-existing Location");
     } catch (UnknownLocationException expected) {}
   }