private static void CreateTeamIfNotExist(IEnumerable<XElement> teamNodes, League league, FootballEntities context)
        {
            foreach (var teamNode in teamNodes)
            {
                string teamName = teamNode.Attribute("name").Value;
                var country = teamNode.Attribute("country");
                string countryName = null;
                if (country != null)
                {
                    countryName = country.Value;
                }

                var team = context.Teams
                    .Include(t => t.Leagues)
                    .FirstOrDefault(t => t.TeamName == teamName && t.Country.CountryName == countryName);
                if (team != null)
                {
                    Console.WriteLine("Existing team: {0} ({1})", team.TeamName, countryName ?? "no country");
                }
                else
                {
                    team = new Team()
                    {
                        TeamName = teamName,
                        Country = context.Countries.FirstOrDefault(c => c.CountryName == countryName)
                    };

                    context.Teams.Add(team);
                    context.SaveChanges();
                    Console.WriteLine("Created team: {0} ({1})", team.TeamName, countryName ?? "no country");
                }

                AddTeamToLeague(team, league, context);
            }
        }
        private static League CreateLeagueIfNotExist(XElement leagueNode, FootballEntities context)
        {
            League league = null;
            var leagueNameNode = leagueNode.Descendants("league-name").FirstOrDefault();
            if (leagueNameNode != null)
            {
                string leagueName = leagueNameNode.Value;
                league = context.Leagues.FirstOrDefault(l => l.LeagueName == leagueName);

                if (league == null)
                {
                    league = new League()
                    {
                        LeagueName = leagueName
                    };

                    context.Leagues.Add(league);
                    context.SaveChanges();

                    Console.WriteLine("Created league: {0}", league.LeagueName);
                }
                else
                {
                    Console.WriteLine("Existing league: {0}", leagueName);
                }
            }

            return league;
        }
 static void Main()
 {
     var context = new FootballEntities();
     foreach (var team in context.Teams)
     {
         Console.WriteLine(team.TeamName);
     }
 }
Exemplo n.º 4
0
        static void Main()
        {
            var context = new FootballEntities();

            foreach (var team in context.Teams)
            {
                Console.WriteLine(team.TeamName);
            }
        }
        static void Main()
        {
            var context = new FootballEntities();

            var allTeamNames = context.Teams
                .Select(t => t.TeamName);

            foreach (var teamName in allTeamNames)
            {
                Console.WriteLine(teamName);
            }
        }
        static void Main()
        {
            var context = new FootballEntities();

            var leaguesAndTeams = context.Leagues
                .OrderBy(l => l.LeagueName)
                .Select(l => new
                {
                    LeaugeName = l.LeagueName,
                    LeagueTeams = l.Teams.OrderBy(t => t.TeamName).Select(t => t.TeamName)
                });

            var json = new JavaScriptSerializer().Serialize(leaguesAndTeams);

            File.WriteAllText(@"leagues-and-teams.json", json);
        }
        public static void Main()
        {
            var context = new FootballEntities();

            var xmlDoc = XDocument.Load(@"..\..\leagues-and-teams.xml");
            var leagueNodes = xmlDoc.XPathSelectElements("/leagues-and-teams/league");
            int counter = 0;

            foreach (var leagueNode in leagueNodes)
            {
                Console.WriteLine("Processing league #{0} ...", ++counter);
                League league = CreateLeagueIfNotExist(leagueNode, context);
                var teamNodes = leagueNode.XPathSelectElements("teams/team");
                CreateTeamIfNotExist(teamNodes, league, context);
            }
        }
        private static void AddTeamToLeague(Team team, League league, FootballEntities context)
        {
            if (league != null)
            {
                if (!team.Leagues.Contains(league))
                {
                    team.Leagues.Add(league);
                    context.SaveChanges();

                    Console.WriteLine("Added team to league: {0} to league {1}", team.TeamName, league.LeagueName);
                }
                else
                {
                    Console.WriteLine("Existing team in league: {0} belongs to {1}", team.TeamName, league.LeagueName);
                }
            }
        }
        public static void Main()
        {
            var context = new FootballEntities();
            var leagues = context.Leagues
                .OrderBy(l => l.LeagueName)
                .Select(l => new
                {
                    Name = l.LeagueName,
                    Teams = l.Teams
                    .OrderBy(t => t.TeamName)
                    .Select(t => t.TeamName)
                });

            var jsSerializer = new JavaScriptSerializer();
            var jsonLeagues = jsSerializer.Serialize(leagues.ToList());

            File.WriteAllText(@"..\..\leagues-and-teams.json", jsonLeagues);
        }
        private static void CreateTeamsIfNotExists(
           FootballEntities context, IEnumerable<XElement> xTeams, League league)
        {
            foreach (var xTeam in xTeams)
            {
                // Find the team by team name and country name (if exists)
                var teamName = xTeam.Attribute("name").Value;
                var xCountry = xTeam.Attribute("country");
                string countryName = null;
                if (xCountry != null)
                {
                    countryName = xCountry.Value;
                }
                var team = context.Teams
                    .Include(t => t.Leagues)
                    .FirstOrDefault(
                        t => t.TeamName == teamName &&
                        t.Country.CountryName == countryName);

                // Create the team if it does not exists
                if (team != null)
                {
                    Console.WriteLine("Existing team: {0} ({1})",
                        team.TeamName, countryName ?? "no country");
                }
                else
                {
                    // Create a new team in the DB
                    team = new Team()
                    {
                        TeamName = teamName,
                        Country = context.Countries.FirstOrDefault(
                            c => c.CountryName == countryName),
                    };
                    context.Teams.Add(team);
                    context.SaveChanges();
                    Console.WriteLine("Created team: {0} ({1})",
                        team.TeamName, countryName ?? "no country");
                }

                AddTeamToLeague(context, team, league);
            }
        }
        static void Main()
        {
            var context = new FootballEntities();
            var leagues = context.Leagues;

            var leaguesQuery = leagues
                    .OrderBy(l => l.LeagueName)
                    .Select(l => new
                    {
                        leagueName = l.LeagueName,
                        teams = l.Teams
                                      .OrderBy(t => t.TeamName)
                                      .Select(t => t.TeamName)
                    });

            var jsSerializer = new JavaScriptSerializer();
            var leaguesJson = jsSerializer.Serialize(leaguesQuery);

            File.WriteAllText(@"../../leagues-and-teams.json", leaguesJson);
            Console.WriteLine(@"Leagues exported to leagues-and-teams.json");
        }
 private static League CreateLeagueIfNotExists(FootballEntities context, XElement xLeague)
 {
     League league = null;
     var xElementLeagueName = xLeague.Element("league-name");
     if (xElementLeagueName != null)
     {
         string leagueName = xElementLeagueName.Value;
         league = context.Leagues.FirstOrDefault(l => l.LeagueName == leagueName);
         if (league != null)
         {
             Console.WriteLine("Existing league: {0}", leagueName);
         }
         else
         {
             // Create a new league in the DB
             league = new League() { LeagueName = leagueName };
             context.Leagues.Add(league);
             context.SaveChanges();
             Console.WriteLine("Created league: {0}", leagueName);
         }
     }
     return league;
 }
        static void Main()
        {
            // Ensure date formatting will use the English names
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            var context = new FootballEntities();
            var matches = context.InternationalMatches;

            var matchesQuery = matches
                .OrderBy(m => m.MatchDate)
                .ThenBy(m => m.HomeCountry.CountryName)
                .ThenBy(m => m.AwayCountry.CountryName)
                .Select(m => new
                {
                    dateTime = m.MatchDate,
                    homeCountryName = m.HomeCountry.CountryName,
                    homeCountryCode = m.HomeCountryCode,
                    awayCountryName = m.AwayCountry.CountryName,
                    awayCountryCode = m.AwayCountryCode,
                    homeGoals = m.HomeGoals,
                    awayGoals = m.AwayGoals,
                    leagueName = m.League.LeagueName
                });

            // Build the output XML
            var xmlMatches = new XElement("matches");
            foreach (var match in matchesQuery)
            {
                var xmlMatch = new XElement("match");
                if (match.dateTime != null)
                {
                    if (match.dateTime.Value.TimeOfDay == TimeSpan.Zero)
                    {
                        string date = match.dateTime.Value.ToString("dd-MMM-yyyy");
                        xmlMatch.Add(new XAttribute("date-time", date));
                    }
                    else
                    {
                        string dateTime = match.dateTime.Value.ToString("dd-MMM-yyyy hh:mm");
                        xmlMatch.Add(new XAttribute("date-time", dateTime));
                    }
                }

                var xmlHomeCountry = new XElement("home-country", match.homeCountryName);
                xmlHomeCountry.Add(new XAttribute("code", match.homeCountryCode));
                xmlMatch.Add(xmlHomeCountry);

                var xmlAwayCountry = new XElement("away-country", match.awayCountryName);
                xmlAwayCountry.Add(new XAttribute("code", match.awayCountryCode));
                xmlMatch.Add(xmlAwayCountry);

                if (match.homeGoals != null && match.awayGoals != null)
                {
                    xmlMatch.Add(new XElement("score", match.homeGoals + "-" + match.awayGoals));
                }
                if (match.leagueName != null)
                {
                    xmlMatch.Add(new XElement("league", match.leagueName));
                }

                xmlMatches.Add(xmlMatch);
            }
            Console.WriteLine(xmlMatches);

            var xmlDoc = new XDocument(xmlMatches);
            xmlDoc.Save(@"..\..\international-matches.xml ");
        }
        private static void ProcessRequest(Request request)
        {
            var context = new FootballEntities();
            var teamsForMatchesQuery = context.Teams.AsQueryable();

            var league = context.Leagues.FirstOrDefault(l => l.LeagueName == request.LeagueName);
            if (request.LeagueName != null)
            {
                teamsForMatchesQuery = teamsForMatchesQuery.Where(
                    t => t.Leagues.Select(l => l.Id).Contains(league.Id));
            }
            var teams = teamsForMatchesQuery.ToList();

            var rnd = new Random();
            var diffDays = (request.EndDate - request.StartDate).Days;
            for (int i = 0; i < request.GenerateCount; i++)
            {
                var match = new TeamMatch();
                match.HomeTeam = teams[rnd.Next(teams.Count)];
                match.AwayTeam = teams[rnd.Next(teams.Count)];
                match.HomeGoals = rnd.Next(request.MaxGoals + 1);
                match.AwayGoals = rnd.Next(request.MaxGoals + 1);
                match.MatchDate = request.StartDate.AddDays(rnd.Next(diffDays + 1));
                match.League = league;

                context.TeamMatches.Add(match);
                context.SaveChanges();

                Console.WriteLine("{0}: {1} - {2}: {3}-{4} ({5})",
                    match.MatchDate.Value.ToString("dd-MMM-yyyy"),
                    match.HomeTeam.TeamName,
                    match.AwayTeam.TeamName,
                    match.HomeGoals,
                    match.AwayGoals,
                    match.League != null ? match.League.LeagueName : "no league");
            }
        }
 static void Main()
 {
     var inputXml = XDocument.Load("../../leagues-and-teams.xml");
     var xLeagues = inputXml.XPathSelectElements("/leagues-and-teams/league");
     var context = new FootballEntities();
     int leaguesCount = 0;
     foreach (var xLeague in xLeagues)
     {
         Console.WriteLine("Processing league #{0} ...", ++leaguesCount);
         League league = CreateLeagueIfNotExists(context, xLeague);
         var xTeams = xLeague.XPathSelectElements("teams/team");
         CreateTeamsIfNotExists(context, xTeams, league);
         Console.WriteLine();
     }
 }
        static void Main(string[] args)
        {
            var context = new FootballEntities();

            var internationalMatches = context.InternationalMatches
                .OrderBy(m => m.MatchDate)
                .ThenBy(m => m.CountryHome.CountryName)
                .ThenBy(m => m.CountryAway.CountryName)
                .Select(m => new
                {
                    MatchDate = m.MatchDate != null ? m.MatchDate : null,
                    HomeCountryCode = m.HomeCountryCode,
                    AwayCountryCode = m.AwayCountryCode,
                    HomeTeam = m.CountryHome.CountryName,
                    AwayTeam = m.CountryAway.CountryName,
                    Score = (m.HomeGoals != null && m.AwayGoals != null) ? (m.HomeGoals + "-" + m.AwayGoals) : null,
                    League = m.League != null ? m.League.LeagueName : null
                });

            var xmlDoc = new XDocument();
            var xmlRoot = new XElement("matches");
            xmlDoc.Add(xmlRoot);
            foreach (var match in internationalMatches)
            {
                var matchXmlElement = new XElement("match");

                if(match.MatchDate != null)
                {
                    DateTime matchDate = DateTime.Parse(match.MatchDate.ToString());
                    if (matchDate.Hour == 0)
                    {
                        string formattedDate = matchDate.ToString("dd-MMM-yyyy");
                        var matchDateAttribute = new XAttribute("date", formattedDate);
                        matchXmlElement.Add(matchDateAttribute);
                    }
                    else
                    {
                        string formattedDate = matchDate.ToString("dd-MMM-yyyy hh:mm");
                        var matchDateAttribute = new XAttribute("date-time", formattedDate);
                        matchXmlElement.Add(matchDateAttribute);
                    }
                }

                var homeCountryXmlElement = new XElement("home-country", match.HomeTeam);
                var homeCountryXmlElementAttirbute = new XAttribute("code", match.HomeCountryCode);
                homeCountryXmlElement.Add(homeCountryXmlElementAttirbute);
                matchXmlElement.Add(homeCountryXmlElement);

                var awayCountryXmlElement = new XElement("away-country", match.AwayTeam);
                var awayCountryXmlElementAttirbute = new XAttribute("code", match.AwayCountryCode);
                awayCountryXmlElement.Add(awayCountryXmlElementAttirbute);
                matchXmlElement.Add(awayCountryXmlElement);

                if(match.League != null)
                {
                    var leagueXmlElement = new XElement("league", match.League);
                    matchXmlElement.Add(leagueXmlElement);
                }

                if (match.Score != null)
                {
                    var scoreXmlElement = new XElement("score", match.Score);
                    matchXmlElement.Add(scoreXmlElement);
                }
                xmlRoot.Add(matchXmlElement);
            }

            xmlDoc.Save("international-matches.xml");
        }
        public static void Main()
        {
            var context = new FootballEntities();
            var matches = context.InternationalMatches
                .OrderBy(im => im.MatchDate)
                .ThenBy(im => im.CountryHome.CountryName)
                .ThenBy(im => im.CountryAway.CountryName)
                .Select(im => new InternationalMatch
                {
                    LeagueName = im.League.LeagueName,
                    HomeCountryName = im.CountryHome.CountryName,
                    AwayCountryName = im.CountryAway.CountryName,
                    HomeCountryCode = im.HomeCountryCode,
                    AwayCountryCode = im.AwayCountryCode,
                    HomeCountryGoals = im.HomeGoals,
                    AwayCountryGoals = im.AwayGoals,
                    MatchDate = im.MatchDate
                });

            var xmlMatches = new XElement("matches");
            foreach (var match in matches)
            {
                var xmlMatch = new XElement("match");
                if (match.MatchDate != null)
                {
                    var matchDate = DateTime.Parse(match.MatchDate.ToString());
                    XAttribute xmlDate;
                    if (matchDate.TimeOfDay.TotalSeconds == 0)
                    {
                        xmlDate = new XAttribute("date", matchDate.ToString("dd-MMM-yyyy"));
                    }
                    else
                    {
                        xmlDate = new XAttribute("date-time", matchDate.ToString("dd-MMM-yyyy hh:mm"));
                    }

                    xmlMatch.Add(xmlDate);
                }

                var xmlHomeCountry = new XElement("home-country", match.HomeCountryName);
                var xmlAwayCountry = new XElement("away-country", match.AwayCountryName);
                var xmlHomeCountryAttribute = new XAttribute("code", match.HomeCountryCode);
                var xmlAwayCountryAttribute = new XAttribute("code", match.AwayCountryCode);

                xmlHomeCountry.Add(xmlHomeCountryAttribute);
                xmlAwayCountry.Add(xmlAwayCountryAttribute);

                xmlMatch.Add(xmlHomeCountry);
                xmlMatch.Add(xmlAwayCountry);

                bool hasMatchScore = match.HomeCountryGoals != null;
                if (hasMatchScore)
                {
                    string matchScore = match.HomeCountryGoals + "-" + match.AwayCountryGoals;
                    var xmlScore = new XElement("score", matchScore);

                    xmlMatch.Add(xmlScore);
                }

                bool hasMatchLeague = match.LeagueName != null;
                if (hasMatchLeague)
                {
                    var xmlLeague = new XElement("league", match.LeagueName);

                    xmlMatch.Add(xmlLeague);
                }

                xmlMatches.Add(xmlMatch);
            }

            var xmlDoc = new XDocument(xmlMatches);
            xmlDoc.Save(@"..\..\international-matches.xml");
        }
        static void Main(string[] args)
        {
            var context = new FootballEntities();

            XDocument xmlDoc = XDocument.Load("../../leagues-and-teams.xml");

            var leaguesAndTeams =
                from league in xmlDoc.Descendants("league")
                select new
                {
                    LeagueName = league.Element("league-name") != null ? league.Element("league-name").Value : null,
                    Teams = league.Element("teams") != null ? league.Element("teams").Elements() : null
                };

            int countXmlLeagues = 0;

            foreach (var league in leaguesAndTeams)
            {
                League leageToDb = null;
                Console.WriteLine("Processing league #{0}", ++countXmlLeagues);
                if(league.LeagueName != null)
                {
                    leageToDb = context.Leagues.FirstOrDefault(l => l.LeagueName == league.LeagueName);
                    if (leageToDb != null)
                    {
                        Console.WriteLine("Existing league: {0}", league.LeagueName);
                    }
                    else
                    {
                        leageToDb = new League() { LeagueName = league.LeagueName };
                        context.Leagues.Add(leageToDb);
                        Console.WriteLine("Created league: {0}", league.LeagueName);
                    }
                }

                if(league.Teams != null)
                {
                    foreach (var team in league.Teams)
                    {
                        string teamName = team.Attribute("name").Value;
                        string countryName = "";
                        if (team.Attribute("country") != null)
                        {
                            countryName = team.Attribute("country").Value;
                        }

                        Team teamToDb = context.Teams.FirstOrDefault(t => t.TeamName == teamName && t.Country.CountryName == countryName);
                        if(teamToDb == null)
                        {
                            teamToDb = context.Teams.FirstOrDefault(t => t.TeamName == teamName);
                        }

                        if(teamToDb != null)
                        {
                            Console.WriteLine("Existing team: {0} ({1})",
                                teamName, !string.IsNullOrEmpty(countryName) ? countryName : "no country");
                        }
                        else
                        {
                            Country country = context.Countries.FirstOrDefault(c => c.CountryName == countryName);
                            if(!string.IsNullOrEmpty(countryName))
                            {
                                if(country == null)
                                {
                                    country = new Country()
                                    {
                                        CountryName = countryName
                                    };
                                }
                            }
                            teamToDb = new Team()
                                {
                                    TeamName = teamName,
                                    Country = country
                                };
                            context.Teams.Add(teamToDb);

                            Console.WriteLine("Created team: {0} ({1})",
                                teamName, !string.IsNullOrEmpty(countryName) ? countryName : "no country");
                        }

                        if(leageToDb != null)
                        {
                            if(!leageToDb.Teams.Contains(teamToDb))
                            {
                                Console.WriteLine("Existing team in league: {0} belongs to {1}",
                                    teamToDb.TeamName, leageToDb.LeagueName);
                            }
                            else
                            {
                                leageToDb.Teams.Add(teamToDb);
                                Console.WriteLine("Added team to league: {0} to league {1}",
                                    teamToDb.TeamName, leageToDb.LeagueName);
                            }
                        }
                    }
                }

                Console.WriteLine();
                context.SaveChanges();
            }
        }