@opentripplanner/core-utils 9.0.0-alpha.8 → 9.0.0

package/src/planQuery.graphql

@@ -1,146 +1,236 @@
-query PlanQuery(
-	$fromPlace: String!,
-	$toPlace: String!,
-	$modes: [TransportMode],
-	$time: String,
-	$date: String,
-	$wheelchair: Boolean,
-	$bikeReluctance: Float,
-	$carReluctance: Float,
-	$walkReluctance: Float,
-	$arriveBy: Boolean,
-	$intermediatePlaces: [InputCoordinates],
-	$preferred: InputPreferred,
-	$unpreferred: InputUnpreferred,
-	$banned: InputBanned,
+query Plan(
+  $fromPlace: String! 
+  $toPlace: String! 
+  $modes: [TransportMode]
+  $time: String
+  $date: String
+  $wheelchair: Boolean
+  $bikeReluctance: Float
+  $carReluctance: Float
+  $walkReluctance: Float
+  $arriveBy: Boolean
+  $preferred: InputPreferred
+  $unpreferred: InputUnpreferred
+  $banned: InputBanned
+  $numItineraries: Int
 ) {
-	plan(
-		fromPlace: $fromPlace
-		toPlace: $toPlace
-		transportModes: $modes
-		# Currently only supporting EN locale, used for times and text
-		locale: "en",
-		time: $time,
-		date: $date,
-		wheelchair: $wheelchair,
-		bikeReluctance: $bikeReluctance,
-		carReluctance: $carReluctance,
-		walkReluctance: $walkReluctance,
-		arriveBy: $arriveBy,
-		intermediatePlaces: $intermediatePlaces,
-		preferred: $preferred,
-		unpreferred: $unpreferred,
-		banned: $banned,
-	) {
-		itineraries {
-			duration
-			endTime
-			startTime
-			waitingTime
-			walkTime
-			legs {
-				distance
-				duration
-				endTime
-				mode
-				realTime
-				realtimeState	
-				startTime
-				transitLeg
-				trip {
-					id
-					gtfsId
-				}
-				agency {
-					name
-					id
-					timezone
-					url
-					alerts {
-            alertHeaderText
+  plan(
+    arriveBy: $arriveBy
+    banned: $banned
+    bikeReluctance: $bikeReluctance
+    carReluctance: $carReluctance
+    date: $date
+    fromPlace: $fromPlace
+    # Currently only supporting EN locale, used for times and text
+    locale: "en"
+    numItineraries: $numItineraries
+    preferred: $preferred
+    time: $time
+    toPlace: $toPlace
+    transportModes: $modes
+    unpreferred: $unpreferred
+    walkReluctance: $walkReluctance
+    wheelchair: $wheelchair
+  ) {
+    itineraries {
+      accessibilityScore
+      duration
+      endTime
+      legs {
+        accessibilityScore
+        agency {
+          alerts {
             alertDescriptionText
+            alertHeaderText
             alertUrl
             effectiveStartDate
+            id
           }
-				}
-				legGeometry {
-					length
-					points
-				}
-				intermediateStops {
-					lat
-					lon
-					name
-					stopCode: code
-					stopId: id
-					locationType
-				}
-				route {
-					shortName
-					color
-					textColor
-					id
-					type
-					alerts {
-            alertHeaderText
+          id
+          name
+          timezone
+          url
+        }
+        arrivalDelay
+        departureDelay
+        distance
+        dropoffType
+        duration
+        endTime
+        fareProducts {
+          id
+          product {
+            id
+            medium {
+              id
+              name
+            }
+            name
+            price {
+              amount
+              currency {
+                code
+                digits
+              }
+            }
+            riderCategory {
+              id
+              name
+            }
+          }
+        }
+        from {
+          lat
+          lon
+          name
+          rentalVehicle {
+            id
+            network
+          }
+          stop {
+            alerts {
+              alertDescriptionText
+              alertHeaderText
+              alertUrl
+              effectiveStartDate
+              id
+            }
+            code
+            gtfsId
+            id
+          }
+          vertexType
+        }
+        interlineWithPreviousLeg
+        intermediateStops {
+          lat
+          locationType
+          lon
+          name
+          stopCode: code
+          stopId: id
+        }
+        legGeometry {
+          length
+          points
+        }
+        mode
+        pickupBookingInfo {
+          earliestBookingTime {
+            daysPrior
+          }
+        }
+        pickupType
+        realTime
+        realtimeState
+        rentedBike
+        rideHailingEstimate {
+          arrival
+          maxPrice {
+            amount
+            currency {
+              code
+            }
+          }
+          minPrice {
+            amount
+            currency {
+              code
+            }
+          }
+          provider {
+            id
+          }
+        }
+        route {
+          alerts {
             alertDescriptionText
+            alertHeaderText
             alertUrl
             effectiveStartDate
+            id
           }
-				}
-				from {
-					lat
-					lon
-					name
-					vertexType
-					stop {
-						id
-						code
-						alerts {
-							alertHeaderText
-							alertDescriptionText
-							alertUrl
-							effectiveStartDate
-						}	
-					}
-				}
-				to {
-					lat
-					lon
-					name
-					vertexType
-					stop {
-						id
-						code
-						alerts {
-							alertHeaderText
-							alertDescriptionText
-							alertUrl
-							effectiveStartDate
-						}
-					}
-				}
-				steps {
-					distance
-					lat
-					lon
-          relativeDirection
+          color
+          id
+          longName
+          shortName
+          textColor
+          type
+        }
+        startTime
+        steps {
           absoluteDirection
-          stayOn
-          streetName
-          area
-          alerts{
-            alertHeaderText
+          alerts {
             alertDescriptionText
+            alertHeaderText
             alertUrl
             effectiveStartDate
+            id
+          }
+          area
+          distance
+          elevationProfile {
+            distance
+            elevation
+          }
+          lat
+          lon
+          relativeDirection
+          stayOn
+          streetName
+        }
+        to {
+          lat
+          lon
+          name
+          rentalVehicle {
+            id
+            network
+          }
+          stop {
+            alerts {
+              alertDescriptionText
+              alertHeaderText
+              alertUrl
+              effectiveStartDate
+              id
+            }
+            code
+            gtfsId
+            id
+          }
+          vertexType
+        }
+        transitLeg
+        trip {
+          arrivalStoptime {
+            stop {
+              gtfsId
+              id
+            }
+            stopPosition
+          }
+          departureStoptime {
+            stop {
+              gtfsId
+              id
+            }
+            stopPosition
           }
-					elevationProfile {
-						distance
-						elevation
-					}
-				}
-			}
-		}
-	}
-}
+
+          gtfsId
+          id
+          tripHeadsign
+        }
+      }
+      startTime
+      waitingTime
+      walkTime
+    }
+    routingErrors {
+      code
+      description
+      inputField
+    }
+  }
+}

package/src/query-gen.ts

@@ -6,16 +6,33 @@ import {
   TransportMode
 } from "@opentripplanner/types";
 
-import PlanQuery from "./planQuery.graphql";
+import DefaultPlanQuery from "./planQuery.graphql";
+
+type InputBanned = {
+  routes?: string;
+  agencies?: string;
+  trips?: string;
+  stops?: string;
+  stopsHard?: string;
+};
+
+type InputPreferred = {
+  routes?: string;
+  agencies?: string;
+  unpreferredCost?: string;
+};
 
 type OTPQueryParams = {
   arriveBy: boolean;
-  date: string;
+  date?: string;
   from: LonLatOutput & { name?: string };
   modes: TransportMode[];
   modeSettings: ModeSetting[];
-  time: string;
+  time?: string;
+  numItineraries?: number;
   to: LonLatOutput & { name?: string };
+  banned?: InputBanned;
+  preferred?: InputPreferred;
 };
 
 type GraphQLQuery = {
@@ -41,7 +58,11 @@ export function extractAdditionalModes(
     }
 
     // In checkboxes, mode must be enabled and have a transport mode in it
-    if (cur.type === "CHECKBOX" && cur.addTransportMode && cur.value) {
+    if (
+      (cur.type === "CHECKBOX" || cur.type === "SUBMODE") &&
+      cur.addTransportMode &&
+      cur.value
+    ) {
       return [...prev, cur.addTransportMode];
     }
     if (cur.type === "DROPDOWN") {
@@ -106,7 +127,7 @@ const VALID_COMBOS = [
   ["TRANSIT", "CAR"]
 ];
 
-const BANNED_TOGETHER = ["SCOOTER", "BICYCLE"];
+const BANNED_TOGETHER = ["SCOOTER", "BICYCLE", "CAR"];
 
 export const TRANSIT_SUBMODES = Object.keys(SIMPLIFICATIONS).filter(
   mode => SIMPLIFICATIONS[mode] === "TRANSIT" && mode !== "TRANSIT"
@@ -147,7 +168,9 @@ function isCombinationValid(
   }
 
   // OTP doesn't support multiple non-walk modes
-  if (BANNED_TOGETHER.every(m => combo.find(c => c.mode === m))) return false;
+  if (BANNED_TOGETHER.filter(m => combo.find(c => c.mode === m)).length > 1) {
+    return false;
+  }
 
   return !!VALID_COMBOS.find(
     vc =>
@@ -178,17 +201,32 @@ export function generateCombinations(params: OTPQueryParams): OTPQueryParams[] {
     .map(combo => ({ ...params, modes: combo }));
 }
 
-export function generateOtp2Query({
-  arriveBy,
-  date,
-  from,
-  modes,
-  modeSettings,
-  time,
-  to
-}: OTPQueryParams): GraphQLQuery {
+/**
+ * Generates a query for OTP GraphQL API based on parameters.
+ * @param param0 OTP2 Parameters for the query
+ * @param planQuery Override the default query for OTP
+ * @returns A fully formed query+variables ready to be sent to GraphQL backend
+ */
+export function generateOtp2Query(
+  {
+    arriveBy,
+    banned,
+    date,
+    from,
+    modes,
+    modeSettings,
+    numItineraries,
+    preferred,
+    time,
+    to
+  }: OTPQueryParams,
+  planQuery = DefaultPlanQuery
+): GraphQLQuery {
   // This extracts the values from the mode settings to key value pairs
   const modeSettingValues = modeSettings.reduce((prev, cur) => {
+    if (cur.type === "SLIDER" && cur.inverseKey) {
+      prev[cur.inverseKey] = cur.high - cur.value + cur.low;
+    }
     prev[cur.key] = cur.value;
     return prev;
   }, {}) as ModeSettingValues;
@@ -201,14 +239,17 @@ export function generateOtp2Query({
   } = modeSettingValues;
 
   return {
-    query: print(PlanQuery),
+    query: print(planQuery),
     variables: {
       arriveBy,
+      banned,
       bikeReluctance,
       carReluctance,
       date,
       fromPlace: `${from.name}::${from.lat},${from.lon}}`,
       modes,
+      numItineraries,
+      preferred,
       time,
       toPlace: `${to.name}::${to.lat},${to.lon}}`,
       walkReluctance,