@bash-app/bash-common 1.0.14 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash-app/bash-common",
-  "version": "1.0.14",
+  "version": "1.2.0",
   "description": "Common data and scripts to use on the frontend and backend",
   "type": "module",
   "main": "src/index.ts",
@@ -21,7 +21,9 @@
     "typescript": "^5.2.2"
   },
   "peerDependencies": {
-    "tsx": "^4.10.3"
+    "tsx": "^4.10.3",
+    "dayjs": "^1.11.10",
+    "react-tailwindcss-datepicker": "^1.6.6"
   },
   "devDependencies": {
     "@prisma/client": "^5.13.0",

package/prisma/schema.prisma

@@ -767,22 +767,48 @@ model AssociatedBash {
 }
 
 model Service {
-  id             String        @id @default(cuid())
-  ownerId        String
-  owner          User          @relation(fields: [ownerId], references: [id], onDelete: Cascade)
-  name           String?
-  coverPhoto     String?
-  media          Media[]
-  serviceType    ServiceType
-  subServiceType String?
-  serviceLinks   ServiceLink[]
-  address        String
-  description    String?
-  canContact     Boolean?
-  genre          GenreType?
-}
-
-enum GenreType {
+  id                 String               @id @default(cuid())
+  ownerId            String
+  owner              User                 @relation(fields: [ownerId], references: [id], onDelete: Cascade)
+  name               String?
+  coverPhoto         String?
+  media              Media[]
+  serviceType        ServiceType[]
+  subServiceType     String?
+  serviceLinks       ServiceLink[]
+  address            String
+  description        String?
+  canContact         Boolean?
+  musicGenre         MusicGenreType?
+  visibility         VisibilityPreference @default(Public)
+  bashesInterestedIn BashEventType[]
+  crowdSizeId        String               @unique
+  crowdSize          ServiceRange         @relation("CrowdSize", fields: [crowdSizeId], references: [id], onDelete: Cascade)
+  serviceRangeId     String               @unique
+  serviceRange       ServiceRange         @relation("ServiceRange", fields: [serviceRangeId], references: [id], onDelete: Cascade)
+  availableDateTimes DateTime?
+}
+
+model ServiceRange {
+  id           String   @id @default(cuid())
+  minimum      Int?
+  maximum      Int?
+  crowdSize    Service? @relation("CrowdSize")
+  serviceRange Service? @relation("ServiceRange")
+}
+
+model Availability {
+    id           String   @id @default(cuid())
+  startDateTime String
+  endDateTime String
+}
+
+enum VisibilityPreference {
+  Public
+  Private
+}
+
+enum MusicGenreType {
   Classical
   Rock
   HipHop
@@ -873,8 +899,8 @@ model VendorLink {
 
 model ServiceLink {
   id         String  @id @default(cuid())
-  service    Service @relation(fields: [servicesId], references: [id], onDelete: Cascade)
-  link       Link    @relation(fields: [linkId], references: [id], onDelete: Cascade)
   servicesId String
+  service    Service @relation(fields: [servicesId], references: [id], onDelete: Cascade)
   linkId     String
+  link       Link    @relation(fields: [linkId], references: [id], onDelete: Cascade)
 }

package/src/index.ts

@@ -1,2 +1,6 @@
 export * from "./extendedSchemas";
 export * from "./definitions";
+export * from "./utils/ticketListUtils";
+export * from "./utils/dateTimeUtils";
+export * from "./utils/recurrenceUtils";
+export * from "./utils/addressUtils";

package/src/utils/addressUtils.ts

@@ -0,0 +1,173 @@
+
+const ADDRESS_DELIM = '|';
+
+const googleMapsApiKey = process.env.REACT_APP_GOOGLE_MAP_API_KEY as string;
+
+
+export interface IAddress {
+  place: string;
+  street: string;
+  city: string;
+  state: string;
+  zipCode: string;
+  country: string;
+}
+
+export function addressHasEnoughDataForGeolocation(address: IAddress): boolean {
+  return !!((address.place && address.city && address.state) || (address.street && address.city && address.state));
+}
+
+export function addressValuesToDatabaseAddressString(addressValues: IAddress): string {
+  const { place = '', street, city, state, zipCode, country } = addressValues;
+  return [place, street, city, state, zipCode, country].join(ADDRESS_DELIM);
+}
+
+export function databaseAddressStringToAddressValues(addressString: string | undefined | null): IAddress {
+  if (addressString) {
+    const addressArray = addressString.split(ADDRESS_DELIM);
+    return {
+      place: addressArray[0],
+      street: addressArray[1],
+      city: addressArray[2],
+      state: addressArray[3],
+      zipCode: addressArray[4],
+      country: 'USA'
+    }
+  }
+  return { place: '', street: '', city: '', state: '', zipCode: '', country: '' };
+}
+
+
+export function databaseAddressStringToOneLineString(addressString: string | undefined | null): string {
+  if (addressString) {
+    const address = databaseAddressStringToAddressValues(addressString);
+    let addressArr = address.place ? [address.place] : [];
+    addressArr = [...addressArr, address.street, address.city, address.state];
+    const addressStr = addressArr.filter((str) => !!str).join(', ');
+    return `${addressStr} ${address.zipCode}`;
+  }
+  return '';
+}
+
+export function databaseAddressStringToDisplayString(addressString: string | undefined | null): string {
+  if (addressString) {
+    const oneLineString = databaseAddressStringToOneLineString(addressString);
+    const formatted = oneLineString.replace(/([A-Z])(?=[A-Z][a-z])/g, "$1 ") // Add space between a single uppercase letter and a capitalized word
+                 .replace(/(\d)(?=[A-Z])/g, "$1 ") // Add space between numbers and letters
+                 .replace(/,/g, ", "); // Add space after commas
+    return formatted;
+  }
+  return '';
+}
+
+
+export async function getAddressFromCoordinates( lat: number, lng: number ): Promise<IAddress> {
+  const apiUrl = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${googleMapsApiKey}&loading=async`;
+  try {
+    const response = await fetch(apiUrl);
+    const data = await response.json();
+    if (data.results.length > 0) {
+      const addressComponents = data.results[0].address_components;
+
+      let street = "";
+      let city = "";
+      let state = "";
+      let zipCode = "";
+
+      addressComponents.forEach((component: any) => {
+        if (component.types.includes("route")) {
+          street = component.long_name;
+        } else if (component.types.includes("locality")) {
+          city = component.long_name;
+        } else if (component.types.includes("administrative_area_level_1")) {
+          state = component.short_name;
+        } else if (component.types.includes("postal_code")) {
+          zipCode = component.long_name;
+        }
+      });
+
+      return { place: '',  street, city, state, zipCode, country: 'USA' };
+    } else {
+      throw new Error("No address found");
+    }
+  } catch (error) {
+    console.error(error);
+    return {
+      place: '',
+      street: "",
+      city: "",
+      state: "",
+      zipCode: "",
+      country: 'USA'
+    };
+  }
+}
+
+export function extractAddressComponents(place: any): IAddress {
+  const addressComponents = place.address_components;
+  let streetNumber = '';
+  let streetName = '';
+  let city = '';
+  let state = '';
+  let zipCode = '';
+  let country = 'USA';
+
+  addressComponents.forEach((component: any) => {
+    const types = component.types;
+    if (types.includes('street_number')) {
+      streetNumber = component.long_name;
+    }
+    if (types.includes('route')) {
+      streetName = component.long_name;
+    }
+    if (types.includes('locality')) {
+      city = component.long_name;
+    }
+    if (types.includes('administrative_area_level_1')) {
+      state = component.short_name;
+    }
+    if (types.includes('postal_code')) {
+      zipCode = component.long_name;
+    }
+    if (types.includes('country')) {
+      country = component.long_name;
+    }
+  });
+
+  const street = `${streetNumber} ${streetName}`.trim();
+
+  return {
+    place: place.name || '',
+    street,
+    city,
+    state,
+    zipCode,
+    country
+  };
+}
+
+
+export async function getGeoCoordinatesFromAddress(address: IAddress): Promise<{lat: number, lng: number} | undefined> {
+  const addressStr = `${address.street}, ${address.city}, ${address.state} ${address.zipCode}, ${address.country}`;
+
+  const response = await fetch(
+    `https://maps.googleapis.com/maps/api/geocode/json?address=${encodeURIComponent(addressStr)}&key=${googleMapsApiKey}`
+  );
+  if (!response.ok) {
+    console.error('Geocode response was not ok for address: ' + addressStr);
+  }
+
+  const data = await response.json();
+
+  if (data.status === 'OK') {
+    if (data.results?.length) {
+      return data.results[0].geometry.location;
+    }
+    else {
+      console.error('Geocode results were empty with address: ' + addressStr);
+    }
+  }
+  else {
+    console.error(`Geocode was not successful with address: ${addressStr}\nfor the following reason: ${data.status}`);
+  }
+}

package/src/utils/dateTimeUtils.ts

@@ -0,0 +1,177 @@
+import {DateType, DateValueType} from "react-tailwindcss-datepicker";
+import dayjs from "dayjs";
+import dayjsUtc from "dayjs/plugin/utc";
+import dayjsTimeZone from "dayjs/plugin/timezone";
+import {DateTimeArgType} from "../definitions";
+
+dayjs.extend(dayjsUtc);
+dayjs.extend(dayjsTimeZone);
+
+
+const PARSE_TIME_REG = /^(\d{1,2}):(\d{2}) ?([APM]{0,2})$/i;
+
+export const DATETIME_FORMAT_STANDARD = "MMM D, YYYY - h:mm A";
+export const DATETIME_FORMAT_ISO_LIKE = "YYYY-MM-DD HH:mm"
+export const DATE_FORMAT_STANDARD = "MM/DD/YYYY";
+export const DATE_FORMAT_ISO = "YYYY-MM-DD";
+export const TIME_FORMAT_AM_PM = "hh:mm A";
+
+export interface ITime {
+  hours: number;
+  minutes: number;
+  ampm: string;
+}
+
+export function ensureIsDateTime(possiblyADate: DateTimeArgType): Date | undefined {
+  if (!possiblyADate) {
+    return undefined;
+  }
+  return typeof possiblyADate === 'string' ? new Date(possiblyADate) : possiblyADate;
+}
+
+export function normalizeDate(validDate: Date | string | undefined | null): Date | undefined {
+  if (validDate) {
+    if (typeof validDate === 'string') {
+      validDate = new Date(validDate);
+    }
+    validDate.setHours(validDate.getHours(), validDate.getMinutes(), 0);
+    return validDate;
+  }
+}
+
+export function normalizeDates(dates: Date[]): Date[] {
+  return dates
+    .map((date): Date | undefined => {
+      return normalizeDate(date);
+    })
+    .filter((dateTime: Date | undefined): boolean => {
+      return !!dateTime
+    }) as Date[];
+}
+
+export function formatDateTimeToISODateTimeString(date: DateTimeArgType): string | undefined {
+  if (!date) {
+    return undefined;
+  }
+  date = new Date(date);
+  return date.toISOString();
+}
+
+export function dateWithinDateRange(date: DateTimeArgType, dateRange: DateValueType | undefined): boolean {
+  const startDate = dayjs(dateRange?.startDate).startOf('day').toDate();
+  const endDate = dayjs(dateRange?.endDate).endOf('day').toDate();
+
+  return compareDateTime(date, startDate) >= 0 &&
+    compareDateTime(date, endDate) < 0;
+}
+
+export function findLatestDateTime(date1Arg: DateTimeArgType, date2Arg: DateTimeArgType): Date | undefined {
+  const date1 = dateTimeTypeToDate(date1Arg);
+  const date2 = dateTimeTypeToDate(date2Arg);
+  return compareDateTime(date1, date2) > 0 ? date1 : date2;
+}
+
+function dateTimeTypeToDate(date: DateTimeArgType): Date | undefined {
+  if (typeof date === 'string') {
+    return new Date(date);
+  }
+  else {
+    return date ?? undefined;
+  }
+}
+
+export function isDateTimeLaterThanNow(date: DateTimeArgType): boolean {
+  return compareDateTime(date, new Date()) > 0;
+}
+
+export function areDateTimesEqual(date1: DateTimeArgType,
+                                  date2: DateTimeArgType): boolean {
+  return compareDateTime(date1, date2) === 0;
+}
+
+/**
+ * Returns a 1 if date1 is later than date2; 0 if both dates are equal; -1 if date2 is later than date1
+ * @param date1
+ * @param date2
+ */
+export function compareDateTime(date1: DateTimeArgType,
+                                date2: DateTimeArgType): number {
+  if (!date1 && !date2) {
+    return 0;
+  }
+  if (!date1) {
+    return -1;
+  }
+  if (!date2) {
+    return 1;
+  }
+  if (typeof date1 === 'string') {
+    date1 = new Date(date1);
+  }
+  if (typeof date2 === 'string') {
+    date2 = new Date(date2);
+  }
+
+  const date1Time = date1.getTime();
+  const date2Time = date2.getTime();
+
+  if (date1Time > date2Time) {
+    return 1;
+  }
+  if (date1Time === date2Time) {
+    return 0;
+  }
+  else {
+    return -1;
+  }
+}
+
+export function setDateButPreserveTime(dateArg: DateType, dateWithTheTimeYouWantToKeep: DateType | undefined): Date {
+  const date = dayjs(dateArg).format(DATE_FORMAT_ISO);
+  const time = dayjs(dateWithTheTimeYouWantToKeep).format(TIME_FORMAT_AM_PM);
+  const combinedDateTime = dayjs(date + " " + time).toDate();
+  return combinedDateTime;
+}
+
+export function setTimeOnDate(date: DateType | Date | undefined, parsedTime: ITime): Date {
+  const dateTime = new Date(date ?? Date.now());
+  const parsedTimeDate = new Date();
+  parsedTimeDate.setHours(parsedTime.hours, parsedTime.minutes, 0); // Will change the date depending on time; corrected later
+  const correctTimeOnDate = setDateButPreserveTime(dateTime, parsedTimeDate);
+  return correctTimeOnDate;
+}
+
+export function ensureDateTimeIsLocalDateTime(dateArg: DateType | undefined): Date {
+  if (dayjs(dateArg).isUTC()) {
+    const dateLocalTimeZone = dayjs(dateArg);
+    const date = dateLocalTimeZone.toDate();
+    return date;
+  }
+  else {
+    return new Date(dateArg ?? Date.now());
+  }
+}
+
+export function formatDateTimeToTimeString(date: Date | string | undefined | null): string {
+  date = new Date(date ?? Date.now());
+  const result = dayjs(date).format("h:mm A");
+  return result;
+}
+
+export function parseTimeString(timeStr: string): ITime | null {
+  const match = timeStr.match(PARSE_TIME_REG);
+
+  if (match) {
+    const hours = parseInt(match[1], 10);
+    const minutes = parseInt(match[2], 10);
+    const ampm = match[3].toUpperCase();
+
+    if ((hours >= 0 && hours <= 12) && (minutes >= 0 && minutes <= 59) && (ampm === 'AM' || ampm === 'PM')) {
+      return {
+        hours: ampm === 'PM' && hours < 12 ? hours + 12 : hours,
+        minutes,
+        ampm };
+    }
+  }
+  return null;
+}

package/src/utils/recurrenceUtils.ts

@@ -0,0 +1,175 @@
+import {DayOfWeek, Recurrence, RecurringFrequency} from "@prisma/client";
+import dayjs, {Dayjs} from "dayjs";
+import dayjsWeekDay from "dayjs/plugin/weekday";
+import {DateTimeArgType} from "../definitions";
+import {compareDateTime, DATETIME_FORMAT_ISO_LIKE} from "./dateTimeUtils";
+
+dayjs.extend(dayjsWeekDay);
+
+
+export function getRecurringBashEventPossibleDateTimes(startDateTime: DateTimeArgType,
+                                                       recurrence: Recurrence | undefined | null): Date[] {
+  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, true) as Date[];
+}
+
+export function getRecurringBashEventPossibleDayjsTimes(startDateTime: DateTimeArgType,
+                                                        recurrence: Recurrence | undefined | null): Dayjs[] {
+  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, false) as Dayjs[];
+}
+
+
+function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTimeArgType,
+                                                         recurrence: Recurrence | undefined | null,
+                                                         toDate: boolean): (Dayjs | Date)[] {
+  if (!recurrence || !recurrence.frequency || recurrence.frequency === RecurringFrequency.Never) {
+    return [];
+  }
+
+  let recurrenceDates: Dayjs[] = [];
+  const beginningDate = findEarliestPossibleBashEventDate(startDateTime) as Dayjs; // Don't allow dates before the current date
+
+  switch (recurrence.frequency) {
+    case RecurringFrequency.Weekly:
+      recurrenceDates = getWeeklyRecurringDates(beginningDate, recurrence);
+      break;
+    default:
+      console.error(`Only weekly frequency is currently supported`);
+  }
+  return recurrenceDates.map((date: Dayjs): string => date.format(DATETIME_FORMAT_ISO_LIKE))
+                        .sort()
+                        .map((dateStr: string): Dayjs | Date => {
+                          if (toDate) {
+                            return dayjs(dateStr).toDate();
+                          }
+                          else {
+                            return dayjs(dateStr);
+                          }
+                        });
+}
+
+/**
+ * Get the weekly recurring dates
+ * @param beginningDateTime The beginning DateTime of the event, adjusted to be no earlier than now.
+ * @param recurrence
+ */
+function getWeeklyRecurringDates(beginningDateTime: Dayjs, recurrence: Recurrence): Dayjs[] {
+  if (recurrence.frequency !== RecurringFrequency.Weekly) {
+    throw new Error(`Cannot do a weekly recurrence if the frequency isn't weekly.`);
+  }
+
+  const interval = recurrence.interval ?? 1;
+  const recurrenceEnds = dayjs(recurrence.ends).endOf('day'); // Get the end of the day to not miss the last day
+  const numberOfDays = recurrenceEnds.diff(beginningDateTime, 'days');
+  const numberOfWeeks = Math.ceil((numberOfDays / 7) / interval); // Get the number of days and then round up so that we include the ending date
+
+  const recurrenceDates: Dayjs[] = [];
+  let theNextWeekOfRecurrences = beginningDateTime;
+
+  // Go week by week getting the next recurrence date
+  for (let i = 0; i < numberOfWeeks; i++) {
+    let weekday: Dayjs | null = null;
+    for (const dayOfWeekEnum of recurrence.repeatOnDays) {
+      const dayOfWeekNum = dayOfWeekEnumToDayNumber(dayOfWeekEnum);
+      weekday = theNextWeekOfRecurrences.weekday(dayOfWeekNum);
+      if (weekday > recurrenceEnds || weekday < beginningDateTime) {
+        continue; // Continue because repeatOnDays isn't sorted by the day of the week
+      }
+      // Set the time on the date so that it matches the time when the event starts
+      weekday = copyTimeToDate(beginningDateTime, weekday);
+      recurrenceDates.push(weekday);
+    }
+    if (weekday) {
+      theNextWeekOfRecurrences = getBeginningOfWeekInterval(weekday, interval);
+    }
+  }
+  return recurrenceDates;
+}
+
+function copyTimeToDate(dateWithTimeToCopy: Dayjs, dateWhoseTimeToChange: Dayjs): Dayjs {
+  if (dateWithTimeToCopy.second() !== 0) {
+    console.warn(`dateWithTimeToCopy has non-zero seconds: ${dateWithTimeToCopy.toString()} \nFixing...`);
+    dateWithTimeToCopy = dateWithTimeToCopy.set('seconds', 0);
+  }
+  dateWhoseTimeToChange = dateWhoseTimeToChange.set('hours', dateWithTimeToCopy.hour());
+  dateWhoseTimeToChange = dateWhoseTimeToChange.set('minutes', dateWithTimeToCopy.minute());
+  dateWhoseTimeToChange = dateWhoseTimeToChange.set('seconds', 0); // Should be 0
+  return dateWhoseTimeToChange;
+}
+
+function dayOfWeekEnumToDayNumber(dayEnum: DayOfWeek): number {
+  switch (dayEnum) {
+    case DayOfWeek.Sunday:
+      return 0;
+    case DayOfWeek.Monday:
+      return 1;
+    case DayOfWeek.Tuesday:
+      return 2;
+    case DayOfWeek.Wednesday:
+      return 3;
+    case DayOfWeek.Thursday:
+      return 4;
+    case DayOfWeek.Friday:
+      return 5;
+    case DayOfWeek.Saturday:
+      return 6;
+    default:
+      throw new Error(`How did this happen? Invalid DayOfWeek: ${dayEnum}`); // Shouldn't happen
+  }
+}
+
+/**
+ * Get the next week determined by the interval by going to the end of the week interval and adding one day
+ * @param date
+ * @param interval
+ */
+function getBeginningOfWeekInterval(date: Dayjs, interval: number): Dayjs {
+  if (!interval) {
+    interval = 1; // Avoid 0
+  }
+  // An interval of 2 would be (2 - 1) * 7 + 1 = 8 days to add to skip a week and go into the next week
+  const numberOfDaysToAdd = interval > 1 ? (interval - 1) * 7 + 1 : 1;
+  return date.endOf('week').add(numberOfDaysToAdd, 'day');
+}
+
+export function freqToGrammarString(freq: RecurringFrequency, interval: number | undefined, toLowerCase: boolean = false): string {
+  if (!interval) {
+    return freq;
+  }
+  const isPlural = interval > 1;
+  let result: string = freq;
+  switch (freq) {
+    case RecurringFrequency.Daily:
+      result = isPlural ? 'Days' : 'Day';
+      break;
+    case RecurringFrequency.Weekly:
+      result = isPlural ? 'Weeks' : 'Week';
+      break;
+    case RecurringFrequency.Monthly:
+      result = isPlural ? 'Months' : 'Month';
+      break;
+    case RecurringFrequency.Yearly:
+      result = isPlural ? 'Years' : 'Year';
+      break;
+  }
+  return toLowerCase ? result.toLowerCase() : result;
+}
+
+export function findEarliestPossibleBashEventDate(startDateTimeArg: DateTimeArgType): Dayjs | undefined {
+  return findEarliestOrLatestPossibleBashEventDate(startDateTimeArg, true);
+}
+
+function findEarliestOrLatestPossibleBashEventDate(startDateTimeArg: DateTimeArgType, findEarly: boolean): Dayjs | undefined {
+  if (!startDateTimeArg) {
+    return;
+  }
+  // Don't allow dates before the current date
+  const startDateTime = dayjs(startDateTimeArg);
+  const currentDateTime = dayjs();
+  const comparedDateTime = compareDateTime(currentDateTime.toDate(), startDateTimeArg);
+  if (findEarly) {
+    return comparedDateTime > 0 ? currentDateTime : startDateTime;
+  }
+  else {
+    return comparedDateTime < 0 ? currentDateTime : startDateTime;
+  }
+}

package/src/utils/ticketListUtils.ts

@@ -0,0 +1,69 @@
+import dayjs from "dayjs";
+import {
+  NumberOfTicketsForDate,
+  URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM,
+  URL_PARAMS_TICKET_ID_NUMBER_OF_TICKETS_DATE_DELIM,
+  URL_PARAMS_TICKET_LIST_DELIM,
+  URL_PARAMS_TICKETS_DATE_DELIM
+} from "../definitions";
+import { DATETIME_FORMAT_ISO_LIKE } from "./dateTimeUtils";
+
+
+/**
+ * Returns A string structured like: [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~,...
+ * @param ticketList A map where the key is the ticketTierId
+ */
+export function ticketListToString(ticketList: Map<string, NumberOfTicketsForDate[]>): string {
+  const ticketListArr: string[] = [];
+
+  for (const [ticketTierId, ticketListArgs] of ticketList.entries()) {
+    const ticketArgs: string[] = [`${ticketTierId}${URL_PARAMS_TICKET_ID_NUMBER_OF_TICKETS_DATE_DELIM}`];
+    for (const ticketNumAndDates of ticketListArgs) {
+      if (ticketNumAndDates.numberOfTickets > 0) {
+        ticketArgs.push(
+          `${ticketNumAndDates.numberOfTickets}${URL_PARAMS_TICKETS_DATE_DELIM}${ticketNumAndDates.ticketDateTime}`);
+      }
+    }
+    ticketListArr.push(ticketArgs.join(URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM));
+  }
+  return ticketListArr.join(URL_PARAMS_TICKET_LIST_DELIM);
+}
+
+/**
+ * Returns map where the key is the ticketTierId
+ * @param ticketListStr A string structured like: [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...,...
+ */
+export function ticketListStrToTicketList(ticketListStr: string): Map<string, NumberOfTicketsForDate[]> {
+  const ticketList: Map<string, NumberOfTicketsForDate[]> = new Map();
+
+  // [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...,...
+  const ticketListArgs = ticketListStr.split(URL_PARAMS_TICKET_LIST_DELIM);
+
+  ticketListArgs.forEach((tierIdAndTicketNumbersAndDates: string): void => {
+    const ticketNumAndDatesArr: NumberOfTicketsForDate[] = [];
+    // [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...
+    const [ticketTierId, ticketNumAndDatesStr] = tierIdAndTicketNumbersAndDates.split(URL_PARAMS_TICKET_ID_NUMBER_OF_TICKETS_DATE_DELIM);
+    // [numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...
+    const ticketNumAndDates = ticketNumAndDatesStr.split(URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM)
+                                                  .filter((ticketNumAndDateStr): boolean => !!ticketNumAndDateStr);
+
+    for (const ticketNumAndDateStr of ticketNumAndDates) {
+      // [numberOfTickets];;[date]
+      const [numberOfTickets, ticketDateTimeStr] = ticketNumAndDateStr.split(URL_PARAMS_TICKETS_DATE_DELIM);
+      let ticketDateTime: string | undefined;
+      if (!ticketDateTimeStr) {
+        ticketDateTime = undefined;
+      }
+      else {
+        ticketDateTime = dayjs(ticketDateTimeStr).format(DATETIME_FORMAT_ISO_LIKE);
+      }
+
+      ticketNumAndDatesArr.push({
+        numberOfTickets: parseInt(numberOfTickets),
+        ticketDateTime: ticketDateTime,
+      });
+    }
+    ticketList.set(ticketTierId, ticketNumAndDatesArr);
+  });
+  return ticketList;
+}