Merge remote-tracking branch 'server/gwt' into gwt

java/com.sap.sailing.gwt.ui/.settings/com.google.gdt.eclipse.core.prefs

@@ -1,7 +1,7 @@
-#Wed Dec 07 09:21:39 CET 2011
+#Thu Dec 08 15:04:04 CET 2011
 eclipse.preferences.version=1
 jarsExcludedFromWebInfLib=
-lastWarOutDir=C\:/data/SAP/sailing/workspace/java/com.sap.sailing.gwt.ui/war
+lastWarOutDir=C\:/Users/d056995/git/git/java/com.sap.sailing.gwt.ui/war
 launchConfigExternalUrlPrefix=
 warSrcDir=war
 warSrcDirIsOutput=false

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

@@ -39,7 +39,7 @@ import com.sap.sailing.gwt.ui.shared.RegattaDAO;
 import com.sap.sailing.gwt.ui.shared.Triple;
 import com.sap.sailing.server.api.EventNameAndRaceName;
 
-public class LeaderboardConfigPanel extends FormPanel implements EventDisplayer, RaceSelectionChangeListener {
+public class LeaderboardConfigPanel extends FormPanel implements EventDisplayer, RaceSelectionChangeListener, TrackedRaceChangedListener {
 
     // AXEL: DON'T DELETE!!!
     // private static final int MAX_NUMBER_OF_DISCARDED_RESULTS = 4;
@@ -247,7 +247,7 @@ public class LeaderboardConfigPanel extends FormPanel implements EventDisplayer,
         trackedEventsComposite = new TrackedEventsComposite(sailingService, errorReporter, adminConsole,
                 stringConstants, /* multiselection */false);
         trackedRacesPanel.add(trackedEventsComposite);
-        trackedEventsComposite.addRaceSelectionChangeListener(this);
+        trackedEventsComposite.addTrackedRaceChangeListener(this);
 
         HorizontalPanel hPanel = new HorizontalPanel();
         hPanel.setSpacing(5);
@@ -716,6 +716,18 @@ public class LeaderboardConfigPanel extends FormPanel implements EventDisplayer,
     public void fillEvents(List<EventDAO> result) {
         trackedEventsComposite.fillEvents(result);
     }
+    
+
+    @Override
+    public void changeTrackingRace(EventNameAndRaceName eventNameAndRaceName, boolean isTracked) {
+        for (RaceInLeaderboardDAO race : raceColumnList.getList()) {
+            if(race.getRaceColumnName().equals(eventNameAndRaceName.getRaceName())){
+                race.setTrackedRace(isTracked);
+            }
+        }
+        raceColumnList.refresh();
+    }
+    
 
     private void addNewLeaderboard() {
         List<String> leaderboardNames = new ArrayList<String>();

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

@@ -47,6 +47,8 @@ public interface SailingService extends RemoteService {
     void stopTrackingEvent(EventIdentifier eventIdentifier) throws Exception;
 
     void stopTrackingRace(EventAndRaceIdentifier eventAndRaceIdentifier) throws Exception;
+    
+    void removeAndUntrackedRace(EventAndRaceIdentifier eventAndRaceidentifier) throws Exception;
 
     WindInfoForRaceDAO getWindInfo(RaceIdentifier raceIdentifier, Date from, Date to,
             boolean includeTrackBasedWindEstimation);

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

@@ -57,6 +57,13 @@ public interface SailingServiceAsync {
     void stopTrackingEvent(EventIdentifier eventIdentifier, AsyncCallback<Void> callback);
 
     void stopTrackingRace(EventAndRaceIdentifier raceIdentifier, AsyncCallback<Void> asyncCallback);
+    
+    /**
+     * Untracks the race and removes it from the event. It will also be removed in all leaerboards
+     * @param eventAndRaceidentifier The identifier for the event name, and the race name to remove
+     * @throws Exception
+     */
+    void removeAndUntrackedRace(EventAndRaceIdentifier eventAndRaceidentifier, AsyncCallback<Void> callback);
 
     void getWindInfo(RaceIdentifier raceIdentifier, Date from, Date to, boolean includeTrackBasedWindEstimation,
             AsyncCallback<WindInfoForRaceDAO> callback);

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

@@ -42,6 +42,8 @@ import com.sap.sailing.server.api.EventNameAndRaceName;
 public class TrackedEventsComposite extends FormPanel implements EventDisplayer, RaceSelectionProvider {
     private final Set<RaceSelectionChangeListener> raceSelectionChangeListeners;
 
+    private final Set<TrackedRaceChangedListener> raceIsTrackedRaceChangeListener;
+
     private final boolean multiSelection;
 
     private boolean dontFireNextSelectionChangeEvent;
@@ -65,13 +67,16 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
     private final ErrorReporter errorReporter;
     private final EventRefresher eventRefresher;
 
-    private Button btnRemove = null;
+    private Button btnUntrack = null;
     private Button btnRefresh = null;
+    private Button btnRemoveRace = null;
 
     private TextBox filterRacesTextbox;
 
     private List<Triple<EventDAO, RegattaDAO, RaceDAO>> availableRaceList;
 
+    private Triple<EventDAO, RegattaDAO, RaceDAO> lastSelectedTriple;
+
     public TrackedEventsComposite(final SailingServiceAsync sailingService, final ErrorReporter errorReporter,
             final EventRefresher eventRefresher, StringConstants stringConstants, boolean hasMultiSelection) {
         this.sailingService = sailingService;
@@ -79,8 +84,11 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
         this.eventRefresher = eventRefresher;
         this.multiSelection = hasMultiSelection;
         this.raceSelectionChangeListeners = new HashSet<RaceSelectionChangeListener>();
+        this.raceIsTrackedRaceChangeListener = new HashSet<TrackedRaceChangedListener>();
         this.availableRaceList = new ArrayList<Triple<EventDAO, RegattaDAO, RaceDAO>>();
 
+        this.lastSelectedTriple = null;
+
         raceList = new ListDataProvider<Triple<EventDAO, RegattaDAO, RaceDAO>>();
 
         selectionModel = multiSelection ? new MultiSelectionModel<Triple<EventDAO, RegattaDAO, RaceDAO>>()
@@ -106,14 +114,14 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
                 List<String> wordsToFilter = Arrays.asList(text.split(" "));
                 raceList.getList().clear();
                 raceList.getList().addAll(availableRaceList);
-                racesToHold = new ArrayList<Triple<EventDAO,RegattaDAO,RaceDAO>>();
+                racesToHold = new ArrayList<Triple<EventDAO, RegattaDAO, RaceDAO>>();
                 if (text == null || text.isEmpty()) {
                     racesToHold.addAll(availableRaceList);
                 } else {
                     for (String word : wordsToFilter) {
                         // TODO improve search algorithm
                         String textAsUppercase = word.toUpperCase();
-                        racesToHold = new ArrayList<Triple<EventDAO,RegattaDAO,RaceDAO>>();
+                        racesToHold = new ArrayList<Triple<EventDAO, RegattaDAO, RaceDAO>>();
                         for (Triple<EventDAO, RegattaDAO, RaceDAO> triple : raceList.getList()) {
                             if (triple.getA().name.toUpperCase().contains(textAsUppercase)
                                     || triple.getB().boatClass.name.toUpperCase().contains(textAsUppercase)
@@ -287,7 +295,16 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
         raceTable.getSelectionModel().addSelectionChangeHandler(new Handler() {
             @Override
             public void onSelectionChange(SelectionChangeEvent event) {
-                fireRaceSelectionChanged(getSelectedEventAndRace());
+                List<Triple<EventDAO, RegattaDAO, RaceDAO>> selectedEventAndRace = getSelectedEventAndRace();
+                lastSelectedTriple = selectedEventAndRace.get(0);
+                if (selectedEventAndRace == null) {
+                    btnRemoveRace.setEnabled(false);
+                    btnUntrack.setEnabled(false);
+                } else {
+                    btnRemoveRace.setEnabled(true);
+                    btnUntrack.setEnabled(true);
+                }
+                fireRaceSelectionChanged(selectedEventAndRace);
             }
         });
 
@@ -296,9 +313,22 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
         trackedRacesButtonPanel.setSpacing(10);
         panel.add(trackedRacesButtonPanel);
 
-        btnRemove = new Button("Stop tracking");
+        btnRemoveRace = new Button(stringConstants.remove());
+        btnRemoveRace.addClickHandler(new ClickHandler() {
+
+            @Override
+            public void onClick(ClickEvent event) {
+                for (Triple<EventDAO, RegattaDAO, RaceDAO> selection : getSelectedEventAndRace()) {
+                    removeAndUntrackRace(selection.getA(), selection.getC());
+                }
+            }
+        });
+        btnRemoveRace.setEnabled(false);
+        trackedRacesButtonPanel.add(btnRemoveRace);
+
+        btnUntrack = new Button("Stop tracking");
         // btnRemove = new Button(stringConstants.remove());
-        btnRemove.addClickHandler(new ClickHandler() {
+        btnUntrack.addClickHandler(new ClickHandler() {
             @Override
             public void onClick(ClickEvent click) {
                 for (Triple<EventDAO, RegattaDAO, RaceDAO> selection : getSelectedEventAndRace()) {
@@ -308,7 +338,8 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
                 }
             }
         });
-        trackedRacesButtonPanel.add(btnRemove);
+        btnUntrack.setEnabled(false);
+        trackedRacesButtonPanel.add(btnUntrack);
 
         btnRefresh = new Button(stringConstants.refresh());
         btnRefresh.addClickHandler(new ClickHandler() {
@@ -382,12 +413,14 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
     public void fillEvents(List<EventDAO> events) {
         if (events.size() == 0) {
             raceTable.setVisible(false);
-            btnRemove.setVisible(false);
+            btnUntrack.setEnabled(false);
+            btnRemoveRace.setEnabled(false);
             noTrackedRacesLabel.setVisible(true);
         } else {
             raceTable.setVisible(true);
             if (eventRefresher != null) {
-                btnRemove.setVisible(true);
+                btnUntrack.setEnabled(true);
+                btnRemoveRace.setEnabled(true);
             }
             noTrackedRacesLabel.setVisible(false);
         }
@@ -411,10 +444,18 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
                 }
             }
         }
+        if (lastSelectedTriple != null) {
+            selectRaceByName(lastSelectedTriple.getA().name, lastSelectedTriple.getC().name);
+        }
+    }
+
+    public void addTrackedRaceChangeListener(TrackedRaceChangedListener listener) {
+        this.raceIsTrackedRaceChangeListener.add(listener);
     }
 
     private void stopTrackingRace(final EventDAO event, final RaceDAO race) {
-        sailingService.stopTrackingRace(new EventNameAndRaceName(event.name, race.name), new AsyncCallback<Void>() {
+        final EventNameAndRaceName eventNameAndRaceName = new EventNameAndRaceName(event.name, race.name);
+        sailingService.stopTrackingRace(eventNameAndRaceName, new AsyncCallback<Void>() {
             @Override
             public void onFailure(Throwable caught) {
                 errorReporter.reportError("Exception trying to stop tracking race " + race.name + "in event "
@@ -424,8 +465,28 @@ public class TrackedEventsComposite extends FormPanel implements EventDisplayer,
             @Override
             public void onSuccess(Void result) {
                 eventRefresher.fillEvents();
+                for (TrackedRaceChangedListener listener : raceIsTrackedRaceChangeListener) {
+                    listener.changeTrackingRace(eventNameAndRaceName, false);
+                }
             }
         });
     }
 
+    private void removeAndUntrackRace(final EventDAO event, final RaceDAO race) {
+        sailingService.removeAndUntrackedRace(new EventNameAndRaceName(event.name, race.name),
+                new AsyncCallback<Void>() {
+
+                    @Override
+                    public void onFailure(Throwable caught) {
+                        errorReporter.reportError("Exception trying to stop tracking race " + race.name + "in event "
+                                + event.name + ": " + caught.getMessage());
+                    }
+
+                    @Override
+                    public void onSuccess(Void result) {
+                        eventRefresher.fillEvents();
+                    }
+                });
+    }
+
 }

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

@@ -0,0 +1,7 @@
+package com.sap.sailing.gwt.ui.client;
+
+import com.sap.sailing.server.api.EventNameAndRaceName;
+
+public interface TrackedRaceChangedListener {
+    void changeTrackingRace(EventNameAndRaceName eventNameAndRaceName, boolean isTracked);
+}

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

@@ -473,6 +473,18 @@ public class SailingServiceImpl extends RemoteServiceServlet implements SailingS
         }
     }
     
+    @Override
+    public void removeAndUntrackedRace(EventAndRaceIdentifier eventAndRaceidentifier) throws Exception{
+        Event event = getEvent(eventAndRaceidentifier);
+        if(event!= null){
+            RaceDefinition race = getRace(eventAndRaceidentifier);
+            if(race != null){
+                getService().stopRemoveTrackedRace(event, race);
+            }
+        }
+        
+    }
+    
     /**
      * @param timeoutInMilliseconds eventually passed to {@link RacesHandle#getRaces(long)}. If the race definition
      * can be obtained within this timeout, wind for the race will be tracked; otherwise, the method returns without

java/com.sap.sailing.server/src/com/sap/sailing/server/RacingEventService.java

@@ -103,6 +103,16 @@ public interface RacingEventService extends TrackedEventRegistry {
      */
     void stopTracking(Event event) throws MalformedURLException, IOException, InterruptedException;
     
+    /**
+     * Stops the race to non-tracked. Removes the race from whole RacingEventService. The race will be also removed from all leaderboards, containing that race. 
+     * @param event the event to remove
+     * @param race the race to remove
+     * @throws MalformedURLException
+     * @throws IOException
+     * @throws InterruptedException
+     */
+    void stopRemoveTrackedRace(Event event, RaceDefinition race) throws MalformedURLException, IOException,InterruptedException;
+    
     /**
      * Stops tracking a single race. Other races of the same event that are currently tracked will continue to be
      * tracked. If wind tracking for the race is currently running, it will be stopped (see also

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

@@ -417,13 +417,9 @@ public class RacingEventServiceImpl implements RacingEventService {
                 if (raceTracker.getRaces() != null && raceTracker.getRaces().contains(race)) {
                     System.out.println("Found tracker to stop...");
                     raceTracker.stop(); // this also removes the TrackedRace from trackedEvent
+                    // do not remove the tracker from raceTrackersByEvent, because it should still exist there, but with the state "non-tracked"
                     trackerIter.remove();
                     raceTrackersByID.remove(raceTracker.getID());
-                    for (RaceDefinition trackerRace : raceTracker.getRaces()) {
-                        // remove from default leaderboard
-                        Leaderboard defaultLeaderboard = getLeaderboardByName(DEFAULT_LEADERBOARD_NAME);
-                        defaultLeaderboard.removeRaceColumn(trackerRace.getName());
-                    }
                 }
             }
         } else {
@@ -435,6 +431,44 @@ public class RacingEventServiceImpl implements RacingEventService {
             stopTracking(event);
         }
     }
+    
+    @Override
+    public synchronized void stopRemoveTrackedRace(Event event, RaceDefinition race) throws MalformedURLException, IOException, InterruptedException{
+        logger.info("Removing the race + " + race + "...");
+        if(raceTrackersByEvent.containsKey(event)){
+            Iterator<RaceTracker> trackerIter = raceTrackersByEvent.get(event).iterator();
+            while(trackerIter.hasNext()){
+                RaceTracker raceTracker = trackerIter.next();
+                if(raceTracker.getRaces() != null && raceTracker.getRaces().contains(race)){
+                    System.out.println("Found tracker to remove");
+                    // firstly stop the tracker
+                    raceTracker.stop();
+                    // remove it from the raceTrackers by Event
+                    trackerIter.remove();
+                    raceTrackersByID.remove(raceTracker.getID());
+                    for (RaceDefinition trackerRace : raceTracker.getRaces()) {
+                        // remove from every leaderboard
+                        Map<String, Leaderboard> leaderboards = getLeaderboards();
+                        for (Map.Entry<String, Leaderboard> entry : leaderboards.entrySet()) {
+                            if(entry.getValue().getRaceColumnByName(race.getName()) != null){
+                                getLeaderboardByName(entry.getKey()).removeRaceColumn(trackerRace.getName());                                
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // remove the race from the event
+        if(eventsByName.containsKey(event.getName())){
+            eventsByName.get(event.getName()).removeRace(race);
+        }
+        
+        stopTrackingWind(event, race);
+     // if the last tracked race was removed, remove the entire event
+        if (raceTrackersByEvent.get(event).isEmpty()) {
+            stopTracking(event);
+        }
+    }
 
     @Override
     public void startTrackingWind(Event event, RaceDefinition race,