bug6237: result and error handling/display for tracking times revocation

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/racelog/tracking/TrackingTimesRevocationErrorCode.java

@@ -0,0 +1,15 @@
+package com.sap.sailing.domain.common.racelog.tracking;
+
+/**
+ * Error codes for the revocation of tracking times. These are used to report errors that occur during the revocation
+ * process, e.g. when there is no regatta leaderboard or when there are no automated tracking times.
+ * 
+ * @see com.sap.sailing.domain.racelogtracking.TrackingTimesRevocationReport
+ * 
+ * @author Axel Uhl (d043530)
+ *
+ */
+public enum TrackingTimesRevocationErrorCode {
+    NO_REGATTA_LEADERBOARD,
+    NO_AUTOMATED_TRACKING_TIMES
+}

java/com.sap.sailing.domain.racelogtrackingadapter/src/com/sap/sailing/domain/racelogtracking/RaceLogTrackingAdapter.java

@@ -141,5 +141,5 @@ public interface RaceLogTrackingAdapter {
     void copyPairingListFromOtherLeaderboard(RegattaLeaderboard sourceLeaderboard, RegattaLeaderboard targetLeaderboard,
             String fromRaceColumnName, String toRaceColumnInclusiveName) throws NotFoundException;
 
-    void revokeExplicitTrackingTimes(RegattaLeaderboard leaderboard, RacingEventService raceLogResolver);
+    TrackingTimesRevocationReport revokeExplicitTrackingTimes(RegattaLeaderboard leaderboard, RacingEventService raceLogResolver);
 }

java/com.sap.sailing.domain.racelogtrackingadapter/src/com/sap/sailing/domain/racelogtracking/TrackingTimesRevocationReport.java

@@ -0,0 +1,31 @@
+package com.sap.sailing.domain.racelogtracking;
+
+import java.util.Map;
+import java.util.Set;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.common.racelog.tracking.TrackingTimesRevocationErrorCode;
+import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.Util.Pair;
+
+public interface TrackingTimesRevocationReport {
+    /**
+     * @return {@code null} means no error
+     */
+    TrackingTimesRevocationErrorCode getErrorCode();
+
+    void revoked(RaceColumn raceColumn, Fleet fleet, RaceLogEvent event);
+
+    void notRevokedBecauseOfMissingStartOrFinishTime(RaceColumn raceColumn, Fleet fleet, TimePoint startTime, TimePoint finishedTime);
+
+    void notRevokedBecauseNotForTracking(RaceColumn raceColumn, Fleet fleet);
+
+    Map<Pair<RaceColumn, Fleet>, Pair<TimePoint, TimePoint>> getNotRevokedBecauseOfMissingStartOfFinishTime();
+
+    Map<Pair<RaceColumn, Fleet>, Set<RaceLogEvent>> getRevokedEvents();
+
+    Iterable<Pair<RaceColumn, Fleet>> getNotRevokedBecauseNotForTracking();
+
+}

java/com.sap.sailing.domain.racelogtrackingadapter/src/com/sap/sailing/domain/racelogtracking/impl/RaceLogTrackingAdapterImpl.java

@@ -73,6 +73,7 @@ import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
 import com.sap.sailing.domain.racelogtracking.DeviceMappingWithRegattaLogEvent;
 import com.sap.sailing.domain.racelogtracking.RaceLogTrackingAdapter;
+import com.sap.sailing.domain.racelogtracking.TrackingTimesRevocationReport;
 import com.sap.sailing.domain.regattalike.LeaderboardThatHasRegattaLike;
 import com.sap.sailing.domain.tracking.RaceHandle;
 import com.sap.sailing.domain.tracking.RaceTrackingHandler;
@@ -471,7 +472,8 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter {
     }
 
     @Override
-    public void revokeExplicitTrackingTimes(RegattaLeaderboard leaderboard, RacingEventService service) {
+    public TrackingTimesRevocationReport revokeExplicitTrackingTimes(RegattaLeaderboard leaderboard, RacingEventService service) {
+        final TrackingTimesRevocationReportImpl result = new TrackingTimesRevocationReportImpl(/* error code */ null /* meaning no error */);
         for (final RaceColumn raceColumn : leaderboard.getRaceColumns()) {
             for (final Fleet fleet : raceColumn.getFleets()) {
                 final RaceLog raceLog = raceColumn.getRaceLog(fleet);
@@ -489,6 +491,7 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter {
                                 if (trackingTimes.getA() != null) {
                                     try {
                                         raceLog.revokeEvent(service.getServerAuthor(), trackingTimes.getA(), "revoke explicit start of tracking time");
+                                        result.revoked(raceColumn, fleet, trackingTimes.getA());
                                     } catch (NotRevokableException e) {
                                         logger.log(Level.WARNING, "could not revoke explicit start of tracking time by adding RevokeEvent", e);
                                     }
@@ -496,15 +499,21 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter {
                                 if (trackingTimes.getB() != null) {
                                     try {
                                         raceLog.revokeEvent(service.getServerAuthor(), trackingTimes.getB(), "revoke explicit end of tracking time");
+                                        result.revoked(raceColumn, fleet, trackingTimes.getB());
                                     } catch (NotRevokableException e) {
                                         logger.log(Level.WARNING, "could not revoke explicit end of tracking time by adding RevokeEvent", e);
                                     }
                                 }
                             }
+                        } else {
+                            result.notRevokedBecauseOfMissingStartOrFinishTime(raceColumn, fleet, startTimeFinderResult != null ? startTimeFinderResult.getStartTime() : null, finishedTime);
                         }
+                    } else {
+                        result.notRevokedBecauseNotForTracking(raceColumn, fleet);
                     }
                 }
             }
         }
+        return result;
     }
 }

java/com.sap.sailing.domain.racelogtrackingadapter/src/com/sap/sailing/domain/racelogtracking/impl/TrackingTimesRevocationReportImpl.java

@@ -0,0 +1,68 @@
+package com.sap.sailing.domain.racelogtracking.impl;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.common.racelog.tracking.TrackingTimesRevocationErrorCode;
+import com.sap.sailing.domain.racelogtracking.TrackingTimesRevocationReport;
+import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.Util.Pair;
+
+public class TrackingTimesRevocationReportImpl implements TrackingTimesRevocationReport {
+    private final Map<Pair<RaceColumn, Fleet>, Set<RaceLogEvent>> revokedEvents;
+    private final Map<Pair<RaceColumn, Fleet>, Pair<TimePoint, TimePoint>> notRevokedBecauseOfMissingStartOrFinishTime;
+    private final List<Pair<RaceColumn, Fleet>> notRevokedBecauseNotForTracking;
+    private final TrackingTimesRevocationErrorCode errorCode;
+
+    public TrackingTimesRevocationReportImpl(TrackingTimesRevocationErrorCode errorCode) {
+        super();
+        this.errorCode = errorCode;
+        this.revokedEvents = new LinkedHashMap<>();
+        this.notRevokedBecauseOfMissingStartOrFinishTime = new LinkedHashMap<>();
+        this.notRevokedBecauseNotForTracking = new ArrayList<>();
+    }
+    
+    @Override
+    public TrackingTimesRevocationErrorCode getErrorCode() {
+        return errorCode;
+    }
+
+    @Override
+    public void revoked(RaceColumn raceColumn, Fleet fleet, RaceLogEvent event) {
+        final Set<RaceLogEvent> set = revokedEvents.computeIfAbsent(new Pair<>(raceColumn, fleet), k->new HashSet<>());
+        set.add(event);
+    }
+
+    @Override
+    public void notRevokedBecauseOfMissingStartOrFinishTime(RaceColumn raceColumn, Fleet fleet, TimePoint startTime, TimePoint finishedTime) {
+        notRevokedBecauseOfMissingStartOrFinishTime.put(new Pair<>(raceColumn, fleet), new Pair<>(startTime, finishedTime));
+    }
+    
+    @Override
+    public void notRevokedBecauseNotForTracking(RaceColumn raceColumn, Fleet fleet) {
+        notRevokedBecauseNotForTracking.add(new Pair<>(raceColumn, fleet));
+    }
+
+    @Override
+    public Map<Pair<RaceColumn, Fleet>, Pair<TimePoint, TimePoint>> getNotRevokedBecauseOfMissingStartOfFinishTime() {
+        return Collections.unmodifiableMap(notRevokedBecauseOfMissingStartOrFinishTime);
+    }
+
+    @Override
+    public Map<Pair<RaceColumn, Fleet>, Set<RaceLogEvent>> getRevokedEvents() {
+        return Collections.unmodifiableMap(revokedEvents);
+    }
+
+    @Override
+    public Iterable<Pair<RaceColumn, Fleet>> getNotRevokedBecauseNotForTracking() {
+        return Collections.unmodifiableList(notRevokedBecauseNotForTracking);
+    }
+}

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

@@ -59,6 +59,7 @@ import com.sap.sailing.gwt.ui.shared.RaceLogSetFinishingAndFinishTimeDTO;
 import com.sap.sailing.gwt.ui.shared.RaceLogSetStartTimeAndProcedureDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaDTO;
 import com.sap.sailing.gwt.ui.shared.StrippedLeaderboardDTO;
+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;
 import com.sap.sse.common.Distance;
 import com.sap.sse.common.Util;
 import com.sap.sse.common.Util.Pair;
@@ -227,17 +228,60 @@ public class SmartphoneTrackingEventManagementPanel extends AbstractLeaderboardC
     
     private void revokeExplicitTrackingTimes() {
         if (Window.confirm(stringMessages.confirmRevokeExplicitTrackingTimes(getSelectedLeaderboard().getName()))) {
-            sailingServiceWrite.revokeExplicitTrackingTimes(getSelectedLeaderboard().getName(), new AsyncCallback<Void>() {
+            sailingServiceWrite.revokeExplicitTrackingTimes(getSelectedLeaderboard().getName(), new AsyncCallback<TrackingTimesRevocationReportDTO>() {
                 @Override
                 public void onFailure(Throwable caught) {
                     errorReporter.reportError(stringMessages.errorRevokingExplicitTrackingTimes(getSelectedLeaderboard().getName(), caught.getMessage()));
                 }
 
                 @Override
-                public void onSuccess(Void result) {
-                    Notification.notify(stringMessages.successfullyREvokedExplicitTrackingTimes(getSelectedLeaderboard().getName()), NotificationType.SUCCESS);
+                public void onSuccess(TrackingTimesRevocationReportDTO result) {
+                    Window.alert(result.getErrorCode() == null ?
+                            stringMessages.successfullyRevokedExplicitTrackingTimes(getSelectedLeaderboard().getName(), i18n(result)) :
+                            stringMessages.errorRevokingExplicitTrackingTimes(getSelectedLeaderboard().getName(), i18n(result)));
                     loadAndRefreshLeaderboard(getSelectedLeaderboard().getName());
                 }
+
+                private String i18n(TrackingTimesRevocationReportDTO report) {
+                    final StringBuilder result = new StringBuilder();
+                    if (report.getErrorCode() != null) {
+                        switch (report.getErrorCode()) {
+                            case NO_REGATTA_LEADERBOARD:
+                                result.append(stringMessages.noRegattaLeaderboard(getSelectedLeaderboard().getName())).append("\n");
+                                break;
+                            case NO_AUTOMATED_TRACKING_TIMES:
+                                result.append(stringMessages.noAutomatedTrackingTimes(getSelectedLeaderboard().getName())).append("\n");
+                                break;
+                            default:
+                                result.append(stringMessages.unknownError(report.getErrorCode().name())).append("\n");
+                        }
+                    } else {
+                        result.append(stringMessages.revokedTrackingTimesForEvents()).append("\n");
+                        report.getRevokedEvents().forEach((raceColumnAndFleet, events)->{
+                            final String raceColumnName = raceColumnAndFleet.getA().getName();
+                            final String fleetName = raceColumnAndFleet.getB().getName();
+                            result.append(" - ").append(raceColumnName).append(" / ").append(fleetName).append("\n");
+                            events.forEach(event->{
+                                result.append("    - ").append(event.getType()).append(" (").append(event.getLogicalTimePoint()).append(")\n");
+                            });
+                        });
+                        result.append(stringMessages.notRevokedTrackingTimesBecauseNotForTracking()).append("\n");
+                        report.getNotRevokedBecauseNotForTracking().forEach(raceColumnAndFleet->{
+                            final String raceColumnName = raceColumnAndFleet.getA().getName();
+                            final String fleetName = raceColumnAndFleet.getB().getName();
+                            result.append(" - ").append(raceColumnName).append(" / ").append(fleetName).append("\n");
+                        });
+                        result.append(stringMessages.notRevokedTrackingTimesBecauseOfMissingStartOrFinishTime()).append("\n");
+                        report.getNotRevokedBecauseOfMissingStartOrFinishTime().forEach((raceColumnAndFleet, startAndEndTime)->{
+                            final String raceColumnName = raceColumnAndFleet.getA().getName();
+                            final String fleetName = raceColumnAndFleet.getB().getName();
+                            result.append(" - ").append(raceColumnName).append(" / ").append(fleetName)
+                                .append(" (").append(stringMessages.startTime()).append(": ").append(startAndEndTime.getA())
+                                .append(", ").append(stringMessages.finishedTime()).append(": ").append(startAndEndTime.getB()).append(")\n");
+                        });
+                    }
+                    return result.toString();
+                }
             });
         }
     }

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

@@ -84,6 +84,7 @@ import com.sap.sailing.gwt.ui.shared.SwissTimingRaceRecordDTO;
 import com.sap.sailing.gwt.ui.shared.TracTracConfigurationWithSecurityDTO;
 import com.sap.sailing.gwt.ui.shared.TracTracRaceRecordDTO;
 import com.sap.sailing.gwt.ui.shared.TrackFileImportDeviceIdentifierDTO;
+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;
 import com.sap.sailing.gwt.ui.shared.TypedDeviceMappingDTO;
 import com.sap.sailing.gwt.ui.shared.UrlDTO;
 import com.sap.sailing.gwt.ui.shared.VenueDTO;
@@ -763,5 +764,5 @@ public interface SailingServiceWrite extends FileStorageManagementGwtService, Sa
     void copyPairingListFromOtherLeaderboard(String sourceLeaderboardName, String targetLeaderboardName, String fromRaceColumnName,
             String toRaceColumnInclusiveName) throws UnauthorizedException, NotFoundException;
     
-    void revokeExplicitTrackingTimes(String leaderboardName) throws NotFoundException;
+    TrackingTimesRevocationReportDTO revokeExplicitTrackingTimes(String leaderboardName) throws NotFoundException;
 }

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

@@ -72,6 +72,7 @@ import com.sap.sailing.gwt.ui.shared.SwissTimingRaceRecordDTO;
 import com.sap.sailing.gwt.ui.shared.TracTracConfigurationWithSecurityDTO;
 import com.sap.sailing.gwt.ui.shared.TracTracRaceRecordDTO;
 import com.sap.sailing.gwt.ui.shared.TrackFileImportDeviceIdentifierDTO;
+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;
 import com.sap.sailing.gwt.ui.shared.TypedDeviceMappingDTO;
 import com.sap.sailing.gwt.ui.shared.UrlDTO;
 import com.sap.sailing.gwt.ui.shared.VenueDTO;
@@ -791,5 +792,5 @@ public interface SailingServiceWriteAsync extends FileStorageManagementGwtServic
      * Precondition: The leaderboard must be a {@link RegattaLeaderboard}, and the corresponding regatta must be in more
      * {@link Regatta#isControlTrackingFromStartAndFinishTimes()}
      */
-    void revokeExplicitTrackingTimes(String leaderboardName, AsyncCallback<Void> asyncCallback);
+    void revokeExplicitTrackingTimes(String leaderboardName, AsyncCallback<TrackingTimesRevocationReportDTO> asyncCallback);
 }

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

@@ -105,6 +105,7 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String event();
     String startTime();
     String endTime();
+    String finishedTime();
     String startOfTracking();
     String endOfTracking();
     String regatta();
@@ -2558,5 +2559,11 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String revokeExplicitTrackingTimes();
     String confirmRevokeExplicitTrackingTimes(String leaderboardName);
     String errorRevokingExplicitTrackingTimes(String leaderboardName, String message);
-    String successfullyREvokedExplicitTrackingTimes(String leaderboardName);
+    String successfullyRevokedExplicitTrackingTimes(String leaderboardName, String formattedAndTranslatedReport);
+    String revokedTrackingTimesForEvents();
+    String notRevokedTrackingTimesBecauseNotForTracking();
+    String notRevokedTrackingTimesBecauseOfMissingStartOrFinishTime();
+    String noRegattaLeaderboard(String leaderboardName);
+    String noAutomatedTrackingTimes(String leaderboardName);
+    String unknownError(String name);
 }

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

@@ -111,6 +111,7 @@ regattaName=Regatta name
 eventName=Event name
 event=Event
 startTime=Start time
+finishedTime=Finished time
 endTime=End time
 startOfTracking=Start of tracking
 endOfTracking=End of tracking
@@ -2594,4 +2595,10 @@ sourceCode=Source Code
 revokeExplicitTrackingTimes=Revoke explicit tracking times for races with valid start and finishing times
 confirmRevokeExplicitTrackingTimes=Really revoke explicit tracking times for all races of leaderboard {0} that have valid start and finishing times?
 errorRevokingExplicitTrackingTimes=Error revoking explicit tracking times for leaderboard {0}: {1}
-successfullyREvokedExplicitTrackingTimes=Successfully revoked explicit tracking times for leaderboard {0}
+successfullyRevokedExplicitTrackingTimes=Successfully revoked explicit tracking times for leaderboard {0}: {1}
+revokedTrackingTimesForEvents=Revoked tracking times for events:
+notRevokedTrackingTimesBecauseNotForTracking=Not revoked tracking times for events that are not tracked:
+notRevokedTrackingTimesBecauseOfMissingStartOrFinishTime=Not revoked tracking times for events with missing start or finish time:
+noRegattaLeaderboard=Leaderboard {0} is not a regatta leaderboard.
+noAutomatedTrackingTimes=Leaderboard {0} has no automated tracking times.
+unknownError=Unknown error: {0}

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

@@ -112,6 +112,7 @@ regattaName=Name der Regatta
 eventName=Event-Name
 event=Veranstaltung
 startTime=Startzeit
+finishedTime=Zielenlauf-Endezeit
 endTime=Schlusszeit
 startOfTracking=Start des Trackings
 endOfTracking=Ende des Trackings
@@ -2588,4 +2589,10 @@ sourceCode=Quellcode
 revokeExplicitTrackingTimes=Explizite Tracking-Zeiten zurücksetzen für Rennen mit gültigen Start- und Endzeitpunkten
 confirmRevokeExplicitTrackingTimes=Wirklich explizite Tracking-Zeiten zurücksetzen für Rennen mit gültigen Start- und Endzeitpunkten der Rangliste {0}?
 errorRevokingExplicitTrackingTimes=Fehler beim Zurücksetzen expliziter Tracking-Zeiten für Rennen mit gültigen Start- und Endzeitpunkten der Rangliste {0}: {1}
-successfullyREvokedExplicitTrackingTimes=Explizite Tracking-Zeiten erfolgreich zurückgesetzt für Rangliste {0}
+successfullyRevokedExplicitTrackingTimes=Explizite Tracking-Zeiten erfolgreich zurückgesetzt für Rangliste {0}: {1}
+revokedTrackingTimesForEvents=Widerrufene explizite Tracking-Zeiten:
+notRevokedTrackingTimesBecauseNotForTracking=Nicht widerrufene explizite Tracking-Zeiten für nicht getrackte Rennen:
+notRevokedTrackingTimesBecauseOfMissingStartOrFinishTime=Nicht widerrufene explizite Tracking-Zeiten für Rennen mit ungültigen Start- oder Endzeitpunkten:
+noRegattaLeaderboard=Rangliste {0} ist keine Regatta-Rangliste.
+noAutomatedTrackingTimes=Rangliste {0} nutzt keine automatisierten Tracking-Zeiten, auf die zurückgesetzt werden könnte. 
+unknownError=Unbekannter Fehler: {0}

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

@@ -207,6 +207,7 @@ import com.sap.sailing.domain.common.racelog.tracking.DoesNotHaveRegattaLogExcep
 import com.sap.sailing.domain.common.racelog.tracking.MarkAlreadyUsedInRaceException;
 import com.sap.sailing.domain.common.racelog.tracking.NotDenotableForRaceLogTrackingException;
 import com.sap.sailing.domain.common.racelog.tracking.NotDenotedForRaceLogTrackingException;
+import com.sap.sailing.domain.common.racelog.tracking.TrackingTimesRevocationErrorCode;
 import com.sap.sailing.domain.common.security.SecuredDomainType;
 import com.sap.sailing.domain.common.security.SecuredDomainType.EventActions;
 import com.sap.sailing.domain.common.tagging.RaceLogNotFoundException;
@@ -288,6 +289,7 @@ import com.sap.sailing.gwt.ui.shared.SwissTimingRaceRecordDTO;
 import com.sap.sailing.gwt.ui.shared.TracTracConfigurationWithSecurityDTO;
 import com.sap.sailing.gwt.ui.shared.TracTracRaceRecordDTO;
 import com.sap.sailing.gwt.ui.shared.TrackFileImportDeviceIdentifierDTO;
+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;
 import com.sap.sailing.gwt.ui.shared.TypedDeviceMappingDTO;
 import com.sap.sailing.gwt.ui.shared.UrlDTO;
 import com.sap.sailing.gwt.ui.shared.VenueDTO;
@@ -4197,22 +4199,21 @@ public class SailingServiceWriteImpl extends SailingServiceImpl implements Saili
     }
 
     @Override
-    public void revokeExplicitTrackingTimes(String leaderboardName) throws NotFoundException {
+    public TrackingTimesRevocationReportDTO revokeExplicitTrackingTimes(String leaderboardName) throws NotFoundException {
         final Leaderboard leaderboard = getLeaderboardByName(leaderboardName);
         getService().getSecurityService().checkCurrentUserUpdatePermission(leaderboard);
+        final TrackingTimesRevocationReportDTO result;
         if (leaderboard instanceof RegattaLeaderboard) {
             final Regatta regatta = ((RegattaLeaderboard) leaderboard).getRegatta();
             if (regatta.isControlTrackingFromStartAndFinishTimes()) {
-                getRaceLogTrackingAdapter().revokeExplicitTrackingTimes((RegattaLeaderboard) leaderboard, /* raceLogResolver */ getService());
+                result = new TrackingTimesRevocationReportDTO(getRaceLogTrackingAdapter().revokeExplicitTrackingTimes(
+                        (RegattaLeaderboard) leaderboard, /* raceLogResolver */ getService()));
             } else {
-                throw new IllegalStateException("Leaderboard " + leaderboardName
-                        + " is not configured to control tracking from start and finish times, so explicit tracking times should not exist and thus cannot be revoked.");
+                result = new TrackingTimesRevocationReportDTO(TrackingTimesRevocationErrorCode.NO_AUTOMATED_TRACKING_TIMES);
             }
         } else {
-            throw new IllegalArgumentException("Leaderboard " + leaderboardName
-                    + " must be a regatta leaderboard, but was: " + leaderboard.getLeaderboardType());
+           result = new TrackingTimesRevocationReportDTO(TrackingTimesRevocationErrorCode.NO_REGATTA_LEADERBOARD);
         }
-        // TODO Auto-generated method stub
-        
+        return result;
     }
 }

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

@@ -0,0 +1,97 @@
+package com.sap.sailing.gwt.ui.shared;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import com.google.gwt.core.shared.GwtIncompatible;
+import com.google.gwt.user.client.rpc.IsSerializable;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.common.dto.FleetDTO;
+import com.sap.sailing.domain.common.dto.RaceColumnDTO;
+import com.sap.sailing.domain.common.racelog.tracking.TrackingTimesRevocationErrorCode;
+import com.sap.sailing.domain.racelogtracking.TrackingTimesRevocationReport;
+import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.Util.Pair;
+
+public class TrackingTimesRevocationReportDTO implements IsSerializable {
+    private LinkedHashMap<Pair<RaceColumnDTO, FleetDTO>, HashSet<RaceLogEventDTO>> revokedEvents;
+    private LinkedHashMap<Pair<RaceColumnDTO, FleetDTO>, Pair<TimePoint, TimePoint>> notRevokedBecauseOfMissingStartOrFinishTime;
+    private ArrayList<Pair<RaceColumnDTO, FleetDTO>> notRevokedBecauseNotForTracking;
+    private TrackingTimesRevocationErrorCode errorCode;
+
+    @Deprecated
+    TrackingTimesRevocationReportDTO() {
+        // for GWT serialization
+    }
+    
+    @GwtIncompatible
+    public TrackingTimesRevocationReportDTO(TrackingTimesRevocationErrorCode errorCode) {
+        this.errorCode = errorCode;
+    }
+    
+    @GwtIncompatible
+    public TrackingTimesRevocationReportDTO(TrackingTimesRevocationReport report) {
+        this.errorCode = report.getErrorCode();
+        this.revokedEvents = new LinkedHashMap<>();
+        for (final Entry<Pair<RaceColumn, Fleet>, Set<RaceLogEvent>> e : report.getRevokedEvents().entrySet()) {
+            revokedEvents.put(
+                    new Pair<>(toDTO(e.getKey().getA()), toDTO(e.getKey().getB())),
+                    new HashSet<>(e.getValue().stream().map(this::toDTO)
+                            .collect(java.util.stream.Collectors.toSet())));
+        }
+        this.notRevokedBecauseOfMissingStartOrFinishTime = new LinkedHashMap<>();
+        for (final Entry<Pair<RaceColumn, Fleet>, Pair<TimePoint, TimePoint>> e : report.getNotRevokedBecauseOfMissingStartOfFinishTime().entrySet()) {
+            notRevokedBecauseOfMissingStartOrFinishTime.put(
+                    new Pair<>(toDTO(e.getKey().getA()), toDTO(e.getKey().getB())),
+                    e.getValue());
+        }
+        this.notRevokedBecauseNotForTracking = new ArrayList<>();
+        for (final Pair<RaceColumn, Fleet> e : report.getNotRevokedBecauseNotForTracking()) {
+            notRevokedBecauseNotForTracking.add(new Pair<>(toDTO(e.getA()), toDTO(e.getB())));
+        }
+    }
+    
+    /**
+     * @return {@code null} means no error
+     */
+    public TrackingTimesRevocationErrorCode getErrorCode() {
+        return errorCode;
+    }
+
+    public HashMap<Pair<RaceColumnDTO, FleetDTO>, HashSet<RaceLogEventDTO>> getRevokedEvents() {
+        return revokedEvents;
+    }
+
+    public HashMap<Pair<RaceColumnDTO, FleetDTO>, Pair<TimePoint, TimePoint>> getNotRevokedBecauseOfMissingStartOrFinishTime() {
+        return notRevokedBecauseOfMissingStartOrFinishTime;
+    }
+
+    public ArrayList<Pair<RaceColumnDTO, FleetDTO>> getNotRevokedBecauseNotForTracking() {
+        return notRevokedBecauseNotForTracking;
+    }
+
+    @GwtIncompatible
+    private FleetDTO toDTO(Fleet fleet) {
+        return new FleetDTO(fleet.getName(), fleet.getOrdering(), fleet.getColor());
+    }
+
+    @GwtIncompatible
+    private RaceColumnDTO toDTO(final RaceColumn raceColumn) {
+        return new RaceColumnDTO(raceColumn.getName(), raceColumn.isOneAlwaysStaysOne());
+    }
+
+    @GwtIncompatible
+    private RaceLogEventDTO toDTO(RaceLogEvent raceLogEvent) {
+        return new RaceLogEventDTO(raceLogEvent.getPassId(), raceLogEvent.getAuthor().getName(),
+                raceLogEvent.getAuthor().getPriority(),
+                raceLogEvent.getCreatedAt() != null ? raceLogEvent.getCreatedAt().asDate() : null,
+                raceLogEvent.getLogicalTimePoint() != null ? raceLogEvent.getLogicalTimePoint().asDate() : null,
+                raceLogEvent.getClass().getSimpleName(), raceLogEvent.getShortInfo());
+    }
+}