@dcrackel/hematournamentui 1.0.713 → 1.0.715

package/src/stories/Templates/EventManagement/Bracket/BracketStories.test.js

@@ -77,4 +77,125 @@ describe('Bracket story assignment simulation', () => {
       expect(shared.every(bout => getRing(bracket(), bout) === undefined)).toBe(true);
     }
   });
+
+  it.each(['Active', 'Completed'])(
+    'redistributes scheduled work after removal while preserving a %s bout',
+    async Status => {
+      const { bracket } = mountStory(stories.PlannedDirectorSuggestions);
+      const station = bracket().props('plannedDirectingStations')[0];
+      const bout = bracket()
+        .props('bouts')
+        .find(item => item.Person1.PersonId > 0 && item.Person2.PersonId > 0);
+      const savedBout = {
+        ...bout,
+        Status,
+        RefereeId: station.Director.PersonId,
+        RefName: station.Director.DisplayName,
+        Score1: 4,
+        Score2: 3
+      };
+      bracket().vm.$emit('update:bout', savedBout);
+      await nextTick();
+      bracket().vm.$emit('request:remove-planned-director', station);
+      await nextTick();
+      expect(
+        bracket()
+          .props('plannedDirectingStations')
+          .map(item => item.RingId)
+      ).toEqual([2]);
+      expect(
+        bracket()
+          .props('bouts')
+          .find(item => item.BoutId === bout.BoutId)
+      ).toEqual(savedBout);
+      const scheduledIds = new Set(
+        bracket()
+          .props('bouts')
+          .filter(item => item.Status === 'Scheduled')
+          .map(item => item.DEBoutId)
+      );
+      expect(
+        bracket()
+          .props('plannedBoutAssignments')
+          .filter(item => scheduledIds.has(item.DEBoutId))
+          .every(item => item.RingId === 2)
+      ).toBe(true);
+      expect(getRing(bracket(), savedBout)).toBe(1);
+    }
+  );
+
+  it('supports removing every director and adding a removed director again without changing story args', async () => {
+    const { bracket, args } = mountStory(stories.PlannedDirectorSuggestions);
+    for (const station of args.plannedDirectingStations) {
+      bracket().vm.$emit('request:remove-planned-director', station);
+      await nextTick();
+    }
+    expect(bracket().props('plannedDirectingStations')).toEqual([]);
+    expect(bracket().props('plannedBoutAssignments')).toEqual([]);
+    expect(bracket().props('showAddPlannedDirectorCard')).toBe(true);
+    bracket().vm.$emit('request:add-planned-director');
+    await nextTick();
+    expect(
+      bracket()
+        .props('plannedDirectingStations')
+        .map(station => station.RingId)
+    ).toEqual([1]);
+    expect(
+      bracket()
+        .props('plannedBoutAssignments')
+        .every(item => item.RingId === 1)
+    ).toBe(true);
+    expect(args.plannedDirectingStations).toHaveLength(2);
+  });
+
+  it('keeps the signed-in director identity when resuming a bout after removing their planned station', async () => {
+    const { bracket } = mountStory(stories.PlannedDirectorSuggestions);
+    const station = bracket().props('plannedDirectingStations')[0];
+    const bout = bracket()
+      .props('bouts')
+      .find(item => item.Person1.PersonId > 0 && item.Person2.PersonId > 0);
+    bracket().vm.$emit('update:directing-bout', bout);
+    await nextTick();
+    const active = bracket()
+      .props('bouts')
+      .find(item => item.BoutId === bout.BoutId);
+    bracket().vm.$emit('request:remove-planned-director', station);
+    await nextTick();
+    bracket().vm.$emit('update:directing-bout', { ...active, Score1: 3 });
+    await nextTick();
+    expect(
+      bracket()
+        .props('bouts')
+        .find(item => item.BoutId === bout.BoutId)
+    ).toMatchObject({
+      RefereeId: station.Director.PersonId,
+      RefName: station.Director.DisplayName,
+      Status: 'Active',
+      Score1: 3
+    });
+  });
+
+  it('applies staff-fed roster saves and ring moves only to DE plans', async () => {
+    const { bracket, args } = mountStory(stories.PlannedDirectorSuggestions);
+    const beforeBouts = JSON.parse(JSON.stringify(bracket().props('bouts')));
+    const original = bracket().props('plannedDirectingStations')[0];
+    const updated = { ...original, RingId: 3, RingName: 'Ring 3' };
+    bracket().vm.$emit('update:planned-directing-stations', [
+      updated,
+      ...bracket().props('plannedDirectingStations').slice(1)
+    ]);
+    await nextTick();
+    expect(bracket().props('plannedDirectingStations')[0]).toEqual(updated);
+    expect(
+      bracket()
+        .props('plannedBoutAssignments')
+        .every(item => [2, 3].includes(item.RingId))
+    ).toBe(true);
+    expect(args.plannedDirectingStations[0].RingId).toBe(1);
+    expect(args.availableDirectors[0].DefaultRingId).toBe(1);
+    bracket().vm.$emit('update:planned-directing-stations', [updated]);
+    await nextTick();
+    expect(bracket().props('plannedDirectingStations')).toEqual([updated]);
+    expect(bracket().props('bouts')).toEqual(beforeBouts);
+  });
 });

package/src/stories/Util/bracketDirectors.js

@@ -0,0 +1,86 @@
+export const getIdentityKey = value => String(value ?? '');
+export const cloneDirectorData = value => JSON.parse(JSON.stringify(value));
+const hasIdentity = value => value !== null && value !== undefined && String(value) !== '';
+const isDirector = director => hasIdentity(director?.PersonId) && getIdentityKey(director.PersonId) !== '0';
+
+export const getRingOptions = rings => {
+  const options = new Map();
+  for (const ring of rings || []) {
+    if (!hasIdentity(ring?.RingId)) continue;
+    options.set(getIdentityKey(ring.RingId), { ...ring, RingName: ring.RingName || 'Ring ' + ring.RingId });
+  }
+  return [...options.values()];
+};
+
+const getDirectorOptions = (availableDirectors, stations) => {
+  const options = new Map();
+  for (const director of availableDirectors || []) {
+    if (isDirector(director)) options.set(getIdentityKey(director.PersonId), cloneDirectorData(director));
+  }
+  for (const station of stations || []) {
+    const director = station?.Director;
+    if (!isDirector(director) || options.has(getIdentityKey(director.PersonId))) continue;
+    options.set(getIdentityKey(director.PersonId), cloneDirectorData(director));
+  }
+  return [...options.values()];
+};
+
+export const createDirectorDraft = (availableDirectors, stations) => {
+  const stationByDirector = new Map(
+    (stations || [])
+      .filter(station => isDirector(station?.Director))
+      .map(station => [getIdentityKey(station.Director.PersonId), station])
+  );
+  return getDirectorOptions(availableDirectors, stations).map(candidate => {
+    const station = stationByDirector.get(getIdentityKey(candidate.PersonId));
+    const savedStation = station ? cloneDirectorData(station) : {};
+    const { DefaultRingId, Color, ...director } = candidate;
+    return {
+      Director: { ...savedStation.Director, ...director, DisplayName: director.DisplayName || 'Unnamed director' },
+      Color: savedStation.Color || Color || '',
+      RingId: savedStation.RingId ?? DefaultRingId ?? '',
+      Selected: Boolean(station),
+      station: savedStation
+    };
+  });
+};
+
+export const reconcileDirectorDraft = (availableDirectors, stations, draft) => {
+  const previous = new Map(draft.map(row => [getIdentityKey(row.Director.PersonId), row]));
+  return createDirectorDraft(availableDirectors, stations).map(row => {
+    const existing = previous.get(getIdentityKey(row.Director.PersonId));
+    if (!existing) return row;
+    return { ...row, Selected: existing.Selected, RingId: existing.RingId };
+  });
+};
+
+export const getDirectorDraftError = (draft, rings) => {
+  const selected = draft.filter(row => row.Selected);
+  const availableIds = new Set(
+    getRingOptions(rings)
+      .filter(ring => !ring.Disabled)
+      .map(ring => getIdentityKey(ring.RingId))
+  );
+  if (selected.some(row => !availableIds.has(getIdentityKey(row.RingId))))
+    return 'Choose a ring for each selected director.';
+  const selectedIds = selected.map(row => getIdentityKey(row.RingId));
+  if (new Set(selectedIds).size !== selectedIds.length) return 'Each selected director needs a different ring.';
+  return '';
+};
+
+export const createDirectorStations = (draft, rings) => {
+  if (getDirectorDraftError(draft, rings)) return null;
+  const ringById = new Map(getRingOptions(rings).map(ring => [getIdentityKey(ring.RingId), ring]));
+  return draft
+    .filter(row => row.Selected)
+    .map(row => {
+      const ring = ringById.get(getIdentityKey(row.RingId));
+      return cloneDirectorData({
+        ...row.station,
+        RingId: ring.RingId,
+        RingName: ring.RingName,
+        Color: row.Color || ring.Color || '',
+        Director: row.Director
+      });
+    });
+};