org.opentripplanner.apis.gtfs.datafetchers.LegImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of application Show documentation
The newest version!
package org.opentripplanner.apis.gtfs.datafetchers;

import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.locationtech.jts.geom.Geometry;
import org.opentripplanner.apis.gtfs.GraphQLRequestContext;
import org.opentripplanner.apis.gtfs.generated.GraphQLDataFetchers;
import org.opentripplanner.apis.gtfs.generated.GraphQLTypes;
import org.opentripplanner.apis.gtfs.mapping.NumberMapper;
import org.opentripplanner.apis.gtfs.mapping.PickDropMapper;
import org.opentripplanner.apis.gtfs.mapping.RealtimeStateMapper;
import org.opentripplanner.ext.restapi.mapping.LocalDateMapper;
import org.opentripplanner.ext.ridehailing.model.RideEstimate;
import org.opentripplanner.ext.ridehailing.model.RideHailingLeg;
import org.opentripplanner.framework.graphql.GraphQLUtils;
import org.opentripplanner.model.fare.FareProductUse;
import org.opentripplanner.model.plan.Leg;
import org.opentripplanner.model.plan.LegCallTime;
import org.opentripplanner.model.plan.ScheduledTransitLeg;
import org.opentripplanner.model.plan.StopArrival;
import org.opentripplanner.model.plan.StreetLeg;
import org.opentripplanner.model.plan.TransitLeg;
import org.opentripplanner.model.plan.WalkStep;
import org.opentripplanner.model.plan.legreference.LegReferenceSerializer;
import org.opentripplanner.routing.alertpatch.TransitAlert;
import org.opentripplanner.routing.alternativelegs.AlternativeLegs;
import org.opentripplanner.routing.alternativelegs.AlternativeLegsFilter;
import org.opentripplanner.routing.alternativelegs.NavigationDirection;
import org.opentripplanner.transit.model.network.Route;
import org.opentripplanner.transit.model.organization.Agency;
import org.opentripplanner.transit.model.timetable.Trip;
import org.opentripplanner.transit.model.timetable.booking.BookingInfo;

public class LegImpl implements GraphQLDataFetchers.GraphQLLeg {

  @Override
  public DataFetcher agency() {
    return environment -> getSource(environment).getAgency();
  }

  @Override
  public DataFetcher> alerts() {
    return environment -> getSource(environment).getTransitAlerts();
  }

  @Override
  public DataFetcher arrivalDelay() {
    return environment -> getSource(environment).getArrivalDelay();
  }

  @Override
  public DataFetcher departureDelay() {
    return environment -> getSource(environment).getDepartureDelay();
  }

  @Override
  public DataFetcher distance() {
    return environment -> getSource(environment).getDistanceMeters();
  }

  @Override
  public DataFetcher dropOffBookingInfo() {
    return environment -> getSource(environment).getDropOffBookingInfo();
  }

  @Override
  public DataFetcher dropoffType() {
    return environment -> {
      if (getSource(environment).getAlightRule() == null) {
        return GraphQLTypes.GraphQLPickupDropoffType.SCHEDULED;
      }
      return PickDropMapper.map(getSource(environment).getAlightRule());
    };
  }

  @Override
  public DataFetcher duration() {
    return environment -> (double) getSource(environment).getDuration().toSeconds();
  }

  @Override
  public DataFetcher end() {
    return environment -> getSource(environment).end();
  }

  @Override
  @Deprecated
  public DataFetcher endTime() {
    return environment -> getSource(environment).getEndTime().toInstant().toEpochMilli();
  }

  @Override
  public DataFetcher> fareProducts() {
    return environment -> getSource(environment).fareProducts();
  }

  @Override
  public DataFetcher from() {
    return environment -> {
      Leg source = getSource(environment);
      return new StopArrival(
        source.getFrom(),
        source.start(),
        source.start(),
        source.getBoardStopPosInPattern(),
        source.getBoardingGtfsStopSequence()
      );
    };
  }

  @Override
  public DataFetcher generalizedCost() {
    return environment -> getSource(environment).getGeneralizedCost();
  }

  @Override
  public DataFetcher headsign() {
    return environment ->
      GraphQLUtils.getTranslation(getSource(environment).getHeadsign(), environment);
  }

  @Override
  public DataFetcher interlineWithPreviousLeg() {
    return environment -> getSource(environment).isInterlinedWithPreviousLeg();
  }

  // TODO
  @Override
  public DataFetcher intermediatePlace() {
    return environment -> false;
  }

  @Override
  public DataFetcher> intermediatePlaces() {
    return environment -> getSource(environment).getIntermediateStops();
  }

  @Override
  public DataFetcher> intermediateStops() {
    return environment -> {
      List intermediateStops = getSource(environment).getIntermediateStops();
      if (intermediateStops == null) {
        return null;
      }
      return intermediateStops
        .stream()
        .map(intermediateStop -> intermediateStop.place.stop)
        .filter(Objects::nonNull)
        .collect(Collectors.toList());
    };
  }

  @Override
  public DataFetcher legGeometry() {
    return environment -> getSource(environment).getLegGeometry();
  }

  @Override
  public DataFetcher mode() {
    return environment -> {
      Leg leg = getSource(environment);
      if (leg instanceof StreetLeg s) {
        return s.getMode().name();
      }
      if (leg instanceof TransitLeg s) {
        return s.getMode().name();
      }
      throw new IllegalStateException("Unhandled leg type: " + leg);
    };
  }

  @Override
  public DataFetcher pickupBookingInfo() {
    return environment -> getSource(environment).getPickupBookingInfo();
  }

  @Override
  public DataFetcher pickupType() {
    return environment -> {
      if (getSource(environment).getBoardRule() == null) {
        return GraphQLTypes.GraphQLPickupDropoffType.SCHEDULED;
      }
      return PickDropMapper.map(getSource(environment).getBoardRule());
    };
  }

  @Override
  public DataFetcher realTime() {
    return environment -> getSource(environment).isRealTimeUpdated();
  }

  @Override
  public DataFetcher realtimeState() {
    return environment -> {
      var state = getSource(environment).getRealTimeState();
      return RealtimeStateMapper.map(state);
    };
  }

  @Override
  public DataFetcher rentedBike() {
    return environment -> getSource(environment).getRentedVehicle();
  }

  @Override
  public DataFetcher rideHailingEstimate() {
    return environment -> {
      Leg leg = getSource(environment);
      if (leg instanceof RideHailingLeg rhl) {
        return rhl.rideEstimate();
      } else {
        return null;
      }
    };
  }

  @Override
  public DataFetcher route() {
    return environment -> getSource(environment).getRoute();
  }

  @Override
  public DataFetcher serviceDate() {
    return environment -> LocalDateMapper.mapToApi(getSource(environment).getServiceDate());
  }

  @Override
  public DataFetcher start() {
    return environment -> getSource(environment).start();
  }

  @Override
  @Deprecated
  public DataFetcher startTime() {
    return environment -> getSource(environment).getStartTime().toInstant().toEpochMilli();
  }

  @Override
  public DataFetcher> steps() {
    return environment -> getSource(environment).getWalkSteps();
  }

  @Override
  public DataFetcher to() {
    return environment -> {
      Leg source = getSource(environment);
      return new StopArrival(
        source.getTo(),
        source.end(),
        source.end(),
        source.getAlightStopPosInPattern(),
        source.getAlightGtfsStopSequence()
      );
    };
  }

  @Override
  public DataFetcher transitLeg() {
    return environment -> getSource(environment).isTransitLeg();
  }

  @Override
  public DataFetcher trip() {
    return environment -> getSource(environment).getTrip();
  }

  @Override
  public DataFetcher walkingBike() {
    return environment -> getSource(environment).getWalkingBike();
  }

  private Leg getSource(DataFetchingEnvironment environment) {
    return environment.getSource();
  }

  @Override
  public DataFetcher> previousLegs() {
    return alternativeLegs(NavigationDirection.PREVIOUS);
  }

  @Override
  public DataFetcher> nextLegs() {
    return alternativeLegs(NavigationDirection.NEXT);
  }

  private DataFetcher> alternativeLegs(NavigationDirection direction) {
    return environment -> {
      if (environment.getSource() instanceof ScheduledTransitLeg originalLeg) {
        var args = new GraphQLTypes.GraphQLLegNextLegsArgs(environment.getArguments());

        int numberOfLegs = args.getGraphQLNumberOfLegs();

        var originModesWithParentStation = args.getGraphQLOriginModesWithParentStation();
        var destinationModesWithParentStation = args.getGraphQLDestinationModesWithParentStation();

        boolean limitToExactOriginStop =
          originModesWithParentStation == null ||
          !(originModesWithParentStation
              .stream()
              .map(GraphQLTypes.GraphQLTransitMode::toString)
              .toList()
              .contains(originalLeg.getMode().name()));

        boolean limitToExactDestinationStop =
          destinationModesWithParentStation == null ||
          !(destinationModesWithParentStation
              .stream()
              .map(GraphQLTypes.GraphQLTransitMode::toString)
              .toList()
              .contains(originalLeg.getMode().name()));

        var res = AlternativeLegs.getAlternativeLegs(
          environment.getSource(),
          numberOfLegs,
          environment.getContext().transitService(),
          direction,
          AlternativeLegsFilter.NO_FILTER,
          limitToExactOriginStop,
          limitToExactDestinationStop
        )
          .stream()
          .map(Leg.class::cast)
          .toList();
        return res;
      } else return null;
    };
  }

  @Override
  public DataFetcher accessibilityScore() {
    return environment -> NumberMapper.toDouble(getSource(environment).accessibilityScore());
  }

  @Override
  public DataFetcher id() {
    return environment -> {
      var ref = getSource(environment).getLegReference();
      if (ref == null) {
        return null;
      }
      return LegReferenceSerializer.encode(ref);
    };
  }
}