11298984545

Committed 11 Oct 2024 08:36PM UTC coverage: 97.004% (-0.1%) from 97.131%

Build # 11298984545

Build Type

push

github

Committed by

web-flow

Commit Message

v2.2.5 (#1058)

Run Details

6541 of 7009 branches covered (93.32%)

Branch coverage included in aggregate %.

82 of 88 new or added lines in 43 files covered. (93.18%)

1 existing line in 1 file now uncovered.

12724 of 12851 relevant lines covered (99.01%)

164.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.59

/CourageScores/ClientApp/src/components/tournaments/Tournament.tsx

import React, {useEffect, useState} from 'react';
import {useParams} from "react-router-dom";
import {DivisionControls} from "../league/DivisionControls";
import {ErrorDisplay} from "../common/ErrorDisplay";
import {any, sortBy} from "../../helpers/collections";
import {propChanged} from "../../helpers/events";
import {Loading} from "../common/Loading";
import {EditTournament} from "./EditTournament";
import {useDependencies} from "../common/IocContainer";
import {useApp} from "../common/AppContainer";
import {Dialog} from "../common/Dialog";
import {EditPlayerDetails} from "../division_players/EditPlayerDetails";
import {EMPTY_ID} from "../../helpers/projection";
import {TournamentContainer} from "./TournamentContainer";
import {SuperLeaguePrintout} from "./superleague/SuperLeaguePrintout";
import {PrintableSheet} from "./PrintableSheet";
import {LoadingSpinnerSmall} from "../common/LoadingSpinnerSmall";
import {TournamentGameDto} from "../../interfaces/models/dtos/Game/TournamentGameDto";
import {IClientActionResultDto} from "../common/IClientActionResultDto";
import {DivisionDataDto} from "../../interfaces/models/dtos/Division/DivisionDataDto";
import {DivisionFixtureDateDto} from "../../interfaces/models/dtos/Division/DivisionFixtureDateDto";
import {TournamentPlayerDto} from "../../interfaces/models/dtos/Game/TournamentPlayerDto";
import {TournamentSideDto} from "../../interfaces/models/dtos/Game/TournamentSideDto";
import {TeamDto} from "../../interfaces/models/dtos/Team/TeamDto";
import {GameMatchOptionDto} from "../../interfaces/models/dtos/Game/GameMatchOptionDto";
import {SeasonDto} from "../../interfaces/models/dtos/Season/SeasonDto";
import {DivisionDto} from "../../interfaces/models/dtos/DivisionDto";
import {EditTeamPlayerDto} from "../../interfaces/models/dtos/Team/EditTeamPlayerDto";
import {ILiveOptions} from "../../live/ILiveOptions";
import {ISelectablePlayer} from "../common/PlayerSelection";
import {PatchTournamentDto} from "../../interfaces/models/dtos/Game/PatchTournamentDto";
import {PatchTournamentRoundDto} from "../../interfaces/models/dtos/Game/PatchTournamentRoundDto";
import {TeamPlayerDto} from "../../interfaces/models/dtos/Team/TeamPlayerDto";
import {TeamSeasonDto} from "../../interfaces/models/dtos/Team/TeamSeasonDto";
import {DivisionDataFilter} from "../../interfaces/models/dtos/Division/DivisionDataFilter";
import {EditTournamentGameDto} from "../../interfaces/models/dtos/Game/EditTournamentGameDto";
import {TournamentDetails} from "./TournamentDetails";
import {TournamentRoundDto} from "../../interfaces/models/dtos/Game/TournamentRoundDto";
import {LiveDataType} from "../../interfaces/models/dtos/Live/LiveDataType";
import {PhotoManager} from "../common/PhotoManager";
import {UploadPhotoDto} from "../../interfaces/models/dtos/UploadPhotoDto";
import {ConfiguredFeatureDto} from "../../interfaces/models/dtos/ConfiguredFeatureDto";
import {
    DivisionTournamentFixtureDetailsDto
} from "../../interfaces/models/dtos/Division/DivisionTournamentFixtureDetailsDto";
import {useBranding} from "../common/BrandingContainer";
import {renderDate} from "../../helpers/rendering";

export interface ITournamentPlayerMap {
    [id: string]: DivisionTournamentFixtureDetailsDto;
}

export function Tournament() {
    const {tournamentId} = useParams();
    const {appLoading, account, seasons, onError, teams, reloadTeams, divisions} = useApp();
    const {divisionApi, tournamentApi, webSocket, featureApi} = useDependencies();
    const canManageTournaments: boolean = account && account.access && account.access.manageTournaments;
    const canManagePlayers: boolean = account && account.access && account.access.managePlayers;
    const canEnterTournamentResults = account && account.access && account.access.enterTournamentResults;
    const [loading, setLoading] = useState<string>('init');
    const [saving, setSaving] = useState<boolean>(false);
    const [patching, setPatching] = useState<boolean>(false);
    const [preventScroll, setPreventScroll] = useState<boolean>(false);
    const [tournamentData, setTournamentData] = useState<TournamentGameDto | null>(null);
    const [saveError, setSaveError] = useState<IClientActionResultDto<TournamentGameDto> | null>(null);
    const [allPlayers, setAllPlayers] = useState<ISelectablePlayer[]>([]);
    const [alreadyPlaying, setAlreadyPlaying] = useState<ITournamentPlayerMap | null>(null);
    const [addPlayerDialogOpen, setAddPlayerDialogOpen] = useState<boolean>(false);
    const [newPlayerDetails, setNewPlayerDetails] = useState<EditTeamPlayerDto>({name: '', captain: false});
    const [warnBeforeEditDialogClose, setWarnBeforeEditDialogClose] = useState(null);
    const division: DivisionDto = tournamentData && tournamentData.divisionId ? divisions.filter(d => d.id === tournamentData.divisionId)[0] : null;
    const [editTournament, setEditTournament] = useState<string>(null);
    const [showPhotoManager, setShowPhotoManager] = useState(false);
    const [photosEnabled, setPhotosEnabled] = useState(false);
    const {setTitle} = useBranding();

    useEffect(() => {
        featureApi.getFeatures().then(features => {
            const feature: ConfiguredFeatureDto = features.filter(f => f.id === 'af2ef520-8153-42b0-9ef4-d8419daebc23')[0];
            const featureEnabled = feature && (feature.configuredValue || feature.defaultValue) === 'true';
            setPhotosEnabled(featureEnabled);
        });
    },
    // eslint-disable-next-line
    []);

    useEffect(() => {
            /* istanbul ignore next */
            if (loading !== 'init' || appLoading) {
                /* istanbul ignore next */
                return;
            }

            if (seasons.length) {
                setLoading('loading');
                // noinspection JSIgnoredPromiseFromCall
                loadFixtureData();
            } else {
                onError('No seasons found');
            }
        },
        // eslint-disable-next-line
        [appLoading, loading, seasons]);

    async function loadFixtureData() {
        try {
            const tournamentData: TournamentGameDto = await tournamentApi.get(tournamentId);

            if (!tournamentData) {
                onError('Tournament could not be found');
                return;
            }

            await updateTournamentData(tournamentData);

            const tournamentPlayerMap: ITournamentPlayerMap = {};
            if (canManageTournaments) {
                const filter: DivisionDataFilter = {
                    seasonId: tournamentData.seasonId,
                    divisionId: [ tournamentData.divisionId ].filter((id: string) => !!id),
                };

                const divisionData: DivisionDataDto = await divisionApi.data(filter);
                const fixtureDate: DivisionFixtureDateDto = divisionData.fixtures.filter(f => f.date === tournamentData.date)[0];
                if (fixtureDate) {
                    const tournamentFixtures: DivisionTournamentFixtureDetailsDto[] = fixtureDate.tournamentFixtures
                        .filter((f: DivisionTournamentFixtureDetailsDto) => !f.proposed && f.id !== tournamentData.id);
                    for (const tournamentFixture of tournamentFixtures) {
                        tournamentFixture.players.forEach((playerId: string) => {
                            tournamentPlayerMap[playerId] = tournamentFixture;
                        });
                    }
                }
            }
            setAlreadyPlaying(tournamentPlayerMap);
        } catch (e) {
            /* istanbul ignore next */
            onError(e);
        } finally {
            setLoading('ready');
        }
    }

    function getMatchOptionDefaults(tournamentData: TournamentGameDto): GameMatchOptionDto {
        return {
            startingScore: 501,
            numberOfLegs: tournamentData.bestOf || 5,
        };
    }

    function getAllPlayers(tournamentData: TournamentGameDto): ISelectablePlayer[] {
        const selectedTournamentPlayers: ISelectablePlayer[] = tournamentData.sides
            ? tournamentData.sides
                .filter((s: TournamentSideDto) => !s.noShow)
                .flatMap((side: TournamentSideDto) => side.players || [])
                .map((p: TournamentPlayerDto) => p as ISelectablePlayer)
            : [];

        if (any(selectedTournamentPlayers)) {
            return selectedTournamentPlayers.sort(sortBy('name'));
        }

        const selectedTournamentTeams: string[] = tournamentData.sides
            ? tournamentData.sides.filter((s: TournamentSideDto) => !s.noShow).map((side: TournamentSideDto) => side.teamId)
            : [];

        const players: ISelectablePlayer[] = teams
            .filter((t: TeamDto) => any(selectedTournamentTeams, (id: string) => id === t.id))
            .map((t: TeamDto) => t.seasons.filter((ts: TeamSeasonDto) => ts.seasonId === tournamentData.seasonId && !ts.deleted)[0])
            .filter((teamSeasonDto: TeamSeasonDto) => teamSeasonDto)
            .flatMap((teamSeason: TeamSeasonDto) => teamSeason.players.map((p: TeamPlayerDto) => p as ISelectablePlayer));

        return players.sort(sortBy('name'));
    }

    async function saveTournament(preventLoading?: boolean | React.MouseEvent): Promise<TournamentGameDto> {
        /* istanbul ignore next */
        if (saving || patching) {
            /* istanbul ignore next */
            return;
        }

        if (preventLoading !== true) {
            setSaving(true);
        }

        try {
            const update: EditTournamentGameDto = tournamentData;
            update.lastUpdated = tournamentData.updated;

            const response: IClientActionResultDto<TournamentGameDto> = await tournamentApi.update(update);
            if (!response.success) {
                setSaveError(response);
            } else {
                await updateTournamentData(response.result);
                await publishLiveUpdate(response.result);
                return response.result;
            }
        } finally {
            if (preventLoading !== true) {
                setSaving(false);
            }
        }
    }

    async function applyPatch(patch: PatchTournamentDto | PatchTournamentRoundDto, nestInRound: boolean): Promise<boolean> {
        /* istanbul ignore next */
        if (saving || patching) {
            /* istanbul ignore next */
            return false;
        }

        setPatching(true);

        try {
            const response: IClientActionResultDto<TournamentGameDto> = await tournamentApi.patch(
                tournamentId,
                nestInRound ? ({round: patch} as PatchTournamentDto) : patch as PatchTournamentDto);

            if (!response.success) {
                setSaveError(response);
                return false;
            } else {
                await updateTournamentData(response.result);
                await publishLiveUpdate(response.result);
                return true;
            }
        } finally {
            setPatching(false);
        }
    }

    async function publishLiveUpdate(data: TournamentGameDto) {
        if (canManageTournaments) {
            if (!await webSocket.publish(tournamentId, LiveDataType.tournament, data)) {
                window.alert('Unable to publish updated data');
            }
        }
    }

    function renderCreatePlayerDialog(season: SeasonDto) {
        return (<Dialog title={`Add a player...`}>
            <EditPlayerDetails
                player={newPlayerDetails}
                seasonId={season.id}
                divisionId={tournamentData.divisionId}
                onChange={propChanged(newPlayerDetails, setNewPlayerDetails)}
                onCancel={async () => setAddPlayerDialogOpen(false)}
                onSaved={reloadPlayers}
            />
        </Dialog>);
    }

    async function reloadPlayers() {
        await reloadTeams();
        setAddPlayerDialogOpen(false);
        setNewPlayerDetails({name: '', captain: false});
    }

    async function updateTournamentData(newData: TournamentGameDto) {
        try {
            const matchOptionsHaveChanged = tournamentData && tournamentData.bestOf !== newData.bestOf;
            if (matchOptionsHaveChanged && newData.round) {
                updateMatchOptions(newData.round, newData.bestOf);
            }

            setTournamentData(newData);
            setAllPlayers(getAllPlayers(newData));
        } catch (e) {
            onError(e);
        }
    }

    function updateMatchOptions(round: TournamentRoundDto, numberOfLegs: number) {
        for (const matchOptions of round.matchOptions) {
            matchOptions.numberOfLegs = numberOfLegs;
        }

        if (round.nextRound) {
            updateMatchOptions(round.nextRound, numberOfLegs);
        }
    }

    async function uploadPhotos(file: File): Promise<boolean> {
        const request: UploadPhotoDto = {
            id: tournamentData.id,
        };
        const result: IClientActionResultDto<TournamentGameDto> = await tournamentApi.uploadPhoto(request, file);

        if (result.success) {
            await updateTournamentData(result.result);
            return true;
        }

        setSaveError(result);
        return false;
    }

    async function deletePhotos(id: string): Promise<boolean> {
        const result: IClientActionResultDto<TournamentGameDto> = await tournamentApi.deletePhoto(tournamentData.id, id);

        if (result.success) {
            await updateTournamentData(result.result);
            return true;
        }

        setSaveError(result);
        return false;
    }

    async function closeEditTournamentDialog() {
        // if any matches exist, but have not been added, add them?
        if (warnBeforeEditDialogClose) {
            window.alert(warnBeforeEditDialogClose);
            return;
        }

        await saveTournament();
        setEditTournament(null);
    }

    if (loading !== 'ready') {
        return (<Loading/>);
    }

    try {
        const season: SeasonDto = tournamentData
            ? seasons.filter(s => s.id === tournamentData.seasonId)[0]
            : {id: EMPTY_ID, name: 'Not found'};
        if (!season) {
            // noinspection ExceptionCaughtLocallyJS
            throw new Error('Could not find the season for this tournament');
        }

        const liveOptions: ILiveOptions = {
            publish: canManageTournaments,
            canSubscribe: false,
            subscribeAtStartup: [],
        };

        if (tournamentData && tournamentData.singleRound) {
            setTitle(`${tournamentData.host} vs ${tournamentData.opponent} - ${renderDate(tournamentData.date)}`);
        } else if (tournamentData) {
            setTitle(`${tournamentData.type || 'tournament'} at ${tournamentData.address} - ${renderDate(tournamentData.date)}`);
        }

        return (<div className="landscape">
            <DivisionControls
                originalSeasonData={season}
                originalDivisionData={division}
                overrideMode="fixtures"/>
            {canManageTournaments && tournamentData && editTournament === 'details'
                ? (<Dialog onClose={closeEditTournamentDialog} className="d-print-none">
                    <TournamentDetails
                        tournamentData={tournamentData}
                        disabled={saving}
                        setTournamentData={async (data: TournamentGameDto) => updateTournamentData(data)} />
                </Dialog>)
                : null}
            {tournamentData ? (<div className="content-background p-3">
                <TournamentContainer
                    tournamentData={tournamentData}
                    setTournamentData={updateTournamentData}
                    season={season}
                    division={division}
                    alreadyPlaying={alreadyPlaying}
                    allPlayers={allPlayers}
                    saveTournament={saveTournament}
                    setWarnBeforeEditDialogClose={async (warning: string) => setWarnBeforeEditDialogClose(warning)}
                    matchOptionDefaults={getMatchOptionDefaults(tournamentData)}
                    saving={saving}
                    editTournament={editTournament}
                    setEditTournament={canManageTournaments ? async (value: string) => setEditTournament(value) : null}
                    liveOptions={liveOptions}
                    preventScroll={preventScroll}
                    setPreventScroll={setPreventScroll}>
                    {canManageTournaments && tournamentData && editTournament === 'matches'
                        ? (<Dialog title="Edit sides and matches" onClose={closeEditTournamentDialog} className="d-print-none">
                            <EditTournament canSave={true} saving={saving} />
                        </Dialog>)
                        : null}
                    {tournamentData.singleRound && !canManageTournaments ? (<SuperLeaguePrintout division={division} readOnly={true}/>) : null}
                    {tournamentData.singleRound && canManageTournaments ? (<div>
                        <SuperLeaguePrintout division={division} patchData={applyPatch} />
                    </div>) : null}
                    {tournamentData.singleRound
                        ? null
                        : (<PrintableSheet
                            patchData={applyPatch}
                            editable={canEnterTournamentResults || canManageTournaments} />)}
                </TournamentContainer>
                {(canManageTournaments || canEnterTournamentResults) && !tournamentData.singleRound ? (
                    <button className="btn btn-primary d-print-none margin-right" onClick={saveTournament}>
                        {saving ? (<LoadingSpinnerSmall/>) : null}
                        Save
                    </button>) : null}
                {canManagePlayers && !tournamentData.singleRound ? (
                    <button className="btn btn-primary d-print-none margin-right" onClick={() => setAddPlayerDialogOpen(true)}>Add
                        player</button>) : null}
                {account && account.access && (account.access.uploadPhotos || account.access.viewAnyPhoto) && photosEnabled && !tournamentData.singleRound
                    ? (<button className="btn btn-primary d-print-none margin-right" onClick={() => setShowPhotoManager(true)}>📷 Photos</button>)
                    : null}
            </div>) : (<div>Tournament not found</div>)}
            {showPhotoManager ? (<PhotoManager
                doUpload={uploadPhotos}
                photos={tournamentData.photos}
                onClose={async () => setShowPhotoManager(false)}
                doDelete={deletePhotos}
                canUploadPhotos={account && account.access && account.access.uploadPhotos}
                canDeletePhotos={account && account.access && (account.access.uploadPhotos || account.access.deleteAnyPhoto)}
                canViewAllPhotos={account && account.access && account.access.viewAnyPhoto}
            />) : null}
            {saveError ? (<ErrorDisplay {...saveError} onClose={async () => setSaveError(null)}
                                        title="Could not save tournament details"/>) : null}
            {addPlayerDialogOpen ? renderCreatePlayerDialog(season) : null}
        </div>);
    } catch (e) {
        /* istanbul ignore next */
        onError(e);
    }
}

1	import React, {useEffect, useState} from 'react';	2✔
2	import {useParams} from "react-router-dom";	2✔
3	import {DivisionControls} from "../league/DivisionControls";	2✔
4	import {ErrorDisplay} from "../common/ErrorDisplay";	2✔
5	import {any, sortBy} from "../../helpers/collections";	2✔
6	import {propChanged} from "../../helpers/events";	2✔
7	import {Loading} from "../common/Loading";	2✔
8	import {EditTournament} from "./EditTournament";	2✔
9	import {useDependencies} from "../common/IocContainer";	2✔
10	import {useApp} from "../common/AppContainer";	2✔
11	import {Dialog} from "../common/Dialog";	2✔
12	import {EditPlayerDetails} from "../division_players/EditPlayerDetails";	2✔
13	import {EMPTY_ID} from "../../helpers/projection";	2✔
14	import {TournamentContainer} from "./TournamentContainer";	2✔
15	import {SuperLeaguePrintout} from "./superleague/SuperLeaguePrintout";	2✔
16	import {PrintableSheet} from "./PrintableSheet";	2✔
17	import {LoadingSpinnerSmall} from "../common/LoadingSpinnerSmall";	2✔
18	import {TournamentGameDto} from "../../interfaces/models/dtos/Game/TournamentGameDto";
19	import {IClientActionResultDto} from "../common/IClientActionResultDto";
20	import {DivisionDataDto} from "../../interfaces/models/dtos/Division/DivisionDataDto";
21	import {DivisionFixtureDateDto} from "../../interfaces/models/dtos/Division/DivisionFixtureDateDto";
22	import {TournamentPlayerDto} from "../../interfaces/models/dtos/Game/TournamentPlayerDto";
23	import {TournamentSideDto} from "../../interfaces/models/dtos/Game/TournamentSideDto";
24	import {TeamDto} from "../../interfaces/models/dtos/Team/TeamDto";
25	import {GameMatchOptionDto} from "../../interfaces/models/dtos/Game/GameMatchOptionDto";
26	import {SeasonDto} from "../../interfaces/models/dtos/Season/SeasonDto";
27	import {DivisionDto} from "../../interfaces/models/dtos/DivisionDto";
28	import {EditTeamPlayerDto} from "../../interfaces/models/dtos/Team/EditTeamPlayerDto";
29	import {ILiveOptions} from "../../live/ILiveOptions";
30	import {ISelectablePlayer} from "../common/PlayerSelection";
31	import {PatchTournamentDto} from "../../interfaces/models/dtos/Game/PatchTournamentDto";
32	import {PatchTournamentRoundDto} from "../../interfaces/models/dtos/Game/PatchTournamentRoundDto";
33	import {TeamPlayerDto} from "../../interfaces/models/dtos/Team/TeamPlayerDto";
34	import {TeamSeasonDto} from "../../interfaces/models/dtos/Team/TeamSeasonDto";
35	import {DivisionDataFilter} from "../../interfaces/models/dtos/Division/DivisionDataFilter";
36	import {EditTournamentGameDto} from "../../interfaces/models/dtos/Game/EditTournamentGameDto";
37	import {TournamentDetails} from "./TournamentDetails";	2✔
38	import {TournamentRoundDto} from "../../interfaces/models/dtos/Game/TournamentRoundDto";
39	import {LiveDataType} from "../../interfaces/models/dtos/Live/LiveDataType";	2✔
40	import {PhotoManager} from "../common/PhotoManager";	2✔
41	import {UploadPhotoDto} from "../../interfaces/models/dtos/UploadPhotoDto";
42	import {ConfiguredFeatureDto} from "../../interfaces/models/dtos/ConfiguredFeatureDto";
43	import {
44	DivisionTournamentFixtureDetailsDto
45	} from "../../interfaces/models/dtos/Division/DivisionTournamentFixtureDetailsDto";
46	import {useBranding} from "../common/BrandingContainer";	2✔
47	import {renderDate} from "../../helpers/rendering";	2✔
48
49	export interface ITournamentPlayerMap {
50	[id: string]: DivisionTournamentFixtureDetailsDto;
51	}
52
53	export function Tournament() {	2✔
54	const {tournamentId} = useParams();	250✔
55	const {appLoading, account, seasons, onError, teams, reloadTeams, divisions} = useApp();	250✔
56	const {divisionApi, tournamentApi, webSocket, featureApi} = useDependencies();	250✔
57	const canManageTournaments: boolean = account && account.access && account.access.manageTournaments;	250✔
58	const canManagePlayers: boolean = account && account.access && account.access.managePlayers;	250✔
59	const canEnterTournamentResults = account && account.access && account.access.enterTournamentResults;	250✔
60	const [loading, setLoading] = useState<string>('init');	250✔
61	const [saving, setSaving] = useState<boolean>(false);	250✔
62	const [patching, setPatching] = useState<boolean>(false);	250✔
63	const [preventScroll, setPreventScroll] = useState<boolean>(false);	250✔
64	const [tournamentData, setTournamentData] = useState<TournamentGameDto \| null>(null);	250✔
65	const [saveError, setSaveError] = useState<IClientActionResultDto<TournamentGameDto> \| null>(null);	250✔
66	const [allPlayers, setAllPlayers] = useState<ISelectablePlayer[]>([]);	250✔
67	const [alreadyPlaying, setAlreadyPlaying] = useState<ITournamentPlayerMap \| null>(null);	250✔
68	const [addPlayerDialogOpen, setAddPlayerDialogOpen] = useState<boolean>(false);	250✔
69	const [newPlayerDetails, setNewPlayerDetails] = useState<EditTeamPlayerDto>({name: '', captain: false});	250✔
70	const [warnBeforeEditDialogClose, setWarnBeforeEditDialogClose] = useState(null);	250✔
71	const division: DivisionDto = tournamentData && tournamentData.divisionId ? divisions.filter(d => d.id === tournamentData.divisionId)[0] : null;	250✔
72	const [editTournament, setEditTournament] = useState<string>(null);	250✔
73	const [showPhotoManager, setShowPhotoManager] = useState(false);	250✔
74	const [photosEnabled, setPhotosEnabled] = useState(false);	250✔
75	const {setTitle} = useBranding();	250✔
76
77	useEffect(() => {	250✔
78	featureApi.getFeatures().then(features => {	49✔
79	const feature: ConfiguredFeatureDto = features.filter(f => f.id === 'af2ef520-8153-42b0-9ef4-d8419daebc23')[0];	49✔
80	const featureEnabled = feature && (feature.configuredValue \|\| feature.defaultValue) === 'true';	49!
81	setPhotosEnabled(featureEnabled);	49✔
82	});
83	},
84	// eslint-disable-next-line
85	[]);
86
87	useEffect(() => {	250✔
88	/* istanbul ignore next */
89	if (loading !== 'init' \|\| appLoading) {
90	/* istanbul ignore next */
91	return;
92	}
93
94	if (seasons.length) {	47✔
95	setLoading('loading');	45✔
96	// noinspection JSIgnoredPromiseFromCall
97	loadFixtureData();	45✔
98	} else {
99	onError('No seasons found');	2✔
100	}
101	},
102	// eslint-disable-next-line
103	[appLoading, loading, seasons]);
104
105	async function loadFixtureData() {
106	try {	45✔
107	const tournamentData: TournamentGameDto = await tournamentApi.get(tournamentId);	45✔
108
109	if (!tournamentData) {	45✔
110	onError('Tournament could not be found');	1✔
111	return;	1✔
112	}
113
114	await updateTournamentData(tournamentData);	44✔
115
116	const tournamentPlayerMap: ITournamentPlayerMap = {};	44✔
117	if (canManageTournaments) {	44✔
118	const filter: DivisionDataFilter = {	36✔
119	seasonId: tournamentData.seasonId,
120	divisionId: [ tournamentData.divisionId ].filter((id: string) => !!id),	36✔
121	};
122
123	const divisionData: DivisionDataDto = await divisionApi.data(filter);	36✔
124	const fixtureDate: DivisionFixtureDateDto = divisionData.fixtures.filter(f => f.date === tournamentData.date)[0];	36✔
125	if (fixtureDate) {	36!
126	const tournamentFixtures: DivisionTournamentFixtureDetailsDto[] = fixtureDate.tournamentFixtures	×
127	.filter((f: DivisionTournamentFixtureDetailsDto) => !f.proposed && f.id !== tournamentData.id);	×
NEW 128	for (const tournamentFixture of tournamentFixtures) {	×
129	tournamentFixture.players.forEach((playerId: string) => {	×
130	tournamentPlayerMap[playerId] = tournamentFixture;	×
131	});
132	}
133	}
134	}
135	setAlreadyPlaying(tournamentPlayerMap);	44✔
136	} catch (e) {
137	/* istanbul ignore next */
138	onError(e);
139	} finally {
140	setLoading('ready');	45✔
141	}
142	}
143
144	function getMatchOptionDefaults(tournamentData: TournamentGameDto): GameMatchOptionDto {
145	return {	150✔
146	startingScore: 501,
147	numberOfLegs: tournamentData.bestOf \|\| 5,	278✔
148	};
149	}
150
151	function getAllPlayers(tournamentData: TournamentGameDto): ISelectablePlayer[] {
152	const selectedTournamentPlayers: ISelectablePlayer[] = tournamentData.sides	75!
153	? tournamentData.sides
154	.filter((s: TournamentSideDto) => !s.noShow)	92✔
155	.flatMap((side: TournamentSideDto) => side.players \|\| [])	90✔
156	.map((p: TournamentPlayerDto) => p as ISelectablePlayer)	84✔
157	: [];
158
159	if (any(selectedTournamentPlayers)) {	75✔
160	return selectedTournamentPlayers.sort(sortBy('name'));	43✔
161	}
162
163	const selectedTournamentTeams: string[] = tournamentData.sides	32!
164	? tournamentData.sides.filter((s: TournamentSideDto) => !s.noShow).map((side: TournamentSideDto) => side.teamId)	3✔
165	: [];
166
167	const players: ISelectablePlayer[] = teams	32✔
168	.filter((t: TeamDto) => any(selectedTournamentTeams, (id: string) => id === t.id))	13✔
169	.map((t: TeamDto) => t.seasons.filter((ts: TeamSeasonDto) => ts.seasonId === tournamentData.seasonId && !ts.deleted)[0])	2✔
170	.filter((teamSeasonDto: TeamSeasonDto) => teamSeasonDto)	2✔
171	.flatMap((teamSeason: TeamSeasonDto) => teamSeason.players.map((p: TeamPlayerDto) => p as ISelectablePlayer));	1✔
172
173	return players.sort(sortBy('name'));	32✔
174	}
175
176	async function saveTournament(preventLoading?: boolean \| React.MouseEvent): Promise<TournamentGameDto> {
177	/* istanbul ignore next */
178	if (saving \|\| patching) {
179	/* istanbul ignore next */
180	return;
181	}
182
183	if (preventLoading !== true) {	10✔
184	setSaving(true);	10✔
185	}
186
187	try {	10✔
188	const update: EditTournamentGameDto = tournamentData;	10✔
189	update.lastUpdated = tournamentData.updated;	10✔
190
191	const response: IClientActionResultDto<TournamentGameDto> = await tournamentApi.update(update);	10✔
192	if (!response.success) {	10✔
193	setSaveError(response);	2✔
194	} else {
195	await updateTournamentData(response.result);	8✔
196	await publishLiveUpdate(response.result);	8✔
197	return response.result;	8✔
198	}
199	} finally {
200	if (preventLoading !== true) {	10✔
201	setSaving(false);	10✔
202	}
203	}
204	}
205
206	async function applyPatch(patch: PatchTournamentDto \| PatchTournamentRoundDto, nestInRound: boolean): Promise<boolean> {
207	/* istanbul ignore next */
208	if (saving \|\| patching) {
209	/* istanbul ignore next */
210	return false;
211	}
212
213	setPatching(true);	5✔
214
215	try {	5✔
216	const response: IClientActionResultDto<TournamentGameDto> = await tournamentApi.patch(	5✔
217	tournamentId,
218	nestInRound ? ({round: patch} as PatchTournamentDto) : patch as PatchTournamentDto);	5✔
219
220	if (!response.success) {	5✔
221	setSaveError(response);	1✔
222	return false;	1✔
223	} else {
224	await updateTournamentData(response.result);	4✔
225	await publishLiveUpdate(response.result);	4✔
226	return true;	4✔
227	}
228	} finally {
229	setPatching(false);	5✔
230	}
231	}
232
233	async function publishLiveUpdate(data: TournamentGameDto) {
234	if (canManageTournaments) {	12✔
235	if (!await webSocket.publish(tournamentId, LiveDataType.tournament, data)) {	12!
236	window.alert('Unable to publish updated data');	×
237	}
238	}
239	}
240
241	function renderCreatePlayerDialog(season: SeasonDto) {
242	return (<Dialog title={`Add a player...`}>	5✔
243	<EditPlayerDetails
244	player={newPlayerDetails}
245	seasonId={season.id}
246	divisionId={tournamentData.divisionId}
247	onChange={propChanged(newPlayerDetails, setNewPlayerDetails)}
248	onCancel={async () => setAddPlayerDialogOpen(false)}	1✔
249	onSaved={reloadPlayers}
250	/>
251	</Dialog>);
252	}
253
254	async function reloadPlayers() {
255	await reloadTeams();	1✔
256	setAddPlayerDialogOpen(false);	1✔
257	setNewPlayerDetails({name: '', captain: false});	1✔
258	}
259
260	async function updateTournamentData(newData: TournamentGameDto) {
261	try {	75✔
262	const matchOptionsHaveChanged = tournamentData && tournamentData.bestOf !== newData.bestOf;	75✔
263	if (matchOptionsHaveChanged && newData.round) {	75✔
264	updateMatchOptions(newData.round, newData.bestOf);	1✔
265	}
266
267	setTournamentData(newData);	75✔
268	setAllPlayers(getAllPlayers(newData));	75✔
269	} catch (e) {
270	onError(e);	×
271	}
272	}
273
274	function updateMatchOptions(round: TournamentRoundDto, numberOfLegs: number) {
275	for (const matchOptions of round.matchOptions) {	2✔
276	matchOptions.numberOfLegs = numberOfLegs;	2✔
277	}
278
279	if (round.nextRound) {	2✔
280	updateMatchOptions(round.nextRound, numberOfLegs);	1✔
281	}
282	}
283
284	async function uploadPhotos(file: File): Promise<boolean> {
285	const request: UploadPhotoDto = {	2✔
286	id: tournamentData.id,
287	};
288	const result: IClientActionResultDto<TournamentGameDto> = await tournamentApi.uploadPhoto(request, file);	2✔
289
290	if (result.success) {	2✔
291	await updateTournamentData(result.result);	1✔
292	return true;	1✔
293	}
294
295	setSaveError(result);	1✔
296	return false;	1✔
297	}
298
299	async function deletePhotos(id: string): Promise<boolean> {
300	const result: IClientActionResultDto<TournamentGameDto> = await tournamentApi.deletePhoto(tournamentData.id, id);	2✔
301
302	if (result.success) {	2✔
303	await updateTournamentData(result.result);	1✔
304	return true;	1✔
305	}
306
307	setSaveError(result);	1✔
308	return false;	1✔
309	}
310
311	async function closeEditTournamentDialog() {
312	// if any matches exist, but have not been added, add them?
313	if (warnBeforeEditDialogClose) {	7✔
314	window.alert(warnBeforeEditDialogClose);	1✔
315	return;	1✔
316	}
317
318	await saveTournament();	6✔
319	setEditTournament(null);	6✔
320	}
321
322	if (loading !== 'ready') {	250✔
323	return (<Loading/>);	98✔
324	}
325
326	try {	152✔
327	const season: SeasonDto = tournamentData	152✔
328	? seasons.filter(s => s.id === tournamentData.seasonId)[0]	151✔
329	: {id: EMPTY_ID, name: 'Not found'};
330	if (!season) {	152✔
331	// noinspection ExceptionCaughtLocallyJS
332	throw new Error('Could not find the season for this tournament');	1✔
333	}
334
335	const liveOptions: ILiveOptions = {	151✔
336	publish: canManageTournaments,
337	canSubscribe: false,
338	subscribeAtStartup: [],
339	};
340
341	if (tournamentData && tournamentData.singleRound) {	151✔
342	setTitle(`${tournamentData.host} vs ${tournamentData.opponent} - ${renderDate(tournamentData.date)}`);	65✔
343	} else if (tournamentData) {	86✔
344	setTitle(`${tournamentData.type \|\| 'tournament'} at ${tournamentData.address} - ${renderDate(tournamentData.date)}`);	85!
345	}
346
347	return (<div className="landscape">	151✔
348	<DivisionControls
349	originalSeasonData={season}
350	originalDivisionData={division}
351	overrideMode="fixtures"/>
352	{canManageTournaments && tournamentData && editTournament === 'details'	588✔
353	? (<Dialog onClose={closeEditTournamentDialog} className="d-print-none">
354	<TournamentDetails
355	tournamentData={tournamentData}
356	disabled={saving}
357	setTournamentData={async (data: TournamentGameDto) => updateTournamentData(data)} />	2✔
358	</Dialog>)
359	: null}
360	{tournamentData ? (<div className="content-background p-3">	151✔
361	<TournamentContainer
362	tournamentData={tournamentData}
363	setTournamentData={updateTournamentData}
364	season={season}
365	division={division}
366	alreadyPlaying={alreadyPlaying}
367	allPlayers={allPlayers}
368	saveTournament={saveTournament}
369	setWarnBeforeEditDialogClose={async (warning: string) => setWarnBeforeEditDialogClose(warning)}	17✔
370	matchOptionDefaults={getMatchOptionDefaults(tournamentData)}
371	saving={saving}
372	editTournament={editTournament}
373	setEditTournament={canManageTournaments ? async (value: string) => setEditTournament(value) : null}	11✔
374	liveOptions={liveOptions}
375	preventScroll={preventScroll}
376	setPreventScroll={setPreventScroll}>
377	{canManageTournaments && tournamentData && editTournament === 'matches'	586✔
378	? (<Dialog title="Edit sides and matches" onClose={closeEditTournamentDialog} className="d-print-none">
379	<EditTournament canSave={true} saving={saving} />
380	</Dialog>)
381	: null}
382	{tournamentData.singleRound && !canManageTournaments ? (<SuperLeaguePrintout division={division} readOnly={true}/>) : null}	365✔
383	{tournamentData.singleRound && canManageTournaments ? (<div>	365✔
384	<SuperLeaguePrintout division={division} patchData={applyPatch} />
385	</div>) : null}
386	{tournamentData.singleRound	150✔
387	? null
388	: (<PrintableSheet
389	patchData={applyPatch}
390	editable={canEnterTournamentResults \|\| canManageTournaments} />)}	170✔
391	</TournamentContainer>
392	{(canManageTournaments \|\| canEnterTournamentResults) && !tournamentData.singleRound ? (	450✔
393	<button className="btn btn-primary d-print-none margin-right" onClick={saveTournament}>
394	{saving ? (<LoadingSpinnerSmall/>) : null}	80✔
395	Save
396	</button>) : null}
397	{canManagePlayers && !tournamentData.singleRound ? (	443✔
398	<button className="btn btn-primary d-print-none margin-right" onClick={() => setAddPlayerDialogOpen(true)}>Add	3✔
399	player</button>) : null}
400	{account && account.access && (account.access.uploadPhotos \|\| account.access.viewAnyPhoto) && photosEnabled && !tournamentData.singleRound	753✔
401	? (<button className="btn btn-primary d-print-none margin-right" onClick={() => setShowPhotoManager(true)}>📷 Photos</button>)	6✔
402	: null}
403	</div>) : (<div>Tournament not found</div>)}
404	{showPhotoManager ? (<PhotoManager	151✔
405	doUpload={uploadPhotos}
406	photos={tournamentData.photos}
407	onClose={async () => setShowPhotoManager(false)}	3✔
408	doDelete={deletePhotos}
409	canUploadPhotos={account && account.access && account.access.uploadPhotos}	27✔
410	canDeletePhotos={account && account.access && (account.access.uploadPhotos \|\| account.access.deleteAnyPhoto)}	27!
411	canViewAllPhotos={account && account.access && account.access.viewAnyPhoto}	27✔
412	/>) : null}
413	{saveError ? (<ErrorDisplay {...saveError} onClose={async () => setSaveError(null)}	1✔
414	title="Could not save tournament details"/>) : null}
415	{addPlayerDialogOpen ? renderCreatePlayerDialog(season) : null}	151✔
416	</div>);
417	} catch (e) {
418	/* istanbul ignore next */
419	onError(e);
420	}
421	}

laingsimon / courage_scores / 11298984545

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous