Merge branch 'master' into ubilabs--rcapp--develop

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/impl/ReadonlyRacingProcedureFactory.java

@@ -11,6 +11,7 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ReadonlyRac
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.basic.impl.BasicRacingProcedureImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ess.impl.ESSRacingProcedureImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.GateStartRacingProcedureImpl;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.impl.LeagueRacingProcedureImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.RRS26RacingProcedureImpl;
 import com.sap.sailing.domain.base.configuration.ConfigurationLoader;
 import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
@@ -49,7 +50,7 @@ public class ReadonlyRacingProcedureFactory implements RacingProcedureFactory {
         case BASIC:
             return new BasicRacingProcedureImpl(raceLog, author, factory, loadedConfiguration.getBasicConfiguration());
         case LEAGUE:
-            return new BasicRacingProcedureImpl(raceLog, author, factory, loadedConfiguration.getBasicConfiguration());
+            return new LeagueRacingProcedureImpl(raceLog, author, factory, loadedConfiguration.getLeagueConfiguration());
         default:
             throw new UnsupportedOperationException("Unknown racing procedure " + type.toString());
         }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/league/LeagueRacingProcedureChangedListener.java

@@ -0,0 +1,6 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
+
+public interface LeagueRacingProcedureChangedListener extends RacingProcedureChangedListener {
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/league/impl/LeagueRacingProcedureChangedListeners.java

@@ -0,0 +1,8 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.impl;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.LeagueRacingProcedureChangedListener;
+
+public class LeagueRacingProcedureChangedListeners extends RacingProcedureChangedListeners<LeagueRacingProcedureChangedListener> implements
+    LeagueRacingProcedureChangedListener {
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/league/impl/LeagueRacingProcedureImpl.java

@@ -17,8 +17,7 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProce
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.NoMorePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.RRS26ChangedListeners;
-import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
+import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.common.racelog.FlagPole;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
@@ -33,7 +32,7 @@ public class LeagueRacingProcedureImpl extends BaseRacingProcedure {
     private final static Flags startmodeFlag = Flags.PAPA;
     
     public LeagueRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author, 
-            RaceLogEventFactory factory, RRS26Configuration configuration) {
+            RaceLogEventFactory factory, LeagueConfiguration configuration) {
         super(raceLog, author, factory, configuration);
         update();
     }
@@ -75,6 +74,8 @@ public class LeagueRacingProcedureImpl extends BaseRacingProcedure {
 
     @Override
     protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
+        // Remark: We are reusing here CLASS_UP, STARTMODE_UP and STARTMODE_DOWN from the RRS26 procedure
+        // The question is why there are no generic CLASS_UP, STARTMODE_UP and STARTMODE_DOWN events
         return Arrays.<RaceStateEvent> asList(
                 new RaceStateEventImpl(startTime.minus(startPhaseClassUpInterval), RaceStateEvents.RRS26_CLASS_UP),
                 new RaceStateEventImpl(startTime.minus(startPhaseStartModeUpInterval), RaceStateEvents.RRS26_STARTMODE_UP),
@@ -135,6 +136,6 @@ public class LeagueRacingProcedureImpl extends BaseRacingProcedure {
     
     @Override
     protected RacingProcedureChangedListeners<? extends RacingProcedureChangedListener> createChangedListenerContainer() {
-        return new RRS26ChangedListeners();
+        return new LeagueRacingProcedureChangedListeners();
     }
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/RegattaConfiguration.java

@@ -5,6 +5,7 @@ import java.io.Serializable;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
 import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.CourseDesignerMode;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
@@ -42,7 +43,13 @@ public interface RegattaConfiguration extends Serializable, Cloneable {
      * @return <code>null</code> if there is no configuration.
      */
     ESSConfiguration getESSConfiguration();
-    
+
+    /**
+     * Gets the configuration for league races.
+     * @return <code>null</code> if there is no configuration.
+     */
+    LeagueConfiguration getLeagueConfiguration();
+
     /**
      * Gets the configuration for Basic races.
      * @return <code>null</code> if there is no configuration.

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/EmptyRegattaConfiguration.java

@@ -21,6 +21,7 @@ public class EmptyRegattaConfiguration extends RegattaConfigurationImpl implemen
         setGateStartConfiguration(new GateStartConfigurationImpl());
         setESSConfiguration(new ESSConfigurationImpl());
         setBasicConfiguration(new RacingProcedureConfigurationImpl());
+        setLeagueConfiguration(new LeagueConfigurationImpl());
         return clone();
     }
 

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/LeagueConfigurationImpl.java

@@ -0,0 +1,20 @@
+package com.sap.sailing.domain.base.configuration.impl;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
+
+public class LeagueConfigurationImpl extends RacingProcedureConfigurationImpl implements LeagueConfiguration {
+    private static final long serialVersionUID = 3625803505541394766L;
+
+    protected LeagueConfigurationImpl copy() {
+        LeagueConfigurationImpl copy = (LeagueConfigurationImpl) super.copy(new LeagueConfigurationImpl());
+        return copy;
+    }
+    
+    @Override
+    public RacingProcedureConfiguration merge(RacingProcedureConfiguration update) {
+        LeagueConfigurationImpl target = (LeagueConfigurationImpl) super.merge(update);
+        return target;
+    }
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RegattaConfigurationImpl.java

@@ -4,6 +4,7 @@ import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.CourseDesignerMode;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
@@ -18,6 +19,7 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
     private RRS26Configuration rrs26Configuration;
     private GateStartConfiguration gateStartConfiguration;
     private ESSConfiguration essConfiguration;
+    private LeagueConfiguration leagueConfiguration;
     private RacingProcedureConfiguration basicConfiguration;
 
     @Override
@@ -65,6 +67,15 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
         this.essConfiguration = essConfiguration;
     }   
 
+    @Override
+    public LeagueConfiguration getLeagueConfiguration() {
+        return leagueConfiguration;
+    }
+
+    public void setLeagueConfiguration(LeagueConfiguration leagueConfiguration) {
+        this.leagueConfiguration = leagueConfiguration;
+    }   
+
     @Override
     public RacingProcedureConfiguration getBasicConfiguration() {
         return basicConfiguration;
@@ -83,6 +94,7 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
         copy.setGateStartConfiguration(gateStartConfiguration);
         copy.setESSConfiguration(essConfiguration);
         copy.setBasicConfiguration(basicConfiguration);
+        copy.setLeagueConfiguration(leagueConfiguration);
         return copy;
     }
 
@@ -112,6 +124,10 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
             target.setBasicConfiguration(
                     (RacingProcedureConfiguration) target.getBasicConfiguration().merge(update.getBasicConfiguration()));
         }
+        if (update.getLeagueConfiguration() != null) {
+            target.setLeagueConfiguration(
+                    (LeagueConfiguration) target.getLeagueConfiguration().merge(update.getLeagueConfiguration()));
+        }
 
         return target;
     }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/procedures/LeagueConfiguration.java

@@ -0,0 +1,7 @@
+package com.sap.sailing.domain.base.configuration.procedures;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+
+public interface LeagueConfiguration extends RacingProcedureConfiguration {
+
+}

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

@@ -60,6 +60,11 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
     private ListBox basicClassFlagListBox;
     private CheckBox basicRecallBox;
 
+    private DisclosurePanel leagueDisclosurePanel;
+    private CheckBox leagueEnabledBox;
+    private ListBox leagueClassFlagListBox;
+    private CheckBox leagueRecallBox;
+
     public RegattaConfigurationDialog(DeviceConfigurationDTO.RegattaConfigurationDTO regattaConfiguration,
             StringMessages messages, DataEntryDialog.DialogCallback<RegattaConfigurationDTO> callback) {
         super(messages.racingProcedureConfiguration(), "", messages.save(), messages.cancel(), /* validator */ null, callback);
@@ -75,6 +80,7 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         setupGateStart();
         setupESS();
         setupBasic();
+        setupLeague();
         
         if (rrs26EnabledBox.getValue()) {
             rrs26DisclosurePanel.setOpen(true);
@@ -88,6 +94,9 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         if (basicEnabledBox.getValue()) {
             basicDisclosurePanel.setOpen(true);
         }
+        if (leagueEnabledBox.getValue()) {
+            leagueDisclosurePanel.setOpen(true);
+        }
 
         return contentPanel;
     }
@@ -109,7 +118,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         racingProcedureListBox.addChangeHandler(new ChangeHandler() {
             @Override
             public void onChange(ChangeEvent event) {
-                markAsDrity(true);
             }
         });
         grid.setWidget(gridRow, 0, new Label(stringMessages.racingProcedure()));
@@ -126,7 +134,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         designerModeEntryListBox.addChangeHandler(new ChangeHandler() {
             @Override
             public void onChange(ChangeEvent event) {
-                markAsDrity(true);
             }
         });
         grid.setWidget(gridRow, 0, new Label(stringMessages.courseDesignerMode()));
@@ -143,7 +150,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         box.addChangeHandler(new ChangeHandler() {
             @Override
             public void onChange(ChangeEvent event) {
-                markAsDrity(true);
             }
         });
         return box;
@@ -155,7 +161,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
 
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
-                markAsDrity(true);
             }
         });
         return box;
@@ -170,7 +175,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         rrs26EnabledBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
-                markAsDrity(true);
                 boolean isActive = event.getValue();
                 rrs26ClassFlagListBox.setEnabled(isActive);
                 rrs26RecallBox.setEnabled(isActive);
@@ -215,7 +219,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         rrs26StartModeFlagsBox.addChangeHandler(new ChangeHandler() {
             @Override
             public void onChange(ChangeEvent event) {
-                markAsDrity(true);
             }
         });
     }
@@ -229,7 +232,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         gateStartEnabledBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
-                markAsDrity(true);
                 gateStartClassFlagListBox.setEnabled(event.getValue());
                 gateStartRecallBox.setEnabled(event.getValue());
                 gateStartPathfinderBox.setEnabled(event.getValue());
@@ -244,14 +246,12 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         gateStartPathfinderBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
-                markAsDrity(true);
             }
         });
         gateStartGolfDownBox = createCheckbox(stringMessages.hasAdditionalGolfDownTime());
         gateStartGolfDownBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
-                markAsDrity(true);
             }
         });
 
@@ -284,7 +284,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         essEnabledBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
-                markAsDrity(true);
                 essClassFlagListBox.setEnabled(event.getValue());
                 essRecallBox.setEnabled(event.getValue());
             }
@@ -318,7 +317,6 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         basicEnabledBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
-                markAsDrity(true);
                 basicClassFlagListBox.setEnabled(event.getValue());
                 basicRecallBox.setEnabled(event.getValue());
             }
@@ -343,8 +341,37 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         contentPanel.add(basicDisclosurePanel);
     }
 
-    private void markAsDrity(boolean b) {
-        // hmnn do we need to this?
+    private void setupLeague() {
+        leagueDisclosurePanel = new DisclosurePanel(stringMessages.leagueStart());
+        VerticalPanel panel = new VerticalPanel();
+
+        Grid grid = new Grid(2, 3);
+        leagueEnabledBox = new CheckBox(stringMessages.setConfiguration());
+        leagueEnabledBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
+            @Override
+            public void onValueChange(ValueChangeEvent<Boolean> event) {
+                leagueClassFlagListBox.setEnabled(event.getValue());
+                leagueRecallBox.setEnabled(event.getValue());
+            }
+        });
+        leagueClassFlagListBox = setupClassFlagListBox(originalConfiguration == null ? null
+                : originalConfiguration.leagueConfiguration);
+        leagueClassFlagListBox.setWidth("100%");
+        leagueRecallBox = setupRecallBox();
+
+        grid.setWidget(0, 0, new Label(stringMessages.classFlag() + ":"));
+        grid.setWidget(0, 1, leagueClassFlagListBox);
+        grid.setWidget(0, 2, createHelpImage(stringMessages.classFlagHelpText("league start")));
+        grid.setWidget(1, 0, leagueRecallBox);
+        grid.setWidget(1, 2, createHelpImage(stringMessages.individualRecallHelpText()));
+
+        leagueEnabledBox.setValue(originalConfiguration != null && originalConfiguration.leagueConfiguration != null);
+        ValueChangeEvent.fire(leagueEnabledBox, leagueEnabledBox.getValue());
+
+        panel.add(leagueEnabledBox);
+        panel.add(grid);
+        leagueDisclosurePanel.add(panel);
+        contentPanel.add(leagueDisclosurePanel);
     }
 
     private Widget createHelpImage(String tooltip) {
@@ -399,6 +426,10 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
             result.basicConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.RacingProcedureConfigurationDTO();
             getRacingProcedureConfigurationResults(result.basicConfiguration, basicClassFlagListBox, basicRecallBox);
         }
+        if (leagueEnabledBox.getValue()) {
+            result.leagueConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.LeagueConfigurationDTO();
+            getRacingProcedureConfigurationResults(result.leagueConfiguration, leagueClassFlagListBox, leagueRecallBox);
+        }
         return result;
     }
 

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

@@ -938,6 +938,7 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages, c
     String pathfinderHelpText();
     String essStart();
     String basicStart();
+    String leagueStart();
     String configured();
     String overwriteRacingProceduresConfiguration();
     String overwriteRacingProceduresConfigurationHelpText();

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

@@ -922,6 +922,7 @@ activatePathfinder=Activate Pathfinder
 pathfinderHelpText=When activated the Race Officer is able to set the Pathfinder boat.
 essStart=ESS Start
 basicStart=Basic Start
+leagueStart=League Start
 configured=Configured
 overwriteRacingProceduresConfiguration=Activate regatta configuration
 overwriteRacingProceduresConfigurationHelpText=Enabling this option will provide a base regatta configuration for all options unconfigured in the regatta-specific configuration.

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

@@ -918,6 +918,7 @@ activatePathfinder=Aktiviere Pathfinder
 pathfinderHelpText=Wenn aktiviert, ermöglicht dem Race Officer einen Pathfinder auszuwählen.
 essStart=ESS Start
 basicStart=Basic Start
+leagueStart=Liga Start
 configured=Konfiguriert
 overwriteRacingProceduresConfiguration=Aktivere Regattakonfiguration
 overwriteRacingProceduresConfigurationHelpText=Wenn aktiviert überschreibt jegliche Konfiguration der Rennarten durch eine Regatta.

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

@@ -911,7 +911,8 @@ gateStart=Ворота старта
 activatePathfinder=Активировать «Следопыт» 
 pathfinderHelpText=После активации официальное лицо гонки может настроить судно «Следопыт».
 essStart=Старт ESS
-basicStart=Основной старт 
+basicStart=Основной старт
+leagueStart=League Start 
 configured=Настроенный
 overwriteRacingProceduresConfiguration=Активировать конфигурацию регаты
 overwriteRacingProceduresConfigurationHelpText=Включение этой опции предоставляет базовую конфигурацию регаты для всех опций, не настроенных в специальной конфигурации регаты.

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

@@ -117,6 +117,7 @@ import com.sap.sailing.domain.base.configuration.impl.DeviceConfigurationMatcher
 import com.sap.sailing.domain.base.configuration.impl.DeviceConfigurationMatcherSingle;
 import com.sap.sailing.domain.base.configuration.impl.ESSConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.GateStartConfigurationImpl;
+import com.sap.sailing.domain.base.configuration.impl.LeagueConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RRS26ConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RacingProcedureConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RegattaConfigurationImpl;
@@ -4593,6 +4594,11 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
             dto.basicConfiguration.classFlag = configuration.getBasicConfiguration().getClassFlag();
             dto.basicConfiguration.hasInidividualRecall = configuration.getBasicConfiguration().hasInidividualRecall();
         }
+        if (configuration.getLeagueConfiguration() != null) {
+            dto.leagueConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.LeagueConfigurationDTO();
+            dto.leagueConfiguration.classFlag = configuration.getLeagueConfiguration().getClassFlag();
+            dto.leagueConfiguration.hasInidividualRecall = configuration.getLeagueConfiguration().hasInidividualRecall();
+        }
         return dto;
     }
 
@@ -4638,6 +4644,12 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
             config.setHasInidividualRecall(dto.basicConfiguration.hasInidividualRecall);
             configuration.setBasicConfiguration(config);
         }
+        if (dto.leagueConfiguration != null) {
+            LeagueConfigurationImpl config = new LeagueConfigurationImpl();
+            config.setClassFlag(dto.leagueConfiguration.classFlag);
+            config.setHasInidividualRecall(dto.leagueConfiguration.hasInidividualRecall);
+            configuration.setLeagueConfiguration(config);
+        }
         return configuration;
     }
 

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

@@ -22,7 +22,11 @@ public class DeviceConfigurationDTO implements IsSerializable {
         public static class ESSConfigurationDTO extends RacingProcedureConfigurationDTO {
             
         }
-        
+
+        public static class LeagueConfigurationDTO extends RacingProcedureConfigurationDTO {
+            
+        }
+
         public static class RacingProcedureConfigurationDTO implements IsSerializable {
             public Flags classFlag;
             public Boolean hasInidividualRecall;
@@ -34,6 +38,7 @@ public class DeviceConfigurationDTO implements IsSerializable {
         public GateStartConfigurationDTO gateStartConfiguration;
         public ESSConfigurationDTO essConfiguration;
         public RacingProcedureConfigurationDTO basicConfiguration;
+        public LeagueConfigurationDTO leagueConfiguration;
     }
 
     public List<String> allowedCourseAreaNames;

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/serialization/impl/LeagueConfigurationJsonSerializer.java

@@ -0,0 +1,29 @@
+package com.sap.sailing.server.gateway.serialization.impl;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class LeagueConfigurationJsonSerializer extends RacingProcedureConfigurationJsonSerializer implements
+        JsonSerializer<RacingProcedureConfiguration> {
+
+    public static LeagueConfigurationJsonSerializer create() {
+        return new LeagueConfigurationJsonSerializer();
+    }
+
+    public LeagueConfigurationJsonSerializer() {
+        super();
+    }
+
+    @Override
+    public JSONObject serialize(RacingProcedureConfiguration baseObject) {
+        JSONObject result = super.serialize(baseObject);
+        @SuppressWarnings("unused")
+        LeagueConfiguration object = (LeagueConfiguration) baseObject;
+
+        return result;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/serialization/impl/RegattaConfigurationJsonSerializer.java

@@ -11,7 +11,7 @@ public class RegattaConfigurationJsonSerializer implements JsonSerializer<Regatt
     public static RegattaConfigurationJsonSerializer create() {
         return new RegattaConfigurationJsonSerializer(RRS26ConfigurationJsonSerializer.create(),
                 GateStartConfigurationJsonSerializer.create(), ESSConfigurationJsonSerializer.create(),
-                RacingProcedureConfigurationJsonSerializer.create());
+                RacingProcedureConfigurationJsonSerializer.create(), LeagueConfigurationJsonSerializer.create());
     }
 
     public static final Object FIELD_DEFAULT_RACING_PROCEDURE_TYPE = "defaultRacingProcedureType";
@@ -19,20 +19,23 @@ public class RegattaConfigurationJsonSerializer implements JsonSerializer<Regatt
     public static final String FIELD_RRS26 = "rrs26";
     public static final String FIELD_GATE_START = "gateStart";
     public static final String FIELD_ESS = "ess";
+    public static final String FIELD_LEAGUE = "league";
     public static final String FIELD_BASIC = "basic";
 
     private final JsonSerializer<RacingProcedureConfiguration> rrs26Serializer;
     private final JsonSerializer<RacingProcedureConfiguration> gateStartSerializer;
     private final JsonSerializer<RacingProcedureConfiguration> essSerializer;
     private final JsonSerializer<RacingProcedureConfiguration> basicSerializer;
+    private final JsonSerializer<RacingProcedureConfiguration> leagueSerializer;
 
     public RegattaConfigurationJsonSerializer(JsonSerializer<RacingProcedureConfiguration> rrs26,
             JsonSerializer<RacingProcedureConfiguration> gateStart, JsonSerializer<RacingProcedureConfiguration> ess,
-            JsonSerializer<RacingProcedureConfiguration> basicSerializer) {
+            JsonSerializer<RacingProcedureConfiguration> basicSerializer, JsonSerializer<RacingProcedureConfiguration> leagueSerializer) {
         this.rrs26Serializer = rrs26;
         this.gateStartSerializer = gateStart;
         this.essSerializer = ess;
         this.basicSerializer = basicSerializer;
+        this.leagueSerializer = leagueSerializer;
     }
 
     @Override
@@ -59,6 +62,10 @@ public class RegattaConfigurationJsonSerializer implements JsonSerializer<Regatt
         if (object.getBasicConfiguration() != null) {
             result.put(FIELD_BASIC, basicSerializer.serialize(object.getBasicConfiguration()));
         }
+        if (object.getLeagueConfiguration() != null) {
+            result.put(FIELD_LEAGUE, leagueSerializer.serialize(object.getLeagueConfiguration()));
+        }
+
         return result;
     }
 

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

@@ -691,6 +691,19 @@ public class MasterDataImportTest {
         } finally {
             windTrackOnDest.unlockAfterRead();
         }
+        
+        //Reimport again to see if db throws exceptions (see console for error for now, since exception is caught deep inside)
+        try {
+            streamingOutput.write(os);
+            os.flush();
+
+            inputStream = new ByteArrayInputStream(os.toByteArray());
+            MasterDataImporter importer = new MasterDataImporter(domainFactory, destService);
+            importer.importFromStream(inputStream, randomUUID, false);
+        } finally {
+            os.close();
+            inputStream.close();
+        }
 
     }
 

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

@@ -332,7 +332,13 @@ public class ImportMasterDataOperation extends
             windTrackToReadFrom.lockForRead();
             try {
                 for (Wind fix : windTrackToReadFrom.getRawFixes()) {
-                    windTrackToWriteTo.add(fix);
+                    Wind existingFix = windTrackToWriteTo.getFirstRawFixAtOrAfter(fix.getTimePoint());
+                    if (existingFix == null || !(existingFix.equals(fix) && fix.getTimePoint().equals(existingFix.getTimePoint())
+                            && fix.getPosition().equals(existingFix.getPosition()))) {
+                        windTrackToWriteTo.add(fix);
+                    } else {
+                        logger.info("Didn't add wind fix in import, because equal fix was already there.");
+                    }
                 }
             } finally {
                 windTrackToReadFrom.unlockAfterRead();

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/AppPreferences.java

@@ -219,6 +219,8 @@ public class AppPreferences {
             return key(R.string.preference_racing_procedure_ess_classflag_key);
         case BASIC:
             return key(R.string.preference_racing_procedure_basic_classflag_key);
+        case LEAGUE:
+            return key(R.string.preference_racing_procedure_basic_classflag_key);
         default:
             throw new IllegalArgumentException("Unknown racing procedure type.");
         }
@@ -245,8 +247,7 @@ public class AppPreferences {
     }
 
     public Set<Flags> getRRS26StartmodeFlags() {
-        Set<String> flagNames = preferences.getStringSet(
-                key(R.string.preference_racing_procedure_rrs26_startmode_flags_key), new HashSet<String>());
+        Set<String> flagNames = preferences.getStringSet(key(R.string.preference_racing_procedure_rrs26_startmode_flags_key), new HashSet<String>());
         if (flagNames != null) {
             Set<Flags> flags = new HashSet<Flags>();
             for (String flagName : flagNames) {
@@ -308,8 +309,8 @@ public class AppPreferences {
     }
 
     public boolean isSendingActive() {
-        return preferences.getBoolean(context.getResources().getString(R.string.preference_isSendingActive_key),
-                context.getResources().getBoolean(R.bool.preference_isSendingActive_default));
+        return preferences.getBoolean(context.getResources().getString(R.string.preference_isSendingActive_key), context
+            .getResources().getBoolean(R.bool.preference_isSendingActive_default));
     }
 
     protected String key(int keyId) {
@@ -331,8 +332,7 @@ public class AppPreferences {
     public void setByNameCourseDesignerCourseNames(List<String> courseNames) {
         preferences
                 .edit()
-                .putStringSet(key(R.string.preference_course_designer_by_name_course_names_key),
-                        new HashSet<String>(courseNames)).commit();
+                .putStringSet(key(R.string.preference_course_designer_by_name_course_names_key), new HashSet<String>(courseNames)).commit();
     }
 
     public void setCourseLayout(CourseLayouts courseLayout) {
@@ -444,8 +444,7 @@ public class AppPreferences {
         	.putLong(HIDDEN_PREFERENCE_WIND_LNG, lng)
         .commit();
     }
-    
-    
+
     public void setCourseUUID(UUID uuid){
     	long least = uuid.getLeastSignificantBits(); 
     	long most  = uuid.getMostSignificantBits();

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/domain/configuration/impl/PreferencesRegattaConfigurationLoader.java

@@ -3,21 +3,23 @@ package com.sap.sailing.racecommittee.app.domain.configuration.impl;
 import java.util.ArrayList;
 import java.util.HashSet;
 
+import com.sap.sailing.android.shared.logging.ExLog;
 import com.sap.sailing.domain.base.configuration.ConfigurationLoader;
 import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
 import com.sap.sailing.domain.base.configuration.impl.ESSConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.GateStartConfigurationImpl;
+import com.sap.sailing.domain.base.configuration.impl.LeagueConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RRS26ConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RacingProcedureConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RegattaConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sailing.racecommittee.app.AppPreferences;
-import com.sap.sailing.android.shared.logging.ExLog;
 
 public class PreferencesRegattaConfigurationLoader implements ConfigurationLoader<RegattaConfiguration> {
 
@@ -69,6 +71,11 @@ public class PreferencesRegattaConfigurationLoader implements ConfigurationLoade
         basic.setHasInidividualRecall(preferences.getRacingProcedureHasIndividualRecall(RacingProcedureType.BASIC));
         configuration.setBasicConfiguration(basic);
 
+        LeagueConfigurationImpl league = new LeagueConfigurationImpl();
+        league.setClassFlag(preferences.getRacingProcedureClassFlag(RacingProcedureType.LEAGUE));
+        league.setHasInidividualRecall(preferences.getRacingProcedureHasIndividualRecall(RacingProcedureType.LEAGUE));
+        configuration.setLeagueConfiguration(league);
+
         return configuration.clone();
     }
 
@@ -109,6 +116,10 @@ public class PreferencesRegattaConfigurationLoader implements ConfigurationLoade
             RacingProcedureConfiguration config = configuration.getBasicConfiguration();
             storeRacingProcedureConfiguration(RacingProcedureType.BASIC, config);
         }
+        if (configuration.getLeagueConfiguration() != null) {
+            LeagueConfiguration config = configuration.getLeagueConfiguration();
+            storeRacingProcedureConfiguration(RacingProcedureType.LEAGUE, config);
+        }
     }
 
     private void storeRacingProcedureConfiguration(RacingProcedureType type, RacingProcedureConfiguration config) {

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/chooser/LeagueRaceInfoFragmentChooser.java

@@ -0,0 +1,31 @@
+package com.sap.sailing.racecommittee.app.ui.fragments.chooser;
+
+import com.sap.sailing.racecommittee.app.ui.fragments.RaceFragment;
+import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.startphase.LeagueStartphaseRaceFragment;
+import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.finished.LeagueFinishedRaceFragment;
+import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.finishing.LeagueFinishingRaceFragment;
+import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.running.LeagueRunningRaceFragment;
+
+public class LeagueRaceInfoFragmentChooser extends RaceInfoFragmentChooser {
+
+    @Override
+    protected Class<? extends RaceFragment> getStartphaseFragment() {
+        return LeagueStartphaseRaceFragment.class;
+    }
+    
+    @Override
+    protected Class<? extends RaceFragment> getRunningFragment() {
+        return LeagueRunningRaceFragment.class;
+    }
+
+    @Override
+    protected Class<? extends RaceFragment> getFinishingFragment() {
+        return LeagueFinishingRaceFragment.class;
+    }
+
+    @Override
+    protected Class<? extends RaceFragment> getFinishedFragment() {
+        return LeagueFinishedRaceFragment.class;
+    }
+
+}

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/chooser/RaceInfoFragmentChooser.java

@@ -1,73 +1,60 @@
-package com.sap.sailing.racecommittee.app.ui.fragments.chooser;
-
-import android.content.Context;
-
-import com.sap.sailing.android.shared.logging.ExLog;
-import com.sap.sailing.domain.common.racelog.RacingProcedureType;
-import com.sap.sailing.racecommittee.app.domain.ManagedRace;
-import com.sap.sailing.racecommittee.app.ui.fragments.RaceFragment;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.ErrorRaceFragment;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.StartTimeFragment;
-
-public abstract class RaceInfoFragmentChooser {
-    private static final String TAG = RaceInfoFragmentChooser.class.getName();
-    
-    public static RaceInfoFragmentChooser on(RacingProcedureType racingProcedureType) {
-        return new BasicRaceInfoFragmentChooser();
-
-//        switch (racingProcedureType) {
-//            case RRS26:
-//                return new RRS26RaceInfoFragmentChooser();
-//            case GateStart:
-//                return new GateStartRaceInfoFragmentChooser();
-//            case ESS:
-//                return new ESSRaceInfoFragmentChooser();
-//            case BASIC:
-//                return new BasicRaceInfoFragmentChooser();
-//            default:
-//                throw new UnsupportedOperationException(racingProcedureType.toString());
-//        }
-    }
-    
-    protected abstract Class<? extends RaceFragment> getStartphaseFragment();
-    protected abstract Class<? extends RaceFragment> getRunningFragment();
-    protected abstract Class<? extends RaceFragment> getFinishingFragment();
-    protected abstract Class<? extends RaceFragment> getFinishedFragment();
-
-    public RaceFragment choose(Context context, ManagedRace managedRace) {
-        switch (managedRace.getStatus()) {
-            case UNSCHEDULED:
-                return createInfoFragment(StartTimeFragment.newInstance(1), managedRace);
-            case SCHEDULED:
-            case STARTPHASE:
-                return createInfoFragment(context, getStartphaseFragment(), managedRace);
-            case RUNNING:
-                return createInfoFragment(context, getRunningFragment(), managedRace);
-            case FINISHING:
-                return createInfoFragment(context, getFinishingFragment(), managedRace);
-            case FINISHED:
-                return createInfoFragment(context, getFinishedFragment(), managedRace);
-            default:
-                return createInfoFragment(context, ErrorRaceFragment.class, managedRace);
-        }
-    }
-
-    protected RaceFragment createInfoFragment(Context context, Class<? extends RaceFragment> fragmentClass, ManagedRace managedRace) {
-        try {
-            RaceFragment fragment = fragmentClass.newInstance();
-            return createInfoFragment(fragment, managedRace);
-        } catch (Exception e) {
-            ExLog.e(context, TAG, String.format("Exception while instantiating race info fragment:\n%s", e.toString()));
-            return new ErrorRaceFragment();
-        }
-    }
-
-    protected RaceFragment createInfoFragment(RaceFragment fragment, ManagedRace managedRace) {
-        fragment.setArguments(RaceFragment.createArguments(managedRace));
-        return fragment;
-    }
-
-    public RaceFragment getStartFragment(Context context, ManagedRace managedRace) {
-        return createInfoFragment(context, getStartphaseFragment(), managedRace);
-    }
-}
+package com.sap.sailing.racecommittee.app.ui.fragments.chooser;
+
+import android.content.Context;
+
+import com.sap.sailing.android.shared.logging.ExLog;
+import com.sap.sailing.domain.common.racelog.RacingProcedureType;
+import com.sap.sailing.racecommittee.app.domain.ManagedRace;
+import com.sap.sailing.racecommittee.app.ui.fragments.RaceFragment;
+import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.ErrorRaceFragment;
+import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.StartTimeFragment;
+
+public abstract class RaceInfoFragmentChooser {
+    private static final String TAG = RaceInfoFragmentChooser.class.getName();
+    
+    public static RaceInfoFragmentChooser on(RacingProcedureType racingProcedureType) {
+        return new BasicRaceInfoFragmentChooser();
+    }
+    
+    protected abstract Class<? extends RaceFragment> getStartphaseFragment();
+    protected abstract Class<? extends RaceFragment> getRunningFragment();
+    protected abstract Class<? extends RaceFragment> getFinishingFragment();
+    protected abstract Class<? extends RaceFragment> getFinishedFragment();
+
+    public RaceFragment choose(Context context, ManagedRace managedRace) {
+        switch (managedRace.getStatus()) {
+            case UNSCHEDULED:
+                return createInfoFragment(StartTimeFragment.newInstance(1), managedRace);
+            case SCHEDULED:
+            case STARTPHASE:
+                return createInfoFragment(context, getStartphaseFragment(), managedRace);
+            case RUNNING:
+                return createInfoFragment(context, getRunningFragment(), managedRace);
+            case FINISHING:
+                return createInfoFragment(context, getFinishingFragment(), managedRace);
+            case FINISHED:
+                return createInfoFragment(context, getFinishedFragment(), managedRace);
+            default:
+                return createInfoFragment(context, ErrorRaceFragment.class, managedRace);
+        }
+    }
+
+    protected RaceFragment createInfoFragment(Context context, Class<? extends RaceFragment> fragmentClass, ManagedRace managedRace) {
+        try {
+            RaceFragment fragment = fragmentClass.newInstance();
+            return createInfoFragment(fragment, managedRace);
+        } catch (Exception e) {
+            ExLog.e(context, TAG, String.format("Exception while instantiating race info fragment:\n%s", e.toString()));
+            return new ErrorRaceFragment();
+        }
+    }
+
+    protected RaceFragment createInfoFragment(RaceFragment fragment, ManagedRace managedRace) {
+        fragment.setArguments(RaceFragment.createArguments(managedRace));
+        return fragment;
+    }
+
+    public RaceFragment getStartFragment(Context context, ManagedRace managedRace) {
+        return createInfoFragment(context, getStartphaseFragment(), managedRace);
+    }
+}

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/raceinfo/finished/LeagueFinishedRaceFragment.java

@@ -0,0 +1,47 @@
+package com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.finished;
+
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.LeagueRacingProcedure;
+import com.sap.sailing.racecommittee.app.R;
+import com.sap.sailing.racecommittee.app.ui.fragments.dialogs.PositioningFragment;
+import com.sap.sailing.racecommittee.app.utils.TimeUtils;
+import com.sap.sse.common.TimePoint;
+
+public class LeagueFinishedRaceFragment extends BaseFinishedRaceFragment<LeagueRacingProcedure> {
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        Button positioningButton = (Button) getView().findViewById(R.id.buttonPositioning);
+        positioningButton.setVisibility(Button.VISIBLE);
+        positioningButton.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                PositioningFragment fragment = new PositioningFragment();
+                fragment.setArguments(PositioningFragment.createArguments(getRace()));
+                fragment.show(getFragmentManager(), null);
+            }
+        });
+    }
+    
+    private TimePoint getTimeLimit() {
+        TimePoint startTime = getRaceState().getStartTime();
+        TimePoint firstBoatTime = getRaceState().getFinishingTime();
+        if (startTime == null || firstBoatTime == null) {
+            return null;
+        }
+        return firstBoatTime.plus((long) ((firstBoatTime.asMillis() - startTime.asMillis()) * 0.75));
+    }
+
+    protected CharSequence getTimeLimitText() {
+        TimePoint timeLimit = getTimeLimit();
+        if (timeLimit != null) {
+            return String.format(getString(R.string.race_time_limit), TimeUtils.formatTime(timeLimit));
+        }
+        return getString(R.string.empty);
+    }
+}

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/raceinfo/finishing/LeagueFinishingRaceFragment.java

@@ -0,0 +1,7 @@
+package com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.finishing;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.LeagueRacingProcedure;
+
+public class LeagueFinishingRaceFragment extends BaseFinishingRaceFragment<LeagueRacingProcedure> {
+
+}

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/raceinfo/running/LeagueRunningRaceFragment.java

@@ -0,0 +1,7 @@
+package com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.running;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.LeagueRacingProcedure;
+
+public class LeagueRunningRaceFragment extends BaseRunningRaceFragment<LeagueRacingProcedure> {
+
+}

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/raceinfo/startphase/LeagueStartphaseRaceFragment.java

@@ -0,0 +1,8 @@
+package com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.startphase;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.LeagueRacingProcedure;
+
+
+public class LeagueStartphaseRaceFragment extends BaseStartphaseRaceFragment<LeagueRacingProcedure> {
+
+}