org.opentripplanner.apis.transmodel.mapping.TripRequestMapper 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.transmodel.mapping;

import static org.opentripplanner.apis.transmodel.mapping.TransitIdMapper.mapIDsToDomainNullSafe;

import graphql.schema.DataFetchingEnvironment;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.opentripplanner.apis.transmodel.TransmodelRequestContext;
import org.opentripplanner.apis.transmodel.support.DataFetcherDecorator;
import org.opentripplanner.apis.transmodel.support.GqlUtil;
import org.opentripplanner.routing.api.request.RouteRequest;
import org.opentripplanner.standalone.api.OtpServerRequestContext;
import org.opentripplanner.transit.model.framework.FeedScopedId;
import org.opentripplanner.transit.service.TransitService;

public class TripRequestMapper {

  /**
   * Create a RouteRequest from the input fields of the trip query arguments.
   */
  public static RouteRequest createRequest(DataFetchingEnvironment environment) {
    TransmodelRequestContext context = environment.getContext();
    OtpServerRequestContext serverContext = context.getServerContext();
    RouteRequest request = serverContext.defaultRouteRequest();

    DataFetcherDecorator callWith = new DataFetcherDecorator(environment);

    callWith.argument("locale", (String v) -> request.setLocale(Locale.forLanguageTag(v)));

    callWith.argument(
      "from",
      (Map v) -> request.setFrom(GenericLocationMapper.toGenericLocation(v))
    );
    callWith.argument(
      "to",
      (Map v) -> request.setTo(GenericLocationMapper.toGenericLocation(v))
    );
    final TransitService transitService = context.getTransitService();
    callWith.argument(
      "passThroughPoints",
      (List> v) -> {
        request.setPassThroughPoints(PassThroughLocationMapper.toLocations(transitService, v));
      }
    );

    callWith.argument(
      "dateTime",
      millisSinceEpoch -> request.setDateTime(Instant.ofEpochMilli((long) millisSinceEpoch))
    );

    callWith.argument(
      "bookingTime",
      millisSinceEpoch -> request.setBookingTime(Instant.ofEpochMilli((long) millisSinceEpoch))
    );

    callWith.argument(
      "searchWindow",
      (Integer m) -> request.setSearchWindow(Duration.ofMinutes(m))
    );
    callWith.argument("pageCursor", request::setPageCursorFromEncoded);
    callWith.argument("timetableView", request::setTimetableView);
    callWith.argument("wheelchairAccessible", request::setWheelchair);
    callWith.argument("numTripPatterns", request::setNumItineraries);
    callWith.argument("arriveBy", request::setArriveBy);

    callWith.argument(
      "preferred.authorities",
      (Collection authorities) ->
        request.journey().transit().setPreferredAgencies(mapIDsToDomainNullSafe(authorities))
    );
    callWith.argument(
      "unpreferred.authorities",
      (Collection authorities) ->
        request.journey().transit().setUnpreferredAgencies(mapIDsToDomainNullSafe(authorities))
    );

    callWith.argument(
      "preferred.lines",
      (List lines) ->
        request.journey().transit().setPreferredRoutes(mapIDsToDomainNullSafe(lines))
    );
    callWith.argument(
      "unpreferred.lines",
      (List lines) ->
        request.journey().transit().setUnpreferredRoutes(mapIDsToDomainNullSafe(lines))
    );

    if (GqlUtil.hasArgument(environment, "modes")) {
      request
        .journey()
        .setModes(RequestModesMapper.mapRequestModes(environment.getArgument("modes")));
    }

    var bannedTrips = new ArrayList();
    callWith.argument(
      "banned.serviceJourneys",
      (Collection serviceJourneys) ->
        bannedTrips.addAll(mapIDsToDomainNullSafe(serviceJourneys))
    );
    if (!bannedTrips.isEmpty()) {
      request.journey().transit().setBannedTrips(bannedTrips);
    }

    if (GqlUtil.hasArgument(environment, "filters")) {
      request
        .journey()
        .transit()
        .setFilters(FilterMapper.mapFilterNewWay(environment.getArgument("filters")));
    } else {
      FilterMapper.mapFilterOldWay(environment, callWith, request);
    }

    request.withPreferences(preferences ->
      PreferencesMapper.mapPreferences(environment, callWith, preferences)
    );

    return request;
  }
}