Merge branch 'dataMining' into polar-api

Conflicts:
	java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/DynamicTrackedRegatta.java
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java
	java/com.sap.sailing.mongodb.test/META-INF/MANIFEST.MF
	java/com.sap.sailing.polars/src/com/sap/sailing/polars/aggregation/PolarFixAggregationWorker.java
	java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/RestApiApplication.java
	java/com.sap.sailing.server.replication.test/META-INF/MANIFEST.MF
	java/com.sap.sailing.server/META-INF/MANIFEST.MF
	java/com.sap.sailing.server/SailingServer (No Proxy).launch
	java/com.sap.sailing.server/SailingServer (No Proxy, Jetty on 8889).launch
	java/com.sap.sailing.server/SailingServer (No Proxy, Jetty on 8889, Cached MTB).launch
	java/com.sap.sailing.server/SailingServer (No Proxy, No Tests).launch
	java/com.sap.sailing.server/SailingServer (No Proxy, Remote Debug SAP VM).launch
	java/com.sap.sailing.server/SailingServer (No Proxy, winddbTest).launch
	java/com.sap.sailing.server/SailingServer (Proxy).launch
	java/com.sap.sailing.server/SailingServer (Proxy, Jetty on 8889).launch
	java/com.sap.sailing.server/SailingServer (Proxy, Remote Debug SAP VM).launch
	java/com.sap.sailing.server/SailingServer (Proxy, SwissTiming Live Simulation).launch
	java/com.sap.sailing.server/SailingServer (Proxy, winddbTest).launch
	java/com.sap.sailing.server/src/com/sap/sailing/server/RacingEventService.java
	java/com.sap.sailing.server/src/com/sap/sailing/server/impl/RacingEventServiceImpl.java
	java/com.sap.sse.datamining/META-INF/MANIFEST.MF

java/com.sap.sailing.mongodb.test/META-INF/MANIFEST.MF

@@ -20,6 +20,10 @@ Require-Bundle: com.sap.sailing.domain,
  org.junit4;bundle-version="4.8.2",
  org.hamcrest;bundle-version="1.1.0",
  org.mockito.mockito-core;bundle-version="1.9.5",
- com.sap.sailing.polars;bundle-version="1.0.0"
-Import-Package: com.sap.sailing.domain.common.impl
+ com.sap.sailing.polars;bundle-version="1.0.0",
+ com.sap.sailing.domain.racelogtrackingadapter.testsupport,
+ com.sap.sailing.server.gateway;bundle-version="1.0.0",
+ com.sap.sse.common
+Import-Package: com.sap.sailing.domain.common.impl,
+ com.sap.sailing.domain.common.racelog.tracking
 

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/CollectionNameServiceTest.java

@@ -6,20 +6,20 @@ import com.sap.sailing.mongodb.AlreadyRegisteredException;
 import com.sap.sailing.mongodb.MongoDBService;
 
 public class CollectionNameServiceTest {
-	
-	@Test
-	public void shouldWork() throws AlreadyRegisteredException {
-		MongoDBService service = MongoDBService.INSTANCE;
-		service.registerExclusively(TestInterface.class, "a");
-		service.registerExclusively(TestInterface.class, "b");
-		service.registerExclusively(TestInterface.class, "B");
-		service.registerExclusively(TestInterface.class, "B");
-	}
-	
-	@Test(expected=AlreadyRegisteredException.class)
-	public void shouldNotWork() throws AlreadyRegisteredException {
-		MongoDBService service = MongoDBService.INSTANCE;
-		service.registerExclusively(TestInterface.class, "b");
-		service.registerExclusively(com.sap.sailing.mongodb.test.needadifferentpackage.TestInterface.class, "b");
-	}
+
+    @Test
+    public void shouldWork() throws AlreadyRegisteredException {
+        MongoDBService service = MongoDBService.INSTANCE;
+        service.registerExclusively(TestInterface.class, "a");
+        service.registerExclusively(TestInterface.class, "b");
+        service.registerExclusively(TestInterface.class, "B");
+        service.registerExclusively(TestInterface.class, "B");
+    }
+
+    @Test(expected=AlreadyRegisteredException.class)
+    public void shouldNotWork() throws AlreadyRegisteredException {
+        MongoDBService service = MongoDBService.INSTANCE;
+        service.registerExclusively(TestInterface.class, "b");
+        service.registerExclusively(com.sap.sailing.mongodb.test.needadifferentpackage.TestInterface.class, "b");
+    }
 }

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/StoreAndLoadDeviceConfigurationsTest.java

@@ -17,10 +17,10 @@ import com.sap.sailing.domain.base.configuration.DeviceConfigurationMatcher;
 import com.sap.sailing.domain.base.configuration.impl.DeviceConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.DeviceConfigurationMatcherSingle;
 import com.sap.sailing.domain.base.configuration.impl.RegattaConfigurationImpl;
-import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.persistence.PersistenceFactory;
 import com.sap.sailing.domain.persistence.impl.DomainObjectFactoryImpl;
 import com.sap.sailing.domain.persistence.impl.MongoObjectFactoryImpl;
+import com.sap.sse.common.Util;
 
 public class StoreAndLoadDeviceConfigurationsTest extends AbstractMongoDBTest {
 

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/StoreAndLoadDeviceIdentifierTest.java

@@ -0,0 +1,149 @@
+package com.sap.sailing.mongodb.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.net.UnknownHostException;
+import java.util.UUID;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.mongodb.MongoException;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.DomainFactory;
+import com.sap.sailing.domain.base.impl.CompetitorImpl;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegisteredException;
+import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinderFactory;
+import com.sap.sailing.domain.persistence.PersistenceFactory;
+import com.sap.sailing.domain.persistence.impl.DomainObjectFactoryImpl;
+import com.sap.sailing.domain.persistence.impl.MongoObjectFactoryImpl;
+import com.sap.sailing.domain.persistence.impl.MongoRaceLogStoreImpl;
+import com.sap.sailing.domain.racelog.RaceLog;
+import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
+import com.sap.sailing.domain.racelog.RaceLogEventFactory;
+import com.sap.sailing.domain.racelog.RaceLogIdentifier;
+import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
+import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.PlaceHolderDeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockEmptyServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifierImpl;
+import com.sap.sse.common.Util;
+
+public class StoreAndLoadDeviceIdentifierTest extends AbstractMongoDBTest {
+    public StoreAndLoadDeviceIdentifierTest() throws UnknownHostException, MongoException {
+        super();
+    }
+
+    protected static final String group = "group";
+    protected static final String column = "column";
+    protected static final String fleet = "fleet";
+    protected final RaceLogEventAuthor author = new RaceLogEventAuthorImpl("author", 0);
+    protected RaceLogIdentifier logIdentifier;
+
+    protected MongoObjectFactoryImpl mongoFactory;
+    protected DomainObjectFactoryImpl domainFactory;
+    protected RaceLog raceLog;
+    
+    private TimePoint now() {
+        return MillisecondsTimePoint.now();
+    }
+    
+    @Before
+    public void setup() throws UnknownHostException, MongoException, InterruptedException {
+        dropTestDB();
+
+        logIdentifier = mock(RaceLogIdentifier.class);
+        com.sap.sse.common.Util.Triple<String, String, String> triple = new com.sap.sse.common.Util.Triple<String, String, String>("a", "b", UUID.randomUUID().toString());
+        when(logIdentifier.getIdentifier()).thenReturn(triple);
+        when(logIdentifier.getDeprecatedIdentifier()).thenReturn("");
+    }
+    
+    private RaceLog loadRaceLog() {        
+        return new MongoRaceLogStoreImpl(mongoFactory, domainFactory).getRaceLog(logIdentifier, true);
+    }
+    
+    private void createFactories(TypeBasedServiceFinderFactory factory) {
+        mongoFactory = (MongoObjectFactoryImpl) PersistenceFactory.INSTANCE
+                .getMongoObjectFactory(getMongoService(), factory);
+        domainFactory = (DomainObjectFactoryImpl) PersistenceFactory.INSTANCE
+                .getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE, factory);
+
+        raceLog = loadRaceLog();
+    }
+    
+    private DeviceIdentifier storeAndLoad(DeviceIdentifier device, TypeBasedServiceFinderFactory forStoring, TypeBasedServiceFinderFactory forLoading) {
+        createFactories(forStoring);
+        Competitor c = new CompetitorImpl("a", "a", null, null, null);
+        
+        raceLog.add(RaceLogEventFactory.INSTANCE.createDeviceCompetitorMappingEvent(now(), author, device,
+                c, 0, now(), now()));
+        
+        createFactories(forLoading);
+        
+        RaceLog loadedRaceLog = loadRaceLog();
+        loadedRaceLog.lockForRead();
+        assertEquals(1, Util.size(loadedRaceLog.getRawFixes()));
+        DeviceCompetitorMappingEvent mapping = (DeviceCompetitorMappingEvent) loadedRaceLog.getRawFixes().iterator().next();
+        loadedRaceLog.unlockAfterRead();
+        
+        return mapping.getDevice();
+    }
+    
+    @Test
+    public void testNormal() throws TransformationException, NoCorrespondingServiceRegisteredException {
+        TypeBasedServiceFinderFactory factory = new MockSmartphoneImeiServiceFinderFactory();
+
+        DeviceIdentifier smartphone = new SmartphoneImeiIdentifier("abc");
+        DeviceIdentifier loaded = storeAndLoad(smartphone, factory, factory);
+        
+        assertEquals(smartphone, loaded);
+    }
+    
+    @Test
+    public void testNoAppropriateDeserializer() throws TransformationException, NoCorrespondingServiceRegisteredException {
+        TypeBasedServiceFinderFactory forStoring = new MockSmartphoneImeiServiceFinderFactory();
+        TypeBasedServiceFinderFactory forLoading = new MockEmptyServiceFinderFactory();
+
+        DeviceIdentifier smartphone = new SmartphoneImeiIdentifier("abc");
+        DeviceIdentifier loaded = storeAndLoad(smartphone, forStoring, forLoading);
+        
+        assertTrue(loaded instanceof PlaceHolderDeviceIdentifier);
+        assertEquals(smartphone.getIdentifierType(), loaded.getIdentifierType());
+        assertEquals(smartphone.getStringRepresentation(), loaded.getStringRepresentation());
+    }
+    
+    @Test
+    public void testUseStringRepForDeserializing() throws TransformationException, NoCorrespondingServiceRegisteredException {
+        TypeBasedServiceFinderFactory forLoading = new MockSmartphoneImeiServiceFinderFactory();
+        TypeBasedServiceFinderFactory forStoring = new MockEmptyServiceFinderFactory();
+
+        DeviceIdentifier smartphone = new SmartphoneImeiIdentifier("abc");
+        DeviceIdentifier loaded = storeAndLoad(smartphone, forStoring, forLoading);
+        
+        //smartphone imei identifier can be restored from string rep
+        assertTrue(loaded instanceof SmartphoneImeiIdentifier);
+        assertEquals(smartphone.getIdentifierType(), loaded.getIdentifierType());
+        assertEquals(smartphone.getStringRepresentation(), loaded.getStringRepresentation());
+    }
+    
+    @Test
+    public void testNoAppropriateSerializer() throws TransformationException, NoCorrespondingServiceRegisteredException {
+        TypeBasedServiceFinderFactory forLoading = new MockSmartphoneImeiServiceFinderFactory();
+        TypeBasedServiceFinderFactory forStoring = new MockEmptyServiceFinderFactory();
+        
+        DeviceIdentifier trackFile = new TrackFileImportDeviceIdentifierImpl("FILE", "track");
+        DeviceIdentifier loaded = storeAndLoad(trackFile, forStoring, forLoading);
+        assertTrue(loaded instanceof PlaceHolderDeviceIdentifier);
+        assertEquals(trackFile.getIdentifierType(), loaded.getIdentifierType());
+        assertEquals(trackFile.getStringRepresentation(), loaded.getStringRepresentation());
+    }
+}

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/StoreAndLoadRaceLogEventsTest.java

@@ -1,6 +1,9 @@
 package com.sap.sailing.mongodb.test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -15,12 +18,12 @@ import org.junit.Test;
 
 import com.mongodb.DBObject;
 import com.mongodb.MongoException;
+import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.DomainFactory;
+import com.sap.sailing.domain.base.Mark;
 import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
-import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sailing.domain.persistence.PersistenceFactory;
@@ -30,21 +33,33 @@ import com.sap.sailing.domain.persistence.impl.MongoObjectFactoryImpl;
 import com.sap.sailing.domain.racelog.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogEvent;
 import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
-import com.sap.sailing.domain.racelog.RaceLogEventFactory;
+import com.sap.sailing.domain.racelog.RaceLogEventRestoreFactory;
 import com.sap.sailing.domain.racelog.RaceLogFlagEvent;
 import com.sap.sailing.domain.racelog.RaceLogIdentifier;
 import com.sap.sailing.domain.racelog.RaceLogPassChangeEvent;
 import com.sap.sailing.domain.racelog.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
+import com.sap.sailing.domain.racelog.RevokeEvent;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
+import com.sap.sailing.domain.racelog.tracking.CloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
+import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
+import com.sap.sse.common.Util;
 
 public class StoreAndLoadRaceLogEventsTest extends AbstractMongoDBTest {
 
     protected MongoObjectFactoryImpl mongoFactory = (MongoObjectFactoryImpl) PersistenceFactory.INSTANCE
-            .getMongoObjectFactory(getMongoService());
+            .getMongoObjectFactory(getMongoService(), new MockSmartphoneImeiServiceFinderFactory());
     protected DomainObjectFactoryImpl domainFactory = (DomainObjectFactoryImpl) PersistenceFactory.INSTANCE
-            .getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE);
-    protected RaceLogEventFactory eventFactory = RaceLogEventFactory.INSTANCE;
+            .getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE,
+            		new MockSmartphoneImeiServiceFinderFactory());
+    protected RaceLogEventRestoreFactory eventFactory = RaceLogEventRestoreFactory.INSTANCE;
 
     protected RaceLogIdentifier logIdentifier;
 
@@ -61,7 +76,7 @@ public class StoreAndLoadRaceLogEventsTest extends AbstractMongoDBTest {
     @Before
     public void setUp() {
         logIdentifier = mock(RaceLogIdentifier.class);
-        when(logIdentifier.getIdentifier()).thenReturn(new Triple<String, String, String>("a", "b", UUID.randomUUID().toString()));
+        when(logIdentifier.getIdentifier()).thenReturn(new com.sap.sse.common.Util.Triple<String, String, String>("a", "b", UUID.randomUUID().toString()));
     }
 
     public void assertBaseFields(RaceLogEvent expectedEvent, RaceLogEvent actualEvent) {
@@ -156,6 +171,115 @@ public class StoreAndLoadRaceLogEventsTest extends AbstractMongoDBTest {
         assertEquals(startTime, actualEvent.getStartTime());
     }
 
+    @Test
+    public void testStoreAndLoadDeviceCompetitorMappingEvent() {
+        DeviceIdentifier device = new SmartphoneImeiIdentifier("a");
+        Competitor mappedTo = DomainFactory.INSTANCE.getOrCreateCompetitor("abc", "abc", null, null, null);
+        TimePoint from = new MillisecondsTimePoint(20);
+        TimePoint to = new MillisecondsTimePoint(30);
+        DeviceCompetitorMappingEvent expectedEvent = eventFactory.createDeviceCompetitorMappingEvent(
+        		expectedEventTime, author, expectedEventTime, expectedId, device, mappedTo, expectedPassId, from, to);
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        DeviceCompetitorMappingEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(device, actualEvent.getDevice());
+        assertEquals(from, actualEvent.getFrom());
+        assertEquals(to, actualEvent.getTo());
+        assertEquals(mappedTo, actualEvent.getMappedTo());
+    }
+
+    @Test
+    public void testStoreAndLoadDeviceMarkMappingEvent() {
+        DeviceIdentifier device = new SmartphoneImeiIdentifier("a");
+        Mark mappedTo = DomainFactory.INSTANCE.getOrCreateMark("abc", "abc");
+        TimePoint from = new MillisecondsTimePoint(20);
+        TimePoint to = new MillisecondsTimePoint(30);
+        DeviceMarkMappingEvent expectedEvent = eventFactory.createDeviceMarkMappingEvent(
+        		expectedEventTime, author, expectedEventTime, expectedId, device, mappedTo, expectedPassId, from, to);
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        DeviceMarkMappingEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(device, actualEvent.getDevice());
+        assertEquals(from, actualEvent.getFrom());
+        assertEquals(to, actualEvent.getTo());
+        assertEquals(mappedTo, actualEvent.getMappedTo());
+    }
+
+    @Test
+    public void testStoreAndLoadDenoteForTrackingEvent() {
+    	String raceName = "race";
+    	BoatClass boatClass = DomainFactory.INSTANCE.getOrCreateBoatClass("49er");
+    	UUID raceId = UUID.randomUUID();
+        DenoteForTrackingEvent expectedEvent = eventFactory.createDenoteForTrackingEvent(
+        		expectedEventTime, author, expectedEventTime, expectedId, expectedPassId, raceName, boatClass,
+        		raceId);
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        DenoteForTrackingEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(boatClass, actualEvent.getBoatClass());
+        assertEquals(raceName, actualEvent.getRaceName());
+        assertEquals(raceId, actualEvent.getRaceId());
+    }
+
+    @Test
+    public void testStoreAndLoadRevokeEvent() {
+        UUID revokedEventId = UUID.randomUUID();
+        RevokeEvent expectedEvent = eventFactory.createRevokeEvent(
+        		expectedEventTime, author, expectedEventTime, expectedId, expectedPassId, revokedEventId);
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        RevokeEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(revokedEventId, actualEvent.getRevokedEventId());
+    }
+
+    @Test
+    public void testStoreAndLoadRegisterCompetitorEvent() {
+        RegisterCompetitorEvent expectedEvent = eventFactory.createRegisterCompetitorEvent(
+        		expectedEventTime, author, expectedEventTime, expectedId, expectedPassId,
+        		DomainFactory.INSTANCE.getOrCreateCompetitor("comp", "comp", null, null, null));
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        RegisterCompetitorEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(expectedEvent.getCompetitor(), actualEvent.getCompetitor());
+    }
+
+    @Test
+    public void testStoreAndLoadDefineMarkEvent() {
+        DefineMarkEvent expectedEvent = eventFactory.createDefineMarkEvent(
+                        expectedEventTime, author, expectedEventTime, expectedId, expectedPassId,
+                        DomainFactory.INSTANCE.getOrCreateMark("mytestmark"));
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        DefineMarkEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(expectedEvent.getMark(), actualEvent.getMark());
+    }
+
+    @Test
+    public void testStoreAndLoadCloseOpenDeviceMappingEvent() {
+        CloseOpenEndedDeviceMappingEvent expectedEvent = eventFactory.createCloseOpenEndedDeviceMappingEvent(
+                        expectedEventTime, author, expectedEventTime, expectedId, expectedPassId,
+                        UUID.randomUUID(), new MillisecondsTimePoint(49));
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        CloseOpenEndedDeviceMappingEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(expectedEvent.getDeviceMappingEventId(), actualEvent.getDeviceMappingEventId());
+        assertEquals(expectedEvent.getClosingTimePoint(), actualEvent.getClosingTimePoint());
+    }
+
     /**
      * Will always wait a couple of milliseconds to ensure that {@link RaceLogEvent#getCreatedAt()} has passed.
      */

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/StoreAndLoadRaceLogsTest.java

@@ -22,7 +22,6 @@ import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.base.Fleet;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.persistence.PersistenceFactory;
 import com.sap.sailing.domain.persistence.impl.DomainObjectFactoryImpl;
@@ -36,6 +35,7 @@ import com.sap.sailing.domain.racelog.RaceLogIdentifier;
 import com.sap.sailing.domain.racelog.RaceLogIdentifierTemplate;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
 import com.sap.sailing.domain.racelog.impl.RaceLogIdentifierImpl;
+import com.sap.sse.common.Util;
 
 public class StoreAndLoadRaceLogsTest extends AbstractMongoDBTest {
 

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/StoreCompetitorTest.java

@@ -11,12 +11,12 @@ import com.mongodb.DB;
 import com.mongodb.MongoException;
 import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.base.impl.DynamicCompetitor;
-import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.persistence.DomainObjectFactory;
 import com.sap.sailing.domain.persistence.MongoObjectFactory;
 import com.sap.sailing.domain.persistence.PersistenceFactory;
 import com.sap.sailing.domain.persistence.impl.CollectionNames;
 import com.sap.sailing.domain.test.AbstractLeaderboardTest;
+import com.sap.sse.common.Util;
 
 public class StoreCompetitorTest extends AbstractMongoDBTest {
 

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/StoreGPSFixTrackTest.java

@@ -0,0 +1,103 @@
+package com.sap.sailing.mongodb.test;
+
+import static junit.framework.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+import java.net.UnknownHostException;
+
+import org.junit.After;
+import org.junit.Test;
+
+import com.mongodb.DB;
+import com.mongodb.MongoException;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.DomainFactory;
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.impl.KnotSpeedWithBearingImpl;
+import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegisteredException;
+import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinderFactory;
+import com.sap.sailing.domain.persistence.DomainObjectFactory;
+import com.sap.sailing.domain.persistence.MongoObjectFactory;
+import com.sap.sailing.domain.persistence.PersistenceFactory;
+import com.sap.sailing.domain.persistence.impl.CollectionNames;
+import com.sap.sailing.domain.persistence.racelog.tracking.impl.MongoGPSFixStoreImpl;
+import com.sap.sailing.domain.racelog.RaceLog;
+import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
+import com.sap.sailing.domain.racelog.RaceLogEventFactory;
+import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
+import com.sap.sailing.domain.racelog.impl.RaceLogImpl;
+import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
+import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
+import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.tracking.GPSFix;
+import com.sap.sailing.domain.tracking.GPSFixMoving;
+import com.sap.sailing.domain.tracking.impl.DynamicGPSFixMovingTrackImpl;
+import com.sap.sailing.domain.tracking.impl.DynamicGPSFixTrackImpl;
+import com.sap.sailing.domain.tracking.impl.GPSFixImpl;
+import com.sap.sailing.domain.tracking.impl.GPSFixMovingImpl;
+import com.sap.sse.common.Util;
+
+public class StoreGPSFixTrackTest extends AbstractMongoDBTest {
+    public StoreGPSFixTrackTest() throws UnknownHostException, MongoException {
+		super();
+	}
+
+    @After
+	public void dropCollection() {
+        DB db = getMongoService().getDB();
+        db.getCollection(CollectionNames.GPS_FIXES.name()).drop();
+    }
+    
+    @Test
+    public void testStoreAndLoadFixes() throws TransformationException, NoCorrespondingServiceRegisteredException {
+    	TypeBasedServiceFinderFactory factory = new MockSmartphoneImeiServiceFinderFactory();
+    	RaceLogEventAuthor author = new RaceLogEventAuthorImpl("author", 0);
+    	Competitor comp = DomainFactory.INSTANCE.getOrCreateCompetitor("comp", "comp", null, null, null);
+    	Mark mark = DomainFactory.INSTANCE.getOrCreateMark("mark");
+        MongoObjectFactory mongoObjectFactory = PersistenceFactory.INSTANCE.getMongoObjectFactory(getMongoService(), factory);
+        DomainObjectFactory domainObjectFactory = PersistenceFactory.INSTANCE.getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE, factory);
+        GPSFixStore store = new MongoGPSFixStoreImpl(mongoObjectFactory, domainObjectFactory, factory);
+        
+        TimePoint time0 = new MillisecondsTimePoint(0);
+        TimePoint time1 = new MillisecondsTimePoint(1);
+        TimePoint time2 = new MillisecondsTimePoint(2);
+        
+        GPSFixMoving fix1 = new GPSFixMovingImpl(new DegreePosition(30, 40), time0,
+        		new KnotSpeedWithBearingImpl(0, new DegreeBearingImpl(0)));
+        GPSFixMoving fix2 = new GPSFixMovingImpl(new DegreePosition(30, 40), time1,
+        		new KnotSpeedWithBearingImpl(0, new DegreeBearingImpl(0)));
+        //lies outside of mapping range
+        GPSFixMoving fix3 = new GPSFixMovingImpl(new DegreePosition(30, 40), time2,
+        		new KnotSpeedWithBearingImpl(0, new DegreeBearingImpl(0)));
+        DeviceIdentifier device1 = new SmartphoneImeiIdentifier("a");
+        store.storeFix(device1, fix1);
+        store.storeFix(device1, fix2);
+        store.storeFix(device1, fix3);
+        
+        GPSFix fix4 = new GPSFixImpl(new DegreePosition(40, 50), time0);
+        DeviceIdentifier device2 = new SmartphoneImeiIdentifier("b");
+        store.storeFix(device2, fix4);
+        
+        RaceLog raceLog = new RaceLogImpl("racelog");
+        raceLog.add(RaceLogEventFactory.INSTANCE.createDeviceCompetitorMappingEvent(time0, author, device1, comp, 0, time0, time1));
+        raceLog.add(RaceLogEventFactory.INSTANCE.createDeviceMarkMappingEvent(time0, author, device2, mark, 0, time0, time1));
+        
+        DynamicGPSFixMovingTrackImpl<Competitor> track1 = new DynamicGPSFixMovingTrackImpl<>(comp, 0);
+        store.loadCompetitorTrack(track1, raceLog, comp);
+        DynamicGPSFixTrackImpl<Mark> track2 = new DynamicGPSFixTrackImpl<>(mark, 0);
+        store.loadMarkTrack(track2, raceLog, mark);
+        track1.lockForRead();
+        assertEquals(2, Util.size(track1.getRawFixes()));
+        assertTrue(track1.getFirstRawFix() instanceof GPSFixMoving);
+        track1.unlockAfterRead();
+        track2.lockForRead();
+        assertEquals(1, Util.size(track2.getRawFixes()));
+        track2.unlockAfterRead();
+    }
+}

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestRaceLogRemovalInRegatta.java

@@ -13,11 +13,11 @@ import com.sap.sailing.domain.base.Fleet;
 import com.sap.sailing.domain.base.Series;
 import com.sap.sailing.domain.base.impl.FleetImpl;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.racelog.RaceLog;
 import com.sap.sailing.domain.racelog.RaceLogEventFactory;
 import com.sap.sailing.domain.racelog.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
+import com.sap.sse.common.Util;
 
 public class TestRaceLogRemovalInRegatta extends AbstractTestStoringAndRetrievingRaceLogInRegatta {
     private final String blueFleetName = "Blue";

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestStoringAndLoadingEventsAndRegattas.java

@@ -8,6 +8,9 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
+import java.io.Serializable;
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -53,13 +56,16 @@ import com.sap.sailing.domain.common.RegattaNameAndRaceName;
 import com.sap.sailing.domain.common.ScoringSchemeType;
 import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
+import com.sap.sailing.domain.leaderboard.EventResolver;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
+import com.sap.sailing.domain.leaderboard.LeaderboardGroupResolver;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
 import com.sap.sailing.domain.leaderboard.ScoringScheme;
 import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
 import com.sap.sailing.domain.leaderboard.impl.HighPoint;
+import com.sap.sailing.domain.leaderboard.impl.LeaderboardGroupImpl;
 import com.sap.sailing.domain.leaderboard.impl.LowPoint;
 import com.sap.sailing.domain.leaderboard.impl.ThresholdBasedResultDiscardingRuleImpl;
 import com.sap.sailing.domain.persistence.DomainObjectFactory;
@@ -67,6 +73,7 @@ import com.sap.sailing.domain.persistence.MongoObjectFactory;
 import com.sap.sailing.domain.persistence.PersistenceFactory;
 import com.sap.sailing.domain.persistence.impl.CollectionNames;
 import com.sap.sailing.domain.persistence.media.MediaDBFactory;
+import com.sap.sailing.domain.racelog.tracking.EmptyGPSFixStore;
 import com.sap.sailing.domain.test.AbstractLeaderboardTest;
 import com.sap.sailing.domain.test.mock.MockedTrackedRaceWithFixedRank;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
@@ -77,6 +84,7 @@ import com.sap.sailing.server.RacingEventService;
 import com.sap.sailing.server.impl.RacingEventServiceImpl;
 import com.sap.sailing.server.operationaltransformation.ConnectTrackedRaceToLeaderboardColumn;
 import com.sap.sailing.server.operationaltransformation.UpdateLeaderboardMaxPointsReason;
+import com.sap.sse.common.Util;
 
 public class TestStoringAndLoadingEventsAndRegattas extends AbstractMongoDBTest {
     private static final Logger logger = Logger.getLogger(TestStoringAndLoadingEventsAndRegattas.class.getName());
@@ -84,9 +92,13 @@ public class TestStoringAndLoadingEventsAndRegattas extends AbstractMongoDBTest
     public TestStoringAndLoadingEventsAndRegattas() throws UnknownHostException, MongoException {
         super();
     }
+    
+    private LeaderboardGroup createLeaderboardGroup(String name) {
+        return new LeaderboardGroupImpl(name, "Description for "+name, /* displayInReverseOrder */ false, Collections.<Leaderboard>emptyList());
+    }
 
     @Test
-    public void testLoadStoreSimpleEvent() {
+    public void testLoadStoreSimpleEventWithLinkToLeaderboardGroups() throws MalformedURLException {
         final String eventName = "Event Name";
         final String venueName = "Venue Name";
         final String[] courseAreaNames = new String[] { "Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrott" };
@@ -103,13 +115,41 @@ public class TestStoringAndLoadingEventsAndRegattas extends AbstractMongoDBTest
             venue.addCourseArea(courseArea);
         }
         MongoObjectFactory mof = PersistenceFactory.INSTANCE.getMongoObjectFactory(getMongoService());
-        Event event = new EventImpl(eventName, startDate, endDate, venue, /*isPublic*/ true, UUID.randomUUID());
+        final Event event = new EventImpl(eventName, startDate, endDate, venue, /*isPublic*/ true, UUID.randomUUID());
+        final LeaderboardGroup lg1 = createLeaderboardGroup("lg1");
+        final LeaderboardGroup lg2 = createLeaderboardGroup("lg2");
+        event.addLeaderboardGroup(lg1);
+        event.addLeaderboardGroup(lg2);
+        event.addImageURL(new URL("http://some.host/with/some/file1.jpg"));
+        event.addImageURL(new URL("http://some.host/with/some/file2.jpg"));
+        event.addVideoURL(new URL("http://some.host/with/some/file1.mp4"));
+        event.addVideoURL(new URL("http://some.host/with/some/file2.mp4"));
         mof.storeEvent(event);
         
         DomainObjectFactory dof = PersistenceFactory.INSTANCE.getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE);
-        Event loadedEvent = dof.loadEvent(eventName);
+        final Event loadedEvent = dof.loadEvent(eventName);
+        dof.loadLeaderboardGroupLinksForEvents(new EventResolver() {
+            @Override
+            public Event getEvent(Serializable id) {
+                return id.equals(loadedEvent.getId()) ? loadedEvent : null;
+            }
+        }, new LeaderboardGroupResolver() {
+            @Override
+            public LeaderboardGroup getLeaderboardGroupByName(String leaderboardGroupName) {
+                return leaderboardGroupName.equals(lg1.getName()) ? lg1 : leaderboardGroupName.equals(lg2.getName()) ? lg2 : null;
+            }
+            
+            @Override
+            public LeaderboardGroup getLeaderboardGroupByID(UUID leaderboardGroupID) {
+                return leaderboardGroupID.equals(lg1.getId()) ? lg1 : leaderboardGroupID.equals(lg2.getId()) ? lg2 : null;
+            }
+        });
         assertNotNull(loadedEvent);
         assertEquals(eventName, loadedEvent.getName());
+        assertEquals(2, Util.size(loadedEvent.getLeaderboardGroups()));
+        Iterator<LeaderboardGroup> lgIter = loadedEvent.getLeaderboardGroups().iterator();
+        assertSame(lg1, lgIter.next());
+        assertSame(lg2, lgIter.next());
         final Venue loadedVenue = loadedEvent.getVenue();
         assertNotNull(loadedVenue);
         assertEquals(venueName, loadedVenue.getName());
@@ -118,6 +158,8 @@ public class TestStoringAndLoadingEventsAndRegattas extends AbstractMongoDBTest
         for (CourseArea loadedCourseArea : loadedVenue.getCourseAreas()) {
             assertEquals(courseAreaNames[i++], loadedCourseArea.getName());
         }
+        assertTrue("image URLs "+loadedEvent.getImageURLs()+" but expected "+event.getImageURLs(), Util.equals(event.getImageURLs(), loadedEvent.getImageURLs()));
+        assertTrue("video URLs "+loadedEvent.getVideoURLs()+" but expected "+event.getVideoURLs(), Util.equals(event.getVideoURLs(), loadedEvent.getVideoURLs()));
     }
     
     @Test
@@ -177,7 +219,7 @@ public class TestStoringAndLoadingEventsAndRegattas extends AbstractMongoDBTest
     @Test
     public void testLoadStoreSimpleRegattaLeaderboard() {
         RacingEventService res = new RacingEventServiceImpl(PersistenceFactory.INSTANCE.getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE), PersistenceFactory.INSTANCE
-                .getMongoObjectFactory(getMongoService()), MediaDBFactory.INSTANCE.getMediaDB(getMongoService()), EmptyWindStore.INSTANCE);
+                .getMongoObjectFactory(getMongoService()), MediaDBFactory.INSTANCE.getMediaDB(getMongoService()), EmptyWindStore.INSTANCE, EmptyGPSFixStore.INSTANCE);
         final int numberOfQualifyingRaces = 5;
         final int numberOfFinalRaces = 7;
         final String regattaBaseName = "Kieler Woche";
@@ -291,7 +333,7 @@ public class TestStoringAndLoadingEventsAndRegattas extends AbstractMongoDBTest
 
     private RacingEventServiceImpl createRacingEventServiceWithOneMockedTrackedRace(final DynamicTrackedRace q2YellowTrackedRace) {
         return new RacingEventServiceImpl(PersistenceFactory.INSTANCE.getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE), PersistenceFactory.INSTANCE
-                .getMongoObjectFactory(getMongoService()), MediaDBFactory.INSTANCE.getMediaDB(getMongoService()), EmptyWindStore.INSTANCE) {
+                .getMongoObjectFactory(getMongoService()), MediaDBFactory.INSTANCE.getMediaDB(getMongoService()), EmptyWindStore.INSTANCE, EmptyGPSFixStore.INSTANCE) {
             @Override
             public DynamicTrackedRace getExistingTrackedRace(RegattaAndRaceIdentifier raceIdentifier) {
                 return q2YellowTrackedRace;
@@ -513,7 +555,7 @@ public class TestStoringAndLoadingEventsAndRegattas extends AbstractMongoDBTest
         regatta.addRace(racedef);
         
         RacingEventServiceImpl evs = new RacingEventServiceImpl(PersistenceFactory.INSTANCE.getDomainObjectFactory(getMongoService(), DomainFactory.INSTANCE), PersistenceFactory.INSTANCE
-                .getMongoObjectFactory(getMongoService()), MediaDBFactory.INSTANCE.getMediaDB(getMongoService()), EmptyWindStore.INSTANCE);
+                .getMongoObjectFactory(getMongoService()), MediaDBFactory.INSTANCE.getMediaDB(getMongoService()), EmptyWindStore.INSTANCE, EmptyGPSFixStore.INSTANCE);
         assertNull(evs.getRememberedRegattaForRace(racedef.getId()));
         evs.raceAdded(regatta, racedef);
         assertNotNull(evs.getRememberedRegattaForRace(racedef.getId()));

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestStoringAndRetrievingLeaderboardGroups.java

@@ -11,6 +11,7 @@ import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.UUID;
 
 import org.junit.Assert;
 import org.junit.Before;
@@ -33,7 +34,6 @@ import com.sap.sailing.domain.common.RaceIdentifier;
 import com.sap.sailing.domain.common.RegattaNameAndRaceName;
 import com.sap.sailing.domain.common.ScoringSchemeType;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.leaderboard.FlexibleLeaderboard;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
@@ -49,12 +49,14 @@ import com.sap.sailing.domain.persistence.PersistenceFactory;
 import com.sap.sailing.domain.persistence.impl.DomainObjectFactoryImpl;
 import com.sap.sailing.domain.persistence.impl.MongoObjectFactoryImpl;
 import com.sap.sailing.domain.persistence.media.MediaDBFactory;
+import com.sap.sailing.domain.racelog.tracking.EmptyGPSFixStore;
 import com.sap.sailing.domain.test.mock.MockedTrackedRaceWithFixedRankAndManyCompetitors;
 import com.sap.sailing.domain.tracking.impl.EmptyWindStore;
 import com.sap.sailing.mongodb.MongoDBService;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sailing.server.impl.RacingEventServiceImpl;
 import com.sap.sailing.server.operationaltransformation.UpdateLeaderboardScoreCorrection;
+import com.sap.sse.common.Util;
 
 public class TestStoringAndRetrievingLeaderboardGroups extends AbstractMongoDBTest {
     private MongoObjectFactory mongoObjectFactory = null;
@@ -103,6 +105,7 @@ public class TestStoringAndRetrievingLeaderboardGroups extends AbstractMongoDBTe
         final LeaderboardGroup loadedLeaderboardGroup = domainObjectFactory.loadLeaderboardGroup(groupName, /* regattaRegistry */ null,
                 /* leaderboardRegistry */ null);
         assertNotNull(loadedLeaderboardGroup.getOverallLeaderboard());
+        assertEquals(leaderboardGroup.getId(), loadedLeaderboardGroup.getId());
         assertNotSame(leaderboardGroup.getOverallLeaderboard(), loadedLeaderboardGroup.getOverallLeaderboard());
         assertSame(ScoringSchemeType.HIGH_POINT_ESS_OVERALL, loadedLeaderboardGroup.getOverallLeaderboard().getScoringScheme().getType());
     }
@@ -144,8 +147,8 @@ public class TestStoringAndRetrievingLeaderboardGroups extends AbstractMongoDBTe
                 new LowPoint(), null);
         racingEventService.addLeaderboard(leaderboard);
 
-        LeaderboardGroup leaderboardGroup = racingEventService.addLeaderboardGroup(groupName, groupDescription, false, Arrays.asList(leaderboardNames), new int[0],
-                ScoringSchemeType.HIGH_POINT_ESS_OVERALL);
+        LeaderboardGroup leaderboardGroup = racingEventService.addLeaderboardGroup(UUID.randomUUID(), groupName, groupDescription, false, Arrays.asList(leaderboardNames),
+                new int[0], ScoringSchemeType.HIGH_POINT_ESS_OVERALL);
         final Leaderboard overallLeaderboard = leaderboardGroup.getOverallLeaderboard();
         mongoObjectFactory.storeLeaderboardGroup(leaderboardGroup);
         racingEventService.apply(new UpdateLeaderboardScoreCorrection(overallLeaderboard.getName(), "Leaderboard 3",
@@ -317,7 +320,7 @@ public class TestStoringAndRetrievingLeaderboardGroups extends AbstractMongoDBTe
 
         // the leaderboard named leaderboardNames[2] occurs in both groups
         RacingEventService racingEventService = new RacingEventServiceImpl(PersistenceFactory.INSTANCE.getDomainObjectFactory(MongoDBService.INSTANCE, DomainFactory.INSTANCE), PersistenceFactory.INSTANCE
-                .getMongoObjectFactory(MongoDBService.INSTANCE), MediaDBFactory.INSTANCE.getMediaDB(MongoDBService.INSTANCE), EmptyWindStore.INSTANCE); // expected to load leaderboard groups
+                .getMongoObjectFactory(MongoDBService.INSTANCE), MediaDBFactory.INSTANCE.getMediaDB(MongoDBService.INSTANCE), EmptyWindStore.INSTANCE, EmptyGPSFixStore.INSTANCE); // expected to load leaderboard groups
         final LeaderboardGroup loadedLeaderboardGroup1 = racingEventService.getLeaderboardGroupByName(groupName1);
         final LeaderboardGroup loadedLeaderboardGroup2 = racingEventService.getLeaderboardGroupByName(groupName2);
 

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestStoringAndRetrievingLeaderboards.java

@@ -27,7 +27,6 @@ import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.ScoringSchemeType;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.leaderboard.FlexibleLeaderboard;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
@@ -40,6 +39,7 @@ import com.sap.sailing.domain.persistence.impl.MongoObjectFactoryImpl;
 import com.sap.sailing.domain.test.mock.MockedTrackedRaceWithFixedRank;
 import com.sap.sailing.domain.test.mock.MockedTrackedRaceWithFixedRankAndManyCompetitors;
 import com.sap.sailing.domain.tracking.TrackedRace;
+import com.sap.sse.common.Util;
 
 public class TestStoringAndRetrievingLeaderboards extends AbstractMongoDBTest {
     public TestStoringAndRetrievingLeaderboards() throws UnknownHostException, MongoException {

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestStoringAndRetrievingRaceLogInLeaderboards.java

@@ -27,8 +27,6 @@ import com.sap.sailing.domain.base.RaceColumn;
 import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
-import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
@@ -66,6 +64,7 @@ import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventComparator;
 import com.sap.sailing.domain.tracking.Wind;
 import com.sap.sailing.server.impl.RacingEventServiceImpl;
+import com.sap.sse.common.Util;
 
 public class TestStoringAndRetrievingRaceLogInLeaderboards extends RaceLogMongoDBTest {
 
@@ -278,7 +277,7 @@ public class TestStoringAndRetrievingRaceLogInLeaderboards extends RaceLogMongoD
     public void testStoreAndRetrieveSimpleLeaderboardWithRaceLogFinishPositioningConfirmedEvent() {   
         Competitor storedCompetitor = DomainFactory.INSTANCE.getOrCreateCompetitor(UUID.randomUUID(), "SAP Extreme Sailing Team", Color.RED, null, null);
         CompetitorResults storedPositioningList = new CompetitorResultsImpl();
-        storedPositioningList.add(new Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
+        storedPositioningList.add(new com.sap.sse.common.Util.Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
         
         RaceLogFinishPositioningConfirmedEvent event = RaceLogEventFactory.INSTANCE.createFinishPositioningConfirmedEvent(now, author, 0, storedPositioningList);
 
@@ -347,7 +346,7 @@ public class TestStoringAndRetrievingRaceLogInLeaderboards extends RaceLogMongoD
     public void testStoreAndRetrieveSimpleLeaderboardWithRaceLogFinishPositioningListChangeEvent() {
         Competitor storedCompetitor = DomainFactory.INSTANCE.getOrCreateCompetitor(UUID.randomUUID(), "SAP Extreme Sailing Team", Color.RED, null, null);
         CompetitorResults storedPositioningList = new CompetitorResultsImpl();
-        storedPositioningList.add(new Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
+        storedPositioningList.add(new com.sap.sse.common.Util.Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
         
         RaceLogFinishPositioningListChangedEvent event = RaceLogEventFactory.INSTANCE.createFinishPositioningListChangedEvent(now, author, 0, storedPositioningList);
         

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestStoringAndRetrievingRaceLogInRegatta.java

@@ -26,8 +26,6 @@ import com.sap.sailing.domain.base.impl.FleetImpl;
 import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.impl.Util;
-import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
@@ -53,6 +51,7 @@ import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.impl.CompetitorResultsImpl;
 import com.sap.sailing.domain.tracking.Wind;
+import com.sap.sse.common.Util;
 
 public class TestStoringAndRetrievingRaceLogInRegatta extends AbstractTestStoringAndRetrievingRaceLogInRegatta {
     public TestStoringAndRetrievingRaceLogInRegatta() throws UnknownHostException, MongoException {
@@ -190,7 +189,7 @@ public class TestStoringAndRetrievingRaceLogInRegatta extends AbstractTestStorin
     public void testStoreAndRetrieveRegattaWithRaceLogFinishPositioningListChangeEvent() {
         Competitor storedCompetitor = DomainFactory.INSTANCE.getOrCreateCompetitor(UUID.randomUUID(), "SAP Extreme Sailing Team", Color.RED, null, null);
         CompetitorResults storedPositioningList = new CompetitorResultsImpl();
-        storedPositioningList.add(new Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
+        storedPositioningList.add(new com.sap.sse.common.Util.Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
         
         RaceLogFinishPositioningListChangedEvent event = RaceLogEventFactory.INSTANCE.createFinishPositioningListChangedEvent(now, author, 0, storedPositioningList);
 
@@ -220,7 +219,7 @@ public class TestStoringAndRetrievingRaceLogInRegatta extends AbstractTestStorin
     public void testStoreAndRetrieveRegattaWithRaceLogFinishPositioningConfirmedEvent() {   
         Competitor storedCompetitor = DomainFactory.INSTANCE.getOrCreateCompetitor(UUID.randomUUID(), "SAP Extreme Sailing Team", Color.RED, null, null);
         CompetitorResults storedPositioningList = new CompetitorResultsImpl();
-        storedPositioningList.add(new Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
+        storedPositioningList.add(new com.sap.sse.common.Util.Triple<Serializable, String, MaxPointsReason>(storedCompetitor.getId(), storedCompetitor.getName(), MaxPointsReason.NONE));
         
         RaceLogFinishPositioningConfirmedEvent event = RaceLogEventFactory.INSTANCE.createFinishPositioningConfirmedEvent(now, author, 0, storedPositioningList);
 

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestStoringAndRetrievingWindTracksTest.java

@@ -30,6 +30,7 @@ import com.sap.sailing.domain.common.impl.WindSourceImpl;
 import com.sap.sailing.domain.persistence.impl.DomainObjectFactoryImpl;
 import com.sap.sailing.domain.persistence.impl.MongoObjectFactoryImpl;
 import com.sap.sailing.domain.racelog.impl.EmptyRaceLogStore;
+import com.sap.sailing.domain.racelog.tracking.EmptyGPSFixStore;
 import com.sap.sailing.domain.test.AbstractTracTracLiveTest;
 import com.sap.sailing.domain.tracking.DynamicRaceDefinitionSet;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
@@ -85,7 +86,7 @@ public class TestStoringAndRetrievingWindTracksTest extends AbstractTracTracLive
                 }, /* trackedRegattaRegistry */ null, /*courseDesignUpdateURI*/ null, /*tracTracUsername*/ null, /*tracTracPassword*/ null, ReceiverType.RACECOURSE);
         addListenersForStoredDataAndStartController(typeControllers);
         RaceDefinition race = domainFactory.getAndWaitForRaceDefinition(getTracTracEvent().getRaceList().iterator().next().getId());
-        DynamicTrackedRace trackedRace = trackedRegatta.createTrackedRace(race, Collections.<Sideline> emptyList(), EmptyWindStore.INSTANCE, 
+        DynamicTrackedRace trackedRace = trackedRegatta.createTrackedRace(race, Collections.<Sideline> emptyList(), EmptyWindStore.INSTANCE, EmptyGPSFixStore.INSTANCE,
                     /* delayToLiveInMillis */ 0l, /* millisecondsOverWhichToAverageWind */ 30000, /* millisecondsOverWhichToAverageSpeed */ 10000, new DynamicRaceDefinitionSet() {
                     @Override
                     public void addRaceDefinition(RaceDefinition race, DynamicTrackedRace trackedRace) {