tods-competition-factory 2.0.45 → 2.0.47

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

@@ -6102,7 +6102,7 @@ type GenerateTournamentRecordArgs = {
     participantsProfile?: ParticipantsProfile;
     scheduleCompletedMatchUps?: boolean;
     tournamentExtensions?: Extension[];
-    policyDefinitions: PolicyDefinitions;
+    policyDefinitions?: PolicyDefinitions;
     completeAllMatchUps?: boolean;
     tournamentAttributes?: any;
     ratingsParameters?: any;
@@ -9086,7 +9086,6 @@ declare function setTournamentNotes({ tournamentRecord, notes }: {
     };
 } | {
     success: boolean;
-    error?: undefined;
 };
 declare function setTournamentCategories({ tournamentRecord, categories }: {
     tournamentRecord: any;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.45';
+    return '2.0.47';
 }
 
 function isFunction(obj) {
@@ -11921,7 +11921,7 @@ function getParticipantEntries(params) {
     const eventsPublishStatuses = {};
     const derivedEventInfo = {};
     const derivedDrawInfo = {};
-    const getRanking = ({ eventType, scaleNames, participantId }) => participantMap[participantId].participant?.rankings?.[eventType]?.find((ranking) => scaleNames.includes(ranking.scaleName))?.scaleValue;
+    const getRanking = ({ eventType, scaleNames, participantId }) => participantMap[participantId]?.participant?.rankings?.[eventType]?.find((ranking) => scaleNames.includes(ranking.scaleName))?.scaleValue;
     for (const event of tournamentRecord?.events || []) {
         if (participantFilters?.eventIds && !participantFilters.eventIds.includes(event.eventId))
             continue;
@@ -12032,6 +12032,8 @@ function getParticipantEntries(params) {
                     (eventPublishedSeeding?.published &&
                         (eventPublishedSeeding?.drawIds?.length === 0 || eventPublishedSeeding?.drawIds?.includes(drawId)));
                 for (const entry of relevantEntries) {
+                    if (!participantMap[entry.participantId])
+                        continue;
                     const { entryStatus, entryStage, entryPosition, participantId } = entry;
                     const ranking = getRanking({
                         participantId,
@@ -12039,7 +12041,7 @@ function getParticipantEntries(params) {
                         eventType,
                     });
                     const addParticipantDrawEntry = (id) => {
-                        if (participantMap[id].draws?.[drawId])
+                        if (!participantMap[id] || participantMap[id].draws?.[drawId])
                             return;
                         const includeSeeding = withSeeding && seedingPublished;
                         const seedAssignments = includeSeeding ? {} : undefined;
@@ -20887,21 +20889,19 @@ function findDrawMatchUp({ tournamentParticipants, afterRecoveryTimes, contextCo
 }
 
 function addNotes(params) {
-    if (typeof params !== 'object')
+    if (!isObject(params) || !params.notes)
         return { error: MISSING_VALUE };
-    if (typeof params.element !== 'object')
+    if (!isObject(params.element))
         return { error: INVALID_VALUES };
-    if (!params.notes)
-        return { error: MISSING_VALUE };
-    if (typeof params.notes !== 'string' && !params.notes?.testing)
+    if (!isString(params.notes) && !params.notes?.testing)
         return { error: INVALID_VALUES };
     Object.assign(params.element, { notes: params.notes });
     return { ...SUCCESS };
 }
 function removeNotes(params) {
-    if (typeof params !== 'object')
+    if (!isObject(params))
         return { error: MISSING_VALUE };
-    if (typeof params.element !== 'object')
+    if (!isObject(params.element))
         return { error: INVALID_VALUES };
     if (params.element.notes)
         delete params.element.notes;
@@ -55357,15 +55357,15 @@ function setTournamentName({ tournamentRecord, promotionalName, tournamentName,
         return { error: MISSING_TOURNAMENT_RECORD };
     const tournamentId = tournamentRecord.tournamentId;
     const detailUpdates = { tournamentId };
-    if (tournamentName) {
+    if (tournamentName && tournamentName !== tournamentRecord.tournamentName) {
         tournamentRecord.tournamentName = tournamentName;
         detailUpdates.tournamentName = tournamentName;
     }
-    if (promotionalName) {
+    if (promotionalName && promotionalName !== tournamentRecord.promotionalName) {
         tournamentRecord.promotionalName = promotionalName;
         detailUpdates.promotionalName = promotionalName;
     }
-    if (formalName) {
+    if (formalName && formalName !== tournamentRecord.formalName) {
         tournamentRecord.formalName = formalName;
         detailUpdates.formalName = formalName;
     }
@@ -55378,22 +55378,46 @@ function setTournamentName({ tournamentRecord, promotionalName, tournamentName,
         detailUpdates.formalName = '';
     }
     if (Object.keys(detailUpdates).length > 1) {
-        addNotice({ topic: MODIFY_TOURNAMENT_DETAIL, payload: { tournamentId, ...detailUpdates } });
+        addNotice({
+            topic: MODIFY_TOURNAMENT_DETAIL,
+            payload: {
+                parentOrganisation: tournamentRecord.parentOrganisation,
+                tournamentId,
+                ...detailUpdates,
+            },
+        });
     }
     return { ...SUCCESS };
 }
 function setTournamentNotes({ tournamentRecord, notes }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
-    return addNotes({ element: tournamentRecord, notes });
+    const result = notes ? addNotes({ element: tournamentRecord, notes }) : removeNotes({ element: tournamentRecord });
+    if (result.error)
+        return result;
+    addNotice({
+        topic: MODIFY_TOURNAMENT_DETAIL,
+        payload: {
+            parentOrganisation: tournamentRecord.parentOrganisation,
+            tournamentId: tournamentRecord.tournamentId,
+            notes: notes ?? '',
+        },
+    });
+    return { ...SUCCESS };
 }
 function setTournamentCategories({ tournamentRecord, categories }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
-    categories = (categories || []).filter((category) => {
-        return category.categoryName && category.type;
-    });
+    categories = (categories || []).filter((category) => category.categoryName && category.type);
     tournamentRecord.tournamentCategories = categories;
+    addNotice({
+        topic: MODIFY_TOURNAMENT_DETAIL,
+        payload: {
+            parentOrganisation: tournamentRecord.parentOrganisation,
+            tournamentId: tournamentRecord.tournamentId,
+            categories,
+        },
+    });
     return { ...SUCCESS };
 }
 
@@ -55475,7 +55499,12 @@ function setTournamentDates(params) {
     const unscheduledMatchUpIds = checkScheduling && removeInvalidScheduling({ tournamentRecord })?.unscheduledMatchUpIds;
     updateCourtAvailability({ tournamentRecord });
     addNotice({
-        payload: { tournamentId: tournamentRecord.tournamentId, startDate, endDate },
+        payload: {
+            parentOrganisation: tournamentRecord.parentOrganisation,
+            tournamentId: tournamentRecord.tournamentId,
+            startDate,
+            endDate,
+        },
         topic: MODIFY_TOURNAMENT_DETAIL,
     });
     return { ...SUCCESS, unscheduledMatchUpIds, datesAdded, datesRemoved };