tods-competition-factory 0.93.2 → 0.96.0

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.93.2';
+  return '0.96.0';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -1321,13 +1321,6 @@ const validTimeString = /^((0[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?)([.,]
 const dateValidation = /^([0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]))([ T](0[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?)?([.,][0-9]{3})?Z?$/;
 const timeValidation = /^([0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]))?([ T]?(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?)?([.,][0-9]{3})?Z?$/;
 
-/*
-import {
-  INVALID_DATE,
-  INVALID_TIME_ZONE,
-} from '../constants/errorConditionConstants';
-*/
-
 function isDateObject(value) {
   if (typeof value !== 'object' || Array.isArray(value)) {
     return false;
@@ -1398,15 +1391,18 @@ function isDate(dateArg) {
   return t && !isNaN(t.valueOf());
 }
 function dateRange(startDt, endDt) {
-  const startDate = new Date(startDt);
-  const endDate = new Date(endDt);
+  if (!isValidDateString(startDt) || !isValidDateString(endDt)) return [];
+  const startDateString = extractDate(startDt) + 'T00:00';
+  const endDateString = extractDate(endDt) + 'T00:00';
+  const startDate = new Date(startDateString);
+  const endDate = new Date(endDateString);
   const error = isDate(endDate) && isDate(startDate) && isValidDateRange(startDate, endDate) ? false : true;
   const between = [];
   let iterations = 0;
 
   if (!error) {
-    const currentDate = offsetDate(startDate);
-    const end = offsetDate(endDate);
+    const currentDate = startDate;
+    const end = endDate;
 
     while (currentDate <= end && iterations < 300) {
       iterations += 1; // must be a *new* Date otherwise it is an array of the same object
@@ -1416,10 +1412,10 @@ function dateRange(startDt, endDt) {
     }
   }
 
-  return between;
+  return between.map(date => formatDate(date));
 
   function isValidDateRange(minDate, maxDate) {
-    return offsetDate(minDate) <= offsetDate(maxDate);
+    return minDate <= maxDate;
   }
 } // matches valid ISO date string
 
@@ -3890,7 +3886,7 @@ function generateTieMatchUpScore({
   tieFormat,
   matchUp
 }) {
-  var _tieFormat, _tieFormat2;
+  var _tieFormat, _tieFormat2, _tieFormat3;
 
   if (!Array.isArray(sideAdjustments) || sideAdjustments.length !== 2 || isNaN(sideAdjustments.reduce((a, b) => a + b))) {
     return {
@@ -3914,7 +3910,18 @@ function generateTieMatchUpScore({
   };
   const sideTieValues = [0, 0];
   const tieMatchUps = (matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieMatchUps) || [];
-  const collectionDefinitions = ((_tieFormat = tieFormat) === null || _tieFormat === void 0 ? void 0 : _tieFormat.collectionDefinitions) || [];
+  const collectionDefinitions = ((_tieFormat = tieFormat) === null || _tieFormat === void 0 ? void 0 : _tieFormat.collectionDefinitions) || []; // set up to handle groupValue
+
+  const collectionGroups = ((_tieFormat2 = tieFormat) === null || _tieFormat2 === void 0 ? void 0 : _tieFormat2.collectionGroups) || [];
+  const groupValueGroups = Object.assign({}, ...collectionGroups.filter(group => (group === null || group === void 0 ? void 0 : group.groupValue) && (group === null || group === void 0 ? void 0 : group.groupNumber)).map(group => ({
+    [group.groupNumber]: { ...group,
+      allGroupMatchUpsCompleted: true,
+      matchUpsCount: 0,
+      sideWins: [0, 0],
+      values: [0, 0]
+    }
+  })));
+  const groupValueNumbers = Object.keys(groupValueGroups);
 
   for (const collectionDefinition of collectionDefinitions) {
     const collectionMatchUps = tieMatchUps.filter(matchUp => matchUp.collectionId === collectionDefinition.collectionId); // keep track of the values derived from matchUps
@@ -3926,12 +3933,14 @@ function generateTieMatchUpScore({
     const allCollectionMatchUpsCompleted = collectionMatchUps.every(matchUp => completedMatchUpStatuses.includes(matchUp.matchUpStatus));
     const {
       collectionValueProfile,
+      collectionGroupNumber,
       collectionValue,
       matchUpValue,
       winCriteria,
       scoreValue,
       setValue
     } = collectionDefinition;
+    const belongsToValueGroup = collectionGroupNumber && groupValueNumbers.includes(collectionGroupNumber);
 
     if (matchUpValue) {
       collectionMatchUps.forEach(matchUp => {
@@ -3972,11 +3981,12 @@ function generateTieMatchUpScore({
       });
     }
 
+    const sideWins = [0, 0];
+    collectionMatchUps.forEach(matchUp => {
+      if (matchUp.winningSide) sideWins[matchUp.winningSide - 1] += 1;
+    });
+
     if (collectionValue) {
-      const sideWins = [0, 0];
-      collectionMatchUps.forEach(matchUp => {
-        if (matchUp.winningSide) sideWins[matchUp.winningSide - 1] += 1;
-      });
       let collectionWinningSide;
 
       if (winCriteria !== null && winCriteria !== void 0 && winCriteria.aggregateValue) {
@@ -3994,12 +4004,63 @@ function generateTieMatchUpScore({
         }, undefined);
       }
 
-      if (collectionWinningSide) sideCollectionValues[collectionWinningSide - 1] += collectionValue;
+      if (collectionWinningSide) {
+        if (belongsToValueGroup) {
+          groupValueGroups[collectionGroupNumber].values[collectionWinningSide - 1] += collectionValue;
+        } else {
+          sideCollectionValues[collectionWinningSide - 1] += collectionValue;
+        }
+      }
     } else {
-      sideCollectionValues = sideMatchUpValues;
+      if (belongsToValueGroup) {
+        groupValueGroups[collectionGroupNumber].values[0] += sideMatchUpValues[0] || 0;
+        groupValueGroups[collectionGroupNumber].values[1] += sideMatchUpValues[1] || 0;
+      } else {
+        sideCollectionValues = sideMatchUpValues;
+      }
     }
 
-    sideCollectionValues.forEach((sideCollectionValue, i) => sideTieValues[i] += sideCollectionValue);
+    if (!belongsToValueGroup) {
+      sideCollectionValues.forEach((sideCollectionValue, i) => sideTieValues[i] += sideCollectionValue);
+    } else {
+      groupValueGroups[collectionGroupNumber].sideWins[0] += sideWins[0] || 0;
+      groupValueGroups[collectionGroupNumber].sideWins[1] += sideWins[1] || 0;
+      groupValueGroups[collectionGroupNumber].allGroupMatchUpsCompleted = groupValueGroups[collectionGroupNumber].allGroupMatchUpsCompleted && allCollectionMatchUpsCompleted;
+      groupValueGroups[collectionGroupNumber].matchUpsCount += collectionMatchUps.length;
+    }
+  } // process each relevant group for groupValue
+
+
+  for (const groupNumber of groupValueNumbers) {
+    const group = groupValueGroups[groupNumber];
+    let {
+      allGroupMatchUpsCompleted,
+      groupValue,
+      matchUpCount,
+      sideWins,
+      winCriteria,
+      values
+    } = group;
+    let groupWinningSide;
+
+    if (winCriteria !== null && winCriteria !== void 0 && winCriteria.aggregateValue) {
+      if (allGroupMatchUpsCompleted && values[0] !== values[1]) {
+        groupWinningSide = values[0] > values[1] ? 1 : 2;
+      }
+    } else if (winCriteria !== null && winCriteria !== void 0 && winCriteria.valueGoal) {
+      groupWinningSide = values.reduce((winningSide, side, i) => {
+        return side >= winCriteria.valueGoal ? i + 1 : winningSide;
+      }, undefined);
+    } else {
+      const winGoal = Math.floor(matchUpCount / 2) + 1;
+      groupWinningSide = sideWins.reduce((winningSide, side, i) => {
+        return side >= winGoal ? i + 1 : winningSide;
+      }, undefined);
+    }
+
+    if (groupWinningSide) {
+      sideTieValues[groupWinningSide - 1] += groupValue;
+    }
   }
 
   const sideScores = sideTieValues.map((sideTieValue, i) => sideTieValue + sideAdjustments[i]);
@@ -4012,7 +4073,7 @@ function generateTieMatchUpScore({
 
   let winningSide;
 
-  if ((_tieFormat2 = tieFormat) !== null && _tieFormat2 !== void 0 && _tieFormat2.winCriteria) {
+  if ((_tieFormat3 = tieFormat) !== null && _tieFormat3 !== void 0 && _tieFormat3.winCriteria) {
     const {
       valueGoal,
       aggregateValue
@@ -26710,14 +26771,17 @@ function clearScheduledMatchUps$1({
     tournamentRecord,
     inContext: false
   });
+  let clearedScheduleCount = 0;
 
   for (const matchUp of matchUps) {
     if (relevantMatchUpIds.includes(matchUp.matchUpId)) {
       matchUp.timeItems = (matchUp.timeItems || []).filter(timeItem => ![ASSIGN_COURT, ASSIGN_VENUE, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType));
+      clearedScheduleCount += 1;
     }
   }
 
-  return { ...SUCCESS
+  return { ...SUCCESS,
+    clearedScheduleCount
   };
 }
 
@@ -43499,63 +43563,180 @@ function setTournamentNotes({
     element: tournamentRecord,
     notes
   });
-} // TODO: check for matchUps that must be unscheduled with change in date
-// TODO: check all courts in all venues for dateAvailability that is outside of tournament date range
-
-function setTournamentStartDate({
+}
+function setTournamentCategories({
   tournamentRecord,
-  startDate
+  categories
 }) {
   if (!tournamentRecord) return {
     error: MISSING_TOURNAMENT_RECORD
   };
-  if (!dateValidation.test(startDate)) return {
-    error: INVALID_DATE
+  categories = (categories || []).filter(category => {
+    return category.categoryName && category.type;
+  });
+  tournamentRecord.tournamentCategories = categories;
+  return SUCCESS;
+}
+
+function updateCourtAvailability({
+  tournamentRecord
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
   };
+  const {
+    startDate,
+    endDate
+  } = tournamentRecord;
+  const tournamentDates = dateRange(startDate, endDate);
+  const courts = [];
 
-  if (tournamentRecord.startDate && new Date(startDate) > new Date(tournamentRecord.startDate)) ;
+  for (const venue of tournamentRecord.venues || []) {
+    var _venue$courts;
 
-  if (tournamentRecord.endDate && new Date(startDate) > new Date(tournamentRecord.endDate)) {
-    tournamentRecord.endDate = startDate;
+    if (venue !== null && venue !== void 0 && (_venue$courts = venue.courts) !== null && _venue$courts !== void 0 && _venue$courts.length) courts.push(...venue.courts);
   }
 
-  tournamentRecord.startDate = startDate;
-  return SUCCESS;
-} // TODO: check for matchUps that must be unscheduled with change in date
-// TODO: check all courts in all venues for dateAvailability that is outside of tournament date range
+  for (const court of courts) {
+    const {
+      startTime,
+      endTime
+    } = court.dateAvailability.reduce((extents, availability) => {
+      const startMinutes = timeStringMinutes(extents.startTime);
+      const endMinutes = timeStringMinutes(extents.endTime);
+      if (availability.startTime && timeStringMinutes(availability.startTime) < startMinutes) extents.startTime = availability.startTime;
+      if (availability.endTime && timeStringMinutes(availability.endTime) > endMinutes) extents.endTime = availability.endTime;
+      return extents;
+    }, {
+      startTime: '08:00',
+      endTime: '18:00'
+    });
+    const updatedDateAvailability = tournamentDates.map(date => {
+      const existing = court.dateAvailability.find(availability => availability.date === date);
+      return existing || {
+        date,
+        startTime,
+        endTime
+      };
+    });
+    court.dateAvailability = updatedDateAvailability;
+  }
 
-function setTournamentEndDate({
+  return { ...SUCCESS
+  };
+}
+
+function setTournamentDates({
   tournamentRecord,
+  startDate,
   endDate
 }) {
+  var _removeInvalidSchedul;
+
   if (!tournamentRecord) return {
     error: MISSING_TOURNAMENT_RECORD
   };
-  if (!dateValidation.test(endDate)) return {
+  if (startDate && !dateValidation.test(startDate) || endDate && !dateValidation.test(endDate)) return {
     error: INVALID_DATE
   };
+  if (!startDate && !endDate) return {
+    error: MISSING_DATE
+  };
+  if (endDate && startDate && new Date(endDate) < new Date(startDate)) return {
+    error: INVALID_VALUES
+  };
+  let checkScheduling; // if start has moved closer to end or end has moved closer to start, check for scheduling issues
+
+  if (startDate && tournamentRecord.startDate && new Date(startDate) > new Date(tournamentRecord.startDate) || endDate && tournamentRecord.endDate && new Date(endDate) < new Date(tournamentRecord.endDate)) {
+    checkScheduling = true;
+  }
 
-  if (tournamentRecord.endDate && new Date(endDate) < new Date(tournamentRecord.endDate)) ;
+  if (startDate) tournamentRecord.startDate = startDate;
+  if (endDate) tournamentRecord.endDate = endDate; // if there is a startDate specified after current endDate, endDate must be set to startDate
+
+  if (startDate && tournamentRecord.endDate && new Date(startDate) > new Date(tournamentRecord.endDate)) {
+    tournamentRecord.endDate = startDate;
+  } // if there is a endDate specified before current startDate, startDate must be set to endDate
 
-  if (tournamentRecord.startDate && new Date(endDate) < new Date(tournamentRecord.startDate)) {
+
+  if (endDate && tournamentRecord.startDate && new Date(endDate) < new Date(tournamentRecord.startDate)) {
     tournamentRecord.startDate = endDate;
   }
 
-  tournamentRecord.endDate = endDate;
-  return SUCCESS;
-}
-function setTournamentCategories({
+  const unscheduledMatchUpIds = checkScheduling && ((_removeInvalidSchedul = removeInvalidScheduling({
+    tournamentRecord
+  })) === null || _removeInvalidSchedul === void 0 ? void 0 : _removeInvalidSchedul.unscheduledMatchUpIds);
+  updateCourtAvailability({
+    tournamentRecord
+  });
+  return { ...SUCCESS,
+    unscheduledMatchUpIds
+  };
+} // TODO: check all courts in all venues for dateAvailability that is outside of tournament date range
+
+function setTournamentStartDate({
   tournamentRecord,
-  categories
+  startDate
 }) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  categories = (categories || []).filter(category => {
-    return category.categoryName && category.type;
+  return setTournamentDates({
+    tournamentRecord,
+    startDate
   });
-  tournamentRecord.tournamentCategories = categories;
-  return SUCCESS;
+} // TODO: check all courts in all venues for dateAvailability that is outside of tournament date range
+
+function setTournamentEndDate({
+  tournamentRecord,
+  endDate
+}) {
+  return setTournamentDates({
+    tournamentRecord,
+    endDate
+  });
+} // unschedule scheduled matchUps that fall outside of tournament dates
+
+function removeInvalidScheduling({
+  tournamentRecord
+}) {
+  const {
+    matchUps
+  } = allTournamentMatchUps({
+    tournamentRecord
+  });
+  const startDate = tournamentRecord.startDate && new Date(tournamentRecord.startDate);
+  const endDate = tournamentRecord.endDate && new Date(tournamentRecord.endDate);
+  const invalidScheduledDates = [];
+  const invalidSchedulingMatchUpIds = [];
+
+  for (const matchUp of matchUps) {
+    const {
+      schedule,
+      matchUpId
+    } = matchUp;
+    if (!schedule) continue;
+
+    if (schedule.scheduledDate) {
+      const scheduledDate = new Date(schedule.scheduledDate);
+
+      if (startDate && scheduledDate < startDate || endDate && scheduledDate > endDate) {
+        invalidSchedulingMatchUpIds.push(matchUpId);
+        if (!invalidScheduledDates.includes(schedule.scheduledDate)) invalidScheduledDates.push(schedule.scheduledDate);
+      }
+    }
+  }
+
+  if (invalidScheduledDates.length) {
+    const result = clearScheduledMatchUps$1({
+      scheduledDates: invalidScheduledDates,
+      tournamentRecord
+    });
+    if (!result.clearedScheduleCount) return {
+      error: 'schedule not cleared'
+    };
+  }
+
+  return {
+    unscheduledMatchUpIds: invalidSchedulingMatchUpIds
+  };
 }
 
 const tournamentGovernor = {
@@ -43565,6 +43746,7 @@ const tournamentGovernor = {
   analyzeDraws,
   setTournamentName,
   setTournamentNotes,
+  setTournamentDates,
   setTournamentEndDate,
   setTournamentStartDate,
   setTournamentCategories,