Merge branch 'main-qualifying-tieformat'

Author: CourtHive

documentation/docs/types/assets/drawDefinition.ts

@@ -5,26 +5,18 @@ export const drawDefinition = {
   drawOrder: '{\\"type\\":\\"number\\",\\"required\\":\\"false\\"}',
   drawRepresentativeIds:
     '{\\"type\\":\\"string\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\",\\"note\\":\\"participantId array\\"}',
-  drawStatus:
-    '{\\"type\\":\\"enum\\",\\"enum\\": \\"\\",\\"required\\":\\"true\\"}',
-  drawType:
-    '{\\"type\\":\\"enum\\",\\"enum\\": \\"\\",\\"required\\":\\"false\\"}',
-  entries:
-    '{\\"type\\":\\"object\\",\\"object\\":\\"entry\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\"}',
-  endDate:
-    '{\\"type\\":\\"string\\",\\"required\\":\\"true\\",\\"note\\":\\"\'YYYY-MM-DD\'\\"}',
-  links:
-    '{\\"type\\":\\"object\\",\\"object\\":\\"link\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\"}',
-  matchUps:
-    '{\\"type\\":\\"object\\",\\"object\\":\\"matchUp\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\"}',
+  drawStatus: '{\\"type\\":\\"enum\\",\\"enum\\": \\"\\",\\"required\\":\\"true\\"}',
+  drawType: '{\\"type\\":\\"enum\\",\\"enum\\": \\"\\",\\"required\\":\\"false\\"}',
+  entries: '{\\"type\\":\\"object\\",\\"object\\":\\"entry\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\"}',
+  endDate: '{\\"type\\":\\"string\\",\\"required\\":\\"true\\",\\"note\\":\\"\'YYYY-MM-DD\'\\"}',
+  links: '{\\"type\\":\\"object\\",\\"object\\":\\"link\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\"}',
+  matchUps: '{\\"type\\":\\"object\\",\\"object\\":\\"matchUp\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\"}',
   matchUpFormat:
     '{\\"type\\":\\"string\\",\\"required\\":\\"false\\",\\"note\\":\\"TODS matchup format, e.g. \'SET3-S:6/TB7\'\\"}',
-  startDate:
-    '{\\"type\\":\\"string\\",\\"required\\":\\"true\\",\\"note\\":\\"\'YYYY-MM-DD\'\\"}',
+  startDate: '{\\"type\\":\\"string\\",\\"required\\":\\"true\\",\\"note\\":\\"\'YYYY-MM-DD\'\\"}',
   structures:
     '{\\"type\\":\\"object\\",\\"object\\":\\"structure\\",\\"array\\":\\"true\\",\\"required\\":\\"false\\"}',
-  tieFormat:
-    '{\\"type\\":\\"object\\",\\"object\\":\\"tieFormat\\",\\"required\\":\\"false\\"}',
+  tieFormat: '{\\"type\\":\\"object\\",\\"object\\":\\"tieFormat\\",\\"required\\":\\"false\\"}',
 };
 
 export default drawDefinition;

src/assemblies/generators/drawDefinitions/drawTypes/eliminationTree.ts

@@ -1,8 +1,9 @@
-import { generateRange } from '@Tools/arrays';
 import { addFinishingRounds } from '../addFinishingRounds';
+import { generateRange } from '@Tools/arrays';
 import { isPowerOf2 } from '@Tools/math';
 import { buildRound } from '../buildRound';
 
+// Types
 import { MatchUp } from '@Types/tournamentTypes';
 
 type TreeMatchUpsArgs = {

src/assemblies/generators/drawDefinitions/drawTypes/generateQualifyingStructure.ts

@@ -1,15 +1,17 @@
 import { generateQualifyingLink } from '@Generators/drawDefinitions/links/generateQualifyingLink';
 import structureTemplate from '@Assemblies/generators/templates/structureTemplate';
+import { getAllStructureMatchUps } from '@Query/matchUps/getAllStructureMatchUps';
 import { getStructureGroups } from '@Query/structure/getStructureGroups';
 import { decorateResult } from '@Functions/global/decorateResult';
 import { coerceEven, isConvertableInteger } from '@Tools/math';
 import { addExtension } from '@Mutate/extensions/addExtension';
 import { generateRoundRobin } from './roundRobin/roundRobin';
+import { generateTieMatchUps } from '../tieMatchUps';
 import { constantToString } from '@Tools/strings';
 import { treeMatchUps } from './eliminationTree';
 
 // constants, fixtures and types
-import { DrawDefinition, DrawLink, DrawTypeUnion, Event, Structure } from '@Types/tournamentTypes';
+import { DrawDefinition, DrawLink, DrawTypeUnion, Event, Structure, TieFormat } from '@Types/tournamentTypes';
 import { POSITION, QUALIFYING, ROUND_ROBIN, WINNER } from '@Constants/drawDefinitionConstants';
 import POLICY_ROUND_NAMING_DEFAULT from '@Fixtures/policies/POLICY_ROUND_NAMING_DEFAULT';
 import { POLICY_TYPE_ROUND_NAMING } from '@Constants/policyConstants';
@@ -25,16 +27,19 @@ import {
 } from '@Constants/errorConditionConstants';
 
 type GenerateQualifyingStructureArgs = {
+  hasExistingDrawDefinition?: boolean;
   appliedPolicies?: PolicyDefinitions;
   qualifyingRoundNumber: number;
   drawDefinition: DrawDefinition;
   qualifyingPositions?: number;
   participantsCount?: number;
   targetStructureId: string;
+  qualifyingOnly?: boolean;
   drawType?: DrawTypeUnion;
   structureOptions?: any;
   matchUpFormat?: string;
   structureName?: string;
+  tieFormat?: TieFormat;
   structureId?: string;
   roundTarget: number;
   drawSize?: number;
@@ -73,16 +78,19 @@ export function generateQualifyingStructure(params: GenerateQualifyingStructureA
   let drawSize = params.drawSize ?? coerceEven(params.participantsCount);
 
   const {
+    hasExistingDrawDefinition,
     qualifyingRoundNumber,
     qualifyingPositions,
     targetStructureId,
     structureOptions,
     appliedPolicies,
+    qualifyingOnly,
     drawDefinition,
     matchUpFormat,
     structureName,
     structureId,
     roundTarget,
+    tieFormat,
     drawType,
     idPrefix,
     isMock,
@@ -139,12 +147,15 @@ export function generateQualifyingStructure(params: GenerateQualifyingStructureA
     const { maxRoundNumber /*, groupSize*/, structures, groupCount } = generateRoundRobin({
       structureName: structureName ?? qualifyingStructureName,
       structureId: structureId ?? uuids?.pop(),
+      hasExistingDrawDefinition,
       stage: QUALIFYING,
       structureOptions,
       appliedPolicies,
+      qualifyingOnly,
       stageSequence,
       matchUpType,
       roundTarget,
+      tieFormat,
       idPrefix,
       drawSize,
       isMock,
@@ -202,6 +213,14 @@ export function generateQualifyingStructure(params: GenerateQualifyingStructureA
       linkType,
     })?.link;
 
+  if (tieFormat) {
+    matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
+    matchUps?.forEach((matchUp) => {
+      const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
+      Object.assign(matchUp, { tieMatchUps, matchUpType });
+    });
+  }
+
   return {
     qualifyingDrawPositionsCount: drawSize,
     qualifiersCount,

src/assemblies/generators/drawDefinitions/drawTypes/generateQualifyingStructures.ts

@@ -1,4 +1,5 @@
 import { generateQualifyingLink } from '@Generators/drawDefinitions/links/generateQualifyingLink';
+import { getAllStructureMatchUps } from '@Query/matchUps/getAllStructureMatchUps';
 import structureTemplate from '@Generators/templates/structureTemplate';
 import { decorateResult } from '@Functions/global/decorateResult';
 import { coerceEven, isConvertableInteger } from '@Tools/math';
@@ -14,13 +15,15 @@ import { DrawLink, Structure, TieFormat } from '@Types/tournamentTypes';
 import { PolicyDefinitions, ResultType } from '@Types/factoryTypes';
 import { ROUND_TARGET } from '@Constants/extensionConstants';
 import { SUCCESS } from '@Constants/resultConstants';
+import { generateTieMatchUps } from '../tieMatchUps';
 
 type GenerateQualifyingStructuresArgs = {
   hasExistingDrawDefinition?: boolean;
   appliedPolicies?: PolicyDefinitions;
   qualifyingProfiles: any[];
   qualifyingOnly?: boolean;
   tieFormat?: TieFormat;
+  drawType?: string;
   idPrefix?: string;
   isMock?: boolean;
   uuids?: string[];
@@ -97,12 +100,15 @@ export function generateQualifyingStructures({
           structureName: structureProfile.structureName || qualifyingStructureName,
           structureId: structureId || uuids?.pop(),
           // qualifyingPositions,
+          hasExistingDrawDefinition,
           stage: QUALIFYING,
           structureOptions,
           appliedPolicies,
+          qualifyingOnly,
           stageSequence,
           matchUpType,
           roundTarget,
+          tieFormat,
           drawSize,
           idPrefix,
           isMock,
@@ -171,6 +177,14 @@ export function generateQualifyingStructures({
       finalQualifyingStructureId = structure.structureId;
       finalQualifyingRoundNumber = roundLimit;
 
+      if (tieFormat) {
+        matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
+        matchUps?.forEach((matchUp) => {
+          const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
+          Object.assign(matchUp, { tieMatchUps, matchUpType });
+        });
+      }
+
       structures.push(structure);
       stageSequence += 1;
     }

src/assemblies/generators/drawDefinitions/drawTypes/roundRobin/roundRobin.ts

@@ -9,20 +9,23 @@ import { UUID } from '@Tools/UUID';
 import { PlayoffAttributes, PolicyDefinitions, SeedingProfile, ResultType } from '@Types/factoryTypes';
 import { MAIN, ITEM, WIN_RATIO, CONTAINER } from '@Constants/drawDefinitionConstants';
 import { BYE, TO_BE_PLAYED } from '@Constants/matchUpStatusConstants';
-import { MatchUp, EventTypeUnion } from '@Types/tournamentTypes';
+import { MatchUp, EventTypeUnion, TieFormat } from '@Types/tournamentTypes';
 import { ROUND_TARGET } from '@Constants/extensionConstants';
 import { SUCCESS } from '@Constants/resultConstants';
 import { HydratedMatchUp } from '@Types/hydrated';
 
 type GenerateRoundRobinArgs = {
   playoffAttributes?: PlayoffAttributes;
+  hasExistingDrawDefinition?: boolean;
   appliedPolicies?: PolicyDefinitions;
   seedingProfile?: SeedingProfile;
+  matchUpType?: EventTypeUnion;
+  qualifyingOnly?: boolean;
   groupNameBase?: string;
   structureName?: string;
   stageSequence?: number;
   structureOptions?: any;
-  matchUpType?: EventTypeUnion;
+  tieFormat?: TieFormat;
   groupNames?: string[];
   roundTarget?: number;
   structureId?: string;
@@ -35,17 +38,20 @@ type GenerateRoundRobinArgs = {
 
 export function generateRoundRobin(params: GenerateRoundRobinArgs) {
   const {
+    hasExistingDrawDefinition,
     groupNameBase = 'Group',
     playoffAttributes,
     stageSequence = 1,
     structureOptions,
     appliedPolicies,
+    qualifyingOnly,
     seedingProfile,
     stage = MAIN,
     matchUpType,
     roundTarget,
     structureId,
     groupNames,
+    tieFormat,
     drawSize,
     idPrefix,
     isMock,
@@ -79,22 +85,27 @@ export function generateRoundRobin(params: GenerateRoundRobinArgs) {
 
     return structureTemplate({
       structureId: uuids?.pop(),
+      hasExistingDrawDefinition,
       structureType: ITEM,
       finishingPosition,
+      qualifyingOnly,
       structureOrder,
       structureName,
+      tieFormat,
       matchUps,
     });
   });
 
   const structure = structureTemplate({
     structureId: structureId ?? uuids?.pop(),
+    hasExistingDrawDefinition,
     structureType: CONTAINER,
     finishingPosition,
     seedingProfile,
     structureName,
     stageSequence,
     structures,
+    tieFormat,
     stage,
   });
 

src/assemblies/generators/drawDefinitions/generateAndPopulateRRplayoffStructures.ts

@@ -78,11 +78,7 @@ export function generateAndPopulateRRplayoffStructures(params) {
 
     if (tieFormat) {
       addedMatchUps.forEach((matchUp) => {
-        const { tieMatchUps } = generateTieMatchUps({
-          isMock: params.isMock,
-          tieFormat,
-          matchUp,
-        });
+        const { tieMatchUps } = generateTieMatchUps({ isMock: params.isMock, tieFormat, matchUp });
         Object.assign(matchUp, { tieMatchUps, matchUpType: TEAM_MATCHUP });
       });
     }

src/assemblies/generators/drawDefinitions/generateDrawDefinition/checkFormatScopeEquivalence.ts

@@ -2,6 +2,7 @@ import { setMatchUpMatchUpFormat } from '@Mutate/matchUps/matchUpFormat/setMatch
 import { checkTieFormat } from '@Mutate/tieFormat/checkTieFormat';
 
 export function checkFormatScopeEquivalence({
+  existingQualifyingStructures,
   tournamentRecord,
   drawDefinition,
   matchUpFormat,
@@ -23,7 +24,11 @@ export function checkFormatScopeEquivalence({
         const result = checkTieFormat({ tieFormat });
         if (result.error) return result;
 
-        drawDefinition.tieFormat = result.tieFormat ?? tieFormat;
+        const existingQualifyingTieFormats = existingQualifyingStructures?.every((structure) => structure.tieFormat);
+        if (!existingQualifyingStructures?.length || existingQualifyingTieFormats) {
+          // if there are no existing qualifying structures or if all existing qualifying structures have a tieFormat
+          drawDefinition.tieFormat = result.tieFormat ?? tieFormat;
+        }
       } else if (matchUpFormat) {
         const result = setMatchUpMatchUpFormat({
           tournamentRecord,

src/assemblies/generators/drawDefinitions/generateDrawDefinition/qualifyingGeneration.ts

@@ -10,6 +10,7 @@ import { POSITION, QUALIFYING } from '@Constants/drawDefinitionConstants';
 import { MISSING_VALUE } from '@Constants/errorConditionConstants';
 import { ResultType } from '@Types/factoryTypes';
 
+// only does stage perparation unless no qualifyingProfiles are provided and a qualifyingPlaceholder is necessary
 export function qualifyingGeneration(params): ResultType & { qualifyingConflicts?: any[] } {
   const {
     qualifyingPlaceholder,

src/assemblies/generators/drawDefinitions/generateDrawDefinition/setUpDrawGeneration.ts

@@ -16,9 +16,9 @@ export function setUpDrawGeneration(params): ResultType & {
 } {
   const {
     tournamentRecord,
-    matchUpFormat,
-    appliedPolicies,
     policyDefinitions,
+    appliedPolicies,
+    matchUpFormat,
     matchUpType,
     tieFormat,
     drawType,
@@ -30,6 +30,19 @@ export function setUpDrawGeneration(params): ResultType & {
     ? (event?.drawDefinitions?.find((d) => d.drawId === params.drawId) as DrawDefinition)
     : undefined;
 
+  // find existing MAIN structureId if existingDrawDefinition
+  const structureId = existingDrawDefinition?.structures?.find(
+    (structure) => structure.stage === MAIN && structure.stageSequence === 1,
+  )?.structureId;
+
+  const existingQualifyingStructures = existingDrawDefinition
+    ? existingDrawDefinition.structures?.filter((structure) => structure.stage === QUALIFYING)
+    : [];
+  const existingQualifyingPlaceholderStructureId =
+    existingQualifyingStructures?.length === 1 &&
+    !existingQualifyingStructures[0].matchUps?.length &&
+    existingQualifyingStructures[0].structureId;
+
   if (existingDrawDefinition && drawType !== existingDrawDefinition.drawType)
     existingDrawDefinition.drawType = drawType as DrawTypeUnion;
 
@@ -42,6 +55,7 @@ export function setUpDrawGeneration(params): ResultType & {
     });
 
   const equivalenceResult = checkFormatScopeEquivalence({
+    existingQualifyingStructures,
     tournamentRecord,
     drawDefinition,
     matchUpFormat,
@@ -54,18 +68,5 @@ export function setUpDrawGeneration(params): ResultType & {
   const attachmentResult = policyAttachment({ appliedPolicies, policyDefinitions, drawDefinition, stack });
   if (attachmentResult.error) return attachmentResult;
 
-  // find existing MAIN structureId if existingDrawDefinition
-  const structureId = existingDrawDefinition?.structures?.find(
-    (structure) => structure.stage === MAIN && structure.stageSequence === 1,
-  )?.structureId;
-
-  const existingQualifyingStructures = existingDrawDefinition
-    ? existingDrawDefinition.structures?.filter((structure) => structure.stage === QUALIFYING)
-    : [];
-  const existingQualifyingPlaceholderStructureId =
-    existingQualifyingStructures?.length === 1 &&
-    !existingQualifyingStructures[0].matchUps?.length &&
-    existingQualifyingStructures[0].structureId;
-
   return { drawDefinition, structureId, existingDrawDefinition, existingQualifyingPlaceholderStructureId };
 }

src/assemblies/generators/drawDefinitions/generateDrawTypeAndModifyDrawDefinition.ts

@@ -151,11 +151,7 @@ export function generateDrawTypeAndModifyDrawDefinition(params: GenerateDrawType
     // if there were exiting matchUps, exclude them from this step
     matchUps?.forEach((matchUp) => {
       if (!existingMatchUpIds.includes(matchUp.matchUpId)) {
-        const { tieMatchUps } = generateTieMatchUps({
-          tieFormat,
-          matchUp,
-          isMock,
-        });
+        const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
         Object.assign(matchUp, { tieMatchUps, matchUpType });
       }
     });