tods-competition-factory 2.0.20 → 2.0.21

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.20';
+    return '2.0.21';
 }
 
 const SUCCESS = { success: true };
@@ -11485,18 +11485,27 @@ function getPublishState(params) {
         }
         return { ...SUCCESS, publishState };
     }
+    const publishedEventIds = [];
+    let tournamentPublished = false;
     const publishState = {};
     const pubStatus = getTournamentPublishStatus({ tournamentRecord });
-    publishState.tournament = pubStatus;
+    publishState.tournament = pubStatus ?? {};
     for (const event of tournamentRecord?.events ?? []) {
         const pubStatus = getPubStatus({ event });
         publishState[event.eventId] = pubStatus;
+        if (pubStatus.status.published) {
+            publishedEventIds.push(event.eventId);
+            tournamentPublished = true;
+        }
         for (const { drawId } of event.drawDefinitions ?? []) {
             const published = pubStatus.status?.publishedDrawIds?.includes(drawId);
             if (published)
                 publishState[drawId] = { status: { published } };
         }
     }
+    if (tournamentRecord) {
+        publishState.tournament.status = { published: tournamentPublished, publishedEventIds };
+    }
     return { ...SUCCESS, publishState };
 }
 function getPubStatus({ event }) {
@@ -16172,9 +16181,8 @@ function swapAssignedPositions({ candidatePositionAssignments, swapOptions }) {
 }
 
 function randomUnseededSeparation({ provisionalPositioning, unseededParticipantIds, inContextDrawMatchUps, unseededByePositions, tournamentRecord, drawDefinition, seedBlockInfo, participants, matchUpsMap, structureId, avoidance, drawSize, event, }) {
-    if (!avoidance) {
+    if (!avoidance)
         return { error: MISSING_AVOIDANCE_POLICY };
-    }
     const { candidatesCount = 1, policyAttributes, targetDivisions } = avoidance;
     let { roundsToSeparate } = avoidance;
     const stack = 'randomUnseededSeparation';
@@ -16222,9 +16230,8 @@ function randomUnseededSeparation({ provisionalPositioning, unseededParticipantI
         idCollections,
         participants,
     });
-    if (allGroups.error) {
+    if (allGroups.error)
         return decorateResult({ result: allGroups, stack });
-    }
     const participantIdGroups = Object.assign({}, ...unseededParticipantIds.map((participantId) => {
         const groups = Object.keys(allGroups).filter((key) => (allGroups[key] ?? []).includes(participantId));
         return { [participantId]: groups };
@@ -17024,7 +17031,9 @@ function positionByes({ provisionalPositioning, tournamentRecord, appliedPolicie
     return { ...SUCCESS, unseededByePositions, byeDrawPositions };
 }
 
-function automatedPositioning({ applyPositioning = true, provisionalPositioning, inContextDrawMatchUps, multipleStructures, placeByes = true, tournamentRecord, appliedPolicies, placementGroup, drawDefinition, seedingProfile, structureId, matchUpsMap, seedLimit, seedsOnly, drawType, drawSize, event, }) {
+function automatedPositioning(params) {
+    let { drawDefinition } = params;
+    const { applyPositioning = true, provisionalPositioning, multipleStructures, placeByes = true, tournamentRecord, placementGroup, seedingProfile, structureId, seedLimit, seedsOnly, drawType, drawSize, event, } = params;
     const positioningReport = [];
     if (!applyPositioning) {
         disableNotifications();
@@ -17046,13 +17055,12 @@ function automatedPositioning({ applyPositioning = true, provisionalPositioning,
     const structure = result.structure;
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
-    if (!appliedPolicies) {
-        appliedPolicies = getAppliedPolicies({
+    const appliedPolicies = params.appliedPolicies ||
+        getAppliedPolicies({
             drawDefinition,
             structure,
             event,
         })?.appliedPolicies;
-    }
     const { qualifiersCount } = getQualifiersCount({
         stageSequence: structure.stageSequence,
         provisionalPositioning,
@@ -17072,14 +17080,13 @@ function automatedPositioning({ applyPositioning = true, provisionalPositioning,
     });
     if (!entries?.length && !qualifiersCount)
         return handleSuccessCondition({ ...SUCCESS });
-    matchUpsMap = matchUpsMap ?? getMatchUpsMap({ drawDefinition });
-    if (!inContextDrawMatchUps) {
-        ({ matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
+    const matchUpsMap = params.matchUpsMap ?? getMatchUpsMap({ drawDefinition });
+    const inContextDrawMatchUps = params.inContextDrawMatchUps ??
+        getAllDrawMatchUps({
             inContext: true,
             drawDefinition,
             matchUpsMap,
-        }));
-    }
+        })?.matchUps;
     let unseededByePositions = [];
     const seedBlockInfo = getValidSeedBlocks({
         provisionalPositioning,
@@ -17092,12 +17099,14 @@ function automatedPositioning({ applyPositioning = true, provisionalPositioning,
         return seedBlockInfo;
     const { validSeedBlocks } = seedBlockInfo;
     positioningReport.push({ validSeedBlocks });
-    const participants = tournamentRecord
-        ? getParticipants({
-            withIndividualParticipants: true,
-            tournamentRecord,
-        })?.participants
-        : [];
+    const participants = params.participants ||
+        (tournamentRecord
+            ? getParticipants({
+                withIndividualParticipants: true,
+                convertExtensions: true,
+                tournamentRecord,
+            })?.participants
+            : []);
     if (getSeedPattern(structure.seedingProfile || seedingProfile) === WATERFALL) {
         let result = placeByes
             ? positionByes({
@@ -26684,10 +26693,75 @@ function getCompetitionPenalties({ tournamentRecords }) {
     return { penalties: allPenalties };
 }
 
-function getTournamentInfo({ tournamentRecord }) {
+function extractEventInfo({ event }) {
+    const eventInfo = (({ eventId, eventName, eventType, eventLevel, surfaceCategory, matchUpFormat, category, gender, startDate, endDate, ballType, discipline, onlineResources, notes, }) => ({
+        eventId,
+        eventName,
+        eventType,
+        eventLevel,
+        surfaceCategory,
+        matchUpFormat,
+        category,
+        gender,
+        startDate,
+        endDate,
+        ballType,
+        discipline,
+        onlineResources,
+        notes,
+    }))(event);
+    return { eventInfo };
+}
+
+const POLICY_PRIVACY_STAFF = {
+    [POLICY_TYPE_PARTICIPANT]: {
+        policyName: 'Staff Privacy Policy',
+        participant: {
+            contacts: false,
+            individualParticipants: false,
+            individualParticipantIds: false,
+            onlineResources: false,
+            participantName: true,
+            participantOtherName: true,
+            participantId: true,
+            participantRole: true,
+            participantRoleResponsibilities: true,
+            participantStatus: true,
+            penalties: false,
+            representing: true,
+            participantType: true,
+            person: {
+                addresses: false,
+                biographicalInformation: false,
+                birthDate: false,
+                contacts: false,
+                nationalityCode: true,
+                nativeFamilyName: false,
+                nativeGivenName: false,
+                onlineResources: false,
+                otherNames: true,
+                parentOrganisationId: false,
+                passportFamilyName: false,
+                passportGivenName: false,
+                personId: false,
+                personOtherIds: false,
+                previousNames: false,
+                sex: false,
+                standardFamilyName: true,
+                standardGivenName: true,
+                status: false,
+                tennisId: false,
+                wheelchair: true,
+            },
+        },
+    },
+};
+
+function getTournamentInfo(params) {
+    const { tournamentRecord } = params ?? {};
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
-    const tournamentInfo = (({ tournamentId, tournamentRank, tournamentStatus, formalName, tournamentName, promotionalName, onlineResources, localTimeZone, startDate, endDate, hostCountryCode, tournamentContacts, tournamentAddresses, }) => ({
+    const tournamentInfo = (({ tournamentId, tournamentRank, tournamentStatus, formalName, tournamentName, promotionalName, onlineResources, localTimeZone, startDate, endDate, hostCountryCode, venues, notes, updatedAt, }) => ({
         tournamentId,
         tournamentRank,
         tournamentStatus,
@@ -26699,12 +26773,31 @@ function getTournamentInfo({ tournamentRecord }) {
         startDate,
         endDate,
         hostCountryCode,
-        tournamentContacts,
-        tournamentAddresses,
+        venues,
+        notes,
+        updatedAt,
     }))(tournamentRecord);
+    const tournamentContacts = getParticipants({
+        participantFilters: { participantRoles: [ADMINISTRATION, OFFICIAL, MEDIA, MEDICAL, SECURITY] },
+        policyDefinitions: POLICY_PRIVACY_STAFF,
+        tournamentRecord,
+    }).participants;
+    if (tournamentContacts)
+        tournamentInfo.tournamentContacts = tournamentContacts;
+    const publishState = getPublishState({ tournamentRecord })?.publishState;
+    const publishedEventIds = publishState?.tournament?.status?.publishedEventIds || [];
+    const eventInfo = [];
+    for (const event of tournamentRecord.events || []) {
+        if (publishedEventIds.includes(event.eventId)) {
+            const info = extractEventInfo({ event }).eventInfo;
+            if (info)
+                eventInfo.push(info);
+        }
+    }
+    tournamentInfo.eventInfo = eventInfo;
     return {
-        ...SUCCESS,
         tournamentInfo: makeDeepCopy(tournamentInfo, false, true),
+        ...SUCCESS,
     };
 }
 
@@ -46890,313 +46983,6 @@ function addTournamentParticipants({ participantsProfile, tournamentRecord, even
     return { addedCount, ...SUCCESS };
 }
 
-const courtTemplate = () => ({
-    altitude: undefined,
-    courtId: undefined,
-    courtName: '',
-    courtDimensions: undefined,
-    latitude: undefined,
-    longitude: undefined,
-    surfaceCategory: undefined,
-    surfaceType: undefined,
-    surfacedDate: undefined,
-    dateAvailability: [],
-    onlineResources: [],
-    pace: undefined,
-    notes: undefined,
-});
-
-function getInt(value) {
-    return parseInt(value);
-}
-function validTimePeriod({ startTime = '', endTime = '' } = {}) {
-    if (!startTime || !endTime || !timeValidation.test(startTime) || !timeValidation.test(endTime))
-        return false;
-    const [startHour, startMinute] = startTime.split(':').map(getInt);
-    const [endHour, endMinute] = endTime.split(':').map(getInt);
-    if (endHour < startHour)
-        return false;
-    return startHour === endHour && endMinute < startMinute ? false : true;
-}
-function startTimeSort(a, b) {
-    const [startHourA, startMinuteA] = a.startTime.split(':').map(getInt);
-    const [startHourB, startMinuteB] = b.startTime.split(':').map(getInt);
-    if (startHourA < startHourB)
-        return -1;
-    if (startHourA > startHourB)
-        return 1;
-    if (startMinuteA < startMinuteB)
-        return -1;
-    if (startMinuteA > startMinuteB)
-        return 1;
-    return 0;
-}
-
-function validDateAvailability({ dateAvailability }) {
-    if (!dateAvailability)
-        return { error: MISSING_DATE_AVAILABILITY };
-    if (!Array.isArray(dateAvailability))
-        return { error: INVALID_DATE_AVAILABILITY };
-    const dateNote = 'Dates must be formated => YYYY-MM-DD';
-    const timeNote = 'Times must be 24 hour => 00:00';
-    for (const availability of dateAvailability) {
-        if (typeof availability !== 'object') {
-            return { error: INVALID_DATE_AVAILABILITY };
-        }
-        const { date, startTime, endTime, bookings = [] } = availability;
-        if (!startTime || !endTime) {
-            return { error: INVALID_DATE_AVAILABILITY };
-        }
-        if (date && !dateValidation.test(date)) {
-            return {
-                error: INVALID_DATE,
-                dateAvailability: { date },
-                info: dateNote,
-            };
-        }
-        if (!timeValidation.test(startTime)) {
-            return {
-                error: INVALID_TIME,
-                dateAvailability: { startTime },
-                info: timeNote,
-            };
-        }
-        if (!timeValidation.test(endTime)) {
-            return {
-                error: INVALID_TIME,
-                dateAvailability: { endTime },
-                info: timeNote,
-            };
-        }
-        if (startTime === endTime) {
-            return {
-                error: INVALID_TIME,
-                dateAvailability: { startTime, endTime },
-                info: 'startTime and endTime are equivalent',
-            };
-        }
-        if (!validTimePeriod({ startTime, endTime })) {
-            return {
-                error: INVALID_TIME,
-                dateAvailability: { startTime, endTime },
-                info: 'endTime must be after startTime',
-            };
-        }
-        if (bookings) {
-            if (!Array.isArray(bookings)) {
-                return { error: INVALID_BOOKINGS };
-            }
-            for (const booking of bookings) {
-                if (typeof booking !== 'object') {
-                    return { error: INVALID_BOOKINGS };
-                }
-                const { startTime, endTime } = booking;
-                if (!timeValidation.test(startTime)) {
-                    return {
-                        error: INVALID_TIME,
-                        booking: { startTime },
-                        info: timeNote,
-                    };
-                }
-                if (!timeValidation.test(endTime)) {
-                    return {
-                        error: INVALID_TIME,
-                        booking: { endTime },
-                        info: timeNote,
-                    };
-                }
-                if (startTime === endTime) {
-                    return {
-                        error: INVALID_TIME,
-                        dateAvailability: { startTime, endTime },
-                        info: 'startTime and endTime are equivalent',
-                    };
-                }
-                if (!validTimePeriod({ startTime, endTime })) {
-                    return {
-                        error: INVALID_TIME,
-                        dateAvailability: { startTime, endTime },
-                        info: 'endTime must be after startTime',
-                    };
-                }
-            }
-        }
-    }
-    return { valid: true };
-}
-
-function addCourt({ tournamentRecord, disableNotice, venueId, courtId, court }) {
-    const { venue } = findVenue({ tournamentRecord, venueId });
-    if (!venue)
-        return { error: VENUE_NOT_FOUND };
-    if (!venue.courts)
-        venue.courts = [];
-    const courtRecord = { ...courtTemplate(), venueId, courtId };
-    if (!courtRecord.courtId) {
-        courtRecord.courtId = UUID();
-    }
-    const courtExists = venue.courts.some((candidate) => candidate.courtId === courtRecord.courtId);
-    if (courtExists) {
-        return { error: COURT_EXISTS };
-    }
-    else {
-        const dateAvailability = (court?.dateAvailability || []).map((availabilty) => ({
-            ...availabilty,
-            date: extractDate(availabilty.date),
-            startTime: extractTime(availabilty.startTime),
-            endTime: extractTime(availabilty.endTime),
-            bookings: availabilty.bookings?.map(({ startTime, endTime, bookingType }) => ({
-                startTime: extractTime(startTime),
-                endTime: extractTime(endTime),
-                bookingType,
-            })),
-        }));
-        const attributes = Object.keys(courtRecord);
-        for (const attribute of attributes) {
-            if (court?.[attribute]) {
-                if (attribute === 'dateAvailability') {
-                    const result = validDateAvailability({ dateAvailability });
-                    if (!result.valid && result.error)
-                        return result;
-                    courtRecord.dateAvailability = dateAvailability;
-                }
-                else {
-                    courtRecord[attribute] = court[attribute];
-                }
-            }
-        }
-        const newCourt = courtRecord;
-        venue.courts.push(newCourt);
-        if (!disableNotice) {
-            addNotice({
-                payload: { venue, tournamentId: tournamentRecord.tournamentId },
-                topic: MODIFY_VENUE,
-                key: venue.venueId,
-            });
-        }
-        return { ...SUCCESS, court: makeDeepCopy(courtRecord), venueId };
-    }
-}
-function addCourts(params) {
-    const { tournamentRecord, venueId } = params;
-    if (typeof venueId !== 'string' || !venueId)
-        return { error: MISSING_VENUE_ID };
-    const tournamentRecords = params.tournamentRecords ??
-        (tournamentRecord && {
-            [tournamentRecord.tournamentId]: tournamentRecord,
-        }) ??
-        {};
-    const courtIds = [];
-    let success;
-    for (const tournamentRecord of Object.values(tournamentRecords)) {
-        const { venue } = findVenue({ tournamentRecord, venueId });
-        if (venue) {
-            const result = courtsAdd({ ...params, tournamentRecord });
-            for (const court of result?.courts ?? []) {
-                courtIds.push(court?.courtId);
-            }
-            if (result.error)
-                return result;
-            success = true;
-        }
-    }
-    return success ? { ...SUCCESS, courtIds } : { error: VENUE_NOT_FOUND };
-}
-function courtsAdd({ courtNameRoot = 'Court', dateAvailability = [], venueAbbreviationRoot, tournamentRecord, courtNames = [], courtTimings, courtsCount, startTime, courtIds, endTime, idPrefix, venueId, dates, }) {
-    if (!venueId)
-        return { error: MISSING_VENUE_ID };
-    const result = findVenue({ tournamentRecord, venueId });
-    if (result.error)
-        return result;
-    const { venue } = result;
-    if (!isNumeric(courtsCount) || !courtNames)
-        return { error: MISSING_COURTS_INFO };
-    courtsCount = courtsCount ?? courtNames.length;
-    const courts = generateRange(0, courtsCount).map((i) => {
-        const courtTiming = courtTimings?.[i];
-        const courtAvailability = courtTiming
-            ? dates.map((date) => ({
-                date: formatDate(date),
-                startTime,
-                endTime,
-                ...courtTiming,
-            }))
-            : dateAvailability;
-        if (courtTiming && startTime && endTime)
-            courtAvailability.push({ startTime, endTime });
-        return {
-            courtName: courtNames[i] ||
-                (venueAbbreviationRoot && venue?.venueAbbreviation && `${venue?.venueAbbreviation} ${i + 1}`) ||
-                `${courtNameRoot} ${i + 1}`,
-            dateAvailability: courtAvailability,
-        };
-    });
-    const mapResult = courts.map((court, i) => {
-        const courtId = courtIds?.pop() || (idPrefix && `${idPrefix}-${i + 1}`);
-        return addCourt({
-            disableNotice: true,
-            tournamentRecord,
-            courtId,
-            venueId,
-            court,
-        });
-    });
-    const courtRecords = mapResult.map((outcome) => outcome.court).filter(Boolean);
-    if (courtRecords.length !== courtsCount) {
-        return decorateResult({
-            info: 'not all courts could be generated',
-            result: { error: INVALID_VALUES },
-        });
-    }
-    if (venue)
-        addNotice({
-            payload: { venue, tournamentId: tournamentRecord.tournamentId },
-            topic: MODIFY_VENUE,
-            key: venue.venueId,
-        });
-    return { ...SUCCESS, courts: makeDeepCopy(courtRecords) };
-}
-
-function generateVenues({ tournamentRecord, venueProfiles, uuids }) {
-    const { startDate, endDate } = tournamentRecord;
-    const venueIds = [];
-    for (const [index, venueProfile] of venueProfiles.entries()) {
-        const { venueAbbreviation, venueId = uuids?.pop() ?? UUID(), dateAvailability, startTime = '07:00', endTime = '19:00', courtTimings, courtsCount, courtNames, venueName, idPrefix, courtIds, } = venueProfile;
-        const newVenue = {
-            venueName: venueName || `Venue ${index + 1}`,
-            venueAbbreviation,
-            venueId,
-        };
-        const result = addVenue({ tournamentRecord, venue: newVenue });
-        if (result.error)
-            return result;
-        venueIds.push(venueId);
-        const dates = generateDateRange(startDate, endDate);
-        const generatedDateAvailability = !Array.isArray(dateAvailability) &&
-            [{ startTime, endTime }].concat(dates.map((date) => ({
-                date: formatDate(date),
-                startTime,
-                endTime,
-            })));
-        const addResult = addCourts({
-            dateAvailability: dateAvailability || generatedDateAvailability,
-            tournamentRecord,
-            courtTimings,
-            courtsCount,
-            courtNames,
-            startTime,
-            idPrefix,
-            courtIds,
-            endTime,
-            venueId,
-            dates,
-        });
-        if (addResult.error)
-            return addResult;
-    }
-    return venueIds;
-}
-
 function getStageParticipantsCount({ drawProfiles, category, gender }) {
     const uniqueParticipantsCount = {};
     const stageParticipantsCount = drawProfiles?.reduce((stageParticipantsCount, drawProfile) => {
@@ -48687,6 +48473,313 @@ function generateEventWithDraw(params) {
     };
 }
 
+const courtTemplate = () => ({
+    altitude: undefined,
+    courtId: undefined,
+    courtName: '',
+    courtDimensions: undefined,
+    latitude: undefined,
+    longitude: undefined,
+    surfaceCategory: undefined,
+    surfaceType: undefined,
+    surfacedDate: undefined,
+    dateAvailability: [],
+    onlineResources: [],
+    pace: undefined,
+    notes: undefined,
+});
+
+function getInt(value) {
+    return parseInt(value);
+}
+function validTimePeriod({ startTime = '', endTime = '' } = {}) {
+    if (!startTime || !endTime || !timeValidation.test(startTime) || !timeValidation.test(endTime))
+        return false;
+    const [startHour, startMinute] = startTime.split(':').map(getInt);
+    const [endHour, endMinute] = endTime.split(':').map(getInt);
+    if (endHour < startHour)
+        return false;
+    return startHour === endHour && endMinute < startMinute ? false : true;
+}
+function startTimeSort(a, b) {
+    const [startHourA, startMinuteA] = a.startTime.split(':').map(getInt);
+    const [startHourB, startMinuteB] = b.startTime.split(':').map(getInt);
+    if (startHourA < startHourB)
+        return -1;
+    if (startHourA > startHourB)
+        return 1;
+    if (startMinuteA < startMinuteB)
+        return -1;
+    if (startMinuteA > startMinuteB)
+        return 1;
+    return 0;
+}
+
+function validDateAvailability({ dateAvailability }) {
+    if (!dateAvailability)
+        return { error: MISSING_DATE_AVAILABILITY };
+    if (!Array.isArray(dateAvailability))
+        return { error: INVALID_DATE_AVAILABILITY };
+    const dateNote = 'Dates must be formated => YYYY-MM-DD';
+    const timeNote = 'Times must be 24 hour => 00:00';
+    for (const availability of dateAvailability) {
+        if (typeof availability !== 'object') {
+            return { error: INVALID_DATE_AVAILABILITY };
+        }
+        const { date, startTime, endTime, bookings = [] } = availability;
+        if (!startTime || !endTime) {
+            return { error: INVALID_DATE_AVAILABILITY };
+        }
+        if (date && !dateValidation.test(date)) {
+            return {
+                error: INVALID_DATE,
+                dateAvailability: { date },
+                info: dateNote,
+            };
+        }
+        if (!timeValidation.test(startTime)) {
+            return {
+                error: INVALID_TIME,
+                dateAvailability: { startTime },
+                info: timeNote,
+            };
+        }
+        if (!timeValidation.test(endTime)) {
+            return {
+                error: INVALID_TIME,
+                dateAvailability: { endTime },
+                info: timeNote,
+            };
+        }
+        if (startTime === endTime) {
+            return {
+                error: INVALID_TIME,
+                dateAvailability: { startTime, endTime },
+                info: 'startTime and endTime are equivalent',
+            };
+        }
+        if (!validTimePeriod({ startTime, endTime })) {
+            return {
+                error: INVALID_TIME,
+                dateAvailability: { startTime, endTime },
+                info: 'endTime must be after startTime',
+            };
+        }
+        if (bookings) {
+            if (!Array.isArray(bookings)) {
+                return { error: INVALID_BOOKINGS };
+            }
+            for (const booking of bookings) {
+                if (typeof booking !== 'object') {
+                    return { error: INVALID_BOOKINGS };
+                }
+                const { startTime, endTime } = booking;
+                if (!timeValidation.test(startTime)) {
+                    return {
+                        error: INVALID_TIME,
+                        booking: { startTime },
+                        info: timeNote,
+                    };
+                }
+                if (!timeValidation.test(endTime)) {
+                    return {
+                        error: INVALID_TIME,
+                        booking: { endTime },
+                        info: timeNote,
+                    };
+                }
+                if (startTime === endTime) {
+                    return {
+                        error: INVALID_TIME,
+                        dateAvailability: { startTime, endTime },
+                        info: 'startTime and endTime are equivalent',
+                    };
+                }
+                if (!validTimePeriod({ startTime, endTime })) {
+                    return {
+                        error: INVALID_TIME,
+                        dateAvailability: { startTime, endTime },
+                        info: 'endTime must be after startTime',
+                    };
+                }
+            }
+        }
+    }
+    return { valid: true };
+}
+
+function addCourt({ tournamentRecord, disableNotice, venueId, courtId, court }) {
+    const { venue } = findVenue({ tournamentRecord, venueId });
+    if (!venue)
+        return { error: VENUE_NOT_FOUND };
+    if (!venue.courts)
+        venue.courts = [];
+    const courtRecord = { ...courtTemplate(), venueId, courtId };
+    if (!courtRecord.courtId) {
+        courtRecord.courtId = UUID();
+    }
+    const courtExists = venue.courts.some((candidate) => candidate.courtId === courtRecord.courtId);
+    if (courtExists) {
+        return { error: COURT_EXISTS };
+    }
+    else {
+        const dateAvailability = (court?.dateAvailability || []).map((availabilty) => ({
+            ...availabilty,
+            date: extractDate(availabilty.date),
+            startTime: extractTime(availabilty.startTime),
+            endTime: extractTime(availabilty.endTime),
+            bookings: availabilty.bookings?.map(({ startTime, endTime, bookingType }) => ({
+                startTime: extractTime(startTime),
+                endTime: extractTime(endTime),
+                bookingType,
+            })),
+        }));
+        const attributes = Object.keys(courtRecord);
+        for (const attribute of attributes) {
+            if (court?.[attribute]) {
+                if (attribute === 'dateAvailability') {
+                    const result = validDateAvailability({ dateAvailability });
+                    if (!result.valid && result.error)
+                        return result;
+                    courtRecord.dateAvailability = dateAvailability;
+                }
+                else {
+                    courtRecord[attribute] = court[attribute];
+                }
+            }
+        }
+        const newCourt = courtRecord;
+        venue.courts.push(newCourt);
+        if (!disableNotice) {
+            addNotice({
+                payload: { venue, tournamentId: tournamentRecord.tournamentId },
+                topic: MODIFY_VENUE,
+                key: venue.venueId,
+            });
+        }
+        return { ...SUCCESS, court: makeDeepCopy(courtRecord), venueId };
+    }
+}
+function addCourts(params) {
+    const { tournamentRecord, venueId } = params;
+    if (typeof venueId !== 'string' || !venueId)
+        return { error: MISSING_VENUE_ID };
+    const tournamentRecords = params.tournamentRecords ??
+        (tournamentRecord && {
+            [tournamentRecord.tournamentId]: tournamentRecord,
+        }) ??
+        {};
+    const courtIds = [];
+    let success;
+    for (const tournamentRecord of Object.values(tournamentRecords)) {
+        const { venue } = findVenue({ tournamentRecord, venueId });
+        if (venue) {
+            const result = courtsAdd({ ...params, tournamentRecord });
+            for (const court of result?.courts ?? []) {
+                courtIds.push(court?.courtId);
+            }
+            if (result.error)
+                return result;
+            success = true;
+        }
+    }
+    return success ? { ...SUCCESS, courtIds } : { error: VENUE_NOT_FOUND };
+}
+function courtsAdd({ courtNameRoot = 'Court', dateAvailability = [], venueAbbreviationRoot, tournamentRecord, courtNames = [], courtTimings, courtsCount, startTime, courtIds, endTime, idPrefix, venueId, dates, }) {
+    if (!venueId)
+        return { error: MISSING_VENUE_ID };
+    const result = findVenue({ tournamentRecord, venueId });
+    if (result.error)
+        return result;
+    const { venue } = result;
+    if (!isNumeric(courtsCount) || !courtNames)
+        return { error: MISSING_COURTS_INFO };
+    courtsCount = courtsCount ?? courtNames.length;
+    const courts = generateRange(0, courtsCount).map((i) => {
+        const courtTiming = courtTimings?.[i];
+        const courtAvailability = courtTiming
+            ? dates.map((date) => ({
+                date: formatDate(date),
+                startTime,
+                endTime,
+                ...courtTiming,
+            }))
+            : dateAvailability;
+        if (courtTiming && startTime && endTime)
+            courtAvailability.push({ startTime, endTime });
+        return {
+            courtName: courtNames[i] ||
+                (venueAbbreviationRoot && venue?.venueAbbreviation && `${venue?.venueAbbreviation} ${i + 1}`) ||
+                `${courtNameRoot} ${i + 1}`,
+            dateAvailability: courtAvailability,
+        };
+    });
+    const mapResult = courts.map((court, i) => {
+        const courtId = courtIds?.pop() || (idPrefix && `${idPrefix}-${i + 1}`);
+        return addCourt({
+            disableNotice: true,
+            tournamentRecord,
+            courtId,
+            venueId,
+            court,
+        });
+    });
+    const courtRecords = mapResult.map((outcome) => outcome.court).filter(Boolean);
+    if (courtRecords.length !== courtsCount) {
+        return decorateResult({
+            info: 'not all courts could be generated',
+            result: { error: INVALID_VALUES },
+        });
+    }
+    if (venue)
+        addNotice({
+            payload: { venue, tournamentId: tournamentRecord.tournamentId },
+            topic: MODIFY_VENUE,
+            key: venue.venueId,
+        });
+    return { ...SUCCESS, courts: makeDeepCopy(courtRecords) };
+}
+
+function generateVenues({ tournamentRecord, venueProfiles, uuids }) {
+    const { startDate, endDate } = tournamentRecord;
+    const venueIds = [];
+    for (const [index, venueProfile] of venueProfiles.entries()) {
+        const { venueAbbreviation, venueId = uuids?.pop() ?? UUID(), dateAvailability, startTime = '07:00', endTime = '19:00', courtTimings, courtsCount, courtNames, venueName, idPrefix, courtIds, } = venueProfile;
+        const newVenue = {
+            venueName: venueName || `Venue ${index + 1}`,
+            venueAbbreviation,
+            venueId,
+        };
+        const result = addVenue({ tournamentRecord, venue: newVenue });
+        if (result.error)
+            return result;
+        venueIds.push(venueId);
+        const dates = generateDateRange(startDate, endDate);
+        const generatedDateAvailability = !Array.isArray(dateAvailability) &&
+            [{ startTime, endTime }].concat(dates.map((date) => ({
+                date: formatDate(date),
+                startTime,
+                endTime,
+            })));
+        const addResult = addCourts({
+            dateAvailability: dateAvailability || generatedDateAvailability,
+            tournamentRecord,
+            courtTimings,
+            courtsCount,
+            courtNames,
+            startTime,
+            idPrefix,
+            courtIds,
+            endTime,
+            venueId,
+            dates,
+        });
+        if (addResult.error)
+            return addResult;
+    }
+    return venueIds;
+}
+
 const mockTournamentNames = [
     'Mock Tournament',
     'CourtHive Challenge',
@@ -50602,20 +50695,7 @@ function getAllEventData({ tournamentRecord, policyDefinitions }) {
     });
     const eventsData = events.map((event) => {
         const { eventId } = event;
-        const eventInfo = (({ eventId, eventName, eventType, eventLevel, surfaceCategory, matchUpFormat, category, gender, startDate, endDate, ballType, discipline, }) => ({
-            eventId,
-            eventName,
-            eventType,
-            eventLevel,
-            surfaceCategory,
-            matchUpFormat,
-            category,
-            gender,
-            startDate,
-            endDate,
-            ballType,
-            discipline,
-        }))(event);
+        const eventInfo = extractEventInfo({ event }).eventInfo;
         const scheduleTiming = getScheduleTiming({
             tournamentRecord,
             event,
@@ -50668,7 +50748,6 @@ var query = {
     getEventData: getEventData,
     getEventPublishStatus: getEventPublishStatus,
     getPublishState: getPublishState,
-    getTournamentPublishStatus: getTournamentPublishStatus,
     getVenueData: getVenueData
 };
 
@@ -50681,7 +50760,6 @@ var index$7 = {
     getEventData: getEventData,
     getEventPublishStatus: getEventPublishStatus,
     getPublishState: getPublishState,
-    getTournamentPublishStatus: getTournamentPublishStatus,
     getVenueData: getVenueData,
     mutate: mutate$4,
     publishEvent: publishEvent,