Changed master data import to use java.io serialization

scorecorrections don't seem to work yet

java/com.sap.sailing.domain/src/com/sap/sailing/domain/base/RaceColumn.java

@@ -199,5 +199,14 @@ public interface RaceColumn extends Named {
      * 
      * @param fleet
      */
-    void removeRaceIdentifier(Fleet fleet);    
+    void removeRaceIdentifier(Fleet fleet);
+
+    /**
+     * While set to true, any serialization in the current thread will not include the tracked races. Make sure to set
+     * back to false, after serialization. (in finally block)
+     * 
+     * @param flagValue
+     *            set to false for default behavior, set to true to exclude tracked races
+     */
+    public void setMasterDataExportOngoingThreadFlag(boolean flagValue);
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/base/impl/AbstractRaceColumn.java

@@ -25,10 +25,10 @@ import com.sap.sailing.domain.tracking.TrackedRace;
 public abstract class AbstractRaceColumn extends SimpleAbstractRaceColumn implements RaceColumn {
     private static final long serialVersionUID = -7801617988982540470L;
 
-    private final Map<Fleet, TrackedRace> trackedRaces;
-    private final Map<Fleet, RaceIdentifier> raceIdentifiers;
+    private Map<Fleet, TrackedRace> trackedRaces;
+    private Map<Fleet, RaceIdentifier> raceIdentifiers;
 
-    private final Map<Fleet, RaceLog> raceLogs;
+    private Map<Fleet, RaceLog> raceLogs;
     
     /**
      * holds the race log identifier template needed to create the appropriate RaceLogIdentifer that is constructed from the 
@@ -200,8 +200,19 @@ public abstract class AbstractRaceColumn extends SimpleAbstractRaceColumn implem
     /**
      * When deserializing, replication listeners are registered on all race logs.
      */
+    @SuppressWarnings("unchecked")
     private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
-        ois.defaultReadObject();
+
+        // Check if master data export is ongoing
+        boolean masterDataImportOngoing = ois.readBoolean();
+        if (masterDataImportOngoing) {
+            this.trackedRaces = new HashMap<Fleet, TrackedRace>();
+            this.raceIdentifiers = (Map<Fleet, RaceIdentifier>) ois.readObject();
+            this.raceLogs = (Map<Fleet, RaceLog>) ois.readObject();
+            this.raceLogIdentifierTemplate = (RaceLogIdentifierTemplate) ois.readObject();
+        } else {
+            ois.defaultReadObject();
+        }
         for (Entry<Fleet, RaceLog> entry : raceLogs.entrySet()) {
             Fleet fleet = entry.getKey();
             RaceLog raceLog = entry.getValue();
@@ -209,24 +220,19 @@ public abstract class AbstractRaceColumn extends SimpleAbstractRaceColumn implem
         }
     }
 
-    /**
-     * While set to true, any serialization in the current thread will not include the tracked races. Make sure to set
-     * back to false, after serialization. (in finally block)
-     * 
-     * @param flagValue
-     *            set to false for default behavior, set to true to exclude tracked races
-     */
+    @Override
     public void setMasterDataExportOngoingThreadFlag(boolean flagValue) {
         ongoingMasterDataExport.set(flagValue);
     }
 
     private void writeObject(ObjectOutputStream stream) throws IOException {
         if (ongoingMasterDataExport.get()) {
-            stream.writeObject(new HashMap<Fleet, TrackedRace>());
+            stream.writeBoolean(true);
             stream.writeObject(raceIdentifiers);
             stream.writeObject(raceLogs);
             stream.writeObject(raceLogIdentifierTemplate);
         } else {
+            stream.writeBoolean(false);
             stream.defaultWriteObject();
         }
     }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/meta/MetaLeaderboardColumn.java

@@ -193,4 +193,8 @@ public class MetaLeaderboardColumn extends SimpleAbstractRaceColumn implements R
     @Override
     public void removeRaceIdentifier(Fleet fleet) {
     }
+
+    @Override
+    public void setMasterDataExportOngoingThreadFlag(boolean flagValue) {
+    }
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java

@@ -3384,7 +3384,8 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                 inputStream = new TimeoutExtendingInputStream(connection.getInputStream(), connection);
             }
 
-            objectInputStream = new ObjectInputStream(inputStream);
+            objectInputStream = getService().getBaseDomainFactory().createObjectInputStreamResolvingAgainstThisFactory(
+                    inputStream);
             TopLevelMasterData topLevelMasterData = (TopLevelMasterData) objectInputStream.readObject();
             return importFromHttpResponse(topLevelMasterData, override);
         } catch (Exception e) {

java/com.sap.sailing.server.gateway.masterdata/src/com/sap/sailing/server/gateway/masterdata/TopLevelMasterData.java

@@ -2,10 +2,13 @@ package com.sap.sailing.server.gateway.masterdata;
 
 import java.io.Serializable;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 
+import com.sap.sailing.domain.base.CourseArea;
 import com.sap.sailing.domain.base.Event;
 import com.sap.sailing.domain.base.Fleet;
 import com.sap.sailing.domain.base.RaceColumn;
@@ -14,6 +17,7 @@ import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.common.media.MediaTrack;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
+import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
 import com.sap.sailing.domain.masterdataimport.WindTrackMasterData;
 import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.domain.tracking.WindTrack;
@@ -27,18 +31,71 @@ import com.sap.sailing.domain.tracking.WindTrack;
 public class TopLevelMasterData implements Serializable {
 
     private static final long serialVersionUID = 4820893865792553281L;
-    private final Map<String, Regatta> regattaForRaceIdStrings;
+    private final Map<Regatta, Set<String>> raceIdStringsForRegatta;
     private final Set<MediaTrack> allMediaTracks;
     private final Set<LeaderboardGroup> leaderboardGroups;
     private final Set<WindTrackMasterData> windTrackMasterData;
+    private final Map<LeaderboardGroup, Set<Event>> eventForLeaderboardGroup;
 
     public TopLevelMasterData(final Set<LeaderboardGroup> groupsToExport, final Iterable<Event> allEvents,
             final Map<String, Regatta> regattaForRaceIdString, final Collection<MediaTrack> allMediaTracks) {
-        this.regattaForRaceIdStrings = regattaForRaceIdString;
+        this.raceIdStringsForRegatta = convertToRaceIdStringsForRegattaMap(regattaForRaceIdString);
         this.allMediaTracks = new HashSet<MediaTrack>();
         this.allMediaTracks.addAll(allMediaTracks);
         this.leaderboardGroups = groupsToExport;
         this.windTrackMasterData = fillWindMap(groupsToExport);
+        this.eventForLeaderboardGroup = createEventMap(groupsToExport, allEvents);
+    }
+
+    /**
+     * Workaround to look for the events connected to RegattaLeadeboards. There should be a proper connection between
+     * regatta and event soon. TODO
+     * 
+     * @param groupsToExport
+     * @param allEvents
+     * @return
+     */
+    private Map<LeaderboardGroup, Set<Event>> createEventMap(Set<LeaderboardGroup> groupsToExport,
+            Iterable<Event> allEvents) {
+        Map<LeaderboardGroup, Set<Event>> eventsForLeaderboardGroup = new HashMap<LeaderboardGroup, Set<Event>>();
+        Map<CourseArea, Event> eventForCourseArea = new HashMap<CourseArea, Event>();
+        for (Event event : allEvents) {
+            for (CourseArea courseArea : event.getVenue().getCourseAreas()) {
+                eventForCourseArea.put(courseArea, event);
+            }
+        }
+        for (LeaderboardGroup leaderboardGroup : groupsToExport) {
+            HashSet<Event> eventSet = new HashSet<Event>();
+            eventsForLeaderboardGroup.put(leaderboardGroup, eventSet);
+            for (Leaderboard leaderboard : leaderboardGroup.getLeaderboards()) {
+                if (leaderboard instanceof RegattaLeaderboard) {
+                    RegattaLeaderboard regattaLeaderboard = (RegattaLeaderboard) leaderboard;
+                    CourseArea courseArea = regattaLeaderboard.getRegatta().getDefaultCourseArea();
+                    if (courseArea != null) {
+                        Event event = eventForCourseArea.get(courseArea);
+                        if (event != null) {
+                            eventSet.add(event);
+                        }
+                    }
+                }
+            }
+
+        }
+        return eventsForLeaderboardGroup;
+    }
+
+    private Map<Regatta, Set<String>> convertToRaceIdStringsForRegattaMap(Map<String, Regatta> regattaForRaceIdString) {
+        Map<Regatta, Set<String>> raceIdStringsForRegatta = new HashMap<Regatta, Set<String>>();
+        for (Entry<String, Regatta> entry : regattaForRaceIdString.entrySet()) {
+            Regatta regatta = entry.getValue();
+            Set<String> raceIds = raceIdStringsForRegatta.get(regatta);
+            if (raceIds == null) {
+                raceIds = new HashSet<String>();
+                raceIdStringsForRegatta.put(regatta, raceIds);
+            }
+            raceIds.add(entry.getKey());
+        }
+        return raceIdStringsForRegatta;
     }
 
     private Set<WindTrackMasterData> fillWindMap(Set<LeaderboardGroup> groupsToExport) {
@@ -80,10 +137,6 @@ public class TopLevelMasterData implements Serializable {
         }
     }
 
-    public Map<String, Regatta> getRegattaForRaceIdStrings() {
-        return regattaForRaceIdStrings;
-    }
-
     public Collection<MediaTrack> getAllMediaTracks() {
         return allMediaTracks;
     }
@@ -96,4 +149,22 @@ public class TopLevelMasterData implements Serializable {
         return windTrackMasterData;
     }
 
+    public void setMasterDataExportFlagOnRaceColumns(boolean flagValue) {
+        for (LeaderboardGroup group : leaderboardGroups) {
+            for (Leaderboard leaderboard : group.getLeaderboards()) {
+                for (RaceColumn raceColumn : leaderboard.getRaceColumns()) {
+                    raceColumn.setMasterDataExportOngoingThreadFlag(true);
+                }
+            }
+        }
+    }
+
+    public Map<Regatta, Set<String>> getRaceIdStringsForRegatta() {
+        return raceIdStringsForRegatta;
+    }
+
+    public Map<LeaderboardGroup, Set<Event>> getEventForLeaderboardGroup() {
+        return eventForLeaderboardGroup;
+    }
+
 }

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/MasterDataResource.java

@@ -73,10 +73,12 @@ public class MasterDataResource extends AbstractSailingServerResource {
                         OutputStream outputStreamWithByteCounter = new ByteCountOutputStreamDecorator(gzip);
                         objectOutputStream = new ObjectOutputStream(outputStreamWithByteCounter);
 
+                        masterData.setMasterDataExportFlagOnRaceColumns(true);
                         // Actual start of streaming
                         objectOutputStream.writeObject(masterData);
                     } finally {
                         objectOutputStream.close();
+                        masterData.setMasterDataExportFlagOnRaceColumns(false);
                     }
                     long timeToExport = System.currentTimeMillis() - startTime;
                     logger.info(String.format("Took %s ms to finish masterdataexport", timeToExport));

java/com.sap.sailing.server.test/src/com/sap/sailing/server/test/MasterDataImportTest.java

@@ -199,7 +199,8 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         List<Competitor> competitors = new ArrayList<Competitor>();
@@ -263,7 +264,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -376,7 +377,8 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         Set<Competitor> competitors = new HashSet<Competitor>();
@@ -431,7 +433,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -523,7 +525,8 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         Set<Competitor> competitors = new HashSet<Competitor>();
@@ -546,7 +549,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -633,7 +636,8 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         Set<Competitor> competitors = new HashSet<Competitor>();
@@ -684,7 +688,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -770,7 +774,8 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         Set<Competitor> competitors = new HashSet<Competitor>();
@@ -827,7 +832,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -1001,7 +1006,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -1050,7 +1055,7 @@ public class MasterDataImportTest {
         // Import in new service
         DomainFactory domainFactory = DomainFactory.INSTANCE;
         MasterDataImporter importer = new MasterDataImporter(domainFactory, destService);
-        MasterDataImportObjectCreationCount creationCount = importer.importMasterData(masterdata, false);
+        MasterDataImportObjectCreationCount creationCount = importer.importMasterData(masterdata, true);
 
         // ---Asserts---
         // Test correct number of creations
@@ -1105,11 +1110,12 @@ public class MasterDataImportTest {
                 "testDisplayName", new int[] { 1, 2, 3, 4 });
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -1159,7 +1165,8 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         Set<Competitor> competitors = new HashSet<Competitor>();
@@ -1216,7 +1223,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -1273,7 +1280,8 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         Set<Competitor> competitors = new HashSet<Competitor>();
@@ -1334,7 +1342,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -1373,7 +1381,6 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -1438,8 +1445,10 @@ public class MasterDataImportTest {
                 "testDisplayName", discardRule);
         List<String> leaderboardNames = new ArrayList<String>();
         leaderboardNames.add(leaderboard.getName());
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
-        sourceService.addLeaderboardGroup(TEST_GROUP_NAME2, "testGroupDesc2", false, leaderboardNames, null, null);
+        LeaderboardGroup group1 = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
+        LeaderboardGroup group2 = sourceService.addLeaderboardGroup(TEST_GROUP_NAME2, "testGroupDesc2", false,
+                leaderboardNames, null, null);
 
         // Set tracked Race with competitors
         Set<Competitor> competitors = new HashSet<Competitor>();
@@ -1473,7 +1482,8 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(group1);
+        groupsToExport.add(group2);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);
@@ -1527,7 +1537,7 @@ public class MasterDataImportTest {
 
         // Serialize
         HashSet<LeaderboardGroup> groupsToExport = new HashSet<LeaderboardGroup>();
-        groupsToExport.addAll(groupsToExport);
+        groupsToExport.add(sourceGroup);
         TopLevelMasterData masterdata = new TopLevelMasterData(groupsToExport, sourceService.getAllEvents(),
                 sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
         Assert.assertNotNull(masterdata);

java/com.sap.sailing.server/src/com/sap/sailing/server/masterdata/MasterDataImporter.java

@@ -1,10 +1,16 @@
 package com.sap.sailing.server.masterdata;
 
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
 import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.common.MasterDataImportObjectCreationCount;
 import com.sap.sailing.domain.common.impl.MasterDataImportObjectCreationCountImpl;
+import com.sap.sailing.domain.common.media.MediaTrack;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sailing.server.gateway.masterdata.TopLevelMasterData;
+import com.sap.sailing.server.operationaltransformation.ImportMasterDataOperation;
 
 public class MasterDataImporter {
     private final DomainFactory baseDomainFactory;
@@ -18,50 +24,33 @@ public class MasterDataImporter {
 
     public MasterDataImportObjectCreationCount importMasterData(TopLevelMasterData topLevelMasterData, boolean override) {
         MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
-        // JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer =
-        // LeaderboardGroupMasterDataJsonDeserializer.create(baseDomainFactory);
-        // JSONParser parser = new JSONParser();
-        // try {
-        // JSONObject masterDataOverall = (JSONObject) parser.parse(topLevelMasterData);
-        // JSONArray leaderboardGroupsMasterDataJsonArray = (JSONArray)
-        // masterDataOverall.get(TopLevelMasterDataSerializer.FIELD_PER_LG);
-        // for (Object leaderBoardGroupMasterData : leaderboardGroupsMasterDataJsonArray) {
-        // JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
-        // LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
-        // .deserialize(leaderBoardGroupMasterDataJson);
-        // ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, override, creationCount,
-        // baseDomainFactory);
-        // creationCount = racingEventService.apply(op);
-        // }
-        // JsonDeserializer<MediaTrack> mediaTrackDeserializer = new MediaTrackJsonDeserializer();
-        // JSONArray mediaTracks = (JSONArray) masterDataOverall.get(TopLevelMasterDataSerializer.FIELD_MEDIA);
-        // List<MediaTrack> tracks = new ArrayList<MediaTrack>();
-        // for (Object obj : mediaTracks) {
-        // tracks.add(mediaTrackDeserializer.deserialize((JSONObject) obj));
-        // }
-        // Collection<MediaTrack> existingMediaTracks = racingEventService.getAllMediaTracks();
-        // Map<String, MediaTrack> existingMap = new HashMap<String, MediaTrack>();
-        //
-        // for (MediaTrack oneTrack : existingMediaTracks) {
-        // existingMap.put(oneTrack.dbId, oneTrack);
-        // }
-        //
-        // for (MediaTrack oneNewTrack : tracks) {
-        // if (existingMap.containsKey(oneNewTrack.dbId)) {
-        // if (override) {
-        // racingEventService.mediaTrackDeleted(existingMap.get(oneNewTrack.dbId));
-        // } else {
-        // continue;
-        // }
-        // }
-        // racingEventService.mediaTrackAdded(oneNewTrack);
-        // }
-        // } catch (org.json.simple.parser.ParseException e) {
-        // throw new RuntimeException(e);
-        // } catch (JsonDeserializationException e) {
-        // throw new RuntimeException(e);
-        // }
+        ImportMasterDataOperation op = new ImportMasterDataOperation(topLevelMasterData, override, creationCount,
+                baseDomainFactory);
+        creationCount = racingEventService.apply(op);
+        createMediaTracks(topLevelMasterData, override);
+
         return creationCount;
     }
 
+    private void createMediaTracks(TopLevelMasterData topLevelMasterData, boolean override) {
+        Collection<MediaTrack> tracks = topLevelMasterData.getAllMediaTracks();
+        Collection<MediaTrack> existingMediaTracks = racingEventService.getAllMediaTracks();
+        Map<String, MediaTrack> existingMap = new HashMap<String, MediaTrack>();
+
+        for (MediaTrack oneTrack : existingMediaTracks) {
+            existingMap.put(oneTrack.dbId, oneTrack);
+        }
+
+        for (MediaTrack oneNewTrack : tracks) {
+            if (existingMap.containsKey(oneNewTrack.dbId)) {
+                if (override) {
+                    racingEventService.mediaTrackDeleted(existingMap.get(oneNewTrack.dbId));
+                } else {
+                    continue;
+                }
+            }
+            racingEventService.mediaTrackAdded(oneNewTrack);
+        }
+    }
+
 }

java/com.sap.sailing.server/src/com/sap/sailing/server/operationaltransformation/ImportMasterDataOperation.java

@@ -6,7 +6,6 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 import java.util.UUID;
 import java.util.logging.Logger;
@@ -16,39 +15,21 @@ import com.sap.sailing.domain.base.CourseArea;
 import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.base.Event;
 import com.sap.sailing.domain.base.Fleet;
-import com.sap.sailing.domain.base.LeaderboardMasterData;
 import com.sap.sailing.domain.base.RaceColumn;
-import com.sap.sailing.domain.base.RaceColumnInSeries;
 import com.sap.sailing.domain.base.RaceDefinition;
 import com.sap.sailing.domain.base.Regatta;
 import com.sap.sailing.domain.base.Series;
-import com.sap.sailing.domain.base.impl.SeriesImpl;
-import com.sap.sailing.domain.common.MaxPointsReason;
-import com.sap.sailing.domain.common.RaceIdentifier;
 import com.sap.sailing.domain.common.RegattaAndRaceIdentifier;
-import com.sap.sailing.domain.common.RegattaName;
 import com.sap.sailing.domain.common.ScoringSchemeType;
 import com.sap.sailing.domain.common.impl.MasterDataImportObjectCreationCountImpl;
-import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.leaderboard.FlexibleLeaderboard;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
-import com.sap.sailing.domain.leaderboard.SettableScoreCorrection;
-import com.sap.sailing.domain.leaderboard.impl.ThresholdBasedResultDiscardingRuleImpl;
-import com.sap.sailing.domain.masterdataimport.EventMasterData;
-import com.sap.sailing.domain.masterdataimport.FlexibleLeaderboardMasterData;
-import com.sap.sailing.domain.masterdataimport.LeaderboardGroupMasterData;
-import com.sap.sailing.domain.masterdataimport.RaceColumnMasterData;
-import com.sap.sailing.domain.masterdataimport.RegattaLeaderboardMasterData;
-import com.sap.sailing.domain.masterdataimport.RegattaMasterData;
-import com.sap.sailing.domain.masterdataimport.ScoreCorrectionMasterData;
-import com.sap.sailing.domain.masterdataimport.SeriesMasterData;
-import com.sap.sailing.domain.masterdataimport.SingleScoreCorrectionMasterData;
+import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
+import com.sap.sailing.domain.leaderboard.meta.LeaderboardGroupMetaLeaderboard;
 import com.sap.sailing.domain.masterdataimport.WindTrackMasterData;
-import com.sap.sailing.domain.racelog.RaceLog;
-import com.sap.sailing.domain.racelog.RaceLogEvent;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.domain.tracking.TrackedRegatta;
@@ -56,6 +37,7 @@ import com.sap.sailing.domain.tracking.Wind;
 import com.sap.sailing.domain.tracking.WindTrack;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sailing.server.RacingEventServiceOperation;
+import com.sap.sailing.server.gateway.masterdata.TopLevelMasterData;
 
 public class ImportMasterDataOperation extends
         AbstractRacingEventServiceOperation<MasterDataImportObjectCreationCountImpl> {
@@ -64,7 +46,7 @@ public class ImportMasterDataOperation extends
 
     private static final Logger logger = Logger.getLogger(ImportMasterDataOperation.class.getName());
 
-    private final LeaderboardGroupMasterData masterData;
+    private final TopLevelMasterData masterData;
 
     private final MasterDataImportObjectCreationCountImpl creationCount;
 
@@ -72,34 +54,38 @@ public class ImportMasterDataOperation extends
 
     private final boolean override;
 
-    public ImportMasterDataOperation(LeaderboardGroupMasterData masterData, boolean override, MasterDataImportObjectCreationCountImpl existingCreationCount, DomainFactory baseDomainFactory) {
+    public ImportMasterDataOperation(TopLevelMasterData topLevelMasterData, boolean override,
+            MasterDataImportObjectCreationCountImpl existingCreationCount, DomainFactory baseDomainFactory) {
         this.creationCount = new MasterDataImportObjectCreationCountImpl();
         this.creationCount.add(existingCreationCount);
         this.baseDomainFactory = baseDomainFactory;
-        this.masterData = masterData;
+        this.masterData = topLevelMasterData;
         this.override = override;
     }
 
     @Override
     public MasterDataImportObjectCreationCountImpl internalApplyTo(RacingEventService toState) throws Exception {
-        createLeaderboardGroupWithAllRelatedObjects(masterData, toState);
+        for (LeaderboardGroup leaderboardGroup : masterData.getLeaderboardGroups()) {
+            createLeaderboardGroupWithAllRelatedObjects(toState, leaderboardGroup);
+        }
+        createWindTracks(toState);
         return creationCount;
     }
 
-    private void createLeaderboardGroupWithAllRelatedObjects(final LeaderboardGroupMasterData masterData,
-            final RacingEventService toState) {
+    private void createLeaderboardGroupWithAllRelatedObjects(final RacingEventService toState,
+            LeaderboardGroup leaderboardGroup) {
         Map<String, Leaderboard> existingLeaderboards = toState.getLeaderboards();
         List<String> leaderboardNames = new ArrayList<String>();
-        createCourseAreasAndEvents(masterData, toState);
-        createRegattas(masterData, toState);
-        for (final LeaderboardMasterData board : masterData.getLeaderboards()) {
-            leaderboardNames.add(board.getName());
-            if (existingLeaderboards.containsKey(board.getName())) {
-                if (creationCount.alreadyAddedLeaderboardWithName(board.getName())) {
+        createCourseAreasAndEvents(toState, leaderboardGroup);
+        createRegattas(toState, leaderboardGroup);
+        for (final Leaderboard leaderboard : leaderboardGroup.getLeaderboards()) {
+            leaderboardNames.add(leaderboard.getName());
+            if (existingLeaderboards.containsKey(leaderboard.getName())) {
+                if (creationCount.alreadyAddedLeaderboardWithName(leaderboard.getName())) {
                     //Has already been added by this operation
                     continue;
                 } else if (override) {
-                    for (RaceColumn raceColumn : existingLeaderboards.get(board.getName()).getRaceColumns()) {
+                    for (RaceColumn raceColumn : existingLeaderboards.get(leaderboard.getName()).getRaceColumns()) {
                         for (Fleet fleet : raceColumn.getFleets()) {
                             TrackedRace trackedRace = raceColumn.getTrackedRace(fleet);
                             if (trackedRace != null) {
@@ -107,86 +93,66 @@ public class ImportMasterDataOperation extends
                             }
                         }
                     }
-                    if (toState.getLeaderboardByName(board.getName()) != null) {
-                        toState.removeLeaderboard(board.getName());
+                    if (toState.getLeaderboardByName(leaderboard.getName()) != null) {
+                        toState.removeLeaderboard(leaderboard.getName());
                     }
                     logger.info(String.format("Leaderboard with name %1$s already existed and has been overridden.",
-                            board.getName()));
+                            leaderboard.getName()));
                 } else {
                     logger.info(String.format("Leaderboard with name %1$s already exists and hasn't been overridden.",
-                            board.getName()));
+                            leaderboard.getName()));
                     continue;
                 }
             }
-            setCourseAreaIfNecessary(board, toState);
-            setRegattaIfNecessary(board, toState);
-            Leaderboard leaderboard = board.getLeaderboard();
             if (leaderboard != null) {
-                leaderboard.setDisplayName(board.getDisplayName());
                 toState.addLeaderboard(leaderboard);
                 creationCount.addOneLeaderboard(leaderboard.getName());
-                Leaderboard newLeaderboard = toState.getLeaderboardByName(board.getName());
-                addRaceColumnsIfNecessary(board, newLeaderboard, toState);
-                // Set dummy tracked race, so that the leaderboard caches the competitors and
-                // will accept the score corrections
-                Pair<RaceColumn, Fleet> dummyColumnAndFleet = addDummyTrackedRace(board.getCompetitorsById().values(),
-                        leaderboard, getRegattaIfPossible(leaderboard));
-                boolean addedScoreCorrections = false;
-                try {
-                    if (dummyColumnAndFleet.getA() != null && dummyColumnAndFleet.getB() != null) {
-                        addScoreCorrectionsIfPossible(board.getScoreCorrection(), newLeaderboard);
-                        addedScoreCorrections = true;
-                    }
-                    addCarriedPoints(leaderboard, board.getCarriedPoints(), baseDomainFactory);
-                    addSuppressedCompetitors(leaderboard, board.getSuppressedCompetitors(), baseDomainFactory);
-                    addCompetitorDisplayNames(leaderboard, board.getDisplayNamesByCompetitorId(),
-                            board.getCompetitorsById());
-                    addRaceLogEvents(leaderboard, board.getRaceLogEvents());
-                    toState.updateStoredLeaderboard(leaderboard);
-
-                } finally {
-                    if (addedScoreCorrections) {
-                        unsetDummy(dummyColumnAndFleet, leaderboard);
-                    }
-                }
-                relinkTrackedRacesIfPossible(toState, newLeaderboard);
+                relinkTrackedRacesIfPossible(toState, leaderboard);
             }
 
         }
-        int[] overallLeaderboardDiscardThresholds = masterData.getOverallLeaderboardDiscardingRule() != null ? masterData.getOverallLeaderboardDiscardingRule().getDiscardIndexResultsStartingWithHowManyRaces() : null;
-        ScoringSchemeType overallLeaderboardScoringSchemeType = masterData.getOverallLeaderboardScoringScheme() != null ? masterData.getOverallLeaderboardScoringScheme().getType() : null;
-        final LeaderboardGroup leaderboardGroup;
-        LeaderboardGroup existingLeaderboardGroup = toState.getLeaderboardGroupByName(masterData.getName());
+        LeaderboardGroup existingLeaderboardGroup = toState.getLeaderboardGroupByName(leaderboardGroup.getName());
         if (existingLeaderboardGroup != null && override) {
             logger.info(String.format("Leaderboard Group with name %1$s already existed and will be overridden.",
-                    masterData.getName()));
-            toState.removeLeaderboardGroup(masterData.getName());
+                    leaderboardGroup.getName()));
+            toState.removeLeaderboardGroup(leaderboardGroup.getName());
             existingLeaderboardGroup = null;
         }
+        Leaderboard overallLeaderboardData = null;
         if (existingLeaderboardGroup == null) {
-            leaderboardGroup = toState.addLeaderboardGroup(masterData.getName(), masterData.getDescription(),
-                    masterData.isDisplayGroupsRevese(), leaderboardNames, overallLeaderboardDiscardThresholds,
+            overallLeaderboardData = leaderboardGroup.getOverallLeaderboard();
+            int[] overallLeaderboardDiscardThresholds = null;
+            ScoringSchemeType overallLeaderboardScoringSchemeType = null;
+            if (overallLeaderboardData != null) {
+                LeaderboardGroupMetaLeaderboard metaLeaderboard = (LeaderboardGroupMetaLeaderboard) overallLeaderboardData;
+                ThresholdBasedResultDiscardingRule rule = (ThresholdBasedResultDiscardingRule) metaLeaderboard
+                        .getResultDiscardingRule();
+                overallLeaderboardDiscardThresholds = rule.getDiscardIndexResultsStartingWithHowManyRaces();
+                overallLeaderboardScoringSchemeType = metaLeaderboard.getScoringScheme().getType();
+            }
+            leaderboardGroup = toState.addLeaderboardGroup(leaderboardGroup.getName(),
+                    leaderboardGroup.getDescription(), leaderboardGroup.isDisplayGroupsInReverseOrder(),
+                    leaderboardNames, overallLeaderboardDiscardThresholds,
                     overallLeaderboardScoringSchemeType);
-            creationCount.addOneLeaderboardGroup(masterData.getName());
+            creationCount.addOneLeaderboardGroup(leaderboardGroup.getName());
         } else {
             leaderboardGroup = existingLeaderboardGroup;
             logger.info(String.format("Leaderboard Group with name %1$s already exists and hasn't been overridden.",
-                    masterData.getName()));
+                    leaderboardGroup.getName()));
         }
-        if (masterData.hasOverallLeaderboard() && (override || existingLeaderboardGroup == null)) {
+        if (leaderboardGroup.getOverallLeaderboard() != null && (override || existingLeaderboardGroup == null)) {
             if (existingLeaderboardGroup != null && existingLeaderboardGroup.getOverallLeaderboard() != null) {
                 // remove old overall leaderboard if it existed
                 toState.removeLeaderboard(existingLeaderboardGroup.getOverallLeaderboard().getName());
             }
             Leaderboard overallLeaderboard = leaderboardGroup.getOverallLeaderboard();
-            addSuppressedCompetitors(overallLeaderboard, masterData.getOverallLeaderboardSuppressedCompetitorIds(),
-                    baseDomainFactory);
-            Map<String, Double> factorsForMetaColumns = masterData.getMetaColumnsWithFactors();
-            if (factorsForMetaColumns != null) {
-                for (RaceColumn column : overallLeaderboard.getRaceColumns()) {
-                    Double explicitFactor = factorsForMetaColumns.get(column.getName());
-                    toState.updateLeaderboardColumnFactor(overallLeaderboard.getName(), column.getName(), explicitFactor);
-                }
+            for (Competitor suppressedCompetitor : overallLeaderboardData.getSuppressedCompetitors()) {
+                overallLeaderboard.setSuppressed(suppressedCompetitor, true);
+            }
+            for (RaceColumn column : overallLeaderboard.getRaceColumns()) {
+                Double explicitFactor = overallLeaderboardData.getRaceColumnByName(column.getName())
+                        .getExplicitFactor();
+                toState.updateLeaderboardColumnFactor(overallLeaderboard.getName(), column.getName(), explicitFactor);
             }
             toState.getMongoObjectFactory().storeLeaderboardGroup(leaderboardGroup); // store changes to overall leaderboard
         }
@@ -204,72 +170,13 @@ public class ImportMasterDataOperation extends
         }
     }
 
-    private void addRaceLogEvents(Leaderboard leaderboard, Map<String, Map<String, List<RaceLogEvent>>> raceLogEvents) {
-        for (Entry<String, Map<String, List<RaceLogEvent>>> entry : raceLogEvents.entrySet()) {
-            String raceColumnName = entry.getKey();
-            RaceColumn raceColumn = leaderboard.getRaceColumnByName(raceColumnName);
-            for (Entry<String, List<RaceLogEvent>> fleetEntry : entry.getValue().entrySet()) {
-                String fleetName = fleetEntry.getKey();
-                Fleet fleet = raceColumn.getFleetByName(fleetName);
-                List<RaceLogEvent> logEvents = fleetEntry.getValue();
-                RaceLog raceLog = raceColumn.getRaceLog(fleet);
-                for (RaceLogEvent singleEvent : logEvents) {
-                    raceLog.load(singleEvent);
-                }
-            }
-        }
-    }
-
-    private void addCompetitorDisplayNames(Leaderboard leaderboard, Map<Serializable, String> map,
-            Map<Serializable, Competitor> map2) {
-        for (Entry<Serializable, String> entry : map.entrySet()) {
-            leaderboard.setDisplayName(baseDomainFactory.getExistingCompetitorById(entry.getKey()),
-                    entry.getValue());
-        }
-    }
-    
-    interface CompetitorByIdGetter {
-        Competitor getCompetitorById(Serializable id);
-    }
-
-    public static void addSuppressedCompetitors(Leaderboard leaderboard, List<Serializable> list,
-            DomainFactory domainFactory) {
-        for (Serializable id : list) {
-            Competitor competitorById = domainFactory.getExistingCompetitorById(id);
-            if (competitorById != null) {
-                leaderboard.setSuppressed(competitorById, true);
-            }
-        }
-    }
-
-    private void addCarriedPoints(Leaderboard leaderboard, Map<Serializable, Double> carriedPoints,
-            DomainFactory domainFactory) {
-        for (Entry<Serializable, Double> entry : carriedPoints.entrySet()) {
-            leaderboard.setCarriedPoints(domainFactory.getExistingCompetitorById(entry.getKey()), entry.getValue());
-        }
-    }
-
-    private Regatta getRegattaIfPossible(Leaderboard leaderboard) {
-        if (leaderboard instanceof RegattaLeaderboard) {
-            return ((RegattaLeaderboard) leaderboard).getRegatta();
-        }
-        return null;
-    }
-
-    private void unsetDummy(Pair<RaceColumn, Fleet> dummyColumnAndFleet, Leaderboard leaderboard) {
-        RaceColumn raceColumn = dummyColumnAndFleet.getA();
-        Fleet fleet = dummyColumnAndFleet.getB();
-        raceColumn.setTrackedRace(fleet, null);
-    }
-
     /**
      * Hack adding a dummy tracked race, so that the competitors will be added to the leaderboards
      * 
-     * @param competitors
      * @param leaderboard
      * @return the race column and fleet the dummy was attached to
      */
-    public Pair<RaceColumn, Fleet> addDummyTrackedRace(Iterable<Competitor> competitors, Leaderboard leaderboard,
+    public Pair<RaceColumn, Fleet> addDummyTrackedRace(Leaderboard leaderboard,
             Regatta regatta) {
         RaceColumn raceColumn = null;
         Fleet fleet = null;
@@ -281,61 +188,15 @@ public class ImportMasterDataOperation extends
             Iterator<? extends Fleet> fleetIterator = fleets.iterator();
             if (fleetIterator.hasNext()) {
                 fleet = fleetIterator.next();
-                DummyTrackedRace dummy = new DummyTrackedRace(competitors, regatta, null);
+                DummyTrackedRace dummy = new DummyTrackedRace(leaderboard.getAllCompetitors(), regatta, null);
                 raceColumn.setTrackedRace(fleet, dummy);
             }
         }
         return new Pair<RaceColumn, Fleet>(raceColumn, fleet);
     }
 
-    private void addScoreCorrectionsIfPossible(ScoreCorrectionMasterData scoreCorrectionMasterData,
-            final Leaderboard leaderboard) {
-        SettableScoreCorrection scoreCorrection = leaderboard.getScoreCorrection();
-        scoreCorrection.setComment(scoreCorrectionMasterData.getComment());
-        if (scoreCorrectionMasterData.getTimepointMillis() != null) {
-            scoreCorrection.setTimePointOfLastCorrectionsValidity(new MillisecondsTimePoint(scoreCorrectionMasterData
-                    .getTimepointMillis()));
-        }
-        for (Entry<String, Iterable<SingleScoreCorrectionMasterData>> scoreCorrectionEntry : scoreCorrectionMasterData
-                .getCorrectionForRaceColumns().entrySet()) {
-            String columnName = scoreCorrectionEntry.getKey();
-            RaceColumn raceColumn = leaderboard.getRaceColumnByName(columnName);
-            if (raceColumn != null) {
-                for (SingleScoreCorrectionMasterData singleCorrection : scoreCorrectionEntry.getValue()) {
-                    Competitor competitor = leaderboard.getCompetitorByIdAsString(singleCorrection.getCompetitorId()
-                            .toString());
-                    scoreCorrection.setMaxPointsReason(competitor, raceColumn,
-                            MaxPointsReason.valueOf(singleCorrection.getMaxPointsReason()));
-                    if (singleCorrection.getExplicitScoreCorrection() != null) {
-                        scoreCorrection.correctScore(competitor, raceColumn,
-                                singleCorrection.getExplicitScoreCorrection());
-                    }
-                }
-            }
-        }
-
-    }
-
-    private void addRaceColumnsIfNecessary(LeaderboardMasterData board, Leaderboard newLeaderboard,
-            RacingEventService toState) {
-        if (board instanceof FlexibleLeaderboardMasterData) {
-            for (RaceColumnMasterData raceColumnMasterData : ((FlexibleLeaderboardMasterData) board).getRaceColumns()) {
-                RaceColumn raceColumn = toState.addColumnToLeaderboard(raceColumnMasterData.getName(), board.getName(),
-                        raceColumnMasterData.isMedal());
-                Set<WindTrackMasterData> windTrackMasterData = raceColumnMasterData.getWindTrackMasterData();
-                if (windTrackMasterData != null) {
-                    createWindTracks(windTrackMasterData, toState);
-                }
-                for (Map.Entry<String, RaceIdentifier> e : raceColumnMasterData.getRaceIdentifiersByFleetName()
-                        .entrySet()) {
-                    raceColumn.setRaceIdentifier(raceColumn.getFleetByName(e.getKey()), e.getValue());
-                }
-            }
-        }
-    }
-
-    private void createWindTracks(Set<WindTrackMasterData> windTrackMasterData, RacingEventService toState) {
-        for (WindTrackMasterData windMasterData : windTrackMasterData) {
+    private void createWindTracks(RacingEventService toState) {
+        for (WindTrackMasterData windMasterData : masterData.getWindTrackMasterData()) {
             DummyTrackedRace trackedRaceWithNameAndId = new DummyTrackedRace(windMasterData.getRaceName(), windMasterData.getRaceId());
             WindTrack windTrack = toState.getWindStore().getWindTrack(windMasterData.getRegattaName(), trackedRaceWithNameAndId, windMasterData.getWindSource(), 0, -1);
             for (Wind fix : windMasterData.getFixes()) {
@@ -344,115 +205,86 @@ public class ImportMasterDataOperation extends
         }
     }
 
-    private void createRegattas(LeaderboardGroupMasterData masterData, RacingEventService toState) {
-        Iterable<RegattaMasterData> regattaData = masterData.getRegattas();
-        for (RegattaMasterData singleRegattaData : regattaData) {
-            Regatta existingRegatta = toState.getRegatta(new RegattaName(singleRegattaData.getRegattaName()));
-            if (existingRegatta != null) {
-                if (creationCount.alreadyAddedRegattaWithId(existingRegatta.getId().toString())) {
-                    // Already added earlier in this import process
-                    continue;
-                } else if (override) {
-                    logger.info(String
-                            .format("Regatta with name %1$s already existed and has been overridden. All it's tracked races were stopped and removed.",
-                                    singleRegattaData.getRegattaName()));
-                    try {
-                        TrackedRegatta trackedRegatta = toState.getTrackedRegatta(existingRegatta);
-                        List<TrackedRace> toRemove = new ArrayList<TrackedRace>();
-                        if (trackedRegatta != null) {
-                            for (TrackedRace race : trackedRegatta.getTrackedRaces()) {
-                                toRemove.add(race);
-                            }
-                            for (TrackedRace raceToRemove : toRemove) {
-                                trackedRegatta.removeTrackedRace(raceToRemove);
-                                RaceDefinition race = existingRegatta.getRaceByName(raceToRemove.getRaceIdentifier()
-                                        .getRaceName());
-                                if (race != null) {
-                                    try {
-                                        toState.removeRace(existingRegatta, race);
-                                    } catch (IOException | InterruptedException e) {
-                                        throw new RuntimeException(e);
+    private void createRegattas(RacingEventService toState, LeaderboardGroup leaderboardGroup) {
+        Iterable<Leaderboard> leaderboards = leaderboardGroup.getLeaderboards();
+        for (Leaderboard leaderboard : leaderboards) {
+            if (leaderboard instanceof RegattaLeaderboard) {
+                RegattaLeaderboard regattaLeaderboard = (RegattaLeaderboard) leaderboard;
+                Regatta regatta = regattaLeaderboard.getRegatta();
+
+                Regatta existingRegatta = toState.getRegatta(regatta.getRegattaIdentifier());
+                if (existingRegatta != null) {
+                    if (creationCount.alreadyAddedRegattaWithId(existingRegatta.getId().toString())) {
+                        // Already added earlier in this import process
+                        continue;
+                    } else if (override) {
+                        logger.info(String
+                                .format("Regatta with name %1$s already existed and has been overridden. All it's tracked races were stopped and removed.",
+                                        regatta.getRegattaIdentifier()));
+                        try {
+                            TrackedRegatta trackedRegatta = toState.getTrackedRegatta(existingRegatta);
+                            List<TrackedRace> toRemove = new ArrayList<TrackedRace>();
+                            if (trackedRegatta != null) {
+                                for (TrackedRace race : trackedRegatta.getTrackedRaces()) {
+                                    toRemove.add(race);
+                                }
+                                for (TrackedRace raceToRemove : toRemove) {
+                                    trackedRegatta.removeTrackedRace(raceToRemove);
+                                    RaceDefinition race = existingRegatta.getRaceByName(raceToRemove
+                                            .getRaceIdentifier().getRaceName());
+                                    if (race != null) {
+                                        try {
+                                            toState.removeRace(existingRegatta, race);
+                                        } catch (IOException | InterruptedException e) {
+                                            throw new RuntimeException(e);
+                                        }
                                     }
                                 }
                             }
+                            toState.stopTrackingAndRemove(existingRegatta);
+                            creationCount.addOverwrittenRegattaName(existingRegatta.getName());
+                            toState.removeRegatta(existingRegatta);
+                        } catch (IOException | InterruptedException e) {
+                            logger.warning(String.format(
+                                    "Regatta with name %1$s could not be deleted due to an error.",
+                                    regatta.getRegattaIdentifier()));
+                            e.printStackTrace();
+                            continue;
                         }
-                        toState.stopTrackingAndRemove(existingRegatta);
-                        creationCount.addOverwrittenRegattaName(existingRegatta.getName());
-                        toState.removeRegatta(existingRegatta);
-                    } catch (IOException | InterruptedException e) {
-                        logger.warning(String.format("Regatta with name %1$s could not be deleted due to an error.",
-                                singleRegattaData.getRegattaName()));
-                        e.printStackTrace();
+                    } else {
+                        logger.info(String.format("Regatta with name %1$s already exists and hasn't been overridden.",
+                                regatta.getRegattaIdentifier()));
                         continue;
                     }
-                } else {
-                    logger.info(String.format("Regatta with name %1$s already exists and hasn't been overridden.",
-                            singleRegattaData.getRegattaName()));
-                    continue;
                 }
+                Serializable id = regatta.getId();
+                Iterable<? extends Series> series = regatta.getSeries();
+                String baseName = regatta.getBaseName();
+                String boatClassName = regatta.getBoatClass().getName();
+                CourseArea defaultCourseArea = regatta.getDefaultCourseArea();
+                Serializable defaultCourseAreaId = (defaultCourseArea != null) ? defaultCourseArea.getId() : null;
+                ScoringSchemeType scoringSchemeType = regatta.getScoringScheme().getType();
+                boolean isPersistent = regatta.isPersistent();
+                Regatta createdRegatta = toState.getOrCreateRegattaWithoutReplication(baseName, boatClassName, id,
+                        series, isPersistent, baseDomainFactory.createScoringScheme(scoringSchemeType),
+                        defaultCourseAreaId).getA();
+                createdRegatta.setRegattaConfiguration(regatta.getRegattaConfiguration());
+                Set<String> raceIdStrings = masterData.getRaceIdStringsForRegatta().get(regatta);
+                if (raceIdStrings != null) {
+                    toState.setPersistentRegattaForRaceIDs(createdRegatta, raceIdStrings, override);
+                }
+                creationCount.addOneRegatta(createdRegatta.getId().toString());
             }
-            Serializable id = singleRegattaData.getId();
-            Iterable<Series> series = createSeries(singleRegattaData.getSeries(), toState);
-            String baseName = singleRegattaData.getBaseName();
-            String boatClassName = singleRegattaData.getBoatClassName();
-            String defaultCourseAreaId = singleRegattaData.getDefaultCourseAreaId();
-            String scoringSchemeType = singleRegattaData.getScoringSchemeType();
-            boolean isPersistent = singleRegattaData.isPersistent();
-            UUID courseAreaUUID = defaultCourseAreaId != null ? UUID.fromString(defaultCourseAreaId) : null;
-            Regatta createdRegatta = toState.getOrCreateRegattaWithoutReplication(baseName, boatClassName, id, series,
-                    isPersistent, baseDomainFactory.createScoringScheme(ScoringSchemeType.valueOf(scoringSchemeType)),
-                    courseAreaUUID).getA();
-            createdRegatta.setRegattaConfiguration(singleRegattaData.getRegattaConfiguration());
-            toState.setPersistentRegattaForRaceIDs(createdRegatta, singleRegattaData.getRaceIdsAsStrings(), override);
-            creationCount.addOneRegatta(createdRegatta.getId().toString());
         }
 
     }
 
-    private Iterable<Series> createSeries(Iterable<SeriesMasterData> series, RacingEventService toState) {
-        List<Series> result = new ArrayList<Series>();
-        for (SeriesMasterData singleSeriesData : series) {
-            String name = singleSeriesData.getName();
-            boolean isMedal = singleSeriesData.isMedal();
-            Iterable<Fleet> fleets = singleSeriesData.getFleets();
-            Iterable<RaceColumnMasterData> raceColumnMasterData = singleSeriesData.getRaceColumnNames();
-            List<String> raceColumnNames = new ArrayList<String>();
-            for (RaceColumnMasterData rcmd : raceColumnMasterData) {
-                raceColumnNames.add(rcmd.getName());
-            }
-            SeriesImpl newSeries = new SeriesImpl(name, isMedal, fleets, raceColumnNames, toState);
-            Iterator<RaceColumnMasterData> raceColumnMasterDataIter = raceColumnMasterData.iterator();
-            Iterator<? extends RaceColumnInSeries> raceColumnIter = newSeries.getRaceColumns().iterator();
-            while (raceColumnMasterDataIter.hasNext()) {
-                RaceColumnMasterData rcmd = raceColumnMasterDataIter.next();
-                RaceColumnInSeries raceColumn = raceColumnIter.next();
-                if (rcmd.getFactor() != null) {
-                    raceColumn.setFactor(rcmd.getFactor());
-                }
-                Set<WindTrackMasterData> windTrackMasterData = rcmd.getWindTrackMasterData();
-                if (windTrackMasterData != null) {
-                    createWindTracks(windTrackMasterData, toState);
-                }
-                for (Map.Entry<String, RaceIdentifier> e : rcmd.getRaceIdentifiersByFleetName().entrySet()) {
-                    raceColumn.setRaceIdentifier(raceColumn.getFleetByName(e.getKey()), e.getValue());
-                }
-            }
-            int[] resultDiscardingRule = singleSeriesData.getDiscardingRule();
-            if (resultDiscardingRule != null) {
-                newSeries.setResultDiscardingRule(new ThresholdBasedResultDiscardingRuleImpl(resultDiscardingRule));
-            }
-            result.add(newSeries);
-        }
-        return result;
-    }
 
-    private void createCourseAreasAndEvents(LeaderboardGroupMasterData masterData, RacingEventService toState) {
-        Set<EventMasterData> events = masterData.getEvents();
-
-        for (EventMasterData event : events) {
-            String id = event.getId();
-            Event existingEvent = toState.getEvent(UUID.fromString(id));
-            if (existingEvent != null && override && !creationCount.alreadyAddedEventWithId(id)) {
+    private void createCourseAreasAndEvents(RacingEventService toState, LeaderboardGroup leaderboardGroup) {
+        for (Event event : masterData.getEventForLeaderboardGroup().get(leaderboardGroup)) {
+            UUID id = event.getId();
+            Event existingEvent = toState.getEvent(id);
+            if (existingEvent != null && override && !creationCount.alreadyAddedEventWithId(id.toString())) {
                 logger.info(String.format("Event with name %1$s already existed and will be overridden.",
                         event.getName()));
                 toState.removeEvent(existingEvent.getId());
@@ -460,29 +292,29 @@ public class ImportMasterDataOperation extends
             }
             if (existingEvent == null) {
                 String name = event.getName();
-                String pubString = event.getPubUrl();
-                String venueName = event.getVenueName();
+                String pubString = event.getPublicationUrl();
+                String venueName = event.getVenue().getName();
                 boolean isPublic = event.isPublic();
-                Event newEvent = toState.createEventWithoutReplication(name, venueName, pubString, isPublic, UUID.fromString(id));
+                Event newEvent = toState.createEventWithoutReplication(name, venueName, pubString, isPublic, id);
                 creationCount.addOneEvent(newEvent.getId().toString());
             } else {
                 logger.info(String.format("Event with name %1$s already exists and hasn't been overridden.",
                         event.getName()));
             }
-            Iterable<Pair<String, String>> courseAreas = event.getCourseAreas();
-            for (Pair<String, String> courseAreaEntry : courseAreas) {
+            Iterable<CourseArea> courseAreas = event.getVenue().getCourseAreas();
+            for (CourseArea courseArea : courseAreas) {
                 boolean alreadyExists = false;
-                if (existingEvent != null
-                        && existsInSet(existingEvent.getVenue().getCourseAreas(), courseAreaEntry.getA())) {
+                if (existingEvent != null && existsInSet(existingEvent.getVenue().getCourseAreas(), courseArea.getId())) {
                     alreadyExists = true;
                 }
                 if (!alreadyExists) {
-                    toState.addCourseAreaWithoutReplication(UUID.fromString(id), UUID.fromString(courseAreaEntry.getA()), courseAreaEntry.getB());
+                    toState.addCourseAreaWithoutReplication(id, courseArea.getId(), courseArea.getName());
                 } else {
                     logger.info(String
                             .format("Course area with id %1$s for event with id %2$s already exists and hasn't been overridden.",
-                                    courseAreaEntry.getA(), id));
+                                    courseArea.getId(), id));
                 }
+
             }
         }
     }
@@ -490,37 +322,18 @@ public class ImportMasterDataOperation extends
     /**
      * 
      * @param iterable
-     * @param key
+     * @param uuid
      * @return true if course with given id exists in iterable
      */
-    private boolean existsInSet(Iterable<CourseArea> iterable, String key) {
+    private boolean existsInSet(Iterable<CourseArea> iterable, UUID uuid) {
         for (CourseArea area : iterable) {
-            if (area.getId().toString().matches(key)) {
+            if (area.getId() == uuid) {
                 return true;
             }
         }
         return false;
     }
 
-    private void setRegattaIfNecessary(LeaderboardMasterData board, RacingEventService toState) {
-        if (board instanceof RegattaLeaderboardMasterData) {
-            RegattaLeaderboardMasterData regattaBoard = (RegattaLeaderboardMasterData) board;
-            Regatta regatta = toState.getRegatta(regattaBoard.getRegattaName());
-            regattaBoard.setRegatta(regatta);
-        }
-    }
-
-    private void setCourseAreaIfNecessary(LeaderboardMasterData board, RacingEventService toState) {
-        if (board instanceof FlexibleLeaderboardMasterData) {
-            FlexibleLeaderboardMasterData flexBoard = (FlexibleLeaderboardMasterData) board;
-            if (flexBoard.getCourseAreaId() == null) {
-                return;
-            }
-            CourseArea courseArea = toState.getCourseArea(UUID.fromString(flexBoard.getCourseAreaId()));
-            flexBoard.setCourseArea(courseArea);
-        }
-    }
-
     @Override
     public RacingEventServiceOperation<?> transformClientOp(RacingEventServiceOperation<?> serverOp) {
         // TODO Auto-generated method stub