added classes for regattaStructures and fixed some bugs

2026-11-02 17:19:37 +00:00 · 2014-09-23 14:19:31 +02:00
1 parent 0cc874645e
commit d42d2ffcf1
@@ -24,8 +24,8 @@ public class DefaultRegattaCreateDialog extends RegattaWithSeriesAndFleetsCreate
    private SailingServiceAsync sailingService;
    private ErrorReporter errorReporter;

-    public DefaultRegattaCreateDialog(Collection<RegattaDTO> existingRegattas, List<EventDTO> existingEvents, SailingServiceAsync sailingService,
-            ErrorReporter errorReporter, StringMessages stringConstants,
+    public DefaultRegattaCreateDialog(Collection<RegattaDTO> existingRegattas, List<EventDTO> existingEvents,
+            SailingServiceAsync sailingService, ErrorReporter errorReporter, StringMessages stringConstants,
            com.sap.sse.gwt.client.dialog.DataEntryDialog.DialogCallback<RegattaDTO> callback) {
        super(existingRegattas, existingEvents, stringConstants, callback);
        this.sailingService = sailingService;
@@ -33,7 +33,7 @@ public class DefaultRegattaCreateDialog extends RegattaWithSeriesAndFleetsCreate

        nameEntryField.setText("Default");
        nameEntryField.setReadOnly(true);
-        boatClassEntryField.setText("DeOfault");
+        boatClassEntryField.setText("Default");
        boatClassEntryField.setReadOnly(true);
        setCourseAreaSelection();

@@ -101,6 +101,7 @@ public class DefaultRegattaCreateDialog extends RegattaWithSeriesAndFleetsCreate

                    @Override
                    public void onSuccess(EventDTO newEvent) {
+                        sailingEventsListBox.addItem(newEvent.getName());
                        sailingEventsListBox.setSelectedIndex(sailingEventsListBox.getItemCount() - 1);
                        for (CourseAreaDTO courseArea : newEvent.venue.getCourseAreas()) {
                            courseAreaListBox.addItem(courseArea.getName());
@@ -4,6 +4,10 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import buildstructure.BuildStructure;

 import com.github.gwtbootstrap.client.ui.base.ProgressBarBase.Style;
 import com.google.gwt.dom.client.Style.Unit;
@@ -20,16 +24,16 @@ import com.google.gwt.user.client.ui.Label;
 import com.google.gwt.user.client.ui.Panel;
 import com.google.gwt.user.client.ui.TextBox;
 import com.google.gwt.user.client.ui.VerticalPanel;
-import com.sap.sailing.domain.common.RegattaIdentifier;
 import com.sap.sailing.gwt.ui.client.ErrorReporter;
 import com.sap.sailing.gwt.ui.client.RegattaRefresher;
 import com.sap.sailing.gwt.ui.client.RegattaSelectionModel;
 import com.sap.sailing.gwt.ui.client.RegattaSelectionProvider;
 import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
 import com.sap.sailing.gwt.ui.client.StringMessages;
-import com.sap.sailing.gwt.ui.shared.CourseAreaDTO;
 import com.sap.sailing.gwt.ui.shared.EventDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaDTO;
+import com.sap.sailing.gwt.ui.shared.RegattaStructureDTO;
+import com.sap.sailing.xrr.structureimport.RegattaStructureKey;
 import com.sap.sse.gwt.client.dialog.DataEntryDialog.DialogCallback;

 public class StructureImportManagementPanel extends FlowPanel {
@@ -226,8 +230,8 @@ public class StructureImportManagementPanel extends FlowPanel {
                            }

                            @Override
-                            public void ok(RegattaDTO newRegatta) {
-                                sailingService.getRegattaStructure(regattaNames, new AsyncCallback<Void>() {
+                            public void ok(final RegattaDTO newRegatta) {
+                                sailingService.getRegattaStructure(regattaNames, new AsyncCallback<Set<RegattaStructureDTO>>() {
                                    @Override
                                    public void onFailure(Throwable caught) {
 //                                        errorReporter.reportError(stringMessages.errorAddingResultImportUrl(caught
@@ -235,9 +239,9 @@ public class StructureImportManagementPanel extends FlowPanel {
                                    }

                                    @Override
-                                    public void onSuccess(Void result) {
-                                     // TODO hier die getRegattaStructure aus sailingServiceImpl aufrufen und damit das UI
-                                        // aufbauen
+                                    public void onSuccess(Set<RegattaStructureDTO> result) {
+                                     // TODO UI aufbauen
+                                        createRegattas(regattaNames, new EventDTO("MyEvent"), newRegatta); //EventDTO??
                                    }
                                });
                                
@@ -69,6 +69,7 @@ import com.sap.sailing.gwt.ui.shared.RaceTimesInfoDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaOverviewEntryDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaScoreCorrectionDTO;
+import com.sap.sailing.gwt.ui.shared.RegattaStructureDTO;
 import com.sap.sailing.gwt.ui.shared.RemoteSailingServerReferenceDTO;
 import com.sap.sailing.gwt.ui.shared.ReplicationStateDTO;
 import com.sap.sailing.gwt.ui.shared.ScoreCorrectionProviderDTO;
@@ -562,6 +563,6 @@ public interface SailingService extends RemoteService {
     */
    RaceDTO setStartTimeReceivedForRace(RaceIdentifier raceIdentifier, Date newStartTimeReceived);

-    void getRegattaStructure(List<String> regattaNames);
+    Set<RegattaStructureDTO> getRegattaStructure(List<String> regattaNames);

 }
@@ -59,6 +59,7 @@ import com.sap.sailing.gwt.ui.shared.RaceTimesInfoDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaOverviewEntryDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaScoreCorrectionDTO;
+import com.sap.sailing.gwt.ui.shared.RegattaStructureDTO;
 import com.sap.sailing.gwt.ui.shared.RemoteSailingServerReferenceDTO;
 import com.sap.sailing.gwt.ui.shared.ReplicationStateDTO;
 import com.sap.sailing.gwt.ui.shared.ScoreCorrectionProviderDTO;
@@ -644,6 +645,6 @@ public interface SailingServiceAsync {

    void createRegattaStructure(List<String> regattaNames, EventDTO newEvent,RegattaDTO defaultRegatta, AsyncCallback<Void> asyncCallback);

-    void getRegattaStructure(List<String> regattaNames, AsyncCallback<Void> callback); 
+    void getRegattaStructure(List<String> regattaNames, AsyncCallback<Set<RegattaStructureDTO>> asyncCallback); 

 }
@@ -303,6 +303,7 @@ import com.sap.sailing.gwt.ui.shared.RegattaDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaOverviewEntryDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaScoreCorrectionDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaScoreCorrectionDTO.ScoreCorrectionEntryDTO;
+import com.sap.sailing.gwt.ui.shared.RegattaStructureDTO;
 import com.sap.sailing.gwt.ui.shared.RemoteSailingServerReferenceDTO;
 import com.sap.sailing.gwt.ui.shared.ReplicaDTO;
 import com.sap.sailing.gwt.ui.shared.ReplicationMasterDTO;
@@ -388,6 +389,7 @@ import com.sap.sailing.server.replication.ReplicationService;
 import com.sap.sailing.server.replication.impl.ReplicaDescriptor;
 import com.sap.sailing.util.BuildVersion;
 import com.sap.sailing.xrr.schema.RegattaResults;
+import com.sap.sailing.xrr.structureimport.RegattaStructureKey;
 import com.sap.sailing.xrr.structureimport.SeriesParameters;
 import com.sap.sailing.xrr.structureimport.StructureImporter;
 import com.sap.sse.common.Util;
@@ -3723,7 +3725,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S

    private SeriesParameters getDefaultSeries(RegattaDTO defaultRegatta) {
        SeriesParameters defaultSeries = new SeriesParameters(false, false, false, null);
-        if (defaultRegatta.series.size() > 0) {
+        if (defaultRegatta.series.size() > 0) { //null abfangen
            SeriesDTO series = defaultRegatta.series.get(0);
            defaultSeries
                    .setFirstColumnIsNonDiscardableCarryForward(series.isFirstColumnIsNonDiscardableCarryForward());
@@ -3748,20 +3750,14 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
    private List<String> createRegattasWithRaces(Iterable<AddSpecificRegatta> regattas, String eventName) {

        List<String> leaderboardNames = new ArrayList<String>();
-//        List<List<List<String>>> series = structureImporter.getRaceNames();
        List<BuildStructure> buildStructures = structureImporter.getBuildStructures();
        int i = 0;
-        for (AddSpecificRegatta addSpecificRegatta: regattas) {
+        for (AddSpecificRegatta addSpecificRegatta : regattas) {
            Regatta regatta = getService().apply(addSpecificRegatta);

-            // create Races
-            int j = 0;
-            for(buildstructure.Series series: buildStructures.get(i).getRegattaStructure().getSeries()){
-            addRaceColumnsToSeries(regatta.getRegattaIdentifier(), buildStructure.get(i).getRegattaStructure()., );
-            }
-            for (Series s : regatta.getSeries()) {
-                addRaceColumnsToSeries(regatta.getRegattaIdentifier(), s.getName(), series.get(i).get(j));
-                j++;
+            // create RaceColumns
+            for (buildstructure.Series series : buildStructures.get(i).getRegattaStructure().getSeries()) {
+                addRaceColumnsToSeries(regatta.getRegattaIdentifier(), series.getSeries(), series.getRaceNames());
            }

            if (getLeaderboard(regatta.getName()) == null) {
@@ -3774,11 +3770,16 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
    }

    @Override
-    public void getRegattaStructure(final List<String> regattaNames) {
-        structureImporter.getRegattaStructure(regattaNames);
-        // Series erstellen
-        // TODO hier die getRegattaStructure aus StructureImporter aufrufen
-        // TODO Rückgabetyp ändern
+    public Set<RegattaStructureDTO> getRegattaStructure(final List<String> regattaNames) {
+        structureImporter.updateRegattasToSelected(regattaNames);
+        Map<RegattaStructureKey, Set<BuildStructure>> regattaStructures =  structureImporter.getRegattaStructures(regattaNames);
+        Set<RegattaStructureKey> regattaStructureKeys = regattaStructures.keySet();
+        Set<RegattaStructureDTO> regattaStructureDTOs = new HashSet<RegattaStructureDTO>();
+        for(RegattaStructureKey regattaStructureKey: regattaStructureKeys){
+            RegattaStructureDTO regattaStructureDTO = new RegattaStructureDTO(regattaStructureKey, regattaStructures.get(regattaStructureKey));
+            regattaStructureDTOs.add(regattaStructureDTO);
+        }
+        return regattaStructureDTOs;
    }

    @Override
@@ -3790,8 +3791,6 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
            @Override
            public void run() {

-                structureImporter.updateRegattasToSelected(regattaNames);
-
                SeriesParameters defaultSeries = getDefaultSeries(defaultRegatta);

                // get Regattas
@@ -3804,7 +3803,6 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                List<String> leaderboardNames = createRegattasWithRaces(regattas, newEvent.getName());
                createAndAddLeaderboardGroup(newEvent, leaderboardNames);
                structureImporter.setCompetitors();
-                structureImporter.resetSeriesForRegattas();
                structureImporter.setFinished(true);

            }
@@ -3819,6 +3817,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
            description = newEvent.getDescription();
        }
        String eventName = newEvent.getName();
+        List<UUID> eventLeaderboardGroupUUIDs = new ArrayList<>();

        // create Leaderboard Group
        if (getService().getLeaderboardGroupByName(eventName) == null) {
@@ -3826,6 +3825,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                    eventName, false, leaderboardNames, null, null);
            leaderboardGroupDTO = convertToLeaderboardGroupDTO(getService().apply(createLeaderboardGroupOp), false,
                    false);
+            eventLeaderboardGroupUUIDs.add(leaderboardGroupDTO.getId());
        } else {
            leaderboardNames.addAll(getLeaderboardNames());
            updateLeaderboardGroup(eventName, eventName, newEvent.getDescription(), eventName, leaderboardNames, null,
@@ -3833,11 +3833,10 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
            leaderboardGroupDTO = getLeaderboardGroupByName(eventName, false);
        }

-        List<UUID> eventLeaderboardGroupUUIDs = new ArrayList<>();
        for (LeaderboardGroupDTO lg : newEvent.getLeaderboardGroups()) {
            eventLeaderboardGroupUUIDs.add(lg.getId());
        }
-        eventLeaderboardGroupUUIDs.add(leaderboardGroupDTO.getId());
+
        try {
            updateEvent(newEvent.id, newEvent.getName(), description, newEvent.startDate, newEvent.endDate,
                    newEvent.venue, newEvent.isPublic, eventLeaderboardGroupUUIDs, newEvent.getLogoImageURL(),
@@ -0,0 +1,52 @@
+package com.sap.sailing.gwt.ui.shared;
+
+import java.util.Set;
+
+import buildstructure.BuildStructure;
+
+import com.sap.sailing.xrr.structureimport.RegattaStructureKey;
+import com.sap.sailing.xrr.structureimport.SeriesParameters;
+
+public class RegattaStructureDTO {
+    private final RegattaStructureKey regattaStructure;
+    private SeriesDTO defaultSeries;
+    private final Set<BuildStructure> linkedBuildStructures;
+
+    public RegattaStructureDTO(RegattaStructureKey regattaStructure, Set<BuildStructure> linkedBuildStructures) {
+        this.regattaStructure = regattaStructure;
+        this.linkedBuildStructures = linkedBuildStructures;
+        defaultSeries = new SeriesDTO("Default", null, null, false, null, false, false, false);
+    }
+
+    public String getRegattaStructureAsString() {
+        String regattaStructureString = "";
+
+        for (String s : regattaStructure.getRegattaStructureKey()) {
+            regattaStructureString = regattaStructureString.concat("," + s);
+        }
+        return regattaStructureString.substring(1);
+    }
+
+    public void setDefaultSeries(RegattaDTO defaultRegatta) {
+        SeriesParameters defaultSeries = new SeriesParameters(false, false, false, null);
+        if (defaultRegatta.series.size() > 0) { // null abfangen
+            SeriesDTO series = defaultRegatta.series.get(0);
+            defaultSeries
+                    .setFirstColumnIsNonDiscardableCarryForward(series.isFirstColumnIsNonDiscardableCarryForward());
+            defaultSeries.setHasSplitFleetContiguousScoring(series.hasSplitFleetContiguousScoring());
+            defaultSeries.setStartswithZeroScore(series.isStartsWithZeroScore());
+            defaultSeries.setDiscardingThresholds(series.getDiscardThresholds());
+        }
+    }
+
+    public SeriesDTO getDefaultSeries() {
+        return defaultSeries;
+    }
+
+    public Set<BuildStructure> getLinkedBuildStructures() {
+        return linkedBuildStructures;
+    }
+    
+    
+
+}
@@ -4,19 +4,20 @@ import java.util.List;

 import com.sap.sailing.xrr.schema.Race;

-public class SetRacenumberFromSeries implements SetRacenumberStrategy{
+public class SetRacenumberFromSeries implements SetRacenumberStrategy {

-	@Override
-	public void setRacenumber(Race race, Series series, int i, List<String> raceNames) {
-		if (race != null) {
+    @Override
+    public void setRacenumber(Race race, Series series, int i, List<String> raceNames) {
+        if (race != null) {
            char beginOfSeries = series.getFirstChar();
-            if (beginOfSeries =='D' && race.getFirstChar()!='R') {
-            	beginOfSeries = 'R';
-            	raceNames.add("" + beginOfSeries + (i+1));
+            if (beginOfSeries == 'D' && race.getFirstChar() != 'R') {
+                beginOfSeries = 'R';
+                raceNames.add("" + beginOfSeries + (i + 1));
            } else {
-            	raceNames.add(race.getRaceName());
+                raceNames.add(race.getRaceName());
            }
        }
-	}
+        series.setRaceNames(raceNames);
+    }

 }
@@ -0,0 +1,18 @@
+package com.sap.sailing.xrr.structureimport;
+
+public class RegattaStructureKey {
+    
+    /*RegattaStructureKey which consists of series and fleet names*/
+    private final Iterable<String> regattaStructureKey;
+
+    public RegattaStructureKey(Iterable<String> regattaStructureKey) {
+        this.regattaStructureKey = regattaStructureKey;
+    }
+
+    public Iterable<String> getRegattaStructureKey() {
+        return regattaStructureKey;
+    }
+    
+    //define HashCode and equals?
+
+}
@@ -3,5 +3,5 @@
 <module>
  <source path='buildstructure'/>
  <source path='eventimport'/>
-  <source path='importurl'/>
+  <source path='structureimport'/>
 </module>
@@ -3,22 +3,24 @@ package com.sap.sailing.xrr.structureimport;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.Serializable;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.UUID;

 import javax.xml.bind.JAXBException;

 import buildstructure.BuildStructure;
 import buildstructure.Fleet;
-import buildstructure.SetRacenumberStrategy;
-import buildstructure.Series;
 import buildstructure.RegattaStructure;
+import buildstructure.Series;
+import buildstructure.SetRacenumberStrategy;

 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.DomainFactory;
@@ -35,7 +37,6 @@ import com.sap.sailing.domain.common.ScoringSchemeType;
 import com.sap.sailing.domain.common.dto.FleetDTO;
 import com.sap.sailing.domain.common.dto.RegattaCreationParametersDTO;
 import com.sap.sailing.domain.common.dto.SeriesCreationParametersDTO;
-import com.sap.sailing.domain.leaderboard.impl.LowPoint;
 import com.sap.sailing.server.operationaltransformation.AddSpecificRegatta;
 import com.sap.sailing.xrr.resultimport.ParserFactory;
 import com.sap.sailing.xrr.schema.Boat;
@@ -53,8 +54,10 @@ import eventimport.RegattaJSON;
 public class StructureImporter {

    private ArrayList<RegattaResults> results = new ArrayList<RegattaResults>();
-    private static List<List<List<String>>> seriesForRegattas = new ArrayList<List<List<String>>>();
    private ArrayList<RegattaJSON> regattas;
+    private ArrayList<RegattaJSON> selectedRegattas = new ArrayList<RegattaJSON>();;
+    private Map<RegattaStructureKey, Set<BuildStructure>> seriesStructuresWithFrequency = new LinkedHashMap<RegattaStructureKey, Set<BuildStructure>>(); // TODO
+                                                                                                                                                         // rename
    private List<BuildStructure> buildStructures = new ArrayList<BuildStructure>();
    private LinkedHashMap<String, Boat> boatForPerson;
    private DomainFactory baseDomainFactory;
@@ -81,12 +84,11 @@ public class StructureImporter {
    }

    public void updateRegattasToSelected(List<String> regattaNames) {
-        List<RegattaJSON> regattasTemp = new ArrayList<RegattaJSON>(regattas);
-        regattas.clear();
-        for (RegattaJSON regatta : regattasTemp) {
+        selectedRegattas.clear();
+        for (RegattaJSON regatta : regattas) {
            for (String s : regattaNames) {
                if (regatta.getName().equals(s)) {
-                    regattas.add(regatta);
+                    selectedRegattas.add(regatta);
                }
            }
        }
@@ -94,9 +96,9 @@ public class StructureImporter {

    private void parseRegattas() {

-        for (int i = 0; i < regattas.size(); i++) {
+        for (int i = 0; i < selectedRegattas.size(); i++) {
            try {
-                parseRegattaXML(regattas.get(i).getXrrEntriesUrl());
+                parseRegattaXML(selectedRegattas.get(i).getXrrEntriesUrl());
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (JAXBException e) {
@@ -108,37 +110,52 @@ public class StructureImporter {
        }
    }

-    public Iterable<BuildStructure> getRegattaStructure(List<String> regattaNames) {
-        // TODO anderen Rückgabeparameter verwenden. Evtl. eine eigene DTO Klasse.
-        // Die Series aus diesem Paket kann ja nicht verwendet werden, weil es sonst wieder dependencies loops gibt
-
-        List<String> allSeries = new ArrayList<String>();
+    public Map<RegattaStructureKey, Set<BuildStructure>> getRegattaStructures(List<String> regattaNames) {
+        // dependencies loops
        buildStructures.clear();
-
        results.clear();
        parseRegattas();
        int zaehler = 0;

-        for (RegattaResults result: results) {
-            List<String> series = new ArrayList<String>();
+        for (RegattaResults result : results) {
            List<Race> races = new ArrayList<Race>();

-            Event event = (Event) result.getPersonOrBoatOrTeam()
-                    .get(result.getPersonOrBoatOrTeam().size() - 1);
+            Event event = (Event) result.getPersonOrBoatOrTeam().get(result.getPersonOrBoatOrTeam().size() - 1);

            List<Object> raceOrDevisionOrRegattaSeries = event.getRaceOrDivisionOrRegattaSeriesResult();
            for (int j = 1; j < raceOrDevisionOrRegattaSeries.size(); j++) {
                races.add((Race) raceOrDevisionOrRegattaSeries.get(j));
            }

-            BuildStructure structure = new BuildStructure(races, regattas.get(zaehler).getName());
-            // TODO am besten in der Buildstructure im RegattaStructure eine Methode getRegattaStructure(),
-            // um die Struktur in dem gewünschten Format zu bekommen
+            BuildStructure structure = new BuildStructure(races, selectedRegattas.get(zaehler).getName());
+            analyseStructure(structure);
            buildStructures.add(structure);
            zaehler++;
        }

-        return buildStructures;
+        return seriesStructuresWithFrequency;
+    }
+
+    public void analyseStructure(BuildStructure structure) {
+        Set<String> seriesAndFleets = new HashSet<String>();
+        for (Series series : structure.getRegattaStructure().getSeries()) {
+            seriesAndFleets.add(series.getSeries());
+            for (Fleet fleet : series.getFleets()) {
+                seriesAndFleets.add(fleet.getColor());
+            }
+        }
+        RegattaStructureKey regattaStructureKey = new RegattaStructureKey(seriesAndFleets);
+
+        if (!seriesAndFleets.isEmpty()) {
+            if (seriesStructuresWithFrequency.containsKey(regattaStructureKey)) {
+                seriesStructuresWithFrequency.get(regattaStructureKey).add(structure);
+            } else {
+                Set<BuildStructure> buildStructures = new HashSet<BuildStructure>();
+                buildStructures.add(structure);
+                seriesStructuresWithFrequency.put(regattaStructureKey, buildStructures);
+            }
+        }
+
    }

    public Iterable<AddSpecificRegatta> getRegattas(ScoringSchemeType scoringScheme, boolean isPersistent,
@@ -148,31 +165,19 @@ public class StructureImporter {

        this.baseDomainFactory = baseDomainFactory;
        List<AddSpecificRegatta> addSpecificRegattas = new ArrayList<AddSpecificRegatta>();
-        results.clear();
-        parseRegattas();

        for (int i = 0; i < results.size(); i++) {
-
-            List<Race> races = new ArrayList<Race>();
-
-            // TODO hier die BuildStructure rausnehmen und das bestehende verwenden
+            LinkedHashMap<String, SeriesCreationParametersDTO> seriesCreationParams = setSeriesCreationParameters(
+                    buildStructures.get(i), firstColumnIsNonDiscardableCarryForward, hasSplitFleetContiguousScoring,
+                    startswithZeroScore, discardingThresholds);

            Event event = (Event) results.get(i).getPersonOrBoatOrTeam()
                    .get(results.get(i).getPersonOrBoatOrTeam().size() - 1);

-            List<Object> raceOrDevisionOrRegattaSeries = event.getRaceOrDivisionOrRegattaSeriesResult();
-            for (int j = 1; j < raceOrDevisionOrRegattaSeries.size(); j++) {
-                races.add((Race) raceOrDevisionOrRegattaSeries.get(j));
-            }
+            String titel = event.getTitle();

-            BuildStructure structure = new BuildStructure(races, regattas.get(i).getName());
-
-            LinkedHashMap<String, SeriesCreationParametersDTO> seriesCreationParams = setSeriesCreationParameters(
-                    structure, firstColumnIsNonDiscardableCarryForward, hasSplitFleetContiguousScoring,
-                    startswithZeroScore, discardingThresholds);
-
-            addSpecificRegattas.add(new AddSpecificRegatta(RegattaImpl.getDefaultName(event.getTitle(), ((Division) event
-                    .getRaceOrDivisionOrRegattaSeriesResult().get(0)).getTitle()), ((Division) event
+            addSpecificRegattas.add(new AddSpecificRegatta(RegattaImpl.getDefaultName(event.getTitle(),
+                    ((Division) event.getRaceOrDivisionOrRegattaSeriesResult().get(0)).getTitle()), ((Division) event
                    .getRaceOrDivisionOrRegattaSeriesResult().get(0)).getTitle(), event.getEventID(),
                    new RegattaCreationParametersDTO(seriesCreationParams), isPersistent, this.baseDomainFactory
                            .createScoringScheme(scoringScheme), courseArea, useStartTimeInference));
@@ -187,20 +192,18 @@ public class StructureImporter {
        LinkedHashMap<String, SeriesCreationParametersDTO> seriesCreationParams = new LinkedHashMap<String, SeriesCreationParametersDTO>();

        RegattaStructure regattaStructure = structure.getRegattaStructure();
-        List<List<String>> series = new ArrayList<List<String>>();

        if (regattaStructure != null) {
-            ArrayList<Series> raceTypes = regattaStructure.getSeries();
-            for (int i = 0; i < raceTypes.size(); i++) {
+            int i = 0;
+            for (Series raceType : regattaStructure.getSeries()) {

-                Series raceType = raceTypes.get(i);
-
-                ArrayList<FleetDTO> fleets = getFleets(raceType.getFleets());
-                List<String> raceNames = getRaceNames(i, raceType, raceType.getFleets());
+                List<FleetDTO> fleets = getFleets(raceType.getFleets());
+                setRaceNames(i, raceType, raceType.getFleets());

                seriesCreationParams.put(raceType.getSeries(), new SeriesCreationParametersDTO(fleets,
-                /* medal */raceTypes.get(i).isMedal(), startswithZeroScore, firstColumnIsNonDiscardableCarryForward,
+                /* medal */raceType.isMedal(), startswithZeroScore, firstColumnIsNonDiscardableCarryForward,
                        discardingThresholds, hasSplitFleetContiguousScoring));
+                i++;
            }

        }
@@ -208,7 +211,7 @@ public class StructureImporter {

    }

-    private List<String> getRaceNames(int i, Series raceType, ArrayList<Fleet> fleets) {
+    private List<String> setRaceNames(int i, Series raceType, ArrayList<Fleet> fleets) {
        List<String> raceNames = new ArrayList<String>();

        // set Racenumbers for each series
@@ -220,7 +223,7 @@ public class StructureImporter {
        return raceNames;
    }

-    private ArrayList<FleetDTO> getFleets(ArrayList<Fleet> fleets) {
+    private List<FleetDTO> getFleets(ArrayList<Fleet> fleets) {
        ArrayList<FleetDTO> fleetsDTO = new ArrayList<FleetDTO>();
        String fleetColor;
        for (int j = 0; j < fleets.size(); j++) {
@@ -276,7 +279,7 @@ public class StructureImporter {
        for (int i = 0; i < results.size(); i++) {
            BoatClass boatClass = null;

-            boatClass = getBoatClass(regattas.get(i));
+            boatClass = getBoatClass(selectedRegattas.get(i));

            ArrayList<Object> personOrBoatOrTeam = (ArrayList<Object>) results.get(i).getPersonOrBoatOrTeam();

@@ -376,10 +379,6 @@ public class StructureImporter {
        return team;
    }

-    public List<List<List<String>>> getRaceNames() {
-        return seriesForRegattas;
-    }
-
    private void parseRegattaXML(String url) throws FileNotFoundException, JAXBException, IOException {
        results.add(ParserFactory.INSTANCE.createParser(getInputStream(url), "").parse());

@@ -392,10 +391,6 @@ public class StructureImporter {
        return connection.getInputStream();
    }

-    public void resetSeriesForRegattas() {
-        seriesForRegattas.clear();
-    }
-
    public int getProgress() {
        return parsedDocuments;
    }
@@ -407,8 +402,8 @@ public class StructureImporter {
    public void setFinished(boolean finished) {
        this.finished = finished;
    }
-    
-    public List<BuildStructure> getBuildStructures(){
+
+    public List<BuildStructure> getBuildStructures() {
        return buildStructures;
    }