OTP-1382 GMAP Push notifications for leg transition

src/main/java/org/opentripplanner/middleware/i18n/Message.java

@@ -19,7 +19,10 @@ public enum Message {
     ACCEPT_DEPENDENT_EMAIL_SUBJECT,
     ACCEPT_DEPENDENT_EMAIL_MANAGE,
     ACCEPT_DEPENDENT_ERROR,
+    DESTINATION_CHANGE_NOTIFICATION,
     LABEL_AND_CONTENT,
+    MODE_CHANGE_NOTIFICATION,
+    ORIGIN_CHANGE_NOTIFICATION,
     SMS_STOP_NOTIFICATIONS,
     TRIP_EMAIL_SUBJECT,
     TRIP_EMAIL_SUBJECT_FOR_USER,

src/main/java/org/opentripplanner/middleware/models/TripMonitorNotification.java

@@ -1,6 +1,7 @@
 package org.opentripplanner.middleware.models;
 
 import org.opentripplanner.middleware.i18n.Message;
+import org.opentripplanner.middleware.otp.response.Leg;
 import org.opentripplanner.middleware.tripmonitor.jobs.NotificationType;
 import org.opentripplanner.middleware.utils.DateTimeUtils;
 import org.slf4j.Logger;
@@ -110,4 +111,46 @@ public static TripMonitorNotification createInitialReminderNotification(
             )
         );
     }
+
+    /**
+     * Creates a notification that the leg has changed mode.
+     */
+    public static TripMonitorNotification createModeChangeNotification(Leg expectedLeg, Leg changedLeg, Locale locale) {
+        return new TripMonitorNotification(
+            NotificationType.MODE_CHANGE,
+            String.format(
+                Message.MODE_CHANGE_NOTIFICATION.get(locale),
+                expectedLeg.mode,
+                changedLeg.mode,
+                expectedLeg.from.name
+            )
+        );
+    }
+
+    /**
+     * Creates a notification that the origin or destination has changed.
+     */
+    public static TripMonitorNotification createStopChangeNotification(
+        NotificationType delayType,
+        Leg expectedLeg,
+        Leg changedLeg,
+        Locale locale
+    ) {
+        String message = null;
+        if (delayType == NotificationType.ORIGIN_CHANGE) {
+            message = String.format(
+                Message.ORIGIN_CHANGE_NOTIFICATION.get(locale),
+                expectedLeg.from.name,
+                changedLeg.from.name
+            );
+        } else if (delayType == NotificationType.DESTINATION_CHANGE) {
+            message = String.format(
+                Message.DESTINATION_CHANGE_NOTIFICATION.get(locale),
+                expectedLeg.from.name,
+                expectedLeg.to.name,
+                changedLeg.to.name
+            );
+        }
+        return (message != null) ? new TripMonitorNotification(delayType, message) : null;
+    }
 }

src/main/java/org/opentripplanner/middleware/tripmonitor/jobs/CheckMonitoredTrip.java

@@ -1,12 +1,14 @@
 package org.opentripplanner.middleware.tripmonitor.jobs;
 
+import com.mongodb.lang.Nullable;
 import org.opentripplanner.middleware.i18n.Message;
 import org.opentripplanner.middleware.models.ItineraryExistence;
 import org.opentripplanner.middleware.models.MonitoredTrip;
 import org.opentripplanner.middleware.models.OtpUser;
 import org.opentripplanner.middleware.models.TripMonitorAlertNotification;
 import org.opentripplanner.middleware.models.TripMonitorNotification;
 import org.opentripplanner.middleware.otp.OtpGraphQLVariables;
+import org.opentripplanner.middleware.otp.response.Leg;
 import org.opentripplanner.middleware.tripmonitor.TripStatus;
 import org.opentripplanner.middleware.otp.OtpDispatcher;
 import org.opentripplanner.middleware.otp.response.Itinerary;
@@ -33,11 +35,13 @@
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;
+import java.util.stream.IntStream;
 
 import static org.opentripplanner.middleware.utils.I18nUtils.label;
 
@@ -248,6 +252,53 @@ private boolean isTrackingOngoing() {
         return trip.journeyState.tripStatus == TripStatus.TRIP_ACTIVE && TripTrackingData.getOngoingTrackedJourney(trip.id) != null;
     }
 
+    /**
+     * Whilst a trip is ongoing check for upcoming major changes and notify the traveler. These checks are specifically
+     * looking for individual differences between the trip itinerary and the latest OTP response itinerary.
+     */
+    public void checkForMajorTripChanges(Leg nextLeg) {
+        var otpResponse = getOtpResponse();
+        int nextLegIndex = getLegIndex(nextLeg);
+        if (
+            otpResponse == null ||
+            nextLegIndex == -1 ||
+            (!trip.isOneTime() && !isTrackingOngoing() && trip.journeyState.matchingItinerary.hasEnded())
+        ) {
+            // Required criteria to check for major changes not met.
+            return;
+        }
+
+        if (!hasMatchingItinerary(otpResponse)) {
+            // There is a change, workout if it is one of the major changes.
+            enqueueNotification(
+                checkTripForMajorChange(NotificationType.MODE_CHANGE, otpResponse.plan.itineraries, nextLegIndex),
+                checkTripForMajorChange(NotificationType.ORIGIN_CHANGE, otpResponse.plan.itineraries, nextLegIndex),
+                checkTripForMajorChange(NotificationType.DESTINATION_CHANGE, otpResponse.plan.itineraries, nextLegIndex)
+            );
+        }
+        sendNotifications();
+    }
+
+    /**
+     * Get the position of the next leg within the itinerary.
+     */
+    private int getLegIndex(Leg nextLeg) {
+        return IntStream
+            .range(0, trip.itinerary.legs.size())
+            .filter(i -> ItineraryUtils.legsMatch(nextLeg, trip.itinerary.legs.get(i)))
+            .findFirst()
+            .orElse(-1);
+    }
+
+    /**
+     * Confirm that the OTP response contains an itinerary that matches the trip itinerary.
+     */
+    private boolean hasMatchingItinerary(OtpResponse otpResponse) {
+        return otpResponse.plan.itineraries
+            .stream()
+            .anyMatch(i -> ItineraryUtils.itinerariesMatch(trip.itinerary, i));
+    }
+
     /**
      * Find and set the matching itinerary from the OTP response that matches the monitored trip's stored itinerary if a
      * match exists.
@@ -498,6 +549,95 @@ public TripMonitorNotification checkTripForDelay(NotificationType delayType) {
         return null;
     }
 
+    /**
+     * Check for major upcoming change and notify the traveler.
+     */
+    @Nullable
+    public TripMonitorNotification checkTripForMajorChange(
+        NotificationType delayType,
+        List<Itinerary> itineraries,
+        int nextLegIndex
+    ) {
+        var itineraryToCheck = getMatchingItinerary(delayType, itineraries);
+        if (itineraryToCheck != null) {
+            int majorChangeIndex = IntStream
+                .range(0, itineraryToCheck.legs.size())
+                .filter(i -> hasMajorChange(i, delayType, itineraryToCheck))
+                .findFirst()
+                .orElse(-1);
+
+            if (majorChangeIndex == -1 || majorChangeIndex <= (nextLegIndex - 1)) {
+                // No major change or the traveler has already passed it.
+                return null;
+            }
+
+            // Found a major change.
+            switch (delayType) {
+                case MODE_CHANGE:
+                    return TripMonitorNotification.createModeChangeNotification(
+                        trip.itinerary.legs.get(majorChangeIndex),
+                        itineraryToCheck.legs.get(majorChangeIndex),
+                        getOtpUserLocale()
+                    );
+                case ORIGIN_CHANGE:
+                case DESTINATION_CHANGE:
+                    return TripMonitorNotification.createStopChangeNotification(
+                        delayType,
+                        trip.itinerary.legs.get(majorChangeIndex),
+                        itineraryToCheck.legs.get(majorChangeIndex),
+                        getOtpUserLocale()
+                    );
+                default:
+                    return null;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Check the appropriate leg for a major change based on the provided exception.
+     */
+    private boolean hasMajorChange(int index, NotificationType exception, Itinerary itineraryToCheck) {
+        if (exception == NotificationType.MODE_CHANGE) {
+            return !ItineraryUtils.legsModeMatches(trip.itinerary.legs.get(index), itineraryToCheck.legs.get(index));
+        } else if (exception == NotificationType.ORIGIN_CHANGE){
+            return !ItineraryUtils.stopsMatch(trip.itinerary.legs.get(index).from, itineraryToCheck.legs.get(index).from);
+        } else if (exception == NotificationType.DESTINATION_CHANGE){
+            return !ItineraryUtils.stopsMatch(trip.itinerary.legs.get(index).to, itineraryToCheck.legs.get(index).to);
+        }
+        return false;
+    }
+
+    /**
+     * A list of all notification types that are classed as major changes to an itinerary.
+     */
+    private List<NotificationType> getAllMajorChangeNotificationTypes() {
+        return List.of(NotificationType.MODE_CHANGE, NotificationType.ORIGIN_CHANGE, NotificationType.DESTINATION_CHANGE);
+    }
+
+    /**
+     * Attempt to match on just a single exception, else use the wider exception criteria.
+     */
+    @Nullable
+    private Itinerary getMatchingItinerary(NotificationType delayType, List<Itinerary> itineraries) {
+        Itinerary matchingWithSingleException = getMatchingItineraryWithExceptions(itineraries, List.of(delayType));
+        if (matchingWithSingleException != null) {
+            return matchingWithSingleException;
+        }
+        return getMatchingItineraryWithExceptions(itineraries, getAllMajorChangeNotificationTypes());
+    }
+
+    /**
+     * Get the first matching itinerary ignoring exceptions.
+     */
+    private Itinerary getMatchingItineraryWithExceptions(List<Itinerary> itineraries, List<NotificationType> exceptions) {
+        return itineraries
+            .stream()
+            .filter(i -> ItineraryUtils.itinerariesMatch(trip.itinerary, i, exceptions))
+            .findFirst()
+            .orElse(null);
+    }
+
     /**
      * Compose a message for any enqueued notifications and send to {@link OtpUser} based on their notification
      * preferences.

src/main/java/org/opentripplanner/middleware/tripmonitor/jobs/NotificationType.java

@@ -11,5 +11,8 @@ public enum NotificationType {
     ITINERARY_CHANGED, // TODO
     ALERT_FOUND,
     ITINERARY_NOT_FOUND,
-    INITIAL_REMINDER
+    INITIAL_REMINDER,
+    MODE_CHANGE,
+    ORIGIN_CHANGE,
+    DESTINATION_CHANGE
 }

src/main/java/org/opentripplanner/middleware/triptracker/ManageTripTracking.java

@@ -60,7 +60,8 @@ private static TrackingResponse doUpdateTracking(Request request, TripTrackingDa
             TravelerPosition travelerPosition = new TravelerPosition(
                 trackedJourney,
                 tripData.trip.journeyState.matchingItinerary,
-                Persistence.otpUsers.getById(tripData.trip.userId)
+                Persistence.otpUsers.getById(tripData.trip.userId),
+                tripData.trip
             );
             TripStatus tripStatus = TripStatus.getTripStatus(travelerPosition);
             trackedJourney.lastLocation().tripStatus = tripStatus;
@@ -148,7 +149,8 @@ private static EndTrackingResponse completeJourney(TripTrackingData tripData, bo
         TravelerPosition travelerPosition = new TravelerPosition(
             tripData.journey,
             tripData.trip.journeyState.matchingItinerary,
-            Persistence.otpUsers.getById(tripData.trip.userId)
+            Persistence.otpUsers.getById(tripData.trip.userId),
+            tripData.trip
         );
         cancelBusNotification(travelerPosition);
         TrackedJourney trackedJourney = travelerPosition.trackedJourney;

src/main/java/org/opentripplanner/middleware/triptracker/TravelerLocator.java

@@ -4,6 +4,7 @@
 import org.opentripplanner.middleware.otp.response.Leg;
 import org.opentripplanner.middleware.otp.response.Place;
 import org.opentripplanner.middleware.otp.response.Step;
+import org.opentripplanner.middleware.tripmonitor.jobs.CheckMonitoredTrip;
 import org.opentripplanner.middleware.triptracker.instruction.DeviatedInstruction;
 import org.opentripplanner.middleware.triptracker.instruction.GetOffHereTransitInstruction;
 import org.opentripplanner.middleware.triptracker.instruction.GetOffNextStopTransitInstruction;
@@ -16,6 +17,8 @@
 import org.opentripplanner.middleware.utils.Coordinates;
 import org.opentripplanner.middleware.utils.ConvertsToCoordinates;
 import org.opentripplanner.middleware.utils.DateTimeUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nullable;
 import java.time.Duration;
@@ -41,6 +44,8 @@
  */
 public class TravelerLocator {
 
+    private static final Logger LOG = LoggerFactory.getLogger(TravelerLocator.class);
+
     public static final int ACCEPTABLE_AHEAD_OF_SCHEDULE_IN_MINUTES = 15;
 
     private static final int MIN_TRANSIT_VEHICLE_SPEED = 5; // meters per second. 11.1 mph or 18 km/h.
@@ -86,6 +91,12 @@ public static String getInstruction(
                 }
             }
         }
+
+        try {
+            new CheckMonitoredTrip(travelerPosition.trip).checkForMajorTripChanges(travelerPosition.nextLeg);
+        } catch (Exception e) {
+            LOG.error("Error encountered while checking for major trip changes.", e);
+        }
         return NO_INSTRUCTION;
     }
 

src/main/java/org/opentripplanner/middleware/triptracker/TravelerPosition.java

@@ -1,5 +1,6 @@
 package org.opentripplanner.middleware.triptracker;
 
+import org.opentripplanner.middleware.models.MonitoredTrip;
 import org.opentripplanner.middleware.models.OtpUser;
 import org.opentripplanner.middleware.models.TrackedJourney;
 import org.opentripplanner.middleware.otp.response.Itinerary;
@@ -48,6 +49,14 @@ public class TravelerPosition {
     /** The first leg of the trip. **/
     public Leg firstLegOfTrip;
 
+    /** The trip related to the traveler's position */
+    public MonitoredTrip trip;
+
+    public TravelerPosition(TrackedJourney trackedJourney, Itinerary itinerary, OtpUser otpUser, MonitoredTrip trip) {
+        this(trackedJourney, itinerary, otpUser);
+        this.trip = trip;
+    }
+
     public TravelerPosition(TrackedJourney trackedJourney, Itinerary itinerary, OtpUser otpUser) {
         TrackingLocation lastLocation = trackedJourney.locations.get(trackedJourney.locations.size() - 1);
         currentTime = lastLocation.timestamp.toInstant();