ti2-tourplan 1.0.131 → 1.0.133

package/availability/itinerary-availability-helper.js

@@ -18,6 +18,8 @@ const {
 const {
   CROSS_SEASON_CAL_USING_RATE_OF_FIRST_RATE_PERIOD,
 } = require('./product-connect/itinerary-pc-option-helper');
+const { isEnabled, normalizePickupPoints } = require('../tp-helpers/pickup-points');
+const { getOptionInfoTag } = require('../utils');
 
 const NO_RATE_FOUND_FOR_LAST_YEAR_ERROR_MESSAGE = 'Custom rates cannot be calculated as the previous year\'s rate could not be found. Please change the date and try again.';
 const NO_RATE_FOUND_FOR_IMMEDIATE_LAST_DATE_RANGE_ERROR_MESSAGE = 'Custom rates cannot be calculated no last rates available. Please change the date and try again.';
@@ -131,6 +133,7 @@ const GENERIC_AVALABILITY_CHK_ERROR_MESSAGE = 'Not bookable for the requested da
   + '(e.g. no rates, block out period, on request, minimum stay etc.).';
 const RATES_AVAILABLE_TILL_ERROR_TEMPLATE = ' Rates are only available until {dateTill}. '
   + 'Please change the date and try again.';
+
 /**
  * Calculate days in a year for a given date, accounting for leap years
  * @param {string} dateString - Date string in YYYY-MM-DD format
@@ -163,6 +166,7 @@ const getAvailabilityOnly = async ({
   axios,
   startDate,
   requestedEndDate,
+  pickupPointsRequired,
   callTourplan,
 }) => {
   const isValidRequestedEndDate = moment(requestedEndDate, 'YYYY-MM-DD', true).isValid();
@@ -172,7 +176,7 @@ const getAvailabilityOnly = async ({
   const model = {
     OptionInfoRequest: {
       Opt: optionId,
-      Info: 'GAR',
+      Info: getOptionInfoTag({ checkType: 'GAR', pickupPointsRequired }),
       AgentID: hostConnectAgentID,
       Password: hostConnectAgentPassword,
       DateFrom: startDate,
@@ -187,9 +191,12 @@ const getAvailabilityOnly = async ({
     xmlOptions: hostConnectXmlOptions,
   });
   const option = R.path(['OptionInfoReply', 'Option'], replyObj);
+  const pickupPoints = normalizePickupPoints(R.path(['OptGeneral', 'PickupPoints'], option))
+    || normalizePickupPoints(R.path(['PickupPoints'], option));
   return {
     optAvail: R.pathOr([], ['OptAvail'], option),
     optRates: R.path(['OptRates'], option),
+    ...(isEnabled(pickupPointsRequired) && pickupPoints ? { pickupPoints } : {}),
   };
 };
 /*

package/availability/itinerary-availability.js

@@ -43,6 +43,8 @@ const {
   CROSS_SEASON_CAL_USING_RATE_OF_FIRST_RATE_PERIOD,
 } = require('./product-connect/itinerary-pc-option-helper');
 
+const { isEnabled } = require('../tp-helpers/pickup-points');
+
 const MIN_STAY_WARNING_MESSAGE = 'Please note that the a minimum stay requirement of {minSCU} was required for {customPeriodInfoMsg}';
 const PREVIOUS_RATE_CLOSED_PERIODS_ERROR_MESSAGE = 'Not bookable for the requested date/stay using {customPeriodInfoMsg} {closedDateRanges}';
 const INVALID_DAY_OF_WEEK_ERROR_TEMPLATE = 'The start date day can only be on {allowedDays}. Please try again with the allowed day.';
@@ -66,7 +68,19 @@ const doAllDatesHaveRatesAvailable = (lastDateRangeEndDate, startDate, chargeUni
   return !atLeastOneDateDoesNotHaveRatesAvailable;
 };
 
-const returnEmptyRatesOrError = (allowSendingServicesWithoutARate, agentCurrencyCode, errorMsg) => {
+// getAvailabilityOnly already normalizes via tp-helpers/pickup-points, so pickupPoints
+// here (when present) is always a non-empty PickupPoint array; just check for it.
+const attachPickupPoints = (response, pickupPoints) => (
+  pickupPoints && Array.isArray(pickupPoints.PickupPoint) && pickupPoints.PickupPoint.length
+    ? { ...response, pickupPoints }
+    : response
+);
+
+const returnEmptyRatesOrError = (
+  allowSendingServicesWithoutARate,
+  agentCurrencyCode,
+  errorMsg,
+) => {
   // if sending services without a rate is enabled return empty rates (0.00)
   if (allowSendingServicesWithoutARate && agentCurrencyCode) {
     return {
@@ -145,6 +159,7 @@ const searchAvailabilityForItinerary = async ({
     chargeUnitQuantity,
     roomTypeRequired = true,
     availabilityOnly = false,
+    pickupPointsRequired = false,
   },
   callTourplan,
   cache,
@@ -152,7 +167,7 @@ const searchAvailabilityForItinerary = async ({
   const isAvailabilityOnly = availabilityOnly === true;
 
   if (isAvailabilityOnly) {
-    const { optAvail, optRates } = await getAvailabilityOnly({
+    const { optAvail, optRates, pickupPoints } = await getAvailabilityOnly({
       optionId,
       hostConnectEndpoint,
       hostConnectAgentID,
@@ -160,12 +175,13 @@ const searchAvailabilityForItinerary = async ({
       axios,
       startDate,
       requestedEndDate,
+      pickupPointsRequired,
       callTourplan,
     });
     const optAvailValues = getOptAvailValues(optAvail);
     const SCheckPass = isOptAvailBookable(optAvailValues);
     const rates = (SCheckPass && optRates) ? [optRates] : [];
-    return {
+    const availabilityResponse = {
       bookable: SCheckPass,
       type: 'availability',
       ...(requestedEndDate && SCheckPass ? { endDate: requestedEndDate } : {}),
@@ -175,6 +191,9 @@ const searchAvailabilityForItinerary = async ({
       availability: optAvailValues,
       rates,
     };
+    return isEnabled(pickupPointsRequired)
+      ? attachPickupPoints(availabilityResponse, pickupPoints)
+      : availabilityResponse;
   }
 
   // Get agent currency code & cache it

package/availability/itinerary-availability.pickup-points.test.js

@@ -0,0 +1,219 @@
+/* globals describe, it, expect, jest */
+
+const {
+  getAvailabilityOnly,
+  getStayResults,
+} = require('./itinerary-availability-helper');
+const { searchAvailabilityForItinerary } = require('./itinerary-availability');
+
+describe('availability pickup points', () => {
+  const baseParams = {
+    optionId: 'LONSMPICKUP00001',
+    hostConnectEndpoint: 'https://test-host-connect.com',
+    hostConnectAgentID: 'test-agent-id',
+    hostConnectAgentPassword: 'test-agent-password',
+    axios: jest.fn(),
+    startDate: '2025-04-01',
+    requestedEndDate: '2025-04-05',
+  };
+
+  const singlePickupPoint = {
+    Point_ID: '504',
+    PointDescription: 'Keio Plaza Hotel Tokyo',
+    CanPickup: 'Y',
+    CanDropoff: 'Y',
+    puTime: '0815',
+    doTime: '1800',
+  };
+
+  const optionInfoReply = ({ pickupPoints, optAvail = '-2 -2 -2' } = {}) => ({
+    OptionInfoReply: {
+      Option: {
+        OptAvail: optAvail,
+        OptRates: { Currency: 'USD' },
+        OptGeneral: {
+          ...(pickupPoints !== undefined ? { PickupPoints: pickupPoints } : {}),
+        },
+      },
+    },
+  });
+
+  it('keeps GAR OptionInfo by default', async () => {
+    const callTourplan = jest.fn(async () => optionInfoReply());
+
+    await getAvailabilityOnly({
+      ...baseParams,
+      callTourplan,
+    });
+
+    expect(callTourplan).toHaveBeenCalledWith(expect.objectContaining({
+      model: expect.objectContaining({
+        OptionInfoRequest: expect.objectContaining({
+          Info: 'GAR',
+        }),
+      }),
+    }));
+  });
+
+  it.each([false, 'false', 0, null, undefined])(
+    'keeps GAR OptionInfo when pickupPointsRequired is %p',
+    async pickupPointsRequired => {
+      const callTourplan = jest.fn(async () => optionInfoReply());
+
+      await getAvailabilityOnly({
+        ...baseParams,
+        pickupPointsRequired,
+        callTourplan,
+      });
+
+      expect(callTourplan).toHaveBeenCalledWith(expect.objectContaining({
+        model: expect.objectContaining({
+          OptionInfoRequest: expect.objectContaining({
+            Info: 'GAR',
+          }),
+        }),
+      }));
+    },
+  );
+
+  it.each([true, 1, 'true', 'yes', 'YES'])(
+    'adds P to OptionInfo when pickupPointsRequired is %p',
+    async pickupPointsRequired => {
+      const callTourplan = jest.fn(async () => optionInfoReply({
+        pickupPoints: { PickupPoint: singlePickupPoint },
+      }));
+
+      const result = await getAvailabilityOnly({
+        ...baseParams,
+        pickupPointsRequired,
+        callTourplan,
+      });
+
+      expect(callTourplan).toHaveBeenCalledWith(expect.objectContaining({
+        model: expect.objectContaining({
+          OptionInfoRequest: expect.objectContaining({
+            Info: 'GARP',
+          }),
+        }),
+      }));
+      expect(result.pickupPoints).toEqual({
+        PickupPoint: [singlePickupPoint],
+      });
+    },
+  );
+
+  it('omits pickupPoints when Tourplan returns none', async () => {
+    const callTourplan = jest.fn(async () => optionInfoReply({
+      pickupPoints: { PickupPoint: [] },
+    }));
+
+    const result = await getAvailabilityOnly({
+      ...baseParams,
+      pickupPointsRequired: true,
+      callTourplan,
+    });
+
+    expect(result).not.toHaveProperty('pickupPoints');
+  });
+
+  it('omits pickupPoints when pickupPointsRequired is disabled', async () => {
+    const callTourplan = jest.fn(async () => optionInfoReply({
+      pickupPoints: { PickupPoint: singlePickupPoint },
+    }));
+
+    const result = await getAvailabilityOnly({
+      ...baseParams,
+      pickupPointsRequired: false,
+      callTourplan,
+    });
+
+    expect(result).not.toHaveProperty('pickupPoints');
+  });
+
+  it('falls back to top-level pickup points when OptGeneral pickup points are empty', async () => {
+    const callTourplan = jest.fn(async () => ({
+      OptionInfoReply: {
+        Option: {
+          OptAvail: '-2 -2 -2',
+          OptRates: { Currency: 'USD' },
+          OptGeneral: {
+            PickupPoints: { PickupPoint: [] },
+          },
+          PickupPoints: { PickupPoint: singlePickupPoint },
+        },
+      },
+    }));
+
+    const result = await getAvailabilityOnly({
+      ...baseParams,
+      pickupPointsRequired: true,
+      callTourplan,
+    });
+
+    expect(result.pickupPoints).toEqual({
+      PickupPoint: [singlePickupPoint],
+    });
+  });
+
+  it('keeps GS OptionInfo for stay results (pickup points come from GD/GAR)', async () => {
+    const callTourplan = jest.fn(async () => ({
+      OptionInfoReply: {
+        Option: {
+          OptStayResults: [],
+        },
+      },
+    }));
+
+    await getStayResults(
+      baseParams.optionId,
+      baseParams.hostConnectEndpoint,
+      baseParams.hostConnectAgentID,
+      baseParams.hostConnectAgentPassword,
+      baseParams.axios,
+      baseParams.startDate,
+      1,
+      [{ Adults: 2 }],
+      undefined,
+      callTourplan,
+    );
+
+    expect(callTourplan).toHaveBeenCalledWith(expect.objectContaining({
+      model: expect.objectContaining({
+        OptionInfoRequest: expect.objectContaining({
+          Info: 'GS',
+        }),
+      }),
+    }));
+  });
+
+  it('returns pickupPoints on the availabilityOnly search response', async () => {
+    const callTourplan = jest.fn(async () => optionInfoReply({
+      pickupPoints: { PickupPoint: singlePickupPoint },
+      optAvail: '-2 -2 -2',
+    }));
+
+    const result = await searchAvailabilityForItinerary({
+      axios: jest.fn(),
+      token: {
+        hostConnectEndpoint: baseParams.hostConnectEndpoint,
+        hostConnectAgentID: baseParams.hostConnectAgentID,
+        hostConnectAgentPassword: baseParams.hostConnectAgentPassword,
+      },
+      payload: {
+        optionId: baseParams.optionId,
+        startDate: baseParams.startDate,
+        endDate: baseParams.requestedEndDate,
+        availabilityOnly: true,
+        pickupPointsRequired: 'true',
+        paxConfigs: [{ adults: 2 }],
+      },
+      callTourplan,
+      cache: { getOrExec: async ({ fn, fnParams }) => fn(...fnParams) },
+    });
+
+    expect(result.bookable).toBe(true);
+    expect(result.pickupPoints).toEqual({
+      PickupPoint: [singlePickupPoint],
+    });
+  });
+});

package/availability/itinerary-availability.validation-flags.test.js

@@ -183,6 +183,128 @@ describe('searchAvailabilityForItinerary validation flags', () => {
     });
   });
 
+  it('passes pickupPointsRequired through the availabilityOnly flow', async () => {
+    await searchAvailabilityForItinerary({
+      axios: jest.fn(),
+      token: baseToken,
+      payload: {
+        ...basePayload,
+        availabilityOnly: true,
+        endDate: '2025-04-05',
+        pickupPointsRequired: true,
+      },
+      callTourplan: jest.fn(),
+      cache: { getOrExec: async ({ fn, fnParams }) => fn(...fnParams) },
+    });
+
+    expect(itineraryAvailabilityHelper.getAvailabilityOnly).toHaveBeenCalledWith(
+      expect.objectContaining({ pickupPointsRequired: true }),
+    );
+  });
+
+  it('does not pass pickupPointsRequired through the rates availability flow', async () => {
+    const result = await searchAvailabilityForItinerary({
+      axios: jest.fn(),
+      token: baseToken,
+      payload: { ...basePayload, pickupPointsRequired: true },
+      callTourplan: jest.fn(),
+      cache: { getOrExec: async ({ fn, fnParams }) => fn(...fnParams) },
+    });
+
+    expect(itineraryAvailabilityHelper.getAvailabilityConfig).toHaveBeenCalledWith(
+      expect.not.objectContaining({ pickupPointsRequired: expect.anything() }),
+    );
+    expect(itineraryAvailabilityHelper.getStayResults).toHaveBeenCalledWith(
+      basePayload.optionId,
+      baseToken.hostConnectEndpoint,
+      baseToken.hostConnectAgentID,
+      baseToken.hostConnectAgentPassword,
+      expect.any(Function),
+      basePayload.startDate,
+      basePayload.chargeUnitQuantity,
+      expect.any(Array),
+      undefined,
+      expect.any(Function),
+    );
+    expect(result).not.toHaveProperty('pickupPoints');
+  });
+
+  it('returns pickupPoints on the availabilityOnly response when provided', async () => {
+    const pickupPoints = {
+      PickupPoint: [{ Point_ID: '504', PointDescription: 'Keio Plaza Hotel Tokyo' }],
+    };
+    itineraryAvailabilityHelper.getAvailabilityOnly.mockResolvedValueOnce({
+      optAvail: '-2 -2 -2',
+      optRates: { Currency: 'USD' },
+      pickupPoints,
+    });
+
+    const result = await searchAvailabilityForItinerary({
+      axios: jest.fn(),
+      token: baseToken,
+      payload: {
+        ...basePayload,
+        availabilityOnly: true,
+        endDate: '2025-04-05',
+        pickupPointsRequired: 'yes',
+      },
+      callTourplan: jest.fn(),
+      cache: { getOrExec: async ({ fn, fnParams }) => fn(...fnParams) },
+    });
+
+    expect(result.pickupPoints).toEqual(pickupPoints);
+    expect(result.bookable).toBe(true);
+  });
+
+  it('omits pickupPoints on the availabilityOnly response when pickupPointsRequired is disabled', async () => {
+    itineraryAvailabilityHelper.getAvailabilityOnly.mockResolvedValueOnce({
+      optAvail: '-2 -2 -2',
+      optRates: { Currency: 'USD' },
+      pickupPoints: {
+        PickupPoint: [{ Point_ID: '504', PointDescription: 'Keio Plaza Hotel Tokyo' }],
+      },
+    });
+
+    const result = await searchAvailabilityForItinerary({
+      axios: jest.fn(),
+      token: baseToken,
+      payload: {
+        ...basePayload,
+        availabilityOnly: true,
+        endDate: '2025-04-05',
+        pickupPointsRequired: false,
+      },
+      callTourplan: jest.fn(),
+      cache: { getOrExec: async ({ fn, fnParams }) => fn(...fnParams) },
+    });
+
+    expect(result).not.toHaveProperty('pickupPoints');
+    expect(result.bookable).toBe(true);
+  });
+
+  it('omits pickupPoints when the helper returns an empty PickupPoint array', async () => {
+    itineraryAvailabilityHelper.getAvailabilityOnly.mockResolvedValueOnce({
+      optAvail: '-2 -2 -2',
+      optRates: { Currency: 'USD' },
+      pickupPoints: { PickupPoint: [] },
+    });
+
+    const result = await searchAvailabilityForItinerary({
+      axios: jest.fn(),
+      token: baseToken,
+      payload: {
+        ...basePayload,
+        availabilityOnly: true,
+        endDate: '2025-04-05',
+        pickupPointsRequired: true,
+      },
+      callTourplan: jest.fn(),
+      cache: { getOrExec: async ({ fn, fnParams }) => fn(...fnParams) },
+    });
+
+    expect(result).not.toHaveProperty('pickupPoints');
+  });
+
   it('marks availabilityOnly response as not bookable when all days are unavailable', async () => {
     itineraryAvailabilityHelper.getAvailabilityOnly.mockResolvedValueOnce({
       optAvail: '-1 -1 -1',

package/index.test.js

@@ -1804,6 +1804,52 @@ describe('search tests', () => {
       expect(retVal.bookings[0].bookingId).toBe('316559');
     });
 
+    it('searchItineraries keeps successful fallback criteria when one bookingId criterion fails', async () => {
+      axios.mockImplementation(getFixture);
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      mockCallTourplan.mockImplementation(async request => {
+        const { model } = request;
+        const listRequest = model && model.ListBookingsRequest;
+        if (listRequest && listRequest.BookingId === '2694192') {
+          throw new Error('Request failed with status code 500: Object not found in BookingData cache 2694192');
+        }
+        if (listRequest && listRequest.Ref === '2694192') {
+          return { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
+        }
+        if (listRequest && listRequest.AgentRef === '2694192') {
+          return {
+            ListBookingsReply: {
+              BookingHeaders: {
+                BookingHeader: [{ BookingId: '316559' }],
+              },
+            },
+          };
+        }
+        return defaultCallTourplanImplementation(request);
+      });
+
+      try {
+        const retVal = await app.searchItineraries({
+          axios,
+          token,
+          typeDefsAndQueries,
+          payload: {
+            bookingId: '2694192',
+          },
+        });
+
+        expect(retVal.bookings.length).toBe(1);
+        expect(retVal.bookings[0].bookingId).toBe('316559');
+        expect(warnSpy).toHaveBeenCalledWith(
+          '[tourplan] ListBookingsRequest failed',
+          { BookingId: '2694192' },
+          'Request failed with status code 500: Object not found in BookingData cache 2694192',
+        );
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
     it('searchItineraries by name (NameContains)', async () => {
       axios.mockImplementation(getFixture);
       const retVal = await app.searchItineraries({

package/itinerary-products-search.js

@@ -7,30 +7,11 @@ 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 {
+  isEnabled,
+  normalizePickupPoints,
+} = require('./tp-helpers/pickup-points');
+const { getOptionInfoTag } = require('./utils');
 
 const searchProductsForItinerary = async ({
   axios,
@@ -273,10 +254,12 @@ 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),
-      );
+      const pickupPoints = shouldRequestPickupPoints
+        ? normalizePickupPoints(
+          R.path(['OptGeneral', 'PickupPoints'], rawOption)
+            || R.path(['PickupPoints'], rawOption),
+        )
+        : undefined;
       return {
         ...R.omit(['city', 'country', 'rateContext'], currentOption),
         ...(city ? { city } : {}),

package/itinerary-search.js

@@ -231,13 +231,15 @@ const searchItineraries = async ({
 
   // Step4: Fetch for bookings based on the search criterias.
   const allSearches = searchCriterias.length
-    ? searchCriterias.map(async keyObj => {
-      let reply;
-      try {
-        reply = await callTourplan(getPayload('ListBookingsRequest', {
-          ...(baseSearchFilters ? { ...baseSearchFilters } : {}),
-          ...keyObj,
-        }));
+    ? searchCriterias.map(keyObj => ({
+      keyObj,
+      promise: (async () => {
+        let reply;
+        try {
+          reply = await callTourplan(getPayload('ListBookingsRequest', {
+            ...(baseSearchFilters ? { ...baseSearchFilters } : {}),
+            ...keyObj,
+          }));
         /*
           <Reply>
             <ListBookingsReply>
@@ -262,33 +264,55 @@ const searchItineraries = async ({
             </ListBookingsReply>
           </Reply>
         */
-      } catch (err) {
-        const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
-        if (errMsg.includes('Request failed with status code')) {
-          throw Error(errMsg);
+        } catch (err) {
+          const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
+          if (errMsg.includes('Request failed with status code')) {
+            throw Error(errMsg);
+          }
+          // if it's not server error, we just considered as no booking is found
+          reply = { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
         }
-        // if it's not server error, we just considered as no booking is found
-        reply = { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
-      }
-      return reply;
-    })
+        return reply;
+      })(),
+    }))
     : [
       // Date-range-only search (no explicit criteria). Wrap in the same try/catch
       // pattern as the map branch so a non-HTTP error is treated as zero results
       // rather than crashing the entire search.
-      (async () => {
-        try {
-          return await callTourplan(getPayload('ListBookingsRequest', baseSearchFilters));
-        } catch (err) {
-          const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
-          if (errMsg.includes('Request failed with status code')) throw Error(errMsg);
-          return { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
-        }
-      })(),
+      {
+        keyObj: baseSearchFilters,
+        promise: (async () => {
+          try {
+            return await callTourplan(getPayload('ListBookingsRequest', baseSearchFilters));
+          } catch (err) {
+            const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
+            if (errMsg.includes('Request failed with status code')) throw Error(errMsg);
+            return { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
+          }
+        })(),
+      },
     ];
 
   // Step5: Get full booking details for each booking.
-  const replyObjs = await Promise.all(allSearches);
+  const settledSearches = await global.Promise.allSettled(allSearches.map(({ promise }) => promise));
+  const replyObjs = [];
+  const rejectedSearches = [];
+
+  settledSearches.forEach((result, idx) => {
+    if (result.status === 'fulfilled') {
+      replyObjs.push(result.value);
+      return;
+    }
+    const { keyObj } = allSearches[idx];
+    const { reason } = result;
+    const errMsg = reason instanceof Error ? reason.message : String(reason);
+    rejectedSearches.push(reason);
+    console.warn('[tourplan] ListBookingsRequest failed', keyObj, errMsg);
+  });
+
+  if (!replyObjs.length && rejectedSearches.length) {
+    throw rejectedSearches[0];
+  }
   const bookingHeadersRaw = R.flatten(
     replyObjs.map(o => R.pathOr(
       [],

package/package.json

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

package/tp-helpers/pickup-points.js

@@ -0,0 +1,21 @@
+const R = require('ramda');
+const { asArray } = require('./values');
+const { isEnabled } = require('../utils');
+
+// 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,
+  };
+};
+
+module.exports = {
+  isEnabled,
+  normalizePickupPoints,
+};

package/tp-helpers/pickup-points.test.js

@@ -0,0 +1,51 @@
+/* globals describe, it, expect */
+
+const {
+  isEnabled,
+  normalizePickupPoints,
+} = require('./pickup-points');
+
+describe('pickup-points helpers', () => {
+  describe('isEnabled', () => {
+    it.each([true, 1, 'true', 'TRUE', '1', 'yes', ' Yes '])(
+      'treats %p as enabled',
+      value => {
+        expect(isEnabled(value)).toBe(true);
+      },
+    );
+
+    it.each([false, 0, 'false', 'no', '', null, undefined, 'maybe'])(
+      'treats %p as disabled',
+      value => {
+        expect(isEnabled(value)).toBe(false);
+      },
+    );
+  });
+
+  describe('normalizePickupPoints', () => {
+    const singlePickupPoint = {
+      Point_ID: '504',
+      PointDescription: 'Keio Plaza Hotel Tokyo',
+      CanPickup: 'Y',
+      CanDropoff: 'Y',
+    };
+
+    it('normalizes a single PickupPoint object to an array', () => {
+      expect(normalizePickupPoints({ PickupPoint: singlePickupPoint })).toEqual({
+        PickupPoint: [singlePickupPoint],
+      });
+    });
+
+    it('keeps already-array PickupPoint values', () => {
+      const pickupPoints = { PickupPoint: [singlePickupPoint] };
+      expect(normalizePickupPoints(pickupPoints)).toEqual(pickupPoints);
+    });
+
+    it('omits empty shells and non-objects', () => {
+      expect(normalizePickupPoints(undefined)).toBeUndefined();
+      expect(normalizePickupPoints({})).toBeUndefined();
+      expect(normalizePickupPoints({ PickupPoint: [] })).toBeUndefined();
+      expect(normalizePickupPoints('nope')).toBeUndefined();
+    });
+  });
+});

package/utils.js

@@ -71,6 +71,33 @@ const escapeInvalidXmlChars = str => {
     .replace(BAD_XML_CHARS, '');
 };
 
+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';
+};
+
+/**
+ * Build a HostConnect OptionInfoRequest.Info tag (e.g. G, GR, GAR, GD, + optional P).
+ *
+ * @param {object} [options]
+ * @param {string} [options.checkType] - Explicit base tag (e.g. 'GAR', 'GD', 'GS').
+ *   When provided, this takes precedence and `includeRates` is ignored.
+ * @param {boolean} [options.includeRates=false] - Only used when `checkType` is omitted;
+ *   selects between the product-search base tags 'GR' (rates included) and 'G'.
+ * @param {boolean|string|number} [options.pickupPointsRequired=false] - When enabled
+ *   (see `isEnabled`), appends 'P' to the base tag to request pickup/dropoff points.
+ * @returns {string} The resulting Info tag, e.g. 'G', 'GR', 'GARP'.
+ */
+const getOptionInfoTag = ({
+  checkType,
+  includeRates = false,
+  pickupPointsRequired = false,
+} = {}) => {
+  const base = checkType || (includeRates ? 'GR' : 'G');
+  return `${base}${isEnabled(pickupPointsRequired) ? 'P' : ''}`;
+};
+
 const getValidDateOfBirth = dob => {
   if (typeof dob !== 'string') return undefined;
   const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dob);
@@ -188,4 +215,6 @@ module.exports = {
   hostConnectXmlOptions,
   productConnectXmlOptions,
   passengerTypeMap,
+  isEnabled,
+  getOptionInfoTag,
 };

package/utils.test.js

@@ -1,4 +1,10 @@
-const { escapeInvalidXmlChars, getRoomConfigs } = require('./utils');
+/* globals describe, it, expect */
+
+const {
+  escapeInvalidXmlChars,
+  getOptionInfoTag,
+  getRoomConfigs,
+} = require('./utils');
 
 describe('getRoomConfigs', () => {
   const getPaxDetails = passenger => getRoomConfigs([{
@@ -135,3 +141,24 @@ describe('escapeInvalidXmlChars', () => {
     expect(escapeInvalidXmlChars('X\uD800Y')).toBe('XY');
   });
 });
+
+describe('getOptionInfoTag', () => {
+  it('uses includeRates for product-search tags when checkType is omitted', () => {
+    expect(getOptionInfoTag()).toBe('G');
+    expect(getOptionInfoTag({ includeRates: true })).toBe('GR');
+    expect(getOptionInfoTag({ includeRates: false, pickupPointsRequired: 'false' })).toBe('G');
+  });
+
+  it('keeps an explicit checkType when pickup points are not required', () => {
+    expect(getOptionInfoTag({ checkType: 'GAR' })).toBe('GAR');
+    expect(getOptionInfoTag({ checkType: 'GD', pickupPointsRequired: false })).toBe('GD');
+    expect(getOptionInfoTag({ includeRates: true, pickupPointsRequired: 'false' })).toBe('GR');
+  });
+
+  it('appends P for truthy pickupPointsRequired values', () => {
+    expect(getOptionInfoTag({ checkType: 'GAR', pickupPointsRequired: true })).toBe('GARP');
+    expect(getOptionInfoTag({ checkType: 'GD', pickupPointsRequired: 'yes' })).toBe('GDP');
+    expect(getOptionInfoTag({ includeRates: true, pickupPointsRequired: 1 })).toBe('GRP');
+    expect(getOptionInfoTag({ pickupPointsRequired: true })).toBe('GP');
+  });
+});