コード例 #1
0
        void ImportJudges(TournamentData importedData, DivisionData divisionData, PoolData poolData, XmlNode node)
        {
            foreach (XmlNode teamDataNode in node.ChildNodes)
            {
                TeamData teamData = new TeamData();

                foreach (XmlNode dataNode in teamDataNode.FirstChild.ChildNodes)
                {
                    if (dataNode.Name == "RoutineScores")
                    {
                        foreach (XmlNode resultsNode in dataNode.ChildNodes)
                        {
                            if (resultsNode.Name.Contains("Results"))
                            {
                                foreach (XmlNode judgeDataNode in resultsNode.ChildNodes)
                                {
                                    int judgeNameId           = int.Parse(judgeDataNode.FirstChild.FirstChild.Value);
                                    RegisteredPlayer newJudge = new RegisteredPlayer();
                                    if (tournamentData.FindOrAddImportedRegisterPlayer(judgeNameId, ref newJudge))
                                    {
                                        poolData.judgesData.Add(newJudge, GetJudgeCategory(resultsNode.Name));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
コード例 #2
0
        private void ImportItem_Click(object sender, RoutedEventArgs e)
        {
            Microsoft.Win32.OpenFileDialog dialog = new Microsoft.Win32.OpenFileDialog();
            if (dialog.ShowDialog() == true)
            {
                string namesXmlFilename = (new FileInfo(dialog.FileName)).DirectoryName + "\\names.xml";
                if (TryImportNames(namesXmlFilename))
                {
                    XmlDocument xml = new XmlDocument();
                    xml.Load(dialog.FileName);

                    XmlNode root = xml.LastChild.FirstChild;

                    TournamentData importedData = new TournamentData();
                    EDivision      division     = EDivision.Open;
                    foreach (XmlNode divisionNode in root.ChildNodes)                     // DivisionData
                    {
                        ImportDivisionData(importedData, divisionNode, division);
                        division += 1;
                    }

                    tournamentData = importedData;

                    Init();
                }
            }
        }
コード例 #3
0
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            TopLevelMainWindowGrid.DataContext = this;

            tournamentData = TournamentData.LoadFromDisk();

            tournamentData.Init();

            Init();
        }
コード例 #4
0
        void ImportDivisionData(TournamentData importedData, XmlNode node, EDivision division)
        {
            DivisionData divisionData = new DivisionData(division);

            foreach (XmlNode roundNode in node.ChildNodes)             // Rounds
            {
                ERound round = ERound.Finals;
                foreach (XmlNode roundDataNode in roundNode.ChildNodes)
                {
                    RoundData roundData = new RoundData(division, round);
                    EPool     pool      = EPool.A;
                    foreach (XmlNode poolDataNode in roundDataNode.FirstChild.ChildNodes)                     // Pools
                    {
                        PoolData poolData = new PoolData(pool);
                        foreach (XmlNode poolDataChildNode in poolDataNode.ChildNodes)
                        {
                            if (poolDataChildNode.Name == "PoolName")
                            {
                                poolData.pool = (EPool)Enum.Parse(typeof(EPool), poolDataChildNode.FirstChild.Value);
                            }
                            else if (poolDataChildNode.Name == "Teams")
                            {
                                ImportTeams(importedData, divisionData, poolData, poolDataChildNode);
                                ImportJudges(importedData, divisionData, poolData, poolDataChildNode);
                            }
                            else if (poolDataChildNode.Name == "ResultsByTeamIndex")
                            {
                                ImportPoolResults(poolData, poolDataChildNode);
                            }
                        }

                        roundData.pools.Add(poolData);

                        ++pool;
                    }

                    divisionData.rounds.Add(roundData);

                    ++round;
                }
            }

            importedData.divisions.Add(divisionData);
        }
コード例 #5
0
        void ImportTeams(TournamentData importedData, DivisionData divisionData, PoolData poolData, XmlNode node)
        {
            foreach (XmlNode teamDataNode in node.ChildNodes)
            {
                TeamData teamData = new TeamData();

                foreach (XmlNode playerDataNode in teamDataNode.FirstChild.FirstChild.ChildNodes)
                {
                    if (playerDataNode.Name == "PlayerData")
                    {
                        RegisteredPlayer newPlayer = new RegisteredPlayer();

                        if (tournamentData.FindOrAddImportedRegisterPlayer(int.Parse(playerDataNode.FirstChild.FirstChild.Value), ref newPlayer))
                        {
                            teamData.players.Add(newPlayer);

                            importedData.AddRegisteredPlayer(newPlayer);
                        }
                    }
                }

                poolData.teamList.teams.Add(teamData);

                bool bNewTeam = true;
                foreach (TeamData td in divisionData.teamList.teams)
                {
                    if (td.Equals(teamData))
                    {
                        bNewTeam = false;
                        break;
                    }
                }

                if (bNewTeam)
                {
                    divisionData.teamList.teams.Add(teamData);
                }
            }
        }