tods-competition-factory 0.85.0 → 0.86.2

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.85.0';
+  return '0.86.2';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -22692,7 +22692,7 @@ function addParticipantContext(params) {
     return relevantParticipantIds.some(obj => !targetParticipantIds || targetParticipantIds.includes(obj.relevantParticipantId)) ? relevantParticipantIds : [];
   };
 
-  allTournamentParticipants.forEach(participant => {
+  params.withGroupings && allTournamentParticipants.forEach(participant => {
     if (participant.participantType === GROUP) {
       var _participant$individu;
 
@@ -22861,14 +22861,6 @@ function addParticipantContext(params) {
           }));
         }
       });
-      const {
-        matchUps
-      } = allEventMatchUps({
-        tournamentRecord,
-        nextMatchUps: true,
-        inContext: true,
-        event
-      });
       const drawDetails = Object.assign({}, ...(event.drawDefinitions || []).map(drawDefinition => {
         var _getPositionAssignmen, _getPositionAssignmen2, _getPositionAssignmen3, _getPositionAssignmen4;
 
@@ -22905,11 +22897,23 @@ function addParticipantContext(params) {
           }
         };
       }));
-      matchUps === null || matchUps === void 0 ? void 0 : matchUps.forEach(matchUp => processMatchUp({
-        matchUp,
-        drawDetails,
-        eventType
-      }));
+
+      if (event.eventType === TEAM$3 || // for TEAM events some individual attributes can only be derived by processing
+      params.withScheduleItems || params.scheduleAnalysis || params.withStatistics || params.withOpponents || params.withMatchUps) {
+        const {
+          matchUps
+        } = allEventMatchUps({
+          nextMatchUps: true,
+          tournamentRecord,
+          inContext: true,
+          event
+        });
+        matchUps === null || matchUps === void 0 ? void 0 : matchUps.forEach(matchUp => processMatchUp({
+          matchUp,
+          drawDetails,
+          eventType
+        }));
+      }
     });
   } // tournamentParticipants is an array of FILTERED participants
   // whereas allTournamentParticipants = params.tournamentRecord.participants
@@ -22924,6 +22928,16 @@ function addParticipantContext(params) {
       participantIdMap
     });
 
+    if (params.withSignInStatus) {
+      const {
+        timeItem
+      } = getTimeItem({
+        itemType: SIGN_IN_STATUS,
+        element: participant
+      });
+      participant.signedIn = !!((timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemValue) === SIGNED_IN);
+    }
+
     if (params.withScheduleItems) {
       participant.scheduleItems = scheduleItems;
     }
@@ -23585,6 +23599,7 @@ function getEventEntries({
 
 function getTournamentParticipants({
   participantFilters = {},
+  withSignInStatus,
   convertExtensions,
   policyDefinitions,
   withScheduleItems,
@@ -23605,7 +23620,9 @@ function getTournamentParticipants({
   if (!tournamentRecord.participants) return {
     error: MISSING_PARTICIPANTS
   };
-  let tournamentParticipants = tournamentRecord.participants.map(participant => makeDeepCopy(participant, convertExtensions, true));
+  let tournamentParticipants = tournamentRecord.participants.map( // (participant) => makeDeepCopy(participant, convertExtensions, true)
+  participant => makeDeepCopy(participant, convertExtensions) // removed until Mongo/Mongoose issues resolved
+  );
   if (typeof participantFilters !== 'object') return {
     error: INVALID_OBJECT,
     participantFilters
@@ -23631,7 +23648,7 @@ function getTournamentParticipants({
     participantFilters,
     participants: tournamentParticipants
   });
-  const addContext = withScheduleItems || scheduleAnalysis || withStatistics || withGroupings || withOpponents || withMatchUps || withEvents || withDraws || withISO;
+  const addContext = withSignInStatus || withScheduleItems || scheduleAnalysis || withStatistics || withGroupings || withOpponents || withMatchUps || withEvents || withDraws || withISO;
   let participantIdsWithConflicts;
 
   if (addContext) {
@@ -23640,6 +23657,7 @@ function getTournamentParticipants({
       tournamentParticipants,
       participantFilters,
       withScheduleItems,
+      withSignInStatus,
       tournamentRecord,
       scheduleAnalysis,
       withStatistics,
@@ -26324,7 +26342,7 @@ function generateBookings({
   };
   const dateScheduledMatchUps = matchUps === null || matchUps === void 0 ? void 0 : matchUps.filter(matchUp => hasSchedule(matchUp) && (!scheduleDate || matchUp.schedule.scheduledDate === scheduleDate));
   const relevantMatchUps = dateScheduledMatchUps === null || dateScheduledMatchUps === void 0 ? void 0 : dateScheduledMatchUps.filter(matchUp => !venueIds.length || venueIds.includes(matchUp.schedule.venueId));
-  const bookings = dateScheduledMatchUps === null || dateScheduledMatchUps === void 0 ? void 0 : dateScheduledMatchUps.map(({
+  const bookings = relevantMatchUps === null || relevantMatchUps === void 0 ? void 0 : relevantMatchUps.map(({
     eventId,
     schedule,
     matchUpFormat
@@ -26491,21 +26509,26 @@ function jinnScheduler({
     modifications: schedulingProfileModifications
   } = getSchedulingProfile$1({
     tournamentRecords
-  });
+  }); // round robin structures contain other structures and the scheduler
+  // needs to reference the containing structure by contained structureIds
+
   const containedStructureIds = Object.assign({}, ...Object.values(tournamentRecords).map(tournamentRecord => getContainedStructures({
     tournamentRecord
-  }).containedStructures));
+  }).containedStructures)); // ensure all scheduleDates are valid date strings
+
   const validScheduleDates = scheduleDates.map(scheduleDate => {
     if (!isValidDateString(scheduleDate)) return;
     return extractDate(scheduleDate);
-  }).filter(Boolean);
-  const profileDates = schedulingProfile.map(dateSchedulingProfile => dateSchedulingProfile.scheduleDate).map(scheduleDate => isValidDateString(scheduleDate) && extractDate(scheduleDate)).filter(scheduleDate => scheduleDate && (!scheduleDates.length || validScheduleDates.includes(scheduleDate)));
+  }).filter(Boolean); // filter out any invalid scheduleDates in schedulingProfile
+
+  const profileDates = schedulingProfile.map(dateSchedulingProfile => dateSchedulingProfile.scheduleDate).map(scheduleDate => isValidDateString(scheduleDate) && extractDate(scheduleDate)).filter(scheduleDate => scheduleDate && (!scheduleDates.length || validScheduleDates.includes(scheduleDate))); // if no valid profileDates remain throw an error
 
   if (!profileDates.length) {
     return {
       error: NO_VALID_DATES
     };
-  }
+  } // if array of clearScheduleDates, clear all matchUps on scheduledDates
+
 
   if (clearScheduleDates && !dryRun) {
     const scheduledDates = Array.isArray(clearScheduleDates) ? clearScheduleDates : undefined;
@@ -26523,9 +26546,10 @@ function jinnScheduler({
   const {
     matchUps
   } = allCompetitionMatchUps({
-    tournamentRecords,
-    nextMatchUps: true
-  });
+    nextMatchUps: true,
+    tournamentRecords
+  }); // build up a map of all matchUp dependencies
+
   const {
     matchUpDependencies
   } = getMatchUpDependencies({
@@ -26543,7 +26567,8 @@ function jinnScheduler({
   } = getPersonRequests({
     requestType: DO_NOT_SCHEDULE,
     tournamentRecords
-  });
+  }); // filter out any dates in schedulingProfile which have been excluded and sort
+
   const dateSchedulingProfiles = schedulingProfile.filter(dateschedulingProfile => {
     const scheduleDate = extractDate(dateschedulingProfile === null || dateschedulingProfile === void 0 ? void 0 : dateschedulingProfile.scheduleDate);
     return profileDates.includes(scheduleDate);
@@ -42661,24 +42686,30 @@ const publishingGovernor = {
   unPublishEvent
 };
 
-function analyzeDraws(tournamentRecord) {
+function analyzeDraws({
+  tournamentRecord
+}) {
   var _tournamentRecord$eve;
 
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
   const drawsAnalysis = {
-    noPositionsAssigned: 0,
-    // no positions assigned
-    positionsNoOutcomes: 0,
+    positionsNoOutcomes: [],
     // all positions assigned and no outcomes
-    matchPlayDraws: 0,
-    // only first round has active matchUps; some unassigned positions
-    canBePruned: 0,
+    canBePruned: [],
     // partially assigned positions with outcomes => drawSizes can be reduced
-    draws: []
+    matchPlay: [],
+    // only first round has active matchUps; some unassigned positions
+    inactive: [],
+    drawAnalysis: {}
   };
   const drawDefinitions = (_tournamentRecord$eve = tournamentRecord.events) === null || _tournamentRecord$eve === void 0 ? void 0 : _tournamentRecord$eve.map(event => event === null || event === void 0 ? void 0 : event.drawDefinitions).flat().filter(Boolean);
   drawDefinitions.forEach(drawDefinition => {
+    let positionsAssignedCount = 0;
+    let matchUpsWithWinningSideCount = 0;
     const structures = (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.structures) || [];
-    const structureData = structures.map(structure => {
+    const structuresData = structures.map(structure => {
       const {
         stage,
         stageSequence,
@@ -42691,6 +42722,16 @@ function analyzeDraws(tournamentRecord) {
         drawDefinition,
         structure
       });
+      const matchUpsWithWinningSide = inContextStructureMatchUps === null || inContextStructureMatchUps === void 0 ? void 0 : inContextStructureMatchUps.filter(({
+        winningSide
+      }) => winningSide);
+      const winningSideCount = matchUpsWithWinningSide.filter(Boolean).length || 0;
+      matchUpsWithWinningSideCount += winningSideCount;
+      const maxWinningSideFirstRoundPosition = Math.max(matchUpsWithWinningSide.filter(({
+        roundNumber
+      }) => roundNumber === 1).map(({
+        roundPosition
+      }) => roundPosition));
       const {
         positionAssignments
       } = getPositionAssignments$1({
@@ -42699,6 +42740,7 @@ function analyzeDraws(tournamentRecord) {
       const positionsAssigned = positionAssignments === null || positionAssignments === void 0 ? void 0 : positionAssignments.filter(({
         participantId
       }) => participantId);
+      positionsAssignedCount += positionsAssigned.length;
       const unassignedPositionsCount = ((positionAssignments === null || positionAssignments === void 0 ? void 0 : positionAssignments.length) || 0) - ((positionsAssigned === null || positionsAssigned === void 0 ? void 0 : positionsAssigned.length) || 0);
       const {
         roundMatchUps,
@@ -42708,13 +42750,16 @@ function analyzeDraws(tournamentRecord) {
       } = getRoundMatchUps$1({
         matchUps: inContextStructureMatchUps
       });
-      const activeRounds = Object.keys(roundProfile).filter(roundNumber => !roundProfile[roundNumber].inactiveRound);
+      const activeRounds = Object.keys(roundProfile).filter(roundNumber => !roundProfile[roundNumber].inactiveRound).map(roundNumber => parseInt(roundNumber));
+      const inactiveRounds = Object.keys(roundProfile).filter(roundNumber => roundProfile[roundNumber].inactiveRound).map(roundNumber => parseInt(roundNumber));
       const inactiveStructure = Object.values(roundProfile).every(profile => profile.inactiveRound);
       return {
         positionsAssignedCount: (positionsAssigned === null || positionsAssigned === void 0 ? void 0 : positionsAssigned.length) || 0,
+        maxWinningSideFirstRoundPosition,
         unassignedPositionsCount,
         inactiveStructure,
         maxMatchUpsCount,
+        inactiveRounds,
         roundMatchUps,
         activeRounds,
         roundNumbers,
@@ -42725,16 +42770,35 @@ function analyzeDraws(tournamentRecord) {
         stage
       };
     });
-    const mainStructure = structureData.find(data => data.orderNumber === 2 && data.stageSequence === 1);
-    const isMatchPlay = mainStructure.activeRounds.length === 1 && parseInt(mainStructure.activeRounds[0]) === 1;
-    const canBePruned = mainStructure.activeRounds.length && mainStructure.roundProfile[1].inActiveCount;
-    if (isMatchPlay) drawsAnalysis.matchPlayDraws += 1;
-    if (canBePruned) drawsAnalysis.canBePruned += 1;
-    drawsAnalysis.draws.push({
-      drawId: drawDefinition.drawId,
-      structureData,
-      isMatchPlay
+    const mainStructure = structuresData.find(data => data.orderNumber === 2 && data.stageSequence === 1);
+    const activeStructuresCount = structuresData.filter(({
+      inactiveStructure
+    }) => !inactiveStructure).length;
+    const {
+      links
+    } = getStructureLinks({
+      drawDefinition,
+      structureId: mainStructure.structureId
     });
+    const isMatchPlay = parseInt(mainStructure.activeRounds[0]) === 1 && mainStructure.activeRounds.length === 1 && activeStructuresCount === 1;
+    const inactiveDraw = structuresData === null || structuresData === void 0 ? void 0 : structuresData.every(({
+      inactiveStructure
+    }) => inactiveStructure);
+    const canBePruned = !links.length && mainStructure.activeRounds.length && (mainStructure.roundProfile[1].inactiveCount || mainStructure.inactiveRounds.length);
+    const drawId = drawDefinition.drawId;
+    if (positionsAssignedCount && !matchUpsWithWinningSideCount) drawsAnalysis.positionsNoOutcomes.push(drawId);
+    if (inactiveDraw) drawsAnalysis.inactive.push(drawId);
+    if (isMatchPlay) drawsAnalysis.matchPlay.push(drawId);
+    if (canBePruned) drawsAnalysis.canBePruned.push(drawId);
+    const drawAnalysis = {
+      matchUpsWithWinningSideCount,
+      positionsAssignedCount,
+      structuresData,
+      inactiveDraw,
+      isMatchPlay,
+      drawId
+    };
+    drawsAnalysis.drawAnalysis[drawId] = drawAnalysis;
   });
   return { ...SUCCESS,
     drawsAnalysis
@@ -42752,7 +42816,7 @@ function checkIsDual(tournamentRecord) {
   const drawDefinition = (event === null || event === void 0 ? void 0 : (_event$drawDefinition = event.drawDefinitions) === null || _event$drawDefinition === void 0 ? void 0 : _event$drawDefinition.length) === 1 && event.drawDefinitions[0];
   const structure = (drawDefinition === null || drawDefinition === void 0 ? void 0 : (_drawDefinition$struc = drawDefinition.structures) === null || _drawDefinition$struc === void 0 ? void 0 : _drawDefinition$struc.length) === 1 && drawDefinition.structures[0];
   const twoDrawPositions = (structure === null || structure === void 0 ? void 0 : (_structure$positionAs = structure.positionAssignments) === null || _structure$positionAs === void 0 ? void 0 : _structure$positionAs.length) === 2;
-  return event.tieFormat && twoTeams && twoDrawPositions;
+  return !!(event.tieFormat && twoTeams && twoDrawPositions);
 }
 
 function analyzeTournament({
@@ -42763,7 +42827,9 @@ function analyzeTournament({
   };
   const {
     drawsAnalysis
-  } = analyzeDraws(tournamentRecord);
+  } = analyzeDraws({
+    tournamentRecord
+  });
   const analysis = {
     isDual: checkIsDual(tournamentRecord),
     drawsAnalysis
@@ -42870,6 +42936,7 @@ const tournamentGovernor = {
   addNotes,
   removeNotes,
   analyzeTournament,
+  analyzeDraws,
   setTournamentName,
   setTournamentNotes,
   setTournamentEndDate,
@@ -46552,6 +46619,179 @@ function deleteAdHocMatchUps(params) {
   return deleteAdHocMatchUps$1(params);
 }
 
+function resetDrawDefinition({
+  drawDefinition,
+  removeScheduling
+}) {
+  if (!drawDefinition) return {
+    error: MISSING_DRAW_DEFINITION
+  }; // for matchups in all structures:
+  // remove all drawPositions which are not first round or fed
+  // remove all extensions
+  // if removeScheudling, remove all scheduling timeItems
+  // for all structures which are NOT QUALIFYING or MAIN { stageSequence: 1 }
+  // remove all positionAssignments that are not BYE
+
+  const matchUpsMap = getMatchUpsMap({
+    drawDefinition
+  });
+
+  const getRawMatchUp = matchUpId => {
+    var _matchUpsMap$drawMatc;
+
+    return matchUpsMap === null || matchUpsMap === void 0 ? void 0 : (_matchUpsMap$drawMatc = matchUpsMap.drawMatchUps) === null || _matchUpsMap$drawMatc === void 0 ? void 0 : _matchUpsMap$drawMatc.find(matchUp => matchUp.matchUpId === matchUpId);
+  };
+
+  for (const structure of drawDefinition.structures || []) {
+    const {
+      positionAssignments,
+      stage,
+      stageSequence
+    } = structure; // reset positionAssignments and seedAssignments where appropriate
+
+    if (positionAssignments && (stageSequence !== 1 || ![QUALIFYING, MAIN].includes(stage))) {
+      structure.positionAssignments = positionAssignments.map(assignment => {
+        delete assignment.participantId;
+        return assignment;
+      });
+      structure.seedAssignments = [];
+    }
+
+    const {
+      matchUps: inContextMatchUps
+    } = getAllStructureMatchUps({
+      inContext: true,
+      matchUpsMap,
+      structure
+    }); // reset all matchUps to initial state
+
+    for (const inContextMatchUp of inContextMatchUps) {
+      var _matchUp$timeItems;
+
+      const {
+        matchUpId,
+        roundNumber,
+        sides
+      } = inContextMatchUp;
+      const matchUp = getRawMatchUp(matchUpId);
+      delete matchUp.extensions;
+      delete matchUp.notes;
+
+      if (matchUp.matchUpStatus !== BYE) {
+        matchUp.matchUpStatus = TO_BE_PLAYED;
+        delete matchUp.matchUpStatusCodes;
+        delete matchUp.matchUpFormat;
+        delete matchUp.winningSide;
+        delete matchUp.score;
+      }
+
+      if (roundNumber && roundNumber > 1 && matchUp.drawPositions) {
+        const fedDrawPositions = sides === null || sides === void 0 ? void 0 : sides.map(({
+          drawPosition,
+          participantFed
+        }) => !participantFed && drawPosition).filter(Boolean);
+        matchUp.drawPositions = matchUp.drawPositions.map(drawPosition => !fedDrawPositions.includes(drawPosition) ? drawPosition : undefined);
+      }
+
+      if (removeScheduling) {
+        delete matchUp.timeItems;
+      } else if ((_matchUp$timeItems = matchUp.timeItems) !== null && _matchUp$timeItems !== void 0 && _matchUp$timeItems.length) {
+        matchUp.timeItems = matchUp.timeItems.filter(timeItem => ![ASSIGN_COURT, ASSIGN_VENUE, ASSIGN_OFFICIAL, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem.itemType));
+      }
+
+      modifyMatchUpNotice({
+        drawDefinition,
+        matchUp
+      });
+    }
+  }
+
+  const structureIds = (drawDefinition.structures || []).map(({
+    structureId
+  }) => structureId);
+  modifyDrawNotice({
+    drawDefinition,
+    structureIds
+  });
+  return { ...SUCCESS
+  };
+}
+
+function pruneDrawDefinition({
+  tournamentRecord,
+  drawDefinition,
+  drawId
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!drawDefinition) return {
+    error: MISSING_DRAW_DEFINITION
+  };
+  const {
+    drawsAnalysis
+  } = analyzeDraws({
+    tournamentRecord
+  });
+
+  if (drawsAnalysis.canBePruned.includes(drawId)) {
+    const isMatchPlay = drawsAnalysis.matchPlay.includes(drawId);
+    const drawAnalysis = drawsAnalysis.drawAnalysis[drawId];
+    const {
+      structures: [mainStructure]
+    } = getDrawStructures({
+      drawDefinition,
+      stage: MAIN,
+      stageSequence: 1
+    });
+    const structureData = drawAnalysis.structuresData.find(({
+      structureId
+    }) => mainStructure.structureId === structureId);
+    const matchUps = mainStructure.matchUps || [];
+    const relevantMatchUps = matchUps.sort((a, b) => a.roundPosition - b.roundPosition).filter(({
+      roundNumber
+    }) => !structureData.inactiveRounds.includes(roundNumber));
+    const relevantMatchUpIds = relevantMatchUps.map(getMatchUpId);
+    const deletedMatchUpIds = matchUps.map(getMatchUpId).filter(matchUpId => !relevantMatchUpIds.includes(matchUpId)); // only ifMatchPlay can the positionAssignments be reallocated
+
+    if (isMatchPlay) {
+      const matchPlayMatchUps = relevantMatchUps.sort((a, b) => a.roundPosition - b.roundPosition).filter(({
+        roundNumber
+      }) => !structureData.inactiveRounds.includes(roundNumber)).filter(({
+        winningSide
+      }) => !isMatchPlay || winningSide);
+      const matchPlayMatchUpIds = matchPlayMatchUps.map(getMatchUpId);
+      const matchUpIdsToDelete = relevantMatchUpIds.filter(matchUpId => !matchPlayMatchUpIds.includes(matchUpId));
+      deletedMatchUpIds.push(...matchUpIdsToDelete);
+      const existingDrawPositionPairings = matchPlayMatchUps.map(({
+        drawPositions
+      }) => drawPositions);
+      const existingDrawPositions = existingDrawPositionPairings.flat();
+      const drawPositionsMap = Object.assign({}, ...existingDrawPositions.map((drawPosition, i) => ({
+        [drawPosition]: i + 1
+      })));
+      matchPlayMatchUps.forEach(matchUp => matchUp.drawPositions = matchUp.drawPositions.map(drawPosition => drawPositionsMap[drawPosition]));
+      const updatedPositionAssignments = mainStructure.positionAssignments.filter(assignment => existingDrawPositions.includes(assignment.drawPosition)).map(assignment => {
+        assignment.drawPosition = drawPositionsMap[assignment.drawPosition];
+        return assignment;
+      });
+      mainStructure.positionAssignments = updatedPositionAssignments;
+      mainStructure.matchUps = matchPlayMatchUps;
+    }
+
+    deleteMatchUpsNotice({
+      drawDefinition,
+      matchUpIds: deletedMatchUpIds
+    });
+    modifyDrawNotice({
+      drawDefinition
+    });
+  }
+
+  return { ...SUCCESS
+  };
+}
+
 /**
  *
  * @param {object} orderedDrawIdsMap - required - mapping of ALL present drawIds => { [drawId]: drawOrder }
@@ -47001,6 +47241,8 @@ const eventGovernor = {
   deleteFlightAndFlightDraw,
   generateFlightProfile,
   attachFlightProfile,
+  resetDrawDefinition,
+  pruneDrawDefinition,
   updateDrawIdsOrder,
   getFlightProfile,
   getScaledEntries,
@@ -47162,8 +47404,8 @@ function getParticipantSignInStatus({
   const {
     timeItem
   } = getTimeItem({
-    element: participant,
-    itemType: SIGN_IN_STATUS
+    itemType: SIGN_IN_STATUS,
+    element: participant
   });
   return timeItem && timeItem.itemValue === SIGNED_IN && SIGNED_IN;
 }