Merge branch 'racecommittee_app' into racecommittee_wind

Conflicts: java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.properties java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties
2026-10-15 08:41:01 +00:00 · 2013-07-04 21:07:35 +02:00
commit 8af60a38ce
@@ -1,5 +1,8 @@
 package com.sap.sailing.domain.common.impl;

+import java.util.HashSet;
+import java.util.Set;
+
 import com.sap.sailing.domain.common.MasterDataImportObjectCreationCount;


@@ -7,6 +10,9 @@ 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.
 * 
+ * Also keeps track of names and ids of the created objects to ignore one that are 
+ * listed multiple times.
+ * 
 * @author Frederik Petersen (D054528)
 *
 */
@@ -18,22 +24,31 @@ public class MasterDataImportObjectCreationCountImpl implements MasterDataImport
    private int eventCount = 0;
    private int regattaCount = 0;
    
+    private Set<String> createdLeaderboards = new HashSet<String>(); 
+    private Set<String> createdLeaderboardGroups = new HashSet<String>(); 
+    private Set<String> createdEvents = new HashSet<String>(); 
+    private Set<String> createdRegattas = new HashSet<String>(); 
+    
    //For GWT serialization
    public MasterDataImportObjectCreationCountImpl() {};

-    public void addOneLeaderboard() {
+    public void addOneLeaderboard(String name) {
+        createdLeaderboards.add(name);
        leaderboardCount++;
    }
    
-    public void addOneLeaderboardGroup() {
+    public void addOneLeaderboardGroup(String name) {
+        createdLeaderboardGroups.add(name);
        leaderboardGroupCount++;
    }
    
-    public void addOneEvent() {
+    public void addOneEvent(String id) {
+        createdEvents.add(id);
        eventCount++;
    }

-    public void addOneRegatta() {
+    public void addOneRegatta(String id) {
+        createdRegattas.add(id);
        regattaCount++;
        
    }
@@ -43,6 +58,26 @@ public class MasterDataImportObjectCreationCountImpl implements MasterDataImport
        leaderboardGroupCount = leaderboardGroupCount + toAdd.leaderboardGroupCount;
        eventCount = eventCount + toAdd.eventCount;
        regattaCount = regattaCount + toAdd.regattaCount;
+        createdEvents.addAll(toAdd.createdEvents);
+        createdLeaderboardGroups.addAll(toAdd.createdLeaderboardGroups);
+        createdLeaderboards.addAll(toAdd.createdLeaderboards);
+        createdRegattas.addAll(toAdd.createdRegattas);
+    }
+    
+    public boolean alreadyAddedLeaderboardWithName(String name) {
+        return createdLeaderboards.contains(name);
+    }
+    
+    public boolean alreadyAddedLeaderboardGroupWithName(String name) {
+        return createdLeaderboardGroups.contains(name);
+    }
+    
+    public boolean alreadyAddedEventWithId(String id) {
+        return createdEvents.contains(id);
+    }
+    
+    public boolean alreadyAddedRegattaWithId(String id) {
+        return createdRegattas.contains(id);
    }

    @Override
@@ -27,7 +27,10 @@ public class ReverseGeocoderTest {
        //Simple Test in Kiel center to check the connection and the parsing from JSONObject to Placemark
        try {
            Placemark kielReversed = geocoder.getPlacemarkNearest(KIEL_POSITION);
-            Assert.assertEquals(KIEL, kielReversed);
+            Assert.assertEquals(KIEL.getName(), kielReversed.getName());
+            Assert.assertEquals(KIEL.getCountryCode(), kielReversed.getCountryCode());
+            Assert.assertEquals(KIEL.getPosition().getLatDeg(), kielReversed.getPosition().getLatDeg(), 0.0001);
+            Assert.assertEquals(KIEL.getPosition().getLngDeg(), kielReversed.getPosition().getLngDeg(), 0.0001);
        } catch (IOException e) {
            Assert.fail(e.getMessage());
        } catch (ParseException e) {
@@ -55,13 +58,22 @@ public class ReverseGeocoderTest {
        
        try {
            Placemark p = geocoder.getPlacemarkLast(abroad, 20, new Placemark.ByPopulation());
-            Assert.assertEquals(KIEL, p);
+            Assert.assertEquals(KIEL.getName(), p.getName());
+            Assert.assertEquals(KIEL.getCountryCode(), p.getCountryCode());
+            Assert.assertEquals(KIEL.getPosition().getLatDeg(), p.getPosition().getLatDeg(), 0.0001);
+            Assert.assertEquals(KIEL.getPosition().getLngDeg(), p.getPosition().getLngDeg(), 0.0001);
            
            p = geocoder.getPlacemarkFirst(abroad, 20, new Placemark.ByDistance(abroad));
-            Assert.assertEquals(firstByDistance, p);
+            Assert.assertEquals(firstByDistance.getName(), p.getName());
+            Assert.assertEquals(firstByDistance.getCountryCode(), p.getCountryCode());
+            Assert.assertEquals(firstByDistance.getPosition().getLatDeg(), p.getPosition().getLatDeg(), 0.0001);
+            Assert.assertEquals(firstByDistance.getPosition().getLngDeg(), p.getPosition().getLngDeg(), 0.0001);
            
            p = geocoder.getPlacemarkLast(abroad, 20, new Placemark.ByPopulationDistanceRatio(abroad));
-            Assert.assertEquals(KIEL, p);
+            Assert.assertEquals(KIEL.getName(), p.getName());
+            Assert.assertEquals(KIEL.getCountryCode(), p.getCountryCode());
+            Assert.assertEquals(KIEL.getPosition().getLatDeg(), p.getPosition().getLatDeg(), 0.0001);
+            Assert.assertEquals(KIEL.getPosition().getLngDeg(), p.getPosition().getLngDeg(), 0.0001);
        } catch (IOException e) {
            Assert.fail(e.getMessage());
        } catch (ParseException e) {
@@ -159,16 +159,18 @@ public class ReverseGeocoderImpl implements ReverseGeocoder {
        // and are interpreted as Long
        // Casting a Long to a Double raises a ClassCastException
        Double latDeg = null;
-        try {
-            latDeg = (Double) json.get("lat");
-        } catch (ClassCastException e) {
-            latDeg = ((Long) json.get("lat")).doubleValue();
+        Object jsonLat = json.get("lat");
+        if (jsonLat instanceof String) {
+            latDeg = Double.valueOf((String) jsonLat);
+        } else if (jsonLat instanceof Number) {
+            latDeg = ((Number) jsonLat).doubleValue();
        }
        Double lngDeg = null;
-        try {
-            lngDeg = (Double) json.get("lng");
-        } catch (ClassCastException e) {
-            lngDeg = ((Long) json.get("lng")).doubleValue();
+        Object jsonLng = json.get("lng");
+        if (jsonLng instanceof String) {
+            lngDeg = Double.valueOf((String) jsonLng);
+        } else if (jsonLng instanceof Number) {
+            lngDeg = ((Number) jsonLng).doubleValue();
        }
        SerializablePosition position = new SerializablePositionImpl(latDeg, lngDeg);

@@ -731,4 +731,14 @@ public interface StringMessages extends Messages {
    String export();
    String dataBeforeAfter();
    String rawFixes();
+    String importRemoteHost();
+    String importFetchRemoteLgs();
+    String importUrlInvalid(String url);
+    String importGetLeaderboardsFailed(int statusCode, String url);
+    String importNoDataReturned();
+    String importServerError();
+    String importLeaderboardGroups();
+    String importOverrideSwitchLabel();
+    String importSelectedLeaderboardGroups();
+    String importSelectAtLeastOne();
 }
@@ -724,3 +724,13 @@ essTwoDisplayed=Two minutes till start
 essOneDisplayed=One minute till start
 essOneRemoved=Race starting signaldataBeforeAfter=Data from before/after race
 rawFixes=All fixes (including outliers)
+importRemoteHost=Remote host: 
+importFetchRemoteLgs=Fetch Leaderboard Group List
+importUrlInvalid=Not a valid URL for fetching leaderboardgroups: {0}
+importGetLeaderboardsFailed=GET leaderboardgroups request failed with error code: {0}; For url: {1}
+importNoDataReturned=No data was returned by the server
+importServerError=GET leaderboardgroups request failed with Server error. Please see server logs for more information.
+importLeaderboardGroups=Leaderboard Groups:
+importOverrideSwitchLabel=Override existing data if names and ids match
+importSelectedLeaderboardGroups=Import selected leaderboard groups
+importSelectAtLeastOne=You have to select at least one leaderboard group to import
@@ -720,3 +720,13 @@ essTwoDisplayed=Zwei Minuten bis zum Start
 essOneDisplayed=Eine Minute bis zum Start
 essOneRemoved=RennstartsignaldataBeforeAfter=Daten von vor/nach dem Rennen
 rawFixes=Alle Fixes (inklusive Ausreißer)
+importRemoteHost=Entfernter Host:
+importFetchRemoteLgs=Liste der Leaderboard Groups abrufen
+importUrlInvalid=Keine gültige URL um Leaderboard Groups abzurufen: {0}
+importGetLeaderboardsFailed=GET leaderboardgroups Request scheiterte mit Error Code: {0}; Für die Url: {1}
+importNoDataReturned=Es kamen keine Daten vom Server zurück
+importServerError=Der GET leaderboardgroups Request scheiterte an einem Server Error. Bitte schauen Sie in die Server logs für mehr Informationen.
+importLeaderboardGroups=Leaderboard Groups:
+importOverrideSwitchLabel=Bei übereinstimmenden IDs und Namen die Daten überschreiben
+importSelectedLeaderboardGroups=Ausgewählte Leaderboard Groups selektieren
+importSelectAtLeastOne=Es muss mindestens eine Leaderboard Group ausgewählt werden
@@ -44,9 +44,6 @@ public class MasterDataImportPanel extends VerticalPanel {
    private RegExp urlValidator;
    private RegExp urlPlusTldValidator;

-    /*
-     * TODO: use string messages
-     */
    private final StringMessages stringMessages;
    private String currentHost;
    private SailingServiceAsync sailingService;
@@ -65,12 +62,12 @@ public class MasterDataImportPanel extends VerticalPanel {
        this.leaderboardGroupRefresher = leaderboardGroupRefresher;

        HorizontalPanel serverAddressPanel = new HorizontalPanel();
-        serverAddressPanel.add(new Label("Remote host:"));
+        serverAddressPanel.add(new Label(stringMessages.importRemoteHost()));
        hostBox = new TextBox();
-        hostBox.setText("http://prod2.sapsailing.com/");
+        hostBox.setText("http://live2.sapsailing.com/");
        hostBox.setWidth("300px");
        serverAddressPanel.add(hostBox);
-        fetchIdsButton = new Button("Fetch Leaderboard Group List");
+        fetchIdsButton = new Button(stringMessages.importFetchRemoteLgs());
        serverAddressPanel.add(fetchIdsButton);
        this.add(serverAddressPanel);

@@ -115,6 +112,8 @@ public class MasterDataImportPanel extends VerticalPanel {

    protected void importLeaderboardGroups() {
        String[] groupNames = createLeaderBoardGroupNamesFromListBox();
+        if (groupNames.length >= 1) {
+            changeAllButtonState(false);
            boolean override = overrideSwitch.getValue();
            sailingService.importMasterData(currentHost, groupNames, override,
                    new AsyncCallback<MasterDataImportObjectCreationCount>() {
@@ -134,17 +133,29 @@ public class MasterDataImportPanel extends VerticalPanel {
                            if (leaderboardGroupsCreated > 0) {
                                leaderboardGroupRefresher.fillLeaderboardGroups();
                            }
-                        showSuccessAlert(leaderboardsCreated, leaderboardGroupsCreated, eventsCreated, regattasCreated);
+                            showSuccessAlert(leaderboardsCreated, leaderboardGroupsCreated, eventsCreated,
+                                    regattasCreated);
+                            changeAllButtonState(true);
                        }

                        @Override
                        public void onFailure(Throwable caught) {
                            showErrorAlert(caught.getLocalizedMessage());
+                            changeAllButtonState(true);
                        }
                    });
+        } else {
+            showErrorAlert(stringMessages.importSelectAtLeastOne());
+        }
    }


+    private void changeAllButtonState(boolean enabled) {
+        importLeaderboardGroupsButton.setEnabled(enabled);
+        overrideSwitch.setEnabled(enabled);
+        fetchIdsButton.setEnabled(enabled);
+    }
+
    protected void showSuccessAlert(int leaderboardsCreated, int leaderboardGroupsCreated, int eventsCreated,
            int regattasCreated) {
        Window.alert(stringMessages.importSuccess(leaderboardGroupsCreated, leaderboardsCreated, eventsCreated,
@@ -173,17 +184,17 @@ public class MasterDataImportPanel extends VerticalPanel {
        currentHost = host;
        final String getLgsUrl = createGetLgsUrl(host);
        if (!isValidUrl(getLgsUrl, false)) {
-            showErrorAlert("Not a valid URL for fetching leaderboardgroups: " + getLgsUrl);
+            showErrorAlert(stringMessages.importUrlInvalid(getLgsUrl));
            return;
        }
+        changeAllButtonState(false);
        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);
+                    showErrorAlert(stringMessages.importGetLeaderboardsFailed(response.getStatusCode(), getLgsUrl));
                }
                int itemCount = leaderboardgroupListBox.getItemCount();
                for (int i = itemCount - 1; i >= 0; i--) {
@@ -191,7 +202,8 @@ public class MasterDataImportPanel extends VerticalPanel {
                }
                String body = response.getText();
                if (body == null || body.isEmpty()) {
-                    showErrorAlert("No data was returned by remote server.");
+                    showErrorAlert(stringMessages.importNoDataReturned());
+                    changeAllButtonState(true);
                    return;
                }
                JSONArray leaderboardGroups = JSONParser.parseStrict(body).isArray();
@@ -200,18 +212,25 @@ public class MasterDataImportPanel extends VerticalPanel {
                    JSONString leaderboardGroupName = leaderboardGroups.get(i).isString();
                    leaderboardgroupListBox.addItem(leaderboardGroupName.stringValue());
                }
+                if (leaderboardGroups.size() > 1) {
+                    importLeaderboardGroupsButton.setEnabled(true);
+                } else {
+                    importLeaderboardGroupsButton.setEnabled(false);
+                }
+                changeAllButtonState(true);
            }

            @Override
            public void onError(Request request, Throwable exception) {
-                showErrorAlert("GET leaderboardgroups request failed with Server error: "
-                        + exception.getLocalizedMessage());
+                showErrorAlert(stringMessages.importServerError());
+                changeAllButtonState(true);
            }
        });
        try {
            getLgsRequestBuilder.send();
        } catch (RequestException e) {
-            showErrorAlert("GET leaderboardgroups request failed: " + e.getLocalizedMessage());
+            showErrorAlert(stringMessages.importServerError());
+            changeAllButtonState(true);
        }
    }

@@ -246,16 +265,17 @@ public class MasterDataImportPanel extends VerticalPanel {
    }

    private void addContentToLeftPanel(VerticalPanel contentPanel) {
-        contentPanel.add(new Label("Leaderboard Groups:"));
+        contentPanel.add(new Label(stringMessages.importLeaderboardGroups()));

        leaderboardgroupListBox = new ListBox(true);
        contentPanel.add(leaderboardgroupListBox);
        
-        overrideSwitch = new CheckBox("Override existing data if names and ids match");
+        overrideSwitch = new CheckBox(stringMessages.importOverrideSwitchLabel());
        overrideSwitch.setValue(false);
        contentPanel.add(overrideSwitch);

-        importLeaderboardGroupsButton = new Button("Import selected Leaderboard Groups");
+        importLeaderboardGroupsButton = new Button(stringMessages.importSelectedLeaderboardGroups());
+        importLeaderboardGroupsButton.setEnabled(false);
        contentPanel.add(importLeaderboardGroupsButton);
    }

@@ -66,6 +66,7 @@ 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 static final String TEST_GROUP_NAME2 = "testGroup2";

    private final UUID eventUUID = UUID.randomUUID();

@@ -87,6 +88,10 @@ public class MasterDataImportTest {
        if (group != null) {
            service.removeLeaderboardGroup(TEST_GROUP_NAME);
        }
+        LeaderboardGroup group2 = service.getLeaderboardGroupByName(TEST_GROUP_NAME2);
+        if (group2 != null) {
+            service.removeLeaderboardGroup(TEST_GROUP_NAME2);
+        }
        Leaderboard leaderboard = service.getLeaderboardByName(TEST_LEADERBOARD_NAME);
        if (leaderboard != null) {
            service.removeLeaderboard(TEST_LEADERBOARD_NAME);
@@ -416,8 +421,13 @@ public class MasterDataImportTest {

        
        //---Asserts---
-        
+        //Test correct number of creations
        Assert.assertNotNull(creationCount);
+        Assert.assertEquals(0,creationCount.getEventCount());
+        Assert.assertEquals(0,creationCount.getRegattaCount());
+        Assert.assertEquals(0,creationCount.getLeaderboardCount());
+        Assert.assertEquals(0,creationCount.getLeaderboardGroupCount());
+        
        Event eventOnTarget = destService.getEvent(eventUUID);
        Assert.assertNotNull(eventOnTarget);
        
@@ -579,8 +589,14 @@ public class MasterDataImportTest {

        
        //---Asserts---
-        
+        //Test correct number of creations
        Assert.assertNotNull(creationCount);
+        Assert.assertEquals(1,creationCount.getEventCount());
+        Assert.assertEquals(1,creationCount.getRegattaCount());
+        Assert.assertEquals(1,creationCount.getLeaderboardCount());
+        Assert.assertEquals(1,creationCount.getLeaderboardGroupCount());
+        
+        
        Event eventOnTarget = destService.getEvent(eventUUID);
        Assert.assertNotNull(eventOnTarget);
        
@@ -890,4 +906,105 @@ public class MasterDataImportTest {
        Assert.assertEquals(trackOnSource.url, trackOnTarget.url);

    }
+    
+    @Test
+    public void testMasterDataImportWithTwoLgsWithSameLeaderboard() 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);
+        sourceService.addLeaderboardGroup(TEST_GROUP_NAME2, "testGroupDesc2", 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);
+
+        // Serialize
+        TopLevelMasterDataSerializer serializer = new TopLevelMasterDataSerializer(
+                sourceService.getLeaderboardGroups(), sourceService.getAllEvents(),
+                sourceService.getPersistentRegattasForRaceIDs(), sourceService.getAllMediaTracks());
+        Set<String> names = new HashSet<String>();
+        names.add(TEST_GROUP_NAME);
+        names.add(TEST_GROUP_NAME2);
+        JSONObject masterDataOverallObject = serializer.serialize(names);
+        Assert.assertNotNull(masterDataOverallObject);
+
+        // 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;
+        MasterDataImporter importer = new MasterDataImporter(domainFactory, destService);
+        //Test in override model, to find out if data that was created during import is overriden later on
+        // in the same import process. Number of creations is checked below.
+        MasterDataImportObjectCreationCount creationCount = importer.importMasterData(
+                masterDataOverallObject.toString(), true);
+
+        //Test correct number of creations
+        Assert.assertNotNull(creationCount);
+        Assert.assertEquals(1,creationCount.getEventCount());
+        Assert.assertEquals(1,creationCount.getRegattaCount());
+        Assert.assertEquals(1,creationCount.getLeaderboardCount());
+        Assert.assertEquals(2,creationCount.getLeaderboardGroupCount());
+        
+        Event eventOnTarget = destService.getEvent(eventUUID);
+        Assert.assertNotNull(eventOnTarget);
+        LeaderboardGroup leaderboardGroupOnTarget = destService.getLeaderboardGroupByName(TEST_GROUP_NAME);
+        Assert.assertNotNull(leaderboardGroupOnTarget);
+        Assert.assertTrue(leaderboardGroupOnTarget.getLeaderboards().iterator().hasNext());
+        LeaderboardGroup leaderboardGroup2OnTarget = destService.getLeaderboardGroupByName(TEST_GROUP_NAME2);
+        Assert.assertNotNull(leaderboardGroup2OnTarget);
+        Assert.assertTrue(leaderboardGroup2OnTarget.getLeaderboards().iterator().hasNext());
+     
+    }
 }
@@ -48,8 +48,8 @@ public class MasterDataImporter {
                JSONObject leaderBoardGroupMasterDataJson = (JSONObject) leaderBoardGroupMasterData;
                LeaderboardGroupMasterData masterData = leaderboardGroupMasterDataDeserializer
                        .deserialize(leaderBoardGroupMasterDataJson);
-                ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, override);
-                creationCount.add(racingEventService.apply(op));
+                ImportMasterDataOperation op = new ImportMasterDataOperation(masterData, override, creationCount);
+                creationCount = racingEventService.apply(op);
            }
            JsonDeserializer<MediaTrack> mediaTrackDeserializer = new MediaTrackJsonDeserializer();
            JSONArray mediaTracks = (JSONArray) masterDataOverall.get(TopLevelMasterDataSerializer.FIELD_MEDIA);
@@ -67,7 +67,7 @@ public class MasterDataImporter {
            for (MediaTrack oneNewTrack : tracks) {
                if (existingMap.containsKey(oneNewTrack.dbId)) {
                    if (override) {
-                        racingEventService.mediaTrackDeleted(existingMap.get(oneNewTrack));
+                        racingEventService.mediaTrackDeleted(existingMap.get(oneNewTrack.dbId));
                    } else {
                        continue;
                    }
@@ -63,7 +63,8 @@ public class ImportMasterDataOperation extends

    private final boolean override;

-    public ImportMasterDataOperation(LeaderboardGroupMasterData masterData, boolean override) {
+    public ImportMasterDataOperation(LeaderboardGroupMasterData masterData, boolean override, MasterDataImportObjectCreationCountImpl existingCreationCount) {
+        this.creationCount.add(existingCreationCount);
        this.masterData = masterData;
        this.override = override;
    }
@@ -81,8 +82,12 @@ public class ImportMasterDataOperation extends
        createRegattas(masterData, toState);
        Map<String, Leaderboard> existingLeaderboards = toState.getLeaderboards();
        for (LeaderboardMasterData board : masterData.getLeaderboards()) {
+            leaderboardNames.add(board.getName());
            if (existingLeaderboards.containsKey(board.getName())) {
-                if (override) {
+                if (creationCount.alreadyAddedLeaderboardWithName(board.getName())) {
+                    //Has already been added by this operation
+                    continue;
+                } else if (override) {
                    toState.removeLeaderboard(board.getName());
                    logger.info(String.format("Leaderboard with name %1$s already existed and has been overridden.",
                            board.getName()));
@@ -98,8 +103,7 @@ public class ImportMasterDataOperation extends
            if (leaderboard != null) {
                leaderboard.setDisplayName(board.getDisplayName());
                toState.addLeaderboard(leaderboard);
-                leaderboardNames.add(board.getName());
-                creationCount.addOneLeaderboard();
+                creationCount.addOneLeaderboard(leaderboard.getName());
                Leaderboard newLeaderboard = toState.getLeaderboardByName(board.getName());
                addRaceColumnsIfNecessary(board, newLeaderboard, toState);
                // Set dummy tracked race, so that the leaderboard caches the competitors and
@@ -138,7 +142,7 @@ public class ImportMasterDataOperation extends
            toState.addLeaderboardGroup(masterData.getName(), masterData.getDescription(),
                    masterData.isDisplayGroupsRevese(), leaderboardNames, overallLeaderboardDiscardThresholds,
                    overallLeaderboardScoringSchemeType);
-            creationCount.addOneLeaderboardGroup();
+            creationCount.addOneLeaderboardGroup(masterData.getName());
        } else {
            logger.info(String.format("Leaderboard Group with name %1$s already exists and hasn't been overridden.",
                    masterData.getName()));
@@ -267,13 +271,16 @@ public class ImportMasterDataOperation extends
        for (RegattaMasterData singleRegattaData : regattaData) {
            Regatta existingRegatta = toState.getRegatta(new RegattaName(singleRegattaData.getRegattaName()));
            if (existingRegatta != null) {
-                if (override) {
+                if (creationCount.alreadyAddedRegattaWithId(existingRegatta.getId().toString())) {
+                    //Already added earlier in this import process
+                    continue;
+                } else if (override) {
                    logger.info(String.format("Regatta with name %1$s already existed and has been overridden.",
                            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.",
+                        logger.warning(String.format("Regatta with name %1$s could not be deleted due to an error.",
                                singleRegattaData.getRegattaName()));
                        e.printStackTrace();
                        continue;
@@ -297,7 +304,7 @@ public class ImportMasterDataOperation extends
                    domainFactory.createScoringScheme(ScoringSchemeType.valueOf(scoringSchemeType)),
                    courseAreaUUID).getA();
            toState.setPersistentRegattaForRaceIDs(createdRegatta, singleRegattaData.getRaceIds(), override);
-            creationCount.addOneRegatta();
+            creationCount.addOneRegatta(createdRegatta.getId().toString());
        }

    }
@@ -338,7 +345,7 @@ public class ImportMasterDataOperation extends
        for (EventMasterData event : events) {
            String id = event.getId();
            Event existingEvent = toState.getEvent(UUID.fromString(id));
-            if (existingEvent != null && override) {
+            if (existingEvent != null && override && !creationCount.alreadyAddedEventWithId(id)) {
                logger.info(String.format("Event with name %1$s already existed and will be overridden.",
                        event.getName()));
                toState.removeEvent(existingEvent.getId());
@@ -351,7 +358,7 @@ public class ImportMasterDataOperation extends
                boolean isPublic = event.isPublic();
                Event newEvent = new EventImpl(name, venueName, pubString, isPublic, UUID.fromString(id));
                toState.createEventWithoutReplication(newEvent);
-                creationCount.addOneEvent();
+                creationCount.addOneEvent(newEvent.getId().toString());
            } else {
                logger.info(String.format("Event with name %1$s already exists and hasn't been overridden.",
                        event.getName()));