ti2-ventrata 1.0.36 → 1.0.38

package/index.js

@@ -8,6 +8,7 @@ const { translateProduct } = require('./resolvers/product');
 const { translateAvailability } = require('./resolvers/availability');
 const { translateBooking } = require('./resolvers/booking');
 const { translatePickupPoint } = require('./resolvers/pickup-point');
+const { validateCountry } = require('./utils/countrymapping');
 
 const CONCURRENCY = 3; // is this ok ?
 
@@ -71,6 +72,24 @@ class Plugin {
     this.errorPathsAxiosAny = () => ([]); // 200's that should be errors
   }
 
+  static getSettlementMethod(reference, availableSettlementMethods = []) {
+    // Determine settlement method from product's available methods
+    let settlementMethod = 'DEFERRED'; // default fallback
+
+    if (reference && availableSettlementMethods.includes('VOUCHER')) {
+      settlementMethod = 'VOUCHER';
+    } else if (reference && availableSettlementMethods.includes('DIRECT')) {
+      settlementMethod = 'DIRECT';
+    } else if (availableSettlementMethods.includes('DEFERRED')) {
+      settlementMethod = 'DEFERRED';
+    } else if (availableSettlementMethods.length > 0) {
+      // Use the first available settlement method if none of the preferred ones are available
+      [settlementMethod] = availableSettlementMethods;
+    }
+
+    return settlementMethod;
+  }
+
   async validateToken({
     axios,
     token: {
@@ -223,12 +242,22 @@ class Plugin {
     const url = `${endpoint || this.endpoint}/availability`;
     const availability = (
       await Promise.map(productIds, async (productId, ix) => {
+        // Fetch product data to get settlement methods
+        const productUrl = `${endpoint || this.endpoint}/products/${productId}`;
+        const productResult = await axios({
+          method: 'get',
+          url: productUrl,
+          headers,
+        });
+        const settlementMethods = R.path(['data', 'settlementMethods'], productResult) || [];
+        // eslint-disable-next-line max-len
+        const unitsWithId = units[ix].filter(u => u.unitId).map(u => ({ id: u.unitId, quantity: u.quantity }));
         const data = {
           productId,
           optionId: optionIds[ix],
           localDateStart,
           localDateEnd,
-          units: units[ix].map(u => ({ id: u.unitId, quantity: u.quantity })),
+          ...(unitsWithId && unitsWithId.length > 0 && { units: unitsWithId }),
         };
         if (currency) data.currency = currency;
         const result = R.path(['data'], await axios({
@@ -247,6 +276,7 @@ class Plugin {
             currency,
             unitsWithQuantity: units[ix],
             jwtKey: this.jwtKey,
+            settlementMethods,
           },
         }));
       }, { concurrency: CONCURRENCY })
@@ -297,18 +327,28 @@ class Plugin {
       acceptLanguage,
       resellerId,
     });
-    const url = `${endpoint || this.endpoint}/availability/calendar`;
     const availability = (
       await Promise.map(productIds, async (productId, ix) => {
+        // Fetch product data to get settlement methods
+        const productUrl = `${endpoint || this.endpoint}/products/${productId}`;
+        const productResult = await axios({
+          method: 'get',
+          url: productUrl,
+          headers,
+        });
+        const settlementMethods = R.path(['data', 'settlementMethods'], productResult) || [];
+        // eslint-disable-next-line max-len
+        const unitsWithId = units[ix].filter(u => u.unitId).map(u => ({ id: u.unitId, quantity: u.quantity }));
         const data = {
           productId,
           optionId: optionIds[ix],
           localDateStart,
           localDateEnd,
           // units is required here to get the total pricing for the calendar
-          units: units[ix].map(u => ({ id: u.unitId, quantity: u.quantity })),
+          ...(unitsWithId && unitsWithId.length > 0 && { units: unitsWithId }),
         };
         if (currency) data.currency = currency;
+        const url = `${endpoint || this.endpoint}/availability/calendar`;
         const result = await axios({
           method: 'post',
           url,
@@ -319,6 +359,14 @@ class Plugin {
           rootValue: avail,
           typeDefs: availTypeDefs,
           query: availQuery,
+          variableValues: {
+            productId,
+            optionId: optionIds[ix],
+            currency,
+            unitsWithQuantity: units[ix],
+            jwtKey: this.jwtKey,
+            settlementMethods,
+          },
         }));
       }, { concurrency: CONCURRENCY })
     );
@@ -359,68 +407,100 @@ class Plugin {
       acceptLanguage,
     });
     const dataForCreateBooking = await jwt.verify(availabilityKey, this.jwtKey);
+    // if customFieldValues contains perUnitItem fields
+    // we need to overwrite unitItems from the availabilityKey
+    if (customFieldValues && customFieldValues.length) {
+      const productCFV = customFieldValues.filter(o => !R.isNil(o.value) && !o.field.isPerUnitItem);
+      const unitItemCFV = customFieldValues.filter(o => !R.isNil(o.value) && o.field.isPerUnitItem);
+      if (productCFV.length) {
+        dataForCreateBooking.questionAnswers = productCFV.map(o => ({
+          questionId: o.field.id,
+          value: o.value,
+        }));
+      }
+      if (unitItemCFV.length) {
+        dataForCreateBooking.unitItems = R.call(R.compose(
+          R.map(arr => ({
+            unitId: arr[0].field.unitId,
+            questionAnswers: arr.map(o => ({
+              questionId: o.field.id.split('|')[0],
+              value: o.value,
+            })),
+          })),
+          R.values,
+          R.groupBy(o => {
+            const [, unitItemIndex] = o.field.id.split('|');
+            return unitItemIndex;
+          }),
+        ), unitItemCFV);
+      }
+    }
+
+    const settlementMethod = Plugin.getSettlementMethod(
+      reference,
+      dataForCreateBooking.settlementMethods,
+    );
     let booking = R.path(['data'], await axios({
       method: rebookingId ? 'patch' : 'post',
       url: `${endpoint || this.endpoint}/bookings${rebookingId ? `/${rebookingId}` : ''}`,
       data: {
         orderId,
-        settlementMethod: reference ? 'VOUCHER' : 'DEFERRED',
+        settlementMethod,
         ...dataForCreateBooking,
         notes,
         ...(pickupPoint ? { pickupRequested: true, pickupPointId: pickupPoint } : {}),
       },
       headers,
     }));
-    const answers = customFieldValues && customFieldValues.length
-      ? customFieldValues.filter(o => !R.isNil(o.value)).map(o => ({
-        questionId: o.field.id,
-        value: o.value,
-      })) : [];
-    // for answers to custom fields, ventrata suggest to modify the booking
-    if (answers.length) {
-      let modifierBooking = {
-        questionAnswers: booking.questionAnswers.map(o => {
-          const answer = answers.find(a => a.questionId === o.questionId);
-          return answer || o;
-        }),
-        unitItems: booking.unitItems.map(u => ({
-          ...u,
-          questionAnswers: u.questionAnswers.map(o => {
-            const answer = answers.find(a => a.questionId === o.questionId);
-            return answer || o;
-          }),
-        })),
-      };
-      if (!modifierBooking.unitItems.find(u => u.questionAnswers && u.questionAnswers.length)) {
-        modifierBooking = R.omit(['unitItems'], modifierBooking);
-      }
-      booking = R.path(['data'], await axios({
-        method: 'patch',
-        url: `${endpoint || this.endpoint}/bookings/${booking.uuid}`,
-        data: modifierBooking,
-        headers,
-      }));
-    }
     // for booking update, we may not need to confirm again
     if (!booking.utcConfirmedAt && !partialOrder) {
+      const validatedCountry = validateCountry(R.pathOr('', ['country'], holder));
+
+      // Ensure required contact fields are present
+      const firstName = R.pathOr('', ['name'], holder);
+      const lastName = R.pathOr('', ['surname'], holder);
+      // Validate required fields
+      if (!firstName.trim() || !lastName.trim()) {
+        console.error('Customer validation failed: First and last name are required');
+        throw new Error('Customer validation failed: First and last name are required');
+      }
+
+      const fullName = `${firstName.trim()} ${lastName.trim()}`;
+      const emailAddress = R.pathOr(null, ['emailAddress'], holder);
+      const phoneNumber = R.pathOr('', ['phone'], holder);
+
+      // Basic email validation
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (emailAddress && !emailRegex.test(emailAddress)) {
+        console.error(`Customer validation failed: Invalid email format: ${emailAddress}`);
+        throw new Error('Customer validation failed: Invalid email address format');
+      }
       const dataForConfirmBooking = {
         contact: {
-          fullName: `${holder.name} ${holder.surname}`,
-          emailAddress: R.path(['emailAddress'], holder),
-          phoneNumber: R.path(['phone'], holder),
-          locales: R.path(['locales'], holder),
-          country: R.path(['country'], holder),
+          fullName,
+          emailAddress,
+          phoneNumber: phoneNumber || '',
+          locales: R.path(['locales'], holder) || ['en'],
+          country: validatedCountry,
+          postalCode: R.path(['zipCode'], holder) || '',
         },
         notes,
         resellerReference: reference,
-        settlementMethod: reference ? 'VOUCHER' : 'DEFERRED',
+        settlementMethod,
+        ...(emailAddress ? { emailReceipt: true } : {}), // Send email receipt since we have a valid email address
       };
-      booking = R.path(['data'], await axios({
-        method: 'post',
-        url: `${endpoint || this.endpoint}/bookings/${booking.uuid}/confirm`,
-        data: dataForConfirmBooking,
-        headers,
-      }));
+
+      try {
+        booking = R.path(['data'], await axios({
+          method: 'post',
+          url: `${endpoint || this.endpoint}/bookings/${booking.uuid}/confirm`,
+          data: dataForConfirmBooking,
+          headers,
+        }));
+      } catch (error) {
+        console.error('Booking confirmation failed:', (error.response && error.response.data) ? error.response.data : error.message);
+        throw error;
+      }
     }
     return ({
       booking: await translateBooking({
@@ -623,8 +703,6 @@ class Plugin {
     },
     query: {
       productId,
-      date,
-      dateFormat,
     },
   }) {
     const headers = getHeaders({
@@ -647,6 +725,7 @@ class Plugin {
         return 'long';
       })(),
       options: o.selectOptions,
+      isPerUnitItem: o.isPerUnitItem,
     });
     if (!productId) {
       const allProducts = R.pathOr([], ['data'], await axios({
@@ -655,13 +734,15 @@ class Plugin {
         headers,
       }));
       const allOptions = R.chain(R.propOr([], 'options'), allProducts);
-      const allUnits = R.chain(R.propOr([], 'units'), allOptions);
+      const allUnits = R.chain(R.propOr([], 'units'), allOptions).map(o => ({ ...o, isPerUnitItem: true }));
       const allQuestions = R.call(R.compose(
         R.uniqBy(R.prop('id')),
-        R.chain(R.propOr([], 'questions')),
+        R.chain(obj => (obj.questions || []).map(q => ({
+          ...q,
+          isPerUnitItem: Boolean(obj.isPerUnitItem),
+        }))),
         R.filter(o => o.questions && o.questions.length),
       ), [...allOptions, ...allUnits]);
-      console.log(allQuestions);
       return {
         fields: [],
         customFields: allQuestions.map(convertQToField),
@@ -677,11 +758,14 @@ class Plugin {
     const allOptions = R.propOr([], 'options', product);
     const allQuestions = R.call(R.compose(
       R.uniqBy(R.prop('id')),
-      R.chain(R.propOr([], 'questions')),
+      R.chain(obj => (obj.questions || []).map(q => ({
+        ...q,
+        isPerUnitItem: Boolean(obj.isPerUnitItem),
+      }))),
       R.filter(o => o.questions && o.questions.length),
     ), [
       ...allOptions,
-      ...R.chain(R.propOr([], 'units'), allOptions),
+      ...R.chain(R.propOr([], 'units'), allOptions).map(o => ({ ...o, isPerUnitItem: true })),
     ]);
     if (!product) return { fields: [] };
     return {

package/index.test.js

@@ -33,7 +33,7 @@ const app = new Plugin({
 describe('search tests', () => {
   let products;
   let testProduct = {
-    productName: 'Edinburgh Pub Crawl Tour',
+    productName: '[ED3D] Edinburgh 3 Day Pass',
   };
   const token = {
     apiKey: process.env.ti2_ventrata_apiKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-ventrata",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "Ventrata's TI2 Plugin",
   "main": "index.js",
   "scripts": {

package/resolvers/availability.js

@@ -12,6 +12,7 @@ const resolvers = {
         currency,
         unitsWithQuantity,
         jwtKey,
+        settlementMethods,
       } = args;
       if (!jwtKey) return null;
       return jwt.sign({
@@ -19,6 +20,7 @@ const resolvers = {
         optionId,
         availabilityId: root.id,
         currency,
+        settlementMethods,
         unitItems: R.chain(u => new Array(u.quantity).fill(1).map(() => ({
           unitId: u.unitId,
         })), unitsWithQuantity),

package/resolvers/booking.js

@@ -35,6 +35,9 @@ const resolvers = {
       fullName: R.pathOr('', ['contact', 'fullName'], root),
       phoneNumber: R.pathOr('', ['contact', 'phoneNumber'], root),
       emailAddress: R.pathOr('', ['contact', 'emailAddress'], root),
+      country: R.pathOr('', ['contact', 'country'], root),
+      locales: R.pathOr('', ['locales'], root),
+      postalCode: R.pathOr('', ['contact', 'postalCode'], root),
     }),
     notes: root => root.notes || '',
     price: root => root.pricing,

package/resolvers/product.js

@@ -9,6 +9,7 @@ const resolvers = {
     availableCurrencies: R.path(['availableCurrencies']),
     defaultCurrency: R.path(['defaultCurrency']),
     options: R.propOr([], 'options'),
+    settlementMethods: R.path(['settlementMethods']),
   },
   Option: {
     optionId: R.prop('id'),

package/utils/countrymapping.js

@@ -0,0 +1,206 @@
+// Country name to ISO 3166-1 alpha-2 code mapping
+const countryNameToCode = {
+  // Major countries
+  'UNITED STATES': 'US',
+  'USA': 'US',
+  'AMERICA': 'US',
+  'UNITED STATES OF AMERICA': 'US',
+  'UNITED KINGDOM': 'GB',
+  'UK': 'GB',
+  'GREAT BRITAIN': 'GB',
+  'ENGLAND': 'GB',
+  'BRITAIN': 'GB',
+  'CANADA': 'CA',
+  'FRANCE': 'FR',
+  'GERMANY': 'DE',
+  'ITALY': 'IT',
+  'SPAIN': 'ES',
+  'AUSTRALIA': 'AU',
+  'NEW ZEALAND': 'NZ',
+  'JAPAN': 'JP',
+  'CHINA': 'CN',
+  'INDIA': 'IN',
+  'BRAZIL': 'BR',
+  'MEXICO': 'MX',
+  'RUSSIA': 'RU',
+  'SOUTH AFRICA': 'ZA',
+  'ARGENTINA': 'AR',
+  'CHILE': 'CL',
+  'COLOMBIA': 'CO',
+  'PERU': 'PE',
+  'VENEZUELA': 'VE',
+  'ECUADOR': 'EC',
+  'BOLIVIA': 'BO',
+  'PARAGUAY': 'PY',
+  'URUGUAY': 'UY',
+  'GUYANA': 'GY',
+  'SURINAME': 'SR',
+  'NETHERLANDS': 'NL',
+  'BELGIUM': 'BE',
+  'SWITZERLAND': 'CH',
+  'AUSTRIA': 'AT',
+  'PORTUGAL': 'PT',
+  'SWEDEN': 'SE',
+  'NORWAY': 'NO',
+  'DENMARK': 'DK',
+  'FINLAND': 'FI',
+  'ICELAND': 'IS',
+  'IRELAND': 'IE',
+  'POLAND': 'PL',
+  'CZECH REPUBLIC': 'CZ',
+  'SLOVAKIA': 'SK',
+  'HUNGARY': 'HU',
+  'ROMANIA': 'RO',
+  'BULGARIA': 'BG',
+  'CROATIA': 'HR',
+  'SLOVENIA': 'SI',
+  'SERBIA': 'RS',
+  'BOSNIA AND HERZEGOVINA': 'BA',
+  'MONTENEGRO': 'ME',
+  'ALBANIA': 'AL',
+  'MACEDONIA': 'MK',
+  'GREECE': 'GR',
+  'TURKEY': 'TR',
+  'CYPRUS': 'CY',
+  'MALTA': 'MT',
+  'LUXEMBOURG': 'LU',
+  'ESTONIA': 'EE',
+  'LATVIA': 'LV',
+  'LITHUANIA': 'LT',
+  'UKRAINE': 'UA',
+  'BELARUS': 'BY',
+  'MOLDOVA': 'MD',
+  'GEORGIA': 'GE',
+  'ARMENIA': 'AM',
+  'AZERBAIJAN': 'AZ',
+  'KAZAKHSTAN': 'KZ',
+  'UZBEKISTAN': 'UZ',
+  'TURKMENISTAN': 'TM',
+  'KYRGYZSTAN': 'KG',
+  'TAJIKISTAN': 'TJ',
+  'AFGHANISTAN': 'AF',
+  'PAKISTAN': 'PK',
+  'BANGLADESH': 'BD',
+  'SRI LANKA': 'LK',
+  'NEPAL': 'NP',
+  'BHUTAN': 'BT',
+  'MALDIVES': 'MV',
+  'MYANMAR': 'MM',
+  'THAILAND': 'TH',
+  'LAOS': 'LA',
+  'VIETNAM': 'VN',
+  'CAMBODIA': 'KH',
+  'MALAYSIA': 'MY',
+  'SINGAPORE': 'SG',
+  'INDONESIA': 'ID',
+  'PHILIPPINES': 'PH',
+  'BRUNEI': 'BN',
+  'TIMOR-LESTE': 'TL',
+  'SOUTH KOREA': 'KR',
+  'NORTH KOREA': 'KP',
+  'MONGOLIA': 'MN',
+  'TAIWAN': 'TW',
+  'HONG KONG': 'HK',
+  'MACAU': 'MO',
+  'ISRAEL': 'IL',
+  'PALESTINE': 'PS',
+  'JORDAN': 'JO',
+  'LEBANON': 'LB',
+  'SYRIA': 'SY',
+  'IRAQ': 'IQ',
+  'IRAN': 'IR',
+  'KUWAIT': 'KW',
+  'SAUDI ARABIA': 'SA',
+  'BAHRAIN': 'BH',
+  'QATAR': 'QA',
+  'UAE': 'AE',
+  'UNITED ARAB EMIRATES': 'AE',
+  'OMAN': 'OM',
+  'YEMEN': 'YE',
+  'EGYPT': 'EG',
+  'LIBYA': 'LY',
+  'TUNISIA': 'TN',
+  'ALGERIA': 'DZ',
+  'MOROCCO': 'MA',
+  'SUDAN': 'SD',
+  'SOUTH SUDAN': 'SS',
+  'ETHIOPIA': 'ET',
+  'ERITREA': 'ER',
+  'DJIBOUTI': 'DJ',
+  'SOMALIA': 'SO',
+  'KENYA': 'KE',
+  'UGANDA': 'UG',
+  'TANZANIA': 'TZ',
+  'RWANDA': 'RW',
+  'BURUNDI': 'BI',
+  'DEMOCRATIC REPUBLIC OF THE CONGO': 'CD',
+  'CONGO': 'CG',
+  'CENTRAL AFRICAN REPUBLIC': 'CF',
+  'CHAD': 'TD',
+  'CAMEROON': 'CM',
+  'EQUATORIAL GUINEA': 'GQ',
+  'GABON': 'GA',
+  'SAO TOME AND PRINCIPE': 'ST',
+  'NIGERIA': 'NG',
+  'NIGER': 'NE',
+  'MALI': 'ML',
+  'BURKINA FASO': 'BF',
+  'SENEGAL': 'SN',
+  'GAMBIA': 'GM',
+  'GUINEA-BISSAU': 'GW',
+  'GUINEA': 'GN',
+  'SIERRA LEONE': 'SL',
+  'LIBERIA': 'LR',
+  'IVORY COAST': 'CI',
+  'GHANA': 'GH',
+  'TOGO': 'TG',
+  'BENIN': 'BJ',
+  'MAURITANIA': 'MR',
+  'WESTERN SAHARA': 'EH',
+  'CAPE VERDE': 'CV',
+  'MADAGASCAR': 'MG',
+  'MAURITIUS': 'MU',
+  'SEYCHELLES': 'SC',
+  'COMOROS': 'KM',
+  'MAYOTTE': 'YT',
+  'REUNION': 'RE',
+  'BOTSWANA': 'BW',
+  'NAMIBIA': 'NA',
+  'ZAMBIA': 'ZM',
+  'ZIMBABWE': 'ZW',
+  'MALAWI': 'MW',
+  'MOZAMBIQUE': 'MZ',
+  'SWAZILAND': 'SZ',
+  'LESOTHO': 'LS',
+  'ANGOLA': 'AO',
+};
+
+const validateCountry = countryInput => {
+  // Validate and format country code - ensure it's a valid ISO 3166-1 alpha-2 code
+  let validatedCountry = 'US'; // Default fallback
+
+  if (countryInput && typeof countryInput === 'string') {
+    const cleanInput = countryInput.trim().toUpperCase();
+
+    // First, check if it's already a valid 2-letter ISO code
+    if (cleanInput.length === 2 && /^[A-Z]{2}$/.test(cleanInput)) {
+      validatedCountry = cleanInput;
+    } else if (countryNameToCode[cleanInput]) {
+      // Then, try to convert country name to ISO code
+      validatedCountry = countryNameToCode[cleanInput];
+    } else {
+      // If it looks like a partial match, try to find it
+      const matchedEntry = Object.entries(countryNameToCode).find(([name]) =>
+        name.includes(cleanInput) || cleanInput.includes(name));
+      if (matchedEntry) {
+        const [, countryCode] = matchedEntry;
+        validatedCountry = countryCode;
+      }
+    }
+  }
+  return validatedCountry;
+};
+
+module.exports = {
+  validateCountry,
+};