@dcrackel/hematournamentui 1.0.713 → 1.0.714

package/src/stories/Templates/EventManagement/Bracket/Bracket.vue

@@ -40,7 +40,10 @@
         class="order-first flex-none xl:order-last"
         :stations="plannedDirectingStations"
         :showAddCard="showAddPlannedDirectorCard"
-        @request:add-planned-director="$emit('request:add-planned-director')"
+        :canManageDirectors="canManagePlannedDirectors"
+        @request:manage-planned-directors="handleManagePlannedDirectors"
+        @request:add-planned-director="handleAddPlannedDirector"
+        @request:remove-planned-director="$emit('request:remove-planned-director', $event)"
       />
     </div>
 
@@ -64,6 +67,15 @@
       </div>
     </div>
 
+    <BracketDirectorsModal
+      v-if="canManagePlannedDirectors"
+      v-model:show="showPlannedDirectorsModal"
+      :availableDirectors="availableDirectors"
+      :rings="rings"
+      :stations="plannedDirectingStations"
+      @submit:stations="handlePlannedDirectorsSubmit"
+    />
+
     <DirectorModal
       :bout="selectedBout"
       :eventRules="eventRules"
@@ -96,6 +108,8 @@ import ToggleHeader from '../../../Organisms/Headers/ToggleHeader/ToggleHeader.v
 import ServerConnected from '../../../Molecules/Indicators/ServerConnected/ServerConnected.vue';
 import BaseText from '../../../Atoms/Text/BaseText.vue';
 import DirectorModal from '../../../Molecules/Modals/DirectorModal/DirectorModal.vue';
+import BracketDirectorsModal from '../../../Molecules/Modals/BracketDirectorsModal/BracketDirectorsModal.vue';
+import { cloneDirectorData } from '../../../Util/bracketDirectors.js';
 import EditBoutModal from '../../../Molecules/Modals/EditBoutModal/EditBoutModal.vue';
 import Tableau from '../../../Organisms/Containers/Tableau/Tableau.vue';
 import BracketDirectorAssignmentPanel from '../../../Organisms/Containers/Tableau/components/BracketDirectorAssignmentPanel.vue';
@@ -121,6 +135,8 @@ export default {
     'penalty:remove',
     'penalty:update',
     'request:add-planned-director',
+    'request:remove-planned-director',
+    'update:planned-directing-stations',
     'request:bout-active',
     'request:bout-director',
     'submit:bout',
@@ -133,12 +149,15 @@ export default {
     EditBoutModal,
     DirectorModal,
     BracketDirectorAssignmentPanel,
+    BracketDirectorsModal,
     BaseText,
     ToggleHeader,
     ServerConnected,
     EditEventsTopMenu
   },
   props: {
+    availableDirectors: { type: Array, default: undefined },
+    rings: { type: Array, default: undefined },
     showBoutDirectorAssignment: { type: Boolean, default: true },
     bouts: {
       type: Array,
@@ -189,6 +208,7 @@ export default {
     return {
       emptyDesertIcon,
       showDirectorModal: false,
+      showPlannedDirectorsModal: false,
       showEditBoutModal: false,
       selectedBout: {},
       tabs,
@@ -198,6 +218,9 @@ export default {
     };
   },
   computed: {
+    canManagePlannedDirectors() {
+      return !this.isMobile && Array.isArray(this.availableDirectors) && Array.isArray(this.rings);
+    },
     isMobile() {
       return this.windowWidth < 768;
     },
@@ -236,6 +259,9 @@ export default {
     }
   },
   watch: {
+    isMobile(value) {
+      if (value) this.showPlannedDirectorsModal = false;
+    },
     bouts: {
       handler(newBouts) {
         this.boutsData = this.cloneBouts(newBouts);
@@ -253,6 +279,21 @@ export default {
     window.removeEventListener('resize', this.updateViewBasedOnScreenSize);
   },
   methods: {
+    handleAddPlannedDirector() {
+      if (this.canManagePlannedDirectors) {
+        this.handleManagePlannedDirectors();
+        return;
+      }
+      this.$emit('request:add-planned-director');
+    },
+    handleManagePlannedDirectors() {
+      if (!this.canManagePlannedDirectors) return;
+      this.showPlannedDirectorsModal = true;
+    },
+    handlePlannedDirectorsSubmit(stations) {
+      this.$emit('update:planned-directing-stations', cloneDirectorData(stations));
+      this.showPlannedDirectorsModal = false;
+    },
     handleBoutDirectorRequest(bout) {
       if (!this.canShowBoutDirectorAssignment) return;
       const currentBout = this.boutsData.find(item => String(item.BoutId) === String(bout?.BoutId));

package/src/stories/Templates/EventManagement/Bracket/BracketPlannedSuggestions.js

@@ -40,3 +40,11 @@ export const plannedDirectingStations = [
 ];
 
 export const plannedSuggestionViewerId = plannedDirectingStations[0].Director.PersonId;
+
+export const availableDirectors = plannedDirectingStations.map((station, index) => ({
+  ...station.Director,
+  Color: station.Color,
+  DefaultRingId: index < 2 ? station.RingId : null
+}));
+
+export const availableRings = plannedDirectingStations.map(({ RingId, RingName }) => ({ RingId, RingName }));

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
+      });
+    });
+};