tods-competition-factory 2.1.3 → 2.1.5

package/dist/tods-competition-factory.d.ts

@@ -2679,13 +2679,6 @@ declare function luckyLoserDrawPositionAssignment(params: any): ResultType | {
     };
 };
 
-declare function alternateDrawPositionAssignment(params: any): ResultType | {
-    error: {
-        message: string;
-        code: string;
-    };
-};
-
 type ShiftRoundsArgs = {
     drawDefinition: DrawDefinition;
     targetRoundNumber: number;
@@ -2718,6 +2711,19 @@ declare function qualifierDrawPositionAssignment(params: any): ResultType | {
     };
 };
 
+declare function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }: {
+    alternateParticipantId: any;
+    tournamentRecord: any;
+    drawDefinition: any;
+    drawPosition: any;
+    structureId: any;
+}): ResultType | {
+    error: {
+        message: string;
+        code: string;
+    };
+};
+
 declare function removeDrawPositionAssignment(params: any): ResultType & {
     participantId?: string;
 };
@@ -4951,6 +4957,13 @@ declare function generateFlightProfile(params: GenerateFlightProfileArgs): {
     error?: ErrorType;
 };
 
+declare function generateStatCrew(params: any): (ResultType & {
+    valid?: boolean | undefined;
+}) | {
+    success: boolean;
+    xml: any;
+};
+
 type GenerateLineUpsArgs = {
     useDefaultEventRanking?: boolean;
     tournamentRecord: Tournament;
@@ -5048,10 +5061,11 @@ declare const index$g_generateFlightProfile: typeof generateFlightProfile;
 declare const index$g_generateLineUps: typeof generateLineUps;
 declare const index$g_generateQualifyingStructure: typeof generateQualifyingStructure;
 declare const index$g_generateSeedingScaleItems: typeof generateSeedingScaleItems;
+declare const index$g_generateStatCrew: typeof generateStatCrew;
 declare const index$g_generateVoluntaryConsolation: typeof generateVoluntaryConsolation;
 declare const index$g_roundRobinGroups: typeof roundRobinGroups;
 declare namespace index$g {
-  export { index$g_drawMatic as drawMatic, garman$1 as garman, index$g_generateAdHocMatchUps as generateAdHocMatchUps, index$g_generateAdHocRounds as generateAdHocRounds, index$g_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures, index$g_generateCourts as generateCourts, index$g_generateDrawDefinition as generateDrawDefinition, index$g_generateDrawMaticRound as generateDrawMaticRound, index$g_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks, index$g_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition, index$g_generateFlightProfile as generateFlightProfile, index$g_generateLineUps as generateLineUps, index$g_generateQualifyingStructure as generateQualifyingStructure, index$g_generateSeedingScaleItems as generateSeedingScaleItems, index$g_generateVoluntaryConsolation as generateVoluntaryConsolation, index$g_roundRobinGroups as roundRobinGroups };
+  export { index$g_drawMatic as drawMatic, garman$1 as garman, index$g_generateAdHocMatchUps as generateAdHocMatchUps, index$g_generateAdHocRounds as generateAdHocRounds, index$g_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures, index$g_generateCourts as generateCourts, index$g_generateDrawDefinition as generateDrawDefinition, index$g_generateDrawMaticRound as generateDrawMaticRound, index$g_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks, index$g_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition, index$g_generateFlightProfile as generateFlightProfile, index$g_generateLineUps as generateLineUps, index$g_generateQualifyingStructure as generateQualifyingStructure, index$g_generateSeedingScaleItems as generateSeedingScaleItems, index$g_generateStatCrew as generateStatCrew, index$g_generateVoluntaryConsolation as generateVoluntaryConsolation, index$g_roundRobinGroups as roundRobinGroups };
 }
 
 declare function isValidMatchUpFormat({ matchUpFormat }: {
@@ -6787,6 +6801,7 @@ type GetParticipantsArgs = {
     scheduleAnalysis?: ScheduleAnalysis;
     policyDefinitions?: PolicyDefinitions;
     withPotentialMatchUps?: boolean;
+    returnParticipantMap?: boolean;
     contextProfile?: ContextProfile;
     tournamentRecord: Tournament;
     withRankingProfile?: boolean;
@@ -6796,6 +6811,7 @@ type GetParticipantsArgs = {
     withTeamMatchUps?: boolean;
     withScaleValues?: boolean;
     usePublishState?: boolean;
+    returnMatchUps?: boolean;
     withStatistics?: boolean;
     withOpponents?: boolean;
     withMatchUps?: boolean;
@@ -6812,6 +6828,7 @@ declare function getParticipants(params: GetParticipantsArgs): {
     };
     participantIdsWithConflicts?: string[];
     participants?: HydratedParticipant[];
+    missingParticipantIds?: string[];
     participantMap?: ParticipantMap;
     derivedEventInfo?: any;
     derivedDrawInfo?: any;
@@ -7373,10 +7390,7 @@ declare function analyzeTournament({ tournamentRecord }: {
         code: string;
     };
 } | {
-    analysis: {
-        isDual: boolean;
-        drawsAnalysis: any;
-    };
+    analysis: any;
     success: boolean;
     error?: undefined;
 };

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.3';
+    return '2.1.5';
 }
 
 function isFunction(obj) {
@@ -174,6 +174,10 @@ const DRAW_POSITION_ACTIVE = {
     message: 'drawPosition is active',
     code: 'ERR_ACTIVE_DRAW_POSITION',
 };
+const DRAW_POSITION_OCCUPIED = {
+    message: 'drawPosition is occupied',
+    code: 'ERR_OCCUPIED_DRAW_POSITION',
+};
 const INVALID_DRAW_POSITION = {
     message: 'Invlid drawPosition',
     code: 'ERR_INVALID_DRAW_POSITION',
@@ -5697,7 +5701,7 @@ function getTimeItem(params) {
         const bDate = new Date(b.createdAt || undefined).getTime();
         return aDate - bDate;
     });
-    const timeItem = filteredSorted.pop();
+    const timeItem = makeDeepCopy(filteredSorted.pop(), false, true);
     if (timeItem) {
         const result = { timeItem, ...SUCCESS };
         if (returnPreviousValues)
@@ -5777,6 +5781,7 @@ const membershipMap = {
     [TEAM]: 'teams',
 };
 function getParticipantMap({ withIndividualParticipants, convertExtensions, tournamentRecord, withSignInStatus, withScaleValues, internalUse, withISO2, withIOC, }) {
+    const missingParticipantIds = [];
     const participantMap = {};
     for (const participant of tournamentRecord.participants ?? []) {
         const participantId = participant?.participantId;
@@ -5785,15 +5790,22 @@ function getParticipantMap({ withIndividualParticipants, convertExtensions, tour
     for (const participant of tournamentRecord.participants ?? []) {
         const participantCopy = makeDeepCopy(participant, convertExtensions, internalUse);
         const { participantId, individualParticipantIds, participantType } = participantCopy;
+        if (!participantMap[participantId]) {
+            missingParticipantIds.push(participantId);
+            continue;
+        }
         Object.assign(participantMap[participantId].participant, participantCopy);
         if (individualParticipantIds) {
-            processIndividualParticipantIds({
+            const result = processIndividualParticipantIds({
                 individualParticipantIds,
                 participantCopy,
                 participantMap,
                 participantType,
                 participantId,
             });
+            if (result.missingParticipantIds.length) {
+                missingParticipantIds.push(...result.missingParticipantIds);
+            }
         }
         if (withSignInStatus) {
             participantMap[participantId].participant.signedIn = signedIn(participantCopy);
@@ -5817,7 +5829,7 @@ function getParticipantMap({ withIndividualParticipants, convertExtensions, tour
         const template = isObject(withIndividualParticipants) ? withIndividualParticipants : undefined;
         addIndividualParticipants({ participantMap, template });
     }
-    return { participantMap };
+    return { missingParticipantIds, participantMap };
 }
 function signedIn(participant) {
     const { timeItem } = getTimeItem({
@@ -5827,8 +5839,13 @@ function signedIn(participant) {
     return timeItem?.itemValue === SIGNED_IN;
 }
 function processIndividualParticipantIds({ individualParticipantIds, participantCopy, participantMap, participantType, participantId, }) {
+    const missingParticipantIds = [];
     for (const individualParticipantId of individualParticipantIds) {
-        const individualParticipant = participantMap[individualParticipantId].participant;
+        const individualParticipant = participantMap[individualParticipantId]?.participant;
+        if (!individualParticipant) {
+            missingParticipantIds.push(individualParticipantId);
+            continue;
+        }
         individualParticipant[typeMap[participantType]].push(participantId);
         if ([TEAM, GROUP].includes(participantType)) {
             const { participantRoleResponsibilities, participantOtherName, participantName, participantId, teamId } = participantCopy;
@@ -5847,6 +5864,7 @@ function processIndividualParticipantIds({ individualParticipantIds, participant
             participantMap[individualParticipantId].pairIdMap[partnerParticipantId] = participantId;
         }
     }
+    return { missingParticipantIds };
 }
 function initializeParticipantId({ participantMap, participantId }) {
     if (participantMap[participantId])
@@ -12520,7 +12538,7 @@ function getParticipants(params) {
     if (withMatchUps || withRankingProfile) {
         getMatchUpDependencies({ tournamentRecord });
     }
-    let { participantMap } = getParticipantMap({
+    const mapResult = getParticipantMap({
         convertExtensions,
         tournamentRecord,
         withSignInStatus,
@@ -12529,6 +12547,7 @@ function getParticipants(params) {
         withISO2,
         withIOC,
     });
+    let { participantMap } = mapResult;
     const entriesResult = getParticipantEntries({
         withMatchUps: withMatchUps ?? withRankingProfile,
         withEvents: withEvents ?? withRankingProfile,
@@ -12600,15 +12619,16 @@ function getParticipants(params) {
         ? filteredParticipants.map((source) => attributeFilter({ source, template }))
         : filteredParticipants;
     return {
+        participantMap: params.returnParticipantMap !== false ? participantMap : undefined,
+        mappedMatchUps: params.returnMatchUps !== false ? mappedMatchUps : undefined,
+        matchUps: params.returnMatchUps !== false ? matchUps : undefined,
+        missingParticipantIds: mapResult.missingParticipantIds,
         participantIdsWithConflicts,
         eventsPublishStatuses,
         derivedEventInfo,
         derivedDrawInfo,
-        mappedMatchUps,
-        participantMap,
         participants,
         ...SUCCESS,
-        matchUps,
     };
 }
 
@@ -12887,7 +12907,7 @@ function addDrawEntries$1(params) {
         }
         return notAdded;
     }, []);
-    if (duplicateEntries.length && suppressDuplicateEntries) {
+    if (duplicateEntries.length && !suppressDuplicateEntries) {
         return decorateResult({
             context: { eventId, drawId, duplicateEntries },
             result: { error: DUPLICATE_ENTRY },
@@ -15399,22 +15419,6 @@ function luckyLoserDrawPositionAssignment(params) {
     return luckyLoserDrawPositionAssignment$1(params);
 }
 
-function alternateDrawPositionAssignment$1({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
-    return positionParticipantAction({
-        positionActionName: 'alternateDrawPositionAssignment',
-        participantIdAttributeName: 'alternateParticipantid',
-        participantId: alternateParticipantId,
-        tournamentRecord,
-        drawDefinition,
-        drawPosition,
-        structureId,
-    });
-}
-
-function alternateDrawPositionAssignment(params) {
-    return alternateDrawPositionAssignment$1(params);
-}
-
 function modifyMappedMatchUps({ params, modMap, structure }) {
     const { tournamentRecord, drawDefinition, event } = params;
     for (const matchUp of structure.matchUps) {
@@ -15600,6 +15604,18 @@ function qualifierDrawPositionAssignment(params) {
     return qualifierDrawPositionAssignment$1(params);
 }
 
+function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
+    return positionParticipantAction({
+        positionActionName: 'alternateDrawPositionAssignment',
+        participantIdAttributeName: 'alternateParticipantid',
+        participantId: alternateParticipantId,
+        tournamentRecord,
+        drawDefinition,
+        drawPosition,
+        structureId,
+    });
+}
+
 function modifySeedAssignment({ validation = true, tournamentRecord, drawDefinition, participantId, structureId, seedValue, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -22395,9 +22411,10 @@ function directLoser(params) {
             return decorateResult({ result, stack });
     }
     else {
+        const error = !targetDrawPositionIsUnfilled ? DRAW_POSITION_OCCUPIED : INVALID_DRAW_POSITION;
         return decorateResult({
-            result: { error: INVALID_DRAW_POSITION },
-            context: { loserDrawPosition, loserTargetLink },
+            context: { loserDrawPosition, loserTargetLink, targetDrawPositionIsUnfilled },
+            result: { error },
             stack,
         });
     }
@@ -33674,11 +33691,12 @@ function getTournamentInfo(params) {
         notes,
         updatedAt,
     }))(tournamentRecord);
-    const tournamentContacts = getParticipants({
+    const participantResult = getParticipants({
         participantFilters: { participantRoles: [ADMINISTRATION, OFFICIAL, MEDIA, MEDICAL, SECURITY] },
         policyDefinitions: POLICY_PRIVACY_STAFF,
         tournamentRecord,
-    }).participants;
+    });
+    const tournamentContacts = participantResult?.participants ?? [];
     if (tournamentContacts)
         tournamentInfo.tournamentContacts = tournamentContacts;
     const publishState = getPublishState({ tournamentRecord })?.publishState;
@@ -33774,6 +33792,10 @@ function analyzeTournament({ tournamentRecord }) {
         isDual: checkIsDual(tournamentRecord),
         drawsAnalysis,
     };
+    const participantResult = getParticipants({ tournamentRecord });
+    if (participantResult.missingParticipantIds?.length) {
+        analysis.missingParticipantIds = participantResult.missingParticipantIds;
+    }
     return { ...SUCCESS, analysis };
 }
 
@@ -40160,6 +40182,94 @@ function generateFlightProfile(params) {
     }
 }
 
+function jsonToXml({ json, tagName }) {
+    const childArrays = Object.keys(json)
+        .filter((key) => Array.isArray(json[key]))
+        .map((key) => ({ key, value: json[key].filter((v) => typeof v === 'object' && Object.keys(v).length === 1) }));
+    const childObjects = Object.keys(json)
+        .filter((key) => typeof json[key] === 'object' && !Array.isArray(json[key]))
+        .map((key) => ({ key, value: json[key] }));
+    const attributes = Object.keys(json)
+        .filter((key) => ['string', 'number'].includes(typeof json[key]))
+        .map((key) => ({ key, value: json[key] }));
+    return generateTag({ tagName, attributes, childArrays, childObjects });
+}
+function generateTag(params) {
+    const { tagName, attributes = [], childArrays = [], childObjects } = params;
+    const carriageReturn = '\r\n';
+    const arrayChild = (v) => {
+        const key = Object.keys(v)[0];
+        const value = v[key];
+        return { key, value };
+    };
+    const arrayValues = childArrays
+        ?.map(({ key, value }) => generateTag({ tagName: key, childObjects: value.map(arrayChild) }))
+        .join('\r\n');
+    const childValues = childObjects
+        ?.map(({ key, value }) => jsonToXml({ tagName: key, json: value ?? [] }))
+        .join('\r\n');
+    const attributeString = attributes?.map(({ key, value }) => `${key}="${value}"`).join(' ');
+    const attributeValue = attributeString ? ` ${attributeString}` : '';
+    if (tagName === 'childArray')
+        return childValues;
+    const objectsTag = childValues?.length ? `${carriageReturn}${childValues}${carriageReturn}` : '';
+    const arraysTag = arrayValues?.length ? `${carriageReturn}${arrayValues}${carriageReturn}` : '';
+    return `<${tagName}${attributeValue}>${objectsTag}${arraysTag}</${tagName}>`;
+}
+
+function generateStatCrew(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord } = params;
+    const { startDate, tournamentId } = tournamentRecord;
+    const teamParticipants = tournamentRecord.participants.filter((participant) => participant.participantType === TEAM);
+    const homeTeam = teamParticipants?.find((team) => team.participantRoleResponsibilities?.includes('Home'));
+    const awayTeams = teamParticipants?.filter((team) => team.participantId !== homeTeam?.participantId);
+    const date = formatDate(startDate, '/', 'MDY');
+    const neutralGame = !homeTeam ? 'Y' : 'N';
+    const homename = homeTeam?.participantName || awayTeams?.[1]?.participantName;
+    const homeid = homeTeam?.participantId || awayTeams?.[1]?.participantId;
+    const visname = awayTeams?.[0]?.participantName;
+    const visid = awayTeams?.[0]?.participantId;
+    const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps;
+    const singles = matchUps?.filter((matchUp) => matchUp.matchUpType === SINGLES);
+    const doubles = matchUps?.filter((matchUp) => matchUp.matchUpType === DOUBLES);
+    const getScoreAttributes = ({ sets, sideNumber }) => Object.assign({}, ...(sets?.map((set) => {
+        const { setNumber, side1Score, side2Score, side1TiebreakScore, side2TiebreakScore } = set;
+        const setKey = `set_${setNumber}`;
+        const tbKey = `tie_${setNumber}`;
+        const setValue = sideNumber === 1 ? side1Score : side2Score;
+        const tieValue = sideNumber === 1 ? side1TiebreakScore : side2TiebreakScore;
+        return { [setKey]: setValue, [tbKey]: tieValue };
+    }) ?? []));
+    const getParticipantAttibutes = ({ matchUpId, participant }) => {
+        const name = !participant.individualParticipants ? participant.participantName : undefined;
+        const name_1 = participant.individualParticipants?.[0]?.participantName;
+        const name_2 = participant.individualParticipants?.[1]?.participantName;
+        const vh = matchUpId === homeid ? 'H' : 'V';
+        return definedAttributes({ vh, name, name_1, name_2 });
+    };
+    const mapMatchUp = (matchUp) => {
+        const { collectionPosition: match, orderOfFinish: order, matchUpId, matchUpType, sides } = matchUp;
+        const childArray = sides?.map((side) => {
+            const { sideNumber, participant } = side;
+            const scoreAttributes = getScoreAttributes({ sets: matchUp.score?.sets, sideNumber });
+            const scoreType = matchUpType === SINGLES ? 'singles_score' : 'doubles_score';
+            return { [scoreType]: { ...getParticipantAttibutes({ matchUpId, participant }), ...scoreAttributes } };
+        });
+        const matchType = matchUpType === SINGLES ? 'singles_match' : 'doubles_match';
+        return { [matchType]: { match, order, childArray } };
+    };
+    const json = {
+        venue: { gameid: tournamentId, date, neutralGame, homeid, homename, visid, visname, officials: {}, rules: {} },
+        singles_matches: singles?.map(mapMatchUp),
+        doubles_matches: doubles?.map(mapMatchUp),
+    };
+    const xml = jsonToXml({ json, tagName: 'tngame' });
+    return { xml, ...SUCCESS };
+}
+
 const ASC = 'ASC';
 const ASCENDING = 'ASC';
 const DESC = 'DESC';
@@ -40695,6 +40805,7 @@ var index$b = {
     generateLineUps: generateLineUps,
     generateQualifyingStructure: generateQualifyingStructure,
     generateSeedingScaleItems: generateSeedingScaleItems,
+    generateStatCrew: generateStatCrew,
     generateVoluntaryConsolation: generateVoluntaryConsolation,
     roundRobinGroups: roundRobinGroups
 };
@@ -45002,7 +45113,7 @@ function resetAdHocMatchUps(params) {
     return { ...SUCCESS };
 }
 
-function setOrderOfFinish$1({ drawDefinition, finishingOrder }) {
+function setOrderOfFinish$1({ tournamentRecord, drawDefinition, finishingOrder }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     const stack = 'setOrderOfFinish';
@@ -45103,7 +45214,15 @@ function setOrderOfFinish$1({ drawDefinition, finishingOrder }) {
         });
         if (result.error)
             return decorateResult({ result, stack });
-        result.completedMatchUps?.forEach((matchUp) => (matchUp.orderOfFinish = valuesMap[matchUp.matchUpId]));
+        result.completedMatchUps?.forEach((matchUp) => {
+            matchUp.orderOfFinish = valuesMap[matchUp.matchUpId];
+            modifyMatchUpNotice({
+                tournamentId: tournamentRecord.tournamentId,
+                context: 'setOrderOfFinish',
+                drawDefinition,
+                matchUp,
+            });
+        });
     }
     return { ...SUCCESS };
 }