tripstorekrabi-shared 1.0.0

package/availability.js

@@ -0,0 +1,179 @@
+import dayjs from "dayjs";
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import isBetween from 'dayjs/plugin/isBetween.js';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js';
+import isSameOrAfter from 'dayjs/plugin/isSameOrAfter.js';
+import utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+
+dayjs.extend(customParseFormat);
+dayjs.extend(isBetween);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(isSameOrAfter);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+const WEEKDAYS = new Array(7);
+WEEKDAYS[0] = "Sunday";
+WEEKDAYS[1] = "Monday";
+WEEKDAYS[2] = "Tuesday";
+WEEKDAYS[3] = "Wednesday";
+WEEKDAYS[4] = "Thursday";
+WEEKDAYS[5] = "Friday";
+WEEKDAYS[6] = "Saturday";
+
+export const INACTIVE = "inactive";
+export const SINGLE_DATES = "singleDates";
+export const BLOCKOUT = "blockout";
+export const SCHEDULE_MODES = [INACTIVE, SINGLE_DATES, BLOCKOUT];
+
+export function isAvailable(availability, date, schedule, options = {}) {
+  let available = availability.available;
+
+  if (available && options.viatorApi === true && (!availability.br?.connectedToApi || !availability.br?.available)) {
+    return false;
+  }
+
+  if (available && options.gygApi === true && (!availability.gyg?.connectedToApi || !availability.gyg?.available)) {
+    return false;
+  }
+
+  if (available) {
+    if (schedule) {
+      let scheduleObject = findSchedule(availability, schedule);
+      if (scheduleObject) {
+        available = checkAvailability(date, scheduleObject);
+      } else {
+        available = false;
+      }
+    } else if (availability.schedules) {
+      available = Object.values(availability.schedules).every(
+        (schedule) => checkAvailability(date, schedule)
+      );
+    } else if (availability.openingHours) {
+      available = Object.values(availability.openingHours).every(
+        (schedule) => checkAvailability(date, schedule)
+      );
+    }
+  }
+
+  if (available) {
+    date = dayjs(date, "DD.MM.YYYY");
+    let today = dayjs().startOf('day');
+    available = date.isSameOrAfter(today);
+  }
+
+  return available;
+}
+
+function checkAvailability(date, schedule) {
+  let mode = schedule.mode;
+
+  switch (mode) {
+    case INACTIVE: {
+      return false;
+    }
+    case SINGLE_DATES: {
+      return schedule.singleDates.includes(date);
+    }
+    case BLOCKOUT: {
+      let available = true;
+
+      if (schedule.blockoutDates) {
+        available = !schedule.blockoutDates.includes(date);
+      }
+      if (available && schedule.blockoutPeriods) {
+        let day = dayjs(date, "DD.MM.YYYY");
+        let year = day.year();
+        available = !schedule.blockoutPeriods.some((period) => {
+          let start = dayjs(`${period.start}.${year}`, "DD.MM.YYYY");
+          let end = dayjs(`${period.end}.${year}`, "DD.MM.YYYY");
+          return day.isBetween(start, end, 'day', '[]');
+        });
+      }
+
+      if (available && schedule.weekDays) {
+        let weekDay = WEEKDAYS[dayjs(date, "DD.MM.YYYY").day()];
+        available = schedule.weekDays.includes(weekDay);
+      }
+
+      return available;
+    }
+    default: {
+      return true;
+    }
+  }
+}
+
+export function getSchedules(availability) {
+  if (availability.schedules) {
+    return Object.keys(availability.schedules).sort();
+  } else if (availability.openingHours) {
+    return Object.keys(availability.openingHours).sort();
+  } else {
+    return [];
+  }
+}
+
+export function findSchedule(availability, schedule) {
+  if (availability.schedules) {
+    return availability.schedules[schedule] ?? Object.entries(availability.schedules)[0];
+  } else if (availability.openingHours) {
+    return availability.openingHours[schedule] ?? Object.entries(availability.openingHours)[0];
+  }
+}
+
+export function getAvailabilityLabel(availability, schedule) {
+  if (!availability.available) {
+    return "Not available";
+  } else {
+    let scheduleObject = findSchedule(availability, schedule);
+
+    if (scheduleObject.mode === INACTIVE) {
+      return "Not available";
+    } else if (scheduleObject.mode === SINGLE_DATES) {
+      return "Available on selected dates";
+    } else if (scheduleObject.mode === BLOCKOUT) {
+      if (scheduleObject.blockoutPeriods && scheduleObject.blockoutPeriods.length > 0) {
+        let starts = [];
+        let ends = [];
+        let startPeriod = scheduleObject.blockoutPeriods[0];
+        let year = dayjs().year();
+        scheduleObject.blockoutPeriods.forEach((period, i) => {
+          starts.push(dayjs(`${period.end}.${year}`, "DD.MM.YYYY").add(1, 'day'));
+          if (i + 1 < scheduleObject.blockoutPeriods.length) {
+            ends.push(dayjs(`${scheduleObject.blockoutPeriods[i + 1].start}.${year}`, "DD.MM.YYYY").subtract(1, 'day'));
+          }
+        });
+        ends.push(dayjs(`${startPeriod.start}.${year + 1}`, "DD.MM.YYYY").subtract(1, 'day'));
+
+        let availability = [];
+        starts.forEach((start, i) => {
+          if (ends[i].diff(start, "month") > 1) {
+            availability.push(start.format("MMM") + " - " + ends[i].format("MMM"));
+          }
+        });
+
+        return availability.join(", ");
+      } else if (scheduleObject.weekDays) {
+        return scheduleObject.weekDays.map((item) => item.substring(0, 3)).join(", ");
+      } else {
+        return "Daily";
+      }
+    }
+  }
+}
+
+export function isLastMinuteDate(dateValue, cutoffTime) {
+  let date = dayjs(dateValue, "DD.MM.YYYY").tz("Asia/Bangkok");
+  let now = dayjs().tz("Asia/Bangkok");
+
+  return now.add(cutoffTime, "hour").isSame(date, "day");
+}
+
+export function isPastDate(dateValue, schedule) {
+  let date = dayjs(dateValue + " " + schedule, "DD.MM.YYYY HH:mm").tz("Asia/Bangkok");
+  let now = dayjs().tz("Asia/Bangkok");
+
+  return date.isSameOrBefore(now);
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "tripstorekrabi-shared",
+  "version": "1.0.0",
+  "description": "Shared library for Trip Store Krabi",
+  "author": "Stefan Sommer",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tonprince/tripstorekrabi.git"
+  },
+  "exports": {
+    "./utils": "./utils.js",
+    "./price": "./price.js",
+    "./availability": "./availability.js"
+  },
+  "dependencies": {
+    "dayjs": "^1.10.8"
+  },
+  "type": "module"
+}

package/price.js

@@ -0,0 +1,122 @@
+
+import { getBookingType } from "./utils.js";
+
+export const MAX_PAX = 20;
+
+export function calculateProductPrice(booking, pricing, selling = true) {
+  let type = pricing.type;
+  let total = 0;
+
+  switch (type) {
+    case "person": {
+      let volume = findVolume(booking, pricing);
+      if (!volume) {
+        throw new Error(`No volume price found for the total amount of ${booking.adults + booking.children} people`);
+      } else {
+        let bookingType = getBookingType(booking.referenceNumber);
+
+        if (volume[bookingType]?.active) {
+          let customPricing = volume[bookingType];
+          total = booking.adults * (selling ? customPricing.adult.partnerNetPrice : customPricing.adult.operatorNetPrice) + (pricing.ageBands.child.active && volume.child && booking.children ? booking.children * (selling ? customPricing.child.partnerNetPrice : customPricing.child.operatorNetPrice) : 0);
+        } else {
+          total = booking.adults * (selling ? volume.adult.sellingPrice : volume.adult.operatorNetPrice) + (pricing.ageBands.child.active && volume.child && booking.children ? booking.children * (selling ? volume.child.sellingPrice : volume.child.operatorNetPrice) : 0);
+        }
+        break;
+      }
+    }
+
+    case "group": {
+      let volume = findVolume(booking, pricing);
+      if (!volume) {
+        throw new Error(`No volume price found for the total amount of ${booking.adults + booking.children} people`);
+      } else {
+        let bookingType = getBookingType(booking.referenceNumber);
+
+        if (volume[bookingType]?.active) {
+          let customPricing = volume[bookingType];
+          total = selling ? customPricing.partnerNetPrice : customPricing.operatorNetPrice;
+        } else {
+          total = (selling ? volume.sellingPrice : volume.operatorNetPrice);
+        }
+
+        break;
+      }
+    }
+    default:
+      throw new Error(`Pricing type ${type} is not supported`);
+  }
+
+  return total;
+}
+
+export function findVolume(people, pricing) {
+  let total = people.adults + people.children ?? 0;
+  return pricing.volumes.sort((v1, v2) => v1.max - v2.max).find((item) => total <= item.max);
+}
+
+export function countMinPeople(pricing) {
+  let volume = pricing.volumes.map((item) => item.min);
+  return volume ? Math.max(volume.reduce((p, v) => p < v ? p : v), 1) : 1;
+}
+
+export function countMaxPeople(pricing) {
+  let volume = pricing.volumes.map((item) => item.max);
+  return volume ? volume.reduce((p, v) => p > v ? p : v) : MAX_PAX;
+}
+
+export function calculateTotalPrice(data, product, selling = true) {
+  let total = calculateProductPrice(data, product.pricing, selling);
+  total += calculateStartEndPointPrice(data, findStartingPoint(product, data.startingPointId), selling);
+  total += calculateStartEndPointPrice(data, findEndPoint(product, data.endPointId), selling);
+  total += calculateNationalParkFee(data, product);
+  total += calculateAddOnsPrice(data, product, selling);
+  return total;
+}
+
+export function calculateNationalParkFee(data, product) {
+  return data.nationalParkFee === "Already paid" && product.nationalPark ? product.nationalPark.pricing.adult * data.adults + product.nationalPark.pricing.child * data.children : 0;
+}
+
+export function calculateAddOnsPrice(data, product, selling = true) {
+  let total = 0;
+  if (data.addOns) {
+    for (const [id, addOn] of Object.entries(data.addOns)) {
+      let addOnDef = findAddOn(id, product.addOns);
+      if (addOnDef) {
+        total += addOn.adults * (selling ? addOnDef.pricing.adult
+          .sellingPrice : addOnDef.pricing.adult
+          .operatorNetPrice) + (addOn.children > 0 ? addOn.children * (selling ? addOnDef.pricing.child
+            .sellingPrice : addOnDef.pricing.child
+            .operatorNetPrice) : 0);
+      }
+    }
+  }
+  return total;
+}
+
+export function calculateStartEndPointPrice(people, startEndPoint, selling = true) {
+  let pricing = startEndPoint?.pricing;
+  if (pricing) {
+    if (pricing.type === "group") {
+      return (selling ? pricing.sellingPrice : pricing.operatorNetPrice) * Math.ceil((people.adults + people.children) / pricing.max);
+    } else if (pricing.type === "person") {
+      return (selling ? pricing.sellingPrice : pricing.operatorNetPrice) * (people.adults + people.children);
+    }
+  } else {
+    return 0;
+  }
+}
+
+export function findStartingPoint(product, startingPointId) {
+  return product.startingPoints.find((item) => item.id === startingPointId) ?? product.startingPoints[0];
+}
+
+export function findEndPoint(product, endPointId) {
+  return product.endPoints.find((item) => item.id === endPointId) ?? product.endPoints[0] ?? { name: "" };
+}
+
+export function findAddOn(id, addOns) {
+  return addOns.find((item) =>
+    item.id === id
+  );
+}

package/utils.js

@@ -0,0 +1,589 @@
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+import advancedFormat from 'dayjs/plugin/advancedFormat.js';
+import isSameOrBefore from "dayjs/plugin/isSameOrBefore.js";
+import utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+import { findEndPoint, findStartingPoint } from "./price.js";
+
+dayjs.extend(customParseFormat);
+dayjs.extend(advancedFormat);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+export const PROD_URL = "https://www.tripstorekrabi.com";
+export const MAX_AGE_SEC = 60 * 60 * 24;
+const EMAIL_PATTERN = new RegExp(/^[a-zA-Z0-9.!#$%&' * +/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/);
+const MEALS = ["lunch", "meal", "breakfast", "dinner"];
+const SCHEDULE_PATTERN = new RegExp('^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$');
+
+export function validateEmail(email) {
+  return EMAIL_PATTERN.test(email);
+}
+
+export function resizeGoogleImage(image, size) {
+  return image.replace(/\/w.\d+-.\d+-p\//, "/" + size + "/").replace(
+    /\/w.\d+-.\d+-c\//, "/" + size + "/").replace(/\/w.\d+-.\d+-no\//,
+      "/" + size + "/").replace(/\/w.\d+-.\d+\//, "/" + size + "/").replace(
+        /\/s.\d+\//, "/" + size + "/").replace(/\=w.\d+-.\d+-p/, "=" + size)
+    .replace(/\=w.\d+-.\d+-c/, "=" + size).replace(/\=w.\d+-.\d+-no/,
+      "=" + size).replace(/\=w.\d+-.\d+/, "=" + size).replace(/\=s.\d+/,
+        "=" + size).replace(/\=s.\d+/, "=" + size);
+}
+
+export function resizeStorageImage(path, size) {
+  return `https://tripstorekrabi-next.firebaseapp.com/images/${path}?${size}`;
+}
+
+export function createPdfPreview(path, size) {
+  return `https://tripstorekrabi-next.firebaseapp.com/pdf/preview/${path}?${size}`;
+}
+
+export function formatNumber(number, fraction = 2) {
+  return number.toLocaleString("th-TH", {
+    minimumFractionDigits: fraction,
+  });
+}
+
+export function getPickupTimeFromTo(product) {
+  return product.pickupZones;
+}
+
+export function getDurationSummary(schedules) {
+  let minDuration = Number.MAX_VALUE;
+  let maxDuration = -1;
+  schedules.forEach((schedule) => {
+    let duration = getDuration(schedule);
+    if (duration > maxDuration) {
+      maxDuration = duration;
+    }
+    if (duration < minDuration) {
+      minDuration = duration;
+    }
+  });
+
+  return minDuration == maxDuration ? formatDuration(minDuration) : `${formatDuration(minDuration)} - ${formatDuration(maxDuration)}`;
+}
+
+export function getDuration(schedule) {
+  if (schedule) {
+    let schedules = schedule.split("-");
+    let minutes = dayjs(schedules[1].trim(), "HH:mm").diff(dayjs(schedules[0].trim(), "HH:mm"), 'minute');
+    if (minutes < 0) {
+      minutes = 24 * 60 + minutes;
+    }
+    return minutes;
+  }
+  else {
+    return 0;
+  }
+}
+
+export function formatDuration(minutes) {
+  if (minutes === 0) {
+    return "-";
+  } else if (minutes > 60) {
+    return (minutes / 60).toFixed(1) + " hours";
+  } else {
+    return minutes + " minutes";
+  }
+}
+
+export function getPickuptimeSummary(pickupZones) {
+  if (pickupZones) {
+    let pickupTimesArray = [];
+    pickupZones.forEach((pickupZone) => {
+      var pickupLength = pickupZone.indexOf(": ");
+      var pickupTimes = pickupZone.substring(pickupLength + 1).trim();
+      if (pickupZone.indexOf(" / ") != -1) {
+        pickupTimesArray.push(pickupTimes.split(" / "));
+      } else {
+        pickupTimesArray.push([pickupTimes]);
+      }
+    });
+
+
+    pickupTimesArray = pickupTimesArray[0].map((_, colIndex) => pickupTimesArray.map(row => row[colIndex]));
+
+    return pickupTimesArray.map((items) => {
+      let pickupTimes = [...new Set(items.reduce((r, e) => {
+        e.split(" - ").forEach((item) => {
+          r.push(item);
+        });
+        return r;
+      }, []))].sort();
+
+      if (pickupTimes.length == 1) {
+        return pickupTimes[0];
+      } else {
+        return `${pickupTimes[0]} - ${pickupTimes[pickupTimes.length - 1]}`;
+      }
+    });
+  } else {
+    return null;
+  }
+}
+
+export function getDeparture(schedule) {
+  return schedule.split("-")[0].trim();
+}
+
+export function getPickupTime(schedule, offset = 30) {
+  if (schedule.indexOf("-") != -1) {
+    return dayjs(schedule.split("-")[0].trim(), "HH:mm").subtract(offset, "minute").format("HH:mm");
+  } else {
+    return dayjs(schedule, "HH:mm").subtract(offset, "minute").format("HH:mm");
+  }
+}
+
+export function getArrival(schedule) {
+  return schedule.split("-")[1].trim();
+}
+
+export function isHotelPickup(value) {
+  value = value.toLowerCase();
+  return (value.includes("picked up") || value.includes("pickup") || value.includes("round-trip")) && value.includes("hotel");
+}
+
+export function isHotelDropOff(value) {
+  value = value.toLowerCase();
+  return (value.includes("dropped off") || value.includes("drop-off") || value.includes("transfer")) && value.includes("hotel");
+}
+
+export function isAirportPickup(value) {
+  value = value.toLowerCase();
+  return (value.includes("pickup") || value.includes("meet")) && value.includes("airport");
+}
+
+export function isAirportDropOff(value) {
+  value = value.toLowerCase();
+
+  let result = (value.includes("drop-off") || value.includes("transfer")) && value.includes("airport");
+
+  if (!result && value.includes(" to ")) {
+    result = value.substring(value.indexOf(" to ")).includes(" airport");
+  }
+  return result;
+}
+
+export function isMeetingPoint(value) {
+  value = value.toLowerCase();
+  value = value.replace('pick up', 'pickup').replace('picked up', 'pickup').replace('pick-up', 'pickup');
+  return (value.indexOf("meet ") != -1) || (value.indexOf('pickup') != -1 && value.indexOf('hotel') == -1);
+}
+
+export function isTrainStation(value) {
+  value = value.toLowerCase();
+  return value.includes("train") && value.includes("station");
+}
+
+export function isMealIncluded(includes) {
+  if (includes) {
+    let includesString = includes.join(" ").toLowerCase();
+    return MEALS.some((item) => includesString.includes(item));
+  } else {
+    return false;
+  }
+}
+
+export function validateName(name) {
+  name = name.trim();
+  if (name) {
+    return name.indexOf(" ") != -1;
+  } else {
+    return false;
+  }
+}
+
+export function applySchedule(schedule, schedules, pickupZones, includeZonePrice = false) {
+  let index = schedules.indexOf(schedule);
+  return pickupZones.map((zone) => {
+    let zoneArray = zone.split(": ");
+    let zoneName = zoneArray[0].trim();
+    let zonePickupTimes = zoneArray[1].trim();
+    let pickupTimes = zonePickupTimes.split("/");
+    return pickupTimes[index] ? (includeZonePrice ? zoneName : zoneName.replace(/ *\([^)]*\) */g, "")) + ": " + pickupTimes[index].trim() : undefined;
+  }).filter((item) => item !== undefined);
+}
+
+export function scrollContainer() {
+  return document.documentElement || document.body;
+}
+
+export function toTitleCase(str) {
+  return str.replace(/\b\S/g, t => t.toUpperCase());
+}
+
+export function capitalize(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+}
+
+export function transformToNCols(array, n) {
+  let converted = [];
+  let chunks = chunkArray(array, Math.ceil(array.length / n));
+
+  let chunk = chunks[0];
+  for (let i = 0; i < chunk.length; i++) {
+    let item = chunk[i];
+    if (item) {
+      converted.push(item);
+    }
+
+    for (let j = 1; j < chunks.length; j++) {
+      let nextChunk = chunks[j];
+      let item = nextChunk[i];
+      if (item) {
+        converted.push(item);
+      }
+    }
+  }
+  return converted;
+}
+
+function chunkArray(array, chunk_size) {
+  array = [...array];
+  var results = [];
+
+  while (array.length) {
+    results.push(array.splice(0, chunk_size));
+  }
+
+  return results;
+}
+
+export function encodeURL(url) {
+  return toTitleCase(url).replace(/ /g, "-");
+}
+
+export function formatPeople(people) {
+  let result = [];
+  if (people.adults > 0) {
+    result.push(`${people.adults} ${people.adults > 1 ? "adults" : "adult"}`);
+  }
+  if (people.children > 0) {
+    result.push(`${people.children} ${people.children > 1 ? "children" : "child"
+      }`);
+  }
+  if (people.infants > 0) {
+    result.push(`${people.infants} ${people.infants > 1 ? "infants" : "infant"
+      }`);
+  }
+  return result.join(", ");
+}
+
+export function countPeople(people) {
+  return people.adults ?? 0 + people.children ?? 0 + people.infants ?? 0;
+}
+
+export function recaptchaChallenge(secret, token) {
+  const url = `https://www.google.com/recaptcha/api/siteverify?secret=${secret}&response=${token}`;
+  return fetch(url, {
+    method: "POST",
+  }).then(async (result) => result.json())
+    .then((result) => result.success
+    ).catch((e) => {
+      console.error(e);
+      return false
+    });
+}
+
+export function isNumeric(n) {
+  return !isNaN(parseFloat(n)) && isFinite(n);
+}
+
+export function validURL(str) {
+  var pattern = new RegExp('^(https?:\\/\\/)?' + // protocol
+    '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+    '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+    '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+    '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+    '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
+  return !!pattern.test(str);
+}
+
+export function getBookingSummary(booking, options = {}) {
+  let summary = "";
+  if (!options.excludeReferenceNumber) {
+    summary += booking.referenceNumber;
+    if (booking.code) {
+      summary += ", Code: " + booking.code;
+    }
+
+    if (options.includeVersion && booking.version) {
+      summary += ", Version: " + booking.version;
+    }
+    summary += ": ";
+  }
+
+  if (booking.productDescription && booking.operator && booking.departureDate && booking.schedule && booking.leadTraveller) {
+    let departureDate = dayjs(booking.departureDate.toDate()).format("DD.MM.YYYY");
+    summary += booking.productDescription + ", " + departureDate + ", " + booking.operator + ", " + booking.adults + ", " + booking.children + ", "
+      + booking.infants + ", " + booking.leadTraveller;
+
+    if (booking.startingPointDescription) {
+      summary += ", " + (isHotelPickup(booking.startingPointDescription) && booking.noHotelYet ? "NO HOTEL YET" : booking.startingPointDescription);
+    } else if (booking.noHotelYet) {
+      summary += ", NO HOTEL YET";
+    }
+
+    let hasHotelPickup = isHotelPickup(booking.startingPointDescription);
+    let hasRoomNumber = booking.roomNumber;
+
+    if (hasHotelPickup && hasRoomNumber) {
+      summary += " (room " + booking.roomNumber + ")";
+    }
+
+    summary += ", " + booking.schedule;
+
+    if (booking.pickupTime && booking.pickupTime != "?") {
+      if (hasHotelPickup) {
+        summary += " (Pickup";
+
+        if (booking.pickupTime.indexOf("-") != -1) {
+          summary += " between " + booking.pickupTime.replace(" - ", " and ").replace("-", " and ");
+        } else {
+          summary += " at " + booking.pickupTime;
+        }
+        summary += ")";
+      } else if (isMeetingPoint(booking.startingPointDescription)) {
+        summary += " (Meet";
+
+        if (booking.pickupTime.indexOf("-") != -1) {
+          summary += " at " + booking.pickupTime.split("-")[0].trim();
+        } else {
+          summary += " at " + booking.pickupTime;
+        }
+        summary += ")";
+      }
+    }
+  } else {
+    summary += "«THE BOOKING IS INCOMPLETE»";
+  }
+
+  return summary;
+}
+
+export function getItemSummary(item, product) {
+  let summary = item.description;
+
+  if (product) {
+    if (item.departureDate) {
+      summary += ", " + dayjs(item.departureDate).tz("Asia/Bangkok").format("DD.MM.YYYY");
+    }
+
+    if (item.schedule) {
+      summary += ", " + item.schedule;
+    }
+
+    if (item.adults || item.children || item.infants) {
+      summary += ", " + formatPeople(item) + ", ";
+    }
+
+    if (item.startingPointId) {
+      let startingPointDescription = findStartingPoint(product, item.startingPointId).value;
+      if (isHotelPickup(startingPointDescription)) {
+        summary += "Hotel pickup from " + item.pickupHotel;
+
+        if (item.roomNumber) {
+          summary += ` (${item.roomNumber})`;
+        }
+      } else {
+        summary += startingPointDescription;
+      }
+    }
+
+    if (item.endPointId) {
+      let endPointDescription = findEndPoint(product, item.endPointId).value;
+      if (isHotelDropOff(endPointDescription) && item.dropoffHotel) {
+        summary += ", Hotel drop-off at " + item.dropoffHotel;
+      }
+    }
+  }
+
+  return summary;
+}
+
+export function validateSchedule(schedule, schedules = []) {
+  if (schedule === "?") {
+    return true;
+  } else if (schedule.indexOf(" - ") != -1) {
+    var times = schedule.split(" - ");
+    var from = times[0];
+    var to = times[1];
+
+    if (!SCHEDULE_PATTERN.test(from) || !SCHEDULE_PATTERN.test(to) || (from === to)) {
+      return "Invalid schedule format: for example use '09:00 - 15:30'";
+    }
+  } else {
+    return "Invalid schedule format: for example use '09:00 - 15:30'";
+  }
+
+
+  if (schedule != "") {
+    if (schedules.length > 0 && schedules.indexOf(schedule) == -1) {
+      return { status: "warning", message: "The value does not match the product schedules" };
+    }
+  }
+
+  return true;
+}
+
+export function validatePickupTime(pickupTime, schedule) {
+  let departureTime = schedule.split(" - ")[0];
+
+  if (pickupTime === "?" || schedule === "?") {
+    return true;
+  } else if (pickupTime.indexOf(" - ") != -1) {
+    var times = pickupTime.split(" - ");
+    var from = times[0];
+    var to = times[1];
+
+    if (!SCHEDULE_PATTERN.test(from) || !SCHEDULE_PATTERN.test(to) || (from === to)) {
+      return "Invalid pickup time format: for example use '09:00' or '08:45 - 09:00'";
+    } else {
+      return checkTime(from, departureTime);
+    }
+  } else if (pickupTime.indexOf("-") != -1) {
+    return `Invalid pickup time format, use spaces around the dash: ${pickupTime.replace(/ /g, '').replace("-", " - ")}`;
+  } else {
+    if (!SCHEDULE_PATTERN.test(pickupTime)) {
+      return "Invalid pickup time format: for example use '09:00' or '08:45 - 09:00'";
+    } else {
+      return checkTime(pickupTime, departureTime);
+    }
+  }
+}
+
+function checkTime(pickupTimeValue, departureTimeValue) {
+  if (pickupTimeValue === "" || departureTimeValue === "") {
+    return false;
+  }
+
+  try {
+    let pickupTimeValues = pickupTimeValue.split(":");
+    let pickupTime = dayjs().hour(pickupTimeValues[0]).minute(pickupTimeValues[1]).second(0);
+
+    let departureTimeValues = departureTimeValue.split(":");
+    let departureTime = dayjs().hour(departureTimeValues[0]).minute(departureTimeValues[1]).second(0);
+
+    return pickupTime.isSameOrBefore(departureTime) ? true : "Pickup time must be before or equals departure time";
+  } catch (e) {
+    return false;
+  }
+}
+
+export function hasCustomerEmail(email) {
+  return email && email !== "info@tripstorekrabi.com";
+}
+
+export function isActivity(url) {
+  return url.includes("/Activities/");
+}
+
+export function getGoogleDocId(url) {
+  return url.match(/[-\w]{25,}/)[0];
+}
+
+export function createVoucherRequest(booking, product) {
+  let request = {
+    booking: {
+      referenceNumber: booking.referenceNumber,
+      specialRequirements: booking.specialRequirements,
+      nationalParkFee:
+        product && product.nationalPark
+          ? "NATIONAL PARK ENTRANCE FEE: " +
+          booking.nationalParkFee.toUpperCase()
+          : "",
+      productDescription: booking.productDescription,
+      leadTraveller: booking.leadTraveller,
+      adults: booking.adults,
+      children: booking.children,
+      infants: booking.infants,
+      departureDate: dayjs(booking.departureDate.toDate()).tz("Asia/Bangkok").format("Do MMM YYYY"),
+      operator: booking.operator,
+      startingPointDescription: booking.startingPointDescription,
+      roomNumber: booking.roomNumber,
+      schedule: booking.schedule,
+      pickupTime: booking.pickupTime,
+      mobileVoucher: product
+        ? product.operator.mobileVoucher ??
+        product.operator.default.mobileVoucher
+        : true,
+    },
+  };
+  if (booking.voucherUrl) {
+    request["id"] = getGoogleDocId(booking.voucherUrl);
+  }
+
+  return request;
+}
+
+export function isGYGBooking(referenceNumber) {
+  return referenceNumber.startsWith("GYG");
+}
+
+export function isViatorBooking(referenceNumber) {
+  return referenceNumber.startsWith("BR-");
+}
+
+export function isExpediaBooking(referenceNumber) {
+  return referenceNumber.startsWith("EXP-");
+}
+
+export function isKlookBooking(referenceNumber) {
+  return referenceNumber.startsWith("KLK-");
+}
+
+export function isMusementBooking(referenceNumber) {
+  return referenceNumber.startsWith("MUS");
+}
+
+export function isAirbnbBooking(referenceNumber) {
+  return referenceNumber.startsWith("Airbnb-");
+}
+
+export function isKKdayBooking(referenceNumber) {
+  return referenceNumber.startsWith("KKday-");
+}
+
+export function isTiqetsBooking(referenceNumber) {
+  return referenceNumber.startsWith("TIQ-");
+}
+
+export function isTSKBooking(referenceNumber) {
+  return referenceNumber.startsWith("TSK");
+}
+
+export function getBookingType(referenceNumber) {
+  if (!referenceNumber) {
+    return "";
+  }
+  if (isGYGBooking(referenceNumber)) {
+    return "gyg";
+  } else if (isViatorBooking(referenceNumber)) {
+    return "br";
+  } else if (isExpediaBooking(referenceNumber)) {
+    return "exp";
+  } else if (isKlookBooking(referenceNumber)) {
+    return "klk";
+  } else if (isMusementBooking(referenceNumber)) {
+    return "mus";
+  } else if (isAirbnbBooking(referenceNumber)) {
+    return "air";
+  } else if (isKKdayBooking(referenceNumber)) {
+    return "kkday";
+  } else if (isTiqetsBooking(referenceNumber)) {
+    return "tiq";
+  } else if (isTSKBooking(referenceNumber)) {
+    return "tsk";
+  }
+}
+
+export function hasCustomPricing(pricing, bookingType) {
+  return pricing[bookingType] || bookingType === "tsk";
+}
+
+export function truncate(str, num) {
+  return str.length > num ? str.slice(0, num - 1) : str;
+}