feat: ✨ support groupTotalGamesPlayed in tally policies

Author: CourtHive

src/fixtures/policies/POLICY_ROUND_ROBIN_TALLY_DEFAULT.ts

@@ -4,6 +4,7 @@ export const POLICY_ROUND_ROBIN_TALLY_DEFAULT = {
   [POLICY_TYPE_ROUND_ROBIN_TALLY]: {
     policyName: 'Default Round Robin Tally',
     groupOrderKey: 'matchUpsWon', // possible to group by tieMatchUpsWon, tieSinglesWon, tieDoublesWon, matchUpsWon, pointsWon, gamesWon, setsWon, gamesPct, setsPct, pointsPct, matchUpsPct
+    groupTotalGamesPlayed: false, // optional - when true will calculate % of games won based on total group games played rather than participant games played
     groupTotalSetsPlayed: false, // optional - when true will calculate % of sets won based on total group sets played rather than participant sets played
     headToHead: { disabled: false },
     tallyDirectives: [
@@ -12,17 +13,17 @@ export const POLICY_ROUND_ROBIN_TALLY_DEFAULT = {
       // with { idsFilter: false } the ratio is calculated from all group matchUps
       // with { idsFilter: true } the ratio is calculated from matchUps including tied participants
       // any attribute/idsFilter combination can be selectively disabled for Head to Head calculations
-      { attribute: 'matchUpsPct', idsFilter: false },
+      { attribute: 'matchUpsPct', idsFilter: false, groupTotals: false },
       { attribute: 'allDefaults', reversed: true, idsFilter: false }, // reversed: true => reverses default which is greatest to least
       { attribute: 'defaults', reversed: true, idsFilter: false },
       { attribute: 'walkovers', reversed: true, idsFilter: false },
       { attribute: 'retirements', reversed: true, idsFilter: false },
-      { attribute: 'setsPct', idsFilter: false },
-      { attribute: 'gamesPct', idsFilter: false },
+      { attribute: 'setsPct', idsFilter: false, groupTotals: false },
+      { attribute: 'gamesPct', idsFilter: false, groupTotals: false },
       { attribute: 'pointsPct', idsFilter: false },
-      { attribute: 'matchUpsPct', idsFilter: true },
-      { attribute: 'setsPct', idsFilter: true },
-      { attribute: 'gamesPct', idsFilter: true },
+      { attribute: 'matchUpsPct', idsFilter: true, groupTotals: false },
+      { attribute: 'setsPct', idsFilter: true, groupTotals: false },
+      { attribute: 'gamesPct', idsFilter: true, groupTotals: false },
       { attribute: 'pointsPct', idsFilter: true },
     ],
     disqualifyDefaults: true, // disqualified participants are pushed to the bottom of the group order

src/query/matchUps/roundRobinTally/calculatePercentages.ts

@@ -1,6 +1,14 @@
 import { parse } from '@Helpers/matchUpFormatCode/parse';
 
-export function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy, perPlayer, totalSets }) {
+export function calculatePercentages({
+  participantResults,
+  groupingTotal,
+  matchUpFormat,
+  tallyPolicy,
+  totalGames,
+  perPlayer,
+  totalSets,
+}) {
   const parsedGroupMatchUpFormat = (matchUpFormat && parse(matchUpFormat)) || {};
   const bestOfGames = parsedGroupMatchUpFormat.bestOf;
   const bracketSetsToWin = (bestOfGames && Math.ceil(bestOfGames / 2)) || 1;
@@ -10,9 +18,10 @@ export function calculatePercentages({ participantResults, matchUpFormat, tallyP
   Object.keys(participantResults).forEach((participantId) => {
     const setsWon = participantResults[participantId].setsWon;
     const setsLost = participantResults[participantId].setsLost;
-    const setsTotal = tallyPolicy?.groupTotalSetsPlayed
-      ? totalSets
-      : perPlayer * (bracketSetsToWin || 0) || setsWon + setsLost;
+    const setsTotal =
+      tallyPolicy?.groupTotalSetsPlayed || groupingTotal === 'setsPct'
+        ? totalSets
+        : perPlayer * (bracketSetsToWin || 0) || setsWon + setsLost;
     let setsPct = Math.round((setsWon / setsTotal) * precision) / precision;
     if (setsPct === Infinity || isNaN(setsPct)) setsPct = setsTotal;
 
@@ -31,7 +40,10 @@ export function calculatePercentages({ participantResults, matchUpFormat, tallyP
     const gamesWon = participantResults[participantId].gamesWon || 0;
     const gamesLost = participantResults[participantId].gamesLost || 0;
     const minimumExpectedGames = (perPlayer || 0) * (bracketSetsToWin || 0) * (bracketGamesForSet || 0);
-    const gamesTotal = Math.max(minimumExpectedGames, gamesWon + gamesLost);
+    const gamesTotal =
+      tallyPolicy?.groupTotalGamesPlayed || groupingTotal === 'gamesPct'
+        ? totalGames
+        : Math.max(minimumExpectedGames, gamesWon + gamesLost);
     let gamesPct = Math.round((gamesWon / gamesTotal) * precision) / precision;
     if (gamesPct === Infinity || isNaN(gamesPct)) gamesPct = 0;
 

src/query/matchUps/roundRobinTally/getGroupOrder.ts

@@ -205,6 +205,7 @@ function processAttribute({
   disableHeadToHead,
   participantIds,
   matchUpFormat,
+  groupTotals,
   tallyPolicy,
   attribute,
   idsFilter,
@@ -213,6 +214,7 @@ function processAttribute({
 }) {
   const { participantResults } = getParticipantResults({
     participantIds: idsFilter && participantIds,
+    groupingTotal: groupTotals && attribute,
     matchUpFormat,
     tallyPolicy,
     matchUps,
@@ -290,11 +292,12 @@ function groupSubSort({ participantResults, disableHeadToHead, participantIds, m
 
   if (excludedDirectives.length) report.push({ excludedDirectives, participantIds });
 
-  filteredDirectives.every(({ attribute, reversed, idsFilter, disableHeadToHead }) => {
+  filteredDirectives.every(({ attribute, reversed, idsFilter, groupTotals, disableHeadToHead }) => {
     result = processAttribute({
       disableHeadToHead,
       participantIds,
       matchUpFormat,
+      groupTotals,
       tallyPolicy,
       attribute,
       idsFilter,

src/query/matchUps/roundRobinTally/getParticipantResults.ts

@@ -14,6 +14,7 @@ type GetParticipantResultsArgs = {
   matchUps: HydratedMatchUp[];
   participantIds?: string[];
   pressureRating?: string;
+  groupingTotal?: string; // attribute being processed for group totals
   matchUpFormat?: string;
   perPlayer?: number;
   tallyPolicy?: any;
@@ -22,6 +23,7 @@ type GetParticipantResultsArgs = {
 export function getParticipantResults({
   participantIds,
   pressureRating,
+  groupingTotal,
   matchUpFormat,
   tallyPolicy,
   perPlayer,
@@ -42,14 +44,25 @@ export function getParticipantResults({
     );
   });
 
-  const allSets = filteredMatchUps?.flatMap(({ score, tieMatchUps }) =>
+  const allSetsCount = filteredMatchUps?.flatMap(({ score, tieMatchUps }) =>
     tieMatchUps
       ? tieMatchUps
           .filter(({ matchUpStatus }) => !excludeMatchUpStatuses.includes(matchUpStatus))
           .flatMap(({ score }) => score?.sets?.length ?? 0)
       : (score?.sets?.length ?? 0),
   );
-  const totalSets = allSets?.reduce((a, b) => a + b, 0);
+  const totalSets = allSetsCount?.reduce((a, b) => a + b, 0);
+
+  const getGames = (score) =>
+    score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0) + (set?.side2Score ?? 0), 0) ?? 0;
+  const allGamesCount = filteredMatchUps?.flatMap(({ score, tieMatchUps }) =>
+    tieMatchUps
+      ? tieMatchUps
+          .filter(({ matchUpStatus }) => !excludeMatchUpStatuses.includes(matchUpStatus))
+          .flatMap(({ score }) => getGames(score))
+      : getGames(score),
+  );
+  const totalGames = allGamesCount?.reduce((a, b) => a + b, 0);
 
   for (const matchUp of filteredMatchUps ?? []) {
     const { matchUpStatus, tieMatchUps, tieFormat, score, winningSide, sides } = matchUp;
@@ -200,10 +213,10 @@ export function getParticipantResults({
       }
     }
 
-    const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
-    const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
-
     if (manualGamesOverride) {
+      const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
+      const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
+
       const side1participantId = sides?.find(({ sideNumber }) => sideNumber === 1)?.participantId;
       const side2participantId = sides?.find(({ sideNumber }) => sideNumber === 2)?.participantId;
 
@@ -224,8 +237,10 @@ export function getParticipantResults({
 
   calculatePercentages({
     participantResults,
+    groupingTotal,
     matchUpFormat,
     tallyPolicy,
+    totalGames,
     perPlayer,
     totalSets,
   });

src/query/matchUps/roundRobinTally/tallyParticipantResults.ts

@@ -89,8 +89,8 @@ export function tallyParticipantResults({
     participantResults,
     participantsCount,
     matchUpFormat,
-    tallyPolicy,
     subOrderMap,
+    tallyPolicy,
   });
 
   if (pressureRating) addPressureOrder({ participantResults });

src/tests/mutations/drawDefinitions/drawTypeSpecific/tallyPolicy.test.ts

@@ -3,6 +3,9 @@ import mocksEngine from '@Assemblies/engines/mock';
 import tournamentEngine from '@Engines/syncEngine';
 import { expect, test } from 'vitest';
 
+// Constants
+import { ROUND_ROBIN } from '@Constants/drawDefinitionConstants';
+
 test('roundRobinTally policy can specify tally by games only', () => {
   // prettier-ignore
   const mockProfile: any = {
@@ -24,8 +27,8 @@ test('roundRobinTally policy can specify tally by games only', () => {
 
     drawProfiles: [
       {
-        drawType: 'ROUND_ROBIN',
         matchUpFormat: 'SET1-S:T20',
+        drawType: ROUND_ROBIN,
         drawSize: 4,
       },
     ],
@@ -53,3 +56,35 @@ test('roundRobinTally policy can specify tally by games only', () => {
     expect([expectation - 1, expectation].includes(parseInt(GEMscore?.toString()?.slice(0, 2)))).toEqual(true);
   });
 });
+
+test('roundRobinTally policy can specify groupTotalGamesPlayed and groupTotalSetsPlayed', () => {
+  const mockProfile: any = {
+    policyDefinitions: { roundRobinTally: { groupTotalGamesPlayed: true, groupTotalSetsPlayed: true } },
+    drawProfiles: [{ drawType: ROUND_ROBIN, drawSize: 4 }],
+    tournamentName: 'group total games and sets',
+  };
+
+  mocksEngine.generateTournamentRecord({
+    completeAllMatchUps: true,
+    setState: true,
+    ...mockProfile,
+  });
+
+  const { matchUps } = tournamentEngine.allTournamentMatchUps();
+
+  const { participantResults } = tallyParticipantResults({
+    policyDefinitions: mockProfile.policyDefinitions,
+    matchUpFormat: mockProfile.matchUpFormat,
+    matchUps,
+  });
+
+  let gamesPctTotal = 0;
+  let setsPctTotal = 0;
+  Object.values(participantResults).forEach((result: any) => {
+    const { setsPct, gamesPct = 0 } = result;
+    gamesPctTotal += gamesPct;
+    setsPctTotal += setsPct;
+  });
+  expect(Math.round(gamesPctTotal)).toEqual(1);
+  expect(Math.round(setsPctTotal)).toEqual(1);
+});