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 otp Show documentation
The OpenTripPlanner multimodal journey planning system
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.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.PickDrop;
import org.opentripplanner.model.fare.FareProductUse;
import org.opentripplanner.model.plan.Leg;
import org.opentripplanner.model.plan.LegTime;
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.routing.alertpatch.TransitAlert;
import org.opentripplanner.routing.alternativelegs.AlternativeLegs;
import org.opentripplanner.routing.alternativelegs.AlternativeLegsFilter;
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 PickDrop.SCHEDULED.name();
      }
      return getSource(environment).getAlightRule().name();
    };
  }

  @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 PickDrop.SCHEDULED.name();
      }
      return getSource(environment).getBoardRule().name();
    };
  }

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

  // TODO
  @Override
  public DataFetcher realtimeState() {
    return environment -> null;
  }

  @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> nextLegs() {
    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(),
            false,
            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());
  }
}