/// <summary>
        /// Diese Methode erstellt aus den Turnierdaten eine Excel-Datei
        /// </summary>
        public void Export(SpreadsheetDocument document, SheetData sheetData, WorksheetPart worksheetPart)
        {
            int rowsToCreate = RowsCounter.CalculateRowsToCreate(Rounds);

            RowsCreator.CreateRows(sheetData, rowsToCreate);
            EvaluateRowData(worksheetPart);

            // Datei Speichern
            document.WorkbookPart.Workbook.Save();
        }
Пример #2
0
        public void Export(SpreadsheetDocument document, SheetData sheetData, WorksheetPart worksheetPart)
        {
            if (Groups.Count == 0)
            {
                return;
            }

            int rowsToCreate = RowsCounter.CalculateRowsToCreate(AllMatches.Count, Groups);

            RowsCreator.CreateRows(sheetData, rowsToCreate);

            int matchesInRow   = 1;
            int matchRowNumber = 2;

            for (int i = 0; i < AllMatches.Count; i++)
            {
                var match       = AllMatches[i];
                var matchPoints = Adapters.MatchAdapter.GetMatchInformationForExcelExport(match);
                var p1Cell      = CellFinder.GetCell(worksheetPart.Worksheet, matchesInRow, matchRowNumber);
                p1Cell.CellValue = new CellValue(match.PlayerOne);
                p1Cell.DataType  = new EnumValue <CellValues>(CellValues.String);
                var p1P = CellFinder.GetCell(worksheetPart.Worksheet, matchesInRow + 1, matchRowNumber);
                p1P.CellValue = new CellValue(matchPoints.Item1);
                p1P.DataType  = new EnumValue <CellValues>(CellValues.Number);

                var p2Cell = CellFinder.GetCell(worksheetPart.Worksheet, matchesInRow, matchRowNumber + 1);
                p2Cell.CellValue = new CellValue(match.PlayerTwo);
                p2Cell.DataType  = new EnumValue <CellValues>(CellValues.String);
                var p2P = CellFinder.GetCell(worksheetPart.Worksheet, matchesInRow + 1, matchRowNumber + 1);
                p2P.CellValue = new CellValue(matchPoints.Item2);
                p2P.DataType  = new EnumValue <CellValues>(CellValues.Number);

                if (matchesInRow < 10)
                {
                    matchesInRow += 3;
                }
                else
                {
                    matchesInRow    = 1;
                    matchRowNumber += 3;
                }
            }

            matchRowNumber += 3;
            foreach (var group in Groups)
            {
                int    columnIndex = 1;
                var    gCell       = CellFinder.GetCell(worksheetPart.Worksheet, columnIndex, matchRowNumber);
                string gName       = $"Group {group.Key}";
                gCell.CellValue = new CellValue(gName);
                gCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                foreach (var player in group.Value)
                {
                    matchRowNumber++;
                    var pCell = CellFinder.GetCell(worksheetPart.Worksheet, columnIndex, matchRowNumber);
                    pCell.CellValue = new CellValue(player.PlayerName.Title);
                    pCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                    var dCell = CellFinder.GetCell(worksheetPart.Worksheet, columnIndex + 1, matchRowNumber);
                    dCell.CellValue = new CellValue(player.GoalDifference);
                    dCell.DataType  = new EnumValue <CellValues>(CellValues.Number);

                    var pointsCell = CellFinder.GetCell(worksheetPart.Worksheet, columnIndex + 2, matchRowNumber);
                    pointsCell.CellValue = new CellValue(player.Points);
                    pointsCell.DataType  = new EnumValue <CellValues>(CellValues.Number);
                }

                matchRowNumber += 2;
            }

            // Datei Speichern
            document.WorkbookPart.Workbook.Save();
        }
        public void Export(SpreadsheetDocument document, SheetData sheetData, WorksheetPart worksheetPart)
        {
            RowsCreator.CreateRows(sheetData, 100);

            // Variablen für die Startpositionen des ersten Spiels der jeweiligen Runde
            // nextStartPosition ist dafür da, sich die Position zu merken, wann das erste "VS"
            // der vorigen Runde gesetzt wird, da dort das erste Spiel der nächsten Runde beginnt,
            // damit die Excel-Datei am Ende wie ein richtiger Turnierbaum aussieht
            int startPosition           = 3;
            int?nextStartposition       = null;
            int?firstLoserStartPosition = null;

            // Nun jede Runde der KO-Runde durchgehen
            for (int i = 0; i <= WinnerRounds.Count; i++)
            {
                // Zelle ermittelt, in die der Rundenname geschrieben wird
                Cell   cell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, 2);
                string text = $"Round {i + 1}";
                if (i == WinnerRounds.Count)
                {
                    text = "Winner";
                }

                // Rundenname in die Zelle schreiben
                cell.CellValue = new CellValue(text);
                cell.DataType  = new EnumValue <CellValues>(CellValues.String);

                // Da die for-Schleife ein Mal öfter als die eigentliche Rundenanzahl läuft
                // gibt es hier eine Überprüfung, da es sonst zu einem Absturz kommen würde
                // Die for-Schleife läuft so oft, da am Ende ja noch der Gewinner in die Datei
                // geschrieben werden muss.
                if (i < WinnerRounds.Count)
                {
                    // Jedes Spiel jeder Runde durchgehen
                    foreach (var match in WinnerRounds[i].Matches)
                    {
                        // Daten des Spiels in die Zellen schreiben
                        // Erster Spieler des Spiels
                        var firstPlayerCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, startPosition);
                        firstPlayerCell.CellValue = new CellValue(match.PlayerOne);
                        firstPlayerCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                        // VS
                        var vsPosition = startPosition + Convert.ToInt32(Math.Pow(2, i));
                        if (!nextStartposition.HasValue)
                        {
                            nextStartposition = vsPosition;
                        }
                        var vsCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, vsPosition);
                        vsCell.CellValue = new CellValue("vs");
                        vsCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                        // Zweiter Spieler des Spiels
                        var secondPlayerCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, startPosition + 2 * Convert.ToInt32(Math.Pow(2, i)));
                        secondPlayerCell.CellValue = new CellValue(match.PlayerTwo);
                        secondPlayerCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                        // Nun wird die Startposition für das nächste Spiel berechnet
                        startPosition = startPosition + Convert.ToInt32(Math.Pow(2, i + 2));
                    }

                    if (!firstLoserStartPosition.HasValue)
                    {
                        var position = startPosition + 2 * Convert.ToInt32(Math.Pow(2, i));
                        firstLoserStartPosition = position + 2;
                    }
                }
                else
                {
                    // Gewinner eintragen
                    var match  = WinnerRounds[i - 1].Matches[0];
                    var winner = match.FirstPlayerWin ? match.PlayerOne : match.PlayerTwo;

                    var winnerCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, startPosition);
                    winnerCell.CellValue = new CellValue(winner);
                    winnerCell.DataType  = new EnumValue <CellValues>(CellValues.String);
                }

                if (nextStartposition.HasValue)
                {
                    // Wenn die nextStartPosition-Variable nun gesetzt ist, dann wird startPosition
                    // mit dem gesetzten Wert überschrieben, sodass die nächste Runde an dieser Stelle
                    // weitermachen kann.
                    startPosition     = nextStartposition.Value;
                    nextStartposition = null;
                }
            }

            nextStartposition = null;
            startPosition     = firstLoserStartPosition.Value;
            int?firstFinalPosition = null;

            for (int i = 0; i <= LoserRounds.Count; i++)
            {
                // Da die for-Schleife ein Mal öfter als die eigentliche Rundenanzahl läuft
                // gibt es hier eine Überprüfung, da es sonst zu einem Absturz kommen würde
                // Die for-Schleife läuft so oft, da am Ende ja noch der Gewinner in die Datei
                // geschrieben werden muss.
                if (i < LoserRounds.Count)
                {
                    // Jedes Spiel jeder Runde durchgehen
                    foreach (var match in LoserRounds[i].Matches)
                    {
                        // Daten des Spiels in die Zellen schreiben
                        // Erster Spieler des Spiels
                        var firstPlayerCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, startPosition);
                        firstPlayerCell.CellValue = new CellValue(match.PlayerOne);
                        firstPlayerCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                        // VS
                        var vsPosition = startPosition + Convert.ToInt32(Math.Pow(2, i));
                        if (!nextStartposition.HasValue)
                        {
                            nextStartposition = vsPosition;
                        }
                        var vsCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, vsPosition);
                        vsCell.CellValue = new CellValue("vs");
                        vsCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                        // Zweiter Spieler des Spiels
                        var secondPlayerCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, startPosition + 2 * Convert.ToInt32(Math.Pow(2, i)));
                        secondPlayerCell.CellValue = new CellValue(match.PlayerTwo);
                        secondPlayerCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                        var position = 2 + startPosition + 2 * Convert.ToInt32(Math.Pow(2, i));
                        if (!firstFinalPosition.HasValue || position > firstFinalPosition.Value)
                        {
                            firstFinalPosition = position;
                        }

                        // Nun wird die Startposition für das nächste Spiel berechnet
                        startPosition = startPosition + Convert.ToInt32(Math.Pow(2, i + 2));
                    }
                }
                else
                {
                    // Gewinner eintragen
                    var match  = LoserRounds[i - 1].Matches[0];
                    var winner = match.FirstPlayerWin ? match.PlayerOne : match.PlayerTwo;

                    var winnerCell = CellFinder.GetCell(worksheetPart.Worksheet, i + 1, startPosition);
                    winnerCell.CellValue = new CellValue(winner);
                    winnerCell.DataType  = new EnumValue <CellValues>(CellValues.String);
                }

                if (nextStartposition.HasValue)
                {
                    // Wenn die nextStartPosition-Variable nun gesetzt ist, dann wird startPosition
                    // mit dem gesetzten Wert überschrieben, sodass die nächste Runde an dieser Stelle
                    // weitermachen kann.
                    startPosition     = nextStartposition.Value;
                    nextStartposition = null;
                }
            }

            nextStartposition = null;
            startPosition     = firstFinalPosition.Value;
            Cell finalCell = CellFinder.GetCell(worksheetPart.Worksheet, 1, startPosition);

            finalCell.CellValue = new CellValue("Finals");
            finalCell.DataType  = new EnumValue <CellValues>(CellValues.String);
            startPosition++;
            foreach (var final in FinalMatches)
            {
                // Daten des Spiels in die Zellen schreiben
                // Erster Spieler des Spiels
                var firstPlayerCell = CellFinder.GetCell(worksheetPart.Worksheet, 1, startPosition);
                firstPlayerCell.CellValue = new CellValue(final.PlayerOne.ToString());
                firstPlayerCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                // VS
                var vsPosition = startPosition + 1;
                if (!nextStartposition.HasValue)
                {
                    nextStartposition = vsPosition;
                }
                var vsCell = CellFinder.GetCell(worksheetPart.Worksheet, 1, vsPosition);
                vsCell.CellValue = new CellValue("vs");
                vsCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                // Zweiter Spieler des Spiels
                var secondPlayerCell = CellFinder.GetCell(worksheetPart.Worksheet, 1, startPosition + 2);
                secondPlayerCell.CellValue = new CellValue(final.PlayerTwo.ToString());
                secondPlayerCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                var winnerCell = CellFinder.GetCell(worksheetPart.Worksheet, 2, vsPosition);
                var winner     = final.FirstPlayerWin ? final.PlayerOne.ToString() : final.PlayerTwo.ToString();
                winnerCell.CellValue = new CellValue(winner);
                winnerCell.DataType  = new EnumValue <CellValues>(CellValues.String);

                startPosition += 4;
            }

            // Datei Speichern
            document.WorkbookPart.Workbook.Save();
        }