Support double forfeit in final of elimination for standings (#243)

* Support double forfeit in final of elimination for standings

* Add test case for reset match

Author: Drarig29

src/get.ts

@@ -337,22 +337,27 @@ export class Get extends BaseGetter {
         const final = matches.filter(match => match.group_id === singleBracket.id).pop();
         if (!final) throw Error('Final not found.');
 
-        // 1st place: Final winner.
-        grouped[0] = [helpers.findParticipant(participants, getFinalWinnerIfDefined(final))];
+        const finalDoubleForfeitParticipants = getDoubleForfeitParticipants(participants, final);
+
+        // 1st place: Final winner, or both finalists when the final is a double forfeit.
+        grouped[0] = finalDoubleForfeitParticipants || [helpers.findParticipant(participants, getFinalWinnerIfDefined(final))];
 
         // Rest: every loser in reverse order.
         const losers = helpers.getLosers(participants, matches.filter(match => match.group_id === singleBracket.id));
-        grouped.push(...losers.reverse());
+        grouped.push(...losers.reverse().filter(group => group.length > 0));
 
         if (stage.settings?.consolationFinal) {
             const consolationFinal = matches.filter(match => match.group_id === finalGroup.id).pop();
             if (!consolationFinal) throw Error('Consolation final not found.');
 
-            const consolationFinalWinner = helpers.findParticipant(participants, getFinalWinnerIfDefined(consolationFinal));
-            const consolationFinalLoser = helpers.findParticipant(participants, helpers.getLoser(consolationFinal));
+            const consolationFinalDoubleForfeitParticipants = getDoubleForfeitParticipants(participants, consolationFinal);
+            const consolationFinalGroups = consolationFinalDoubleForfeitParticipants ? [consolationFinalDoubleForfeitParticipants] : [
+                [helpers.findParticipant(participants, getFinalWinnerIfDefined(consolationFinal))],
+                [helpers.findParticipant(participants, helpers.getLoser(consolationFinal))],
+            ];
 
             // Overwrite semi-final losers with the consolation final results.
-            grouped.splice(2, 1, [consolationFinalWinner], [consolationFinalLoser]);
+            grouped.splice(finalDoubleForfeitParticipants ? 1 : 2, 1, ...consolationFinalGroups);
         }
 
         return helpers.makeFinalStandings(grouped);
@@ -377,25 +382,35 @@ export class Get extends BaseGetter {
             const finalLB = matches.filter(match => match.group_id === loserBracket.id).pop();
             if (!finalLB) throw Error('LB final not found.');
 
-            // 1st place: WB Final winner.
-            grouped[0] = [helpers.findParticipant(participants, getFinalWinnerIfDefined(finalWB))];
+            const finalWBDoubleForfeitParticipants = getDoubleForfeitParticipants(participants, finalWB);
+
+            // 1st place: WB Final winner, or both finalists when the WB Final is a double forfeit.
+            grouped[0] = finalWBDoubleForfeitParticipants || [helpers.findParticipant(participants, getFinalWinnerIfDefined(finalWB))];
 
-            // 2nd place: LB Final winner.
-            grouped[1] = [helpers.findParticipant(participants, getFinalWinnerIfDefined(finalLB))];
+            const finalLBDoubleForfeitParticipants = getDoubleForfeitParticipants(participants, finalLB);
+
+            // 2nd place: LB Final winner, or both finalists when the LB Final is a double forfeit.
+            grouped[1] = finalLBDoubleForfeitParticipants || [helpers.findParticipant(participants, getFinalWinnerIfDefined(finalLB))];
         } else {
             const grandFinalMatches = matches.filter(match => match.group_id === finalGroup.id);
             const decisiveMatch = helpers.getGrandFinalDecisiveMatch(stage.settings?.grandFinal || 'none', grandFinalMatches);
+            const grandFinalDoubleForfeitParticipants = getDoubleForfeitParticipants(participants, decisiveMatch);
 
-            // 1st place: Grand Final winner.
-            grouped[0] = [helpers.findParticipant(participants, getFinalWinnerIfDefined(decisiveMatch))];
+            if (grandFinalDoubleForfeitParticipants) {
+                // 1st place: Both grand finalists; the final creates no loser.
+                grouped[0] = grandFinalDoubleForfeitParticipants;
+            } else {
+                // 1st place: Grand Final winner.
+                grouped[0] = [helpers.findParticipant(participants, getFinalWinnerIfDefined(decisiveMatch))];
 
-            // 2nd place: Grand Final loser.
-            grouped[1] = [helpers.findParticipant(participants, helpers.getLoser(decisiveMatch))];
+                // 2nd place: Grand Final loser.
+                grouped[1] = [helpers.findParticipant(participants, helpers.getLoser(decisiveMatch))];
+            }
         }
 
         // Rest: every loser in reverse order.
         const losers = helpers.getLosers(participants, matches.filter(match => match.group_id === loserBracket.id));
-        grouped.push(...losers.reverse());
+        grouped.push(...losers.reverse().filter(group => group.length > 0));
 
         return helpers.makeFinalStandings(grouped);
     }
@@ -436,3 +451,13 @@ const getFinalWinnerIfDefined = (match: Match): ParticipantSlot => {
     if (!winner) throw Error('The final match does not have a winner.');
     return winner;
 };
+
+const getDoubleForfeitParticipants = (participants: Participant[], match: Match): Participant[] | null => {
+    if (!helpers.isDoubleForfeitCompleted(match))
+        return null;
+
+    return [
+        helpers.findParticipant(participants, match.opponent1),
+        helpers.findParticipant(participants, match.opponent2),
+    ];
+};

test/get.spec.js

@@ -8,6 +8,11 @@ const { JsonDatabase } = require('brackets-json-db');
 const storage = new JsonDatabase();
 const manager = new BracketsManager(storage);
 
+const makeStandingsItem = (participants, slot, rank) => {
+    const participant = participants.find(participant => participant.id === slot.id);
+    return { id: participant.id, name: participant.name, rank };
+};
+
 describe('Get child games', () => {
 
     beforeEach(() => {
@@ -132,6 +137,72 @@ describe('Get final standings', () => {
         ]);
     });
 
+    it('should get shared first place for a single elimination final double forfeit', async () => {
+        await manager.create.stage({
+            name: 'Example',
+            tournamentId: 0,
+            type: 'single_elimination',
+            seeding: ['Team 1', 'Team 2', 'Team 3', 'Team 4'],
+        });
+
+        await manager.update.match({ id: 0, opponent1: { result: 'win' } });
+        await manager.update.match({ id: 1, opponent1: { result: 'win' } });
+
+        const semiFinals = await storage.select('match', { round_id: 0 });
+        const final = await storage.select('match', 2);
+
+        await manager.update.match({
+            id: final.id,
+            opponent1: { forfeit: true },
+            opponent2: { forfeit: true },
+        });
+
+        const participants = await storage.select('participant', { tournament_id: 0 });
+        const finalStandings = await manager.get.finalStandings(0);
+
+        assert.deepEqual(finalStandings, [
+            makeStandingsItem(participants, final.opponent1, 1),
+            makeStandingsItem(participants, final.opponent2, 1),
+            makeStandingsItem(participants, semiFinals[0].opponent2, 2),
+            makeStandingsItem(participants, semiFinals[1].opponent2, 2),
+        ]);
+    });
+
+    it('should keep consolation final ranks after a single elimination final double forfeit', async () => {
+        await manager.create.stage({
+            name: 'Example',
+            tournamentId: 0,
+            type: 'single_elimination',
+            seeding: ['Team 1', 'Team 2', 'Team 3', 'Team 4'],
+            settings: { consolationFinal: true },
+        });
+
+        await manager.update.match({ id: 0, opponent1: { result: 'win' } });
+        await manager.update.match({ id: 1, opponent1: { result: 'win' } });
+
+        const groups = await storage.select('group', { stage_id: 0 });
+        const final = (await storage.select('match', { group_id: groups[0].id })).pop();
+        const consolationFinal = (await storage.select('match', { group_id: groups[1].id })).pop();
+
+        await manager.update.match({ id: consolationFinal.id, opponent1: { result: 'win' } });
+
+        await manager.update.match({
+            id: final.id,
+            opponent1: { forfeit: true },
+            opponent2: { forfeit: true },
+        });
+
+        const participants = await storage.select('participant', { tournament_id: 0 });
+        const finalStandings = await manager.get.finalStandings(0);
+
+        assert.deepEqual(finalStandings, [
+            makeStandingsItem(participants, final.opponent1, 1),
+            makeStandingsItem(participants, final.opponent2, 1),
+            makeStandingsItem(participants, consolationFinal.opponent1, 2),
+            makeStandingsItem(participants, consolationFinal.opponent2, 3),
+        ]);
+    });
+
     it('should get the final standings for a double elimination stage with a grand final', async () => {
         await manager.create.stage({
             name: 'Example',
@@ -165,6 +236,84 @@ describe('Get final standings', () => {
         ]);
     });
 
+    it('should get shared first place for a double elimination grand final double forfeit', async () => {
+        await manager.create.stage({
+            name: 'Example',
+            tournamentId: 0,
+            type: 'double_elimination',
+            seeding: [
+                'Team 1', 'Team 2', 'Team 3', 'Team 4',
+            ],
+            settings: { grandFinal: 'simple' },
+        });
+
+        const groups = await storage.select('group', { stage_id: 0 });
+        const grandFinal = (await storage.select('match', { group_id: groups[2].id }))[0];
+        const matches = (await storage.select('match', { stage_id: 0 }))
+            .filter(match => match.id !== grandFinal.id)
+            .sort((a, b) => a.id - b.id);
+
+        for (const match of matches)
+            await manager.update.match({ id: match.id, opponent1: { result: 'win' } });
+
+        const final = await storage.select('match', grandFinal.id);
+
+        await manager.update.match({
+            id: final.id,
+            opponent1: { forfeit: true },
+            opponent2: { forfeit: true },
+        });
+
+        const participants = await storage.select('participant', { tournament_id: 0 });
+        const finalStandings = await manager.get.finalStandings(0);
+
+        assert.deepEqual(finalStandings.slice(0, 2), [
+            makeStandingsItem(participants, final.opponent1, 1),
+            makeStandingsItem(participants, final.opponent2, 1),
+        ]);
+        assert.strictEqual(finalStandings[2].rank, 2);
+    });
+
+    it('should get shared first place for a double grand final reset match double forfeit', async () => {
+        await manager.create.stage({
+            name: 'Example',
+            tournamentId: 0,
+            type: 'double_elimination',
+            seeding: [
+                'Team 1', 'Team 2', 'Team 3', 'Team 4',
+            ],
+            settings: { grandFinal: 'double' },
+        });
+
+        const groups = await storage.select('group', { stage_id: 0 });
+        const grandFinalMatches = await storage.select('match', { group_id: groups[2].id });
+        const matches = (await storage.select('match', { stage_id: 0 }))
+            .filter(match => match.group_id !== groups[2].id)
+            .sort((a, b) => a.id - b.id);
+
+        for (const match of matches)
+            await manager.update.match({ id: match.id, opponent1: { result: 'win' } });
+
+        await manager.update.match({ id: grandFinalMatches[0].id, opponent2: { result: 'win' } });
+
+        const resetMatch = await storage.select('match', grandFinalMatches[1].id);
+
+        await manager.update.match({
+            id: resetMatch.id,
+            opponent1: { forfeit: true },
+            opponent2: { forfeit: true },
+        });
+
+        const participants = await storage.select('participant', { tournament_id: 0 });
+        const finalStandings = await manager.get.finalStandings(0);
+
+        assert.deepEqual(finalStandings.slice(0, 2), [
+            makeStandingsItem(participants, resetMatch.opponent1, 1),
+            makeStandingsItem(participants, resetMatch.opponent2, 1),
+        ]);
+        assert.strictEqual(finalStandings[2].rank, 2);
+    });
+
     it('should get the final standings for a double elimination stage without a grand final', async () => {
         await manager.create.stage({
             name: 'Example',