Merge remote-tracking branch 'origin/master'

configuration/buildAndUpdateProduct.sh

@@ -442,8 +442,8 @@ if [[ "$@" == "remote-deploy" ]]; then
     esac
 
     echo ""
-    $SSH_CMD "cd $REMOTE_SERVER && $REMOTE_SERVER/stop"
-    $SSH_CMD "cd $REMOTE_SERVER && $REMOTE_SERVER/start"
+    $SSH_CMD "cd $REMOTE_SERVER && bash -l -c $REMOTE_SERVER/stop"
+    $SSH_CMD "cd $REMOTE_SERVER && bash -l -c $REMOTE_SERVER/start"
 
     echo "Restarted remote server. Please check."
 fi

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/MasterDataImportObjectCreationCount.java

@@ -0,0 +1,15 @@
+package com.sap.sailing.domain.common;
+
+import java.io.Serializable;
+
+public interface MasterDataImportObjectCreationCount extends Serializable{
+
+    public abstract int getLeaderboardCount();
+
+    public abstract int getLeaderboardGroupCount();
+
+    public abstract int getEventCount();
+
+    public abstract int getRegattaCount();
+
+}

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/impl/MasterDataImportObjectCreationCountImpl.java

@@ -0,0 +1,68 @@
+package com.sap.sailing.domain.common.impl;
+
+import com.sap.sailing.domain.common.MasterDataImportObjectCreationCount;
+
+
+/**
+ * Keeps track of how many instances of domain classes are created in the process of
+ * the master data import.
+ * 
+ * @author Frederik Petersen (D054528)
+ *
+ */
+public class MasterDataImportObjectCreationCountImpl implements MasterDataImportObjectCreationCount {
+    
+    private static final long serialVersionUID = -3677005970701170818L;
+    private int leaderboardCount = 0;
+    private int leaderboardGroupCount = 0;
+    private int eventCount = 0;
+    private int regattaCount = 0;
+    
+    //For GWT serialization
+    public MasterDataImportObjectCreationCountImpl() {};
+
+    public void addOneLeaderboard() {
+        leaderboardCount++;
+    }
+    
+    public void addOneLeaderboardGroup() {
+        leaderboardGroupCount++;
+    }
+    
+    public void addOneEvent() {
+        eventCount++;
+    }
+
+    public void addOneRegatta() {
+        regattaCount++;
+        
+    }
+
+    public void add(MasterDataImportObjectCreationCountImpl toAdd) {
+        leaderboardCount = leaderboardCount + toAdd.leaderboardCount;
+        leaderboardGroupCount = leaderboardGroupCount + toAdd.leaderboardGroupCount;
+        eventCount = eventCount + toAdd.eventCount;
+        regattaCount = regattaCount + toAdd.regattaCount;
+    }
+
+    @Override
+    public int getLeaderboardCount() {
+        return leaderboardCount;
+    }
+
+    @Override
+    public int getLeaderboardGroupCount() {
+        return leaderboardGroupCount;
+    }
+
+    @Override
+    public int getEventCount() {
+        return eventCount;
+    }
+
+    @Override
+    public int getRegattaCount() {
+        return regattaCount;
+    }
+   
+}

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/OnlineTracTracBasedTest.java

@@ -116,10 +116,14 @@ public abstract class OnlineTracTracBasedTest extends AbstractTracTracLiveTest {
         }
         logger.info("Stored data has been loaded for " + race.getName());
         for (Receiver receiver : receivers) {
+            logger.info("Stopping receiver "+receiver);
             receiver.stopAfterNotReceivingEventsForSomeTime(/* timeoutInMilliseconds */ 5000l);
+            logger.info("Stopped receiver "+receiver);
         }
         for (Receiver receiver : receivers) {
+            logger.info("Joining receiver "+receiver);
             receiver.join();
+            logger.info("Joined receiver "+receiver);
         }
         trackedRace = getTrackedRegatta().getTrackedRace(race);
     }

java/com.sap.sailing.domain/META-INF/MANIFEST.MF

@@ -14,6 +14,7 @@ Export-Package: com.sap.sailing.domain.base,
  com.sap.sailing.domain.leaderboard.caching,
  com.sap.sailing.domain.leaderboard.impl,
  com.sap.sailing.domain.leaderboard.meta,
+ com.sap.sailing.domain.masterdataimport,
  com.sap.sailing.domain.polarsheets,
  com.sap.sailing.domain.racelog,
  com.sap.sailing.domain.racelog.impl,

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

@@ -0,0 +1,89 @@
+package com.sap.sailing.domain.base;
+
+import java.util.List;
+import java.util.Map;
+
+import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
+import com.sap.sailing.domain.leaderboard.impl.ThresholdBasedResultDiscardingRuleImpl;
+import com.sap.sailing.domain.masterdataimport.ScoreCorrectionMasterData;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+
+public abstract class LeaderboardMasterData {
+
+    private String name;
+
+    private String displayName;
+
+    private int[] resultDiscardingRule;
+
+    private Map<String, Competitor> competitorsById;
+
+    private ScoreCorrectionMasterData scoreCorrection;
+
+    private Map<String, Double> carriedPoints;
+
+    private List<String> suppressedCompetitors;
+
+    private Map<String, String> displayNamesByCompetitorId;
+
+    private Map<String, Map<String, List<RaceLogEvent>>> raceLogEvents;
+
+    public LeaderboardMasterData(String name, String displayName, int[] resultDiscardingRule,
+            Map<String, Competitor> competitorsById, ScoreCorrectionMasterData scoreCorrection,
+            Map<String, Double> carriedPoints, List<String> suppressedCompetitors,
+            Map<String, String> displayNamesByCompetitorId, Map<String, Map<String, List<RaceLogEvent>>> raceLogEvents) {
+        this.name = name;
+        this.displayName = displayName;
+        this.resultDiscardingRule = resultDiscardingRule;
+        this.competitorsById = competitorsById;
+        this.scoreCorrection = scoreCorrection;
+        this.carriedPoints = carriedPoints;
+        this.suppressedCompetitors = suppressedCompetitors;
+        this.displayNamesByCompetitorId = displayNamesByCompetitorId;
+        this.raceLogEvents = raceLogEvents;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public ThresholdBasedResultDiscardingRule getResultDiscardingRule() {
+        if (resultDiscardingRule == null) {
+            return null;
+        }
+        ThresholdBasedResultDiscardingRule rule = new ThresholdBasedResultDiscardingRuleImpl(resultDiscardingRule);
+        return rule;
+    }
+
+    public Map<String, Competitor> getCompetitorsById() {
+        return competitorsById;
+    }
+
+    public ScoreCorrectionMasterData getScoreCorrection() {
+        return scoreCorrection;
+    }
+
+    public Map<String, Double> getCarriedPoints() {
+        return carriedPoints;
+    }
+
+    public List<String> getSuppressedCompetitors() {
+        return suppressedCompetitors;
+    }
+
+    public Map<String, String> getDisplayNamesByCompetitorId() {
+        return displayNamesByCompetitorId;
+    }
+
+    public Map<String, Map<String, List<RaceLogEvent>>> getRaceLogEvents() {
+        return raceLogEvents;
+    }
+
+    public abstract Leaderboard getLeaderboard();
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/EventMasterData.java

@@ -0,0 +1,49 @@
+package com.sap.sailing.domain.masterdataimport;
+
+import com.sap.sailing.domain.common.impl.Util.Pair;
+
+public class EventMasterData {
+
+    private String id;
+    private String name;
+    private String venueName;
+    private String pubUrl;
+    private Iterable<Pair<String, String>> courseAreas;
+    private boolean isPublic;
+
+    public EventMasterData(String id, String name, String venueName, String pubUrl, Iterable<Pair<String, String>> courseAreas, boolean isPublic) {
+        this.id = id;
+        this.name = name;
+        this.venueName = venueName;
+        this.pubUrl = pubUrl;
+        this.courseAreas = courseAreas;
+        this.isPublic = isPublic;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getVenueName() {
+        return venueName;
+    }
+
+    public String getPubUrl() {
+        return pubUrl;
+    }
+
+    public Iterable<Pair<String, String>> getCourseAreas() {
+        return courseAreas;
+    }
+
+    public boolean isPublic() {
+        return isPublic;
+    }
+    
+    
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/FlexibleLeaderboardMasterData.java

@@ -0,0 +1,59 @@
+package com.sap.sailing.domain.masterdataimport;
+
+import java.util.List;
+import java.util.Map;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.CourseArea;
+import com.sap.sailing.domain.base.LeaderboardMasterData;
+import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.ScoringScheme;
+import com.sap.sailing.domain.leaderboard.impl.FlexibleLeaderboardImpl;
+import com.sap.sailing.domain.leaderboard.impl.ScoreCorrectionImpl;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+
+public class FlexibleLeaderboardMasterData extends LeaderboardMasterData {
+
+    private ScoringScheme scoringScheme;
+
+    private String courseAreaId;
+
+    private CourseArea courseArea;
+
+    private List<RaceColumnMasterData> raceColumns;
+
+    public FlexibleLeaderboardMasterData(String name, String displayName, int[] resultDiscardingRule,
+            Map<String, Competitor> competitorsById, ScoreCorrectionMasterData scoreCorrection,
+            ScoringScheme scoringScheme, String courseAreaId, List<RaceColumnMasterData> raceColumns,
+            Map<String, Double> carriedPoints, List<String> suppressedCompetitors,
+            Map<String, String> displayNamesByCompetitorId, Map<String, Map<String, List<RaceLogEvent>>> raceLogEvents) {
+        super(name, displayName, resultDiscardingRule, competitorsById, scoreCorrection, carriedPoints,
+                suppressedCompetitors, displayNamesByCompetitorId, raceLogEvents);
+        this.scoringScheme = scoringScheme;
+        this.courseAreaId = courseAreaId;
+        this.raceColumns = raceColumns;
+    }
+
+    public ScoringScheme getScoringScheme() {
+        return scoringScheme;
+    }
+
+    public String getCourseAreaId() {
+        return courseAreaId;
+    }
+
+    public void setCourseArea(CourseArea courseArea) {
+        this.courseArea = courseArea;
+    }
+
+    @Override
+    public Leaderboard getLeaderboard() {
+        return new FlexibleLeaderboardImpl(getName(), new ScoreCorrectionImpl(), getResultDiscardingRule(),
+                scoringScheme, courseArea);
+    }
+
+    public List<RaceColumnMasterData> getRaceColumns() {
+        return raceColumns;
+    }
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/LeaderboardGroupMasterData.java

@@ -0,0 +1,62 @@
+package com.sap.sailing.domain.masterdataimport;
+
+import java.util.Set;
+
+import com.sap.sailing.domain.base.LeaderboardMasterData;
+
+/**
+ * Holds leaderboard group object AND its leaderboards, etc
+ * @author d054528
+ *
+ */
+public class LeaderboardGroupMasterData {
+
+    private String name;
+    private String description;
+    private LeaderboardMasterData overallLeaderboardMasterData;
+    private Iterable<LeaderboardMasterData> leaderboards;
+    private boolean displayGroupsRevese;
+    private Set<EventMasterData> events;
+    private Set<RegattaMasterData> regattas;
+
+    public LeaderboardGroupMasterData(String name, String description,
+            boolean displayGroupsRevese, LeaderboardMasterData overallLeaderboardMasterData, Iterable<LeaderboardMasterData> leaderboards, Set<EventMasterData> events, Set<RegattaMasterData> regattas) {
+                this.name = name;
+                this.description = description;
+                this.displayGroupsRevese = displayGroupsRevese;
+                this.overallLeaderboardMasterData = overallLeaderboardMasterData;
+                this.leaderboards = leaderboards;
+                this.events = events;
+                this.regattas = regattas;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public LeaderboardMasterData getOverallLeaderboardMasterData() {
+        return overallLeaderboardMasterData;
+    }
+
+    public Iterable<LeaderboardMasterData> getLeaderboards() {
+        return leaderboards;
+    }
+
+    public boolean isDisplayGroupsRevese() {
+        return displayGroupsRevese;
+    }
+
+    public Set<EventMasterData> getEvents() {
+        return events;
+    }
+
+    public Set<RegattaMasterData> getRegattas() {
+        return regattas;
+    }
+    
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/RaceColumnMasterData.java

@@ -0,0 +1,31 @@
+package com.sap.sailing.domain.masterdataimport;
+
+import java.util.Map;
+
+import com.sap.sailing.domain.common.RaceIdentifier;
+
+public class RaceColumnMasterData {
+    private final String name;
+    private final boolean medal;
+    private final Map<String, RaceIdentifier> raceIdentifiersByFleetName;
+    
+    public RaceColumnMasterData(String name, boolean medal, Map<String, RaceIdentifier> raceIdentifiersByFleetName) {
+        super();
+        this.name = name;
+        this.medal = medal;
+        this.raceIdentifiersByFleetName = raceIdentifiersByFleetName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean isMedal() {
+        return medal;
+    }
+
+    public Map<String, RaceIdentifier> getRaceIdentifiersByFleetName() {
+        return raceIdentifiersByFleetName;
+    }
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/RegattaLeaderboardMasterData.java

@@ -0,0 +1,46 @@
+package com.sap.sailing.domain.masterdataimport;
+
+import java.util.List;
+import java.util.Map;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.LeaderboardMasterData;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.common.RegattaIdentifier;
+import com.sap.sailing.domain.common.RegattaName;
+import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.impl.RegattaLeaderboardImpl;
+import com.sap.sailing.domain.leaderboard.impl.ScoreCorrectionImpl;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+
+public class RegattaLeaderboardMasterData extends LeaderboardMasterData {
+
+    private String regattaName;
+    private Regatta regatta;
+
+    public RegattaLeaderboardMasterData(String name, String displayName, int[] resultDiscardingRule,
+            Map<String, Competitor> competitorsById, ScoreCorrectionMasterData scoreCorrection, String regattaName,
+            Map<String, Double> carriedPoints, List<String> suppressedCompetitors,
+            Map<String, String> displayNamesByCompetitorId, Map<String, Map<String, List<RaceLogEvent>>> raceLogEvents) {
+        super(name, displayName, resultDiscardingRule, competitorsById, scoreCorrection, carriedPoints,
+                suppressedCompetitors, displayNamesByCompetitorId, raceLogEvents);
+        this.regattaName = regattaName;
+    }
+
+    public RegattaIdentifier getRegattaName() {
+        return new RegattaName(regattaName);
+    }
+
+    public void setRegatta(Regatta regatta) {
+        this.regatta = regatta;
+    }
+
+    @Override
+    public Leaderboard getLeaderboard() {
+        if (regatta == null) {
+            return null;
+        }
+        return new RegattaLeaderboardImpl(regatta, new ScoreCorrectionImpl(), getResultDiscardingRule());
+    }
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/RegattaMasterData.java

@@ -0,0 +1,68 @@
+package com.sap.sailing.domain.masterdataimport;
+
+public class RegattaMasterData {
+
+    private String id;
+    private String baseName;
+    private String defaultCourseAreaId;
+    private String boatClassName;
+    private String scoringSchemeType;
+    private Iterable<SeriesMasterData> series;
+    private boolean isPersistent;
+    private String regattaName;
+    private Iterable<String> raceIds;
+    
+
+    public RegattaMasterData(String id, String baseName, String defaultCourseAreaId, String boatClassName,
+            String scoringSchemeType, Iterable<SeriesMasterData> series, boolean isPersistent, String regattaName,
+            Iterable<String> raceIds) {
+                this.id = id;
+                this.baseName = baseName;
+                this.defaultCourseAreaId = defaultCourseAreaId;
+                this.boatClassName = boatClassName;
+                this.scoringSchemeType = scoringSchemeType;
+                this.series = series;
+                this.isPersistent = isPersistent;
+                this.regattaName = regattaName;
+                this.raceIds = raceIds;
+    }
+
+    public Iterable<String> getRaceIds() {
+        return raceIds;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getBaseName() {
+        return baseName;
+    }
+
+    public String getDefaultCourseAreaId() {
+        return defaultCourseAreaId;
+    }
+
+    public String getBoatClassName() {
+        return boatClassName;
+    }
+
+    public String getScoringSchemeType() {
+        return scoringSchemeType;
+    }
+
+    public Iterable<SeriesMasterData> getSeries() {
+        return series;
+    }
+
+    public boolean isPersistent() {
+        return isPersistent;
+    }
+
+    public String getRegattaName() {
+        return regattaName;
+    }
+    
+    
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/ScoreCorrectionMasterData.java

@@ -0,0 +1,29 @@
+package com.sap.sailing.domain.masterdataimport;
+
+import java.util.Map;
+
+public class ScoreCorrectionMasterData {
+
+    private String comment;
+    private Long timepointMillis;
+    private Map<String, Iterable<SingleScoreCorrectionMasterData>> correctionForRaceColumns;
+
+    public ScoreCorrectionMasterData(String comment, Long timepointMillis,
+            Map<String, Iterable<SingleScoreCorrectionMasterData>> correctionForRaceColumns) {
+                this.comment = comment;
+                this.timepointMillis = timepointMillis;
+                this.correctionForRaceColumns = correctionForRaceColumns;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public Long getTimepointMillis() {
+        return timepointMillis;
+    }
+
+    public Map<String, Iterable<SingleScoreCorrectionMasterData>> getCorrectionForRaceColumns() {
+        return correctionForRaceColumns;
+    }
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/SeriesMasterData.java

@@ -0,0 +1,42 @@
+package com.sap.sailing.domain.masterdataimport;
+
+import com.sap.sailing.domain.base.Fleet;
+
+public class SeriesMasterData {
+
+    private String name;
+    private boolean isMedal;
+    private Iterable<Fleet> fleets;
+    private Iterable<RaceColumnMasterData> raceColumns;
+    private int[] discardingRule;
+
+    public SeriesMasterData(String name, boolean isMedal, Iterable<Fleet> fleets, Iterable<RaceColumnMasterData> raceColumns, int[] discardingRule) {
+        this.name = name;
+        this.isMedal = isMedal;
+        this.fleets = fleets;
+        this.raceColumns = raceColumns;
+        this.discardingRule = discardingRule;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean isMedal() {
+        return isMedal;
+    }
+
+    public Iterable<Fleet> getFleets() {
+        return fleets;
+    }
+
+    public Iterable<RaceColumnMasterData> getRaceColumnNames() {
+        return raceColumns;
+    }
+
+    public int[] getDiscardingRule() {
+        return discardingRule;
+    }
+
+    
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/masterdataimport/SingleScoreCorrectionMasterData.java

@@ -0,0 +1,27 @@
+package com.sap.sailing.domain.masterdataimport;
+
+public class SingleScoreCorrectionMasterData {
+
+    private String competitorId;
+    private Double explicitScoreCorrection;
+    private String maxPointsReason;
+
+    public SingleScoreCorrectionMasterData(String competitorId, Double explicitScoreCorrection, String maxPointsReason) {
+        this.competitorId = competitorId;
+        this.explicitScoreCorrection = explicitScoreCorrection;
+        this.maxPointsReason = maxPointsReason;
+    }
+
+    public String getCompetitorId() {
+        return competitorId;
+    }
+
+    public Double getExplicitScoreCorrection() {
+        return explicitScoreCorrection;
+    }
+
+    public String getMaxPointsReason() {
+        return maxPointsReason;
+    }
+
+}

java/com.sap.sailing.gwt.ui/META-INF/MANIFEST.MF

@@ -25,7 +25,8 @@ Require-Bundle: com.sap.sailing.domain,
  com.googlecode.java-diff-utils;bundle-version="1.3.0",
  com.sap.sailing.freg.resultimport,
  com.sap.sailing.domain.swisstimingreplayadapter,
- com.sap.sailing.simulator;bundle-version="1.0.0"
+ com.sap.sailing.simulator;bundle-version="1.0.0",
+ com.sap.sailing.server.gateway.serialization;bundle-version="1.0.0"
 Bundle-Activator: com.sap.sailing.gwt.ui.server.Activator
 Bundle-ActivationPolicy: lazy
 Import-Package: javax.jms;version="1.1.0",

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/adminconsole/AdminConsoleEntryPoint.java

@@ -17,6 +17,7 @@ import com.sap.sailing.gwt.ui.client.RegattaDisplayer;
 import com.sap.sailing.gwt.ui.client.RegattaRefresher;
 import com.sap.sailing.gwt.ui.client.shared.panels.SystemInformationPanel;
 import com.sap.sailing.gwt.ui.client.shared.panels.UserStatusPanel;
+import com.sap.sailing.gwt.ui.masterdataimport.MasterDataImportPanel;
 import com.sap.sailing.gwt.ui.shared.RegattaDTO;
 
 public class AdminConsoleEntryPoint extends AbstractEntryPoint implements RegattaRefresher {
@@ -119,6 +120,9 @@ public class AdminConsoleEntryPoint extends AbstractEntryPoint implements Regatt
         final MediaPanel mediaPanel = new MediaPanel(mediaService, this, stringMessages);
         tabPanel.add(mediaPanel, stringMessages.mediaPanel(), /* asHTML */ false);
         
+        final MasterDataImportPanel masterDataImportPanel = new MasterDataImportPanel(stringMessages, sailingService);
+        tabPanel.add(masterDataImportPanel, stringMessages.masterDataImportPanel(), /* asHTML */ false);
+        
         tabPanel.selectTab(0);
         tabPanel.addSelectionHandler(new SelectionHandler<Integer>() {
             @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java

@@ -10,6 +10,7 @@ import java.util.Set;
 import com.google.gwt.user.client.rpc.RemoteService;
 import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
 import com.sap.sailing.domain.common.DetailType;
+import com.sap.sailing.domain.common.MasterDataImportObjectCreationCount;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.NauticalSide;
 import com.sap.sailing.domain.common.NoWindException;
@@ -319,4 +320,6 @@ public interface SailingService extends RemoteService {
     void stopSingleReplicaInstance(String identifier);
 
     void reloadRaceLog(String selectedLeaderboardName, RaceColumnDTO raceColumnDTO, FleetDTO fleet);
+
+    MasterDataImportObjectCreationCount importMasterData(String host, String[] groupNames, boolean override);
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingServiceAsync.java

@@ -9,6 +9,7 @@ import java.util.Set;
 
 import com.google.gwt.user.client.rpc.AsyncCallback;
 import com.sap.sailing.domain.common.DetailType;
+import com.sap.sailing.domain.common.MasterDataImportObjectCreationCount;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.NauticalSide;
 import com.sap.sailing.domain.common.PolarSheetGenerationTriggerResponse;
@@ -441,5 +442,7 @@ public interface SailingServiceAsync {
     void reloadRaceLog(String selectedLeaderboardName, RaceColumnDTO raceColumnDTO, FleetDTO fleet,
             AsyncCallback<Void> asyncCallback);
     
+    void importMasterData(String host, String[] names, boolean override, AsyncCallback<MasterDataImportObjectCreationCount> asyncCallback);
+    
 }
 

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.java

@@ -654,6 +654,8 @@ public interface StringMessages extends Messages {
     String addSeries();
     String regattaDefinesResultDiscardingRules();
     String startsWithZeroScore();
+    String masterDataImportPanel();
+    String importSuccess(int leaderboardGroups, int leaderboards, int events, int regattas);
     String regattaOverviewConfiguration();
     String firstRaceIsNonDiscardableCarryForward();
     String addReplicationMaster();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.properties

@@ -646,6 +646,8 @@ seriesDefinesResultDiscardingRule=Series defines result discarding rules
 addSeries=Add series
 regattaDefinesResultDiscardingRules=Regatta defines result discarding rules
 startsWithZeroScore=Series starts with zero score
+masterDataImportPanel=Master Data Import
+importSuccess=Success\nCreated {0} leaderboard group(s) and {1} leaderboard(s) and {2} event(s) and {3} regatta(s).
 regattaOverviewConfiguration=Regatta Overview Configuration
 firstRaceIsNonDiscardableCarryForward=Starts with non-discardable carry-forward
 addReplicationMaster=Connect to replication master server
@@ -690,4 +692,4 @@ unknown=Unknown
 earlyStarters=Early starters
 refreshRaceLog=Refresh race log
 raceLogReloaded=RaceLog successfully reloaded from database
-reloadAllRaceLogs=Reload all race logs
+reloadAllRaceLogs=Reload all race logs

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties

@@ -645,8 +645,8 @@ seriesDefinesResultDiscardingRule=Serie legt Streichregel fest
 addSeries=Serie hinzufügen
 regattaDefinesResultDiscardingRules=Streichergebnisse werden von der Regatta festgelegt
 startsWithZeroScore=Serie beginnt mit auf 0 gesetzten Ergebnissen
-regattaOverviewConfiguration=Regattaübersicht-Konfiguration
-firstRaceIsNonDiscardableCarryForward=Beginnt mit nicht streichbarem Übertrag
+masterDataImportPanel=Master Data Import
+importSuccess=Erfolg\nEs wurden {0} leaderboard group(s) und {1} leaderboard(s) und {2} event(s) und {3} regatta(s) erstellt.
 addReplicationMaster=Verbindung mit Master herstellen
 connect=Verbinden
 connectToMaster=Mit einem Master verbinden
@@ -688,4 +688,4 @@ unknown=Unbekannt
 earlyStarters=Frühstarter
 refreshRaceLog=RaceLog neu laden
 raceLogReloaded=RaceLog wurde neu geladen
-reloadAllRaceLogs=Alle RaceLogs neu laden
+reloadAllRaceLogs=Alle RaceLogs neu laden

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/masterdataimport/MasterDataImportPanel.java

@@ -0,0 +1,241 @@
+package com.sap.sailing.gwt.ui.masterdataimport;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.google.gwt.event.dom.client.ClickEvent;
+import com.google.gwt.event.dom.client.ClickHandler;
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.event.dom.client.KeyDownEvent;
+import com.google.gwt.event.dom.client.KeyDownHandler;
+import com.google.gwt.http.client.Request;
+import com.google.gwt.http.client.RequestBuilder;
+import com.google.gwt.http.client.RequestCallback;
+import com.google.gwt.http.client.RequestException;
+import com.google.gwt.http.client.Response;
+import com.google.gwt.json.client.JSONArray;
+import com.google.gwt.json.client.JSONParser;
+import com.google.gwt.json.client.JSONString;
+import com.google.gwt.regexp.shared.RegExp;
+import com.google.gwt.user.client.Window;
+import com.google.gwt.user.client.rpc.AsyncCallback;
+import com.google.gwt.user.client.ui.Button;
+import com.google.gwt.user.client.ui.CheckBox;
+import com.google.gwt.user.client.ui.HorizontalPanel;
+import com.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.ListBox;
+import com.google.gwt.user.client.ui.ScrollPanel;
+import com.google.gwt.user.client.ui.TextBox;
+import com.google.gwt.user.client.ui.VerticalPanel;
+import com.sap.sailing.domain.common.MasterDataImportObjectCreationCount;
+import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
+import com.sap.sailing.gwt.ui.client.StringMessages;
+
+public class MasterDataImportPanel extends VerticalPanel {
+
+    private ListBox leaderboardgroupListBox;
+    private TextBox hostBox;
+    private Button importLeaderboardGroupsButton;
+    private Button fetchIdsButton;
+
+    private RegExp urlValidator;
+    private RegExp urlPlusTldValidator;
+
+    /*
+     * TODO: use string messages
+     */
+    private final StringMessages stringMessages;
+    private String currentHost;
+    private SailingServiceAsync sailingService;
+    private CheckBox overrideSwitch;
+
+    public MasterDataImportPanel(StringMessages stringMessages, SailingServiceAsync sailingService) {
+        this.sailingService = sailingService;
+        this.stringMessages = stringMessages;
+
+        HorizontalPanel serverAddressPanel = new HorizontalPanel();
+        serverAddressPanel.add(new Label("Remote host:"));
+        hostBox = new TextBox();
+        hostBox.setText("http://prod2.sapsailing.com/");
+        hostBox.setWidth("300px");
+        serverAddressPanel.add(hostBox);
+        fetchIdsButton = new Button("Fetch Leaderboard Group List");
+        serverAddressPanel.add(fetchIdsButton);
+        this.add(serverAddressPanel);
+
+        ScrollPanel scrollPanel = new ScrollPanel();
+        this.add(scrollPanel);
+
+        VerticalPanel contentPanel = new VerticalPanel();
+        scrollPanel.setWidget(contentPanel);
+
+        addContentToLeftPanel(contentPanel);
+
+        setListeners();
+    }
+
+    private void setListeners() {
+        fetchIdsButton.addClickHandler(new ClickHandler() {
+
+            @Override
+            public void onClick(ClickEvent event) {
+                fireIdRequestsAndFillLists();
+            }
+        });
+
+        hostBox.addKeyDownHandler(new KeyDownHandler() {
+
+            @Override
+            public void onKeyDown(KeyDownEvent event) {
+                if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
+                    fireIdRequestsAndFillLists();
+                }
+            }
+        });
+
+        importLeaderboardGroupsButton.addClickHandler(new ClickHandler() {
+
+            @Override
+            public void onClick(ClickEvent event) {
+                importLeaderboardGroups();
+            }
+        });
+    }
+
+    protected void importLeaderboardGroups() {
+        String[] groupNames = createLeaderBoardGroupNamesFromListBox();
+        boolean override = overrideSwitch.getValue();
+        sailingService.importMasterData(currentHost, groupNames, override,
+                new AsyncCallback<MasterDataImportObjectCreationCount>() {
+
+                    @Override
+                    public void onSuccess(MasterDataImportObjectCreationCount result) {
+                        int leaderboardsCreated = result.getLeaderboardCount();
+                        int leaderboardGroupsCreated = result.getLeaderboardGroupCount();
+                        int eventsCreated = result.getEventCount();
+                        int regattasCreated = result.getRegattaCount();
+                        showSuccessAlert(leaderboardsCreated, leaderboardGroupsCreated, eventsCreated, regattasCreated);
+                    }
+
+                    @Override
+                    public void onFailure(Throwable caught) {
+                        showErrorAlert(caught.getLocalizedMessage());
+                    }
+                });
+    }
+
+
+    protected void showSuccessAlert(int leaderboardsCreated, int leaderboardGroupsCreated, int eventsCreated,
+            int regattasCreated) {
+        Window.alert(stringMessages.importSuccess(leaderboardGroupsCreated, leaderboardsCreated, eventsCreated,
+                regattasCreated));
+
+    }
+
+    private String[] createLeaderBoardGroupNamesFromListBox() {
+        List<String> names = new ArrayList<String>();
+        for (int i = 0; i < leaderboardgroupListBox.getItemCount(); i++) {
+            if (leaderboardgroupListBox.isItemSelected(i)) {
+                names.add(leaderboardgroupListBox.getValue(i));
+            }
+        }
+        return names.toArray(new String[names.size()]);
+    }
+
+    protected void fireIdRequestsAndFillLists() {
+        String host = hostBox.getText();
+        if (host != null && !host.isEmpty()) {
+            fireLgIdRequestAndFillList(host);
+        }
+    }
+
+    private void fireLgIdRequestAndFillList(String host) {
+        currentHost = host;
+        final String getLgsUrl = createGetLgsUrl(host);
+        if (!isValidUrl(getLgsUrl, false)) {
+            showErrorAlert("Not a valid URL for fetching leaderboardgroups: " + getLgsUrl);
+            return;
+        }
+        RequestBuilder getLgsRequestBuilder = new RequestBuilder(RequestBuilder.GET, getLgsUrl);
+        getLgsRequestBuilder.setCallback(new RequestCallback() {
+
+            @Override
+            public void onResponseReceived(Request request, Response response) {
+                if (response.getStatusCode() != 200) {
+                    showErrorAlert("GET leaderboardgroups request failed with error code: " + response.getStatusCode()
+                            + " For url: " + getLgsUrl);
+                }
+                int itemCount = leaderboardgroupListBox.getItemCount();
+                for (int i = itemCount - 1; i >= 0; i--) {
+                    leaderboardgroupListBox.removeItem(i);
+                }
+                String body = response.getText();
+                if (body == null || body.isEmpty()) {
+                    showErrorAlert("No data was returned by remote server.");
+                    return;
+                }
+                JSONArray leaderboardGroups = JSONParser.parseStrict(body).isArray();
+                leaderboardgroupListBox.setVisibleItemCount(leaderboardGroups.size());
+                for (int i = 0; i < leaderboardGroups.size(); i++) {
+                    JSONString leaderboardGroupName = leaderboardGroups.get(i).isString();
+                    leaderboardgroupListBox.addItem(leaderboardGroupName.stringValue());
+                }
+            }
+
+            @Override
+            public void onError(Request request, Throwable exception) {
+                showErrorAlert("GET leaderboardgroups request failed with Server error: "
+                        + exception.getLocalizedMessage());
+            }
+        });
+        try {
+            getLgsRequestBuilder.send();
+        } catch (RequestException e) {
+            showErrorAlert("GET leaderboardgroups request failed: " + e.getLocalizedMessage());
+        }
+    }
+
+    private String createGetLgsUrl(String host) {
+        StringBuffer urlBuffer = new StringBuffer(host);
+        appendHttpAndSlashIfNeeded(host, urlBuffer);
+        urlBuffer.append("sailingserver/leaderboardgroups");
+        return urlBuffer.toString();
+    }
+
+    private void appendHttpAndSlashIfNeeded(String host, StringBuffer urlBuffer) {
+        if (!host.endsWith("/")) {
+            urlBuffer.append("/");
+        }
+        if (!host.startsWith("http://")) {
+            urlBuffer.insert(0, "http://");
+        }
+    }
+
+    private void showErrorAlert(String string) {
+        Window.alert(string);
+    }
+
+    public boolean isValidUrl(String url, boolean topLevelDomainRequired) {
+        if (urlValidator == null || urlPlusTldValidator == null) {
+            urlValidator = RegExp
+                    .compile("^((ftp|http|https)://[\\w@.\\-\\_]+(:\\d{1,5})?(/[\\w#!:.?+=&%@!\\_\\-/]+)*){1}$");
+            urlPlusTldValidator = RegExp
+                    .compile("^((ftp|http|https)://[\\w@.\\-\\_]+\\.[a-zA-Z]{2,}(:\\d{1,5})?(/[\\w#!:.?+=&%@!\\_\\-/]+)*){1}$");
+        }
+        return (topLevelDomainRequired ? urlPlusTldValidator : urlValidator).exec(url) != null;
+    }
+
+    private void addContentToLeftPanel(VerticalPanel contentPanel) {
+        contentPanel.add(new Label("Leaderboard Groups:"));
+
+        leaderboardgroupListBox = new ListBox(true);
+        contentPanel.add(leaderboardgroupListBox);
+        
+        overrideSwitch = new CheckBox("Override existing data if names and ids match");
+        overrideSwitch.setValue(false);
+
+        importLeaderboardGroupsButton = new Button("Import selected Leaderboard Groups");
+        contentPanel.add(importLeaderboardGroupsButton);
+    }
+
+}

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

@@ -1,8 +1,11 @@
 package com.sap.sailing.gwt.ui.server;
 
+import java.io.BufferedReader;
 import java.io.IOException;
+import java.io.InputStreamReader;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
+import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -42,9 +45,13 @@ import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpSession;
 
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
 import org.osgi.framework.BundleContext;
 import org.osgi.util.tracker.ServiceTracker;
 
+import com.google.gwt.regexp.shared.RegExp;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
@@ -75,6 +82,7 @@ import com.sap.sailing.domain.common.Distance;
 import com.sap.sailing.domain.common.LeaderboardNameConstants;
 import com.sap.sailing.domain.common.LegType;
 import com.sap.sailing.domain.common.ManeuverType;
+import com.sap.sailing.domain.common.MasterDataImportObjectCreationCount;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.NauticalSide;
 import com.sap.sailing.domain.common.NoWindError;
@@ -115,6 +123,7 @@ import com.sap.sailing.domain.common.dto.TrackedRaceDTO;
 import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.common.impl.KilometersPerHourSpeedImpl;
+import com.sap.sailing.domain.common.impl.MasterDataImportObjectCreationCountImpl;
 import com.sap.sailing.domain.common.impl.MeterDistance;
 import com.sap.sailing.domain.common.impl.PolarSheetGenerationTriggerResponseImpl;
 import com.sap.sailing.domain.common.impl.PolarSheetsHistogramDataImpl;
@@ -132,6 +141,7 @@ import com.sap.sailing.domain.leaderboard.MetaLeaderboard;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
 import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
 import com.sap.sailing.domain.leaderboard.caching.LiveLeaderboardUpdater;
+import com.sap.sailing.domain.masterdataimport.LeaderboardGroupMasterData;
 import com.sap.sailing.domain.persistence.DomainObjectFactory;
 import com.sap.sailing.domain.persistence.MongoFactory;
 import com.sap.sailing.domain.persistence.MongoObjectFactory;
@@ -236,6 +246,9 @@ import com.sap.sailing.resultimport.ResultUrlProvider;
 import com.sap.sailing.resultimport.ResultUrlRegistry;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sailing.server.RacingEventServiceOperation;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.masterdata.impl.LeaderboardGroupMasterDataJsonDeserializer;
 import com.sap.sailing.server.operationaltransformation.AddColumnToLeaderboard;
 import com.sap.sailing.server.operationaltransformation.AddColumnToSeries;
 import com.sap.sailing.server.operationaltransformation.AddCourseArea;
@@ -246,6 +259,7 @@ import com.sap.sailing.server.operationaltransformation.CreateFlexibleLeaderboar
 import com.sap.sailing.server.operationaltransformation.CreateLeaderboardGroup;
 import com.sap.sailing.server.operationaltransformation.CreateRegattaLeaderboard;
 import com.sap.sailing.server.operationaltransformation.DisconnectLeaderboardColumnFromTrackedRace;
+import com.sap.sailing.server.operationaltransformation.ImportMasterDataOperation;
 import com.sap.sailing.server.operationaltransformation.MoveColumnInSeriesDown;
 import com.sap.sailing.server.operationaltransformation.MoveColumnInSeriesUp;
 import com.sap.sailing.server.operationaltransformation.MoveLeaderboardColumnDown;
@@ -3145,4 +3159,123 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
     public void reloadRaceLog(String selectedLeaderboardName, RaceColumnDTO raceColumnDTO, FleetDTO fleet) {
         getService().reloadRaceLog(selectedLeaderboardName, raceColumnDTO, fleet);
     }
+    
+    @Override
+    public MasterDataImportObjectCreationCount importMasterData(String host, String[] groupNames, boolean override) {
+        String getMasterDataUrl = createGetMasterDataForLgsUrl(host);
+        if (!isValidUrl(getMasterDataUrl, false)) {
+            throw new RuntimeException("Not a valid URL for fetching leaderboardgroups masterdata: " + getMasterDataUrl);
+        }
+        String query = createLeaderboardQuery(groupNames);
+        HttpURLConnection connection = null;
+        BufferedReader rd  = null;
+        StringBuilder sb = null;
+        String line = null;
+      
+        URL serverAddress = null;
+      
+        try {
+            serverAddress = parseUrl(getMasterDataUrl + query);
+            //set up out communications stuff
+            connection = null;
+          
+            //Set up the initial connection
+            connection = (HttpURLConnection)serverAddress.openConnection();
+            connection.setRequestMethod("GET");
+            connection.setDoOutput(true);
+            connection.setReadTimeout(10000);
+                      
+            connection.connect();
+          
+            //read the result from the server
+            rd  = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+            sb = new StringBuilder();
+
+            while ((line = rd.readLine()) != null) {
+                sb.append(line);
+            }
+
+            return importFromHttpResponse(sb.toString(), override);
+
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            // close the connection, set all objects to null
+            connection.disconnect();
+            rd = null;
+            sb = null;
+            connection = null;
+        }
+    }
+    
+    private URL parseUrl(String s) throws Exception {
+        URL u = new URL(s);
+        return new URI(
+               u.getProtocol(), 
+               u.getAuthority(), 
+               u.getPath(),
+               u.getQuery(), 
+               u.getRef()).
+               toURL();
+   }
+    
+    protected MasterDataImportObjectCreationCountImpl importFromHttpResponse(String response, boolean override) {
+        MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
+        JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer = LeaderboardGroupMasterDataJsonDeserializer
+                .create(baseDomainFactory);
+        JSONParser parser = new JSONParser();
+        try {
+            JSONArray leaderboardGroupsMasterDataJsonArray = (JSONArray) parser.parse(response);
+            for (Object leaderBoardGroupMasterData : leaderboardGroupsMasterDataJsonArray) {
+                JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
+                LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
+                        .deserialize(leaderBoardGroupMasterDataJson);
+                ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, override);
+                creationCount.add(getService().apply(op));
+            }
+        } catch (org.json.simple.parser.ParseException e) {
+            throw new RuntimeException(e);
+        } catch (JsonDeserializationException e) {
+            throw new RuntimeException(e);
+        }
+        
+        return creationCount;
+    }
+
+    private String createLeaderboardQuery(String[] groupNames) {
+        StringBuffer queryStringBuffer = new StringBuffer("?");
+        for (int i = 0; i < groupNames.length; i++) {
+            queryStringBuffer.append("names[]=" + groupNames[i] + "&");
+        }
+        if (queryStringBuffer.length() == 1) {
+            return "";
+        } else {
+            // Delete last "&"
+            queryStringBuffer.deleteCharAt(queryStringBuffer.length() - 1);
+        }
+        return queryStringBuffer.toString();
+    }
+    
+    private boolean isValidUrl(String url, boolean topLevelDomainRequired) {
+            RegExp urlValidator = RegExp
+                    .compile("^((ftp|http|https)://[\\w@.\\-\\_]+(:\\d{1,5})?(/[\\w#!:.?+=&%@!\\_\\-/]+)*){1}$");
+        return urlValidator.exec(url) != null;
+    }
+    
+    private String createGetMasterDataForLgsUrl(String host) {
+        StringBuffer urlBuffer = new StringBuffer(host);
+        appendHttpAndSlashIfNeeded(host, urlBuffer);
+        urlBuffer.append("sailingserver/masterdata/leaderboardgroups");
+        return urlBuffer.toString();
+    }
+    
+    private void appendHttpAndSlashIfNeeded(String host, StringBuffer urlBuffer) {
+        if (!host.endsWith("/")) {
+            urlBuffer.append("/");
+        }
+        if (!host.startsWith("http://")) {
+            urlBuffer.insert(0, "http://");
+        }
+    }
+
 }

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/ui/AdminConsole.gwt.xml

@@ -48,6 +48,7 @@
   <source path='adminconsole'/>
   <source path='leaderboard'/>
   <source path='raceboard'/>
+  <source path='masterdataimport'/>
   <source path='usermanagement'/>
   <source path='shared'/>
   <source path='test'/>

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/ui/Leaderboard.gwt.xml

@@ -32,6 +32,7 @@
   <source path='leaderboard'/>
   <source path='raceboard'/>
   <source path='adminconsole'/>
+  <source path='masterdataimport'/>
   <source path='usermanagement'/>
   <source path='shared'/>
   <source path='common'/>

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/ui/LeaderboardEditing.gwt.xml

@@ -36,4 +36,5 @@
   <source path='usermanagement'/>
   <source path='shared'/>
   <source path='actions'/>
+  <source path='masterdataimport'/>
 </module>

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/ui/PolarSheets.gwt.xml

@@ -16,6 +16,7 @@
 	<source path='shared' />
 	<source path='common' />
 	<source path='actions' />
+	<source path='masterdataimport'/>
 	<entry-point class="com.sap.sailing.gwt.ui.polarsheets.PolarSheetsEntryPoint">
 	</entry-point>
 

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/ui/RaceBoard.gwt.xml

@@ -36,4 +36,5 @@
   <source path='usermanagement'/>
   <source path='shared'/>
   <source path='actions'/>
+  <source path='masterdataimport'/>
 </module>

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/ui/Spectator.gwt.xml

@@ -40,4 +40,5 @@
   <source path='usermanagement'/>
   <source path='test'/>
   <source path='actions'/>
+  <source path='masterdataimport'/>
 </module>

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/ui/TvView.gwt.xml

@@ -38,4 +38,5 @@
   <source path='shared'/>
   <source path='common'/>
   <source path='actions'/>
+  <source path='masterdataimport'/>
 </module>

java/com.sap.sailing.server.gateway.serialization.test/src/com/sap/sailing/server/gateway/serialization/test/racelog/RaceLogCourseDesignChangedEventSerializerTest.java

@@ -40,86 +40,84 @@ import com.sap.sailing.server.gateway.serialization.coursedata.impl.GateJsonSeri
 import com.sap.sailing.server.gateway.serialization.coursedata.impl.MarkJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.coursedata.impl.WaypointJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogCourseDesignChangedEventSerializer;
 
 public class RaceLogCourseDesignChangedEventSerializerTest {
-    
+
     private RaceLogCourseDesignChangedEventSerializer serializer;
     private RaceLogCourseDesignChangedEventDeserializer deserializer;
     private RaceLogCourseDesignChangedEvent event;
     private TimePoint now;
-    
+
     @Before
     public void setUp() {
         SharedDomainFactory factory = DomainFactory.INSTANCE;
-        serializer = new RaceLogCourseDesignChangedEventSerializer(new CompetitorJsonSerializer(new TeamJsonSerializer(new PersonJsonSerializer())), 
-                new CourseBaseJsonSerializer(new WaypointJsonSerializer(
-                        new ControlPointJsonSerializer(
-                                new MarkJsonSerializer(), 
-                                new GateJsonSerializer(
-                                        new MarkJsonSerializer())))));
-        deserializer = new RaceLogCourseDesignChangedEventDeserializer(new CompetitorDeserializer(factory), new CourseDataDeserializer(
-                new WaypointDeserializer(
-                        new ControlPointDeserializer(
-                                new MarkDeserializer(factory), 
-                                new GateDeserializer(factory, new MarkDeserializer(factory))))));
+        NationalityJsonSerializer nationalityJsonSerializer = new NationalityJsonSerializer();
+        serializer = new RaceLogCourseDesignChangedEventSerializer(new CompetitorJsonSerializer(new TeamJsonSerializer(
+                new PersonJsonSerializer(nationalityJsonSerializer))),
+                new CourseBaseJsonSerializer(new WaypointJsonSerializer(new ControlPointJsonSerializer(
+                        new MarkJsonSerializer(), new GateJsonSerializer(new MarkJsonSerializer())))));
+        deserializer = new RaceLogCourseDesignChangedEventDeserializer(new CompetitorDeserializer(factory),
+                new CourseDataDeserializer(new WaypointDeserializer(new ControlPointDeserializer(new MarkDeserializer(
+                        factory), new GateDeserializer(factory, new MarkDeserializer(factory))))));
         now = MillisecondsTimePoint.now();
-        
+
         event = RaceLogEventFactory.INSTANCE.createCourseDesignChangedEvent(now, 0, createCourseData());
     }
-    
+
     @Test
     public void testSerializeAndDeserializeRaceLogCourseDesignChangedEvent() throws JsonDeserializationException {
         JSONObject jsonCourseDesignEvent = serializer.serialize(event);
-        RaceLogCourseDesignChangedEvent deserializedEvent = (RaceLogCourseDesignChangedEvent) deserializer.deserialize(jsonCourseDesignEvent);
-        
+        RaceLogCourseDesignChangedEvent deserializedEvent = (RaceLogCourseDesignChangedEvent) deserializer
+                .deserialize(jsonCourseDesignEvent);
+
         assertEquals(event.getId(), deserializedEvent.getId());
         assertEquals(event.getPassId(), deserializedEvent.getPassId());
         assertEquals(event.getTimePoint(), deserializedEvent.getTimePoint());
         assertEquals(0, Util.size(event.getInvolvedBoats()));
         assertEquals(0, Util.size(deserializedEvent.getInvolvedBoats()));
-        
+
         compareCourseData(event.getCourseDesign(), deserializedEvent.getCourseDesign());
     }
 
-    
     protected CourseBase createCourseData() {
         CourseBase course = new CourseDataImpl("Test Course");
-        
-        course.addWaypoint(0, new WaypointImpl(new GateImpl(UUID.randomUUID(), 
-                new MarkImpl(UUID.randomUUID(), "Black", MarkType.BUOY, "black", "round", "circle"),
-                new MarkImpl(UUID.randomUUID(), "Green", MarkType.BUOY, "green", "round", "circle"),
-                "Upper gate")));
-        course.addWaypoint(1, new WaypointImpl(new MarkImpl(UUID.randomUUID(), "White", MarkType.BUOY, "white", "conical", "bold"), NauticalSide.PORT));
-        
+
+        course.addWaypoint(0, new WaypointImpl(new GateImpl(UUID.randomUUID(), new MarkImpl(UUID.randomUUID(), "Black",
+                MarkType.BUOY, "black", "round", "circle"), new MarkImpl(UUID.randomUUID(), "Green", MarkType.BUOY,
+                "green", "round", "circle"), "Upper gate")));
+        course.addWaypoint(1, new WaypointImpl(new MarkImpl(UUID.randomUUID(), "White", MarkType.BUOY, "white",
+                "conical", "bold"), NauticalSide.PORT));
+
         return course;
     }
-    
+
     protected void compareCourseData(CourseBase serializedCourse, CourseBase deserializedCourse) {
         assertEquals(serializedCourse.getFirstWaypoint().getPassingSide(), null);
         assertEquals(deserializedCourse.getFirstWaypoint().getPassingSide(), null);
         Assert.assertTrue(serializedCourse.getFirstWaypoint().getControlPoint() instanceof Gate);
         Assert.assertTrue(deserializedCourse.getFirstWaypoint().getControlPoint() instanceof Gate);
-        
+
         Gate serializedGate = (Gate) serializedCourse.getFirstWaypoint().getControlPoint();
         Gate deserializedGate = (Gate) deserializedCourse.getFirstWaypoint().getControlPoint();
-        
+
         assertEquals(serializedGate.getName(), deserializedGate.getName());
         compareMarks(serializedGate.getLeft(), deserializedGate.getLeft());
         compareMarks(serializedGate.getRight(), deserializedGate.getRight());
-        
+
         assertEquals(serializedCourse.getLastWaypoint().getPassingSide(), NauticalSide.PORT);
         assertEquals(deserializedCourse.getLastWaypoint().getPassingSide(), NauticalSide.PORT);
         Assert.assertTrue(serializedCourse.getLastWaypoint().getControlPoint() instanceof Mark);
         Assert.assertTrue(deserializedCourse.getLastWaypoint().getControlPoint() instanceof Mark);
-        
+
         Mark serializedMark = (Mark) serializedCourse.getLastWaypoint().getControlPoint();
         Mark deserializedMark = (Mark) deserializedCourse.getLastWaypoint().getControlPoint();
         compareMarks(serializedMark, deserializedMark);
     }
-    
+
     private void compareMarks(Mark serializedMark, Mark deserializedMark) {
         assertEquals(serializedMark.getId(), deserializedMark.getId());
         assertEquals(serializedMark.getColor(), deserializedMark.getColor());

java/com.sap.sailing.server.gateway.serialization.test/src/com/sap/sailing/server/gateway/serialization/test/racelog/RaceLogFinishPositioningConfirmedEventSerializerTest.java

@@ -26,22 +26,24 @@ import com.sap.sailing.server.gateway.deserialization.JsonDeserializationExcepti
 import com.sap.sailing.server.gateway.deserialization.impl.CompetitorDeserializer;
 import com.sap.sailing.server.gateway.deserialization.racelog.impl.RaceLogFinishPositioningConfirmedEventDeserializer;
 import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogFinishPositioningConfirmedEventSerializer;
 
 public class RaceLogFinishPositioningConfirmedEventSerializerTest {
-    
+
     private RaceLogFinishPositioningConfirmedEventSerializer serializer;
     private RaceLogFinishPositioningConfirmedEventDeserializer deserializer;
     private RaceLogFinishPositioningConfirmedEvent event;
     private TimePoint now;
     private List<Triple<Serializable, String, MaxPointsReason>> positioningList;
-    
+
     @Before
     public void setUp() {
         SharedDomainFactory factory = DomainFactory.INSTANCE;
-        serializer = new RaceLogFinishPositioningConfirmedEventSerializer(new CompetitorJsonSerializer(new TeamJsonSerializer(new PersonJsonSerializer())));
+        serializer = new RaceLogFinishPositioningConfirmedEventSerializer(new CompetitorJsonSerializer(
+                new TeamJsonSerializer(new PersonJsonSerializer(new NationalityJsonSerializer()))));
         deserializer = new RaceLogFinishPositioningConfirmedEventDeserializer(new CompetitorDeserializer(factory));
 
         now = MillisecondsTimePoint.now();
@@ -50,11 +52,13 @@ public class RaceLogFinishPositioningConfirmedEventSerializerTest {
 
     @Test
     public void testSerializeAndDeserializeRaceLogFinishPositioningConfirmedEvent() throws JsonDeserializationException {
-        positioningList.add(new Triple<Serializable, String, MaxPointsReason>(UUID.randomUUID(), "SAP Extreme", MaxPointsReason.NONE));
+        positioningList.add(new Triple<Serializable, String, MaxPointsReason>(UUID.randomUUID(), "SAP Extreme",
+                MaxPointsReason.NONE));
         event = RaceLogEventFactory.INSTANCE.createFinishPositioningConfirmedEvent(now, 0, positioningList);
         JSONObject jsonConfirmationEvent = serializer.serialize(event);
-        RaceLogFinishPositioningConfirmedEvent deserializedEvent = (RaceLogFinishPositioningConfirmedEvent) deserializer.deserialize(jsonConfirmationEvent);
-        
+        RaceLogFinishPositioningConfirmedEvent deserializedEvent = (RaceLogFinishPositioningConfirmedEvent) deserializer
+                .deserialize(jsonConfirmationEvent);
+
         assertEquals(event.getId(), deserializedEvent.getId());
         assertEquals(event.getPassId(), deserializedEvent.getPassId());
         assertEquals(event.getTimePoint(), deserializedEvent.getTimePoint());
@@ -64,17 +68,22 @@ public class RaceLogFinishPositioningConfirmedEventSerializerTest {
         assertNotNull(deserializedEvent.getPositionedCompetitors());
         assertEquals(1, event.getPositionedCompetitors().size());
         assertEquals(1, deserializedEvent.getPositionedCompetitors().size());
-        assertEquals(event.getPositionedCompetitors().get(0).getA(), deserializedEvent.getPositionedCompetitors().get(0).getA());
-        assertEquals(event.getPositionedCompetitors().get(0).getB(), deserializedEvent.getPositionedCompetitors().get(0).getB());
-        assertEquals(event.getPositionedCompetitors().get(0).getC(), deserializedEvent.getPositionedCompetitors().get(0).getC());
+        assertEquals(event.getPositionedCompetitors().get(0).getA(), deserializedEvent.getPositionedCompetitors()
+                .get(0).getA());
+        assertEquals(event.getPositionedCompetitors().get(0).getB(), deserializedEvent.getPositionedCompetitors()
+                .get(0).getB());
+        assertEquals(event.getPositionedCompetitors().get(0).getC(), deserializedEvent.getPositionedCompetitors()
+                .get(0).getC());
     }
-    
+
     @Test
-    public void testSerializeAndDeserializeRaceLogFinishPositioningConfirmedEventWithoutPositioningBackwardsCompatible() throws JsonDeserializationException {
+    public void testSerializeAndDeserializeRaceLogFinishPositioningConfirmedEventWithoutPositioningBackwardsCompatible()
+            throws JsonDeserializationException {
         event = RaceLogEventFactory.INSTANCE.createFinishPositioningConfirmedEvent(now, 0, null);
         JSONObject jsonConfirmationEvent = serializer.serialize(event);
-        RaceLogFinishPositioningConfirmedEvent deserializedEvent = (RaceLogFinishPositioningConfirmedEvent) deserializer.deserialize(jsonConfirmationEvent);
-        
+        RaceLogFinishPositioningConfirmedEvent deserializedEvent = (RaceLogFinishPositioningConfirmedEvent) deserializer
+                .deserialize(jsonConfirmationEvent);
+
         assertEquals(event.getId(), deserializedEvent.getId());
         assertEquals(event.getPassId(), deserializedEvent.getPassId());
         assertEquals(event.getTimePoint(), deserializedEvent.getTimePoint());
@@ -84,13 +93,15 @@ public class RaceLogFinishPositioningConfirmedEventSerializerTest {
         assertNotNull(deserializedEvent.getPositionedCompetitors());
         assertEquals(0, deserializedEvent.getPositionedCompetitors().size());
     }
-    
+
     @Test
-    public void testSerializeAndDeserializeRaceLogFinishPositioningConfirmedEventWithEmptyPositioning() throws JsonDeserializationException {
+    public void testSerializeAndDeserializeRaceLogFinishPositioningConfirmedEventWithEmptyPositioning()
+            throws JsonDeserializationException {
         event = RaceLogEventFactory.INSTANCE.createFinishPositioningConfirmedEvent(now, 0, positioningList);
         JSONObject jsonConfirmationEvent = serializer.serialize(event);
-        RaceLogFinishPositioningConfirmedEvent deserializedEvent = (RaceLogFinishPositioningConfirmedEvent) deserializer.deserialize(jsonConfirmationEvent);
-        
+        RaceLogFinishPositioningConfirmedEvent deserializedEvent = (RaceLogFinishPositioningConfirmedEvent) deserializer
+                .deserialize(jsonConfirmationEvent);
+
         assertEquals(event.getId(), deserializedEvent.getId());
         assertEquals(event.getPassId(), deserializedEvent.getPassId());
         assertEquals(event.getTimePoint(), deserializedEvent.getTimePoint());
@@ -101,5 +112,5 @@ public class RaceLogFinishPositioningConfirmedEventSerializerTest {
         assertEquals(0, event.getPositionedCompetitors().size());
         assertEquals(0, deserializedEvent.getPositionedCompetitors().size());
     }
-    
+
 }

java/com.sap.sailing.server.gateway.serialization.test/src/com/sap/sailing/server/gateway/serialization/test/racelog/RaceLogWindFixEventSerializerTest.java

@@ -28,6 +28,7 @@ import com.sap.sailing.server.gateway.deserialization.impl.PositionJsonDeseriali
 import com.sap.sailing.server.gateway.deserialization.impl.WindJsonDeserializer;
 import com.sap.sailing.server.gateway.deserialization.racelog.impl.RaceLogWindFixEventDeserializer;
 import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PositionJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
@@ -35,22 +36,23 @@ import com.sap.sailing.server.gateway.serialization.impl.WindJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogWindFixEventSerializer;
 
 public class RaceLogWindFixEventSerializerTest {
-    
+
     private RaceLogWindFixEventSerializer serializer;
     private RaceLogWindFixEventDeserializer deserializer;
     private RaceLogWindFixEvent event;
     private TimePoint now;
-    
+
     @Before
     public void setUp() {
         SharedDomainFactory factory = DomainFactory.INSTANCE;
-        serializer = new RaceLogWindFixEventSerializer(new CompetitorJsonSerializer(new TeamJsonSerializer(new PersonJsonSerializer())), 
-                new WindJsonSerializer(new PositionJsonSerializer()));
-        deserializer = new RaceLogWindFixEventDeserializer(new CompetitorDeserializer(factory), 
+        serializer = new RaceLogWindFixEventSerializer(new CompetitorJsonSerializer(new TeamJsonSerializer(
+                new PersonJsonSerializer(new NationalityJsonSerializer()))), new WindJsonSerializer(
+                new PositionJsonSerializer()));
+        deserializer = new RaceLogWindFixEventDeserializer(new CompetitorDeserializer(factory),
                 new WindJsonDeserializer(new PositionJsonDeserializer()));
 
         now = MillisecondsTimePoint.now();
-        
+
         event = RaceLogEventFactory.INSTANCE.createWindFixEvent(now, 0, createWindFix());
     }
 
@@ -58,16 +60,16 @@ public class RaceLogWindFixEventSerializerTest {
     public void testSerializeAndDeserializeRaceLogWindFixEvent() throws JsonDeserializationException {
         JSONObject jsonWindFixEvent = serializer.serialize(event);
         RaceLogWindFixEvent deserializedEvent = (RaceLogWindFixEvent) deserializer.deserialize(jsonWindFixEvent);
-        
+
         assertEquals(event.getId(), deserializedEvent.getId());
         assertEquals(event.getPassId(), deserializedEvent.getPassId());
         assertEquals(event.getTimePoint(), deserializedEvent.getTimePoint());
         assertEquals(0, Util.size(event.getInvolvedBoats()));
         assertEquals(0, Util.size(deserializedEvent.getInvolvedBoats()));
-        
+
         compareWind(event.getWindFix(), deserializedEvent.getWindFix());
     }
-    
+
     private void compareWind(Wind serializedWindFix, Wind deserializedWindFix) {
         assertEquals(serializedWindFix.getTimePoint(), deserializedWindFix.getTimePoint());
         assertNotNull(serializedWindFix.getPosition());
@@ -86,5 +88,5 @@ public class RaceLogWindFixEventSerializerTest {
         SpeedWithBearing speedBearing = new KnotSpeedWithBearingImpl(10.4, bearing);
         return new WindImpl(position, now, speedBearing);
     }
-    
+
 }

java/com.sap.sailing.server.gateway.serialization/META-INF/MANIFEST.MF

@@ -12,9 +12,11 @@ Require-Bundle: com.sap.sailing.domain.common;bundle-version="1.0.0",
 Export-Package: com.sap.sailing.server.gateway.deserialization,
  com.sap.sailing.server.gateway.deserialization.coursedata.impl,
  com.sap.sailing.server.gateway.deserialization.impl,
+ com.sap.sailing.server.gateway.deserialization.masterdata.impl,
  com.sap.sailing.server.gateway.deserialization.racelog.impl,
  com.sap.sailing.server.gateway.serialization,
  com.sap.sailing.server.gateway.serialization.coursedata.impl,
  com.sap.sailing.server.gateway.serialization.impl,
+ com.sap.sailing.server.gateway.serialization.masterdata.impl,
  com.sap.sailing.server.gateway.serialization.racegroup.impl,
  com.sap.sailing.server.gateway.serialization.racelog.impl

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/impl/NationalityJsonDeserialzer.java

@@ -0,0 +1,28 @@
+package com.sap.sailing.server.gateway.deserialization.impl;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Nationality;
+import com.sap.sailing.domain.base.impl.NationalityImpl;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
+
+public class NationalityJsonDeserialzer implements JsonDeserializer<Nationality> {
+
+    @Override
+    public Nationality deserialize(JSONObject object) throws JsonDeserializationException {
+        final Nationality result;
+        if (object == null) {
+            result = null;
+        } else {
+            String threeLetterIOCAcronym = (String) object.get(NationalityJsonSerializer.FIELD_IOC);
+            if (threeLetterIOCAcronym == null) {
+                result = null;
+            } else {
+                result = new NationalityImpl(threeLetterIOCAcronym);
+            }
+        }
+        return result;
+    }
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/impl/PersonJsonDeserializer.java

@@ -0,0 +1,39 @@
+package com.sap.sailing.server.gateway.deserialization.impl;
+
+import java.util.Date;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Nationality;
+import com.sap.sailing.domain.base.Person;
+import com.sap.sailing.domain.base.impl.PersonImpl;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
+
+public class PersonJsonDeserializer implements JsonDeserializer<Person> {
+
+    private final JsonDeserializer<Nationality> nationalityDeserializer;
+    
+    public PersonJsonDeserializer(JsonDeserializer<Nationality> nationalityDeserializer) {
+        this.nationalityDeserializer = nationalityDeserializer;
+    }
+
+    @Override
+    public Person deserialize(JSONObject object) throws JsonDeserializationException {
+        if (object == null) {
+            // Coach is often null
+            return null;
+        }
+        String name = (String) object.get(PersonJsonSerializer.FIELD_NAME);
+        String description = (String) object.get(PersonJsonSerializer.FIELD_DESCRIPTION);
+        Nationality nationality = nationalityDeserializer.deserialize((JSONObject) object
+                .get(PersonJsonSerializer.FIELD_NATIONALITY));
+        Date dateOfBirth = null;
+        if (object.containsKey(PersonJsonSerializer.FIELD_DATE_OF_BIRTH)) {
+            dateOfBirth = new Date((Long) object.get(PersonJsonSerializer.FIELD_DATE_OF_BIRTH));
+        }
+        return new PersonImpl(name, nationality, dateOfBirth, description);
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/impl/TeamJsonDeserializer.java

@@ -0,0 +1,39 @@
+package com.sap.sailing.server.gateway.deserialization.impl;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Person;
+import com.sap.sailing.domain.base.Team;
+import com.sap.sailing.domain.base.impl.TeamImpl;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
+
+public class TeamJsonDeserializer implements JsonDeserializer<Team> {
+    
+    private final JsonDeserializer<Person> personDeserializer;
+
+    public TeamJsonDeserializer(JsonDeserializer<Person> personDeserializer) {
+        this.personDeserializer = personDeserializer;
+    }
+
+
+
+    @Override
+    public Team deserialize(JSONObject object) throws JsonDeserializationException {
+        String name = (String) object.get(TeamJsonSerializer.FIELD_NAME);
+        Person coach = personDeserializer.deserialize((JSONObject) object.get(TeamJsonSerializer.FIELD_COACH));
+        Set<Person> sailors = new HashSet<Person>();
+        
+        JSONArray sailorsJson = (JSONArray) object.get(TeamJsonSerializer.FIELD_SAILORS);
+        for (Object sailorObject : sailorsJson) {
+            sailors.add(personDeserializer.deserialize((JSONObject) sailorObject));
+        }
+        return new TeamImpl(name, sailors, coach);
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/masterdata/impl/CompetitorMasterDataDeserializer.java

@@ -0,0 +1,51 @@
+package com.sap.sailing.server.gateway.deserialization.masterdata.impl;
+
+import java.util.UUID;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Boat;
+import com.sap.sailing.domain.base.BoatClass;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.SharedDomainFactory;
+import com.sap.sailing.domain.base.Team;
+import com.sap.sailing.domain.base.impl.BoatImpl;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.CompetitorMasterDataJsonSerializer;
+
+public class CompetitorMasterDataDeserializer implements JsonDeserializer<Competitor> {
+    
+    private final JsonDeserializer<BoatClass> boatClassDeserializer;
+    
+    private final JsonDeserializer<Team> teamDeserializer;
+    
+    private final SharedDomainFactory domainFactory;
+    
+    
+
+    public CompetitorMasterDataDeserializer(JsonDeserializer<BoatClass> boatClassDeserializer,
+            JsonDeserializer<Team> teamDeserializer, SharedDomainFactory domainFactory) {
+        this.boatClassDeserializer = boatClassDeserializer;
+        this.teamDeserializer = teamDeserializer;
+        this.domainFactory = domainFactory;
+    }
+
+    @Override
+    public Competitor deserialize(JSONObject object) throws JsonDeserializationException {
+        String name = (String) object.get(CompetitorMasterDataJsonSerializer.FIELD_NAME);
+        String id = (String) object.get(CompetitorMasterDataJsonSerializer.FIELD_ID);
+        Boat boat = createBoatFromJson((JSONObject) object.get(CompetitorMasterDataJsonSerializer.FIELD_BOAT));
+        Team team = teamDeserializer.deserialize((JSONObject) object.get(CompetitorMasterDataJsonSerializer.FIELD_TEAM));
+        return domainFactory.getOrCreateCompetitor(UUID.fromString(id), name, team, boat);
+        
+    }
+    
+    private Boat createBoatFromJson(JSONObject object) throws JsonDeserializationException {
+        String name = (String) object.get(CompetitorMasterDataJsonSerializer.FIELD_NAME); 
+        String sailID = (String) object.get(CompetitorMasterDataJsonSerializer.FIELD_SAIL_ID); 
+        BoatClass boatClass = boatClassDeserializer.deserialize((JSONObject) object.get(CompetitorMasterDataJsonSerializer.FIELD_BOAT_CLASS)); 
+        return new BoatImpl(name, boatClass, sailID);
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/masterdata/impl/EventMasterDataJsonDeserializer.java

@@ -0,0 +1,47 @@
+package com.sap.sailing.server.gateway.deserialization.masterdata.impl;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.masterdataimport.EventMasterData;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.EventMasterDataJsonSerializer;
+
+public class EventMasterDataJsonDeserializer implements JsonDeserializer<EventMasterData> {
+
+    @Override
+    public EventMasterData deserialize(JSONObject object) throws JsonDeserializationException {
+        String id = (String) object.get(EventMasterDataJsonSerializer.FIELD_ID);
+        String name = (String) object.get(EventMasterDataJsonSerializer.FIELD_NAME);
+        String venueName = (String) object.get(EventMasterDataJsonSerializer.FIELD_VENUE_NAME);
+        String pubUrl = (String) object.get(EventMasterDataJsonSerializer.FIELD_PUB_URL);
+        boolean isPublic = (Boolean) object.get(EventMasterDataJsonSerializer.FIELD_IS_PUBLIC);
+        Iterable<Pair<String, String>> courseAreas = deserializeCourseAreas((JSONArray) object.get(EventMasterDataJsonSerializer.FIELD_COURSE_AREAS));
+        return new EventMasterData(id, name, venueName, pubUrl, courseAreas, isPublic);
+    }
+
+    private Iterable<Pair<String, String>> deserializeCourseAreas(JSONArray jsonArray) {
+        List<Pair<String, String>> courseAreas = new ArrayList<Pair<String,String>>();
+        for (Object courseObject : jsonArray) {
+            JSONObject courseJson = (JSONObject) courseObject;
+            String id = (String) courseJson.get(EventMasterDataJsonSerializer.FIELD_ID);
+            String name = (String) courseJson.get(EventMasterDataJsonSerializer.FIELD_NAME);
+            courseAreas.add(new Pair<String, String>(id, name));
+        }
+        Collections.sort(courseAreas, new Comparator<Pair<String,String>>() {
+            @Override
+            public int compare(Pair<String, String> courseArea1, Pair<String, String> courseArea2) {
+                return courseArea1.getB().compareTo(courseArea2.getB());
+            }
+        });
+        return courseAreas;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/masterdata/impl/LeaderboardGroupMasterDataJsonDeserializer.java

@@ -0,0 +1,99 @@
+package com.sap.sailing.server.gateway.deserialization.masterdata.impl;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+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.Fleet;
+import com.sap.sailing.domain.base.LeaderboardMasterData;
+import com.sap.sailing.domain.base.Nationality;
+import com.sap.sailing.domain.base.Person;
+import com.sap.sailing.domain.base.Team;
+import com.sap.sailing.domain.common.Color;
+import com.sap.sailing.domain.masterdataimport.EventMasterData;
+import com.sap.sailing.domain.masterdataimport.LeaderboardGroupMasterData;
+import com.sap.sailing.domain.masterdataimport.RaceColumnMasterData;
+import com.sap.sailing.domain.masterdataimport.RegattaMasterData;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.BoatClassJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.ColorDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.FleetDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.NationalityJsonDeserialzer;
+import com.sap.sailing.server.gateway.deserialization.impl.PersonJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.TeamJsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.racelog.impl.RaceLogEventDeserializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.LeaderboardGroupMasterDataJsonSerializer;
+
+public class LeaderboardGroupMasterDataJsonDeserializer implements JsonDeserializer<LeaderboardGroupMasterData> {
+    
+    private final JsonDeserializer<LeaderboardMasterData> leaderboardDeserializer;
+    
+    private final JsonDeserializer<EventMasterData> eventDeserializer;
+    
+    private final JsonDeserializer<RegattaMasterData> regattaDeserializer;
+    
+    public static JsonDeserializer<LeaderboardGroupMasterData> create(DomainFactory domainFactory) {
+        JsonDeserializer<BoatClass> boatClassDeserializer = new BoatClassJsonDeserializer(domainFactory);
+        JsonDeserializer<Nationality> nationalityDeserializer = new NationalityJsonDeserialzer();
+        JsonDeserializer<Person> personDeserializer = new PersonJsonDeserializer(nationalityDeserializer);
+        JsonDeserializer<Team> teamDeserializer = new TeamJsonDeserializer(personDeserializer);
+        JsonDeserializer<Competitor> competitorDeserializer = new CompetitorMasterDataDeserializer(
+                boatClassDeserializer, teamDeserializer, domainFactory);
+        JsonDeserializer<RaceLogEvent> raceLogEventDeserializer = RaceLogEventDeserializer.create(domainFactory);
+        JsonDeserializer<LeaderboardMasterData> leaderboardDeserializer = new LeaderboardMasterDataJsonDeserializer(
+                competitorDeserializer, domainFactory, raceLogEventDeserializer);
+        JsonDeserializer<EventMasterData> eventDeserializer = new EventMasterDataJsonDeserializer();
+        JsonDeserializer<Color> colorDeserializer = new ColorDeserializer();
+        JsonDeserializer<Fleet> fleetDeserializer = new FleetDeserializer(colorDeserializer);
+        JsonDeserializer<RaceColumnMasterData> raceColumnDeserializer = new RaceColumnMasterDataJsonDeserializer();
+        JsonDeserializer<RegattaMasterData> regattaDeserializer = new RegattaMasterDataJsonDeserializer(
+                fleetDeserializer, raceColumnDeserializer);
+        JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer = new LeaderboardGroupMasterDataJsonDeserializer(
+                leaderboardDeserializer, eventDeserializer, regattaDeserializer);
+        return leaderboardGroupMasterDataDeserializer;
+    }
+
+    public LeaderboardGroupMasterDataJsonDeserializer(JsonDeserializer<LeaderboardMasterData> leaderboardDeserializer,
+            JsonDeserializer<EventMasterData> eventDeserializer, JsonDeserializer<RegattaMasterData> regattaDeserializer) {
+        this.leaderboardDeserializer = leaderboardDeserializer;
+        this.eventDeserializer = eventDeserializer;
+        this.regattaDeserializer = regattaDeserializer;
+    }
+
+    @Override
+    public LeaderboardGroupMasterData deserialize(JSONObject object) throws JsonDeserializationException {
+        List<LeaderboardMasterData> leaderboards = new ArrayList<LeaderboardMasterData>();
+        JSONArray leaderboardsJson = (JSONArray) object.get(LeaderboardGroupMasterDataJsonSerializer.FIELD_LEADERBOARDS);
+        for (Object leaderboardObject : leaderboardsJson) {
+            JSONObject leaderboardJson = (JSONObject) leaderboardObject;
+            leaderboards.add(leaderboardDeserializer.deserialize(leaderboardJson));
+        }
+        JSONArray eventsJson = (JSONArray) object.get(LeaderboardGroupMasterDataJsonSerializer.FIELD_EVENTS);
+        Set<EventMasterData> events = new HashSet<EventMasterData>();
+        for (Object eventObject : eventsJson) {
+            JSONObject eventJson = (JSONObject) eventObject;
+            events.add(eventDeserializer.deserialize(eventJson));
+        }
+        JSONArray regattasJson = (JSONArray) object.get(LeaderboardGroupMasterDataJsonSerializer.FIELD_REGATTAS);
+        Set<RegattaMasterData> regattas = new HashSet<RegattaMasterData>();
+        for (Object regattaObject : regattasJson) {
+            JSONObject regattaJson = (JSONObject) regattaObject;
+            regattas.add(regattaDeserializer.deserialize(regattaJson));
+        }
+        String name = (String) object.get(LeaderboardGroupMasterDataJsonSerializer.FIELD_NAME);
+        String description = (String) object.get(LeaderboardGroupMasterDataJsonSerializer.FIELD_DESCRIPTION);
+        boolean displayGroupsReverse = (Boolean) object.get(LeaderboardGroupMasterDataJsonSerializer.FIELD_DISPLAY_GROUPS_REVERSE);
+        LeaderboardMasterData overallLeaderboardMasterData = leaderboardDeserializer.deserialize((JSONObject) object.get(LeaderboardGroupMasterDataJsonSerializer.FIELD_OVERALL_LEADERBOARD));
+        return new LeaderboardGroupMasterData(name, description, displayGroupsReverse, overallLeaderboardMasterData, leaderboards, events, regattas);
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/masterdata/impl/LeaderboardMasterDataJsonDeserializer.java

@@ -0,0 +1,248 @@
+package com.sap.sailing.server.gateway.deserialization.masterdata.impl;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.DomainFactory;
+import com.sap.sailing.domain.base.LeaderboardMasterData;
+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.leaderboard.ScoringScheme;
+import com.sap.sailing.domain.masterdataimport.FlexibleLeaderboardMasterData;
+import com.sap.sailing.domain.masterdataimport.RaceColumnMasterData;
+import com.sap.sailing.domain.masterdataimport.RegattaLeaderboardMasterData;
+import com.sap.sailing.domain.masterdataimport.ScoreCorrectionMasterData;
+import com.sap.sailing.domain.masterdataimport.SingleScoreCorrectionMasterData;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.LeaderboardMasterDataJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.RaceColumnMasterDataJsonSerializer;
+
+public class LeaderboardMasterDataJsonDeserializer implements JsonDeserializer<LeaderboardMasterData> {
+
+    private final JsonDeserializer<Competitor> competitorDeserializer;
+    private final DomainFactory domainFactory;
+    private final JsonDeserializer<RaceLogEvent> raceLogEventDeseriaizer;
+
+    public LeaderboardMasterDataJsonDeserializer(JsonDeserializer<Competitor> competitorDeserializer,
+            DomainFactory domainFactory, JsonDeserializer<RaceLogEvent> raceLogEventDeseriaizer) {
+        this.competitorDeserializer = competitorDeserializer;
+        this.domainFactory = domainFactory;
+        this.raceLogEventDeseriaizer = raceLogEventDeseriaizer;
+    }
+
+    @Override
+    public LeaderboardMasterData deserialize(JSONObject object) throws JsonDeserializationException {
+        if (object == null) {
+            return null;
+        }
+        String name = (String) object.get(LeaderboardMasterDataJsonSerializer.FIELD_NAME);
+        String displayName = (String) object.get(LeaderboardMasterDataJsonSerializer.FIELD_DISPLAY_NAME);
+        Map<String, String> displayNamesByCompetitorId = deserializeCompetitorDisplayNames((JSONArray) object
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_COMPETITOR_DISPLAY_NAMES));
+        ScoreCorrectionMasterData scoreCorrection = deserializeScoreCorrection((JSONObject) object
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_SCORE_CORRECTION));
+        Map<String, Double> carriedPoints = deserializeCarriedPoints((JSONArray) object
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_CARRIED_POINTS));
+        List<String> suppressedCompetitors = deserializeSuppressedCompetitors((JSONArray) object
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_SUPPRESSED_COMPETITORS));
+        Map<String, Map<String, List<RaceLogEvent>>> raceLogEvents = deserializeRaceLogEvents((JSONArray) object
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_RACE_LOG_EVENTS));
+        int[] resultDiscardingRule = deserializeResultDesicardingRule((JSONObject) object
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_RESULT_DISCARDING_RULE));
+        boolean isRegattaLeaderBoard = (Boolean) object
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_REGATTA_LEADERBOARD);
+
+        Map<String, Competitor> competitorsById = new HashMap<String, Competitor>();
+        JSONArray competitorsJsonArray = (JSONArray) object.get(LeaderboardMasterDataJsonSerializer.FIELD_COMPETITORS);
+
+        for (Object obj : competitorsJsonArray) {
+            JSONObject competitorJson = (JSONObject) obj;
+            Competitor deserializedCompetitor = competitorDeserializer.deserialize(competitorJson);
+            competitorsById.put(deserializedCompetitor.getId().toString(), deserializedCompetitor);
+        }
+        if (isRegattaLeaderBoard) {
+            String regattaName = (String) object.get(LeaderboardMasterDataJsonSerializer.FIELD_REGATTA_NAME);
+            return new RegattaLeaderboardMasterData(name, displayName, resultDiscardingRule, competitorsById,
+                    scoreCorrection, regattaName, carriedPoints, suppressedCompetitors, displayNamesByCompetitorId,
+                    raceLogEvents);
+
+        } else {
+            ScoringScheme scoringScheme = deserializeScoringScheme((JSONObject) object
+                    .get(LeaderboardMasterDataJsonSerializer.FIELD_SCORING_SCHEME));
+            String courseAreaId = deserializeCourseAreaId((JSONObject) object
+                    .get(LeaderboardMasterDataJsonSerializer.FIELD_COURSE_AREA));
+            List<RaceColumnMasterData> raceColumns = deserializeRaceColumns((JSONArray) object
+                    .get(LeaderboardMasterDataJsonSerializer.FIELD_RACE_COLUMNS));
+            return new FlexibleLeaderboardMasterData(name, displayName, resultDiscardingRule, competitorsById,
+                    scoreCorrection, scoringScheme, courseAreaId, raceColumns, carriedPoints, suppressedCompetitors,
+                    displayNamesByCompetitorId, raceLogEvents);
+        }
+    }
+
+    private Map<String, Map<String, List<RaceLogEvent>>> deserializeRaceLogEvents(JSONArray jsonArray) {
+        Map<String, Map<String, List<RaceLogEvent>>> raceLogEvents = new HashMap<String, Map<String, List<RaceLogEvent>>>();
+        for (Object obj : jsonArray) {
+            JSONObject json = (JSONObject) obj;
+            String raceColumnName = (String) json.get(LeaderboardMasterDataJsonSerializer.FIELD_RACE_COLUMN_NAME);
+            Map<String, List<RaceLogEvent>> perFleet = deserializeRaceLogEventsForFleets((JSONArray) json
+                    .get(LeaderboardMasterDataJsonSerializer.FIELD_FLEETS));
+            raceLogEvents.put(raceColumnName, perFleet);
+        }
+        return raceLogEvents;
+    }
+
+    private Map<String, List<RaceLogEvent>> deserializeRaceLogEventsForFleets(JSONArray fleets) {
+        Map<String, List<RaceLogEvent>> perFleet = new HashMap<String, List<RaceLogEvent>>();
+        for (Object obj : fleets) {
+            JSONObject json = (JSONObject) obj;
+            String fleetName = (String) json.get(LeaderboardMasterDataJsonSerializer.FIELD_FLEET_NAME);
+            List<RaceLogEvent> logEvents = deserializeRaceLogEventArray((JSONArray) json
+                    .get(LeaderboardMasterDataJsonSerializer.FIELD_RACE_LOG_EVENTS));
+            perFleet.put(fleetName, logEvents);
+        }
+        return perFleet;
+    }
+
+    private List<RaceLogEvent> deserializeRaceLogEventArray(JSONArray jsonArray) {
+        List<RaceLogEvent> logEvents = new ArrayList<RaceLogEvent>();
+        for (Object obj : jsonArray) {
+            JSONObject json = (JSONObject) obj;
+            try {
+                logEvents.add(raceLogEventDeseriaizer.deserialize(json));
+            } catch (JsonDeserializationException e) {
+                // TODO Exception handling
+                e.printStackTrace();
+            }
+        }
+        return logEvents;
+    }
+
+    private Map<String, String> deserializeCompetitorDisplayNames(JSONArray jsonArray) {
+        Map<String, String> result = new HashMap<String, String>();
+        for (Object obj : jsonArray) {
+            JSONObject json = (JSONObject) obj;
+            String id = (String) json.get(LeaderboardMasterDataJsonSerializer.FIELD_COMPETITOR_ID);
+            String displayName = (String) json.get(LeaderboardMasterDataJsonSerializer.FIELD_DISPLAY_NAME);
+            result.put(id, displayName);
+        }
+        return result;
+    }
+
+    private List<String> deserializeSuppressedCompetitors(JSONArray jsonArray) {
+        List<String> ids = new ArrayList<String>();
+        for (Object obj : jsonArray) {
+            ids.add((String) obj);
+        }
+        return ids;
+    }
+
+    private Map<String, Double> deserializeCarriedPoints(JSONArray jsonArray) {
+        Map<String, Double> carriedPoints = new HashMap<String, Double>();
+        for (Object obj : jsonArray) {
+            JSONObject jsonCarriedPoints = (JSONObject) obj;
+            String competitorId = (String) jsonCarriedPoints
+                    .get(LeaderboardMasterDataJsonSerializer.FIELD_COMPETITOR_ID);
+            Double carried = (Double) jsonCarriedPoints.get(LeaderboardMasterDataJsonSerializer.FIELD_CARRIED);
+            carriedPoints.put(competitorId, carried);
+        }
+        return carriedPoints;
+    }
+
+    private ScoreCorrectionMasterData deserializeScoreCorrection(JSONObject jsonObject) {
+        String comment = (String) jsonObject.get(LeaderboardMasterDataJsonSerializer.FIELD_COMMENT);
+        Object timeObject = jsonObject.get(LeaderboardMasterDataJsonSerializer.FIELD_TIME_POINT);
+        Long timepointMillis = null;
+        if (timeObject != null) {
+            timepointMillis = (Long) timeObject;
+        }
+
+        JSONArray forRaceColumns = (JSONArray) jsonObject
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_FOR_RACE_COLUMNS);
+        Map<String, Iterable<SingleScoreCorrectionMasterData>> correctionForRaceColumns = new HashMap<String, Iterable<SingleScoreCorrectionMasterData>>();
+        for (Object obj : forRaceColumns) {
+            JSONObject json = (JSONObject) obj;
+            String raceColumnName = (String) json.get(LeaderboardMasterDataJsonSerializer.FIELD_RACE_COLUMN_NAME);
+            Iterable<SingleScoreCorrectionMasterData> correctionsForRaceColumn = deserializeScoreCorrectionForRaceColumn((JSONArray) json
+                    .get(LeaderboardMasterDataJsonSerializer.FIELD_FOR_COMPETITORS));
+            correctionForRaceColumns.put(raceColumnName, correctionsForRaceColumn);
+        }
+        return new ScoreCorrectionMasterData(comment, timepointMillis, correctionForRaceColumns);
+    }
+
+    private Iterable<SingleScoreCorrectionMasterData> deserializeScoreCorrectionForRaceColumn(JSONArray jsonArray) {
+        Set<SingleScoreCorrectionMasterData> result = new HashSet<SingleScoreCorrectionMasterData>();
+        for (Object obj : jsonArray) {
+            JSONObject json = (JSONObject) obj;
+            result.add(deserializeScoreCorrectionForCompetitor(json));
+        }
+        return result;
+    }
+
+    private SingleScoreCorrectionMasterData deserializeScoreCorrectionForCompetitor(JSONObject json) {
+        String competitorId = (String) json.get(LeaderboardMasterDataJsonSerializer.FIELD_COMPETITOR_ID);
+        Double explicitScoreCorrection = ((Double) json
+                .get(LeaderboardMasterDataJsonSerializer.FIELD_EXPLICIT_SCORE_CORRECTION));
+        String maxPointsReason = (String) json.get(LeaderboardMasterDataJsonSerializer.FIELD_MAX_POINTS_REASON);
+        return new SingleScoreCorrectionMasterData(competitorId, explicitScoreCorrection, maxPointsReason);
+    }
+
+    private List<RaceColumnMasterData> deserializeRaceColumns(JSONArray array) {
+        List<RaceColumnMasterData> columns = new ArrayList<RaceColumnMasterData>();
+        for (Object columnObj : array) {
+            JSONObject columnJson = (JSONObject) columnObj;
+            String columnName = (String) columnJson
+                    .get(RaceColumnMasterDataJsonSerializer.FIELD_NAME);
+            Boolean medal = (Boolean) columnJson
+                    .get(RaceColumnMasterDataJsonSerializer.FIELD_MEDAL_RACE);
+            Map<String, RaceIdentifier> raceIdentifiers = new HashMap<String, RaceIdentifier>();
+            JSONArray jsonRaceIdentifiers = (JSONArray) columnJson.get(RaceColumnMasterDataJsonSerializer.FIELD_RACE_IDENTIFIERS);
+            for (Object raceIdentifierObject : jsonRaceIdentifiers) {
+                JSONObject jsonRaceIdentifier = (JSONObject) raceIdentifierObject;
+                String fleetName = (String) jsonRaceIdentifier.get(RaceColumnMasterDataJsonSerializer.FIELD_FLEET_NAME);
+                String raceName = (String) jsonRaceIdentifier.get(RaceColumnMasterDataJsonSerializer.FIELD_RACE_NAME);
+                String regattaName = (String) jsonRaceIdentifier.get(RaceColumnMasterDataJsonSerializer.FIELD_REGATTA_NAME);
+                RaceIdentifier raceIdentifier = new RegattaNameAndRaceName(regattaName, raceName);
+                raceIdentifiers.put(fleetName, raceIdentifier);
+            }
+            columns.add(new RaceColumnMasterData(columnName, medal, raceIdentifiers));
+        }
+        return columns;
+    }
+
+    private String deserializeCourseAreaId(JSONObject jsonObject) {
+        if (jsonObject == null) {
+            return null;
+        }
+        String id = (String) jsonObject.get(LeaderboardMasterDataJsonSerializer.FIELD_ID);
+        return id;
+
+    }
+
+    private ScoringScheme deserializeScoringScheme(JSONObject jsonObject) {
+        String type = (String) jsonObject.get(LeaderboardMasterDataJsonSerializer.FIELD_TYPE);
+        return domainFactory.createScoringScheme(ScoringSchemeType.valueOf(type));
+    }
+
+    private int[] deserializeResultDesicardingRule(JSONObject jsonObject) {
+        JSONArray indeces = (JSONArray) jsonObject.get(LeaderboardMasterDataJsonSerializer.FIELD_INDICES);
+        if (indeces == null) {
+            return null;
+        }
+        int[] result = new int[indeces.size()];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = (Integer) indeces.get(i);
+        }
+        return result;
+    }
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/masterdata/impl/RaceColumnMasterDataJsonDeserializer.java

@@ -0,0 +1,35 @@
+package com.sap.sailing.server.gateway.deserialization.masterdata.impl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.common.RaceIdentifier;
+import com.sap.sailing.domain.common.RegattaNameAndRaceName;
+import com.sap.sailing.domain.masterdataimport.RaceColumnMasterData;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.RaceColumnMasterDataJsonSerializer;
+
+public class RaceColumnMasterDataJsonDeserializer implements JsonDeserializer<RaceColumnMasterData>  {
+    @Override
+    public RaceColumnMasterData deserialize(JSONObject columnJson) throws JsonDeserializationException {
+        String columnName = (String) columnJson
+                .get(RaceColumnMasterDataJsonSerializer.FIELD_NAME);
+        Boolean medal = (Boolean) columnJson
+                .get(RaceColumnMasterDataJsonSerializer.FIELD_MEDAL_RACE);
+        Map<String, RaceIdentifier> raceIdentifiers = new HashMap<String, RaceIdentifier>();
+        JSONArray jsonRaceIdentifiers = (JSONArray) columnJson.get(RaceColumnMasterDataJsonSerializer.FIELD_RACE_IDENTIFIERS);
+        for (Object raceIdentifierObject : jsonRaceIdentifiers) {
+            JSONObject jsonRaceIdentifier = (JSONObject) raceIdentifierObject;
+            String fleetName = (String) jsonRaceIdentifier.get(RaceColumnMasterDataJsonSerializer.FIELD_FLEET_NAME);
+            String raceName = (String) jsonRaceIdentifier.get(RaceColumnMasterDataJsonSerializer.FIELD_RACE_NAME);
+            String regattaName = (String) jsonRaceIdentifier.get(RaceColumnMasterDataJsonSerializer.FIELD_REGATTA_NAME);
+            RaceIdentifier raceIdentifier = new RegattaNameAndRaceName(regattaName, raceName);
+            raceIdentifiers.put(fleetName, raceIdentifier);
+        }
+        return new RaceColumnMasterData(columnName, medal, raceIdentifiers);
+    }
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/masterdata/impl/RegattaMasterDataJsonDeserializer.java

@@ -0,0 +1,107 @@
+package com.sap.sailing.server.gateway.deserialization.masterdata.impl;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.masterdataimport.RaceColumnMasterData;
+import com.sap.sailing.domain.masterdataimport.RegattaMasterData;
+import com.sap.sailing.domain.masterdataimport.SeriesMasterData;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.LeaderboardMasterDataJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.RegattaMasterDataJsonSerializer;
+
+public class RegattaMasterDataJsonDeserializer implements JsonDeserializer<RegattaMasterData> {
+    
+    private final JsonDeserializer<Fleet> fleetDeserializer;
+    private final JsonDeserializer<RaceColumnMasterData> raceColumnDeserializer;
+
+    public RegattaMasterDataJsonDeserializer(JsonDeserializer<Fleet> fleetDeserializer, JsonDeserializer<RaceColumnMasterData> raceColumnDeserializer) {
+        this.fleetDeserializer = fleetDeserializer;
+        this.raceColumnDeserializer = raceColumnDeserializer;
+    }
+
+    @Override
+    public RegattaMasterData deserialize(JSONObject object) throws JsonDeserializationException {
+        String id = (String) object.get(RegattaMasterDataJsonSerializer.FIELD_ID);
+        String regattaName = (String) object.get(RegattaMasterDataJsonSerializer.FIELD_REGATTA_NAME);
+        String baseName = (String) object.get(RegattaMasterDataJsonSerializer.FIELD_BASE_NAME);
+        String defaultCourseAreaId = (String) object.get(RegattaMasterDataJsonSerializer.FIELD_DEFAULT_COURSE_AREA_ID);
+        String boatClassName = (String) object.get(RegattaMasterDataJsonSerializer.FIELD_BOAT_CLASS_NAME);
+        String scoringSchemeType = (String) object.get(RegattaMasterDataJsonSerializer.FIELD_SCORING_SCHEME_TYPE);
+        boolean isPersistent = (Boolean) object.get(RegattaMasterDataJsonSerializer.FIELD_IS_PERSISTENT);
+        Iterable<SeriesMasterData> series = deserializeSeries((JSONArray) object.get(RegattaMasterDataJsonSerializer.FIELD_SERIES));
+        Iterable<String> raceIds = deserializeRaceIds((JSONArray) object.get(RegattaMasterDataJsonSerializer.FIELD_REGATTA_RACE_IDS));
+        return new RegattaMasterData(id, baseName, defaultCourseAreaId, boatClassName, scoringSchemeType, series, isPersistent, regattaName, raceIds);
+    }
+
+    private Iterable<String> deserializeRaceIds(JSONArray jsonArray) {
+        Set<String> raceIdStrings = new HashSet<String>();
+        for (Object obj : jsonArray) {
+            String id = (String) obj;
+            raceIdStrings.add(id);
+        }
+        return raceIdStrings;
+    }
+
+    private Iterable<SeriesMasterData> deserializeSeries(JSONArray jsonArray) throws JsonDeserializationException {
+        List<SeriesMasterData> series = new ArrayList<SeriesMasterData>();
+        for (Object seriesObject : jsonArray) {
+            JSONObject seriesJson = (JSONObject) seriesObject;
+            String name = (String) seriesJson.get(RegattaMasterDataJsonSerializer.FIELD_NAME);
+            boolean isMedal = (Boolean) seriesJson.get(RegattaMasterDataJsonSerializer.FIELD_IS_MEDAL);
+            Iterable<Fleet> fleets = deserializeFleets((JSONArray) seriesJson.get(RegattaMasterDataJsonSerializer.FIELD_FLEETS));
+            Iterable<RaceColumnMasterData> raceColumnNames = deserializeRaceColumnNames((JSONArray) seriesJson.get(RegattaMasterDataJsonSerializer.FIELD_RACE_COLUMNS));
+            int[] discardingRule = deserializeResultDesicardingRule((JSONObject) seriesJson.get(RegattaMasterDataJsonSerializer.FIELD_RESULT_DISCARDING_RULE));
+            series.add(new SeriesMasterData(name, isMedal, fleets, raceColumnNames, discardingRule));
+        }
+        
+        return series;
+    }
+
+    private Iterable<RaceColumnMasterData> deserializeRaceColumnNames(JSONArray jsonArray) throws JsonDeserializationException {
+        List<RaceColumnMasterData> raceColumns = new ArrayList<RaceColumnMasterData>();
+        for (Object raceColumnObject : jsonArray) {
+            JSONObject jsonRaceColumn = (JSONObject) raceColumnObject;
+            raceColumns.add(raceColumnDeserializer.deserialize(jsonRaceColumn));
+        }
+        return raceColumns;
+    }
+
+    private Iterable<Fleet> deserializeFleets(JSONArray jsonArray) {
+        List<Fleet> fleets = new ArrayList<Fleet>();
+        for (Object fleetObject : jsonArray) {
+            JSONObject fleetJson = (JSONObject) fleetObject;
+            try {
+                fleets.add(fleetDeserializer.deserialize(fleetJson));
+            } catch (JsonDeserializationException e) {
+                // TODO exception handling
+                e.printStackTrace();
+            }
+            
+        }
+        return fleets;
+    }
+    
+    private int[] deserializeResultDesicardingRule(JSONObject jsonObject) {
+        if (jsonObject == null) {
+            return null;
+        }
+        JSONArray indeces = (JSONArray) jsonObject.get(LeaderboardMasterDataJsonSerializer.FIELD_INDICES);
+        if (indeces == null) {
+            return null;
+        }
+        int[] result = new int[indeces.size()];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = ((Long) indeces.get(i)).intValue();
+        }
+        return result;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/NationalityJsonSerializer.java

@@ -0,0 +1,22 @@
+package com.sap.sailing.server.gateway.serialization.impl;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Nationality;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class NationalityJsonSerializer implements JsonSerializer<Nationality> {
+
+    public static final String FIELD_IOC = "IOC";
+
+    @Override
+    public JSONObject serialize(Nationality object) {
+        if (object == null) {
+            return null;
+        }
+        JSONObject result = new JSONObject();
+        result.put(FIELD_IOC, object.getThreeLetterIOCAcronym());
+        return result;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/PersonJsonSerializer.java

@@ -2,19 +2,35 @@ package com.sap.sailing.server.gateway.serialization.impl;
 
 import org.json.simple.JSONObject;
 
+import com.sap.sailing.domain.base.Nationality;
 import com.sap.sailing.domain.base.Person;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 
 public class PersonJsonSerializer implements JsonSerializer<Person> {
     public static final String FIELD_NAME = "name";
     public static final String FIELD_DESCRIPTION = "description";
+    public static final String FIELD_NATIONALITY = "nationality";
+    public static final String FIELD_DATE_OF_BIRTH = "dateOfBirth";
+    
+    private final JsonSerializer<Nationality> nationalityJsonSerializer;
+
+    public PersonJsonSerializer(JsonSerializer<Nationality> nationalityJsonSerializer) {
+        this.nationalityJsonSerializer = nationalityJsonSerializer;
+    }
 
     @Override
     public JSONObject serialize(Person person) {
+        if (person == null) {
+            return null;
+        }
         JSONObject result = new JSONObject();
 
         result.put(FIELD_NAME, person.getName());
+        if (person.getDateOfBirth() != null) {
+            result.put(FIELD_DATE_OF_BIRTH, person.getDateOfBirth().getTime());
+        }
         result.put(FIELD_DESCRIPTION, person.getDescription());
+        result.put(FIELD_NATIONALITY, nationalityJsonSerializer.serialize(person.getNationality()));
         
         return result;
     }

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/TeamJsonSerializer.java

@@ -10,6 +10,8 @@ import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 public class TeamJsonSerializer implements JsonSerializer<Team> {
     public static final String FIELD_NAME = "name";
     public static final String FIELD_SAILORS = "sailors";
+    public static final String FIELD_COACH = "coach";
+    public static final String FIELD_NATIONALITY = "nationality";
     
     private final JsonSerializer<Person> personJsonSerializer;
 
@@ -22,6 +24,8 @@ public class TeamJsonSerializer implements JsonSerializer<Team> {
         JSONObject result = new JSONObject();
         result.put(FIELD_NAME, team.getName());
         
+        result.put(FIELD_COACH, personJsonSerializer.serialize(team.getCoach()));
+        
         JSONArray jsonSailors = new JSONArray();
         for (Person sailor : team.getSailors()) {
             jsonSailors.add(personJsonSerializer.serialize(sailor));

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/masterdata/impl/CompetitorMasterDataJsonSerializer.java

@@ -0,0 +1,53 @@
+package com.sap.sailing.server.gateway.serialization.masterdata.impl;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Boat;
+import com.sap.sailing.domain.base.BoatClass;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.Team;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class CompetitorMasterDataJsonSerializer implements JsonSerializer<Competitor> {
+    
+    public static final String FIELD_BOAT_CLASS = "boatClass";
+    public static final String FIELD_SAIL_ID = "sailID";
+    public static final String FIELD_TEAM = "team";
+    public static final String FIELD_BOAT = "boat";
+    public static final String FIELD_ID = "id";
+    public static final String FIELD_NAME = "name";
+    private final JsonSerializer<BoatClass> boatClassSerializer;
+    private final JsonSerializer<Team> teamSerializer;
+    
+    
+
+    public CompetitorMasterDataJsonSerializer(JsonSerializer<BoatClass> boatClassSerializer,
+            JsonSerializer<Team> teamSerializer) {
+        this.boatClassSerializer = boatClassSerializer;
+        this.teamSerializer = teamSerializer;
+    }
+
+    @Override
+    public JSONObject serialize(Competitor competitor) {
+        //Check if it is null. This can happen for race log events that specify competitors
+        //  but where the race is not tracked.
+        if (competitor == null) {
+            return null;
+        }
+        JSONObject jsonCompetitor = new JSONObject();
+        jsonCompetitor.put(FIELD_NAME, competitor.getName());
+        jsonCompetitor.put(FIELD_ID, competitor.getId().toString());
+        jsonCompetitor.put(FIELD_BOAT, createJsonForBoat(competitor.getBoat()));
+        jsonCompetitor.put(FIELD_TEAM, teamSerializer.serialize(competitor.getTeam()));
+        return jsonCompetitor;
+    }
+    
+    private JSONObject createJsonForBoat(Boat boat) {
+        JSONObject jsonBoat = new JSONObject();
+        jsonBoat.put(FIELD_NAME, boat.getName());
+        jsonBoat.put(FIELD_SAIL_ID, boat.getSailID());
+        jsonBoat.put(FIELD_BOAT_CLASS, boatClassSerializer.serialize(boat.getBoatClass()));
+        return jsonBoat;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/masterdata/impl/EventMasterDataJsonSerializer.java

@@ -0,0 +1,49 @@
+package com.sap.sailing.server.gateway.serialization.masterdata.impl;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.CourseArea;
+import com.sap.sailing.domain.base.Event;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class EventMasterDataJsonSerializer implements JsonSerializer<Event> {
+
+    public static final String FIELD_ID = "id";
+    public static final String FIELD_NAME = "name";
+    public static final String FIELD_VENUE_NAME = "venueName";
+    public static final String FIELD_PUB_URL = "publicationUrl";
+    public static final String FIELD_COURSE_AREAS = "courseAreas";
+    public static final String FIELD_IS_PUBLIC = "isPublic";
+    
+
+    @Override
+    public JSONObject serialize(Event event) {
+        JSONObject result = new JSONObject();
+        result.put(FIELD_ID, event.getId().toString());
+        result.put(FIELD_NAME, event.getName());
+        result.put(FIELD_VENUE_NAME, event.getVenue().getName());
+        result.put(FIELD_PUB_URL, event.getPublicationUrl());
+        result.put(FIELD_IS_PUBLIC, event.isPublic());
+        result.put(FIELD_COURSE_AREAS, createJsonArrayForCourseAreas(event.getVenue().getCourseAreas()));
+        //TODO Sadly event.getRegattas() returns an empty collection
+        //result.put(FIELD_REGATTAS, createJsonArrayForRegattas(event.getRegattas()));
+        return result;
+    }
+
+    private JSONArray createJsonArrayForCourseAreas(Iterable<CourseArea> courseAreas) {
+        JSONArray array = new JSONArray();
+        for (CourseArea courseArea : courseAreas) {
+            array.add(createJsonForCourseArea(courseArea));
+        }
+        return array;
+    }
+
+    private JSONObject createJsonForCourseArea(CourseArea courseArea) {
+        JSONObject result = new JSONObject();
+        result.put(FIELD_ID, courseArea.getId().toString());
+        result.put(FIELD_NAME, courseArea.getName());
+        return result;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/masterdata/impl/LeaderboardGroupMasterDataJsonSerializer.java

@@ -0,0 +1,127 @@
+package com.sap.sailing.server.gateway.serialization.masterdata.impl;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+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;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.common.Color;
+import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.BoatClassJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.ColorJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.FleetJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogEventSerializer;
+
+public class LeaderboardGroupMasterDataJsonSerializer implements JsonSerializer<LeaderboardGroup> {
+
+    public static final String FIELD_LEADERBOARDS = "leaderboards";
+    public static final String FIELD_OVERALL_LEADERBOARD = "overallLeaderboard";
+    public static final String FIELD_DESCRIPTION = "description";
+    public static final String FIELD_NAME = "name";
+    public static final String FIELD_DISPLAY_GROUPS_REVERSE = "displayGroupsReverse";
+    public static final String FIELD_EVENTS = "events";
+    public static final String FIELD_REGATTAS = "regattas";
+    private final LeaderboardMasterDataJsonSerializer leadboardSerializer;
+    private final Iterable<Event> allEvents;
+    private final JsonSerializer<Event> eventSerializer;
+    private final JsonSerializer<Regatta> regattaSerializer;
+
+    /**
+     * If masterdata is imported from a server where exported races are not tracked, data like race log competitor
+     * data may be lost in the process of serialization
+     * @param events 
+     * @param regattaForRaceIdString 
+     */
+    public LeaderboardGroupMasterDataJsonSerializer(Iterable<Event> events, ConcurrentHashMap<String, Regatta> regattaForRaceIdStrings) {
+        this.allEvents = events;
+        NationalityJsonSerializer nationalityJsonSerializer = new NationalityJsonSerializer();
+        PersonJsonSerializer personSerializer = new PersonJsonSerializer(nationalityJsonSerializer);
+        TeamJsonSerializer teamSerializer = new TeamJsonSerializer(personSerializer);
+        BoatClassJsonSerializer boatClassSerializer = new BoatClassJsonSerializer();
+        CompetitorMasterDataJsonSerializer competitorSerializer = new CompetitorMasterDataJsonSerializer(
+                boatClassSerializer, teamSerializer);
+        JsonSerializer<Color> colorSerializer = new ColorJsonSerializer();
+        JsonSerializer<Fleet> fleetSerializer = new FleetJsonSerializer(colorSerializer);
+        JsonSerializer<RaceColumn> raceColumnSerializer = new RaceColumnMasterDataJsonSerializer();
+        JsonSerializer<RaceLogEvent> raceLogEventSerializer = RaceLogEventSerializer.create(competitorSerializer);
+        eventSerializer = new EventMasterDataJsonSerializer();
+        leadboardSerializer = new LeaderboardMasterDataJsonSerializer(competitorSerializer, raceColumnSerializer, raceLogEventSerializer);
+        regattaSerializer = new RegattaMasterDataJsonSerializer(fleetSerializer, raceColumnSerializer, regattaForRaceIdStrings);
+    }
+
+    @Override
+    public JSONObject serialize(LeaderboardGroup leaderboardGroup) {
+        JSONObject jsonLeaderboardGroup = new JSONObject();
+        jsonLeaderboardGroup.put(FIELD_NAME, leaderboardGroup.getName());
+        jsonLeaderboardGroup.put(FIELD_DESCRIPTION, leaderboardGroup.getDescription());
+        jsonLeaderboardGroup.put(FIELD_OVERALL_LEADERBOARD,
+                leadboardSerializer.serialize(leaderboardGroup.getOverallLeaderboard()));
+        jsonLeaderboardGroup.put(FIELD_LEADERBOARDS, createJsonArrayForLeaderboards(leaderboardGroup.getLeaderboards()));
+        jsonLeaderboardGroup.put(FIELD_DISPLAY_GROUPS_REVERSE, leaderboardGroup.isDisplayGroupsInReverseOrder());
+        
+        //Important to call this after serializing leaderboards, as the leaderboard serializer has state
+        jsonLeaderboardGroup.put(FIELD_EVENTS, createJsonArrayForEvents());
+        jsonLeaderboardGroup.put(FIELD_REGATTAS, createJsonArrayForRegattas());
+        
+        return jsonLeaderboardGroup;
+    }
+
+    private JSONArray createJsonArrayForRegattas() {
+        JSONArray array = new JSONArray();
+        Iterable<Regatta> regattas = leadboardSerializer.getRegattas();
+        for (Regatta regatta : regattas) {
+            array.add(regattaSerializer.serialize(regatta));
+        }
+        return array;
+    }
+
+    /*
+     * TODO, this is a hack to find out which events are needed for the exported 
+     *  regatta leaderboards. should be replaced by a proper connection from regatta to event
+     */
+    private JSONArray createJsonArrayForEvents() {
+        Set<String> courseAreaIds = leadboardSerializer.getCourseAreaIds();
+        Set<Event> eventsThatShouldBeExported = new HashSet<Event>();
+        for (Event event : allEvents) {
+            boolean shouldBeExported = false;
+            for (CourseArea courseArea : event.getVenue().getCourseAreas()) {
+                if (courseAreaIds.contains(courseArea.getId().toString())) {
+                    shouldBeExported = true;
+                    break;
+                }
+            }
+            if (shouldBeExported) {
+                eventsThatShouldBeExported.add(event);
+            }
+        }
+        
+        JSONArray array = new JSONArray();
+        for (Event event : eventsThatShouldBeExported) {
+            array.add(eventSerializer.serialize(event));
+        }
+        return array;
+    }
+
+    private JSONArray createJsonArrayForLeaderboards(Iterable<Leaderboard> leaderboards) {
+        JSONArray jsonLeaderBoards = new JSONArray();
+        for (Leaderboard leaderboard : leaderboards) {
+            JSONObject jsonLeaderboard = leadboardSerializer.serialize(leaderboard);
+            jsonLeaderBoards.add(jsonLeaderboard);
+        }
+        return jsonLeaderBoards;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/masterdata/impl/LeaderboardMasterDataJsonSerializer.java

@@ -0,0 +1,294 @@
+package com.sap.sailing.server.gateway.serialization.masterdata.impl;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.CourseArea;
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.leaderboard.FlexibleLeaderboard;
+import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
+import com.sap.sailing.domain.leaderboard.ResultDiscardingRule;
+import com.sap.sailing.domain.leaderboard.ScoringScheme;
+import com.sap.sailing.domain.leaderboard.SettableScoreCorrection;
+import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
+import com.sap.sailing.domain.racelog.RaceLog;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class LeaderboardMasterDataJsonSerializer implements JsonSerializer<Leaderboard> {
+
+    public static final String FIELD_FOR_RACE_COLUMNS = "forRaceColumns";
+    public static final String FIELD_TIME_POINT = "timePoint";
+    public static final String FIELD_COMMENT = "comment";
+    public static final String FIELD_MAX_POINTS_REASON = "maxPointsReason";
+    public static final String FIELD_EXPLICIT_SCORE_CORRECTION = "explicitScoreCorrection";
+    public static final String FIELD_FOR_COMPETITORS = "forCompetitors";
+    public static final String FIELD_RACE_COLUMN_NAME = "raceColumnName";
+    public static final String FIELD_RACE_COLUMNS = "raceColumns";
+    public static final String FIELD_COMPETITORS = "competitors";
+    public static final String FIELD_NAME = "name";
+    public static final String FIELD_SCORE_CORRECTION = "scoreCorrection";
+    public static final String FIELD_SCORING_SCHEME = "scoringScheme";
+    public static final String FIELD_TYPE = "type";
+    public static final String FIELD_REGATTA_LEADERBOARD = "regattaLeaderboard";
+    public static final String FIELD_RESULT_DISCARDING_RULE = "resultDiscardingRule";
+    public static final String FIELD_INDICES = "indices";
+    public static final String FIELD_COURSE_AREA = "courseArea";
+    public static final String FIELD_ID = "id";
+    public static final String FIELD_REGATTA_NAME = "regattaName";
+    public static final String FIELD_DISPLAY_NAME = "displayName";
+    public static final String FIELD_COMPETITOR_ID = "competitorId";
+    public static final String FIELD_CARRIED_POINTS = "carriedPoints";
+    public static final String FIELD_CARRIED = "carried";
+    public static final String FIELD_SUPPRESSED_COMPETITORS = "suppressedCompetitors";
+    public static final String FIELD_COMPETITOR_DISPLAY_NAMES = "competitorDisplayNames";
+    public static final String FIELD_RACE_LOG_EVENTS = "raceLogEvents";
+    public static final String FIELD_FLEETS = "fleets";
+    public static final String FIELD_FLEET_NAME = "fleetName";
+
+    private final JsonSerializer<Competitor> competitorSerializer;
+    private final JsonSerializer<RaceColumn> raceColumnSerializer;
+    private final JsonSerializer<RaceLogEvent> raceLogEventSerializer;
+
+    /*
+     * TODO This is a hack to "remember" the course areas to allow finding the events which own the course areas. This
+     * way regatta leaderboard can be completely exported, because all events, their regattas, etc can be exported too.
+     * Their should be a proper connection between regatta and event soon.
+     */
+    private final Set<String> courseAreaIds = new HashSet<String>();
+
+    private final Set<Regatta> regattas = new HashSet<Regatta>();
+
+    public LeaderboardMasterDataJsonSerializer(JsonSerializer<Competitor> competitorSerializer,
+            JsonSerializer<RaceColumn> raceColumnSerializer, JsonSerializer<RaceLogEvent> raceLogEventSerializer) {
+        this.competitorSerializer = competitorSerializer;
+        this.raceColumnSerializer = raceColumnSerializer;
+        this.raceLogEventSerializer = raceLogEventSerializer;
+    }
+
+    @Override
+    public JSONObject serialize(Leaderboard leaderboard) {
+        if (leaderboard == null) {
+            return null;
+        }
+        JSONObject jsonLeaderboard = new JSONObject();
+        jsonLeaderboard.put(FIELD_NAME, leaderboard.getName());
+        jsonLeaderboard.put(FIELD_SCORE_CORRECTION, createJsonForScoreCorrection(leaderboard));
+        jsonLeaderboard.put(FIELD_CARRIED_POINTS, createJsonArrayForCarriedPoints(leaderboard));
+        jsonLeaderboard.put(FIELD_SUPPRESSED_COMPETITORS,
+                createJsonArrayForSuppressedCompetitors(leaderboard.getSuppressedCompetitors()));
+        jsonLeaderboard.put(FIELD_COMPETITOR_DISPLAY_NAMES, createJsonArrayForCompetitorDisplayNames(leaderboard));
+        jsonLeaderboard.put(FIELD_COMPETITORS, createJsonArrayForCompetitors(leaderboard.getAllCompetitors()));
+        jsonLeaderboard.put(FIELD_RESULT_DISCARDING_RULE,
+                createJsonForResultDiscardingRule(leaderboard.getResultDiscardingRule()));
+        jsonLeaderboard.put(FIELD_DISPLAY_NAME, leaderboard.getDisplayName());
+        jsonLeaderboard.put(FIELD_RACE_LOG_EVENTS, createJsonArrayForRaceLogEventsPerRaceColumn(leaderboard));
+        boolean isRegattaLeaderboard = false;
+        if (leaderboard instanceof FlexibleLeaderboard) {
+            FlexibleLeaderboard flexibleLeaderboard = (FlexibleLeaderboard) leaderboard;
+            jsonLeaderboard.put(FIELD_SCORING_SCHEME, createJsonForScoringScheme(leaderboard.getScoringScheme()));
+            jsonLeaderboard.put(FIELD_COURSE_AREA, createJsonForCourseArea(flexibleLeaderboard.getDefaultCourseArea()));
+            jsonLeaderboard.put(FIELD_RACE_COLUMNS, createJsonArrayForRaceColumns(leaderboard.getRaceColumns()));
+        } else {
+            RegattaLeaderboard regattaLeaderboard = (RegattaLeaderboard) leaderboard;
+            jsonLeaderboard.put(FIELD_REGATTA_NAME, regattaLeaderboard.getRegatta().getName());
+            CourseArea courseArea = regattaLeaderboard.getRegatta().getDefaultCourseArea();
+            if (courseArea != null) {
+                courseAreaIds.add(courseArea.getId().toString());
+            }
+            regattas.add(regattaLeaderboard.getRegatta());
+            isRegattaLeaderboard = true;
+        }
+
+        jsonLeaderboard.put(FIELD_REGATTA_LEADERBOARD, isRegattaLeaderboard);
+
+        return jsonLeaderboard;
+    }
+
+    private JSONArray createJsonArrayForRaceLogEventsPerRaceColumn(Leaderboard leaderboard) {
+        JSONArray array = new JSONArray();
+        for (RaceColumn raceColumn : leaderboard.getRaceColumns()) {
+            JSONObject raceColumnRaceLogJson = new JSONObject();
+            raceColumnRaceLogJson.put(FIELD_RACE_COLUMN_NAME, raceColumn.getName());
+            raceColumnRaceLogJson.put(FIELD_FLEETS, createJsonArrayForRaceLogEventsForFleets(raceColumn));
+            array.add(raceColumnRaceLogJson);
+        }
+        return array;
+    }
+
+    private JSONArray createJsonArrayForRaceLogEventsForFleets(RaceColumn raceColumn) {
+        JSONArray array = new JSONArray();
+        for (Fleet fleet : raceColumn.getFleets()) {
+            JSONObject fleetRaceLogJson = new JSONObject();
+            fleetRaceLogJson.put(FIELD_FLEET_NAME, fleet.getName());
+            fleetRaceLogJson.put(FIELD_RACE_LOG_EVENTS, createRaceLogEventsForFleet(raceColumn, fleet));
+            array.add(fleetRaceLogJson);
+        }
+        return array;
+    }
+
+    private JSONArray createRaceLogEventsForFleet(RaceColumn raceColumn, Fleet fleet) {
+        JSONArray array = new JSONArray();
+        RaceLog raceLog = raceColumn.getRaceLog(fleet);
+        raceLog.lockForRead();
+        for (RaceLogEvent event : raceLog.getFixes()) {
+            array.add(raceLogEventSerializer.serialize(event));
+        }
+        raceLog.unlockAfterRead();
+        return array;
+    }
+
+    private JSONArray createJsonArrayForCompetitorDisplayNames(Leaderboard leaderboard) {
+        JSONArray array = new JSONArray();
+        for (Competitor competitor : leaderboard.getAllCompetitors()) {
+            String displayName = leaderboard.getDisplayName(competitor);
+            if (displayName != null) {
+                JSONObject displayNameJson = new JSONObject();
+                displayNameJson.put(FIELD_COMPETITOR_ID, competitor.getId().toString());
+                displayNameJson.put(FIELD_DISPLAY_NAME, displayName);
+                array.add(displayNameJson);
+            }
+        }
+        return array;
+    }
+
+    private JSONArray createJsonArrayForSuppressedCompetitors(Iterable<Competitor> suppressedCompetitors) {
+        JSONArray array = new JSONArray();
+        for (Competitor competitor : suppressedCompetitors) {
+            array.add(competitor.getId().toString());
+        }
+        return array;
+    }
+
+    private JSONArray createJsonArrayForCarriedPoints(Leaderboard leaderboard) {
+        JSONArray jsonArray = new JSONArray();
+        for (Competitor competitor : leaderboard.getAllCompetitors()) {
+            double carriedPoints = leaderboard.getCarriedPoints(competitor);
+            if (carriedPoints != 0) {
+                jsonArray.add(createJsonForCarriedPoints(competitor.getId().toString(), carriedPoints));
+            }
+        }
+
+        return jsonArray;
+    }
+
+    private JSONObject createJsonForCarriedPoints(String id, double carriedPoints) {
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put(FIELD_COMPETITOR_ID, id);
+        jsonObject.put(FIELD_CARRIED, carriedPoints);
+        return jsonObject;
+    }
+
+    private JSONObject createJsonForCourseArea(CourseArea defaultCourseArea) {
+        if (defaultCourseArea == null) {
+            return null;
+        }
+        JSONObject result = new JSONObject();
+        result.put(FIELD_ID, defaultCourseArea.getId());
+        result.put(FIELD_NAME, defaultCourseArea.getName());
+        return null;
+    }
+
+    private JSONObject createJsonForResultDiscardingRule(ResultDiscardingRule resultDiscardingRule) {
+        JSONObject result = new JSONObject();
+        if (resultDiscardingRule instanceof ThresholdBasedResultDiscardingRule) {
+            ThresholdBasedResultDiscardingRule rule = (ThresholdBasedResultDiscardingRule) resultDiscardingRule;
+            JSONArray indices = new JSONArray();
+            int[] rawValues = rule.getDiscardIndexResultsStartingWithHowManyRaces();
+            for (int i = 0; i < rawValues.length; i++) {
+                indices.add(new Integer(rawValues[i]));
+            }
+            result.put(FIELD_INDICES, indices);
+        }
+        return result;
+    }
+
+    private JSONObject createJsonForScoringScheme(ScoringScheme scoringScheme) {
+        JSONObject result = new JSONObject();
+        result.put(FIELD_TYPE, scoringScheme.getType().name());
+        return result;
+    }
+
+    private JSONArray createJsonArrayForRaceColumns(Iterable<RaceColumn> raceColumns) {
+        JSONArray jsonRaceColumns = new JSONArray();
+        for (RaceColumn raceColumn : raceColumns) {
+            JSONObject jsonRaceColumn = raceColumnSerializer.serialize(raceColumn);
+            jsonRaceColumns.add(jsonRaceColumn);
+        }
+        return jsonRaceColumns;
+    }
+
+    private JSONArray createJsonArrayForCompetitors(Iterable<Competitor> allCompetitors) {
+        JSONArray jsonCompetitors = new JSONArray();
+        for (Competitor competitor : allCompetitors) {
+            JSONObject jsonCompetitor = competitorSerializer.serialize(competitor);
+            jsonCompetitors.add(jsonCompetitor);
+        }
+        return jsonCompetitors;
+    }
+
+    private JSONObject createJsonForScoreCorrection(Leaderboard leaderboard) {
+        SettableScoreCorrection correction = leaderboard.getScoreCorrection();
+        JSONObject jsonScoreCorrection = new JSONObject();
+        jsonScoreCorrection.put(FIELD_COMMENT, correction.getComment());
+        if (correction.getTimePointOfLastCorrectionsValidity() != null) {
+            jsonScoreCorrection.put(FIELD_TIME_POINT, correction.getTimePointOfLastCorrectionsValidity().asMillis());
+        } else {
+            jsonScoreCorrection.put(FIELD_TIME_POINT, null);
+        }
+
+        jsonScoreCorrection.put(FIELD_FOR_RACE_COLUMNS,
+                createJSONArrayForScoreCorrectionsForRaceColumns(correction, leaderboard));
+
+        return jsonScoreCorrection;
+    }
+
+    private JSONArray createJSONArrayForScoreCorrectionsForRaceColumns(SettableScoreCorrection correction,
+            Leaderboard leaderboard) {
+        JSONArray scoreCorrectionsForRaceColumns = new JSONArray();
+        for (RaceColumn raceColumn : leaderboard.getRaceColumns()) {
+            if (correction.hasCorrectionFor(raceColumn)) {
+                JSONObject scoreCorrectionsForRaceColumn = new JSONObject();
+                scoreCorrectionsForRaceColumn.put(FIELD_RACE_COLUMN_NAME, raceColumn.getName());
+                scoreCorrectionsForRaceColumn.put(FIELD_FOR_COMPETITORS,
+                        createJsonForScoreCorrectionsForRaceColumnAndCompetitors(correction, raceColumn, leaderboard));
+                scoreCorrectionsForRaceColumns.add(scoreCorrectionsForRaceColumn);
+            }
+
+        }
+
+        return scoreCorrectionsForRaceColumns;
+    }
+
+    private JSONArray createJsonForScoreCorrectionsForRaceColumnAndCompetitors(SettableScoreCorrection correction,
+            RaceColumn raceColumn, Leaderboard leaderboard) {
+        JSONArray scoreCorrectionsForCompetitors = new JSONArray();
+        for (Competitor competitor : leaderboard.getAllCompetitors()) {
+            JSONObject scoreCorrectionForCompetitor = new JSONObject();
+            scoreCorrectionForCompetitor.put(FIELD_EXPLICIT_SCORE_CORRECTION,
+                    correction.getExplicitScoreCorrection(competitor, raceColumn));
+            scoreCorrectionForCompetitor.put(FIELD_MAX_POINTS_REASON,
+                    correction.getMaxPointsReason(competitor, raceColumn).toString());
+            scoreCorrectionForCompetitor.put(FIELD_COMPETITOR_ID, competitor.getId().toString());
+            scoreCorrectionsForCompetitors.add(scoreCorrectionForCompetitor);
+        }
+
+        return scoreCorrectionsForCompetitors;
+    }
+
+    public Set<String> getCourseAreaIds() {
+        return courseAreaIds;
+    }
+
+    public Iterable<Regatta> getRegattas() {
+        return regattas;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/masterdata/impl/RaceColumnMasterDataJsonSerializer.java

@@ -0,0 +1,40 @@
+package com.sap.sailing.server.gateway.serialization.masterdata.impl;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.common.RaceIdentifier;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class RaceColumnMasterDataJsonSerializer implements JsonSerializer<RaceColumn> {
+    
+    public static final String FIELD_MEDAL_RACE = "medalRace";
+    public static final String FIELD_NAME = "name";
+    public static final String FIELD_RACE_IDENTIFIERS = "raceIdentifiers";
+    public static final String FIELD_FLEET_NAME = "fleetName";
+    public static final String FIELD_RACE_NAME = "raceName";
+    public static final String FIELD_REGATTA_NAME = "regattaName";
+    
+    @Override
+    public JSONObject serialize(RaceColumn raceColumn) {
+        JSONObject jsonRaceColumn = new JSONObject();
+        jsonRaceColumn.put(FIELD_NAME, raceColumn.getName());
+        jsonRaceColumn.put(FIELD_MEDAL_RACE, raceColumn.isMedalRace());
+        JSONArray raceIdentifiers = new JSONArray();
+        jsonRaceColumn.put(FIELD_RACE_IDENTIFIERS, raceIdentifiers);
+        for (Fleet fleet : raceColumn.getFleets()) {
+            RaceIdentifier raceIdentifierForFleet = raceColumn.getRaceIdentifier(fleet);
+            if (raceIdentifierForFleet != null) {
+                JSONObject jsonRaceIdentifierForFleet = new JSONObject();
+                jsonRaceIdentifierForFleet.put(FIELD_FLEET_NAME, fleet.getName());
+                jsonRaceIdentifierForFleet.put(FIELD_RACE_NAME, raceIdentifierForFleet.getRaceName());
+                jsonRaceIdentifierForFleet.put(FIELD_REGATTA_NAME, raceIdentifierForFleet.getRegattaName());
+                raceIdentifiers.add(jsonRaceIdentifierForFleet);
+            }
+        }
+        return jsonRaceColumn;
+    } 
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/masterdata/impl/RegattaMasterDataJsonSerializer.java

@@ -0,0 +1,139 @@
+package com.sap.sailing.server.gateway.serialization.masterdata.impl;
+
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.CourseArea;
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.base.RaceColumnInSeries;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.base.Series;
+import com.sap.sailing.domain.common.RegattaName;
+import com.sap.sailing.domain.leaderboard.ResultDiscardingRule;
+import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class RegattaMasterDataJsonSerializer implements JsonSerializer<Regatta> {
+
+    public static final String FIELD_ID = "id";
+    public static final String FIELD_NAME = "name";
+    public static final String FIELD_BASE_NAME = "baseName";
+    public static final String FIELD_REGATTAS = "regattas";
+    public static final String FIELD_BOAT_CLASS_NAME = "boatClass";
+    public static final String FIELD_DEFAULT_COURSE_AREA_ID = "defaultCourseAreaId";
+    public static final String FIELD_SCORING_SCHEME_TYPE = "scoringSchemeType";
+    public static final String FIELD_SERIES = "series";
+    public static final String FIELD_RACE_COLUMNS = "raceColumns";
+    public static final String FIELD_IS_MEDAL = "isMedal";
+    public static final String FIELD_FLEETS = "fleets";
+    public static final String FIELD_IS_PERSISTENT = "isPersistent";
+    public static final String FIELD_REGATTA_NAME = "regattaName";
+    public static final String FIELD_RESULT_DISCARDING_RULE = "resultDiscardingRule";
+    public static final String FIELD_INDICES = "indices";
+    public static final String FIELD_REGATTA_RACE_IDS = "regattaRaceIds";
+
+    private final JsonSerializer<Fleet> fleetSerializer;
+    private final JsonSerializer<RaceColumn> raceColumnSerializer;
+    private final ConcurrentHashMap<String, Regatta> regattaForRaceIdStrings;
+
+    public RegattaMasterDataJsonSerializer(JsonSerializer<Fleet> fleetSerializer,
+            JsonSerializer<RaceColumn> raceColumnSerializer, ConcurrentHashMap<String, Regatta> regattaForRaceIdStrings) {
+        this.fleetSerializer = fleetSerializer;
+        this.raceColumnSerializer = raceColumnSerializer;
+        this.regattaForRaceIdStrings = regattaForRaceIdStrings;
+    }
+
+    @Override
+    public JSONObject serialize(Regatta regatta) {
+        return createJsonForRegatta(regatta);
+    }
+
+    private JSONObject createJsonForRegatta(Regatta regatta) {
+        JSONObject result = new JSONObject();
+        result.put(FIELD_ID, regatta.getId().toString());
+        result.put(FIELD_BASE_NAME, regatta.getBaseName());
+        result.put(FIELD_BOAT_CLASS_NAME, regatta.getBoatClass().getName());
+        CourseArea defaultCourseArea = regatta.getDefaultCourseArea();
+        if (defaultCourseArea != null) {
+            result.put(FIELD_DEFAULT_COURSE_AREA_ID, defaultCourseArea.getId().toString());
+        } else {
+            result.put(FIELD_DEFAULT_COURSE_AREA_ID, null);
+        }
+        result.put(FIELD_SCORING_SCHEME_TYPE, regatta.getScoringScheme().getType().toString());
+        result.put(FIELD_SERIES, createJsonArrayForSeries(regatta.getSeries()));
+        result.put(FIELD_IS_PERSISTENT, regatta.isPersistent());
+        result.put(FIELD_REGATTA_NAME, ((RegattaName) regatta.getRegattaIdentifier()).getRegattaName());
+        result.put(FIELD_REGATTA_RACE_IDS, createJsonArrayForRaceIdStrings(regatta));
+        return result;
+    }
+
+    private JSONArray createJsonArrayForRaceIdStrings(Regatta regatta) {
+        JSONArray result = new JSONArray();
+        for (Entry<String, Regatta> entry: regattaForRaceIdStrings.entrySet()) {
+            if (entry.getValue() == regatta) {
+                result.add(entry.getKey());
+            }
+        }
+        return result;
+    }
+
+    private JSONArray createJsonArrayForSeries(Iterable<? extends Series> series) {
+        JSONArray array = new JSONArray();
+        for (Series oneSeries : series) {
+            array.add(createJsonForSeries(oneSeries));
+        }
+        return array;
+    }
+
+    private JSONObject createJsonForSeries(Series series) {
+        JSONObject result = new JSONObject();
+        result.put(FIELD_NAME, series.getName());
+        result.put(FIELD_IS_MEDAL, series.isMedal());
+        result.put(FIELD_FLEETS, createJsonArrayForFleets(series.getFleets()));
+        result.put(FIELD_RACE_COLUMNS, createJsonArrayForRaceColumns(series.getRaceColumns()));
+        result.put(FIELD_RESULT_DISCARDING_RULE, createJsonForResultDiscardingRule(series.getResultDiscardingRule()));
+        return result;
+    }
+
+    private JSONObject createJsonForResultDiscardingRule(ResultDiscardingRule resultDiscardingRule) {
+        if (resultDiscardingRule == null) {
+            return null;
+        }
+        JSONObject result = new JSONObject();
+        if (resultDiscardingRule instanceof ThresholdBasedResultDiscardingRule) {
+            ThresholdBasedResultDiscardingRule rule = (ThresholdBasedResultDiscardingRule) resultDiscardingRule;
+            JSONArray indices = new JSONArray();
+            int[] rawValues = rule.getDiscardIndexResultsStartingWithHowManyRaces();
+            for (int i = 0; i < rawValues.length; i++) {
+                indices.add(new Integer(rawValues[i]));
+            }
+            result.put(FIELD_INDICES, indices);
+        }
+        return result;
+    }
+
+    private JSONArray createJsonArrayForFleets(Iterable<? extends Fleet> fleets) {
+        JSONArray array = new JSONArray();
+        for (Fleet fleet : fleets) {
+            array.add(fleetSerializer.serialize(fleet));
+        }
+        return array;
+    }
+
+    private JSONArray createJsonArrayForRaceColumns(Iterable<? extends RaceColumnInSeries> raceColumns) {
+        JSONArray array = new JSONArray();
+        for (RaceColumnInSeries raceColumn : raceColumns) {
+            array.add(createJsonForRaceColumn(raceColumn));
+        }
+        return array;
+    }
+
+    private JSONObject createJsonForRaceColumn(RaceColumnInSeries raceColumn) {
+        return raceColumnSerializer.serialize(raceColumn);
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/masterdata/impl/TopLevelMasterDataSerializer.java

@@ -0,0 +1,50 @@
+package com.sap.sailing.server.gateway.serialization.masterdata.impl;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.json.simple.JSONArray;
+
+import com.sap.sailing.domain.base.Event;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+/**
+ * Will take care of serializing all master data connected to a set of leaderboard groups. They
+ * are identified in {@link #serialize(Set)}. The serializer must be created with a reference to all
+ * leaderboard groups and all events, so that all necessary data can be found and serialized.
+ * 
+ * @author Frederik Petersen (D054528)
+ *
+ */
+public class TopLevelMasterDataSerializer  {
+    
+    private final Map<String, LeaderboardGroup> allLeaderboardGroups;
+    private final Iterable<Event> allEvents;
+    private final ConcurrentHashMap<String, Regatta> regattaForRaceIdStrings;
+
+    public TopLevelMasterDataSerializer(Map<String, LeaderboardGroup> allLeaderboardGroups, Iterable<Event> allEvents, ConcurrentHashMap<String, Regatta> regattaForRaceIdString) {
+        this.allLeaderboardGroups = allLeaderboardGroups;
+        this.allEvents = allEvents;
+        this.regattaForRaceIdStrings = regattaForRaceIdString;
+        
+    }
+
+    public JSONArray serialize(Set<String> requestedLeaderboardGroupNames) {
+        JSONArray masterData = new JSONArray();
+
+        for (String name : requestedLeaderboardGroupNames) {
+            LeaderboardGroup leaderboardGroup = allLeaderboardGroups.get(name);
+            if (leaderboardGroup == null) {
+                continue;
+            }
+            JsonSerializer<LeaderboardGroup> serializer = new LeaderboardGroupMasterDataJsonSerializer(allEvents, regattaForRaceIdStrings);
+            masterData.add(serializer.serialize(leaderboardGroup));
+        }
+        
+        return masterData;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/racelog/impl/BaseRaceLogEventSerializer.java

@@ -10,7 +10,7 @@ import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 public abstract class BaseRaceLogEventSerializer implements JsonSerializer<RaceLogEvent> {
     public static final String FIELD_CLASS = "@class";
     public static final String FIELD_ID = "id";
-    public static final Object FIELD_CREATED_AT = "createdAt";
+    public static final String FIELD_CREATED_AT = "createdAt";
     public static final String FIELD_TIMESTAMP = "timestamp";
     public static final String FIELD_PASS_ID = "passId";
     public static final String FIELD_COMPETITORS = "competitors";

java/com.sap.sailing.server.gateway/META-INF/MANIFEST.MF

@@ -5,12 +5,13 @@ Bundle-SymbolicName: com.sap.sailing.server.gateway
 Bundle-Version: 1.0.0.qualifier
 Bundle-Vendor: SAP
 Bundle-RequiredExecutionEnvironment: JavaSE-1.7
-Import-Package: org.apache.jasper.servlet,
+Import-Package: com.sap.sailing.server,
+ com.sap.sailing.server.operationaltransformation,
+ org.apache.jasper.servlet,
  org.json.simple,
  org.json.simple.parser,
  org.osgi.framework;version="1.3.0",
- org.osgi.util.tracker;version="1.3.1",
- com.sap.sailing.server
+ org.osgi.util.tracker;version="1.3.1"
 Bundle-ActivationPolicy: lazy
 Require-Bundle: com.sap.sailing.domain,
  com.sap.sailing.expeditionconnector,

java/com.sap.sailing.server.gateway/WEB-INF/web.xml

@@ -185,6 +185,15 @@
 		<servlet-name>LiveRaceRankingRssGetServlet</servlet-name>
 		<url-pattern>/rss/liveRaceRanking</url-pattern>
 	</servlet-mapping>
+	
+	<servlet>
+		<servlet-name>MasterDataByLeaderboardGroupJsonGetServlet</servlet-name>
+		<servlet-class>com.sap.sailing.server.gateway.impl.MasterDataByLeaderboardGroupJsonGetServlet</servlet-class>
+	</servlet>
+	<servlet-mapping>
+		<servlet-name>MasterDataByLeaderboardGroupJsonGetServlet</servlet-name>
+		<url-pattern>/masterdata/leaderboardgroups</url-pattern>
+	</servlet-mapping>
  
 	<servlet id="jsp">
      <servlet-name>jspServet</servlet-name>

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/impl/MasterDataByLeaderboardGroupJsonGetServlet.java

@@ -0,0 +1,68 @@
+package com.sap.sailing.server.gateway.impl;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.json.simple.JSONArray;
+
+import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
+import com.sap.sailing.server.gateway.AbstractJsonHttpServlet;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.TopLevelMasterDataSerializer;
+
+public class MasterDataByLeaderboardGroupJsonGetServlet extends AbstractJsonHttpServlet {
+
+    private static final long serialVersionUID = 998103495657252850L;
+
+    @Override
+    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        Map<String, LeaderboardGroup> leaderboardGroups = getService().getLeaderboardGroups();
+        Set<String> requestedLeaderboardGroupNames = new HashSet<String>();
+
+        String query = req.getQueryString();
+        if (query != null && query.length() > 0) {
+            String[] names = parseQuery(query);
+            for (int i = 0; i < names.length; i++) {
+                requestedLeaderboardGroupNames.add(names[i]);
+            }
+        } else {
+            // No range supplied. Export all for now
+            requestedLeaderboardGroupNames.addAll(leaderboardGroups.keySet());
+        }
+
+        TopLevelMasterDataSerializer masterSerializer = new TopLevelMasterDataSerializer(leaderboardGroups,
+                getService().getAllEvents(), getService().getPersistentRegattasForRaceIDs());
+
+        JSONArray masterData = masterSerializer.serialize(requestedLeaderboardGroupNames);
+
+        setJsonResponseHeader(resp);
+        masterData.writeJSONString(resp.getWriter());
+    }
+
+    private String[] parseQuery(String query) throws UnsupportedEncodingException {
+        List<String> names = new ArrayList<String>();
+        for (String pair : query.split("&")) {
+            int eq = pair.indexOf("=");
+            if (eq >= 0) {
+                // key=value
+                String key = URLDecoder.decode(pair.substring(0, eq), "UTF-8");
+                String value = URLDecoder.decode(pair.substring(eq + 1), "UTF-8");
+                if (key.contains("names")) {
+                    names.add(value);
+                }
+            }
+        }
+
+        return names.toArray(new String[names.size()]);
+    }
+
+}

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/impl/RegattaEntryListJsonGetServlet.java

@@ -13,6 +13,7 @@ import com.sap.sailing.domain.common.RegattaName;
 import com.sap.sailing.server.gateway.AbstractJsonHttpServlet;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.RegattaJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
@@ -26,14 +27,17 @@ public class RegattaEntryListJsonGetServlet extends AbstractJsonHttpServlet {
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         String regattaName = request.getParameter(PARAM_NAME_REGATTANAME);
         if (regattaName == null) {
-            response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Need to specify a regatta name using the "+
-                    PARAM_NAME_REGATTANAME + " parameter");
+            response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+                    "Need to specify a regatta name using the " + PARAM_NAME_REGATTANAME + " parameter");
         } else {
             Regatta regatta = getService().getRegatta(new RegattaName(regattaName));
             if (regatta == null) {
-                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Regatta " + regattaName + " not found");
+                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Regatta " + regattaName
+                        + " not found");
             } else {
-                CompetitorJsonSerializer competitorJsonSerializer = new CompetitorJsonSerializer(new TeamJsonSerializer(new PersonJsonSerializer()));
+                NationalityJsonSerializer nationalityJsonSerializer = new NationalityJsonSerializer();
+                CompetitorJsonSerializer competitorJsonSerializer = new CompetitorJsonSerializer(
+                        new TeamJsonSerializer(new PersonJsonSerializer(nationalityJsonSerializer)));
                 JsonSerializer<Regatta> regattaSerializer = new RegattaJsonSerializer(null, competitorJsonSerializer);
                 JSONObject serializedRegatta = regattaSerializer.serialize(regatta);
 

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/impl/rc/CompetitorsJsonExportServlet.java

@@ -16,6 +16,7 @@ import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sailing.server.gateway.AbstractJsonHttpServlet;
 import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
 
@@ -75,7 +76,7 @@ public class CompetitorsJsonExportServlet extends AbstractJsonHttpServlet {
         JSONArray result = new JSONArray();
         
         if (trackedRace != null) {
-            CompetitorJsonSerializer serializer = new CompetitorJsonSerializer(new TeamJsonSerializer(new PersonJsonSerializer()));
+            CompetitorJsonSerializer serializer = new CompetitorJsonSerializer(new TeamJsonSerializer(new PersonJsonSerializer(new NationalityJsonSerializer())));
 
             for (Competitor competitor : raceColumn.getRaceDefinition(fleet).getCompetitors()) {
                 result.add(serializer.serialize(competitor));

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/impl/rc/RaceGroupJsonExportServlet.java

@@ -20,6 +20,7 @@ import com.sap.sailing.server.gateway.serialization.impl.ColorJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.CompetitorJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.CourseAreaJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.FleetJsonSerializer;
+import com.sap.sailing.server.gateway.serialization.impl.NationalityJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.PersonJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.impl.TeamJsonSerializer;
 import com.sap.sailing.server.gateway.serialization.racegroup.impl.RaceCellJsonSerializer;
@@ -88,7 +89,8 @@ public class RaceGroupJsonExportServlet extends AbstractJsonHttpServlet {
     }
 
     private static JsonSerializer<RaceLog> createRaceLogSerializer() {
-        return new RaceLogSerializer(RaceLogEventSerializer.create(new CompetitorJsonSerializer(new TeamJsonSerializer(new PersonJsonSerializer()))));
+        return new RaceLogSerializer(RaceLogEventSerializer.create(new CompetitorJsonSerializer(new TeamJsonSerializer(
+                new PersonJsonSerializer(new NationalityJsonSerializer())))));
     }
 
 }

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

@@ -16,7 +16,8 @@ Require-Bundle: com.sap.sailing.domain,
  com.tractrac.clientmodule;bundle-version="2.0.0",
  com.mongodb.driver;bundle-version="2.6.2",
  com.sap.sailing.domain.test,
- org.hamcrest;bundle-version="1.1.0"
+ org.hamcrest;bundle-version="1.1.0",
+ com.sap.sailing.server.gateway.serialization;bundle-version="1.0.0"
 Import-Package: junit.framework;version="4.8.1",
  org.junit;version="4.8.1",
  org.json.simple

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

@@ -0,0 +1,882 @@
+package com.sap.sailing.server.test;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.net.MalformedURLException;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+import junit.framework.Assert;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.junit.After;
+import org.junit.Test;
+
+import com.mongodb.DBCollection;
+import com.mongodb.DBCursor;
+import com.sap.sailing.domain.base.Boat;
+import com.sap.sailing.domain.base.BoatClass;
+import com.sap.sailing.domain.base.Competitor;
+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.Person;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.base.Series;
+import com.sap.sailing.domain.base.Team;
+import com.sap.sailing.domain.base.impl.BoatClassImpl;
+import com.sap.sailing.domain.base.impl.BoatImpl;
+import com.sap.sailing.domain.base.impl.CompetitorImpl;
+import com.sap.sailing.domain.base.impl.CourseAreaImpl;
+import com.sap.sailing.domain.base.impl.FleetImpl;
+import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.base.impl.NationalityImpl;
+import com.sap.sailing.domain.base.impl.PersonImpl;
+import com.sap.sailing.domain.base.impl.SeriesImpl;
+import com.sap.sailing.domain.base.impl.TeamImpl;
+import com.sap.sailing.domain.common.MaxPointsReason;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.MasterDataImportObjectCreationCountImpl;
+import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
+import com.sap.sailing.domain.leaderboard.impl.LowPoint;
+import com.sap.sailing.domain.masterdataimport.LeaderboardGroupMasterData;
+import com.sap.sailing.domain.racelog.RaceLogEventFactory;
+import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
+import com.sap.sailing.domain.racelog.impl.RaceLogEventFactoryImpl;
+import com.sap.sailing.domain.tracking.TrackedRace;
+import com.sap.sailing.mongodb.MongoDBService;
+import com.sap.sailing.server.RacingEventService;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.masterdata.impl.LeaderboardGroupMasterDataJsonDeserializer;
+import com.sap.sailing.server.gateway.serialization.masterdata.impl.TopLevelMasterDataSerializer;
+import com.sap.sailing.server.impl.RacingEventServiceImpl;
+import com.sap.sailing.server.operationaltransformation.DummyTrackedRace;
+import com.sap.sailing.server.operationaltransformation.ImportMasterDataOperation;
+
+public class MasterDataImportTest {
+
+    private static final String TEST_GROUP_NAME = "testGroup";
+    private static final String TEST_EVENT_NAME = "testEvent";
+    private static final String TEST_LEADERBOARD_NAME = "testRegatta (29er)";
+
+    private final UUID eventUUID = UUID.randomUUID();
+
+    /**
+     * Log Events created when running test. Will be removed from db at teardown
+     */
+    private Set<Serializable> storedLogUUIDs = new HashSet<Serializable>();
+
+    @After
+    public void tearDown() throws MalformedURLException, IOException, InterruptedException {
+        deleteCreatedDataFromDatabase();
+
+    }
+
+    private void deleteCreatedDataFromDatabase() throws MalformedURLException, IOException, InterruptedException {
+        storedLogUUIDs.clear();
+        RacingEventService service = new RacingEventServiceImpl();
+        LeaderboardGroup group = service.getLeaderboardGroupByName(TEST_GROUP_NAME);
+        if (group != null) {
+            service.removeLeaderboardGroup(TEST_GROUP_NAME);
+        }
+        Leaderboard leaderboard = service.getLeaderboardByName(TEST_LEADERBOARD_NAME);
+        if (leaderboard != null) {
+            service.removeLeaderboard(TEST_LEADERBOARD_NAME);
+        }
+        Event event = service.getEvent(eventUUID);
+        if (event != null) {
+            service.removeEvent(eventUUID);
+        }
+        Regatta regatta = service.getRegattaByName(TEST_LEADERBOARD_NAME);
+        if (regatta != null) {
+            service.removeRegatta(regatta);
+        }
+        DBCollection raceLogCollection = MongoDBService.INSTANCE.getDB().getCollection("RACE_LOGS");
+        //Removes all race log events
+        DBCursor cursor = raceLogCollection.find();
+        while (cursor.hasNext()) {
+            raceLogCollection.remove(cursor.next());
+        }
+        // This should only delete those logs created during this test. Sadly it doesn't seem to work.
+        // Didnt use CollectionNames stuff since it was not visible in this package. Sucks as soon as these names
+        // change, I know..
+        // raceLogCollection.ensureIndex(new BasicDBObject("RACE_LOG_EVENT_ID", null));
+        // for (Serializable id : storedLogUUIDs) {
+        // BasicDBObject query = new BasicDBObject();
+        // query.put("RACE_LOG_EVENT.RACE_LOG_EVENT_ID", id);
+        // DBCursor result = raceLogCollection.find(query);
+        // while (result.hasNext()) {
+        // raceLogCollection.remove(result.next());
+        // }
+        // }
+    }
+
+    @Test
+    public void testMasterDataImportWithoutHttpStack() throws MalformedURLException, IOException, InterruptedException {
+        // Setup source service
+        RacingEventService sourceService = new RacingEventServiceImpl();
+        Event event = sourceService.addEvent(TEST_EVENT_NAME, "testVenue", "", false, eventUUID,
+                new ArrayList<String>());
+        UUID courseAreaUUID = UUID.randomUUID();
+        CourseArea courseArea = new CourseAreaImpl("testArea", courseAreaUUID);
+        event.getVenue().addCourseArea(courseArea);
+
+        List<String> raceColumnNames = new ArrayList<String>();
+        String raceColumnName = "T1";
+        raceColumnNames.add(raceColumnName);
+        raceColumnNames.add("T2");
+
+        List<Series> series = new ArrayList<Series>();
+        List<Fleet> fleets = new ArrayList<Fleet>();
+        FleetImpl testFleet1 = new FleetImpl("testFleet1");
+        fleets.add(testFleet1);
+        fleets.add(new FleetImpl("testFleet2"));
+        series.add(new SeriesImpl("testSeries", false, fleets, raceColumnNames, sourceService));
+        UUID regattaUUID = UUID.randomUUID();
+        Regatta regatta = sourceService.createRegatta("testRegatta", "29er", regattaUUID, series, true, new LowPoint(),
+                courseAreaUUID);
+        event.addRegatta(regatta);
+        int[] discardRule = { 1, 2, 3, 4 };
+        Leaderboard leaderboard = sourceService.addRegattaLeaderboard(regatta.getRegattaIdentifier(),
+                "testDisplayName", discardRule);
+        List<String> leaderboardNames = new ArrayList<String>();
+        leaderboardNames.add(leaderboard.getName());
+        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+
+        // Set tracked Race with competitors
+        Set<Competitor> competitors = new HashSet<Competitor>();
+        UUID competitorUUID = UUID.randomUUID();
+        Set<Person> sailors = new HashSet<Person>();
+        sailors.add(new PersonImpl("Froderik Poterson", new NationalityImpl("GER"), new Date(645487200000L),
+                "Oberhoschy"));
+        Person coach = new PersonImpl("Lennart Hensler", new NationalityImpl("GER"), new Date(645487200000L),
+                "Der Lennart halt");
+        Team team = new TeamImpl("Pros", sailors, coach);
+        BoatClass boatClass = new BoatClassImpl("H16", true);
+        Boat boat = new BoatImpl("Wingy", boatClass, "GER70133");
+        CompetitorImpl competitor = new CompetitorImpl(competitorUUID, "Froderik", team, boat);
+        competitors.add(competitor);
+        UUID competitorToSuppressUUID = UUID.randomUUID();
+        Set<Person> sailors2 = new HashSet<Person>();
+        sailors2.add(new PersonImpl("Angela Merkel", new NationalityImpl("GER"), new Date(645487200000L),
+                "segelt auch mit"));
+        Person coach2 = new PersonImpl("Peer Steinbrueck", new NationalityImpl("GER"), new Date(645487200000L),
+                "Bester Coach");
+        Team team2 = new TeamImpl("Noobs", sailors2, coach2);
+        Boat boat2 = new BoatImpl("LahmeEnte", boatClass, "GER1337");
+        CompetitorImpl competitorToSuppress = new CompetitorImpl(competitorToSuppressUUID, "Merkel", team2, boat2);
+        competitors.add(competitorToSuppress);
+        TrackedRace trackedRace = new DummyTrackedRace(competitors, regatta);
+
+        RaceColumn raceColumn = leaderboard.getRaceColumnByName(raceColumnName);
+        raceColumn.setTrackedRace(testFleet1, trackedRace);
+
+        // Set log event
+        RaceLogEventFactory factory = new RaceLogEventFactoryImpl();
+        TimePoint logTimePoint = new MillisecondsTimePoint(1372489200000L);
+        RaceLogStartTimeEvent logEvent = factory.createStartTimeEvent(logTimePoint, 1,
+                logTimePoint);
+        raceColumn.getRaceLog(testFleet1).add(logEvent);
+        storedLogUUIDs.add(logEvent.getId());
+
+        // Set score correction
+        double scoreCorrection = 12.0;
+        leaderboard.getScoreCorrection().correctScore(competitor, raceColumn, scoreCorrection);
+        MaxPointsReason maxPointsReason = MaxPointsReason.DNS;
+        leaderboard.getScoreCorrection().setMaxPointsReason(competitor, raceColumn, maxPointsReason);
+
+        // Set carried Points
+        double carriedPoints = 2.0;
+        leaderboard.setCarriedPoints(competitor, carriedPoints);
+
+        // Set suppressed competitor
+        leaderboard.setSuppressed(competitorToSuppress, true);
+
+        // Set display name
+        String nickName = "Angie";
+        leaderboard.setDisplayName(competitorToSuppress, nickName);
+
+        // Serialize
+        TopLevelMasterDataSerializer serializer = new TopLevelMasterDataSerializer(
+                sourceService.getLeaderboardGroups(), sourceService.getAllEvents(),
+                sourceService.getPersistentRegattasForRaceIDs());
+        Set<String> names = new HashSet<String>();
+        names.add(TEST_GROUP_NAME);
+        JSONArray masterDataOverallArray = serializer.serialize(names);
+        Assert.assertNotNull(masterDataOverallArray);
+
+        // Delete all data above from the database, to allow recreating all of it on target server
+        deleteCreatedDataFromDatabase();
+
+        // Deserialization copied from doPost in MasterDataByLeaderboardGroupJsonPostServlet
+        RacingEventService destService = new RacingEventServiceImplMock();
+        DomainFactory domainFactory = DomainFactory.INSTANCE;
+        MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
+        JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer = LeaderboardGroupMasterDataJsonDeserializer
+                .create(domainFactory);
+        JSONArray leaderboardGroupsMasterDataJsonArray = masterDataOverallArray;
+        // Actual import. Roughly copied from doPost in MasterDataByLeaderboardGroupJsonPostServlet
+        for (Object leaderBoardGroupMasterData : leaderboardGroupsMasterDataJsonArray) {
+            JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
+            LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
+                    .deserialize(leaderBoardGroupMasterDataJson);
+            ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, false);
+            creationCount.add(destService.apply(op));
+        }
+
+        Assert.assertNotNull(creationCount);
+        Event eventOnTarget = destService.getEvent(eventUUID);
+        Assert.assertNotNull(eventOnTarget);
+        LeaderboardGroup leaderboardGroupOnTarget = destService.getLeaderboardGroupByName(TEST_GROUP_NAME);
+        Assert.assertNotNull(leaderboardGroupOnTarget);
+        Leaderboard leaderboardOnTarget = destService.getLeaderboardByName(TEST_LEADERBOARD_NAME);
+        Assert.assertNotNull(leaderboardOnTarget);
+        Regatta regattaOnTarget = destService.getRegattaByName(TEST_LEADERBOARD_NAME);
+        Assert.assertNotNull(regattaOnTarget);
+
+        Assert.assertEquals(courseAreaUUID, eventOnTarget.getVenue().getCourseAreas().iterator().next().getId());
+
+        RaceColumn raceColumnOnTarget = leaderboardOnTarget.getRaceColumnByName(raceColumnName);
+        Assert.assertNotNull(raceColumnOnTarget);
+
+        Assert.assertTrue(leaderboardOnTarget.getScoreCorrection().hasCorrectionFor(raceColumnOnTarget));
+        Competitor competitorOnTarget = domainFactory.getExistingCompetitorById(competitorUUID);
+        Set<Competitor> competitorsCreatedOnTarget = new HashSet<Competitor>();
+        competitorsCreatedOnTarget.add(competitorOnTarget);
+
+        TrackedRace trackedRaceForTarget = new DummyTrackedRace(competitorsCreatedOnTarget, regattaOnTarget);
+        Fleet fleet1OnTarget = raceColumnOnTarget.getFleetByName(testFleet1.getName());
+        raceColumnOnTarget.setTrackedRace(fleet1OnTarget, trackedRaceForTarget);
+
+        Iterable<Competitor> competitorsOnTarget = leaderboardOnTarget.getAllCompetitors();
+        Iterator<Competitor> competitorIterator = competitorsOnTarget.iterator();
+        Assert.assertTrue(competitorIterator.hasNext());
+        Assert.assertEquals(competitorOnTarget, competitorIterator.next());
+
+        // Check for score corrections
+        Assert.assertEquals(
+                scoreCorrection,
+                leaderboardOnTarget.getScoreCorrection().getExplicitScoreCorrection(competitorOnTarget,
+                        raceColumnOnTarget));
+        Assert.assertEquals(maxPointsReason,
+                leaderboardOnTarget.getScoreCorrection().getMaxPointsReason(competitorOnTarget, raceColumnOnTarget));
+
+        // Check for carried points
+        Assert.assertEquals(carriedPoints, leaderboardOnTarget.getCarriedPoints(competitorOnTarget));
+
+        // Check for suppressed competitor
+        Assert.assertTrue(leaderboardOnTarget.getSuppressedCompetitors().iterator().hasNext());
+        Competitor suppressedCompetitorOnTarget = domainFactory.getExistingCompetitorById(competitorToSuppressUUID);
+        Assert.assertEquals(suppressedCompetitorOnTarget, leaderboardOnTarget.getSuppressedCompetitors().iterator()
+                .next());
+
+        // Check for competitor desplay name
+        Assert.assertEquals(nickName, leaderboardOnTarget.getDisplayName(suppressedCompetitorOnTarget));
+
+        // Check for race log event
+        Assert.assertNotNull(raceColumnOnTarget.getRaceLog(fleet1OnTarget).getFirstRawFix());
+        Assert.assertEquals(logEvent.getId(), raceColumnOnTarget.getRaceLog(fleet1OnTarget).getFirstRawFixAtOrAfter(logTimePoint).getId());
+    }
+    
+    @Test
+    public void testMasterDataImportWithoutOverrideWithoutHttpStack() throws MalformedURLException, IOException, InterruptedException {
+        // Setup source service
+        RacingEventService sourceService = new RacingEventServiceImpl();
+        Event event = sourceService.addEvent(TEST_EVENT_NAME, "testVenue", "", false, eventUUID,
+                new ArrayList<String>());
+        UUID courseAreaUUID = UUID.randomUUID();
+        CourseArea courseArea = new CourseAreaImpl("testArea", courseAreaUUID);
+        event.getVenue().addCourseArea(courseArea);
+
+        List<String> raceColumnNames = new ArrayList<String>();
+        String raceColumnName = "T1";
+        raceColumnNames.add(raceColumnName);
+        raceColumnNames.add("T2");
+
+        List<Series> series = new ArrayList<Series>();
+        List<Fleet> fleets = new ArrayList<Fleet>();
+        FleetImpl testFleet1 = new FleetImpl("testFleet1");
+        fleets.add(testFleet1);
+        fleets.add(new FleetImpl("testFleet2"));
+        series.add(new SeriesImpl("testSeries", false, fleets, raceColumnNames, sourceService));
+        UUID regattaUUID = UUID.randomUUID();
+        Regatta regatta = sourceService.createRegatta("testRegatta", "29er", regattaUUID, series, true, new LowPoint(),
+                courseAreaUUID);
+        event.addRegatta(regatta);
+        int[] discardRule = { 1, 2, 3, 4 };
+        Leaderboard leaderboard = sourceService.addRegattaLeaderboard(regatta.getRegattaIdentifier(),
+                "testDisplayName", discardRule);
+        List<String> leaderboardNames = new ArrayList<String>();
+        leaderboardNames.add(leaderboard.getName());
+        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+
+        // Set tracked Race with competitors
+        Set<Competitor> competitors = new HashSet<Competitor>();
+        UUID competitorUUID = UUID.randomUUID();
+        Set<Person> sailors = new HashSet<Person>();
+        sailors.add(new PersonImpl("Froderik Poterson", new NationalityImpl("GER"), new Date(645487200000L),
+                "Oberhoschy"));
+        Person coach = new PersonImpl("Lennart Hensler", new NationalityImpl("GER"), new Date(645487200000L),
+                "Der Lennart halt");
+        Team team = new TeamImpl("Pros", sailors, coach);
+        BoatClass boatClass = new BoatClassImpl("H16", true);
+        Boat boat = new BoatImpl("Wingy", boatClass, "GER70133");
+        CompetitorImpl competitor = new CompetitorImpl(competitorUUID, "Froderik", team, boat);
+        competitors.add(competitor);
+        UUID competitorToSuppressUUID = UUID.randomUUID();
+        Set<Person> sailors2 = new HashSet<Person>();
+        sailors2.add(new PersonImpl("Angela Merkel", new NationalityImpl("GER"), new Date(645487200000L),
+                "segelt auch mit"));
+        Person coach2 = new PersonImpl("Peer Steinbrueck", new NationalityImpl("GER"), new Date(645487200000L),
+                "Bester Coach");
+        Team team2 = new TeamImpl("Noobs", sailors2, coach2);
+        Boat boat2 = new BoatImpl("LahmeEnte", boatClass, "GER1337");
+        CompetitorImpl competitorToSuppress = new CompetitorImpl(competitorToSuppressUUID, "Merkel", team2, boat2);
+        competitors.add(competitorToSuppress);
+        TrackedRace trackedRace = new DummyTrackedRace(competitors, regatta);
+
+        RaceColumn raceColumn = leaderboard.getRaceColumnByName(raceColumnName);
+        raceColumn.setTrackedRace(testFleet1, trackedRace);
+
+        // Set log event
+        RaceLogEventFactory factory = new RaceLogEventFactoryImpl();
+        TimePoint logTimePoint = new MillisecondsTimePoint(1372489200000L);
+        RaceLogStartTimeEvent logEvent = factory.createStartTimeEvent(logTimePoint, 1,
+                logTimePoint);
+        raceColumn.getRaceLog(testFleet1).add(logEvent);
+        storedLogUUIDs.add(logEvent.getId());
+
+        // Set score correction
+        double scoreCorrection = 12.0;
+        leaderboard.getScoreCorrection().correctScore(competitor, raceColumn, scoreCorrection);
+        MaxPointsReason maxPointsReason = MaxPointsReason.DNS;
+        leaderboard.getScoreCorrection().setMaxPointsReason(competitor, raceColumn, maxPointsReason);
+
+        // Set carried Points
+        double carriedPoints = 2.0;
+        leaderboard.setCarriedPoints(competitor, carriedPoints);
+
+        // Set suppressed competitor
+        leaderboard.setSuppressed(competitorToSuppress, true);
+
+        // Set display name
+        String nickName = "Angie";
+        leaderboard.setDisplayName(competitorToSuppress, nickName);
+
+        // Serialize
+        TopLevelMasterDataSerializer serializer = new TopLevelMasterDataSerializer(
+                sourceService.getLeaderboardGroups(), sourceService.getAllEvents(), sourceService.getPersistentRegattasForRaceIDs());
+        Set<String> names = new HashSet<String>();
+        names.add(TEST_GROUP_NAME);
+        JSONArray masterDataOverallArray = serializer.serialize(names);
+        Assert.assertNotNull(masterDataOverallArray);
+
+        // Delete all data above from the database, to allow recreating all of it on target server
+        deleteCreatedDataFromDatabase();
+        
+        // Create existing data on target
+        RacingEventService destService = new RacingEventServiceImplMock();
+        String venueNameNotToOverride = "doNotOverride";
+        Event eventNotToOverride = destService.addEvent(TEST_EVENT_NAME, venueNameNotToOverride, "", false, eventUUID,
+                new ArrayList<String>());
+        CourseArea courseAreaNotToOverride = new CourseAreaImpl("testAreaNotToOverride", courseAreaUUID);
+        eventNotToOverride.getVenue().addCourseArea(courseAreaNotToOverride);
+        
+        List<String> raceColumnNamesNotToOverride = new ArrayList<String>();
+        String raceColumnNameNotToOveride = "T1nottooverride";
+        raceColumnNamesNotToOverride.add(raceColumnNameNotToOveride);
+
+        List<Series> seriesNotToOverride = new ArrayList<Series>();
+        List<Fleet> fleetsNotToOverride = new ArrayList<Fleet>();
+        FleetImpl testFleet1NotToOverride = new FleetImpl("testFleet1");
+        fleetsNotToOverride.add(testFleet1NotToOverride);
+        seriesNotToOverride.add(new SeriesImpl("testSeries", false, fleetsNotToOverride, raceColumnNamesNotToOverride, destService));
+        Regatta regattaNotToOverride = destService.createRegatta("testRegatta", "29er", regattaUUID, seriesNotToOverride, true, new LowPoint(),
+                courseAreaUUID);
+        event.addRegatta(regattaNotToOverride);
+        Leaderboard leaderboardNotToOverride = destService.addRegattaLeaderboard(regattaNotToOverride.getRegattaIdentifier(),
+                "testDisplayNameNotToOverride", discardRule);
+        List<String> leaderboardNamesNotToOverride = new ArrayList<String>();
+        leaderboardNamesNotToOverride.add(leaderboardNotToOverride.getName());
+        LeaderboardGroup groupNotToOverride = destService.addLeaderboardGroup(TEST_GROUP_NAME,
+                "testGroupDescNotToOverride", false, leaderboardNamesNotToOverride, null, null);
+
+        // Deserialization copied from SailingServiceImpl
+        
+        DomainFactory domainFactory = DomainFactory.INSTANCE;
+        MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
+        JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer = LeaderboardGroupMasterDataJsonDeserializer
+                .create(domainFactory);
+        JSONArray leaderboardGroupsMasterDataJsonArray = masterDataOverallArray;
+        // Actual import. Roughly copied from SailingServiceImpl
+        for (Object leaderBoardGroupMasterData : leaderboardGroupsMasterDataJsonArray) {
+            JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
+            LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
+                    .deserialize(leaderBoardGroupMasterDataJson);
+            ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, false);
+            creationCount.add(destService.apply(op));
+        }
+        
+        //---Asserts---
+        
+        Assert.assertNotNull(creationCount);
+        Event eventOnTarget = destService.getEvent(eventUUID);
+        Assert.assertNotNull(eventOnTarget);
+        
+        //Check if existing event survived import
+        Assert.assertEquals(venueNameNotToOverride, eventOnTarget.getVenue().getName());
+        
+        //Check if existing course area survived import
+        Assert.assertEquals(courseAreaNotToOverride.getName(), eventOnTarget.getVenue().getCourseAreas().iterator().next().getName());
+        LeaderboardGroup leaderboardGroupOnTarget = destService.getLeaderboardGroupByName(TEST_GROUP_NAME);
+        Assert.assertNotNull(leaderboardGroupOnTarget);
+        //Check if existing leaderboard group survived import
+        Assert.assertEquals(groupNotToOverride.getDescription(), leaderboardGroupOnTarget.getDescription());
+        Leaderboard leaderboardOnTarget = destService.getLeaderboardByName(TEST_LEADERBOARD_NAME);
+        Assert.assertNotNull(leaderboardOnTarget);
+        Regatta regattaOnTarget = destService.getRegattaByName(TEST_LEADERBOARD_NAME);
+        Assert.assertNotNull(regattaOnTarget);
+
+        Assert.assertEquals(courseAreaUUID, eventOnTarget.getVenue().getCourseAreas().iterator().next().getId());
+
+        RaceColumn raceColumnOnTarget = leaderboardOnTarget.getRaceColumnByName(raceColumnNameNotToOveride);
+        Assert.assertNotNull(raceColumnOnTarget);
+        //Check if existing leaderboard survived import
+        Assert.assertEquals(leaderboardNotToOverride.getDisplayName(), leaderboardOnTarget.getDisplayName());
+        Assert.assertFalse(leaderboardOnTarget.getScoreCorrection().hasCorrectionFor(raceColumnOnTarget));
+        
+    }
+    
+    @Test
+    public void testMasterDataImportWithOverrideWithoutHttpStack() throws MalformedURLException, IOException, InterruptedException {
+        // Setup source service
+        RacingEventService sourceService = new RacingEventServiceImpl();
+        Event event = sourceService.addEvent(TEST_EVENT_NAME, "testVenue", "", false, eventUUID,
+                new ArrayList<String>());
+        UUID courseAreaUUID = UUID.randomUUID();
+        CourseArea courseArea = new CourseAreaImpl("testArea", courseAreaUUID);
+        event.getVenue().addCourseArea(courseArea);
+
+        List<String> raceColumnNames = new ArrayList<String>();
+        String raceColumnName = "T1";
+        raceColumnNames.add(raceColumnName);
+        raceColumnNames.add("T2");
+
+        List<Series> series = new ArrayList<Series>();
+        List<Fleet> fleets = new ArrayList<Fleet>();
+        FleetImpl testFleet1 = new FleetImpl("testFleet1");
+        fleets.add(testFleet1);
+        fleets.add(new FleetImpl("testFleet2"));
+        series.add(new SeriesImpl("testSeries", false, fleets, raceColumnNames, sourceService));
+        UUID regattaUUID = UUID.randomUUID();
+        Regatta regatta = sourceService.createRegatta("testRegatta", "29er", regattaUUID, series, true, new LowPoint(),
+                courseAreaUUID);
+        event.addRegatta(regatta);
+        int[] discardRule = { 1, 2, 3, 4 };
+        Leaderboard leaderboard = sourceService.addRegattaLeaderboard(regatta.getRegattaIdentifier(),
+                "testDisplayName", discardRule);
+        List<String> leaderboardNames = new ArrayList<String>();
+        leaderboardNames.add(leaderboard.getName());
+        LeaderboardGroup group = sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false,
+                leaderboardNames, null, null);
+
+        // Set tracked Race with competitors
+        Set<Competitor> competitors = new HashSet<Competitor>();
+        UUID competitorUUID = UUID.randomUUID();
+        Set<Person> sailors = new HashSet<Person>();
+        sailors.add(new PersonImpl("Froderik Poterson", new NationalityImpl("GER"), new Date(645487200000L),
+                "Oberhoschy"));
+        Person coach = new PersonImpl("Lennart Hensler", new NationalityImpl("GER"), new Date(645487200000L),
+                "Der Lennart halt");
+        Team team = new TeamImpl("Pros", sailors, coach);
+        BoatClass boatClass = new BoatClassImpl("H16", true);
+        Boat boat = new BoatImpl("Wingy", boatClass, "GER70133");
+        CompetitorImpl competitor = new CompetitorImpl(competitorUUID, "Froderik", team, boat);
+        competitors.add(competitor);
+        UUID competitorToSuppressUUID = UUID.randomUUID();
+        Set<Person> sailors2 = new HashSet<Person>();
+        sailors2.add(new PersonImpl("Angela Merkel", new NationalityImpl("GER"), new Date(645487200000L),
+                "segelt auch mit"));
+        Person coach2 = new PersonImpl("Peer Steinbrueck", new NationalityImpl("GER"), new Date(645487200000L),
+                "Bester Coach");
+        Team team2 = new TeamImpl("Noobs", sailors2, coach2);
+        Boat boat2 = new BoatImpl("LahmeEnte", boatClass, "GER1337");
+        CompetitorImpl competitorToSuppress = new CompetitorImpl(competitorToSuppressUUID, "Merkel", team2, boat2);
+        competitors.add(competitorToSuppress);
+        TrackedRace trackedRace = new DummyTrackedRace(competitors, regatta);
+
+        RaceColumn raceColumn = leaderboard.getRaceColumnByName(raceColumnName);
+        raceColumn.setTrackedRace(testFleet1, trackedRace);
+
+        // Set log event
+        RaceLogEventFactory factory = new RaceLogEventFactoryImpl();
+        TimePoint logTimePoint = new MillisecondsTimePoint(1372489200000L);
+        RaceLogStartTimeEvent logEvent = factory.createStartTimeEvent(logTimePoint, 1,
+                logTimePoint);
+        raceColumn.getRaceLog(testFleet1).add(logEvent);
+        storedLogUUIDs.add(logEvent.getId());
+
+        // Set score correction
+        double scoreCorrection = 12.0;
+        leaderboard.getScoreCorrection().correctScore(competitor, raceColumn, scoreCorrection);
+        MaxPointsReason maxPointsReason = MaxPointsReason.DNS;
+        leaderboard.getScoreCorrection().setMaxPointsReason(competitor, raceColumn, maxPointsReason);
+
+        // Set carried Points
+        double carriedPoints = 2.0;
+        leaderboard.setCarriedPoints(competitor, carriedPoints);
+
+        // Set suppressed competitor
+        leaderboard.setSuppressed(competitorToSuppress, true);
+
+        // Set display name
+        String nickName = "Angie";
+        leaderboard.setDisplayName(competitorToSuppress, nickName);
+
+        // Serialize
+        TopLevelMasterDataSerializer serializer = new TopLevelMasterDataSerializer(
+                sourceService.getLeaderboardGroups(), sourceService.getAllEvents(), sourceService.getPersistentRegattasForRaceIDs());
+        Set<String> names = new HashSet<String>();
+        names.add(TEST_GROUP_NAME);
+        JSONArray masterDataOverallArray = serializer.serialize(names);
+        Assert.assertNotNull(masterDataOverallArray);
+
+        // Delete all data above from the database, to allow recreating all of it on target server
+        deleteCreatedDataFromDatabase();
+        
+        // Create existing data on target
+        RacingEventService destService = new RacingEventServiceImplMock();
+        String venueNameToOverride = "Override";
+        Event eventToOverride = destService.addEvent(TEST_EVENT_NAME, venueNameToOverride, "", false, eventUUID,
+                new ArrayList<String>());
+        CourseArea courseAreaToOverride = new CourseAreaImpl("testAreaToOverride", courseAreaUUID);
+        eventToOverride.getVenue().addCourseArea(courseAreaToOverride);
+        
+        List<String> raceColumnNamesToOverride = new ArrayList<String>();
+        String raceColumnNameToOveride = "T1tooverride";
+        raceColumnNamesToOverride.add(raceColumnNameToOveride);
+
+        List<Series> seriesToOverride = new ArrayList<Series>();
+        List<Fleet> fleetsToOverride = new ArrayList<Fleet>();
+        FleetImpl testFleet1ToOverride = new FleetImpl("testFleet1");
+        fleetsToOverride.add(testFleet1ToOverride);
+        seriesToOverride.add(new SeriesImpl("testSeries", false, fleetsToOverride, raceColumnNamesToOverride, destService));
+        Regatta regattaToOverride = destService.createRegatta("testRegatta", "29er", regattaUUID, seriesToOverride, true, new LowPoint(),
+                courseAreaUUID);
+        event.addRegatta(regattaToOverride);
+        Leaderboard leaderboardToOverride = destService.addRegattaLeaderboard(regattaToOverride.getRegattaIdentifier(),
+                "testDisplayNameNotToOverride", discardRule);
+        List<String> leaderboardNamesToOverride = new ArrayList<String>();
+        leaderboardNamesToOverride.add(leaderboardToOverride.getName());
+        destService.addLeaderboardGroup(TEST_GROUP_NAME,
+                "testGroupDescNotToOverride", false, leaderboardNamesToOverride, null, null);
+
+        // Deserialization copied from SailingServiceImpl
+        
+        DomainFactory domainFactory = DomainFactory.INSTANCE;
+        MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
+        JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer = LeaderboardGroupMasterDataJsonDeserializer
+                .create(domainFactory);
+        JSONArray leaderboardGroupsMasterDataJsonArray = masterDataOverallArray;
+        // Actual import. Roughly copied from SailingServiceImpl
+        for (Object leaderBoardGroupMasterData : leaderboardGroupsMasterDataJsonArray) {
+            JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
+            LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
+                    .deserialize(leaderBoardGroupMasterDataJson);
+            ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, true);
+            creationCount.add(destService.apply(op));
+        }
+        
+        //---Asserts---
+        
+        Assert.assertNotNull(creationCount);
+        Event eventOnTarget = destService.getEvent(eventUUID);
+        Assert.assertNotNull(eventOnTarget);
+        
+        //Check if existing event didn't survive import
+        Assert.assertEquals(event.getVenue().getName(), eventOnTarget.getVenue().getName());
+        
+        //Check if existing course area survive import
+        Assert.assertEquals(courseArea.getName(), eventOnTarget.getVenue().getCourseAreas().iterator().next().getName());
+        LeaderboardGroup leaderboardGroupOnTarget = destService.getLeaderboardGroupByName(TEST_GROUP_NAME);
+        Assert.assertNotNull(leaderboardGroupOnTarget);
+        //Check if existing leaderboard group didn't survive import
+        Assert.assertEquals(group.getDescription(), leaderboardGroupOnTarget.getDescription());
+        Leaderboard leaderboardOnTarget = destService.getLeaderboardByName(TEST_LEADERBOARD_NAME);
+        Assert.assertNotNull(leaderboardOnTarget);
+        Regatta regattaOnTarget = destService.getRegattaByName(TEST_LEADERBOARD_NAME);
+        Assert.assertNotNull(regattaOnTarget);
+
+        Assert.assertEquals(courseAreaUUID, eventOnTarget.getVenue().getCourseAreas().iterator().next().getId());
+
+        RaceColumn raceColumnOnTarget = leaderboardOnTarget.getRaceColumnByName(raceColumnName);
+        Assert.assertNotNull(raceColumnOnTarget);
+        //Check if existing leaderboard didn't survive import
+        Assert.assertEquals(leaderboard.getDisplayName(), leaderboardOnTarget.getDisplayName());
+        Assert.assertTrue(leaderboardOnTarget.getScoreCorrection().hasCorrectionFor(raceColumnOnTarget));
+        
+    }
+    
+    @Test
+    public void testMasterDataImportForRegattaWithoutCourseArea() throws MalformedURLException, IOException, InterruptedException {
+        // Setup source service
+        RacingEventService sourceService = new RacingEventServiceImpl();
+
+        List<String> raceColumnNames = new ArrayList<String>();
+        String raceColumnName = "T1";
+        raceColumnNames.add(raceColumnName);
+        raceColumnNames.add("T2");
+
+        List<Series> series = new ArrayList<Series>();
+        List<Fleet> fleets = new ArrayList<Fleet>();
+        FleetImpl testFleet1 = new FleetImpl("testFleet1");
+        fleets.add(testFleet1);
+        fleets.add(new FleetImpl("testFleet2"));
+        series.add(new SeriesImpl("testSeries", false, fleets, raceColumnNames, sourceService));
+        UUID regattaUUID = UUID.randomUUID();
+        Regatta regatta = sourceService.createRegatta("testRegatta", "29er", regattaUUID, series, true, new LowPoint(),
+                null);
+        int[] discardRule = { 1, 2, 3, 4 };
+        Leaderboard leaderboard = sourceService.addRegattaLeaderboard(regatta.getRegattaIdentifier(),
+                "testDisplayName", discardRule);
+        List<String> leaderboardNames = new ArrayList<String>();
+        leaderboardNames.add(leaderboard.getName());
+        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+
+        // Set tracked Race with competitors
+        Set<Competitor> competitors = new HashSet<Competitor>();
+        UUID competitorUUID = UUID.randomUUID();
+        Set<Person> sailors = new HashSet<Person>();
+        sailors.add(new PersonImpl("Froderik Poterson", new NationalityImpl("GER"), new Date(645487200000L),
+                "Oberhoschy"));
+        Person coach = new PersonImpl("Lennart Hensler", new NationalityImpl("GER"), new Date(645487200000L),
+                "Der Lennart halt");
+        Team team = new TeamImpl("Pros", sailors, coach);
+        BoatClass boatClass = new BoatClassImpl("H16", true);
+        Boat boat = new BoatImpl("Wingy", boatClass, "GER70133");
+        CompetitorImpl competitor = new CompetitorImpl(competitorUUID, "Froderik", team, boat);
+        competitors.add(competitor);
+        UUID competitorToSuppressUUID = UUID.randomUUID();
+        Set<Person> sailors2 = new HashSet<Person>();
+        sailors2.add(new PersonImpl("Angela Merkel", new NationalityImpl("GER"), new Date(645487200000L),
+                "segelt auch mit"));
+        Person coach2 = new PersonImpl("Peer Steinbrueck", new NationalityImpl("GER"), new Date(645487200000L),
+                "Bester Coach");
+        Team team2 = new TeamImpl("Noobs", sailors2, coach2);
+        Boat boat2 = new BoatImpl("LahmeEnte", boatClass, "GER1337");
+        CompetitorImpl competitorToSuppress = new CompetitorImpl(competitorToSuppressUUID, "Merkel", team2, boat2);
+        competitors.add(competitorToSuppress);
+        TrackedRace trackedRace = new DummyTrackedRace(competitors, regatta);
+
+        RaceColumn raceColumn = leaderboard.getRaceColumnByName(raceColumnName);
+        raceColumn.setTrackedRace(testFleet1, trackedRace);
+
+        // Set log event
+        RaceLogEventFactory factory = new RaceLogEventFactoryImpl();
+        TimePoint logTimePoint = new MillisecondsTimePoint(1372489200000L);
+        RaceLogStartTimeEvent logEvent = factory.createStartTimeEvent(logTimePoint, 1,
+                logTimePoint);
+        raceColumn.getRaceLog(testFleet1).add(logEvent);
+        storedLogUUIDs.add(logEvent.getId());
+
+        // Set score correction
+        double scoreCorrection = 12.0;
+        leaderboard.getScoreCorrection().correctScore(competitor, raceColumn, scoreCorrection);
+        MaxPointsReason maxPointsReason = MaxPointsReason.DNS;
+        leaderboard.getScoreCorrection().setMaxPointsReason(competitor, raceColumn, maxPointsReason);
+
+        // Set carried Points
+        double carriedPoints = 2.0;
+        leaderboard.setCarriedPoints(competitor, carriedPoints);
+
+        // Set suppressed competitor
+        leaderboard.setSuppressed(competitorToSuppress, true);
+
+        // Set display name
+        String nickName = "Angie";
+        leaderboard.setDisplayName(competitorToSuppress, nickName);
+
+        // Serialize
+        TopLevelMasterDataSerializer serializer = new TopLevelMasterDataSerializer(
+                sourceService.getLeaderboardGroups(), sourceService.getAllEvents(), sourceService.getPersistentRegattasForRaceIDs());
+        Set<String> names = new HashSet<String>();
+        names.add(TEST_GROUP_NAME);
+        JSONArray masterDataOverallArray = serializer.serialize(names);
+        Assert.assertNotNull(masterDataOverallArray);
+
+        // Delete all data above from the database, to allow recreating all of it on target server
+        deleteCreatedDataFromDatabase();
+        
+        RacingEventService destService = new RacingEventServiceImplMock();
+      
+
+        // Deserialization copied from SailingServiceImpl
+        
+        DomainFactory domainFactory = DomainFactory.INSTANCE;
+        MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
+        JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer = LeaderboardGroupMasterDataJsonDeserializer
+                .create(domainFactory);
+        JSONArray leaderboardGroupsMasterDataJsonArray = masterDataOverallArray;
+        // Actual import. Roughly copied from SailingServiceImpl
+        for (Object leaderBoardGroupMasterData : leaderboardGroupsMasterDataJsonArray) {
+            JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
+            LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
+                    .deserialize(leaderBoardGroupMasterDataJson);
+            ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, false);
+            creationCount.add(destService.apply(op));
+        }
+        
+        //---Asserts---
+        
+
+        
+        //Check if existing event survived import
+        Assert.assertNotNull(destService.getRegattaByName(regatta.getName()));
+        
+        
+        
+    }
+    
+    @Test
+    public void testMasterDataImportForPersistentRegattaRaceIDsWithoutHttpStack() throws MalformedURLException,
+            IOException, InterruptedException {
+        // Setup source service
+        RacingEventService sourceService = new RacingEventServiceImpl();
+        Event event = sourceService.addEvent(TEST_EVENT_NAME, "testVenue", "", false, eventUUID,
+                new ArrayList<String>());
+        UUID courseAreaUUID = UUID.randomUUID();
+        CourseArea courseArea = new CourseAreaImpl("testArea", courseAreaUUID);
+        event.getVenue().addCourseArea(courseArea);
+
+        List<String> raceColumnNames = new ArrayList<String>();
+        String raceColumnName = "T1";
+        raceColumnNames.add(raceColumnName);
+        raceColumnNames.add("T2");
+
+        List<Series> series = new ArrayList<Series>();
+        List<Fleet> fleets = new ArrayList<Fleet>();
+        FleetImpl testFleet1 = new FleetImpl("testFleet1");
+        fleets.add(testFleet1);
+        fleets.add(new FleetImpl("testFleet2"));
+        series.add(new SeriesImpl("testSeries", false, fleets, raceColumnNames, sourceService));
+        UUID regattaUUID = UUID.randomUUID();
+        Regatta regatta = sourceService.createRegatta("testRegatta", "29er", regattaUUID, series, true, new LowPoint(),
+                courseAreaUUID);
+        event.addRegatta(regatta);
+        int[] discardRule = { 1, 2, 3, 4 };
+        Leaderboard leaderboard = sourceService.addRegattaLeaderboard(regatta.getRegattaIdentifier(),
+                "testDisplayName", discardRule);
+        List<String> leaderboardNames = new ArrayList<String>();
+        leaderboardNames.add(leaderboard.getName());
+        sourceService.addLeaderboardGroup(TEST_GROUP_NAME, "testGroupDesc", false, leaderboardNames, null, null);
+
+        // Set tracked Race with competitors
+        Set<Competitor> competitors = new HashSet<Competitor>();
+        UUID competitorUUID = UUID.randomUUID();
+        Set<Person> sailors = new HashSet<Person>();
+        sailors.add(new PersonImpl("Froderik Poterson", new NationalityImpl("GER"), new Date(645487200000L),
+                "Oberhoschy"));
+        Person coach = new PersonImpl("Lennart Hensler", new NationalityImpl("GER"), new Date(645487200000L),
+                "Der Lennart halt");
+        Team team = new TeamImpl("Pros", sailors, coach);
+        BoatClass boatClass = new BoatClassImpl("H16", true);
+        Boat boat = new BoatImpl("Wingy", boatClass, "GER70133");
+        CompetitorImpl competitor = new CompetitorImpl(competitorUUID, "Froderik", team, boat);
+        competitors.add(competitor);
+        UUID competitorToSuppressUUID = UUID.randomUUID();
+        Set<Person> sailors2 = new HashSet<Person>();
+        sailors2.add(new PersonImpl("Angela Merkel", new NationalityImpl("GER"), new Date(645487200000L),
+                "segelt auch mit"));
+        Person coach2 = new PersonImpl("Peer Steinbrueck", new NationalityImpl("GER"), new Date(645487200000L),
+                "Bester Coach");
+        Team team2 = new TeamImpl("Noobs", sailors2, coach2);
+        Boat boat2 = new BoatImpl("LahmeEnte", boatClass, "GER1337");
+        CompetitorImpl competitorToSuppress = new CompetitorImpl(competitorToSuppressUUID, "Merkel", team2, boat2);
+        competitors.add(competitorToSuppress);
+        TrackedRace trackedRace = new DummyTrackedRace(competitors, regatta);
+
+        RaceColumn raceColumn = leaderboard.getRaceColumnByName(raceColumnName);
+        raceColumn.setTrackedRace(testFleet1, trackedRace);
+        Set<String> raceIds = new HashSet<String>();
+        raceIds.add("dummy");
+        
+        sourceService.setPersistentRegattaForRaceIDs(regatta, raceIds, false);
+
+        // Set log event
+        RaceLogEventFactory factory = new RaceLogEventFactoryImpl();
+        TimePoint logTimePoint = new MillisecondsTimePoint(1372489200000L);
+        RaceLogStartTimeEvent logEvent = factory.createStartTimeEvent(logTimePoint, 1, logTimePoint);
+        raceColumn.getRaceLog(testFleet1).add(logEvent);
+        storedLogUUIDs.add(logEvent.getId());
+
+        // Set score correction
+        double scoreCorrection = 12.0;
+        leaderboard.getScoreCorrection().correctScore(competitor, raceColumn, scoreCorrection);
+        MaxPointsReason maxPointsReason = MaxPointsReason.DNS;
+        leaderboard.getScoreCorrection().setMaxPointsReason(competitor, raceColumn, maxPointsReason);
+
+        // Set carried Points
+        double carriedPoints = 2.0;
+        leaderboard.setCarriedPoints(competitor, carriedPoints);
+
+        // Set suppressed competitor
+        leaderboard.setSuppressed(competitorToSuppress, true);
+
+        // Set display name
+        String nickName = "Angie";
+        leaderboard.setDisplayName(competitorToSuppress, nickName);
+
+        // Serialize
+        TopLevelMasterDataSerializer serializer = new TopLevelMasterDataSerializer(
+                sourceService.getLeaderboardGroups(), sourceService.getAllEvents(),
+                sourceService.getPersistentRegattasForRaceIDs());
+        Set<String> names = new HashSet<String>();
+        names.add(TEST_GROUP_NAME);
+        JSONArray masterDataOverallArray = serializer.serialize(names);
+        Assert.assertNotNull(masterDataOverallArray);
+
+        // Delete all data above from the database, to allow recreating all of it on target server
+        deleteCreatedDataFromDatabase();
+
+        // Deserialization copied from SailingServiceImpl
+
+        RacingEventService destService = new RacingEventServiceImplMock();
+        DomainFactory domainFactory = DomainFactory.INSTANCE;
+        MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
+        JsonDeserializer<LeaderboardGroupMasterData> leaderboardGroupMasterDataDeserializer = LeaderboardGroupMasterDataJsonDeserializer
+                .create(domainFactory);
+        JSONArray leaderboardGroupsMasterDataJsonArray = masterDataOverallArray;
+        // Actual import. Roughly copied from SailingServiceImpl
+        for (Object leaderBoardGroupMasterData : leaderboardGroupsMasterDataJsonArray) {
+            JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
+            LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
+                    .deserialize(leaderBoardGroupMasterDataJson);
+            ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, false);
+            creationCount.add(destService.apply(op));
+        }
+
+        // ---Asserts---
+
+        Assert.assertNotNull(creationCount);
+        Event eventOnTarget = destService.getEvent(eventUUID);
+        Assert.assertNotNull(eventOnTarget);
+
+        Regatta regattaOnTarget = destService.getRegattaByName(TEST_LEADERBOARD_NAME);
+        Assert.assertNotNull(regattaOnTarget);
+        
+        //Check if dummy race id has been imported to destination service
+        ConcurrentHashMap<String, Regatta> map = destService.getPersistentRegattasForRaceIDs();
+        Assert.assertEquals(regattaOnTarget, map.get("dummy"));
+
+    }
+}

java/com.sap.sailing.server/src/com/sap/sailing/server/RacingEventService.java

@@ -16,6 +16,7 @@ import java.util.Collection;
 import java.util.ConcurrentModificationException;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 import com.sap.sailing.domain.base.CourseArea;
 import com.sap.sailing.domain.base.Event;
@@ -537,4 +538,28 @@ public interface RacingEventService extends TrackedRegattaRegistry, RegattaFetch
 
     void reloadRaceLog(String selectedLeaderboardName, RaceColumnDTO raceColumnDTO, FleetDTO fleet);
 
+    /**
+     * @return a pair with the found or created regatta, and a boolean that tells whether the regatta was created during
+     *         the call
+     */
+    Pair<Regatta, Boolean> getOrCreateRegattaWithoutReplication(String baseRegattaName, String boatClassName, Serializable id,
+            Iterable<? extends Series> series, boolean persistent, ScoringScheme scoringScheme,
+            Serializable defaultCourseAreaId);
+
+    void createEventWithoutReplication(Event result);
+
+    Event addCourseAreaWithoutReplication(Serializable eventId, CourseArea courseArea);
+
+    /**
+     * @return map where keys are the toString() representation of the {@link RaceDefinition#getId() IDs} of races passed to
+     * {@link #setRegattaForRace(Regatta, RaceDefinition)}. It helps remember the connection between races and regattas.
+     */
+    ConcurrentHashMap<String, Regatta> getPersistentRegattasForRaceIDs();
+
+    /**
+     * 
+     * @param override If set to true, the mthod will override any existing connection
+     */
+    void setPersistentRegattaForRaceIDs(Regatta regatta, Iterable<String> raceIdStrings, boolean override);
+
 }

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

@@ -0,0 +1,490 @@
+package com.sap.sailing.server.operationaltransformation;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.NavigableSet;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.Leg;
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.base.RaceDefinition;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.base.Waypoint;
+import com.sap.sailing.domain.base.impl.RaceDefinitionImpl;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.NoWindException;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.RegattaAndRaceIdentifier;
+import com.sap.sailing.domain.common.Tack;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.WindSourceType;
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.racelog.RaceLog;
+import com.sap.sailing.domain.tracking.CourseDesignChangedListener;
+import com.sap.sailing.domain.tracking.GPSFix;
+import com.sap.sailing.domain.tracking.GPSFixMoving;
+import com.sap.sailing.domain.tracking.GPSFixTrack;
+import com.sap.sailing.domain.tracking.Maneuver;
+import com.sap.sailing.domain.tracking.MarkPassing;
+import com.sap.sailing.domain.tracking.RaceChangeListener;
+import com.sap.sailing.domain.tracking.TrackedLeg;
+import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
+import com.sap.sailing.domain.tracking.TrackedRace;
+import com.sap.sailing.domain.tracking.TrackedRaceStatus;
+import com.sap.sailing.domain.tracking.TrackedRegatta;
+import com.sap.sailing.domain.tracking.Wind;
+import com.sap.sailing.domain.tracking.WindStore;
+import com.sap.sailing.domain.tracking.WindTrack;
+import com.sap.sailing.domain.tracking.WindWithConfidence;
+import com.sap.sailing.domain.tracking.impl.TrackedRegattaImpl;
+
+public class DummyTrackedRace implements TrackedRace {
+
+    private static final long serialVersionUID = -11522605089325440L;
+    private Iterable<? extends Competitor> competitors;
+    private Regatta regatta;
+
+    public DummyTrackedRace(Iterable<? extends Competitor> competitors, Regatta regatta) {
+        this.competitors = competitors;
+        this.regatta = regatta;
+    }
+
+    @Override
+    public RaceDefinition getRace() {
+        return new RaceDefinitionImpl("dummy", null, null, competitors);
+    }
+
+    @Override
+    public RegattaAndRaceIdentifier getRaceIdentifier() {
+        return null;
+    }
+
+    @Override
+    public TimePoint getStartOfRace() {
+        return null;
+    }
+
+    @Override
+    public TimePoint getEndOfRace() {
+        return null;
+    }
+
+    @Override
+    public Iterable<Pair<Waypoint, Pair<TimePoint, TimePoint>>> getMarkPassingsTimes() {
+        return null;
+    }
+
+    @Override
+    public boolean hasStarted(TimePoint at) {
+        return false;
+    }
+
+    @Override
+    public Iterable<TrackedLeg> getTrackedLegs() {
+        return null;
+    }
+
+    @Override
+    public TrackedLeg getTrackedLeg(Leg leg) {
+        return null;
+    }
+
+    @Override
+    public TrackedLegOfCompetitor getCurrentLeg(Competitor competitor, TimePoint timePoint) {
+        return null;
+    }
+
+    @Override
+    public TrackedLeg getCurrentLeg(TimePoint timePoint) {
+        return null;
+    }
+
+    @Override
+    public TrackedLeg getTrackedLegFinishingAt(Waypoint endOfLeg) {
+        return null;
+    }
+
+    @Override
+    public TrackedLeg getTrackedLegStartingAt(Waypoint startOfLeg) {
+        return null;
+    }
+
+    @Override
+    public GPSFixTrack<Competitor, GPSFixMoving> getTrack(Competitor competitor) {
+        return null;
+    }
+
+    @Override
+    public TrackedLegOfCompetitor getTrackedLeg(Competitor competitor, TimePoint at) {
+        return null;
+    }
+
+    @Override
+    public TrackedLegOfCompetitor getTrackedLeg(Competitor competitor, Leg leg) {
+        return null;
+    }
+
+    @Override
+    public long getUpdateCount() {
+        return 0;
+    }
+
+    @Override
+    public int getRankDifference(Competitor competitor, Leg leg, TimePoint timePoint) {
+        return 0;
+    }
+
+    @Override
+    public int getRank(Competitor competitor) throws NoWindException {
+        return 0;
+    }
+
+    @Override
+    public int getRank(Competitor competitor, TimePoint timePoint) throws NoWindException {
+        return 0;
+    }
+
+    @Override
+    public Iterable<MarkPassing> getMarkPassingsInOrder(Waypoint waypoint) {
+        return null;
+    }
+
+    @Override
+    public MarkPassing getMarkPassing(Competitor competitor, Waypoint waypoint) {
+        return null;
+    }
+
+    @Override
+    public GPSFixTrack<Mark, GPSFix> getOrCreateTrack(Mark mark) {
+        return null;
+    }
+
+    @Override
+    public Iterable<Mark> getMarks() {
+        return null;
+    }
+
+    @Override
+    public Position getApproximatePosition(Waypoint waypoint, TimePoint timePoint) {
+        return null;
+    }
+
+    @Override
+    public Wind getWind(Position p, TimePoint at) {
+        return null;
+    }
+
+    @Override
+    public Wind getWind(Position p, TimePoint at, Iterable<WindSource> windSourcesToExclude) {
+        return null;
+    }
+
+    @Override
+    public Iterable<WindSource> getWindSources(WindSourceType type) {
+        return null;
+    }
+
+    @Override
+    public Iterable<WindSource> getWindSources() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public WindTrack getOrCreateWindTrack(WindSource windSource) {
+        return null;
+    }
+
+    @Override
+    public WindTrack getOrCreateWindTrack(WindSource windSource, long delayForWindEstimationCacheInvalidation) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void waitForNextUpdate(int sinceUpdate) throws InterruptedException {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public TimePoint getStartOfTracking() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public TimePoint getEndOfTracking() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public TimePoint getTimePointOfNewestEvent() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public TimePoint getTimePointOfOldestEvent() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public NavigableSet<MarkPassing> getMarkPassings(Competitor competitor) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void lockForRead(Iterable<MarkPassing> markPassings) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void unlockAfterRead(Iterable<MarkPassing> markPassings) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public TimePoint getTimePointOfLastEvent() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public long getMillisecondsOverWhichToAverageSpeed() {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public long getMillisecondsOverWhichToAverageWind() {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public long getDelayToLiveInMillis() {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public Wind getEstimatedWindDirection(Position position, TimePoint timePoint) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Tack getTack(Competitor competitor, TimePoint timePoint) throws NoWindException {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public TrackedRegatta getTrackedRegatta() {
+        return new TrackedRegattaImpl(regatta);
+    }
+
+    @Override
+    public Wind getDirectionFromStartToNextMark(TimePoint at) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public List<GPSFixMoving> approximate(Competitor competitor, Distance maxDistance, TimePoint from, TimePoint to) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public List<Maneuver> getManeuvers(Competitor competitor, TimePoint from, TimePoint to, boolean waitForLatest)
+            throws NoWindException {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public boolean raceIsKnownToStartUpwind() {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public boolean hasWindData() {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public boolean hasGPSData() {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public void addListener(RaceChangeListener listener) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void removeListener(RaceChangeListener listener) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public Distance getDistanceTraveled(Competitor competitor, TimePoint timePoint) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Distance getWindwardDistanceToOverallLeader(Competitor competitor, TimePoint timePoint)
+            throws NoWindException {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public WindWithConfidence<Pair<Position, TimePoint>> getWindWithConfidence(Position p, TimePoint at) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Iterable<WindSource> getWindSourcesToExclude() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public WindWithConfidence<Pair<Position, TimePoint>> getWindWithConfidence(Position p, TimePoint at,
+            Iterable<WindSource> windSourcesToExclude) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public WindWithConfidence<TimePoint> getEstimatedWindDirectionWithConfidence(Position position, TimePoint timePoint) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void setWindSourcesToExclude(Iterable<? extends WindSource> windSourcesToExclude) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public Distance getAverageCrossTrackError(Competitor competitor, TimePoint timePoint, boolean waitForLatestAnalysis)
+            throws NoWindException {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public WindStore getWindStore() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Competitor getOverallLeader(TimePoint timePoint) throws NoWindException {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public List<Competitor> getCompetitorsFromBestToWorst(TimePoint timePoint) throws NoWindException {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Distance getAverageCrossTrackError(Competitor competitor, TimePoint from, TimePoint to, boolean upwindOnly,
+            boolean waitForLatestAnalyses) throws NoWindException {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void waitUntilWindLoadingComplete() throws InterruptedException {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public TrackedRaceStatus getStatus() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void waitUntilNotLoading() {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void detachRaceLog(Serializable identifier) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void detachAllRaceLogs() {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void attachRaceLog(RaceLog raceLog) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public RaceLog getRaceLog(Serializable identifier) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void addCourseDesignChangedListener(CourseDesignChangedListener listener) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public Distance getStartAdvantage(Competitor competitor, double secondsIntoTheRace) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Distance getDistanceToStartLine(Competitor competitor, TimePoint timePoint) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Distance getDistanceFromStarboardSideOfStartLineWhenPassingStart(Competitor competitor) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public boolean isLive(TimePoint at) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+}

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

@@ -0,0 +1,425 @@
+package com.sap.sailing.server.operationaltransformation;
+
+import java.io.IOException;
+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;
+
+import com.sap.sailing.domain.base.Competitor;
+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.Regatta;
+import com.sap.sailing.domain.base.Series;
+import com.sap.sailing.domain.base.impl.EventImpl;
+import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+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.RegattaName;
+import com.sap.sailing.domain.common.ScoringSchemeType;
+import com.sap.sailing.domain.common.impl.MasterDataImportObjectCreationCountImpl;
+import com.sap.sailing.domain.common.impl.Util.Pair;
+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.racelog.RaceLog;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.server.RacingEventService;
+import com.sap.sailing.server.RacingEventServiceOperation;
+
+public class ImportMasterDataOperation extends
+        AbstractRacingEventServiceOperation<MasterDataImportObjectCreationCountImpl> {
+
+    private static final long serialVersionUID = 3131715325307370303L;
+
+    private static final Logger logger = Logger.getLogger(ImportMasterDataOperation.class.getName());
+
+    private LeaderboardGroupMasterData masterData;
+
+    private MasterDataImportObjectCreationCountImpl creationCount = new MasterDataImportObjectCreationCountImpl();
+
+    private DomainFactory domainFactory = DomainFactory.INSTANCE;
+
+    private final boolean override;
+
+    public ImportMasterDataOperation(LeaderboardGroupMasterData masterData, boolean override) {
+        this.masterData = masterData;
+        this.override = override;
+    }
+
+    @Override
+    public MasterDataImportObjectCreationCountImpl internalApplyTo(RacingEventService toState) throws Exception {
+        createLeaderboardGroupWithAllRelatedObjects(masterData, toState);
+        return creationCount;
+    }
+
+    private void createLeaderboardGroupWithAllRelatedObjects(LeaderboardGroupMasterData masterData,
+            RacingEventService toState) {
+        List<String> leaderboardNames = new ArrayList<String>();
+        createCourseAreasAndEvents(masterData, toState);
+        createRegattas(masterData, toState);
+        Map<String, Leaderboard> existingLeaderboards = toState.getLeaderboards();
+        for (LeaderboardMasterData board : masterData.getLeaderboards()) {
+            if (existingLeaderboards.containsKey(board.getName())) {
+                if (override) {
+                    toState.removeLeaderboard(board.getName());
+                    logger.info(String.format("Leaderboard with name %1$s already existed and has been overridden.",
+                            board.getName()));
+                } else {
+                    logger.info(String.format("Leaderboard with name %1$s already exists and hasn't been overridden.",
+                            board.getName()));
+                    continue;
+                }
+            }
+            setCourseAreaIfNecessary(board, toState);
+            setRegattaIfNecessary(board, toState);
+            Leaderboard leaderboard = board.getLeaderboard();
+            if (leaderboard != null) {
+                leaderboard.setDisplayName(board.getDisplayName());
+                toState.addLeaderboard(leaderboard);
+                leaderboardNames.add(board.getName());
+                creationCount.addOneLeaderboard();
+                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));
+                if (dummyColumnAndFleet.getA() != null && dummyColumnAndFleet.getB() != null) {
+                    addScoreCorrectionsIfPossible(board.getScoreCorrection(), newLeaderboard);
+                    unsetDummy(dummyColumnAndFleet, leaderboard);
+                }
+                addCarriedPoints(leaderboard, board.getCarriedPoints(), board.getCompetitorsById());
+                addSuppressedCompetitors(leaderboard, board.getSuppressedCompetitors(), board.getCompetitorsById());
+                addCompetitorDisplayNames(leaderboard, board.getDisplayNamesByCompetitorId(),
+                        board.getCompetitorsById());
+                addRaceLogEvents(leaderboard, board.getRaceLogEvents());
+
+            }
+        }
+        int[] overallLeaderboardDiscardThresholds = null;
+        ScoringSchemeType overallLeaderboardScoringSchemeType = null;
+        LeaderboardMasterData overallLeaderboard = masterData.getOverallLeaderboardMasterData();
+        if (overallLeaderboard != null && overallLeaderboard instanceof FlexibleLeaderboardMasterData) {
+            FlexibleLeaderboardMasterData flex = (FlexibleLeaderboardMasterData) overallLeaderboard;
+            overallLeaderboardDiscardThresholds = overallLeaderboard.getResultDiscardingRule()
+                    .getDiscardIndexResultsStartingWithHowManyRaces();
+            overallLeaderboardScoringSchemeType = flex.getScoringScheme().getType();
+        }
+        LeaderboardGroup existingLeaderboardGroup = toState.getLeaderboardGroupByName(masterData.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());
+            existingLeaderboardGroup = null;
+        }
+        if (existingLeaderboardGroup == null) {
+            toState.addLeaderboardGroup(masterData.getName(), masterData.getDescription(),
+                    masterData.isDisplayGroupsRevese(), leaderboardNames, overallLeaderboardDiscardThresholds,
+                    overallLeaderboardScoringSchemeType);
+            creationCount.addOneLeaderboardGroup();
+        } else {
+            logger.info(String.format("Leaderboard Group with name %1$s already exists and hasn't been overridden.",
+                    masterData.getName()));
+        }
+    }
+
+    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.add(singleEvent);
+                }
+            }
+        }
+    }
+
+    private void addCompetitorDisplayNames(Leaderboard leaderboard, Map<String, String> displayNamesByCompetitorId,
+            Map<String, Competitor> competitorsById) {
+        for (Entry<String, String> entry : displayNamesByCompetitorId.entrySet()) {
+            leaderboard.setDisplayName(competitorsById.get(entry.getKey()), entry.getValue());
+        }
+    }
+
+    private void addSuppressedCompetitors(Leaderboard leaderboard, List<String> suppressedCompetitors,
+            Map<String, Competitor> competitorsById) {
+        for (String id : suppressedCompetitors) {
+            leaderboard.setSuppressed(competitorsById.get(id), true);
+        }
+    }
+
+    private void addCarriedPoints(Leaderboard leaderboard, Map<String, Double> carriedPoints,
+            Map<String, Competitor> competitorsById) {
+        for (Entry<String, Double> entry : carriedPoints.entrySet()) {
+            leaderboard.setCarriedPoints(competitorsById.get(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,
+            Regatta regatta) {
+        RaceColumn raceColumn = null;
+        Fleet fleet = null;
+        Iterable<RaceColumn> raceColumns = leaderboard.getRaceColumns();
+        Iterator<RaceColumn> raceColumnIterator = raceColumns.iterator();
+        if (raceColumnIterator.hasNext()) {
+            raceColumn = raceColumnIterator.next();
+            Iterable<? extends Fleet> fleets = raceColumn.getFleets();
+            Iterator<? extends Fleet> fleetIterator = fleets.iterator();
+            if (fleetIterator.hasNext()) {
+                fleet = fleetIterator.next();
+                DummyTrackedRace dummy = new DummyTrackedRace(competitors, regatta);
+                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());
+                    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());
+                for (Map.Entry<String, RaceIdentifier> e : raceColumnMasterData.getRaceIdentifiersByFleetName()
+                        .entrySet()) {
+                    raceColumn.setRaceIdentifier(raceColumn.getFleetByName(e.getKey()), e.getValue());
+                }
+            }
+        }
+    }
+
+    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 (override) {
+                    logger.info(String.format("Regatta with name %1$s already existed and has been overridden.",
+                            singleRegattaData.getRegattaName()));
+                    try {
+                        toState.removeRegatta(existingRegatta);
+                    } catch (IOException | InterruptedException e) {
+                        logger.info(String.format("Regatta with name %1$s could not be deleted due to an error.",
+                                singleRegattaData.getRegattaName()));
+                        e.printStackTrace();
+                        continue;
+                    }
+                } else {
+                    logger.info(String.format("Regatta with name %1$s already exists and hasn't been overridden.",
+                            singleRegattaData.getRegattaName()));
+                    continue;
+                }
+            }
+            String 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,
+                    UUID.fromString(id), series, isPersistent,
+                    domainFactory.createScoringScheme(ScoringSchemeType.valueOf(scoringSchemeType)),
+                    courseAreaUUID).getA();
+            toState.setPersistentRegattaForRaceIDs(createdRegatta, singleRegattaData.getRaceIds(), override);
+            creationCount.addOneRegatta();
+        }
+
+    }
+
+    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();
+                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) {
+                logger.info(String.format("Event with name %1$s already existed and will be overridden.",
+                        event.getName()));
+                toState.removeEvent(existingEvent.getId());
+                existingEvent = null;
+            }
+            if (existingEvent == null) {
+                String name = event.getName();
+                String pubString = event.getPubUrl();
+                String venueName = event.getVenueName();
+                boolean isPublic = event.isPublic();
+                Event newEvent = new EventImpl(name, venueName, pubString, isPublic, UUID.fromString(id));
+                toState.createEventWithoutReplication(newEvent);
+                creationCount.addOneEvent();
+            } 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) {
+                boolean alreadyExists = false;
+                if (existingEvent != null
+                        && existsInSet(existingEvent.getVenue().getCourseAreas(), courseAreaEntry.getA())) {
+                    alreadyExists = true;
+                }
+                if (!alreadyExists) {
+                    CourseArea courseArea = domainFactory.getOrCreateCourseArea(
+                            UUID.fromString(courseAreaEntry.getA()), courseAreaEntry.getB());
+                    toState.addCourseAreaWithoutReplication(UUID.fromString(id), courseArea);
+                } 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));
+                }
+            }
+        }
+    }
+
+    /**
+     * 
+     * @param iterable
+     * @param key
+     * @return true if course with given id exists in iterable
+     */
+    private boolean existsInSet(Iterable<CourseArea> iterable, String key) {
+        for (CourseArea area : iterable) {
+            if (area.getId().toString().matches(key)) {
+                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
+        return null;
+    }
+
+    @Override
+    public RacingEventServiceOperation<?> transformServerOp(RacingEventServiceOperation<?> clientOp) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+}