ti2-tourplan 1.0.130 → 1.0.131

package/index.test.js

@@ -870,6 +870,240 @@ describe('search tests', () => {
     expect(retVal).toMatchSnapshot();
   });
 
+  describe('searchProductsForItinerary pickupPoints', () => {
+    const singlePickupPoint = {
+      Point_ID: '504',
+      PointDescription: 'Keio Plaza Hotel Tokyo',
+      CanPickup: 'Y',
+      CanDropoff: 'Y',
+      puTime: '0815',
+      doTime: '1800',
+    };
+    const defaultCallTourplan = mockCallTourplan.getMockImplementation();
+    const mockOptionIdProductSearch = ({ pickupPoints } = {}) => {
+      mockCallTourplan.mockImplementation(async ({ model }) => {
+        if (model.AgentInfoRequest) {
+          return { AgentInfoReply: { Currency: 'USD' } };
+        }
+        if (model.GetLocationsRequest) {
+          return { GetLocationsReply: { Locations: { Location: [] } } };
+        }
+        if (model.GetServicesRequest) {
+          return { GetServicesReply: { TPLServices: { TPLService: [] } } };
+        }
+        if (model.GetSystemSettingsRequest) {
+          return { GetSystemSettingsReply: { Countries: { Country: [] } } };
+        }
+        if (model.OptionInfoRequest) {
+          return {
+            OptionInfoReply: {
+              Option: {
+                Opt: 'LONSMPICKUP00001',
+                OptGeneral: {
+                  SupplierId: '1001',
+                  SupplierName: 'Pickup Supplier',
+                  Description: 'Pickup Tour',
+                  SType: 'N',
+                  AdultsAllowed: 'Y',
+                  ButtonName: 'Sightseeing',
+                  ...(pickupPoints !== undefined ? { PickupPoints: pickupPoints } : {}),
+                },
+              },
+            },
+          };
+        }
+        throw new Error(`Unexpected model: ${Object.keys(model)[0]}`);
+      });
+    };
+    const getOptionInfoRequest = () => mockCallTourplan.mock.calls
+      .map(([call]) => call.model.OptionInfoRequest)
+      .find(Boolean);
+
+    afterEach(() => {
+      mockCallTourplan.mockImplementation(defaultCallTourplan);
+    });
+
+    it('uses GR OptionInfo by default for optionId search', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        mockOptionIdProductSearch();
+
+        const retVal = await app.searchProductsForItinerary({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            optionId: 'LONSMPICKUP00001',
+          },
+        });
+
+        expect(getOptionInfoRequest().Info).toBe('GR');
+        expect(retVal.products[0].options[0].pickupPoints).toBeUndefined();
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
+    it.each([false, 'false'])(
+      'keeps GR OptionInfo when pickupPointsRequired is %p',
+      async pickupPointsRequired => {
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        try {
+          mockOptionIdProductSearch();
+
+          const retVal = await app.searchProductsForItinerary({
+            axios,
+            token,
+            typeDefsAndQueries,
+            payload: {
+              optionId: 'LONSMPICKUP00001',
+              pickupPointsRequired,
+            },
+          });
+
+          expect(getOptionInfoRequest().Info).toBe('GR');
+          expect(retVal.products[0].options[0].pickupPoints).toBeUndefined();
+        } finally {
+          warnSpy.mockRestore();
+        }
+      },
+    );
+
+    it('preserves Tourplan pickupPoints on options', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        mockOptionIdProductSearch({
+          pickupPoints: { PickupPoint: singlePickupPoint },
+        });
+
+        const retVal = await app.searchProductsForItinerary({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            optionId: 'LONSMPICKUP00001',
+            pickupPointsRequired: true,
+          },
+        });
+
+        expect(getOptionInfoRequest().Info).toBe('GRP');
+        expect(retVal.products[0].options[0].pickupPoints).toEqual({
+          PickupPoint: [singlePickupPoint],
+        });
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
+    it('treats string true pickupPointsRequired as enabled', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        mockOptionIdProductSearch({
+          pickupPoints: { PickupPoint: singlePickupPoint },
+        });
+
+        const retVal = await app.searchProductsForItinerary({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            optionId: 'LONSMPICKUP00001',
+            pickupPointsRequired: 'true',
+          },
+        });
+
+        expect(getOptionInfoRequest().Info).toBe('GRP');
+        expect(retVal.products[0].options[0].pickupPoints).toEqual({
+          PickupPoint: [singlePickupPoint],
+        });
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
+    it('keeps already-array PickupPoint values', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        const pickupPoints = {
+          PickupPoint: [
+            singlePickupPoint,
+            {
+              Point_ID: '505',
+              PointDescription: 'Tokyo Station',
+              CanPickup: 'N',
+              CanDropoff: 'Y',
+              doTime: '1800',
+            },
+          ],
+        };
+        mockOptionIdProductSearch({ pickupPoints });
+
+        const retVal = await app.searchProductsForItinerary({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            optionId: 'LONSMPICKUP00001',
+            pickupPointsRequired: 1,
+          },
+        });
+
+        expect(getOptionInfoRequest().Info).toBe('GRP');
+        expect(retVal.products[0].options[0].pickupPoints).toEqual(pickupPoints);
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
+    it('omits pickupPoints when Tourplan returns none', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        mockOptionIdProductSearch({
+          pickupPoints: { PickupPoint: [] },
+        });
+
+        const retVal = await app.searchProductsForItinerary({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            optionId: 'LONSMPICKUP00001',
+            pickupPointsRequired: true,
+          },
+        });
+
+        expect(getOptionInfoRequest().Info).toBe('GRP');
+        expect(retVal.products[0].options[0].pickupPoints).toBeUndefined();
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
+    it('omits empty PickupPoints shells', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        mockOptionIdProductSearch({
+          pickupPoints: {},
+        });
+
+        const retVal = await app.searchProductsForItinerary({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            optionId: 'LONSMPICKUP00001',
+            pickupPointsRequired: 'yes',
+          },
+        });
+
+        expect(getOptionInfoRequest().Info).toBe('GRP');
+        expect(retVal.products[0].options[0]).not.toHaveProperty('pickupPoints');
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+  });
+
   describe('searchProductsForItinerary omitServiceCodes', () => {
     const optionGeneral = {
       SupplierId: '1001',
@@ -940,6 +1174,11 @@ describe('search tests', () => {
         '???BD????????????',
         '???TR????????????',
       ]);
+      const infos = mockCallTourplan.mock.calls
+        .map(([call]) => call.model.OptionInfoRequest)
+        .filter(Boolean)
+        .map(req => req.Info);
+      expect(infos).toEqual(['G', 'G', 'G']);
       expect(debugSpy).not.toHaveBeenCalled();
       expect(retVal.products).toHaveLength(1);
       expect(retVal.products[0].options.map(o => o.optionId)).toEqual([
@@ -950,6 +1189,83 @@ describe('search tests', () => {
       debugSpy.mockRestore();
     });
 
+    it('requests pickup points in full-catalog OptionInfo when required', async () => {
+      const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        const tourplanPickupPoints = {
+          PickupPoint: {
+            Point_ID: '504',
+            PointDescription: 'Keio Plaza Hotel Tokyo',
+            CanPickup: 'Y',
+            CanDropoff: 'Y',
+            puTime: '0815',
+            doTime: '1800',
+          },
+        };
+        const normalizedPickupPoints = {
+          PickupPoint: [tourplanPickupPoints.PickupPoint],
+        };
+        mockCallTourplan.mockImplementation(async ({ model }) => {
+          if (model.AgentInfoRequest) {
+            return { AgentInfoReply: { Currency: 'USD' } };
+          }
+          if (model.GetLocationsRequest) {
+            return { GetLocationsReply: { Locations: { Location: [] } } };
+          }
+          if (model.GetSystemSettingsRequest) {
+            return { GetSystemSettingsReply: { Countries: { Country: [] } } };
+          }
+          if (model.GetServicesRequest) return getServicesReply;
+          const opt = model.OptionInfoRequest && model.OptionInfoRequest.Opt;
+          if (optionsByOpt[opt]) {
+            return {
+              OptionInfoReply: {
+                Option: {
+                  ...optionsByOpt[opt],
+                  OptGeneral: {
+                    ...optionsByOpt[opt].OptGeneral,
+                    PickupPoints: tourplanPickupPoints,
+                  },
+                },
+              },
+            };
+          }
+          throw new Error(`Unexpected OptionInfo Opt: ${opt}`);
+        });
+
+        const retVal = await app.searchProductsForItinerary({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            searchInput: '',
+            pickupPointsRequired: true,
+          },
+        });
+
+        const infos = mockCallTourplan.mock.calls
+          .map(([call]) => call.model.OptionInfoRequest)
+          .filter(Boolean)
+          .map(req => req.Info);
+        expect(infos).toEqual(['GP', 'GP', 'GP']);
+        expect(retVal.products[0].options.map(o => o.optionId)).toEqual([
+          'TESTACOPTION00001',
+          'TESTBDOPTION00001',
+          'TESTTROPTION00001',
+        ]);
+        expect(retVal.products[0].options.map(o => o.pickupPoints)).toEqual([
+          normalizedPickupPoints,
+          normalizedPickupPoints,
+          normalizedPickupPoints,
+        ]);
+        expect(warnSpy).not.toHaveBeenCalled();
+      } finally {
+        debugSpy.mockRestore();
+        warnSpy.mockRestore();
+      }
+    });
+
     it('fetches all service codes when omitServiceCodes is empty', async () => {
       const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
       mockFullCatalog();

package/itinerary-products-search.js

@@ -7,6 +7,30 @@ const { getCachedLocations } = require('./tp-helpers/locations');
 const { getCachedServices } = require('./tp-helpers/services');
 const { getCachedDestinationCountries } = require('./tp-helpers/system-settings');
 const { enrichOptionWithCodeTables } = require('./tp-helpers/option-enrichment');
+const { asArray } = require('./tp-helpers/values');
+
+const isEnabled = value => {
+  if (value === true || value === 1) return true;
+  const normalized = String(value == null ? '' : value).trim().toLowerCase();
+  return normalized === 'true' || normalized === '1' || normalized === 'yes';
+};
+
+// Keep Tourplan PascalCase under camelCase pickupPoints (same pattern as optRates).
+// Bokun channel-manager reads container.PickupPoint / point.Point_ID etc.
+const normalizePickupPoints = rawPickupPoints => {
+  if (!rawPickupPoints || typeof rawPickupPoints !== 'object') return undefined;
+  const points = asArray(R.path(['PickupPoint'], rawPickupPoints))
+    .filter(point => point && typeof point === 'object' && !Array.isArray(point));
+  if (!points.length) return undefined;
+  return {
+    ...rawPickupPoints,
+    PickupPoint: points,
+  };
+};
+
+const getOptionInfoTag = ({ includeRates = false, pickupPointsRequired = false } = {}) => (
+  `${includeRates ? 'GR' : 'G'}${pickupPointsRequired ? 'P' : ''}`
+);
 
 const searchProductsForItinerary = async ({
   axios,
@@ -30,6 +54,8 @@ const searchProductsForItinerary = async ({
     // service codes to omit from full catalog search
     // (e.g. ['AC'], 'AC', or 'AC,SM'); when empty/absent, get all
     omitServiceCodes,
+    // Request Tourplan pickup/dropoff points in OptionInfo when product consumers need them.
+    pickupPointsRequired,
   },
   callTourplan,
   cache,
@@ -38,6 +64,7 @@ const searchProductsForItinerary = async ({
   const optionIds = optionId
     ? (Array.isArray(optionId) ? optionId : [optionId]).filter(Boolean)
     : [];
+  const shouldRequestPickupPoints = isEnabled(pickupPointsRequired);
 
   let options = [];
   let servicesByCode;
@@ -62,7 +89,10 @@ const searchProductsForItinerary = async ({
       const getOptionsModel = {
         OptionInfoRequest: {
           Opt: id,
-          Info: 'GR',
+          Info: getOptionInfoTag({
+            includeRates: true,
+            pickupPointsRequired: shouldRequestPickupPoints,
+          }),
           AgentID: hostConnectAgentID,
           Password: hostConnectAgentPassword,
         },
@@ -116,7 +146,7 @@ const searchProductsForItinerary = async ({
       const getOptionsModel = {
         OptionInfoRequest: {
           Opt: `???${serviceCode}????????????`,
-          Info: 'G',
+          Info: getOptionInfoTag({ pickupPointsRequired: shouldRequestPickupPoints }),
           AgentID: hostConnectAgentID,
           Password: hostConnectAgentPassword,
           ...(lastUpdatedFrom ? {
@@ -217,10 +247,11 @@ const searchProductsForItinerary = async ({
       concurrency: 10,
     },
   );
-  // Preserve raw OptRates from Tourplan in product search response when available.
-  // Also ensure city and currency are always on the option for product cache:
-  // stock TI2 itinerary-product typeDefs/query omit them, so GraphQL alone will
-  // not return them even when the code-table and AgentInfo values are available.
+  // Preserve raw OptRates / PickupPoints from Tourplan in product search response
+  // when available (camelCase keys: optRates, pickupPoints; Tourplan field casing
+  // inside). Re-attach after GraphQL because stock TI2 itinerary-product
+  // typeDefs/query omit these fields (same for city/country/currency).
+  // Also ensure city and currency are always on the option for product cache.
   const enrichedByOptionId = R.indexBy(R.prop('Opt'), enrichedOptions);
   const optionRatesByOptionId = options.reduce((acc, option) => {
     const currentOptionId = R.path(['Opt'], option);
@@ -231,7 +262,7 @@ const searchProductsForItinerary = async ({
       [currentOptionId]: currentOptionRates,
     };
   }, {});
-  const productsWithOptRates = products.map(product => ({
+  const productsWithRawOptionMetadata = products.map(product => ({
     ...product,
     options: R.pathOr([], ['options'], product).map(currentOption => {
       const rawOption = R.path([currentOption.optionId], enrichedByOptionId) || {};
@@ -242,11 +273,16 @@ const searchProductsForItinerary = async ({
         || R.path(['__destination', 'city'], rawOption);
       const country = currentOption.country
         || R.path(['__destination', 'country'], rawOption);
+      const pickupPoints = normalizePickupPoints(
+        R.path(['OptGeneral', 'PickupPoints'], rawOption)
+          || R.path(['PickupPoints'], rawOption),
+      );
       return {
         ...R.omit(['city', 'country', 'rateContext'], currentOption),
         ...(city ? { city } : {}),
         ...(country ? { country } : {}),
         ...(currency ? { currency } : {}),
+        ...(pickupPoints ? { pickupPoints } : {}),
         ...(R.path([currentOption.optionId], optionRatesByOptionId)
           ? { optRates: R.path([currentOption.optionId], optionRatesByOptionId) }
           : {}),
@@ -254,7 +290,7 @@ const searchProductsForItinerary = async ({
     }),
   }));
   return {
-    products: productsWithOptRates,
+    products: productsWithRawOptionMetadata,
     productFields: [],
     ...(searchInput || optionId ? {} : configuration),
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-tourplan",
-  "version": "1.0.130",
+  "version": "1.0.131",
   "description": "Tourplan's TI2 Plugin",
   "main": "index.js",
   "scripts": {