Add DefaultRegattaCreation to Event as well as several minor improvements

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

@@ -55,12 +55,14 @@ public abstract class AbstractRegattaWithSeriesAndFleetsDialog<T> extends DataEn
     private final ListBox rankingMetricListBox;
 
     protected final List<EventDTO> existingEvents;
+    private EventDTO defaultEvent;
 
-    public AbstractRegattaWithSeriesAndFleetsDialog(RegattaDTO regatta, Iterable<SeriesDTO> series, List<EventDTO> existingEvents,
+    public AbstractRegattaWithSeriesAndFleetsDialog(RegattaDTO regatta, Iterable<SeriesDTO> series, List<EventDTO> existingEvents, EventDTO correspondingEvent, 
             String title, String okButton, StringMessages stringMessages, Validator<T> validator, DialogCallback<T> callback) {
         super(title, null, okButton, stringMessages.cancel(), validator, callback);
         this.stringMessages = stringMessages;
         this.regatta = regatta;
+        this.defaultEvent = correspondingEvent;
         this.existingEvents = existingEvents;
         rankingMetricListBox = createListBox(/* isMultipleSelect */ false);
         for (RankingMetrics rankingMetricType : RankingMetrics.values()) {
@@ -198,9 +200,20 @@ public abstract class AbstractRegattaWithSeriesAndFleetsDialog<T> extends DataEn
         });
         for (EventDTO event : sortedEvents) {
             sailingEventsListBox.addItem(event.getName());
-            if (isCourseAreaInEvent(event, regatta.defaultCourseAreaUuid)) {
-                sailingEventsListBox.setSelectedIndex(sailingEventsListBox.getItemCount() - 1);
-                fillCourseAreaListBox(event);
+            if(defaultEvent != null){
+                if (defaultEvent.getName().equals(event.getName())){
+                    sailingEventsListBox.setSelectedIndex(sailingEventsListBox.getItemCount() - 1);
+                    fillCourseAreaListBox(event);
+                    //select default course area, 2 elements as first is please select course area string
+                    if (courseAreaListBox.getItemCount() == 2){
+                        courseAreaListBox.setSelectedIndex(1);
+                    }
+                }
+            } else { 
+                if (isCourseAreaInEvent(event, regatta.defaultCourseAreaUuid)) {
+                    sailingEventsListBox.setSelectedIndex(sailingEventsListBox.getItemCount() - 1);
+                    fillCourseAreaListBox(event);
+                }
             }
         }
         sailingEventsListBox.addChangeHandler(new ChangeHandler() {

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

@@ -0,0 +1,19 @@
+package com.sap.sailing.gwt.ui.adminconsole;
+
+import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
+import com.sap.sailing.gwt.ui.client.StringMessages;
+import com.sap.sse.gwt.client.ErrorReporter;
+import com.sap.sse.gwt.client.dialog.DataEntryDialog;
+
+public class CreateDefaultRegattaDialog extends DataEntryDialog<Void> {
+    
+    public CreateDefaultRegattaDialog(SailingServiceAsync sailingService, StringMessages stringMessages,
+            ErrorReporter errorReporter, com.sap.sse.gwt.client.dialog.DataEntryDialog.DialogCallback<Void> callback) {
+        super(stringMessages.createDefaultRegatta(), /*message*/ stringMessages.doYouWantToCreateADefaultRegatta(), stringMessages.yes(), stringMessages.no(), /*validator*/ null, callback);
+    }   
+
+    @Override
+    protected Void getResult() {
+        return null;
+    }
+}

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

@@ -0,0 +1,210 @@
+package com.sap.sailing.gwt.ui.adminconsole;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.UUID;
+
+import com.google.gwt.user.client.rpc.AsyncCallback;
+import com.sap.sailing.domain.base.Series;
+import com.sap.sailing.domain.common.RegattaIdentifier;
+import com.sap.sailing.domain.common.dto.RaceColumnDTO;
+import com.sap.sailing.domain.common.dto.RaceColumnInSeriesDTO;
+import com.sap.sailing.domain.common.dto.RegattaCreationParametersDTO;
+import com.sap.sailing.domain.common.dto.SeriesCreationParametersDTO;
+import com.sap.sailing.gwt.ui.client.RegattaRefresher;
+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.LeaderboardGroupDTO;
+import com.sap.sailing.gwt.ui.shared.RegattaDTO;
+import com.sap.sailing.gwt.ui.shared.SeriesDTO;
+import com.sap.sailing.gwt.ui.shared.StrippedLeaderboardDTO;
+import com.sap.sse.common.Util.Pair;
+import com.sap.sse.gwt.client.ErrorReporter;
+import com.sap.sse.gwt.client.async.MarkedAsyncCallback;
+import com.sap.sse.gwt.client.dialog.DataEntryDialog.DialogCallback;
+
+public class CreateRegattaCallback implements DialogCallback<RegattaDTO>{
+
+    private SailingServiceAsync sailingService;
+    private ErrorReporter errorReporter;
+    private RegattaRefresher regattaRefresher;
+    private StringMessages stringMessages;
+    private List<EventDTO> existingEvents;
+
+    public CreateRegattaCallback(SailingServiceAsync sailingService, StringMessages stringMessages, ErrorReporter errorReporter, RegattaRefresher regattaRefresher, List<EventDTO> existingEvents) {
+        this.sailingService = sailingService;
+        this.errorReporter = errorReporter;
+        this.regattaRefresher = regattaRefresher;
+        this.stringMessages = stringMessages;
+        this.existingEvents = existingEvents;
+    }
+    
+    @Override
+    public void ok(RegattaDTO newRegatta) {
+        createNewRegatta(newRegatta, existingEvents);
+    }
+
+    @Override
+    public void cancel() {
+        // TODO Auto-generated method stub
+        
+    }
+
+
+    private void createNewRegatta(final RegattaDTO newRegatta, final List<EventDTO> existingEvents) {
+        LinkedHashMap<String, SeriesCreationParametersDTO> seriesStructure = new LinkedHashMap<String, SeriesCreationParametersDTO>();
+        for (SeriesDTO seriesDTO : newRegatta.series) {
+            SeriesCreationParametersDTO seriesPair = new SeriesCreationParametersDTO(seriesDTO.getFleets(),
+                    seriesDTO.isMedal(), seriesDTO.isStartsWithZeroScore(),
+                    seriesDTO.isFirstColumnIsNonDiscardableCarryForward(), seriesDTO.getDiscardThresholds(),
+                    seriesDTO.hasSplitFleetContiguousScoring());
+            seriesStructure.put(seriesDTO.getName(), seriesPair);
+        }
+        sailingService.createRegatta(newRegatta.getName(), newRegatta.boatClass==null?null:newRegatta.boatClass.getName(),
+                newRegatta.startDate, newRegatta.endDate, 
+                new RegattaCreationParametersDTO(seriesStructure), true,
+                newRegatta.scoringScheme, newRegatta.defaultCourseAreaUuid, newRegatta.useStartTimeInference,
+                newRegatta.rankingMetricType, new AsyncCallback<RegattaDTO>() {
+            @Override
+            public void onFailure(Throwable t) {
+                errorReporter.reportError("Error trying to create new regatta " + newRegatta.getName() + ": " + t.getMessage());
+            }
+
+            @Override
+            public void onSuccess(RegattaDTO regatta) {
+                fillRegattas();
+                openCreateDefaultRegattaLeaderboardDialog(regatta, existingEvents);
+            }
+        });
+        
+        createDefaultRacesIfDefaultSeriesIsPresent(newRegatta);
+    }
+
+    private void createDefaultRacesIfDefaultSeriesIsPresent(final RegattaDTO newRegatta) {
+        for (final SeriesDTO series: newRegatta.series) {
+            if (series.getName().equals(Series.DEFAULT_NAME) && !series.getRaceColumns().isEmpty()){
+                // TODO see bug 1447: the resulting order currently doesn't necessarily match the order of races in this dialog!
+                int insertIndex = 0;
+                final List<Pair<String, Integer>> raceColumnNamesToAddWithInsertIndex = new ArrayList<>();
+                
+                for (RaceColumnDTO newRaceColumn : series.getRaceColumns()) {
+                    raceColumnNamesToAddWithInsertIndex.add(new Pair<>(newRaceColumn.getName(), insertIndex));
+                    insertIndex++;
+                }
+
+                sailingService.addRaceColumnsToSeries(newRegatta.getRegattaIdentifier(), series.getName(), raceColumnNamesToAddWithInsertIndex,
+                        new AsyncCallback<List<RaceColumnInSeriesDTO>>() {
+                    @Override
+                    public void onFailure(Throwable caught) {
+                        errorReporter.reportError("Error trying to add race columns " + raceColumnNamesToAddWithInsertIndex
+                                + " to series " + series.getName() + ": " + caught.getMessage());
+                    }
+
+                    @Override
+                    public void onSuccess(List<RaceColumnInSeriesDTO> raceColumns) {
+                        fillRegattas();
+                    }
+                });
+            }
+        }
+    }
+    
+    private void fillRegattas() {
+        if (regattaRefresher != null){
+            regattaRefresher.fillRegattas();
+        }
+    }
+    
+    private void openCreateDefaultRegattaLeaderboardDialog(final RegattaDTO newRegatta, final List<EventDTO> existingEvents) {
+        CreateDefaultRegattaLeaderboardDialog dialog = new CreateDefaultRegattaLeaderboardDialog(sailingService, stringMessages, errorReporter, newRegatta, new DialogCallback<RegattaIdentifier>() {
+            @Override
+            public void ok(RegattaIdentifier regattaIdentifier) {
+                sailingService.createRegattaLeaderboard(regattaIdentifier, /* displayName */ null, new int[]{},
+                        new AsyncCallback<StrippedLeaderboardDTO>() {
+                    @Override
+                    public void onFailure(Throwable t) {
+                        errorReporter.reportError("Error trying to create default regatta leaderboard for " + newRegatta.getName()
+                                + ": " + t.getMessage());
+                    }
+
+                    @Override
+                    public void onSuccess(StrippedLeaderboardDTO result) {
+                        if (newRegatta.defaultCourseAreaUuid != null) {
+                            // Show the event's leaderboard groups and allow the user to pick one to assign the regatta leaderboard to
+                            final EventDTO event = getEventForCourseArea(existingEvents, newRegatta.defaultCourseAreaUuid);
+                            if (!event.getLeaderboardGroups().isEmpty()) {
+                                openRegattaLeaderboardToLeaderboardGroupOfEventLinkingDialog(result, event);
+                            }
+                        }
+                    }
+
+                });
+            }
+
+            @Override
+            public void cancel() {
+            }
+        });
+        dialog.ensureDebugId("CreateDefaultRegattaDialog");
+        dialog.show();
+    }
+    
+    
+    /**
+     * When a new regatta with a new regatta leaderboard has been created, the user will now be given the chance to link
+     * the regatta leaderboard into a leaderboard group of the event out of which the regatta chose its default course area.
+     * 
+     * @param newRegattaLeaderboard the new regatta leaderboard that the user may link now to a leaderboard group of an event
+     * @param eventToLinkRegattaTo an event that has at least one {@link EventDTO#getLeaderboardGroups() leaderboard group}
+     */
+    private void openRegattaLeaderboardToLeaderboardGroupOfEventLinkingDialog(final StrippedLeaderboardDTO newRegattaLeaderboard, EventDTO eventToLinkRegattaTo) {
+        LinkRegattaLeaderboardToLeaderboardGroupOfEventDialog dialog = new LinkRegattaLeaderboardToLeaderboardGroupOfEventDialog(sailingService, stringMessages, errorReporter, newRegattaLeaderboard, eventToLinkRegattaTo,
+                new DialogCallback<LeaderboardGroupDTO>() {
+                    @Override
+                    public void ok(final LeaderboardGroupDTO selectedLeaderboardGroup) {
+                        final List<String> leaderboardNames = new ArrayList<>();
+                        for (StrippedLeaderboardDTO leaderboard : selectedLeaderboardGroup.getLeaderboards()) {
+                            leaderboardNames.add(leaderboard.name);
+                        }
+                        leaderboardNames.add(newRegattaLeaderboard.name);
+                        sailingService.updateLeaderboardGroup(selectedLeaderboardGroup.getName(), selectedLeaderboardGroup.getName(), selectedLeaderboardGroup.description,
+                                selectedLeaderboardGroup.getDisplayName(), leaderboardNames, selectedLeaderboardGroup.getOverallLeaderboardDiscardThresholds(),
+                                selectedLeaderboardGroup.getOverallLeaderboardScoringSchemeType(), new MarkedAsyncCallback<Void>(new AsyncCallback<Void>() {
+                                    @Override
+                                    public void onFailure(Throwable caught) {
+                                        errorReporter.reportError(stringMessages.failedToLinkLeaderboardToLeaderboardGroup(newRegattaLeaderboard.name, selectedLeaderboardGroup.getName()));
+                                    }
+
+                                    @Override
+                                    public void onSuccess(Void result) {
+                                    }
+                                }));
+                    }
+
+                    @Override
+                    public void cancel() {
+                    }
+        });
+        dialog.ensureDebugId("LinkRegattaLeaderboardToLeaderboardGroupOfEventDialog");
+        dialog.show();
+    }
+
+    private EventDTO getEventForCourseArea(final List<EventDTO> existingEvents, final UUID courseAreaId) {
+        EventDTO result = null;
+        eventLoop:
+        for (final EventDTO event : existingEvents) {
+            if (event.venue != null) {
+                for (CourseAreaDTO courseArea : event.venue.getCourseAreas()) {
+                    if (courseArea.id.equals(courseAreaId)) {
+                        result = event;
+                        break eventLoop;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

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

@@ -19,7 +19,7 @@ public class DefaultRegattaCreateDialog extends AbstractRegattaWithSeriesAndFlee
     public DefaultRegattaCreateDialog(List<EventDTO> existingEvents, RegattaDTO selectedRegatta,
             SailingServiceAsync sailingService, ErrorReporter errorReporter, StringMessages stringMessages,
             com.sap.sse.gwt.client.dialog.DataEntryDialog.DialogCallback<EventAndRegattaDTO> callback) {
-        super(selectedRegatta, selectedRegatta.series, existingEvents, stringMessages.createDefaultSettingsForAllRegattas(),
+        super(selectedRegatta, selectedRegatta.series, existingEvents, null, stringMessages.createDefaultSettingsForAllRegattas(),
                 stringMessages.ok(), stringMessages, null /* RegattaParameterValidator */, callback);
         if (existingEvents != null && !existingEvents.isEmpty()) {
             sailingEventsListBox.addItem((existingEvents.get(0)).getName());

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

@@ -447,11 +447,69 @@ public class EventListComposite extends Composite implements EventsRefresher, Le
             @Override
             public void ok(final EventDTO newEvent) {
                 createNewEvent(newEvent, existingLeaderboardGroups);
+                openCreateDefaultRegattaDialog(newEvent);
             }
         });
         dialog.show();
     }
     
+    private void openCreateDefaultRegattaDialog(final EventDTO createdEvent) {
+        CreateDefaultRegattaDialog dialog = new CreateDefaultRegattaDialog(sailingService, stringMessages, errorReporter, new DialogCallback<Void>() {
+            @Override
+            public void cancel() {
+            }
+
+            @Override
+            public void ok(Void editedObject) {
+                sailingService.getRegattas(new AsyncCallback<List<RegattaDTO>>() {
+
+                    @Override
+                    public void onFailure(Throwable caught) {
+                        sailingService.getEvents(new AsyncCallback<List<EventDTO>>() {
+                            @Override
+                            public void onFailure(Throwable caught) {
+                                openCreateRegattaDialog(Collections.<RegattaDTO>emptyList(), Collections.<EventDTO>emptyList(), createdEvent);
+                            }
+
+                            @Override
+                            public void onSuccess(List<EventDTO> result) {
+                                openCreateRegattaDialog(Collections.<RegattaDTO>emptyList(), Collections.unmodifiableList(result), createdEvent);
+                            }
+                        });
+
+                    }
+
+                    @Override
+                    public void onSuccess(final List<RegattaDTO> existingRegattas) {
+                        sailingService.getEvents(new AsyncCallback<List<EventDTO>>() {
+                            @Override
+                            public void onFailure(Throwable caught) {
+                                openCreateRegattaDialog(existingRegattas, Collections.<EventDTO>emptyList(), createdEvent);
+                            }
+
+                            @Override
+                            public void onSuccess(List<EventDTO> result) {
+                                openCreateRegattaDialog(existingRegattas, Collections.unmodifiableList(result), createdEvent);
+                            }
+                        });                        
+                    }
+                });
+                                
+                
+            }
+        });
+        dialog.ensureDebugId("CreateDefaultRegattaDialog");
+        dialog.show();
+    }
+    
+    private void openCreateRegattaDialog(List<RegattaDTO> existingRegattas,
+            List<EventDTO> existingEvents, EventDTO createdEvent) {
+        RegattaWithSeriesAndFleetsCreateDialog dialog = new RegattaWithSeriesAndFleetsCreateDialog(existingRegattas, existingEvents, createdEvent, stringMessages,
+                new CreateRegattaCallback(sailingService, stringMessages, errorReporter, null, existingEvents));
+        dialog.ensureDebugId("RegattaCreateDialog");
+        dialog.show();
+    }
+    
     /**
      * @param newEvent the new event as created by the server, already including a valid {@link EventBaseDTO#id} value.
      */

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

@@ -272,7 +272,7 @@ public class RegattaListComposite extends Composite implements RegattasDisplayer
     private void openEditRegattaDialog(RegattaDTO regatta, Collection<RegattaDTO> existingRegattas,
             List<EventDTO> existingEvents) {
         RegattaWithSeriesAndFleetsDialog dialog = new RegattaWithSeriesAndFleetsEditDialog(regatta, existingRegattas,
-                existingEvents, stringMessages, new DialogCallback<RegattaDTO>() {
+                existingEvents, /*correspondingEvent*/ null, stringMessages, new DialogCallback<RegattaDTO>() {
                     @Override
                     public void cancel() {
                     }

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

@@ -4,9 +4,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.UUID;
 
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
@@ -19,27 +17,15 @@ import com.google.gwt.user.client.ui.SimplePanel;
 import com.google.gwt.user.client.ui.VerticalPanel;
 import com.google.gwt.view.client.SelectionChangeEvent;
 import com.google.gwt.view.client.SelectionChangeEvent.Handler;
-import com.sap.sailing.domain.base.Series;
 import com.sap.sailing.domain.common.RegattaIdentifier;
-import com.sap.sailing.domain.common.dto.RaceColumnDTO;
-import com.sap.sailing.domain.common.dto.RaceColumnInSeriesDTO;
-import com.sap.sailing.domain.common.dto.RegattaCreationParametersDTO;
-import com.sap.sailing.domain.common.dto.SeriesCreationParametersDTO;
 import com.sap.sailing.gwt.ui.client.RegattaRefresher;
 import com.sap.sailing.gwt.ui.client.RegattasDisplayer;
 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.LeaderboardGroupDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaDTO;
-import com.sap.sailing.gwt.ui.shared.SeriesDTO;
-import com.sap.sailing.gwt.ui.shared.StrippedLeaderboardDTO;
-import com.sap.sse.common.Util.Pair;
 import com.sap.sse.gwt.client.ErrorReporter;
-import com.sap.sse.gwt.client.async.MarkedAsyncCallback;
 import com.sap.sse.gwt.client.celltable.RefreshableMultiSelectionModel;
-import com.sap.sse.gwt.client.dialog.DataEntryDialog.DialogCallback;
 
 /**
  * Allows administrators to manage the structure of a regatta. Each regatta consists of several substructures like
@@ -176,167 +162,11 @@ public class RegattaManagementPanel extends SimplePanel implements RegattasDispl
     }
 
     private void openCreateRegattaDialog(Collection<RegattaDTO> existingRegattas, final List<EventDTO> existingEvents) {
-        RegattaWithSeriesAndFleetsCreateDialog dialog = new RegattaWithSeriesAndFleetsCreateDialog(existingRegattas, existingEvents, stringMessages,
-                new DialogCallback<RegattaDTO>() {
-            @Override
-            public void cancel() {
-            }
-
-            @Override
-            public void ok(RegattaDTO newRegatta) {
-                createNewRegatta(newRegatta, existingEvents);
-            }
-        });
+        RegattaWithSeriesAndFleetsCreateDialog dialog = new RegattaWithSeriesAndFleetsCreateDialog(existingRegattas, existingEvents, /*eventToSelect*/ null, stringMessages,
+                new CreateRegattaCallback(sailingService, stringMessages, errorReporter, regattaRefresher, existingEvents));
         dialog.ensureDebugId("RegattaCreateDialog");
         dialog.show();
     }
-    
-    private void openCreateDefaultRegattaLeaderboardDialog(final RegattaDTO newRegatta, final List<EventDTO> existingEvents) {
-        CreateDefaultRegattaLeaderboardDialog dialog = new CreateDefaultRegattaLeaderboardDialog(sailingService, stringMessages, errorReporter, newRegatta, new DialogCallback<RegattaIdentifier>() {
-            @Override
-            public void ok(RegattaIdentifier regattaIdentifier) {
-                sailingService.createRegattaLeaderboard(regattaIdentifier, /* displayName */ null, new int[]{},
-                        new AsyncCallback<StrippedLeaderboardDTO>() {
-                    @Override
-                    public void onFailure(Throwable t) {
-                        errorReporter.reportError("Error trying to create default regatta leaderboard for " + newRegatta.getName()
-                                + ": " + t.getMessage());
-                    }
-
-                    @Override
-                    public void onSuccess(StrippedLeaderboardDTO result) {
-                        if (newRegatta.defaultCourseAreaUuid != null) {
-                            // Show the event's leaderboard groups and allow the user to pick one to assign the regatta leaderboard to
-                            final EventDTO event = getEventForCourseArea(existingEvents, newRegatta.defaultCourseAreaUuid);
-                            if (!event.getLeaderboardGroups().isEmpty()) {
-                                openRegattaLeaderboardToLeaderboardGroupOfEventLinkingDialog(result, event);
-                            }
-                        }
-                    }
-
-                });
-            }
-
-            @Override
-            public void cancel() {
-            }
-        });
-        dialog.ensureDebugId("CreateDefaultRegattaDialog");
-        dialog.show();
-    }
-    
-    /**
-     * When a new regatta with a new regatta leaderboard has been created, the user will now be given the chance to link
-     * the regatta leaderboard into a leaderboard group of the event out of which the regatta chose its default course area.
-     * 
-     * @param newRegattaLeaderboard the new regatta leaderboard that the user may link now to a leaderboard group of an event
-     * @param eventToLinkRegattaTo an event that has at least one {@link EventDTO#getLeaderboardGroups() leaderboard group}
-     */
-    private void openRegattaLeaderboardToLeaderboardGroupOfEventLinkingDialog(final StrippedLeaderboardDTO newRegattaLeaderboard, EventDTO eventToLinkRegattaTo) {
-        LinkRegattaLeaderboardToLeaderboardGroupOfEventDialog dialog = new LinkRegattaLeaderboardToLeaderboardGroupOfEventDialog(sailingService, stringMessages, errorReporter, newRegattaLeaderboard, eventToLinkRegattaTo,
-                new DialogCallback<LeaderboardGroupDTO>() {
-                    @Override
-                    public void ok(final LeaderboardGroupDTO selectedLeaderboardGroup) {
-                        final List<String> leaderboardNames = new ArrayList<>();
-                        for (StrippedLeaderboardDTO leaderboard : selectedLeaderboardGroup.getLeaderboards()) {
-                            leaderboardNames.add(leaderboard.name);
-                        }
-                        leaderboardNames.add(newRegattaLeaderboard.name);
-                        sailingService.updateLeaderboardGroup(selectedLeaderboardGroup.getName(), selectedLeaderboardGroup.getName(), selectedLeaderboardGroup.description,
-                                selectedLeaderboardGroup.getDisplayName(), leaderboardNames, selectedLeaderboardGroup.getOverallLeaderboardDiscardThresholds(),
-                                selectedLeaderboardGroup.getOverallLeaderboardScoringSchemeType(), new MarkedAsyncCallback<Void>(new AsyncCallback<Void>() {
-                                    @Override
-                                    public void onFailure(Throwable caught) {
-                                        errorReporter.reportError(stringMessages.failedToLinkLeaderboardToLeaderboardGroup(newRegattaLeaderboard.name, selectedLeaderboardGroup.getName()));
-                                    }
-
-                                    @Override
-                                    public void onSuccess(Void result) {
-                                    }
-                                }));
-                    }
-
-                    @Override
-                    public void cancel() {
-                    }
-        });
-        dialog.ensureDebugId("LinkRegattaLeaderboardToLeaderboardGroupOfEventDialog");
-        dialog.show();
-    }
-
-    private EventDTO getEventForCourseArea(final List<EventDTO> existingEvents, final UUID courseAreaId) {
-        EventDTO result = null;
-        eventLoop:
-        for (final EventDTO event : existingEvents) {
-            if (event.venue != null) {
-                for (CourseAreaDTO courseArea : event.venue.getCourseAreas()) {
-                    if (courseArea.id.equals(courseAreaId)) {
-                        result = event;
-                        break eventLoop;
-                    }
-                }
-            }
-        }
-        return result;
-    }
-
-    private void createNewRegatta(final RegattaDTO newRegatta, final List<EventDTO> existingEvents) {
-        LinkedHashMap<String, SeriesCreationParametersDTO> seriesStructure = new LinkedHashMap<String, SeriesCreationParametersDTO>();
-        for (SeriesDTO seriesDTO : newRegatta.series) {
-            SeriesCreationParametersDTO seriesPair = new SeriesCreationParametersDTO(seriesDTO.getFleets(),
-                    seriesDTO.isMedal(), seriesDTO.isStartsWithZeroScore(),
-                    seriesDTO.isFirstColumnIsNonDiscardableCarryForward(), seriesDTO.getDiscardThresholds(),
-                    seriesDTO.hasSplitFleetContiguousScoring());
-            seriesStructure.put(seriesDTO.getName(), seriesPair);
-        }
-        sailingService.createRegatta(newRegatta.getName(), newRegatta.boatClass==null?null:newRegatta.boatClass.getName(),
-                newRegatta.startDate, newRegatta.endDate, 
-                new RegattaCreationParametersDTO(seriesStructure), true,
-                newRegatta.scoringScheme, newRegatta.defaultCourseAreaUuid, newRegatta.useStartTimeInference,
-                newRegatta.rankingMetricType, new AsyncCallback<RegattaDTO>() {
-            @Override
-            public void onFailure(Throwable t) {
-                errorReporter.reportError("Error trying to create new regatta " + newRegatta.getName() + ": " + t.getMessage());
-            }
-
-            @Override
-            public void onSuccess(RegattaDTO regatta) {
-                regattaRefresher.fillRegattas();
-                openCreateDefaultRegattaLeaderboardDialog(regatta, existingEvents);
-            }
-        });
-        
-        createDefaultRacesIfDefaultSeriesIsPresent(newRegatta);
-    }
-
-    private void createDefaultRacesIfDefaultSeriesIsPresent(final RegattaDTO newRegatta) {
-        for (final SeriesDTO series: newRegatta.series) {
-            if (series.getName().equals(Series.DEFAULT_NAME) && !series.getRaceColumns().isEmpty()){
-                // TODO see bug 1447: the resulting order currently doesn't necessarily match the order of races in this dialog!
-                int insertIndex = 0;
-                final List<Pair<String, Integer>> raceColumnNamesToAddWithInsertIndex = new ArrayList<>();
-                
-                for (RaceColumnDTO newRaceColumn : series.getRaceColumns()) {
-                    raceColumnNamesToAddWithInsertIndex.add(new Pair<>(newRaceColumn.getName(), insertIndex));
-                    insertIndex++;
-                }
-
-                sailingService.addRaceColumnsToSeries(newRegatta.getRegattaIdentifier(), series.getName(), raceColumnNamesToAddWithInsertIndex,
-                        new AsyncCallback<List<RaceColumnInSeriesDTO>>() {
-                    @Override
-                    public void onFailure(Throwable caught) {
-                        errorReporter.reportError("Error trying to add race columns " + raceColumnNamesToAddWithInsertIndex
-                                + " to series " + series.getName() + ": " + caught.getMessage());
-                    }
-
-                    @Override
-                    public void onSuccess(List<RaceColumnInSeriesDTO> raceColumns) {
-                        regattaRefresher.fillRegattas();
-                    }
-                });
-            }
-        }
-    }
 
     @Override
     public void fillRegattas(Iterable<RegattaDTO> regattas) {

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

@@ -105,8 +105,8 @@ public class RegattaWithSeriesAndFleetsCreateDialog extends RegattaWithSeriesAnd
     }
 
     public RegattaWithSeriesAndFleetsCreateDialog(Collection<RegattaDTO> existingRegattas,
-            List<EventDTO> existingEvents, StringMessages stringMessages, DialogCallback<RegattaDTO> callback) {
-        super(new RegattaDTO(), Collections.<SeriesDTO>emptySet(), existingEvents, stringMessages.addRegatta(), stringMessages.ok(),
+            List<EventDTO> existingEvents, EventDTO correspondingEvent, StringMessages stringMessages, DialogCallback<RegattaDTO> callback) {
+        super(new RegattaDTO(), Collections.<SeriesDTO>emptySet(), existingEvents, correspondingEvent, stringMessages.addRegatta(), stringMessages.ok(),
                 stringMessages, new RegattaParameterValidator(stringMessages, existingRegattas), callback);
         SeriesDTO series = new SeriesDTO();
         series.setName(Series.DEFAULT_NAME);

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

@@ -20,10 +20,10 @@ public abstract class RegattaWithSeriesAndFleetsDialog extends AbstractRegattaWi
     protected TextBox nameEntryField;
     protected SuggestBox boatClassEntryField;
 
-    public RegattaWithSeriesAndFleetsDialog(RegattaDTO regatta, Iterable<SeriesDTO> series, List<EventDTO> existingEvents,
+    public RegattaWithSeriesAndFleetsDialog(RegattaDTO regatta, Iterable<SeriesDTO> series, List<EventDTO> existingEvents, EventDTO defaultEvent,
             String title, String okButton, StringMessages stringMessages,
             Validator<RegattaDTO> validator, DialogCallback<RegattaDTO> callback) {
-        super(regatta, series, existingEvents, title, okButton, stringMessages, validator, callback);
+        super(regatta, series, existingEvents, defaultEvent, title, okButton, stringMessages, validator, callback);
         this.stringMessages = stringMessages;
         nameEntryField = createTextBox(null);
         nameEntryField.ensureDebugId("NameTextBox");

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

@@ -25,8 +25,8 @@ public class RegattaWithSeriesAndFleetsEditDialog extends RegattaWithSeriesAndFl
     private RegattaConfigurationDTO currentRegattaConfiguration;
 
     public RegattaWithSeriesAndFleetsEditDialog(RegattaDTO regatta, Collection<RegattaDTO> existingRegattas,
-            List<EventDTO> existingEvents, final StringMessages stringMessages, DialogCallback<RegattaDTO> callback) {
-        super(regatta, regatta.series, existingEvents, stringMessages.editRegatta(), stringMessages.ok(), stringMessages,
+            List<EventDTO> existingEvents, EventDTO correspondingEvent, final StringMessages stringMessages, DialogCallback<RegattaDTO> callback) {
+        super(regatta, regatta.series, existingEvents, correspondingEvent, stringMessages.editRegatta(), stringMessages.ok(), stringMessages,
                 null, callback);
         ensureDebugId("RegattaWithSeriesAndFleetsEditDialog");
         currentRegattaConfiguration = regatta.configuration;

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

@@ -1482,4 +1482,6 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages, c
     String linkLeaderboardToLeaderboardGroupOfEvent();
     String doYouWantToLinkLeaderboardToLeaderboardGroupOfEvent(String leaderboardName, String eventName);
     String failedToLinkLeaderboardToLeaderboardGroup(String leaderboardName, String leaderboardGroupName);
+    String createDefaultRegatta();
+    String doYouWantToCreateADefaultRegatta();
 }

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

@@ -1449,4 +1449,6 @@ enterDeviceIdentifierName=Enter an identifier name
 pleaseSelectALeaderboardGroup=Please select a leaderboard group
 linkLeaderboardToLeaderboardGroupOfEvent=Link Leaderboard to Leaderboard Group of Event
 doYouWantToLinkLeaderboardToLeaderboardGroupOfEvent=Link leaderboard {0} to a leaderboard group of event {1}
-failedToLinkLeaderboardToLeaderboardGroup=Failed to link leaderboard {0} to leaderboard group {1}
+failedToLinkLeaderboardToLeaderboardGroup=Failed to link leaderboard {0} to leaderboard group {1}
+createDefaultRegatta=Create default regatta
+doYouWantToCreateADefaultRegatta=Do you want to create a default Regatta?

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

@@ -1439,4 +1439,6 @@ enterDeviceIdentifierName=Geräteidentifikator eingeben
 pleaseSelectALeaderboardGroup=Bitte eine Ranglisten-Gruppe auswählen
 linkLeaderboardToLeaderboardGroupOfEvent=Ergebnisliste einer Ranglisten-Gruppe einer Veranstaltung hinzufügen
 doYouWantToLinkLeaderboardToLeaderboardGroupOfEvent=Ergebnisliste {0} zu einer Ranglisten-Gruppe der Veranstaltung {1} hinzufügen
-failedToLinkLeaderboardToLeaderboardGroup=Ergebnisliste {0} konnte nicht in Ranglisten-Gruppe {1} eingefügt werden
+failedToLinkLeaderboardToLeaderboardGroup=Ergebnisliste {0} konnte nicht in Ranglisten-Gruppe {1} eingefügt werden
+createDefaultRegatta=Standardregatta anlegen
+doYouWantToCreateADefaultRegatta=Möchten Sie eine Standardregatta für das Event anlegen?

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

@@ -1371,4 +1371,6 @@ enterDeviceIdentifierName=Enter an identifier name
 pleaseSelectALeaderboardGroup=Please select a leaderboard group
 linkLeaderboardToLeaderboardGroupOfEvent=Link Leaderboard to Leaderboard Group of Event
 doYouWantToLinkLeaderboardToLeaderboardGroupOfEvent=Link leaderboard {0} to a leaderboard group of event {1}
-failedToLinkLeaderboardToLeaderboardGroup=Failed to link leaderboard {0} to leaderboard group {1}
+failedToLinkLeaderboardToLeaderboardGroup=Failed to link leaderboard {0} to leaderboard group {1}
+createDefaultRegatta=Create default regatta
+doYouWantToCreateADefaultRegatta=Do you want to create a default Regatta?

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

@@ -1386,4 +1386,6 @@ enterDeviceIdentifierName=Enter an identifier name
 pleaseSelectALeaderboardGroup=Please select a leaderboard group
 linkLeaderboardToLeaderboardGroupOfEvent=Link Leaderboard to Leaderboard Group of Event
 doYouWantToLinkLeaderboardToLeaderboardGroupOfEvent=Link leaderboard {0} to a leaderboard group of event {1}
-failedToLinkLeaderboardToLeaderboardGroup=Failed to link leaderboard {0} to leaderboard group {1}
+failedToLinkLeaderboardToLeaderboardGroup=Failed to link leaderboard {0} to leaderboard group {1}
+createDefaultRegatta=Create default regatta
+doYouWantToCreateADefaultRegatta=Do you want to create a default Regatta?