Renamed DomainEventNotifer to SystemEvents and moved out to application layer.

Moved handling of rejected registration attempts into HandlingEventService, making the JMS consumer pure delegation.

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

 package se.citerus.dddsample.application;
 
 import se.citerus.dddsample.application.messaging.HandlingEventRegistrationAttempt;
-import se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException;
 
 
 /**
    * parties that an event has been registered.
    *
    * @param attempt handling event registration attempt
-   * @throws se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException
    */
-  void register(HandlingEventRegistrationAttempt attempt) throws CannotCreateHandlingEventException;
+  void register(HandlingEventRegistrationAttempt attempt);
 
 }

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

+package se.citerus.dddsample.application;
+
+import se.citerus.dddsample.application.messaging.HandlingEventRegistrationAttempt;
+import se.citerus.dddsample.domain.model.cargo.Cargo;
+import se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException;
+import se.citerus.dddsample.domain.model.handling.HandlingEvent;
+
+/**
+ * This interface provides a way to let other parts
+ * of the system know about events that have occurred.
+ * <p/>
+ * It may be implemented synchronously or asynchronously, using
+ * for example JMS.
+ */
+public interface SystemEvents {
+
+  /**
+   * A cargo has been handled.
+   *
+   * @param event handling event
+   */
+  void cargoWasHandled(HandlingEvent event);
+
+  void cargoWasMisdirected(Cargo cargo);
+
+  void cargoHasArrived(Cargo cargo);
+
+  void rejectHandlingEventRegistrationAttempt(HandlingEventRegistrationAttempt attempt, CannotCreateHandlingEventException problem);
+
+  //void scheduleWasChanged(Voyage voyage);
+
+}

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

   }
 
   @Override
-  @Transactional(readOnly = false)
+  @Transactional
   public TrackingId bookNewCargo(final UnLocode originUnLocode, final UnLocode destinationUnLocode) {
     Validate.notNull(originUnLocode);
     Validate.notNull(destinationUnLocode);

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

 
 import org.springframework.transaction.annotation.Transactional;
 import se.citerus.dddsample.application.HandlingEventService;
+import se.citerus.dddsample.application.SystemEvents;
 import se.citerus.dddsample.application.messaging.HandlingEventRegistrationAttempt;
 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.service.DomainEventNotifier;
 
 public final class HandlingEventServiceImpl implements HandlingEventService {
 
   private final HandlingEventRepository handlingEventRepository;
-  private final DomainEventNotifier domainEventNotifier;
+  private final SystemEvents systemEvents;
   private final HandlingEventFactory handlingEventFactory;
 
-  public HandlingEventServiceImpl(HandlingEventRepository handlingEventRepository, DomainEventNotifier domainEventNotifier, HandlingEventFactory handlingEventFactory) {
+  public HandlingEventServiceImpl(HandlingEventRepository handlingEventRepository, SystemEvents systemEvents, HandlingEventFactory handlingEventFactory) {
     this.handlingEventRepository = handlingEventRepository;
-    this.domainEventNotifier = domainEventNotifier;
+    this.systemEvents = systemEvents;
     this.handlingEventFactory = handlingEventFactory;
   }
 
      are enforced by asynchronous updates, after the commit of this transaction.
   */
   @Override
-  @Transactional(readOnly = false, rollbackFor = {CannotCreateHandlingEventException.class})
-  public void register(HandlingEventRegistrationAttempt attempt) throws CannotCreateHandlingEventException {
-    final HandlingEvent event = handlingEventFactory.createHandlingEvent(attempt.getDate(), attempt.getTrackingId(), attempt.getVoyageNumber(), attempt.getUnLocode(), attempt.getType());
-    handlingEventRepository.save(event);
-    domainEventNotifier.cargoWasHandled(event);
+  @Transactional
+  public void register(HandlingEventRegistrationAttempt attempt) {
+    try {
+      final HandlingEvent event = handlingEventFactory.createHandlingEvent(attempt.getDate(), attempt.getTrackingId(), attempt.getVoyageNumber(), attempt.getUnLocode(), attempt.getType());
+      handlingEventRepository.save(event);
+      systemEvents.cargoWasHandled(event);
+    } catch (CannotCreateHandlingEventException e) {
+      systemEvents.rejectHandlingEventRegistrationAttempt(attempt, e);
+    }
   }
 
 }

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

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.transaction.annotation.Transactional;
+import se.citerus.dddsample.application.SystemEvents;
 import se.citerus.dddsample.application.TrackingService;
 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.service.DomainEventNotifier;
 
 public class TrackingServiceImpl implements TrackingService {
 
-  private final DomainEventNotifier domainEventNotifier;
+  private final SystemEvents systemEvents;
   private final CargoRepository cargoRepository;
   private final Log logger = LogFactory.getLog(getClass());
 
-  public TrackingServiceImpl(DomainEventNotifier domainEventNotifier, CargoRepository cargoRepository) {
-    this.domainEventNotifier = domainEventNotifier;
+  public TrackingServiceImpl(SystemEvents systemEvents, CargoRepository cargoRepository) {
+    this.systemEvents = systemEvents;
     this.cargoRepository = cargoRepository;
   }
 
   @Override
-  @Transactional
+  @Transactional(readOnly = true)
   public void onCargoHandled(final TrackingId trackingId) {
     Validate.notNull(trackingId, "Tracking ID is required");
 
     // TODO cargo delivery status update would happen here
 
     if (cargo.isMisdirected()) {
-      domainEventNotifier.cargoWasMisdirected(cargo);
+      systemEvents.cargoWasMisdirected(cargo);
     }
 
     if (cargo.isUnloadedAtDestination()) {
-      domainEventNotifier.cargoHasArrived(cargo);
+      systemEvents.cargoHasArrived(cargo);
     }
   }
 

dddsample/src/main/java/se/citerus/dddsample/application/messaging/CargoHandledConsumer.java

 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.springframework.transaction.annotation.Transactional;
 import se.citerus.dddsample.application.TrackingService;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 
   private TrackingService trackingService;
   private final Log logger = LogFactory.getLog(getClass());
 
-  @Transactional(readOnly = true)  
+  @Override  
   public void onMessage(final Message message) {
     if (logger.isDebugEnabled()) {
       logger.debug("Received message " + message);

dddsample/src/main/java/se/citerus/dddsample/application/messaging/HandlingEventRegistrationAttemptConsumer.java

 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.springframework.jms.core.JmsOperations;
-import org.springframework.jms.core.MessageCreator;
 import se.citerus.dddsample.application.HandlingEventService;
-import se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException;
 
-import javax.jms.*;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.ObjectMessage;
 
 /**
+ * Consumes handling event registration attempt messages and delegates to
+ * proper registration.
+ * 
  */
 public class HandlingEventRegistrationAttemptConsumer implements MessageListener {
 
   private HandlingEventService handlingEventService;
-  private JmsOperations jmsOperations;
-  private Destination rejectedRegistrationAttemptsQueue;
   private static final Log logger = LogFactory.getLog(HandlingEventRegistrationAttemptConsumer.class);
 
   @Override
   public void onMessage(final Message message) {
     try {
       final ObjectMessage om = (ObjectMessage) message;
-      final HandlingEventRegistrationAttempt attempt = (HandlingEventRegistrationAttempt) om.getObject();
-      try {
-        handlingEventService.register(attempt);
-      } catch (CannotCreateHandlingEventException e) {
-        jmsOperations.send(rejectedRegistrationAttemptsQueue, new MessageCreator() {
-          public Message createMessage(Session session) throws JMSException {
-            
-            return session.createObjectMessage(attempt);
-          }
-        });
-      }
-    } catch (JMSException e) {
+      handlingEventService.register((HandlingEventRegistrationAttempt) om.getObject());
+    } catch (Exception e) {
       logger.error(e, e);
     }
   }
     this.handlingEventService = handlingEventService;
   }
 
-  public void setJmsOperations(JmsOperations jmsOperations) {
-    this.jmsOperations = jmsOperations;
-  }
-
-  public void setRejectedRegistrationAttemptsQueue(Destination rejectedRegistrationAttemptsQueue) {
-    this.rejectedRegistrationAttemptsQueue = rejectedRegistrationAttemptsQueue;
-  }
 }

dddsample/src/main/java/se/citerus/dddsample/application/messaging/JmsSystemEventsImpl.java

+package se.citerus.dddsample.application.messaging;
+
+import org.springframework.jms.core.JmsOperations;
+import org.springframework.jms.core.MessageCreator;
+import se.citerus.dddsample.application.SystemEvents;
+import se.citerus.dddsample.domain.model.cargo.Cargo;
+import se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException;
+import se.citerus.dddsample.domain.model.handling.HandlingEvent;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.Session;
+
+/**
+ * JMS based implementation.
+ */
+public final class JmsSystemEventsImpl implements SystemEvents {
+
+  private JmsOperations jmsOperations;
+  private Destination cargoHandledTopic;
+  private Destination misdirectedCargoTopic;
+  private Destination deliveredCargoTopic;
+  private Destination rejectedRegistrationAttemptsQueue;
+
+  @Override
+  public void cargoWasHandled(final HandlingEvent event) {
+    final Cargo cargo = event.cargo();
+    jmsOperations.send(cargoHandledTopic, new MessageCreator() {
+      public Message createMessage(final Session session) throws JMSException {
+        return session.createTextMessage(cargo.trackingId().idString());
+      }
+    });
+  }
+
+  @Override
+  public void cargoWasMisdirected(final Cargo cargo) {
+    jmsOperations.send(misdirectedCargoTopic, new MessageCreator() {
+      public Message createMessage(Session session) throws JMSException {
+        return session.createTextMessage(cargo.trackingId().idString());
+      }
+    });
+  }
+
+  @Override
+  public void cargoHasArrived(final Cargo cargo) {
+    jmsOperations.send(deliveredCargoTopic, new MessageCreator() {
+      public Message createMessage(Session session) throws JMSException {
+        return session.createTextMessage(cargo.trackingId().idString());
+      }
+    });
+  }
+
+  @Override
+  public void rejectHandlingEventRegistrationAttempt(final HandlingEventRegistrationAttempt attempt, CannotCreateHandlingEventException problem) {
+    // TODO include error message in JMS message
+    jmsOperations.send(rejectedRegistrationAttemptsQueue, new MessageCreator() {
+      public Message createMessage(Session session) throws JMSException {
+        return session.createObjectMessage(attempt);
+      }
+    });
+  }
+
+  public void setJmsOperations(final JmsOperations jmsOperations) {
+    this.jmsOperations = jmsOperations;
+  }
+
+  public void setCargoHandledTopic(final Destination cargoHandledTopic) {
+    this.cargoHandledTopic = cargoHandledTopic;
+  }
+
+  public void setMisdirectedCargoTopic(Destination misdirectedCargoTopic) {
+    this.misdirectedCargoTopic = misdirectedCargoTopic;
+  }
+
+  public void setDeliveredCargoTopic(Destination deliveredCargoTopic) {
+    this.deliveredCargoTopic = deliveredCargoTopic;
+  }
+
+  public void setRejectedRegistrationAttemptsQueue(Destination rejectedRegistrationAttemptsQueue) {
+    this.rejectedRegistrationAttemptsQueue = rejectedRegistrationAttemptsQueue;
+  }
+}

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

   <amq:topic id="misdirectedCargoTopic" name="MisdirectedCargoTopic"/>
   <amq:topic id="deliveredCargoTopic" name="DeliveredCargoTopic"/>
   <amq:queue id="handlingEventRegistrationAttemptQueue" name="HandlingEventRegistrationAttemptQueue"/>
+  <amq:queue id="rejectedRegistrationAttemptsQueue" name="RejectedRegistrationAttemptsQueue"/>
 
   <jms:listener-container connection-factory="jmsConnectionFactory">
     <jms:listener destination="cargoHandledTopic" ref="cargoHandledConsumer" />
     <property name="connectionFactory" ref="jmsConnectionFactory"/>
   </bean>
 
-  <bean id="domainEventNotifier" class="se.citerus.dddsample.application.messaging.JmsDomainEventNotifierImpl">
+  <bean id="systemEvents" class="se.citerus.dddsample.application.messaging.JmsSystemEventsImpl">
     <property name="jmsOperations" ref="jmsOperations"/>
     <property name="cargoHandledTopic" ref="cargoHandledTopic"/>
     <property name="misdirectedCargoTopic" ref="misdirectedCargoTopic"/>
     <property name="deliveredCargoTopic" ref="deliveredCargoTopic"/>
+    <property name="rejectedRegistrationAttemptsQueue" ref="rejectedRegistrationAttemptsQueue"/>
   </bean>
 
   <bean id="cargoHandledConsumer" class="se.citerus.dddsample.application.messaging.CargoHandledConsumer">
   </bean>
 
   <bean id="handlingEventRegistrationAttemptConsumer" class="se.citerus.dddsample.application.messaging.HandlingEventRegistrationAttemptConsumer">
-    <property name="handlingEventFactory" ref="handlingEventFactory"/>
     <property name="handlingEventService" ref="handlingEventService"/>
   </bean>
   

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

 
   <bean id="trackingService" class="se.citerus.dddsample.application.impl.TrackingServiceImpl">
     <constructor-arg ref="cargoRepository"/>
-    <constructor-arg ref="domainEventNotifier"/>
+    <constructor-arg ref="systemEvents"/>
   </bean>
 
   <bean id="handlingEventService" class="se.citerus.dddsample.application.impl.HandlingEventServiceImpl">
     <constructor-arg ref="handlingEventRepository"/>
-    <constructor-arg ref="domainEventNotifier"/>
+    <constructor-arg ref="handlingEventFactory"/>
+    <constructor-arg ref="systemEvents"/>
   </bean>
 
   <bean id="handlingEventFactory" class="se.citerus.dddsample.domain.model.handling.HandlingEventFactory">
     <constructor-arg ref="locationRepository"/>
   </bean>
 
-  <!-- Aplication services below -->
-
   <tx:annotation-driven transaction-manager="transactionManager"/>
 
   <bean id="routingService" class="se.citerus.dddsample.application.routing.ExternalRoutingService">

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

 import se.citerus.dddsample.domain.model.carrier.SampleVoyages;
 import se.citerus.dddsample.domain.model.carrier.VoyageNumber;
 import se.citerus.dddsample.domain.model.carrier.VoyageRepository;
-import se.citerus.dddsample.domain.model.handling.*;
+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.location.LocationRepository;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.location.UnLocode;
-import se.citerus.dddsample.domain.service.DomainEventNotifier;
 
 import java.util.Date;
 
 public class HandlingEventServiceTest extends TestCase {
   private HandlingEventServiceImpl service;
-  private DomainEventNotifier domainEventNotifier;
+  private SystemEvents systemEvents;
   private CargoRepository cargoRepository;
   private VoyageRepository voyageRepository;
   private HandlingEventRepository handlingEventRepository;
     voyageRepository = createMock(VoyageRepository.class);
     handlingEventRepository = createMock(HandlingEventRepository.class);
     locationRepository = createMock(LocationRepository.class);
-    domainEventNotifier = createMock(DomainEventNotifier.class);
+    systemEvents = createMock(SystemEvents.class);
     handlingEventFactory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
-    service = new HandlingEventServiceImpl(handlingEventRepository, domainEventNotifier, handlingEventFactory);
+    service = new HandlingEventServiceImpl(handlingEventRepository, systemEvents, handlingEventFactory);
   }
 
   protected void tearDown() throws Exception {
-    verify(cargoRepository, voyageRepository, handlingEventRepository, domainEventNotifier);
+    verify(cargoRepository, voyageRepository, handlingEventRepository, systemEvents);
   }
 
   public void testRegisterEvent() throws Exception {
 
     // TODO: does not inspect the handling event instance in a sufficient way
     handlingEventRepository.save(isA(HandlingEvent.class));
-    domainEventNotifier.cargoWasHandled(isA(HandlingEvent.class));
+    systemEvents.cargoWasHandled(isA(HandlingEvent.class));
 
-    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, domainEventNotifier);
+    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, systemEvents);
 
     service.register(new HandlingEventRegistrationAttempt(
       new Date(), new Date(), trackingId, voyageNumber, HandlingEvent.Type.LOAD, unLocode
     expect(cargoRepository.find(trackingId)).andReturn(cargoABC);
 
     handlingEventRepository.save(isA(HandlingEvent.class));
-    domainEventNotifier.cargoWasHandled(isA(HandlingEvent.class));
+    systemEvents.cargoWasHandled(isA(HandlingEvent.class));
 
     expect(locationRepository.find(STOCKHOLM.unLocode())).andReturn(STOCKHOLM);
 
-    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, domainEventNotifier);
+    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, systemEvents);
 
     service.register(new HandlingEventRegistrationAttempt(
       new Date(), new Date(), trackingId, null, HandlingEvent.Type.RECEIVE, STOCKHOLM.unLocode()
     expect(cargoRepository.find(trackingId)).andReturn(new Cargo(trackingId, CHICAGO, STOCKHOLM));
 
     expect(locationRepository.find(MELBOURNE.unLocode())).andReturn(MELBOURNE);
+
+    systemEvents.rejectHandlingEventRegistrationAttempt(isA(HandlingEventRegistrationAttempt.class), isA(CannotCreateHandlingEventException.class));
+
+    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, systemEvents);
     
-    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, domainEventNotifier);
-    
-    try {
-      service.register(new HandlingEventRegistrationAttempt(
-        new Date(), new Date(), trackingId, voyageNumber, HandlingEvent.Type.UNLOAD, MELBOURNE.unLocode()
-      ));
-      fail("Should not be able to register an event with non-existing carrier movement");
-    } catch (UnknownVoyageException expected) {}
+    service.register(new HandlingEventRegistrationAttempt(
+      new Date(), new Date(), trackingId, voyageNumber, HandlingEvent.Type.UNLOAD, MELBOURNE.unLocode()
+    ));
   }
   
   public void testRegisterEventInvalidCargo() throws Exception {
     expect(cargoRepository.find(trackingId)).andReturn(null);
 
     expect(locationRepository.find(HONGKONG.unLocode())).andReturn(HONGKONG);
+
+    systemEvents.rejectHandlingEventRegistrationAttempt(isA(HandlingEventRegistrationAttempt.class), isA(CannotCreateHandlingEventException.class));
+
+    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, systemEvents);
     
-    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, domainEventNotifier);
-    
-    try {
       service.register(new HandlingEventRegistrationAttempt(
         new Date(), new Date(), trackingId, new VoyageNumber("V001"), HandlingEvent.Type.CLAIM, HONGKONG.unLocode()
       ));
-      fail("Should not be able to register an event with non-existing cargo");
-    } catch (UnknownCargoException expected) {}
   }
   
   public void testRegisterEventInvalidLocation() throws Exception {
     expect(cargoRepository.find(trackingId)).andReturn(cargoXYZ);
     UnLocode wayOff = new UnLocode("XXYYY");
     expect(locationRepository.find(wayOff)).andReturn(null);
+
+    systemEvents.rejectHandlingEventRegistrationAttempt(isA(HandlingEventRegistrationAttempt.class), isA(CannotCreateHandlingEventException.class));
+
+    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, systemEvents);
     
-    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, domainEventNotifier);
-    
-    try {
-      service.register(new HandlingEventRegistrationAttempt(
-        new Date(), new Date(), trackingId, null, HandlingEvent.Type.CLAIM, wayOff
-      ));
-      fail("Should not be able to register an event with non-existing Location");
-    } catch (UnknownLocationException expected) {}
+    service.register(new HandlingEventRegistrationAttempt(
+      new Date(), new Date(), trackingId, null, HandlingEvent.Type.CLAIM, wayOff
+    ));
   }
 }

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

 
 import junit.framework.TestCase;
 import se.citerus.dddsample.application.HandlingEventService;
+import se.citerus.dddsample.application.SystemEvents;
 import se.citerus.dddsample.application.TrackingService;
 import se.citerus.dddsample.application.impl.HandlingEventServiceImpl;
 import se.citerus.dddsample.application.impl.TrackingServiceImpl;
 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.*;
-import se.citerus.dddsample.domain.service.DomainEventNotifier;
 import se.citerus.dddsample.domain.service.RoutingService;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.VoyageRepositoryInMem;
 
   HandlingEventFactory handlingEventFactory;
 
-  DomainEventNotifier domainEventNotifier;
+  SystemEvents systemEvents;
 
   HandlingEventService handlingEventService;
   TrackingService trackingService;
     };
 
     // Synchronous stub
-    domainEventNotifier = new DomainEventNotifier() {
+    systemEvents = new SystemEvents() {
+      @Override
       public void cargoWasHandled(HandlingEvent event) {
         trackingService.onCargoHandled(event.cargo().trackingId());
       }
+      @Override
       public void cargoWasMisdirected(Cargo cargo) {}
+      @Override
       public void cargoHasArrived(Cargo cargo) {}
-      public void rejectHandlingEventRegistrationAttempt(CannotCreateHandlingEventException e) {}
+      @Override
+      public void rejectHandlingEventRegistrationAttempt(HandlingEventRegistrationAttempt attempt, CannotCreateHandlingEventException problem) {}
     };
 
     // Stub
     voyageRepository = new VoyageRepositoryInMem();
 
     // Domain services and factories that are implemented in the domain layer - not stubbed
-    trackingService = new TrackingServiceImpl(domainEventNotifier, cargoRepository);
+    trackingService = new TrackingServiceImpl(systemEvents, cargoRepository);
     handlingEventFactory = new HandlingEventFactory(cargoRepository, this.voyageRepository, this.locationRepository);
-    handlingEventService = new HandlingEventServiceImpl(handlingEventRepository, domainEventNotifier, handlingEventFactory);
+    handlingEventService = new HandlingEventServiceImpl(handlingEventRepository, systemEvents, handlingEventFactory);
   }
 }