tods-competition-factory 2.3.1 → 2.3.2

package/dist/tods-competition-factory.d.ts

@@ -1356,6 +1356,10 @@ declare const errorConditionConstants: {
         message: string;
         code: string;
     };
+    BOOKING_NOT_FOUND: {
+        message: string;
+        code: string;
+    };
     CANNOT_CHANGE_WINNING_SIDE: {
         message: string;
         code: string;
@@ -1388,6 +1392,10 @@ declare const errorConditionConstants: {
         message: string;
         code: string;
     };
+    EXISTING_MATCHUPS: {
+        message: string;
+        code: string;
+    };
     DRAW_DEFINITION_NOT_FOUND: {
         message: string;
         code: string;
@@ -8456,10 +8464,11 @@ type SetSchedulingProfileArgs = {
 };
 declare function setSchedulingProfile({ tournamentRecords, tournamentRecord, schedulingProfile, }: SetSchedulingProfileArgs): any;
 
-declare function courtGridRows({ courtPrefix, minRowsCount, courtsData }: {
+declare function courtGridRows({ courtPrefix, minRowsCount, courtsData, scheduledDate }: {
     courtPrefix?: string | undefined;
     minRowsCount: any;
     courtsData: any;
+    scheduledDate: any;
 }): {
     error: {
         message: string;
@@ -9448,6 +9457,31 @@ declare function findMatchUpFormatTiming({ defaultRecoveryMinutes, defaultAverag
     error?: undefined;
 };
 
+type AddCourtGridBookingArgs = {
+    tournamentRecord: Tournament;
+    disableNotice?: boolean;
+    bookingType: string;
+    courtOrder: number;
+    scheduledDate: string;
+    courtId: string;
+    rowCount?: number;
+    notes?: string;
+};
+declare function addCourtGridBooking(params: AddCourtGridBookingArgs): ResultType & {
+    booking?: any;
+};
+
+type RemoveCourtGridBookingArgs = {
+    tournamentRecord: Tournament;
+    disableNotice?: boolean;
+    scheduledDate: string;
+    courtOrder: number;
+    courtId: string;
+};
+declare function removeCourtGridBooking(params: RemoveCourtGridBookingArgs): ResultType & {
+    booking?: any;
+};
+
 type AddMatchUpScheduleItemsArgs = {
     inContextMatchUps?: HydratedMatchUp[];
     drawMatchUps?: HydratedMatchUp[];
@@ -9490,6 +9524,7 @@ declare function addMatchUpResumeTime({ removePriorValues, tournamentRecord, dra
     resumeTime?: string;
 }): any;
 
+declare const mutate$4_addCourtGridBooking: typeof addCourtGridBooking;
 declare const mutate$4_addMatchUpCourtOrder: typeof addMatchUpCourtOrder;
 declare const mutate$4_addMatchUpEndTime: typeof addMatchUpEndTime;
 declare const mutate$4_addMatchUpOfficial: typeof addMatchUpOfficial;
@@ -9517,6 +9552,7 @@ declare const mutate$4_matchUpScheduleChange: typeof matchUpScheduleChange;
 declare const mutate$4_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTiming;
 declare const mutate$4_proAutoSchedule: typeof proAutoSchedule;
 declare const mutate$4_proConflicts: typeof proConflicts;
+declare const mutate$4_removeCourtGridBooking: typeof removeCourtGridBooking;
 declare const mutate$4_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
 declare const mutate$4_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment;
 declare const mutate$4_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps;
@@ -9529,6 +9565,7 @@ declare const mutate$4_toggleParticipantCheckInState: typeof toggleParticipantCh
 declare const mutate$4_validateSchedulingProfile: typeof validateSchedulingProfile;
 declare namespace mutate$4 {
   export {
+    mutate$4_addCourtGridBooking as addCourtGridBooking,
     mutate$4_addMatchUpCourtOrder as addMatchUpCourtOrder,
     mutate$4_addMatchUpEndTime as addMatchUpEndTime,
     mutate$4_addMatchUpOfficial as addMatchUpOfficial,
@@ -9556,6 +9593,7 @@ declare namespace mutate$4 {
     mutate$4_modifyMatchUpFormatTiming as modifyMatchUpFormatTiming,
     mutate$4_proAutoSchedule as proAutoSchedule,
     mutate$4_proConflicts as proConflicts,
+    mutate$4_removeCourtGridBooking as removeCourtGridBooking,
     mutate$4_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
     mutate$4_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment,
     mutate$4_reorderUpcomingMatchUps as reorderUpcomingMatchUps,
@@ -9569,6 +9607,7 @@ declare namespace mutate$4 {
   };
 }
 
+declare const index$7_addCourtGridBooking: typeof addCourtGridBooking;
 declare const index$7_addMatchUpCourtOrder: typeof addMatchUpCourtOrder;
 declare const index$7_addMatchUpEndTime: typeof addMatchUpEndTime;
 declare const index$7_addMatchUpOfficial: typeof addMatchUpOfficial;
@@ -9605,6 +9644,7 @@ declare const index$7_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTimin
 declare const index$7_proAutoSchedule: typeof proAutoSchedule;
 declare const index$7_proConflicts: typeof proConflicts;
 declare const index$7_publicFindCourt: typeof publicFindCourt;
+declare const index$7_removeCourtGridBooking: typeof removeCourtGridBooking;
 declare const index$7_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
 declare const index$7_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment;
 declare const index$7_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps;
@@ -9617,6 +9657,7 @@ declare const index$7_toggleParticipantCheckInState: typeof toggleParticipantChe
 declare const index$7_validateSchedulingProfile: typeof validateSchedulingProfile;
 declare namespace index$7 {
   export {
+    index$7_addCourtGridBooking as addCourtGridBooking,
     index$7_addMatchUpCourtOrder as addMatchUpCourtOrder,
     index$7_addMatchUpEndTime as addMatchUpEndTime,
     index$7_addMatchUpOfficial as addMatchUpOfficial,
@@ -9655,6 +9696,7 @@ declare namespace index$7 {
     index$7_proConflicts as proConflicts,
     index$7_publicFindCourt as publicFindCourt,
     query$2 as query,
+    index$7_removeCourtGridBooking as removeCourtGridBooking,
     index$7_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
     index$7_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment,
     index$7_reorderUpcomingMatchUps as reorderUpcomingMatchUps,

package/dist/tods-competition-factory.development.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.3.1';
+    return '2.3.2';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -989,6 +989,14 @@ const COURT_EXISTS = {
     message: 'Court exists',
     code: 'ERR_EXISTING_COURT',
 };
+const BOOKING_NOT_FOUND = {
+    message: 'Booking not found',
+    code: 'ERR_NOT_FOUND_BOOKING',
+};
+const EXISTING_MATCHUPS = {
+    message: 'Existing matchUps conflict with booking',
+    code: 'ERR_EXISTING_MATCHUPS',
+};
 const VENUE_EXISTS = {
     message: 'Venue exists',
     code: 'ERR_EXISTING_VENUE',
@@ -1152,6 +1160,7 @@ const SCORES_PRESENT = {
 };
 const errorConditionConstants = {
     ANACHRONISM,
+    BOOKING_NOT_FOUND,
     CANNOT_CHANGE_WINNING_SIDE,
     CANNOT_MODIFY_TIEFORMAT,
     CANNOT_MODIFY_PARTICIPANT_TYPE,
@@ -1160,6 +1169,7 @@ const errorConditionConstants = {
     CATEGORY_MISMATCH,
     COURT_EXISTS,
     COURT_NOT_FOUND,
+    EXISTING_MATCHUPS,
     DRAW_DEFINITION_NOT_FOUND,
     DRAW_ID_EXISTS,
     DRAW_POSITION_ACTIVE,
@@ -36681,7 +36691,31 @@ function getProfileRounds({ tournamentRecords, schedulingProfile, tournamentReco
     return { profileRounds, segmentedRounds };
 }
 
-function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
+function getCourtDateAvailability({ court, date }) {
+    const targetDateAvailability = date && court.dateAvailability.find((availability) => sameDay(availability.date, date));
+    const defaultAvailability = court.dateAvailability.find((availability) => !availability.date);
+    return targetDateAvailability || defaultAvailability;
+}
+
+function getGridBookings({ court, date }) {
+    const courtDate = getCourtDateAvailability({ court, date });
+    const gridBookings = new Map();
+    const timeBookings = [];
+    (courtDate?.bookings || []).forEach((booking) => {
+        if (typeof booking.courtOrder === 'number') {
+            const rowCount = booking.rowCount || 1;
+            for (let i = 0; i < rowCount; i++) {
+                gridBookings.set(booking.courtOrder + i, booking);
+            }
+        }
+        else {
+            timeBookings.push(booking);
+        }
+    });
+    return { gridBookings, timeBookings };
+}
+
+function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData, scheduledDate }) {
     if (!Array.isArray(courtsData))
         return { error: INVALID_VALUES };
     const maxCourtOrder = courtsData?.reduce((order, court) => {
@@ -36693,7 +36727,21 @@ function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
     const rowBuilder = generateRange(0, rowsCount).map((rowIndex) => ({
         matchUps: generateRange(0, courtsData.length).map((courtIndex) => {
             const courtInfo = courtsData[courtIndex];
-            const { courtId, venueId } = courtInfo;
+            const { courtId, venueId, court } = courtInfo;
+            if (scheduledDate && court) {
+                const { gridBookings } = getGridBookings({
+                    court,
+                    date: scheduledDate,
+                });
+                if (gridBookings.has(rowIndex + 1)) {
+                    const booking = gridBookings.get(rowIndex + 1);
+                    return {
+                        schedule: { courtOrder: rowIndex + 1, venueId, courtId },
+                        isBlocked: true,
+                        booking,
+                    };
+                }
+            }
             return {
                 schedule: {
                     courtOrder: rowIndex + 1,
@@ -37563,8 +37611,10 @@ function competitionScheduleMatchUps(params) {
         venues,
     };
     if (withCourtGridRows) {
+        const scheduledDate = params.matchUpFilters?.scheduledDate;
         const { rows, courtPrefix } = courtGridRows({
             minRowsCount: Math.max(minCourtGridRows || 0, dateMatchUps.length || 0),
+            scheduledDate,
             courtsData,
         });
         result.courtPrefix = courtPrefix;
@@ -42091,12 +42141,6 @@ function generateCourts(params) {
     return { ...SUCCESS, courts };
 }
 
-function getCourtDateAvailability({ court, date }) {
-    const targetDateAvailability = date && court.dateAvailability.find((availability) => sameDay(availability.date, date));
-    const defaultAvailability = court.dateAvailability.find((availability) => !availability.date);
-    return targetDateAvailability || defaultAvailability;
-}
-
 function generateTimeSlots(params) {
     const paramsCheck = checkRequiredParameters(params, [{ courtDate: true, _ofType: OBJECT }]);
     if (paramsCheck.error)
@@ -55110,7 +55154,7 @@ function proAutoSchedule({ scheduleCompletedMatchUps, tournamentRecords, schedul
                 }
             }
         });
-        const availableCourts = Object.values(row).filter((c) => isObject(c) && !c.matchUpId);
+        const availableCourts = Object.values(row).filter((c) => isObject(c) && !c.matchUpId && !c.isBlocked);
         return gridRows.concat({
             matchUpIds,
             availableCourts,
@@ -56029,8 +56073,151 @@ function setMatchUpDailyLimits(params) {
     return { ...SUCCESS };
 }
 
+function addCourtGridBooking(params) {
+    const { tournamentRecord, disableNotice, scheduledDate, bookingType, courtOrder, rowCount = 1, courtId, notes, } = params;
+    if (!tournamentRecord) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'tournamentRecord is required',
+        });
+    }
+    if (!courtId) {
+        return { error: COURT_NOT_FOUND };
+    }
+    if (!scheduledDate) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'scheduledDate is required',
+        });
+    }
+    if (!bookingType) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'bookingType is required',
+        });
+    }
+    if (courtOrder === undefined || courtOrder === null) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'courtOrder is required',
+        });
+    }
+    if (!Number.isInteger(courtOrder) || courtOrder < 1) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'courtOrder must be a positive integer',
+        });
+    }
+    if (!Number.isInteger(rowCount) || rowCount < 1) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'rowCount must be a positive integer',
+        });
+    }
+    const { court, venue } = findCourt({ tournamentRecord, courtId });
+    if (!court)
+        return { error: COURT_NOT_FOUND };
+    const courtDate = getCourtDateAvailability({ court, date: scheduledDate });
+    if (!courtDate) {
+        if (!court.dateAvailability)
+            court.dateAvailability = [];
+        const newAvailability = {
+            date: scheduledDate,
+            bookings: [],
+        };
+        court.dateAvailability.push(newAvailability);
+    }
+    const targetCourtDate = getCourtDateAvailability({ court, date: scheduledDate });
+    if (targetCourtDate.bookings) {
+        for (const existingBooking of targetCourtDate.bookings) {
+            if (typeof existingBooking.courtOrder === 'number') {
+                const existingStart = existingBooking.courtOrder;
+                const existingEnd = existingStart + (existingBooking.rowCount || 1) - 1;
+                const newStart = courtOrder;
+                const newEnd = courtOrder + rowCount - 1;
+                if (newStart <= existingEnd && newEnd >= existingStart) {
+                    return decorateResult({
+                        result: { error: EXISTING_MATCHUPS },
+                        info: `Booking conflicts with existing booking at rows ${existingStart}-${existingEnd}`,
+                    });
+                }
+            }
+        }
+    }
+    const booking = {
+        courtOrder,
+        rowCount,
+        bookingType,
+        notes,
+        createdAt: new Date().toISOString(),
+    };
+    if (!targetCourtDate.bookings)
+        targetCourtDate.bookings = [];
+    targetCourtDate.bookings.push(booking);
+    if (!disableNotice && venue) {
+        addNotice({
+            payload: { venue, tournamentId: tournamentRecord.tournamentId },
+            topic: MODIFY_VENUE,
+            key: venue.venueId,
+        });
+    }
+    return { ...SUCCESS, booking };
+}
+
+function removeCourtGridBooking(params) {
+    const { tournamentRecord, disableNotice, scheduledDate, courtOrder, courtId, } = params;
+    if (!tournamentRecord) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'tournamentRecord is required',
+        });
+    }
+    if (!courtId) {
+        return { error: COURT_NOT_FOUND };
+    }
+    if (!scheduledDate) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'scheduledDate is required',
+        });
+    }
+    if (courtOrder === undefined || courtOrder === null) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'courtOrder is required',
+        });
+    }
+    const { court, venue } = findCourt({ tournamentRecord, courtId });
+    if (!court)
+        return { error: COURT_NOT_FOUND };
+    const courtDate = getCourtDateAvailability({ court, date: scheduledDate });
+    if (!courtDate?.bookings) {
+        return decorateResult({
+            result: { error: BOOKING_NOT_FOUND },
+            info: 'No bookings found for this date',
+        });
+    }
+    const bookingIndex = courtDate.bookings.findIndex((b) => b.courtOrder === courtOrder);
+    if (bookingIndex === -1) {
+        return decorateResult({
+            result: { error: BOOKING_NOT_FOUND },
+            info: `No booking found at row ${courtOrder}`,
+        });
+    }
+    const removed = courtDate.bookings.splice(bookingIndex, 1)[0];
+    if (!disableNotice && venue) {
+        addNotice({
+            payload: { venue, tournamentId: tournamentRecord.tournamentId },
+            topic: MODIFY_VENUE,
+            key: venue.venueId,
+        });
+    }
+    return { ...SUCCESS, booking: removed };
+}
+
 var mutate$3 = {
     __proto__: null,
+    addCourtGridBooking: addCourtGridBooking,
     addMatchUpCourtOrder: addMatchUpCourtOrder,
     addMatchUpEndTime: addMatchUpEndTime,
     addMatchUpOfficial: addMatchUpOfficial,
@@ -56058,6 +56245,7 @@ var mutate$3 = {
     modifyMatchUpFormatTiming: modifyMatchUpFormatTiming,
     proAutoSchedule: proAutoSchedule,
     proConflicts: proConflicts,
+    removeCourtGridBooking: removeCourtGridBooking,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeMatchUpCourtAssignment: removeMatchUpCourtAssignment,
     reorderUpcomingMatchUps: reorderUpcomingMatchUps,
@@ -56072,6 +56260,7 @@ var mutate$3 = {
 
 var index$5 = {
     __proto__: null,
+    addCourtGridBooking: addCourtGridBooking,
     addMatchUpCourtOrder: addMatchUpCourtOrder,
     addMatchUpEndTime: addMatchUpEndTime,
     addMatchUpOfficial: addMatchUpOfficial,
@@ -56110,6 +56299,7 @@ var index$5 = {
     proConflicts: proConflicts,
     publicFindCourt: publicFindCourt,
     query: query$4,
+    removeCourtGridBooking: removeCourtGridBooking,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeMatchUpCourtAssignment: removeMatchUpCourtAssignment,
     reorderUpcomingMatchUps: reorderUpcomingMatchUps,