Merge branch 'nondiscardablecarryforward'

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/dto/RegattaCreationParametersDTO.java

@@ -0,0 +1,20 @@
+package com.sap.sailing.domain.common.dto;
+
+import java.io.Serializable;
+import java.util.LinkedHashMap;
+
+public class RegattaCreationParametersDTO implements Serializable {
+    private static final long serialVersionUID = 6852529475564779063L;
+    private LinkedHashMap<String, SeriesCreationParametersDTO> seriesCreationParameters;
+
+    RegattaCreationParametersDTO() {}
+    
+    public RegattaCreationParametersDTO(LinkedHashMap<String, SeriesCreationParametersDTO> seriesCreationParameters) {
+        super();
+        this.seriesCreationParameters = seriesCreationParameters;
+    }
+
+    public LinkedHashMap<String, SeriesCreationParametersDTO> getSeriesCreationParameters() {
+        return seriesCreationParameters;
+    }
+}

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/dto/SeriesCreationParametersDTO.java

@@ -0,0 +1,51 @@
+package com.sap.sailing.domain.common.dto;
+
+import java.io.Serializable;
+import java.util.List;
+
+public class SeriesCreationParametersDTO implements Serializable {
+    private static final long serialVersionUID = -3205172230707607515L;
+
+    private List<FleetDTO> fleets;
+
+    private boolean medal;
+
+    private boolean startsWithZero;
+    
+    private boolean firstColumnIsNonDiscardableCarryForward;
+
+    private int[] discardingThresholds;
+    
+    SeriesCreationParametersDTO() {}
+
+    public SeriesCreationParametersDTO(List<FleetDTO> fleets, boolean medal, boolean startsWithZero, boolean firstColumnIsNonDiscardableCarryForward,
+            int[] discardingThresholds) {
+        super();
+        this.fleets = fleets;
+        this.medal = medal;
+        this.startsWithZero = startsWithZero;
+        this.firstColumnIsNonDiscardableCarryForward = firstColumnIsNonDiscardableCarryForward;
+        this.discardingThresholds = discardingThresholds;
+    }
+
+    public List<FleetDTO> getFleets() {
+        return fleets;
+    }
+
+    public boolean isMedal() {
+        return medal;
+    }
+
+    public boolean isStartsWithZero() {
+        return startsWithZero;
+    }
+
+    public int[] getDiscardingThresholds() {
+        return discardingThresholds;
+    }
+
+    public boolean isFirstColumnIsNonDiscardableCarryForward() {
+        return firstColumnIsNonDiscardableCarryForward;
+    }
+    
+}

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/impl/DelayedLeaderboardCorrectionsImpl.java

@@ -379,6 +379,10 @@ public class DelayedLeaderboardCorrectionsImpl implements DelayedLeaderboardCorr
     public void isStartsWithZeroScoreChanged(RaceColumn raceColumn, boolean newIsStartsWithZeroScore) {
     }
 
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+    }
+
     @Override
     public boolean canAddRaceColumnToContainer(RaceColumn raceColumn) {
         return true;

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/impl/DomainObjectFactoryImpl.java

@@ -318,14 +318,19 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
      */
     private ThresholdBasedResultDiscardingRule loadResultDiscardingRule(DBObject dbObject, FieldNames field) {
         BasicDBList dbDiscardIndexResultsStartingWithHowManyRaces = (BasicDBList) dbObject.get(field.name());
-        int[] discardIndexResultsStartingWithHowManyRaces = new int[dbDiscardIndexResultsStartingWithHowManyRaces.size()];
-        int i = 0;
-        for (Object discardingThresholdAsObject : dbDiscardIndexResultsStartingWithHowManyRaces) {
-            discardIndexResultsStartingWithHowManyRaces[i++] = (Integer) discardingThresholdAsObject;
+        final ThresholdBasedResultDiscardingRule result;
+        if (dbDiscardIndexResultsStartingWithHowManyRaces == null) {
+            result = null;
+        } else {
+            int[] discardIndexResultsStartingWithHowManyRaces = new int[dbDiscardIndexResultsStartingWithHowManyRaces
+                    .size()];
+            int i = 0;
+            for (Object discardingThresholdAsObject : dbDiscardIndexResultsStartingWithHowManyRaces) {
+                discardIndexResultsStartingWithHowManyRaces[i++] = (Integer) discardingThresholdAsObject;
+            }
+            result = new ThresholdBasedResultDiscardingRuleImpl(discardIndexResultsStartingWithHowManyRaces);
         }
-        ThresholdBasedResultDiscardingRule resultDiscardingRule = new ThresholdBasedResultDiscardingRuleImpl(
-                discardIndexResultsStartingWithHowManyRaces);
-        return resultDiscardingRule;
+        return result;
     }
 
     private CourseArea loadCourseAreaFromEvents(DBObject dbObject) {
@@ -907,6 +912,7 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
         String name = (String) dbSeries.get(FieldNames.SERIES_NAME.name());
         boolean isMedal = (Boolean) dbSeries.get(FieldNames.SERIES_IS_MEDAL.name());
         Boolean startsWithZeroScore = (Boolean) dbSeries.get(FieldNames.SERIES_STARTS_WITH_ZERO_SCORE.name());
+        Boolean firstColumnIsNonDiscardableCarryForward = (Boolean) dbSeries.get(FieldNames.SERIES_STARTS_WITH_NON_DISCARDABLE_CARRY_FORWARD.name());
         final BasicDBList dbFleets = (BasicDBList) dbSeries.get(FieldNames.SERIES_FLEETS.name());
         Map<String, Fleet> fleetsByName = loadFleets(dbFleets);
         BasicDBList dbRaceColumns = (BasicDBList) dbSeries.get(FieldNames.SERIES_RACE_COLUMNS.name());
@@ -919,6 +925,9 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
         if (startsWithZeroScore != null) {
             series.setStartsWithZeroScore(startsWithZeroScore);
         }
+        if (firstColumnIsNonDiscardableCarryForward != null) {
+            series.setFirstColumnIsNonDiscardableCarryForward(firstColumnIsNonDiscardableCarryForward);
+        }
         loadRaceColumnRaceLinks(dbRaceColumns, series);
         return series;
     }

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/impl/FieldNames.java

@@ -21,6 +21,7 @@ public enum FieldNames {
     SERIES_NAME,
     SERIES_IS_MEDAL,
     SERIES_STARTS_WITH_ZERO_SCORE,
+    SERIES_STARTS_WITH_NON_DISCARDABLE_CARRY_FORWARD,
     SERIES_FLEETS,
     SERIES_RACE_COLUMNS,
     SERIES_DISCARDING_THRESHOLDS,

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/impl/MongoObjectFactoryImpl.java

@@ -477,6 +477,7 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
         dbSeries.put(FieldNames.SERIES_NAME.name(), s.getName());
         dbSeries.put(FieldNames.SERIES_IS_MEDAL.name(), s.isMedal());
         dbSeries.put(FieldNames.SERIES_STARTS_WITH_ZERO_SCORE.name(), s.isStartsWithZeroScore());
+        dbSeries.put(FieldNames.SERIES_STARTS_WITH_NON_DISCARDABLE_CARRY_FORWARD.name(), s.isFirstColumnIsNonDiscardableCarryForward());
         BasicDBList dbFleets = new BasicDBList();
         for (Fleet fleet : s.getFleets()) {
             dbFleets.add(storeFleet(fleet));

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

@@ -157,6 +157,8 @@ public interface RaceColumn extends Named {
      * the total points at this column with zero.
      */
     boolean isStartsWithZeroScore();
+    
+    boolean isDiscardable();
 
     /**
      * @param factor if <code>null</code>, {@link #getFactor()} will again compute a default value; otherwise, {@link #getFactor()} will

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

@@ -16,6 +16,8 @@ public interface RaceColumnListener extends Serializable {
     
     void isStartsWithZeroScoreChanged(RaceColumn raceColumn, boolean newIsStartsWithZeroScore);
     
+    void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward);
+
     boolean canAddRaceColumnToContainer(RaceColumn raceColumn);
     
     void raceColumnAddedToContainer(RaceColumn raceColumn);
@@ -43,4 +45,5 @@ public interface RaceColumnListener extends Serializable {
      * exclude listeners from the serialization that return <code>true</code> from this method.
      */
     boolean isTransient();
+
 }

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

@@ -89,4 +89,8 @@ public interface Series extends SeriesBase {
     boolean isStartsWithZeroScore();
     
     void setStartsWithZeroScore(boolean startsWithZeroScore);
+
+    boolean isFirstColumnIsNonDiscardableCarryForward();
+
+    void setFirstColumnIsNonDiscardableCarryForward(boolean firstColumnIsNonDiscardableCarryForward);
 }

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

@@ -101,4 +101,9 @@ public class RaceColumnInSeriesImpl extends AbstractRaceColumn implements RaceCo
     public boolean isStartsWithZeroScore() {
         return getSeries().isStartsWithZeroScore() && isFirstColumnInSeries();
     }
+
+    @Override
+    public boolean isDiscardable() {
+        return !isMedalRace() && (!isFirstColumnInSeries() || !getSeries().isFirstColumnIsNonDiscardableCarryForward());
+    }
 }

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

@@ -273,6 +273,11 @@ public class RegattaImpl extends NamedImpl implements Regatta, RaceColumnListene
         raceColumnListeners.notifyListenersAboutIsStartsWithZeroScoreChanged(raceColumn, newIsStartsWithZeroScore);
     }
 
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+        raceColumnListeners.notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(raceColumn, firstColumnIsNonDiscardableCarryForward);
+    }
+
     @Override
     public boolean canAddRaceColumnToContainer(RaceColumn raceColumn) {
         return raceColumnListeners.canAddRaceColumnToContainer(raceColumn);

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

@@ -34,8 +34,19 @@ public class SeriesImpl extends NamedImpl implements Series, RaceColumnListener
     private Regatta regatta;
     private final RaceColumnListeners raceColumnListeners;
     private ThresholdBasedResultDiscardingRule resultDiscardingRule;
+    
+    /**
+     * If set, the series doesn't take over the scores from any previous series but starts with zero scores for all its
+     * competitors
+     */
     private boolean startsWithZeroScore;
     
+    /**
+     * If set, the first race column is not discardable. This is usually very helpful if the series starts with a
+     * carry-forward score from a previous series.
+     */
+    private boolean firstColumnIsNonDiscardableCarryForward;
+    
     /**
      * @param fleets
      *            must be non-empty
@@ -238,6 +249,11 @@ public class SeriesImpl extends NamedImpl implements Series, RaceColumnListener
         raceColumnListeners.notifyListenersAboutIsStartsWithZeroScoreChanged(raceColumn, newIsStartsWithZeroScore);
     }
 
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+        raceColumnListeners.notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(raceColumn, firstColumnIsNonDiscardableCarryForward);
+    }
+
     /**
      * A series listens on its columns; individual columns, however, don't ask whether they can be added; the series itself does.
      * 
@@ -295,6 +311,11 @@ public class SeriesImpl extends NamedImpl implements Series, RaceColumnListener
 
     @Override
     public void setResultDiscardingRule(ThresholdBasedResultDiscardingRule resultDiscardingRule) {
+        ThresholdBasedResultDiscardingRule oldResultDiscardingRule = this.resultDiscardingRule;
+        if (!Util.equalsWithNull(oldResultDiscardingRule, resultDiscardingRule)) {
+            this.resultDiscardingRule = resultDiscardingRule;
+            raceColumnListeners.notifyListenersAboutResultDiscardingRuleChanged(oldResultDiscardingRule, resultDiscardingRule);
+        }
         this.resultDiscardingRule = resultDiscardingRule;
     }
 
@@ -331,4 +352,23 @@ public class SeriesImpl extends NamedImpl implements Series, RaceColumnListener
         }
     }
 
+    @Override
+    public boolean isFirstColumnIsNonDiscardableCarryForward() {
+        return firstColumnIsNonDiscardableCarryForward;
+    }
+
+    @Override
+    public void setFirstColumnIsNonDiscardableCarryForward(boolean firstColumnIsNonDiscardableCarryForward) {
+        boolean oldFirstColumnIsNonDiscardableCarryForward = this.firstColumnIsNonDiscardableCarryForward;
+        if (oldFirstColumnIsNonDiscardableCarryForward != firstColumnIsNonDiscardableCarryForward) {
+            this.firstColumnIsNonDiscardableCarryForward = firstColumnIsNonDiscardableCarryForward;
+            RaceColumn firstRaceColumnInSeries = getFirstRaceColumn();
+            if (firstRaceColumnInSeries != null) {
+                raceColumnListeners.notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(firstRaceColumnInSeries, firstColumnIsNonDiscardableCarryForward);
+            }
+        }
+        this.firstColumnIsNonDiscardableCarryForward = firstColumnIsNonDiscardableCarryForward;
+    }
+
+    
 }

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

@@ -84,4 +84,10 @@ public abstract class SimpleAbstractRaceColumn implements RaceColumn {
     public boolean isStartsWithZeroScore() {
         return false;
     }
+
+    @Override
+    public boolean isDiscardable() {
+        return !isMedalRace();
+    }
+
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/LeaderboardCacheManager.java

@@ -233,6 +233,11 @@ public class LeaderboardCacheManager {
                     removeFromCache(leaderboard);
                 }
 
+                @Override
+                public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+                    removeFromCache(leaderboard);
+                }
+
                 @Override
                 public boolean canAddRaceColumnToContainer(RaceColumn raceColumn) {
                     return true;

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/AbstractSimpleLeaderboardImpl.java

@@ -717,6 +717,11 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
         getRaceColumnListeners().notifyListenersAboutIsStartsWithZeroScoreChanged(raceColumn, newIsStartsWithZeroScore);
     }
 
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+        getRaceColumnListeners().notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(raceColumn, firstColumnIsNonDiscardableCarryForward);
+    }
+
     @Override
     public void raceColumnMoved(RaceColumn raceColumn, int newIndex) {
         getRaceColumnListeners().notifyListenersAboutRaceColumnMoved(raceColumn, newIndex);

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/RaceColumnImpl.java

@@ -56,4 +56,5 @@ public class RaceColumnImpl extends AbstractRaceColumn implements FlexibleRaceCo
     public Iterable<Fleet> getFleets() {
         return fleets;
     }
+
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/ThresholdBasedResultDiscardingRuleImpl.java

@@ -4,6 +4,7 @@ import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashSet;
@@ -48,6 +49,29 @@ public class ThresholdBasedResultDiscardingRuleImpl implements ThresholdBasedRes
     private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
         ois.defaultReadObject();
     }
+    
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + Arrays.hashCode(discardIndexResultsStartingWithHowManyRaces);
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        ThresholdBasedResultDiscardingRuleImpl other = (ThresholdBasedResultDiscardingRuleImpl) obj;
+        if (!Arrays.equals(discardIndexResultsStartingWithHowManyRaces,
+                other.discardIndexResultsStartingWithHowManyRaces))
+            return false;
+        return true;
+    }
 
     @Override
     public Set<RaceColumn> getDiscardedRaceColumns(final Competitor competitor, final Leaderboard leaderboard,
@@ -74,7 +98,7 @@ public class ThresholdBasedResultDiscardingRuleImpl implements ThresholdBasedRes
                 }
             };
             for (RaceColumn raceColumn : raceColumnsToConsider) {
-                if (!raceColumn.isMedalRace()) {
+                if (raceColumn.isDiscardable()) {
                     sortedRaces.add(raceColumn);
                 }
             }

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

@@ -126,6 +126,11 @@ public class MetaLeaderboardColumn extends SimpleAbstractRaceColumn implements R
         getRaceColumnListeners().notifyListenersAboutIsStartsWithZeroScoreChanged(raceColumn, newIsStartsWithZeroScore);
     }
 
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+        getRaceColumnListeners().notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(raceColumn, firstColumnIsNonDiscardableCarryForward);
+    }
+
     @Override
     public boolean canAddRaceColumnToContainer(RaceColumn raceColumn) {
         return getRaceColumnListeners().canAddRaceColumnToContainer(raceColumn);

java/com.sap.sailing.domain/src/com/sap/sailing/util/impl/RaceColumnListeners.java

@@ -91,6 +91,12 @@ public class RaceColumnListeners implements Serializable {
         }
     }
 
+    public void notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+        for (RaceColumnListener listener : getRaceColumnListeners()) {
+            listener.isFirstColumnIsNonDiscardableCarryForwardChanged(raceColumn, firstColumnIsNonDiscardableCarryForward);
+        }
+    }
+
     public void notifyListenersAboutRaceColumnAddedToContainer(RaceColumn raceColumn) {
         for (RaceColumnListener listener : getRaceColumnListeners()) {
             listener.raceColumnAddedToContainer(raceColumn);

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

@@ -119,6 +119,13 @@ public class RegattaDetailsComposite extends Composite {
             }
         };
 
+        TextColumn<SeriesDTO> isFirstColumnIsNonDiscardableCarryForwardColumn = new TextColumn<SeriesDTO>() {
+            @Override
+            public String getValue(SeriesDTO series) {
+                return series.isFirstColumnIsNonDiscardableCarryForward() ? stringMessages.yes() : stringMessages.no();
+            }
+        };
+
         TextColumn<SeriesDTO> racesColumn = new TextColumn<SeriesDTO>() {
             @Override
             public String getValue(SeriesDTO series) {
@@ -200,6 +207,7 @@ public class RegattaDetailsComposite extends Composite {
         table.addColumn(racesColumn, stringMessages.races());
         table.addColumn(fleetsColumn, stringMessages.fleets());
         table.addColumn(discardsColumn, stringMessages.discarding());
+        table.addColumn(isFirstColumnIsNonDiscardableCarryForwardColumn, stringMessages.firstRaceIsNonDiscardableCarryForward());
         table.addColumn(startsWithZeroScoreColumn, stringMessages.startsWithZeroScore());
         table.addColumn(seriesActionColumn, stringMessages.actions());
         
@@ -235,13 +243,15 @@ public class RegattaDetailsComposite extends Composite {
         final List<RaceColumnDTO> newRaceColumns = seriesDescriptor.getRaces();
         final boolean isMedalChanged = series.isMedal() != seriesDescriptor.isMedal();
         final boolean isStartsWithZeroScoreChanged = series.isStartsWithZeroScore() != seriesDescriptor.isStartsWithZeroScore();
+        final boolean isFirstColumnIsNonDiscardableCarryForwardChanged = series.isFirstColumnIsNonDiscardableCarryForward() != seriesDescriptor.isFirstColumnIsNonDiscardableCarryForward();
         final boolean seriesResultDiscardingThresholdsChanged = !Arrays.equals(series.getDiscardThresholds(),
-                seriesDescriptor.getResultDiscardingThresholds());
+                seriesDescriptor.getResultDiscardingThresholds());       
         final RegattaIdentifier regattaIdentifier = new RegattaName(regatta.getName());
         List<RaceColumnDTO> existingRaceColumns = series.getRaceColumns();
         final List<String> raceColumnsToAdd = new ArrayList<String>();
         final List<String> raceColumnsToRemove = new ArrayList<String>();
         
+        // TODO see bug 1447: the resulting order currently doesn't necessarily match the order of races in this dialog!
         for (RaceColumnDTO newRaceColumn : newRaceColumns) {
             if (!existingRaceColumns.contains(newRaceColumn)) {
                 raceColumnsToAdd.add(newRaceColumn.getName());
@@ -280,9 +290,10 @@ public class RegattaDetailsComposite extends Composite {
                 regattaRefresher.fillRegattas();
             }
         });
-        if (isMedalChanged || seriesResultDiscardingThresholdsChanged || isStartsWithZeroScoreChanged) {
+        if (isMedalChanged || seriesResultDiscardingThresholdsChanged || isStartsWithZeroScoreChanged || isFirstColumnIsNonDiscardableCarryForwardChanged) {
             sailingService.updateSeries(regattaIdentifier, series.getName(), seriesDescriptor.isMedal(),
                     seriesDescriptor.getResultDiscardingThresholds(), seriesDescriptor.isStartsWithZeroScore(),
+                    seriesDescriptor.isFirstColumnIsNonDiscardableCarryForward(),
                     new AsyncCallback<Void>() {
                         @Override
                         public void onFailure(Throwable caught) {

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

@@ -1,6 +1,5 @@
 package com.sap.sailing.gwt.ui.adminconsole;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedHashMap;
@@ -15,11 +14,9 @@ import com.google.gwt.user.client.ui.Grid;
 import com.google.gwt.user.client.ui.HasVerticalAlignment;
 import com.google.gwt.user.client.ui.SimplePanel;
 import com.google.gwt.user.client.ui.VerticalPanel;
-import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.RegattaIdentifier;
-import com.sap.sailing.domain.common.dto.FleetDTO;
-import com.sap.sailing.domain.common.impl.Util.Pair;
-import com.sap.sailing.domain.common.impl.Util.Triple;
+import com.sap.sailing.domain.common.dto.RegattaCreationParametersDTO;
+import com.sap.sailing.domain.common.dto.SeriesCreationParametersDTO;
 import com.sap.sailing.gwt.ui.client.DataEntryDialog.DialogCallback;
 import com.sap.sailing.gwt.ui.client.ErrorReporter;
 import com.sap.sailing.gwt.ui.client.RegattaDisplayer;
@@ -118,20 +115,15 @@ public class RegattaStructureManagementPanel extends SimplePanel implements Rega
     }
     
     private void createNewRegatta(final RegattaDTO newRegatta) {
-        LinkedHashMap<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> seriesStructure =
-                new LinkedHashMap<String, Triple<List<Triple<String,Integer,Color>>,Pair<Boolean, Boolean>,int[]>>();
+        LinkedHashMap<String, SeriesCreationParametersDTO> seriesStructure = new LinkedHashMap<String, SeriesCreationParametersDTO>();
         for (SeriesDTO seriesDTO : newRegatta.series) {
-            List<Triple<String, Integer, Color>> fleets = new ArrayList<Triple<String, Integer, Color>>();
-            for(FleetDTO fleetDTO : seriesDTO.getFleets()) {
-                Triple<String, Integer, Color> fleetTriple = new Triple<String, Integer, Color>(fleetDTO.getName(), fleetDTO.getOrderNo(), fleetDTO.getColor());
-                fleets.add(fleetTriple);
-            }
-            Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]> seriesPair =
-                    new Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>(
-                    fleets, new Pair<Boolean, Boolean>(seriesDTO.isMedal(), seriesDTO.isStartsWithZeroScore()), seriesDTO.getDiscardThresholds());
+            SeriesCreationParametersDTO seriesPair = new SeriesCreationParametersDTO(seriesDTO.getFleets(),
+                    seriesDTO.isMedal(), seriesDTO.isStartsWithZeroScore(),
+                    seriesDTO.isFirstColumnIsNonDiscardableCarryForward(), seriesDTO.getDiscardThresholds());
             seriesStructure.put(seriesDTO.getName(), seriesPair);
         }
-        sailingService.createRegatta(newRegatta.getName(), newRegatta.boatClass==null?null:newRegatta.boatClass.getName(), seriesStructure, true,
+        sailingService.createRegatta(newRegatta.getName(), newRegatta.boatClass==null?null:newRegatta.boatClass.getName(),
+                new RegattaCreationParametersDTO(seriesStructure), true,
                 newRegatta.scoringScheme, newRegatta.defaultCourseAreaIdAsString, new AsyncCallback<RegattaDTO>() {
             @Override
             public void onFailure(Throwable t) {

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

@@ -17,14 +17,16 @@ public class SeriesDescriptor {
     private final List<RaceColumnDTO> races;
     private final boolean isMedal;
     private final boolean startsWithZeroScore;
+    private final boolean firstColumnIsNonDiscardableCarryForward;
     private final int[] resultDiscardingThresholds;
     
-    public SeriesDescriptor(SeriesDTO series, List<RaceColumnDTO> races, boolean isMedal, int[] resultDiscardingThresholds, boolean startsWithZeroScore) {
+    public SeriesDescriptor(SeriesDTO series, List<RaceColumnDTO> races, boolean isMedal, int[] resultDiscardingThresholds, boolean startsWithZeroScore, boolean firstColumnIsNonDiscardableCarryForward) {
         this.series = series;
         this.races = races;
         this.isMedal = isMedal;
         this.startsWithZeroScore = startsWithZeroScore;
         this.resultDiscardingThresholds = resultDiscardingThresholds;
+        this.firstColumnIsNonDiscardableCarryForward = firstColumnIsNonDiscardableCarryForward;
     }
 
     public SeriesDTO getSeries() {
@@ -46,4 +48,8 @@ public class SeriesDescriptor {
     public boolean isStartsWithZeroScore() {
         return startsWithZeroScore;
     }
+
+    public boolean isFirstColumnIsNonDiscardableCarryForward() {
+        return firstColumnIsNonDiscardableCarryForward;
+    }
 }

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

@@ -30,6 +30,7 @@ public class SeriesEditDialog extends DataEntryDialog<SeriesDescriptor> {
     private Button addRacesBtn;
     private CheckBox isMedalCheckbox;
     private CheckBox startWithZeroScoreCheckbox;
+    private CheckBox firstColumnIsNonDiscardableCarryForwardCheckbox;
     private CheckBox useSeriesResultDiscardingThresholdsCheckbox;
     private final List<TextBox> raceNameEntryFields;
     private final List<Button> raceNameDeleteButtons;
@@ -160,15 +161,16 @@ public class SeriesEditDialog extends DataEntryDialog<SeriesDescriptor> {
             races.add(raceColumnDTO);
         }
         return new SeriesDescriptor(selectedSeries, races, isMedalCheckbox.getValue(),
-                useSeriesResultDiscardingThresholdsCheckbox.getValue() ?
-                        discardThresholdBoxes.getDiscardThresholds() : null, startWithZeroScoreCheckbox.getValue());
+                useSeriesResultDiscardingThresholdsCheckbox.getValue() ? discardThresholdBoxes.getDiscardThresholds()
+                        : null, startWithZeroScoreCheckbox.getValue(),
+                firstColumnIsNonDiscardableCarryForwardCheckbox.getValue());
     }
 
     private RaceColumnDTO findRaceColumnInSeriesByName(SeriesDTO series, String raceColumnName) {
         RaceColumnDTO result = null;
-        if(series != null) {
-            for(RaceColumnDTO raceColumn: series.getRaceColumns()) {
-                if(raceColumn.getName().equals(raceColumnName)) {
+        if (series != null) {
+            for (RaceColumnDTO raceColumn : series.getRaceColumns()) {
+                if (raceColumn.getName().equals(raceColumnName)) {
                     result = raceColumn;
                     break;
                 }
@@ -195,6 +197,9 @@ public class SeriesEditDialog extends DataEntryDialog<SeriesDescriptor> {
         startWithZeroScoreCheckbox = createCheckbox(stringMessages.startsWithZeroScore());
         startWithZeroScoreCheckbox.setValue(selectedSeries.isStartsWithZeroScore());
         additionalWidgetPanel.add(startWithZeroScoreCheckbox);
+        firstColumnIsNonDiscardableCarryForwardCheckbox = createCheckbox(stringMessages.firstRaceIsNonDiscardableCarryForward());
+        firstColumnIsNonDiscardableCarryForwardCheckbox.setValue(selectedSeries.isFirstColumnIsNonDiscardableCarryForward());
+        additionalWidgetPanel.add(firstColumnIsNonDiscardableCarryForwardCheckbox);
         useSeriesResultDiscardingThresholdsCheckbox = createCheckbox(stringMessages.seriesDefinesResultDiscardingRule());
         useSeriesResultDiscardingThresholdsCheckbox.setValue(selectedSeries.getDiscardThresholds() != null);
         useSeriesResultDiscardingThresholdsCheckbox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {

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

@@ -34,6 +34,7 @@ public class SeriesWithFleetsCreateDialog extends DataEntryDialog<SeriesDTO> {
     private TextBox nameEntryField;
     private CheckBox isMedalSeriesCheckbox;
     private CheckBox startsWithZeroScoreCheckbox;
+    private CheckBox firstColumnIsNonDiscardableCarryForwardCheckbox;
     private CheckBox useSeriesResultDiscardingThresholdsCheckbox;
     private DiscardThresholdBoxes discardThresholdBoxes;
 
@@ -111,6 +112,7 @@ public class SeriesWithFleetsCreateDialog extends DataEntryDialog<SeriesDTO> {
         nameEntryField.setVisibleLength(40);
         isMedalSeriesCheckbox = createCheckbox(stringMessages.medalSeries());
         startsWithZeroScoreCheckbox = createCheckbox(stringMessages.startsWithZeroScore());
+        firstColumnIsNonDiscardableCarryForwardCheckbox = createCheckbox(stringMessages.firstRaceIsNonDiscardableCarryForward());
         useSeriesResultDiscardingThresholdsCheckbox = createCheckbox(stringMessages.seriesDefinesResultDiscardingRule());
         useSeriesResultDiscardingThresholdsCheckbox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
@@ -181,6 +183,7 @@ public class SeriesWithFleetsCreateDialog extends DataEntryDialog<SeriesDTO> {
         series.setName(nameEntryField.getText());
         series.setMedal(isMedalSeriesCheckbox.getValue());
         series.setStartsWithZeroScore(startsWithZeroScoreCheckbox.getValue());
+        series.setFirstColumnIsNonDiscardableCarryForward(firstColumnIsNonDiscardableCarryForwardCheckbox.getValue());
         List<FleetDTO> fleets = new ArrayList<FleetDTO>();
         int fleetsCount = fleetNameEntryFields.size();
         for(int i = 0; i < fleetsCount; i++) {
@@ -222,14 +225,15 @@ public class SeriesWithFleetsCreateDialog extends DataEntryDialog<SeriesDTO> {
         if (additionalWidget != null) {
             panel.add(additionalWidget);
         }
-        Grid formGrid = new Grid(5, 2);
+        Grid formGrid = new Grid(6, 2);
         panel.add(formGrid);
         formGrid.setWidget(0,  0, new Label(stringMessages.name() + ":"));
         formGrid.setWidget(0, 1, nameEntryField);
         formGrid.setWidget(1, 1, isMedalSeriesCheckbox);
         formGrid.setWidget(2, 1, startsWithZeroScoreCheckbox);
-        formGrid.setWidget(3, 1, useSeriesResultDiscardingThresholdsCheckbox);
-        formGrid.setWidget(4, 1, discardThresholdBoxes.getWidget());
+        formGrid.setWidget(3, 1, firstColumnIsNonDiscardableCarryForwardCheckbox);
+        formGrid.setWidget(4, 1, useSeriesResultDiscardingThresholdsCheckbox);
+        formGrid.setWidget(5, 1, discardThresholdBoxes.getWidget());
         panel.add(createHeadlineLabel(stringMessages.fleets()));
         panel.add(fleetsGrid);
         Button addFleetButton = new Button(stringMessages.addFleet());

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

@@ -3,14 +3,12 @@ package com.sap.sailing.gwt.ui.client;
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Date;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import com.google.gwt.user.client.rpc.RemoteService;
 import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
-import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.DetailType;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.NauticalSide;
@@ -26,6 +24,7 @@ import com.sap.sailing.domain.common.dto.CompetitorDTO;
 import com.sap.sailing.domain.common.dto.IncrementalOrFullLeaderboardDTO;
 import com.sap.sailing.domain.common.dto.RaceColumnInSeriesDTO;
 import com.sap.sailing.domain.common.dto.RaceDTO;
+import com.sap.sailing.domain.common.dto.RegattaCreationParametersDTO;
 import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.gwt.ui.shared.BulkScoreCorrectionDTO;
@@ -142,9 +141,9 @@ public interface SailingService extends RemoteService {
     
     void moveLeaderboardColumnDown(String leaderboardName, String columnName);
     
-    RegattaDTO createRegatta(String regattaName, String boatClassName, 
-            LinkedHashMap<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> seriesNamesWithFleetNamesAndFleetOrderingAndMedal,
-            boolean persistent, ScoringSchemeType scoringSchemeType, String defaultCourseAreaId);
+    RegattaDTO createRegatta(String regattaName, String boatClassName,
+            RegattaCreationParametersDTO seriesNamesWithFleetNamesAndFleetOrderingAndMedal, boolean persistent,
+            ScoringSchemeType scoringSchemeType, String defaultCourseAreaId);
     
     void removeRegatta(RegattaIdentifier regattaIdentifier);
     
@@ -152,7 +151,8 @@ public interface SailingService extends RemoteService {
     
     List<RaceColumnInSeriesDTO> addRaceColumnsToSeries(RegattaIdentifier regattaIdentifier, String seriesName, List<String> columnNames);
 
-    void updateSeries(RegattaIdentifier regattaIdentifier, String seriesName, boolean isMedal, int[] resultDiscardingThresholds, boolean startsWithZeroScore);
+    void updateSeries(RegattaIdentifier regattaIdentifier, String seriesName, boolean isMedal,
+            int[] resultDiscardingThresholds, boolean startsWithZeroScore, boolean firstRaceIsNonDiscardableCarryForward);
 
     RaceColumnInSeriesDTO addRaceColumnToSeries(RegattaIdentifier regattaIdentifier, String seriesName, String columnName);
 

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

@@ -3,13 +3,11 @@ package com.sap.sailing.gwt.ui.client;
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Date;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import com.google.gwt.user.client.rpc.AsyncCallback;
-import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.DetailType;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.NauticalSide;
@@ -26,6 +24,7 @@ import com.sap.sailing.domain.common.dto.CompetitorDTO;
 import com.sap.sailing.domain.common.dto.IncrementalOrFullLeaderboardDTO;
 import com.sap.sailing.domain.common.dto.RaceColumnInSeriesDTO;
 import com.sap.sailing.domain.common.dto.RaceDTO;
+import com.sap.sailing.domain.common.dto.RegattaCreationParametersDTO;
 import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.gwt.ui.shared.BulkScoreCorrectionDTO;
@@ -346,14 +345,14 @@ public interface SailingServiceAsync {
             AsyncCallback<Void> callback);
 
     void createRegatta(String regattaName, String boatClassName,
-            LinkedHashMap<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> seriesNamesWithFleetNamesAndFleetOrderingAndMedal,
-            boolean persistent, ScoringSchemeType scoringSchemeType, String defaultCourseAreaId, AsyncCallback<RegattaDTO> callback);
+            RegattaCreationParametersDTO seriesNamesWithFleetNamesAndFleetOrderingAndMedal, boolean persistent,
+            ScoringSchemeType scoringSchemeType, String defaultCourseAreaId, AsyncCallback<RegattaDTO> callback);
 
     void addRaceColumnsToSeries(RegattaIdentifier regattaIdentifier, String seriesName, List<String> columnNames,
             AsyncCallback<List<RaceColumnInSeriesDTO>> callback);
     
     void updateSeries(RegattaIdentifier regattaIdentifier, String seriesName, boolean isMedal, int[] resultDiscardingThresholds,
-            boolean startsWithZeroScore, AsyncCallback<Void> callback);
+            boolean startsWithZeroScore, boolean firstColumnIsNonDiscardableCarryForward, AsyncCallback<Void> callback);
 
     void removeRaceColumnsFromSeries(RegattaIdentifier regattaIdentifier, String seriesName, List<String> columnNames,
             AsyncCallback<Void> callback);

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

@@ -654,4 +654,5 @@ public interface StringMessages extends Messages {
     String addSeries();
     String regattaDefinesResultDiscardingRules();
     String startsWithZeroScore();
+    String firstRaceIsNonDiscardableCarryForward();
 }

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

@@ -647,3 +647,4 @@ seriesDefinesResultDiscardingRule=Series defines result discarding rules
 addSeries=Add series
 regattaDefinesResultDiscardingRules=Regatta defines result discarding rules
 startsWithZeroScore=Series starts with zero score
+firstRaceIsNonDiscardableCarryForward=Starts with non-discardable carry-forward

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

@@ -644,4 +644,5 @@ showOnlyCurrentlyRunningRaces=Zeige nur gerade laufende Rennen
 seriesDefinesResultDiscardingRule=Serie legt Streichregel fest
 addSeries=Serie hinzufügen
 regattaDefinesResultDiscardingRules=Streichergebnisse werden von der Regatta festgelegt
-startsWithZeroScore=Serie beginnt mit auf 0 gesetzten Ergebnissen
+startsWithZeroScore=Serie beginnt mit auf 0 gesetzten Ergebnissen
+firstRaceIsNonDiscardableCarryForward=Beginnt mit nicht streichbarem Übertrag

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboardedit/EditableLeaderboardPanel.java

@@ -419,8 +419,9 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
                     getWhiteboardOwner().whiteboardProduced(whiteboard);
                     getBusyIndicator().setBusy(true);
                     getSailingService().updateLeaderboardScoreCorrection(getLeaderboardName(), row.competitor.getIdAsString(), raceColumnName,
-                            value == null || value.trim().length() == 0 ? null : Double.valueOf(value.trim()), getLeaderboardDisplayDate(),
-                                    new AsyncCallback<Triple<Double, Double, Boolean>>() {
+                            value == null || value.trim().length() == 0 ? null : value.trim().equals("n/a") ? null
+                                    : Double.valueOf(value.trim()), getLeaderboardDisplayDate(),
+                            new AsyncCallback<Triple<Double, Double, Boolean>>() {
                         @Override
                         public void onFailure(Throwable t) {
                             getBusyIndicator().setBusy(false);

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

@@ -71,7 +71,6 @@ import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.base.impl.RegattaImpl;
 import com.sap.sailing.domain.base.impl.SeriesImpl;
 import com.sap.sailing.domain.common.Bearing;
-import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.CountryCode;
 import com.sap.sailing.domain.common.DetailType;
 import com.sap.sailing.domain.common.Distance;
@@ -114,6 +113,7 @@ import com.sap.sailing.domain.common.dto.RaceColumnDTO;
 import com.sap.sailing.domain.common.dto.RaceColumnInSeriesDTO;
 import com.sap.sailing.domain.common.dto.RaceDTO;
 import com.sap.sailing.domain.common.dto.RaceStatusDTO;
+import com.sap.sailing.domain.common.dto.RegattaCreationParametersDTO;
 import com.sap.sailing.domain.common.dto.TrackedRaceDTO;
 import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.common.impl.DegreePosition;
@@ -597,7 +597,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
         }
         SeriesDTO result = new SeriesDTO(series.getName(), fleets, raceColumns, series.isMedal(),
                 series.getResultDiscardingRule() == null ? null : series.getResultDiscardingRule().getDiscardIndexResultsStartingWithHowManyRaces(),
-                        series.isStartsWithZeroScore());
+                        series.isStartsWithZeroScore(), series.isFirstColumnIsNonDiscardableCarryForward());
         return result;
     }
 
@@ -2606,8 +2606,8 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
     
     @Override
     public void updateSeries(RegattaIdentifier regattaIdentifier, String seriesName, boolean isMedal,
-            int[] resultDiscardingThresholds, boolean startsWithZeroScore) {
-        getService().apply(new UpdateSeries(regattaIdentifier, seriesName, isMedal, resultDiscardingThresholds, startsWithZeroScore));
+            int[] resultDiscardingThresholds, boolean startsWithZeroScore, boolean firstColumnIsNonDiscardableCarryForward) {
+        getService().apply(new UpdateSeries(regattaIdentifier, seriesName, isMedal, resultDiscardingThresholds, startsWithZeroScore, firstColumnIsNonDiscardableCarryForward));
     }
 
     @Override
@@ -2644,7 +2644,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
 
     @Override
     public RegattaDTO createRegatta(String regattaName, String boatClassName,
-            LinkedHashMap<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> seriesNamesWithFleetNamesAndFleetOrderingAndMedal,
+            RegattaCreationParametersDTO seriesNamesWithFleetNamesAndFleetOrderingAndMedal,
             boolean persistent, ScoringSchemeType scoringSchemeType, String defaultCourseAreaId) {
         UUID courseAreaUuid = convertIdentifierStringToUuid(defaultCourseAreaId);
         Regatta regatta = getService().apply(

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/SeriesDTO.java

@@ -13,16 +13,18 @@ public class SeriesDTO extends NamedDTO {
     private boolean isMedal;
     private int[] discardThresholds;
     private Boolean startsWithZeroScore;
+    private boolean firstColumnIsNonDiscardableCarryForward;
     
     public SeriesDTO() {}
     
-    public SeriesDTO(String name, List<FleetDTO> fleets, List<RaceColumnDTO> raceColumns, boolean isMedal, int[] discardThresholds, boolean startsWithZeroScore) {
+    public SeriesDTO(String name, List<FleetDTO> fleets, List<RaceColumnDTO> raceColumns, boolean isMedal, int[] discardThresholds, boolean startsWithZeroScore, boolean firstColumnIsNonDiscardableCarryForward) {
         super(name);
         this.fleets = fleets;
         this.raceColumns = raceColumns;
         this.isMedal = isMedal;
         this.startsWithZeroScore = startsWithZeroScore;
         this.discardThresholds = discardThresholds;
+        this.firstColumnIsNonDiscardableCarryForward = firstColumnIsNonDiscardableCarryForward;
     }
     
     public boolean isMedal() {
@@ -73,4 +75,12 @@ public class SeriesDTO extends NamedDTO {
     public void setStartsWithZeroScore(Boolean startsWithZeroScore) {
         this.startsWithZeroScore = startsWithZeroScore;
     }
+    
+    public void setFirstColumnIsNonDiscardableCarryForward(boolean firstColumnIsNonDiscardableCarryForward) {
+        this.firstColumnIsNonDiscardableCarryForward = firstColumnIsNonDiscardableCarryForward;
+    }
+
+    public boolean isFirstColumnIsNonDiscardableCarryForward() {
+        return firstColumnIsNonDiscardableCarryForward;
+    }
 }

java/com.sap.sailing.server/src/com/sap/sailing/server/impl/RaceLogReplicator.java

@@ -72,6 +72,10 @@ public class RaceLogReplicator implements RaceColumnListener {
     public void isStartsWithZeroScoreChanged(RaceColumn raceColumn, boolean newIsStartsWithZeroScore) {
     }
 
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+    }
+
     @Override
     public boolean canAddRaceColumnToContainer(RaceColumn raceColumn) {
         return true;

java/com.sap.sailing.server/src/com/sap/sailing/server/impl/RaceLogScoringReplicator.java

@@ -54,6 +54,10 @@ public class RaceLogScoringReplicator implements RaceColumnListener {
     public void isStartsWithZeroScoreChanged(RaceColumn raceColumn, boolean newIsStartsWithZeroScore) {
     }
 
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+    }
+
     @Override
     public boolean canAddRaceColumnToContainer(RaceColumn raceColumn) {
         return true;

java/com.sap.sailing.server/src/com/sap/sailing/server/impl/RacingEventServiceImpl.java

@@ -18,6 +18,7 @@ import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -45,7 +46,6 @@ import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.CourseAreaImpl;
 import com.sap.sailing.domain.base.impl.EventImpl;
 import com.sap.sailing.domain.base.impl.RegattaImpl;
-import com.sap.sailing.domain.common.Color;
 import com.sap.sailing.domain.common.LeaderboardNameConstants;
 import com.sap.sailing.domain.common.RegattaAndRaceIdentifier;
 import com.sap.sailing.domain.common.RegattaIdentifier;
@@ -54,6 +54,9 @@ import com.sap.sailing.domain.common.Renamable;
 import com.sap.sailing.domain.common.ScoringSchemeType;
 import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.WindSource;
+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.common.impl.Util;
 import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.common.impl.Util.Triple;
@@ -69,8 +72,8 @@ import com.sap.sailing.domain.leaderboard.ScoringScheme;
 import com.sap.sailing.domain.leaderboard.impl.FlexibleLeaderboardImpl;
 import com.sap.sailing.domain.leaderboard.impl.LeaderboardGroupImpl;
 import com.sap.sailing.domain.leaderboard.impl.RegattaLeaderboardImpl;
-import com.sap.sailing.domain.leaderboard.impl.ThresholdBasedResultDiscardingRuleImpl;
 import com.sap.sailing.domain.leaderboard.impl.ScoreCorrectionImpl;
+import com.sap.sailing.domain.leaderboard.impl.ThresholdBasedResultDiscardingRuleImpl;
 import com.sap.sailing.domain.leaderboard.meta.LeaderboardGroupMetaLeaderboard;
 import com.sap.sailing.domain.persistence.DomainObjectFactory;
 import com.sap.sailing.domain.persistence.MongoFactory;
@@ -860,21 +863,20 @@ public class RacingEventServiceImpl implements RacingEventService, RegattaListen
         }
     }
 
-    private Map<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> getSeriesWithoutRaceColumnsConstructionParametersAsMap(
+    private RegattaCreationParametersDTO getSeriesWithoutRaceColumnsConstructionParametersAsMap(
             Regatta regatta) {
-        Map<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> result =
-                new HashMap<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>>();
+        LinkedHashMap<String, SeriesCreationParametersDTO> result = new LinkedHashMap<String, SeriesCreationParametersDTO>();
         for (Series s : regatta.getSeries()) {
             assert Util.isEmpty(s.getRaceColumns());
-            List<Triple<String, Integer, Color>> fleetNamesAndOrdering = new ArrayList<Triple<String, Integer, Color>>();
+            List<FleetDTO> fleetNamesAndOrdering = new ArrayList<FleetDTO>();
             for (Fleet f : s.getFleets()) {
-                fleetNamesAndOrdering.add(new Triple<String, Integer, Color>(f.getName(), f.getOrdering(), f.getColor()));
+                fleetNamesAndOrdering.add(getBaseDomainFactory().convertToFleetDTO(f));
             }
-            result.put(s.getName(), new Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>(fleetNamesAndOrdering,
-                    new Pair<Boolean, Boolean>(s.isMedal(), s.isStartsWithZeroScore()),
+            result.put(s.getName(), new SeriesCreationParametersDTO(fleetNamesAndOrdering,
+                    s.isMedal(), s.isStartsWithZeroScore(), s.isFirstColumnIsNonDiscardableCarryForward(),
                     s.getResultDiscardingRule() == null ? null : s.getResultDiscardingRule().getDiscardIndexResultsStartingWithHowManyRaces()));
         }
-        return result;
+        return new RegattaCreationParametersDTO(result);
     }
 
     /**

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

@@ -11,9 +11,9 @@ import com.sap.sailing.domain.base.Regatta;
 import com.sap.sailing.domain.base.Series;
 import com.sap.sailing.domain.base.impl.FleetImpl;
 import com.sap.sailing.domain.base.impl.SeriesImpl;
-import com.sap.sailing.domain.common.Color;
-import com.sap.sailing.domain.common.impl.Util.Pair;
-import com.sap.sailing.domain.common.impl.Util.Triple;
+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.ScoringScheme;
 import com.sap.sailing.domain.leaderboard.impl.ThresholdBasedResultDiscardingRuleImpl;
 import com.sap.sailing.domain.tracking.TrackedRegattaRegistry;
@@ -22,13 +22,13 @@ import com.sap.sailing.server.RacingEventServiceOperation;
 
 public class AddSpecificRegatta extends AbstractAddRegattaOperation {
     private static final long serialVersionUID = -8018855620167669352L;
-    private final Map<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndStartsWithZeroScoreAndDiscardingThresholds;
+    private final RegattaCreationParametersDTO seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndStartsWithZeroScoreAndDiscardingThresholds;
     private final boolean persistent;
     private final ScoringScheme scoringScheme;
     private final Serializable defaultCourseAreaId;
     
     public AddSpecificRegatta(String regattaName, String boatClassName, Serializable id,
-            Map<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndDiscardingThresholds,
+            RegattaCreationParametersDTO seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndDiscardingThresholds,
             boolean persistent, ScoringScheme scoringScheme, Serializable defaultCourseAreaId) {
         super(regattaName, boatClassName, id);
         this.seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndStartsWithZeroScoreAndDiscardingThresholds = seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndDiscardingThresholds;
@@ -45,23 +45,24 @@ public class AddSpecificRegatta extends AbstractAddRegattaOperation {
 
     private Iterable<? extends Series> createSeries(TrackedRegattaRegistry trackedRegattaRegistry) {
         List<Series> result = new ArrayList<Series>();
-        for (Map.Entry<String, Triple<List<Triple<String, Integer, Color>>, Pair<Boolean, Boolean>, int[]>> e : seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndStartsWithZeroScoreAndDiscardingThresholds.entrySet()) {
+        for (Map.Entry<String, SeriesCreationParametersDTO> e : seriesNamesWithFleetNamesAndFleetOrderingAndMedalAndStartsWithZeroScoreAndDiscardingThresholds.getSeriesCreationParameters().entrySet()) {
             final List<String> emptyRaceColumnNamesList = Collections.emptyList();
-            Series s = new SeriesImpl(e.getKey(), /* isMedal */e.getValue().getB().getA(), createFleets(e.getValue().getA()),
+            Series s = new SeriesImpl(e.getKey(), e.getValue().isMedal(), createFleets(e.getValue().getFleets()),
                     emptyRaceColumnNamesList, trackedRegattaRegistry);
-            if (e.getValue().getC() != null) {
-                s.setResultDiscardingRule(new ThresholdBasedResultDiscardingRuleImpl(e.getValue().getC()));
+            if (e.getValue().getDiscardingThresholds() != null) {
+                s.setResultDiscardingRule(new ThresholdBasedResultDiscardingRuleImpl(e.getValue().getDiscardingThresholds()));
             }
-            s.setStartsWithZeroScore(e.getValue().getB().getB());
+            s.setStartsWithZeroScore(e.getValue().isStartsWithZero());
+            s.setFirstColumnIsNonDiscardableCarryForward(e.getValue().isFirstColumnIsNonDiscardableCarryForward());
             result.add(s);
         }
         return result;
     }
 
-    private Iterable<? extends Fleet> createFleets(List<Triple<String, Integer, Color>> fleetNamesAndOrderingAndColor) {
+    private Iterable<? extends Fleet> createFleets(List<FleetDTO> fleetNamesAndOrderingAndColor) {
         List<Fleet> result = new ArrayList<Fleet>();
-        for (Triple<String, Integer, Color> fleetNameAndOrderingAndColor : fleetNamesAndOrderingAndColor) {
-            Fleet fleet = new FleetImpl(fleetNameAndOrderingAndColor.getA(), fleetNameAndOrderingAndColor.getB(), fleetNameAndOrderingAndColor.getC());
+        for (FleetDTO fleetNameAndOrderingAndColor : fleetNamesAndOrderingAndColor) {
+            Fleet fleet = new FleetImpl(fleetNameAndOrderingAndColor.getName(), fleetNameAndOrderingAndColor.getOrderNo(), fleetNameAndOrderingAndColor.getColor());
             result.add(fleet);
         }
         return result;

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

@@ -12,12 +12,14 @@ public class UpdateSeries extends AbstractSeriesOperation<Void> {
     private final boolean isMedal;
     private final int[] resultDiscardingThresholds;
     private final boolean startsWithZeroScore;
+    private final boolean firstColumnIsNonDiscardableCarryForward;
 
-    public UpdateSeries(RegattaIdentifier regattaIdentifier, String seriesName, boolean isMedal, int[] resultDiscardingThresholds, boolean startsWithZeroScore) {
+    public UpdateSeries(RegattaIdentifier regattaIdentifier, String seriesName, boolean isMedal, int[] resultDiscardingThresholds, boolean startsWithZeroScore, boolean firstColumnIsNonDiscardableCarryForward) {
         super(regattaIdentifier, seriesName);
         this.isMedal = isMedal;
         this.resultDiscardingThresholds = resultDiscardingThresholds;
         this.startsWithZeroScore = startsWithZeroScore;
+        this.firstColumnIsNonDiscardableCarryForward = firstColumnIsNonDiscardableCarryForward;
     }
 
     @Override
@@ -27,6 +29,7 @@ public class UpdateSeries extends AbstractSeriesOperation<Void> {
         series.setResultDiscardingRule(resultDiscardingThresholds == null ?
                 null : new ThresholdBasedResultDiscardingRuleImpl(resultDiscardingThresholds));
         series.setStartsWithZeroScore(startsWithZeroScore);
+        series.setFirstColumnIsNonDiscardableCarryForward(firstColumnIsNonDiscardableCarryForward);
         if (series.getRegatta().isPersistent()) {
             toState.updateStoredRegatta(series.getRegatta());
         }