ti2-tourplan 1.0.133 → 1.0.135

package/__snapshots__/index.test.js.snap

@@ -4155,6 +4155,7 @@ Object {
           "country": "United Kingdom",
           "currency": "GBP",
           "extras": Array [],
+          "inclusions": Array [],
           "lastUpdateTimestamp": 1700750093,
           "optRates": Object {
             "CancelPolicies": Object {

package/index.test.js

@@ -867,6 +867,7 @@ describe('search tests', () => {
       },
     });
     expect(R.path(['products', 0, 'options', 0, 'city'], retVal)).toBe('London');
+    expect(R.path(['products', 0, 'options', 0, 'inclusions'], retVal)).toEqual([]);
     expect(retVal).toMatchSnapshot();
   });
 
@@ -1850,6 +1851,50 @@ describe('search tests', () => {
       }
     });
 
+    it('searchItineraries searches alphanumeric bookingId candidates as AgentRef', async () => {
+      axios.mockImplementation(getFixture);
+      mockCallTourplan.mockImplementation(async request => {
+        const { model } = request;
+        const listRequest = model && model.ListBookingsRequest;
+        if (listRequest && listRequest.BookingId === 'SGMX269690') {
+          return { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
+        }
+        if (listRequest && listRequest.Ref === 'SGMX269690') {
+          return { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
+        }
+        if (listRequest && listRequest.AgentRef === 'SGMX269690') {
+          return {
+            ListBookingsReply: {
+              BookingHeaders: {
+                BookingHeader: [{ BookingId: '316559' }],
+              },
+            },
+          };
+        }
+        return defaultCallTourplanImplementation(request);
+      });
+
+      const retVal = await app.searchItineraries({
+        axios,
+        token,
+        typeDefsAndQueries,
+        payload: {
+          bookingId: 'SGMX269690',
+        },
+      });
+
+      expect(retVal.bookings.length).toBe(1);
+      expect(retVal.bookings[0].bookingId).toBe('316559');
+      const listRequests = mockCallTourplan.mock.calls
+        .map(([{ model }]) => model && model.ListBookingsRequest)
+        .filter(Boolean);
+      expect(listRequests).toEqual(expect.arrayContaining([
+        expect.objectContaining({ BookingId: 'SGMX269690' }),
+        expect.objectContaining({ Ref: 'SGMX269690' }),
+        expect.objectContaining({ AgentRef: 'SGMX269690' }),
+      ]));
+    });
+
     it('searchItineraries by name (NameContains)', async () => {
       axios.mockImplementation(getFixture);
       const retVal = await app.searchItineraries({

package/itinerary-products-search.js

@@ -7,6 +7,7 @@ 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 { addStructuredOptionMetadata } = require('./option-metadata');
 const {
   isEnabled,
   normalizePickupPoints,
@@ -260,7 +261,7 @@ const searchProductsForItinerary = async ({
             || R.path(['PickupPoints'], rawOption),
         )
         : undefined;
-      return {
+      return addStructuredOptionMetadata({
         ...R.omit(['city', 'country', 'rateContext'], currentOption),
         ...(city ? { city } : {}),
         ...(country ? { country } : {}),
@@ -269,7 +270,7 @@ const searchProductsForItinerary = async ({
         ...(R.path([currentOption.optionId], optionRatesByOptionId)
           ? { optRates: R.path([currentOption.optionId], optionRatesByOptionId) }
           : {}),
-      };
+      });
     }),
   }));
   return {

package/option-metadata.js

@@ -0,0 +1,44 @@
+const BREAKFAST = 'breakfast';
+
+const normalizeText = value => String(value || '').toLowerCase();
+
+const hasNegatedBreakfast = value => {
+  const text = normalizeText(value);
+  return /\b(?:no|without|excluding|exclude|excludes)\s+breakfast\b/.test(text)
+    || /\b(?:no|without)\s+bed\s+(?:and|&)\s+breakfast\b/.test(text)
+    || /\b(?:do|does)\s+not\s+(?:include|includes)\s+breakfast\b/.test(text)
+    || /\bnot\s+including\s+breakfast\b/.test(text)
+    || /\bbreakfast\b\s+(?:is\s+)?(?:not\s+included|not\s+inclusive|excluded)\b/.test(text);
+};
+
+const includesBreakfast = value => {
+  if (hasNegatedBreakfast(value)) return false;
+  const text = normalizeText(value);
+  return /\bbreakfast\b\s+(?:is\s+)?(?:included|inclusive)\b/.test(text)
+    || /\b(?:including|includes|include|with)\s+breakfast\b/.test(text)
+    || /\bbed\s+(?:and|&)\s+breakfast\b/.test(text);
+};
+
+const getOptionInclusions = optionName => (
+  includesBreakfast(optionName) ? [BREAKFAST] : []
+);
+
+const getExtraCategory = extraName => {
+  if (hasNegatedBreakfast(extraName)) return null;
+  return /\bbreakfast\b/.test(normalizeText(extraName)) ? BREAKFAST : null;
+};
+
+const addStructuredOptionMetadata = option => ({
+  ...option,
+  inclusions: getOptionInclusions(option && option.optionName),
+  extras: (option && option.extras || []).map(extra => {
+    const category = getExtraCategory(extra && extra.name);
+    return category ? { ...extra, category } : extra;
+  }),
+});
+
+module.exports = {
+  addStructuredOptionMetadata,
+  getExtraCategory,
+  getOptionInclusions,
+};

package/option-metadata.test.js

@@ -0,0 +1,42 @@
+const {
+  addStructuredOptionMetadata,
+  getExtraCategory,
+  getOptionInclusions,
+} = require('./option-metadata');
+
+describe('structured option metadata', () => {
+  test.each([
+    ['Witherview Super King, Including Breakfast', ['breakfast']],
+    ['Bed and Breakfast', ['breakfast']],
+    ['Bed & Breakfast', ['breakfast']],
+    ['Breakfast not included', []],
+    ['No breakfast included', []],
+    ['Does not include breakfast', []],
+    ['Not including breakfast', []],
+    ['No bed and breakfast', []],
+    ['Room only', []],
+  ])('normalizes option inclusion text %s', (optionName, expected) => {
+    expect(getOptionInclusions(optionName)).toEqual(expected);
+  });
+
+  it('classifies selectable breakfast extras without changing unrelated extras', () => {
+    expect(addStructuredOptionMetadata({
+      optionName: 'Superior Room',
+      extras: [
+        { id: '1', name: 'Breakfast' },
+        { id: '2', name: 'Airport transfer' },
+      ],
+    })).toEqual({
+      optionName: 'Superior Room',
+      inclusions: [],
+      extras: [
+        { id: '1', name: 'Breakfast', category: 'breakfast' },
+        { id: '2', name: 'Airport transfer' },
+      ],
+    });
+  });
+
+  it('does not classify negated breakfast text as a selectable category', () => {
+    expect(getExtraCategory('No breakfast')).toBeNull();
+  });
+});

package/package.json

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