@eventlook/sdk 1.4.49 → 1.4.51

package/src/form/tickets/TicketWithMerchandiseSelection.tsx

@@ -8,6 +8,7 @@ import { IReleaseShort } from '@utils/types/release.type';
 import { IEvent } from '@utils/types/event.type';
 import ReleaseWithMerchandise from '@form/tickets/ReleaseWithMerchandise';
 import { EventType } from '@utils/data/event';
+import { MAX_TICKETS_PER_ORDER } from '@utils/data/ticket';
 import useGlobal from '@hooks/useGlobal.ts';
 
 interface Props {
@@ -42,7 +43,15 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
           item2.releaseCategoryName === item.releaseCategoryName && item2.order === item.order + 1
       );
       const selected = tickets.find((ticket) => ticket.releaseId === item.id);
-      return !!nextRelease && item.locked && !!selected && index + 1 == tickets.length;
+      const maxSelectable = Math.min(item.availableTickets || 0, MAX_TICKETS_PER_ORDER);
+
+      return (
+        !!nextRelease &&
+        item.locked &&
+        !!selected &&
+        Number(selected.quantity) >= maxSelectable &&
+        index + 1 == tickets.length
+      );
     });
     return lockedSelectedReleases && lockedSelectedReleases.includes(true);
   };
@@ -53,33 +62,40 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
 
   const selectedTickets = async () => {
     const releases = await mutate();
+    const currentReleases = releases || activeReleases || [];
     const allFilled = tickets.filter((item) => !item.releaseId || !item.quantity);
 
-    const soldOutReleaseCategories = activeReleases?.filter((release) =>
+    const soldOutReleaseCategories = currentReleases.filter((release) =>
       tickets.find(
         (ticket) =>
           release.id === ticket.releaseId &&
-          ticket.quantity === release.availableTickets &&
-          release.availableTickets !== 10
+          Number(ticket.quantity) >= Math.min(release.availableTickets || 0, MAX_TICKETS_PER_ORDER)
       )
     );
 
     // Unlock next releases when current release is sold out
-    if (soldOutReleaseCategories?.length && activeReleases) {
+    if (currentReleases.length) {
       let hasChanges = false;
-      const updatedReleases = activeReleases.map((release) => {
-        // For each sold-out release, find and unlock the next one
-        const soldOutRelease = soldOutReleaseCategories.find(
-          (soldOut) =>
-            soldOut.releaseCategoryName === release.releaseCategoryName &&
-            soldOut.order === release.order - 1 &&
-            release.locked
+      const updatedReleases = currentReleases.map((release) => {
+        const previousRelease = currentReleases.find(
+          (item) =>
+            item.releaseCategoryName === release.releaseCategoryName &&
+            item.order === release.order - 1
+        );
+
+        if (!release.locked || !previousRelease) return release;
+
+        const previousTicket = tickets.find((ticket) => ticket.releaseId === previousRelease.id);
+        const previousMaxSelectable = Math.min(
+          previousRelease.availableTickets || 0,
+          MAX_TICKETS_PER_ORDER
         );
-        if (soldOutRelease) {
-          hasChanges = true;
-          return { ...release, locked: false };
-        }
-        return release;
+        const shouldUnlock = Number(previousTicket?.quantity || 0) >= previousMaxSelectable;
+
+        if (!shouldUnlock) return release;
+
+        hasChanges = true;
+        return { ...release, locked: false };
       });
 
       if (hasChanges) {
@@ -87,7 +103,7 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
       }
     }
 
-    const hasSelectableRelease = activeReleases?.some(
+    const hasSelectableRelease = currentReleases.some(
       (release) => !isReleaseSelected(release.id) && !release.locked
     );
 
@@ -96,9 +112,9 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
         selectedReleaseIsSoldOut(releases) &&
         tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
         !allFilled.length) ||
-      (activeReleases &&
-        soldOutReleaseCategories?.length &&
-        activeReleases?.length > tickets.length &&
+      (currentReleases.length &&
+        soldOutReleaseCategories.length &&
+        currentReleases.length > tickets.length &&
         tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
         !allFilled.length) ||
       (tickets.length < countReleaseCategories() && !allFilled.length);
@@ -145,16 +161,18 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
           }}
         />
       ) : (
-        activeReleases?.map((release, index) => (
-          <ReleaseWithMerchandise
-            key={release.id}
-            eventId={event.id}
-            release={release}
-            activeReleases={activeReleases}
-            currency={event.currency}
-            index={index}
-          />
-        ))
+        activeReleases
+          ?.filter((release) => !release.locked || isReleaseSelected(release.id))
+          .map((release, index) => (
+            <ReleaseWithMerchandise
+              key={release.id}
+              eventId={event.id}
+              release={release}
+              activeReleases={activeReleases}
+              currency={event.currency}
+              index={index}
+            />
+          ))
       )}
       {!activeReleases && event.type === EventType.RECURRING && (
         <Typography variant="h5">{t('event.tickets.stepper.1.select_timeslot')}</Typography>

package/src/utils/data/ticket.ts

@@ -0,0 +1 @@
+export const MAX_TICKETS_PER_ORDER = 10;