Merge remote-tracking branch 'github/bug6237' into main

+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

+}

+

+ TrackingTimesRevocationReport revokeExplicitTrackingTimes(RegattaLeaderboard leaderboard, RacingEventService raceLogResolver);

+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();

+

+}

+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;

+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;

+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.FinishedTimeFinder;

+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.StartTimeFinder;

+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.StartTimeFinderResult;

+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.TrackingTimesEventFinder;

+import com.sap.sailing.domain.racelogtracking.TrackingTimesRevocationReport;

+

+ @Override

+ 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);

+ if (raceLog != null) {

+ // handle only races denoted for smartphone tracking:

+ if (new RaceLogTrackingStateAnalyzer(raceLog).analyze().isForTracking()) {

+ final StartTimeFinder startTimeFinder = new StartTimeFinder(service, raceLog);

+ final StartTimeFinderResult startTimeFinderResult = startTimeFinder.analyze();

+ final FinishedTimeFinder finishedTimeFinder = new FinishedTimeFinder(raceLog);

+ final TimePoint finishedTime = finishedTimeFinder.analyze();

+ final TrackingTimesEventFinder trackingTimesEventFinder = new TrackingTimesEventFinder(raceLog);

+ if (startTimeFinderResult != null && startTimeFinderResult.getStartTime() != null && finishedTime != null) {

+ Pair<RaceLogStartOfTrackingEvent, RaceLogEndOfTrackingEvent> trackingTimes;

+ while ((trackingTimes = trackingTimesEventFinder.analyze()) != null) {

+ 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);

+ }

+ }

+ 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;

+ }

+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);

+ }

+}

+

+ @Source("com/sap/sailing/gwt/ui/client/images/eraser-icon.png")

+ ImageResource eraser();

+import com.sap.sailing.domain.common.LeaderboardType;

+ public static final String ACTION_REVOKE_EXPLICIT_TRACKING_TIMES = "ACTION_REVOKE_EXPLICIT_TRACKING_TIMES";

+ if (selectedLeaderboard.type == LeaderboardType.RegattaLeaderboard) {

+ result.add(new ImageSpec(ACTION_REVOKE_EXPLICIT_TRACKING_TIMES, stringMessages.revokeExplicitTrackingTimes(),

+ makeImagePrototype(resources.eraser())));

+ }

+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;

+ leaderboardActionColumn.addAction(RaceLogTrackingEventManagementImagesBarCell.ACTION_REVOKE_EXPLICIT_TRACKING_TIMES,

+ DefaultActions.UPDATE, t -> revokeExplicitTrackingTimes());

+ private void revokeExplicitTrackingTimes() {

+ if (Window.confirm(stringMessages.confirmRevokeExplicitTrackingTimes(getSelectedLeaderboard().getName()))) {

+ 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(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();

+ }

+ });

+ }

+ }

+

+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;

+

+ TrackingTimesRevocationReportDTO revokeExplicitTrackingTimes(String leaderboardName) throws NotFoundException;

+import com.sap.sailing.domain.base.Regatta;

+import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;

+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;

+

+ /**

+ * For the leaderboard identified by {@code leaderboardName}, revokes the explicit tracking times for all its

+ * {@link RaceColumn}/{@link Fleet} combinations where the race log of that slot has a valid race start time and

+ * valid finishing/finished times ("blue flag") in the Race Log. Multiple revocation events may be required because

+ * due to priorities and time order, some tracking time events may "shadow" other such events that become valid

+ * after revoking the one currently valid. The process continues until no more valid start/end tracking events exist

+ * in that race log.

+ * <p>

+ *

+ * Precondition: The leaderboard must be a {@link RegattaLeaderboard}, and the corresponding regatta must be in more

+ * {@link Regatta#isControlTrackingFromStartAndFinishTimes()}

+ */

+ void revokeExplicitTrackingTimes(String leaderboardName, AsyncCallback<TrackingTimesRevocationReportDTO> asyncCallback);

+ String finishedTime();

+ String revokeExplicitTrackingTimes();

+ String confirmRevokeExplicitTrackingTimes(String leaderboardName);

+ String errorRevokingExplicitTrackingTimes(String leaderboardName, String message);

+ String successfullyRevokedExplicitTrackingTimes(String leaderboardName, String formattedAndTranslatedReport);

+ String revokedTrackingTimesForEvents();

+ String notRevokedTrackingTimesBecauseNotForTracking();

+ String notRevokedTrackingTimesBecauseOfMissingStartOrFinishTime();

+ String noRegattaLeaderboard(String leaderboardName);

+ String noAutomatedTrackingTimes(String leaderboardName);

+ String unknownError(String name);

+finishedTime=Finished time

+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}: {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}

+finishedTime=Zielenlauf-Endezeit

+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}: {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}

+import com.sap.sailing.domain.common.racelog.tracking.TrackingTimesRevocationErrorCode;

+import com.sap.sailing.gwt.ui.shared.TrackingTimesRevocationReportDTO;

+

+ @Override

+ 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()) {

+ result = new TrackingTimesRevocationReportDTO(getRaceLogTrackingAdapter().revokeExplicitTrackingTimes(

+ (RegattaLeaderboard) leaderboard, /* raceLogResolver */ getService()));

+ } else {

+ result = new TrackingTimesRevocationReportDTO(TrackingTimesRevocationErrorCode.NO_AUTOMATED_TRACKING_TIMES);

+ }

+ } else {

+ result = new TrackingTimesRevocationReportDTO(TrackingTimesRevocationErrorCode.NO_REGATTA_LEADERBOARD);

+ }

+ return result;

+ }

+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());

+ }

+}