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

package/src/__tests__/__mocks__/tnc-itinerary.json

@@ -66,15 +66,23 @@
       "rentedCar": false,
       "rentedVehicle": false,
       "hailedCar": true,
-      "tncData": {
-        "company": "UBER",
-        "currency": "USD",
-        "travelDuration": 300,
-        "maxCost": 10,
-        "minCost": 9,
-        "productId": "a6eef2e1-c99a-436f-bde9-fefb9181c0b0",
-        "displayName": "UberX",
-        "estimatedArrival": 240
+      "rideHailingEstimate": {
+        "provider": {
+          "id": "uber"
+        },
+        "arrival": "PT4M",
+        "minPrice": {
+          "currency": {
+            "code": "USD"
+          },
+          "amount": 17
+        },
+        "maxPrice": {
+          "currency": {
+            "code": "USD"
+          },
+          "amount": 19
+        }
       },
       "duration": 180,
       "transitLeg": false,
@@ -1045,15 +1053,23 @@
       "rentedCar": false,
       "rentedVehicle": false,
       "hailedCar": true,
-      "tncData": {
-        "company": "UBER",
-        "currency": "USD",
-        "travelDuration": 300,
-        "maxCost": 9,
-        "minCost": 8,
-        "productId": "a6eef2e1-c99a-436f-bde9-fefb9181c0b0",
-        "displayName": "UberX",
-        "estimatedArrival": 240
+      "rideHailingEstimate": {
+        "provider": {
+          "id": "uber"
+        },
+        "arrival": "PT4M",
+        "minPrice": {
+          "currency": {
+            "code": "USD"
+          },
+          "amount": 17
+        },
+        "maxPrice": {
+          "currency": {
+            "code": "USD"
+          },
+          "amount": 19
+        }
       },
       "duration": 341,
       "transitLeg": false,

package/src/__tests__/itinerary.js

@@ -2,12 +2,14 @@ import {
   calculateTncFares,
   getCompanyFromLeg,
   getDisplayedStopId,
-  getTransitFare,
+  getItineraryCost,
+  getLegCost,
   isTransit
 } from "../itinerary";
 
 const bikeRentalItinerary = require("./__mocks__/bike-rental-itinerary.json");
 const tncItinerary = require("./__mocks__/tnc-itinerary.json");
+const fareProductItinerary = require("./__mocks__/fare-products-itinerary.json");
 
 const basePlace = {
   lat: 0,
@@ -31,31 +33,7 @@ describe("util > itinerary", () => {
 
     it("should return company for TNC leg", () => {
       const company = getCompanyFromLeg(tncItinerary.legs[0]);
-      expect(company).toEqual("UBER");
-    });
-  });
-
-  describe("getTransitFare", () => {
-    it("should return defaults with missing fare", () => {
-      const { transitFare } = getTransitFare(null);
-      // transit fare value should be zero
-      expect(transitFare).toMatchSnapshot();
-    });
-
-    it("should work with valid fare component", () => {
-      const fareComponent = {
-        currency: {
-          currency: "USD",
-          defaultFractionDigits: 2,
-          currencyCode: "USD",
-          symbol: "$"
-        },
-        cents: 575
-      };
-      const { currencyCode, transitFare } = getTransitFare(fareComponent);
-      expect(currencyCode).toEqual(fareComponent.currency.currencyCode);
-      // Snapshot tests
-      expect(transitFare).toMatchSnapshot();
+      expect(company).toEqual("uber");
     });
   });
 
@@ -63,8 +41,8 @@ describe("util > itinerary", () => {
     it("should return the correct amounts and currency for an itinerary with TNC", () => {
       const fareResult = calculateTncFares(tncItinerary, true);
       expect(fareResult.currencyCode).toEqual("USD");
-      expect(fareResult.maxTNCFare).toEqual(19);
-      expect(fareResult.minTNCFare).toEqual(17);
+      expect(fareResult.maxTNCFare).toEqual(38);
+      expect(fareResult.minTNCFare).toEqual(34);
     });
   });
 
@@ -111,4 +89,72 @@ describe("util > itinerary", () => {
       expect(getDisplayedStopId(basePlace)).toBeFalsy();
     });
   });
+
+  describe("getLegCost", () => {
+    const leg = {
+      fareProducts: [
+        {
+          id: "testId",
+          product: {
+            medium: { id: "cash" },
+            name: "rideCost",
+            price: { amount: 200, currency: "USD" },
+            riderCategory: { id: "regular" }
+          }
+        },
+        {
+          id: "testId",
+          product: {
+            medium: { id: "cash" },
+            name: "transfer",
+            price: { amount: 50, currency: "USD" },
+            riderCategory: { id: "regular" }
+          }
+        }
+      ]
+    };
+    it("should return the total cost for a leg", () => {
+      const result = getLegCost(leg, "cash", "regular");
+      expect(result.price).toEqual({ amount: 200, currency: "USD" });
+    });
+
+    it("should return the transfer discount amount if a transfer was used", () => {
+      const result = getLegCost(leg, "cash", "regular");
+      expect(result.price).toEqual({ amount: 200, currency: "USD" });
+      expect(result.transferAmount).toEqual({ amount: 50, currency: "USD" });
+    });
+
+    it("should return undefined if no fare products exist on the leg", () => {
+      const emptyleg = {};
+      const result = getLegCost(emptyleg, "cash", "regular");
+      expect(result.price).toBeUndefined();
+    });
+    it("should return undefined if the keys are invalid", () => {
+      const result = getLegCost(leg, "invalidkey", "invalidkey");
+      expect(result.price).toBeUndefined();
+    });
+  });
+
+  describe("getItineraryCost", () => {
+    it("should calculate the total cost of an itinerary", () => {
+      const result = getItineraryCost(
+        fareProductItinerary.legs,
+        "orca:cash",
+        "orca:regular"
+      );
+      expect(result.amount).toEqual(5.75);
+      expect(result.currency).toEqual({
+        code: "USD",
+        digits: 2
+      });
+    });
+    it("should return undefined when the keys are invalid", () => {
+      const result = getItineraryCost(
+        fareProductItinerary.legs,
+        "invalidkey",
+        "invalidkey"
+      );
+      expect(result).toBeUndefined();
+    });
+  });
 });

package/src/__tests__/query-params.ts

@@ -148,6 +148,10 @@ describe("query-gen", () => {
         ["WALK"]
       ]
     );
+    expectModes(
+      ["BICYCLE_RENT", "BICYCLE", "WALK"],
+      [["BICYCLE_RENT", "WALK"], ["BICYCLE"], ["WALK"]]
+    );
     expectModes(
       ["SCOOTER_RENT", "BICYCLE_RENT", "TRANSIT", "WALK"],
       [
@@ -159,6 +163,26 @@ describe("query-gen", () => {
         ["WALK"]
       ]
     );
+
+    expectModes(
+      ["CAR_HAIL", "TRANSIT"],
+      [["TRANSIT"], ["CAR_HAIL", "TRANSIT"]]
+    );
+    expectModes(
+      ["CAR_HAIL", "BICYCLE_RENT", "TRANSIT"],
+      [["TRANSIT"], ["CAR_HAIL", "TRANSIT"], ["BICYCLE_RENT", "TRANSIT"]]
+    );
+    expectModes(
+      ["CAR_HAIL", "BICYCLE_RENT", "TRANSIT", "WALK"],
+      [
+        ["TRANSIT"],
+        ["CAR_HAIL", "TRANSIT"],
+        ["CAR_HAIL", "WALK"],
+        ["BICYCLE_RENT", "TRANSIT"],
+        ["BICYCLE_RENT", "WALK"],
+        ["WALK"]
+      ]
+    );
     expectModes(
       ["FLEX", "TRANSIT", "WALK"],
       [["TRANSIT"], ["FLEX", "TRANSIT"], ["FLEX", "WALK"], ["WALK"]]

package/src/itinerary.ts

@@ -4,7 +4,6 @@ import {
   Config,
   ElevationProfile,
   FlexBookingInfo,
-  Itinerary,
   ItineraryOnlyLegsRequired,
   LatLngArray,
   Leg,
@@ -79,6 +78,10 @@ export function legDropoffRequiresAdvanceBooking(leg: Leg): boolean {
   return isAdvanceBookingRequired(leg.dropOffBookingInfo);
 }
 
+export function isRideshareLeg(leg: Leg): boolean {
+  return !!leg.rideHailingEstimate?.provider?.id;
+}
+
 export function isWalk(mode: string): boolean {
   if (!mode) return false;
 
@@ -194,16 +197,26 @@ export function toSentenceCase(str: string): string {
  */
 export function getCompanyFromLeg(leg: Leg): string {
   if (!leg) return null;
-  const { from, mode, rentedBike, rentedCar, rentedVehicle, tncData } = leg;
+  const {
+    from,
+    mode,
+    rentedBike,
+    rentedCar,
+    rentedVehicle,
+    rideHailingEstimate
+  } = leg;
   if (mode === "CAR" && rentedCar) {
     return from.networks[0];
   }
-  if (mode === "CAR" && tncData) {
-    return tncData.company;
+  if (mode === "CAR" && rideHailingEstimate) {
+    return rideHailingEstimate.provider.id;
   }
   if (mode === "BICYCLE" && rentedBike && from.networks) {
     return from.networks[0];
   }
+  if (from.rentalVehicle) {
+    return from.rentalVehicle.network;
+  }
   if (
     (mode === "MICROMOBILITY" || mode === "SCOOTER") &&
     rentedVehicle &&
@@ -441,15 +454,15 @@ export function calculateTncFares(
   itinerary: ItineraryOnlyLegsRequired
 ): TncFare {
   return itinerary.legs
-    .filter(leg => leg.mode === "CAR" && leg.hailedCar && leg.tncData)
+    .filter(leg => leg.mode === "CAR" && leg.rideHailingEstimate)
     .reduce(
-      ({ maxTNCFare, minTNCFare }, { tncData }) => {
-        const { currency, maxCost, minCost } = tncData;
+      ({ maxTNCFare, minTNCFare }, { rideHailingEstimate }) => {
+        const { minPrice, maxPrice } = rideHailingEstimate;
         return {
           // Assumes a single currency for entire itinerary.
-          currencyCode: currency,
-          maxTNCFare: maxTNCFare + maxCost,
-          minTNCFare: minTNCFare + minCost
+          currencyCode: minPrice.currency.code,
+          maxTNCFare: maxTNCFare + maxPrice.amount,
+          minTNCFare: minTNCFare + minPrice.amount
         };
       },
       {
@@ -460,27 +473,6 @@ export function calculateTncFares(
     );
 }
 
-/**
- * For a given fare component (either total fare or component parts), returns
- * an object with the fare value (in cents).
- */
-export function getTransitFare(
-  fareComponent: Money
-): {
-  currencyCode: string;
-  transitFare: number;
-} {
-  return fareComponent
-    ? {
-        currencyCode: fareComponent.currency.currencyCode,
-        transitFare: fareComponent.cents
-      }
-    : {
-        currencyCode: "USD",
-        transitFare: 0
-      };
-}
-
 /**
  * Sources:
  * - https://www.itf-oecd.org/sites/default/files/docs/environmental-performance-new-mobility.pdf
@@ -563,20 +555,6 @@ export function getDisplayedStopId(placeOrStop: Place | Stop): string {
   return stopCode || stopId?.split(":")[1] || stopId;
 }
 
-/**
- * Adds the fare product info to each leg in an itinerary, from the itinerary's fare property
- * @param itinerary Itinerary with legProducts in fare object
- * @returns Itinerary with legs that have fare products attached to them
- */
-export function getLegsWithFares(itinerary: Itinerary): Leg[] {
-  return itinerary.legs.map((leg, i) => ({
-    ...leg,
-    fareProducts: itinerary.fare?.legProducts
-      ?.filter(lp => lp?.legIndices?.includes(i))
-      .flatMap(lp => lp.products)
-  }));
-}
-
 /**
  * Extracts useful data from the fare products on a leg, such as the leg cost and transfer info.
  * @param leg Leg with fare products (must have used getLegsWithFares)
@@ -586,23 +564,26 @@ export function getLegsWithFares(itinerary: Itinerary): Leg[] {
  */
 export function getLegCost(
   leg: Leg,
-  category: string,
-  container: string
-): { price?: Money; transferAmount?: number } {
+  mediumId: string,
+  riderCategoryId: string
+): { price?: Money; transferAmount?: Money | undefined } {
   if (!leg.fareProducts) return { price: undefined };
-
-  const relevantFareProducts = leg.fareProducts.filter(
-    fp => fp.category.name === category && fp.container.name === container
-  );
-  const totalCost = relevantFareProducts.find(fp => fp.name === "rideCost")
-    ?.amount;
+  const relevantFareProducts = leg.fareProducts.filter(({ product }) => {
+    return (
+      product.riderCategory.id === riderCategoryId &&
+      product.medium.id === mediumId
+    );
+  });
+  const totalCost = relevantFareProducts.find(
+    fp => fp.product.name === "rideCost"
+  )?.product?.price;
   const transferFareProduct = relevantFareProducts.find(
-    fp => fp.name === "transfer"
+    fp => fp.product.name === "transfer"
   );
 
   return {
     price: totalCost,
-    transferAmount: transferFareProduct?.amount?.cents
+    transferAmount: transferFareProduct?.product.price
   };
 }
 
@@ -615,17 +596,64 @@ export function getLegCost(
  */
 export function getItineraryCost(
   legs: Leg[],
-  category: string,
-  container: string
-): Money {
-  return legs
-    .filter(leg => !!leg.fareProducts)
-    .map(leg => getLegCost(leg, category, container).price)
-    .reduce<Money>(
-      (prev, cur) => ({
-        cents: prev.cents + cur?.cents || 0,
-        currency: prev.currency ?? cur?.currency
-      }),
-      { cents: 0, currency: null }
-    );
+  mediumId: string,
+  riderCategoryId: string
+): Money | undefined {
+  const legCosts = legs
+    .filter(leg => leg.fareProducts?.length > 0)
+    .map(leg => getLegCost(leg, mediumId, riderCategoryId).price)
+    .filter(cost => cost !== undefined);
+  if (legCosts.length === 0) return undefined;
+  return legCosts.reduce<Money>(
+    (prev, cur) => ({
+      amount: prev.amount + cur?.amount || 0,
+      currency: prev.currency ?? cur?.currency
+    }),
+    { amount: 0, currency: null }
+  );
 }
+
+const pickupDropoffTypeToOtp1 = otp2Type => {
+  switch (otp2Type) {
+    case "COORDINATE_WITH_DRIVER":
+      return "coordinateWithDriver";
+    case "CALL_AGENCY":
+      return "mustPhone";
+    case "SCHEDULED":
+      return "scheduled";
+    case "NONE":
+      return "none";
+    default:
+      return null;
+  }
+};
+
+export const convertGraphQLResponseToLegacy = (leg: any): any => ({
+  ...leg,
+  agencyBrandingUrl: leg.agency?.url,
+  agencyName: leg.agency?.name,
+  agencyUrl: leg.agency?.url,
+  alightRule: pickupDropoffTypeToOtp1(leg.dropoffType),
+  boardRule: pickupDropoffTypeToOtp1(leg.pickupType),
+  dropOffBookingInfo: {
+    latestBookingTime: leg.dropOffBookingInfo
+  },
+  from: {
+    ...leg.from,
+    stopCode: leg.from.stop?.code,
+    stopId: leg.from.stop?.gtfsId
+  },
+  route: leg.route?.shortName,
+  routeColor: leg.route?.color,
+  routeId: leg.route?.id,
+  routeLongName: leg.route?.longName,
+  routeShortName: leg.route?.shortName,
+  routeTextColor: leg.route?.textColor,
+  to: {
+    ...leg.to,
+    stopCode: leg.to.stop?.code,
+    stopId: leg.to.stop?.gtfsId
+  },
+  tripHeadsign: leg.trip?.tripHeadsign,
+  tripId: leg.trip?.gtfsId
+});