static void Main()
        {
            var xml   = XDocument.Load(SourceXmlPath);
            var users = xml.XPathSelectElements("users/user");

            var context = new DiabloEntities();

            foreach (var userNode in users)
            {
                try
                {
                    ImportUsersAndGames(userNode, context);
                }
                catch (Exception ex)
                {
                    if (ex is ValidationException || ex is InvalidOperationException || ex is DataException)
                    {
                        Console.WriteLine(ex.Message);
                    }
                    else
                    {
                        throw;
                    }
                }
            }
        }
 private static void ProcessGames(IEnumerable<XElement> games, User user, DiabloEntities context)
 {
     foreach (var gm in games)
     {
         var gameName = gm.Element("game-name").Value;
         var characterName = gm.Element("character").Attribute("name").Value;
         var characterCash = gm.Element("character").Attribute("cash").Value;
         var characterLevel = gm.Element("character").Attribute("level").Value;
         var joinedOn = gm.Element("joined-on").Value;
         var game = context.Games.FirstOrDefault(g => g.Name == gameName);
         var character = context.Characters.FirstOrDefault(c => c.Name == characterName);
         if (game != null && character != null)
         {
             var userGame = new UsersGame()
             {
                 Game = game,
                 User = user,
                 Character = character,
                 Level = int.Parse(characterLevel),
                 JoinedOn = DateTime.Parse(joinedOn),
                 Cash = decimal.Parse(characterCash)
             };
             if (
                 !context.UsersGames.Any(
                     ug =>
                         ug.Game.Name == game.Name && ug.User.Username == user.Username &&
                         ug.Character.Name == character.Name))
             {
                 context.UsersGames.Add(userGame);
                 context.SaveChanges();
                 Console.WriteLine("User {0} successfully added to game {1}", userGame.User.Username, userGame.Game.Name);
             }
         }
     }
 }
        static void Main(string[] args)
        {
            var context = new DiabloEntities();

            var usersGames = context.Games
                             .Where(g => g.IsFinished == true)
                             .OrderBy(g => g.Name)
                             .ThenBy(g => g.Duration)
                             .Select(g => new
            {
                gameName     = g.Name,
                gameDuration = g.Duration,
                Users        = g.UsersGames
                               .Select(u => new
                {
                    Username = u.User.Username,
                    Ip       = u.User.IpAddress
                }).ToList()
            }).ToList();


            var xmlGames = new XElement("games");

            usersGames.ForEach(g =>
            {
                var xmlGame = new XElement("game");
                xmlGames.Add(xmlGame);
                xmlGame.Add(new XAttribute("name", g.gameName));
                if (g.gameDuration != null)
                {
                    xmlGame.Add(new XAttribute("duration", g.gameDuration));
                }
                var xmlUsers = new XElement("users");
                xmlGame.Add(xmlUsers);

                g.Users.ForEach(u =>
                {
                    var xmlUser = new XElement("user");
                    xmlUser.Add(new XAttribute("username", u.Username));
                    xmlUser.Add(new XAttribute("ip-address", u.Ip));
                    xmlUsers.Add(xmlUser);
                });
            });

            var xmlDoc = new XDocument(xmlGames);

            xmlDoc.Save("finished-games.xml");
            //Console.WriteLine(xmlDoc);


            //usersGames.ForEach(g =>
            //{
            //    Console.WriteLine("{0} : {1}", g.gameName, g.gameDuration);
            //    g.Users.ForEach(u =>
            //    {
            //        Console.WriteLine(u.Username + " " + u.Ip + ",");
            //    });
            //    Console.WriteLine();
            //});
        }
        static void Main(string[] args)
        {
            var context      = new DiabloEntities();
            var charsPlayers = context.Characters
                               .OrderBy(c => c.Name)
                               .Select(c => new
            {
                name     = c.Name,
                playedBy = c.UsersGames
                           .Select(u => u.User.Username).ToList()
            }).ToList();

            //var jsSerializer = new JavaScriptSerializer();
            //var charactersWithPlayers = jsSerializer.Serialize(charsPlayers);
            //Console.WriteLine(charactersWithPlayers);

            var          jsSerializer             = new JavaScriptSerializer();
            var          characterWithPlayersJSON = jsSerializer.Serialize(charsPlayers);
            StreamWriter file =
                new StreamWriter(
                    @"E:\DISK D\Softuni-Projects\Modul Back-End\DB Apps July 2015\Exams\DB-Apps-Exam-02Aug2015\02. ExportCharactersAndPlayersAsJSON\bin\Debug\characters.json");

            file.WriteLine(characterWithPlayersJSON);
            file.Close();
        }
        private static void ImportUsersAndGames(XElement userNode, DiabloEntities context)
        {
            var username = userNode.Attribute("username").Value;

            if (GetUserByUsername(username, context) != null)
            {
                throw new InvalidOperationException(string.Format(
                                                        "User {0} already exists",
                                                        username));
            }

            bool isDeleted = int.Parse(userNode.Attribute("is-deleted").Value) == 0;

            var regDate = ParseDate(userNode.Attribute("registration-date").Value);

            var ipAddress = userNode.Attribute("ip-address").Value;

            var user = new User()
            {
                Username         = username,
                IsDeleted        = isDeleted,
                RegistrationDate = regDate,
                IpAddress        = ipAddress
            };

            var firstName = userNode.Attribute("first-name");

            if (firstName != null)
            {
                user.FirstName = firstName.Value;
            }

            var lastName = userNode.Attribute("last-name");

            if (lastName != null)
            {
                user.LastName = lastName.Value;
            }

            var email = userNode.Attribute("email");

            if (email != null)
            {
                user.Email = email.Value;
            }

            context.Users.Add(user);
            Console.WriteLine("Successfully added user {0}", username);

            var games = userNode.XPathSelectElements("games/game");

            foreach (var gameNode in games)
            {
                ImportGame(context, gameNode, user, username);
            }

            context.SaveChanges();
        }
Example #6
0
        private static UsersGame ProcessGame(DiabloEntities context, XElement game)
        {
            if (game.Element("game-name") == null)
            {
                throw new ArgumentException("game-name is required!");
            }

            var gameName = game.Element("game-name").Value;
            var dbGame   = context.Games.FirstOrDefault(g => g.Name == gameName);

            if (dbGame == null)
            {
                var message = string.Format("{0} game not existing!", gameName);
                throw new ArgumentException(message);
            }

            var characterNode = game.Element("character");

            if (characterNode == null)
            {
                throw new ArgumentException("character is required!");
            }

            var charName = characterNode.Attribute("name").Value;
            var cash     = decimal.Parse(characterNode.Attribute("cash").Value);
            var dbChar   = context.Characters.FirstOrDefault(c => c.Name == charName);

            if (dbChar == null)
            {
                dbChar = new Character()
                {
                    Name = charName
                };
            }

            var level      = int.Parse(characterNode.Attribute("level").Value);
            var joinedNode = game.Element("joined-on");

            if (joinedNode == null)
            {
                throw new ArgumentException("joined-on is required!");
            }

            var joinedOn = DateTime.ParseExact(joinedNode.Value, DateTimeFormat,
                                               CultureInfo.InvariantCulture);

            var userGame = new UsersGame()
            {
                Cash      = cash,
                Game      = dbGame,
                JoinedOn  = joinedOn,
                Level     = level,
                Items     = new List <Item>(),
                Character = dbChar
            };

            return(userGame);
        }
        static void Main()
        {
            var db = new DiabloEntities();

            var xmlDoc = XDocument.Load("../../users-and-games.xml");
            var xUsers = xmlDoc.XPathSelectElements("users/user");

            foreach (var user in xUsers)
            {
                var dbUser = new User();
                var userName = user.Attribute("username").Value;
                if (db.Users.Any(u => u.Username == userName))
                {
                    Console.WriteLine("User {0} already exists", userName);
                    dbUser = db.Users.FirstOrDefault(u => u.Username == userName);
                    continue;
                }
                else
                {
                    dbUser.Username = userName;
                    dbUser.IsDeleted = Convert.ToBoolean(int.Parse(user.Attribute("is-deleted").Value) == 0 ? "false" : "true");
                    dbUser.IpAddress = user.Attribute("ip-address").Value;
                    dbUser.RegistrationDate = DateTime.Parse(user.Attribute("registration-date").Value);
                    var firstName = user.Attribute("first-name");
                    if (firstName != null) dbUser.FirstName = firstName.Value;

                    var lastName = user.Attribute("last-name");
                    if (lastName != null) dbUser.FirstName = lastName.Value;

                    var email = user.Attribute("email");
                    if (email != null) dbUser.FirstName = email.Value;

                    db.Users.Add(dbUser);
                    db.SaveChanges();
                    Console.WriteLine("Successfully added user {0}", userName);
                }

                var games = user.XPathSelectElements("games/game");
                foreach (var gameXml in games)
                {
                    var game = new UsersGame();
                    var gameName = gameXml.Element("game-name").Value;
                    var characterName = gameXml.Element("character").Attribute("name").Value;
                    var currGame = db.Games.FirstOrDefault(g => g.Name == gameName);
                    var currCharacter = db.Characters.FirstOrDefault(g => g.Name == characterName);

                    game.GameId = currGame.Id;
                    game.UserId = dbUser.Id;
                    game.CharacterId = currCharacter.Id;
                    game.Cash = decimal.Parse(gameXml.Element("character").Attribute("cash").Value);
                    game.Level = int.Parse(gameXml.Element("character").Attribute("level").Value);
                    game.JoinedOn = DateTime.Parse(gameXml.Element("joined-on").Value);
                    db.SaveChanges();
                    Console.WriteLine("User {0} successfully added to game {1}", userName, gameXml.Element("game-name").Value);
                }
            }
        }
 static void Main()
 {
     var db = new DiabloEntities();
     var characters = db.Characters.Select(c => c.Name).ToList();
     foreach (var character in characters)
     {
         Console.WriteLine(character);
     }
 }
        static void Main()
        {
            var context = new DiabloEntities();

            var characterNames = context.Characters.Select(c => c.Name).ToList();
            foreach (var name in characterNames)
            {
                Console.WriteLine(name);
            }
        }
    public static void Main()
    {
        var context = new DiabloEntities();

        var characters = context.Characters.Select(c => c.Name);

        foreach (var character in characters)
        {
            Console.WriteLine(character);
        }
    }
        static void Main()
        {
            var       context = new DiabloEntities();
            XDocument xmlDoc  = XDocument.Load("../../users-and-games.xml");

            var xUsers = xmlDoc.XPathSelectElements("/users/user");

            foreach (var xUser in xUsers)
            {
                User user = CreateUserIfNotExists(context, xUser);
            }
        }
        static void Main()
        {
            var context = new DiabloEntities();

            var doc = XDocument.Load("../../users-and-games.xml");
            var users = doc.XPathSelectElements("/users/user");
            foreach (var us in users)
            {
                User user = ProcessUsers(us, context);
                var games = us.XPathSelectElements("games/game");
                ProcessGames(games, user, context);
            }
        }
Example #13
0
        private static UsersGame ProcessGame(DiabloEntities context, XElement game)
        {
            if (game.Element("game-name") == null)
            {
                throw new ArgumentException("game-name is required!");
            }

            var gameName = game.Element("game-name").Value;
            var dbGame = context.Games.FirstOrDefault(g => g.Name == gameName);
            if (dbGame == null)
            {
                var message = string.Format("{0} game not existing!", gameName);
                throw new ArgumentException(message);
            }

            var characterNode = game.Element("character");
            if (characterNode == null)
            {
                throw new ArgumentException("character is required!");
            }

            var charName = characterNode.Attribute("name").Value;
            var cash = decimal.Parse(characterNode.Attribute("cash").Value);
            var dbChar = context.Characters.FirstOrDefault(c => c.Name == charName);
            if (dbChar == null)
            {
                dbChar = new Character() { Name = charName };
            }

            var level = int.Parse(characterNode.Attribute("level").Value);
            var joinedNode = game.Element("joined-on");
            if (joinedNode == null)
            {
                throw new ArgumentException("joined-on is required!");
            }

            var joinedOn = DateTime.ParseExact(joinedNode.Value, DateTimeFormat,
                CultureInfo.InvariantCulture);

            var userGame = new UsersGame()
            {
                Cash = cash,
                Game = dbGame,
                JoinedOn = joinedOn,
                Level = level,
                Items = new List<Item>(),
                Character = dbChar
            };

            return userGame;
        }
Example #14
0
        static void Main()
        {
            var context = new DiabloEntities();

            var finishedGames = context.Games
                                .Where(g => g.IsFinished)
                                .OrderBy(g => g.Name)
                                .ThenBy(g => g.Duration)
                                .Select(g => new
            {
                Name     = g.Name,
                Duration = g.Duration,
                Users    = g.UsersGames.Select(ug => new
                {
                    Username  = ug.User.Username,
                    IPAddress = ug.User.IpAddress
                })
            });


            var doc      = new XDocument();
            var rootElem = new XElement("games");

            foreach (var finishedGame in finishedGames)
            {
                if (finishedGame.Name != null)
                {
                    var gameElem = new XElement("game", new XAttribute("name", finishedGame.Name));

                    if (finishedGame.Duration != null)
                    {
                        gameElem.Add(new XAttribute("duration", finishedGame.Duration));
                    }

                    var usersElem = new XElement("users");

                    foreach (var user in finishedGame.Users)
                    {
                        var userElem = new XElement("user", new XAttribute("username", user.Username), new XAttribute("ip-address", user.IPAddress));
                        usersElem.Add(userElem);
                    }

                    gameElem.Add(usersElem);
                    rootElem.Add(gameElem);
                }
            }

            doc.Add(rootElem);
            doc.Save("../../finished-games.xml");
        }
Example #15
0
        public static void Main(string[] args)
        {
            var directory     = new FileInfo("../../../finished-games.xml");
            var context       = new DiabloEntities();
            var finishedGames = context.Games
                                .Where(g => g.IsFinished == true)
                                .Select(g => new
            {
                gameName     = g.Name,
                gameDuration = g.Duration,
                users        = g.UsersGames.Select(u => new
                {
                    u.User.Username,
                    u.User.IpAddress
                })
            })
                                .OrderBy(g => g.gameName)
                                .ThenBy(g => g.gameDuration)
                                .ToList();

            var xml  = new XDocument();
            var root = new XElement("games");

            xml.Add(root);

            finishedGames.ForEach(g =>
            {
                var gameNode = new XElement("game");
                gameNode.SetAttributeValue("name", g.gameName);
                if (g.gameDuration != null)
                {
                    gameNode.SetAttributeValue("duration", g.gameDuration);
                }

                var usersNode = new XElement("users");
                foreach (var user in g.users)
                {
                    var userNode = new XElement("user");
                    userNode.SetAttributeValue("username", user.Username);
                    userNode.SetAttributeValue("ip-address", user.IpAddress);
                    usersNode.Add(userNode);
                }

                gameNode.Add(usersNode);
                root.Add(gameNode);
            });

            xml.Save(directory.FullName);
            Console.WriteLine("XML saved : " + directory.FullName);
        }
Example #16
0
        static void Main()
        {
            var diabloContext           = new DiabloEntities();
            var finishedGamesAndPlayers = diabloContext.Games
                                          .Where(g => g.IsFinished == true)
                                          .OrderBy(g => g.Name)
                                          .ThenBy(g => g.Duration)
                                          .Select(g => new
            {
                name     = g.Name,
                duration = g.Duration,
                users    = g.UsersGames.Select(ug => new
                {
                    username  = ug.User.Username,
                    ipAddress = ug.User.IpAddress
                })
            });

            XDocument xDocument = new XDocument(new XDeclaration("1.0", "UTF-8", "yes"));
            XElement  xGames    = new XElement("games");

            foreach (var match in finishedGamesAndPlayers)
            {
                XElement xGame = new XElement("game");

                xGame.Add(new XAttribute("name", match.name));

                if (match.duration != null)
                {
                    xGame.Add(new XAttribute("duration", match.duration));
                }

                XElement xUsers = new XElement("users");

                foreach (var user in match.users)
                {
                    XElement xUser = new XElement("user");
                    xUser.Add(new XAttribute("username", user.username));
                    xUser.Add(new XAttribute("ip-address", user.ipAddress));

                    xUsers.Add(xUser);
                }

                xGame.Add(xUsers);
                xGames.Add(xGame);
            }

            xDocument.Add(xGames);
            xDocument.Save("../../finished-games.xml");
        }
Example #17
0
        static void Main(string[] args)
        {
            var         context = new DiabloEntities();
            XmlDocument doc     = new XmlDocument();

            doc.Load("../../users-and-games.xml");

            var root = doc.DocumentElement;

            foreach (XmlNode xmlUsersGames in root.ChildNodes)
            {
                Console.WriteLine(xmlUsersGames);
            }
        }
        static void Main()
        {
            var context = new DiabloEntities();

            var finishedGames = context.Games
                                .Where(g => g.IsFinished == true)
                                .OrderBy(g => g.Name)
                                .ThenBy(g => g.Duration)
                                .Select(g => new
            {
                GameName     = g.Name,
                GameDuration = g.Duration,
                Users        = new
                {
                    user = g.UsersGames.Select(ug => ug.User)
                }
            });

            var resultXml = new XElement("games");

            foreach (var game in finishedGames)
            {
                var gameXml = new XElement("game");
                gameXml.Add(new XAttribute("name", game.GameName));
                if (game.GameDuration.HasValue)
                {
                    gameXml.Add(new XAttribute("duration", game.GameDuration));
                }

                var users = new XElement("users");

                foreach (var user in game.Users.user)
                {
                    users.Add(new XElement("user",
                                           new XAttribute("username", user.Username),
                                           new XAttribute("ip-address", user.IpAddress)));
                }

                gameXml.Add(users);

                resultXml.Add(gameXml);
            }
            var resultXmlDoc = new XDocument();

            resultXmlDoc.Add(resultXml);
            resultXmlDoc.Save("../../finished-games.xml");

            Console.WriteLine("Finished Games exported to finished-games.xml");
        }
Example #19
0
        public static void Main(string[] args)
        {
            var directory = new FileInfo("../../../finished-games.xml");
            var context = new DiabloEntities();
            var finishedGames = context.Games
                .Where(g => g.IsFinished == true)
                .Select(g => new
                {
                    gameName = g.Name,
                    gameDuration = g.Duration,
                    users = g.UsersGames.Select(u => new
                    {
                        u.User.Username,
                        u.User.IpAddress
                    })
                })
                .OrderBy(g => g.gameName)
                .ThenBy(g => g.gameDuration)
                .ToList();

            var xml = new XDocument();
            var root = new XElement("games");
            xml.Add(root);

            finishedGames.ForEach(g =>
            {
                var gameNode = new XElement("game");
                gameNode.SetAttributeValue("name", g.gameName);
                if (g.gameDuration != null)
                {
                    gameNode.SetAttributeValue("duration", g.gameDuration);
                }

                var usersNode = new XElement("users");
                foreach (var user in g.users)
                {
                    var userNode = new XElement("user");
                    userNode.SetAttributeValue("username", user.Username);
                    userNode.SetAttributeValue("ip-address", user.IpAddress);
                    usersNode.Add(userNode);
                }

                gameNode.Add(usersNode);
                root.Add(gameNode);
            });

            xml.Save(directory.FullName);
            Console.WriteLine("XML saved : " + directory.FullName);
        }
Example #20
0
    public static void Main()
    {
        var context = new DiabloEntities();

        var characters = context.Characters
                         .OrderBy(c => c.Name)
                         .Select(c => new
        {
            c.Name,
            Players = c.UsersGames.Select(u => u.User.Username)
        });

        var charactersJson = JsonConvert.SerializeObject(characters, Formatting.Indented);

        File.WriteAllText("..//..//characters.json", charactersJson);
    }
Example #21
0
        static void Main()
        {
            var context = new DiabloEntities();

            var charactersPlayer = context.Characters
                                   .OrderBy(c => c.Name)
                                   .Select(c => new
            {
                name     = c.Name,
                playedBy = c.UsersGames.Select(ug => ug.User.Username)
            });

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

            File.WriteAllText("../../characters.json", json);
        }
        static void Main()
        {
            var context    = new DiabloEntities();
            var characters = context.Characters
                             .OrderBy(ch => ch.Name)
                             .Select(ch => new
            {
                name     = ch.Name,
                playedBy = ch.UsersGames
                           .Select(u => u.User.Username)
            });

            var charactersAsJson = JsonConvert.SerializeObject(characters, Formatting.Indented);

            File.WriteAllText("characters.json", charactersAsJson);
        }
        static void Main()
        {
            var diabloContext = new DiabloEntities();

            var charactersAndPlayers = diabloContext.Characters
                                       .OrderBy(c => c.Name)
                                       .Select(c => new
            {
                c.Name,
                playedBy = c.UsersGames.Select(ug => ug.User.Username)
            });

            var charactersAndPlayersJSON = JsonConvert.SerializeObject(charactersAndPlayers, Formatting.Indented);

            File.WriteAllText("../../characters.json", charactersAndPlayersJSON);
        }
        static void Main()
        {
            var context = new DiabloEntities();
            var games   = context.Games
                          .Where(g => g.IsFinished)
                          .OrderBy(g => g.Name)
                          .Select(g => new
            {
                g.Name,
                g.Duration,
                Users = g.UsersGames
                        .Select(ug => new
                {
                    ug.User.Username,
                    ug.User.IpAddress
                })
            });

            var doc = new XElement("games");

            foreach (var game in games)
            {
                var gameNode = new XElement("game");
                gameNode.Add(new XAttribute("name", game.Name));

                if (game.Duration.HasValue)
                {
                    gameNode.Add(new XAttribute("duration", game.Duration));
                }

                var usersNode = new XElement("users");
                foreach (var user in game.Users)
                {
                    var singleUserNode = new XElement("user");
                    singleUserNode.Add(new XAttribute("username", user.Username));
                    singleUserNode.Add(new XAttribute("ip-address", user.IpAddress));

                    usersNode.Add(singleUserNode);
                }

                gameNode.Add(usersNode);

                doc.Add(gameNode);
            }

            doc.Save("finished-games.xml");
        }
        static void Main()
        {
            var context = new DiabloEntities();

            var finishedGames = context.Games
                                .OrderBy(g => g.Name)
                                .ThenBy(g => g.Duration)
                                .Select(g => new
            {
                GameName     = g.Name,
                GameDuration = g.Duration,
                User         = g.UsersGames.Select(ug => new
                {
                    username = ug.User.Username,
                    ip       = ug.User.IpAddress
                })
            }).ToList();

            XElement games = new XElement("games");

            foreach (var game in finishedGames)
            {
                var gameXml = new XElement("game", new XAttribute("name", game.GameName));
                if (game.GameDuration != null)
                {
                    gameXml.Add(new XAttribute("duration", game.GameDuration));
                }

                var usersXml = new XElement("users");

                foreach (var user in game.User)
                {
                    var currentUserXml = new XElement("user", new XAttribute("username", user.username));
                    currentUserXml.Add(new XAttribute("ip-address", user.ip));
                    usersXml.Add(currentUserXml);
                }

                gameXml.Add(usersXml);

                games.Add(gameXml);
            }

            //Console.WriteLine(games);

            games.Save("../../finished-games.xml");
        }
Example #26
0
    public static void Main()
    {
        var context = new DiabloEntities();

        var games = context.Games
                    .OrderBy(g => g.Name)
                    .ThenBy(g => g.Duration)
                    .Select(g => new
        {
            g.Name,
            g.Duration,
            Users = g.UsersGames.Select(u => new
            {
                Username = u.User.Username,
                IpAdress = u.User.IpAddress
            })
        });

        XElement xmlGames = new XElement("games");

        foreach (var game in games)
        {
            XElement xmlGame = new XElement("game", new XAttribute("name", game.Name));
            if (game.Duration != null)
            {
                xmlGame.Add(new XAttribute("duration", game.Duration));
            }

            XElement xmlUsers = new XElement("users");
            foreach (var user in game.Users)
            {
                XElement xmlUser = new XElement("user",
                                                new XAttribute("username", user.Username),
                                                new XAttribute("ip-address", user.IpAdress));

                xmlUsers.Add(xmlUser);
            }

            xmlGame.Add(xmlUsers);
            xmlGames.Add(xmlGame);
        }

        XDocument docGames = new XDocument(xmlGames);

        docGames.Save("..//..//games.xml");
    }
Example #27
0
 static void Main(string[] args)
 {
     var context = new DiabloEntities();
     var doc = XDocument.Load("../../../data/users-and-games.xml");
     var users = doc.Root.Elements();
     foreach (var user in users)
     {
         try
         {
             ProcessUserBatch(context, user);
         }
         catch (ArgumentException ex)
         {
             Console.Error.WriteLine(ex.Message);
         }
     }
 }
        static void Main()
        {
            var context = new DiabloEntities();

            var charactersPlayers = context.Characters.Select(c => new
            {
                name = c.Name,
                playedBy =
                    context.Users.Where(u => c.UsersGames.Select(ug => ug.UserId).Contains(u.Id))
                        .Select(u => u.Username)
            }).OrderBy(c => c.name)
                .ToList();

            var serializer = new JavaScriptSerializer();
            var json = serializer.Serialize(charactersPlayers);
            File.WriteAllText("../../characters.json", json);
        }
        static void Main()
        {
            var context = new DiabloEntities();

            var finishedGames = context.Games
                                .Where(g => g.IsFinished)
                                .OrderBy(g => g.Name)
                                .ThenBy(g => g.Duration)
                                .Select(g => new
            {
                GameName = g.Name,
                Duration = g.Duration,
                Users    = g.UsersGames
                           .Select(ug => new
                {
                    UserName  = ug.User.Username,
                    IpAddress = ug.User.IpAddress
                })
            });

            string   file     = "../../finished-games.xml";
            Encoding encoding = Encoding.GetEncoding("utf-8");

            using (XmlTextWriter writer = new XmlTextWriter(file, encoding))
            {
                writer.Formatting  = Formatting.Indented;
                writer.IndentChar  = '\t';
                writer.Indentation = 1;

                writer.WriteStartDocument();
                writer.WriteStartElement("games");
                foreach (var game in finishedGames)
                {
                    WriteGame(writer, game.GameName, game.Duration);
                    writer.WriteStartElement("users");
                    foreach (var user in game.Users)
                    {
                        WriteUser(writer, user.UserName, user.IpAddress);
                        writer.WriteEndElement();
                    }
                    writer.WriteEndElement();
                    writer.WriteEndElement();
                }
            }
        }
Example #30
0
        public static void Main(string[] args)
        {
            var directory = new FileInfo("../../../characters.json");
            var context = new DiabloEntities();
            var characters = context.Characters
                .Select(c => new
                {
                    name = c.Name,
                    playedBy = c.UsersGames.Select(ug => ug.User.Username)
                })
                .OrderBy(c => c.name)
                .ToList();

            var serializaer = new JavaScriptSerializer();
            var json = serializaer.Serialize(characters);
            File.WriteAllText(directory.FullName, json);
            Console.WriteLine("Json saved: " + directory.FullName);
        }
Example #31
0
        static void Main()
        {
            var context = new DiabloEntities();

            var characters = context.Characters
                             .OrderBy(ch => ch.Name)
                             .Select(ch => new
            {
                name     = ch.Name,
                playedBy = ch.UsersGames.Select(u => u.User.Username)
            }).ToList();

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

            //Console.WriteLine(json);

            File.WriteAllText("../../characters.json", json);
        }
Example #32
0
        static void Main(string[] args)
        {
            var context = new DiabloEntities();
            var doc     = XDocument.Load("../../../data/users-and-games.xml");
            var users   = doc.Root.Elements();

            foreach (var user in users)
            {
                try
                {
                    ProcessUserBatch(context, user);
                }
                catch (ArgumentException ex)
                {
                    Console.Error.WriteLine(ex.Message);
                }
            }
        }
 private static User ProcessUsers(XElement us, DiabloEntities context)
 {
     var username = us.Attribute("username").Value;
     var regDate = us.Attribute("registration-date").Value;
     var isDeleted = us.Attribute("is-deleted").Value;
     var ipAddress = us.Attribute("ip-address").Value;
     string firstName = null;
     string lastName = null;
     string email = null;
     if (us.Attribute("first-name") != null)
     {
         firstName = us.Attribute("first-name").Value;
     }
     if (us.Attribute("last-name") != null)
     {
         lastName = us.Attribute("last-name").Value;
     }
     if (us.Attribute("email") != null)
     {
         email = us.Attribute("email").Value;
     }
     var user = context.Users.FirstOrDefault(u => u.Username == username);
     if (user == null)
     {
         user = new User()
         {
             Username = username,
             FirstName = firstName,
             LastName = lastName,
             RegistrationDate = DateTime.Parse(regDate),
             IsDeleted = int.Parse(isDeleted) != 0,
             IpAddress = ipAddress,
             Email = email
         };
         context.Users.Add(user);
         context.SaveChanges();
         Console.WriteLine("Successfully added user {0}", username);
     }
     else
     {
         Console.WriteLine("User {0} already exists", username);
     }
     return user;
 }
Example #34
0
        static void Main(string[] args)
        {
            var db = new DiabloEntities();
            var finishedGames = db.Games
            .Where(g => g.IsFinished)
            .Select(g => new
            {
                GameName = g.Name,
                Darution = g.Duration,
                Users = g.UsersGames.Select(u => new
                {
                    UserName = u.User.Username,
                    IpAddress = u.User.IpAddress
                })
            })
            .OrderBy(g => g.GameName)
            .ThenBy(g => g.Darution)
            .ToList();

            var root = new XElement("games");
            foreach (var finishedGame in finishedGames)
            {
                var game = new XElement("game", new XAttribute("name", finishedGame.GameName));
                if (finishedGame.Darution != null)
                {
                    game.Add(new XAttribute("duration", finishedGame.Darution));
                }
                var users = new XElement("users");
                foreach (var user in finishedGame.Users)
                {
                    var userXml = new XElement("user");
                    userXml.Add(new XAttribute("username", user.UserName));
                    userXml.Add(new XAttribute("ip-address", user.IpAddress));
                    users.Add(userXml);
                }

                game.Add(users);
                root.Add(game);
            }

            var xmlDoc = new XDocument(root);
            xmlDoc.Save("../../finished-games.xml");
        }
Example #35
0
        public static void Main(string[] args)
        {
            var directory  = new FileInfo("../../../characters.json");
            var context    = new DiabloEntities();
            var characters = context.Characters
                             .Select(c => new
            {
                name     = c.Name,
                playedBy = c.UsersGames.Select(ug => ug.User.Username)
            })
                             .OrderBy(c => c.name)
                             .ToList();

            var serializaer = new JavaScriptSerializer();
            var json        = serializaer.Serialize(characters);

            File.WriteAllText(directory.FullName, json);
            Console.WriteLine("Json saved: " + directory.FullName);
        }
        static void Main()
        {
            var    context  = new DiabloEntities();
            string fileName = "../../characters.json";

            var characters = context.Characters
                             .OrderBy(c => c.Name)
                             .Select(c => new
            {
                name     = c.Name,
                playedBy = c.UsersGames
                           .Select(ug => ug.User.Username)
            });

            var json = JsonConvert.SerializeObject(characters,
                                                   Formatting.Indented);

            File.WriteAllText(fileName, json);
        }
        static void Main()
        {
            var context = new DiabloEntities();

            var charactersAndPlayers = context.Characters
                                       .OrderBy(c => c.Name)
                                       .Select(c => new
            {
                name     = c.Name,
                playedBy = c.UsersGames.Select(ug => ug.User.Username)
            });


            var JSerializer        = new JavaScriptSerializer();
            var charactersAndUsers = JSerializer.Serialize(charactersAndPlayers);

            File.WriteAllText("../../characters.json", charactersAndUsers);
            Console.WriteLine("File characters.json exported.");
        }
        static void Main()
        {
            var context = new DiabloEntities();

            var finishedGames = context.Games
                .Where(g => g.IsFinished == true)
                .Select(g => new
                {
                    name = g.Name,
                    duration = g.Duration,
                    users = context.Users.Where(u => g.UsersGames.Select(ug => ug.UserId).Contains(u.Id))
                    .Select(u => new
                    {
                        username = u.Username,
                        ip = u.IpAddress
                    })
                }).OrderBy(g => g.name)
                .ThenBy(g => g.duration)
                .ToList();

            var root = new XElement("games");
            foreach (var fGame in finishedGames)
            {
                var game = new XElement("game", new XAttribute("name", fGame.name));
                if (fGame.duration != null)
                {
                    game.Add(new XAttribute("duration", fGame.duration));
                }
                var users = new XElement("users");
                foreach (var us in fGame.users)
                {
                    var user = new XElement("user", new XAttribute("username", us.username),
                        new XAttribute("ip-address", us.ip));
                    users.Add(user);
                }
                game.Add(users);
                root.Add(game);
            }
            var doc = new XDocument();
            doc.Add(root);
            doc.Save("../../finished-games.xml");
        }
        private static void ImportGame(DiabloEntities context, XElement gameNode, User user, string username)
        {
            var gameName      = gameNode.XPathSelectElement("game-name").Value;
            var joinDate      = ParseDate(gameNode.XPathSelectElement("joined-on").Value);
            var characterNode = gameNode.XPathSelectElement("character");
            var characterName = characterNode.Attribute("name").Value;
            var cash          = decimal.Parse(characterNode.Attribute("cash").Value);
            var level         = int.Parse(characterNode.Attribute("level").Value);

            user.UsersGames.Add(new UsersGame()
            {
                Character = GetCharacterByName(characterName, context),
                Game      = GetGameByName(gameName, context),
                Level     = level,
                JoinedOn  = joinDate,
                Cash      = cash
            });

            Console.WriteLine("User {0} successfully added to game {1} with character {2}",
                              username,
                              gameName,
                              characterName);
        }
Example #40
0
        static void Main()
        {
            var context = new DiabloEntities();

            var xml = new XmlDocument();

            xml.Load("../../users-and-games.xml");
            var rootNode = xml.DocumentElement;

            foreach (XmlNode user in rootNode.ChildNodes)
            {
                var      username         = user.Attributes["username"].Value;
                var      ipAddress        = user.Attributes["ip-address"].Value;
                DateTime registrationDate = DateTime.Parse(user.Attributes["registration-date"].Value);
                bool     isDeleted        = false;
                string   lastName         = null;
                string   firstName        = null;
                string   email            = null;

                if (user.Attributes["first-name"] != null)
                {
                    firstName = user.Attributes["first-name"].Value;
                }
                if (user.Attributes["last-name"] != null)
                {
                    lastName = user.Attributes["last-name"].Value;
                }
                if (user.Attributes["email"] != null)
                {
                    email = user.Attributes["email"].Value;
                }
                if (int.Parse(user.Attributes["is-deleted"].Value) == 1)
                {
                    isDeleted = true;
                }

                if (context.Users.Any(u => u.Username == username))
                {
                    Console.WriteLine("User {0} already exists", username);
                    continue;
                }

                var userGames = rootNode.SelectSingleNode("user/games");


                // Loop through all games for the given user
                foreach (XmlNode game in userGames)
                {
                    var gameName  = game["game-name"].InnerText;
                    var character = game["character"];

                    var characterName  = character.Attributes["name"].Value;
                    var characterCash  = decimal.Parse(character.Attributes["cash"].Value);
                    var characterLevel = int.Parse(character.Attributes["level"].Value);
                    var joinedOn       = DateTime.Parse(game["joined-on"].InnerText);
                    Console.WriteLine(joinedOn);

                    if (game["joined-on"] != null && user.Attributes["registration-date"] != null)
                    {
                        var userGame = new UsersGame()
                        {
                            Cash      = characterCash,
                            Character = context.Characters.FirstOrDefault(c => c.Name == characterName),
                            Game      = context.Games.FirstOrDefault(g => g.Name == gameName),
                            JoinedOn  = joinedOn,
                            Level     = characterLevel,
                            User      = new User()
                            {
                                FirstName        = firstName,
                                LastName         = lastName,
                                Email            = email,
                                Username         = username,
                                IpAddress        = ipAddress,
                                RegistrationDate = registrationDate,
                                IsDeleted        = isDeleted
                            }
                        };

                        context.UsersGames.Add(userGame);

                        Console.WriteLine("Successfully added user {0}", username);
                        Console.WriteLine("User {0} successfully added to game {1}", username, gameName);
                    }
                }

                context.SaveChanges();
            }
        }
Example #41
0
        private static void ProcessUserBatch(DiabloEntities context, XElement user)
        {
            // Optional
            string firstName = null;
            string lastName = null;
            string email = null;
            if (user.Attribute("first-name") != null)
            {
                firstName = user.Attribute("first-name").Value;
            }

            if (user.Attribute("last-name") != null)
            {
                lastName = user.Attribute("last-name").Value;
            }

            if (user.Attribute("email") != null)
            {
                email = user.Attribute("email").Value;
            }

            // Required
            ValidateRequired(user);

            var username = user.Attribute("username").Value;
            var ip = user.Attribute("ip-address").Value;
            var deleted = int.Parse(user.Attribute("is-deleted").Value);
            var isDeleted = true;
            if (deleted == 0)
            {
                isDeleted = false;
            }

            var registrationDate = DateTime.ParseExact(user.Attribute("registration-date").Value, DateTimeFormat,
                CultureInfo.InvariantCulture);

            var dbUser = context.Users.FirstOrDefault(u => u.Username == username);
            if (dbUser != null)
            {
                var message = string.Format("User {0} already exists", username);
                throw new ArgumentException(message);
            }

            var xmlUser = new User()
            {
                FirstName = firstName,
                LastName = lastName,
                Email = email,
                Username = username,
                IpAddress = ip,
                IsDeleted = isDeleted,
                RegistrationDate = registrationDate
            };

            var gameMessages = new List<string>();
            var games = user.Elements();
            foreach (var game in games.Elements())
            {
                var userGame = ProcessGame(context, game);

                xmlUser.UsersGames.Add(userGame);
                var gameMessage = string.Format("User {0} successfully added to game {1}", xmlUser.Username, userGame.Game.Name);
                gameMessages.Add(gameMessage);
            }

            context.Users.Add(xmlUser);
            context.SaveChanges();
            Console.WriteLine("Successfully added user {0}", xmlUser.Username);
            Console.WriteLine(string.Join("\n", gameMessages));
        }
Example #42
0
        private static void ProcessUserBatch(DiabloEntities context, XElement user)
        {
            // Optional
            string firstName = null;
            string lastName  = null;
            string email     = null;

            if (user.Attribute("first-name") != null)
            {
                firstName = user.Attribute("first-name").Value;
            }

            if (user.Attribute("last-name") != null)
            {
                lastName = user.Attribute("last-name").Value;
            }

            if (user.Attribute("email") != null)
            {
                email = user.Attribute("email").Value;
            }

            // Required
            ValidateRequired(user);

            var username  = user.Attribute("username").Value;
            var ip        = user.Attribute("ip-address").Value;
            var deleted   = int.Parse(user.Attribute("is-deleted").Value);
            var isDeleted = true;

            if (deleted == 0)
            {
                isDeleted = false;
            }

            var registrationDate = DateTime.ParseExact(user.Attribute("registration-date").Value, DateTimeFormat,
                                                       CultureInfo.InvariantCulture);

            var dbUser = context.Users.FirstOrDefault(u => u.Username == username);

            if (dbUser != null)
            {
                var message = string.Format("User {0} already exists", username);
                throw new ArgumentException(message);
            }

            var xmlUser = new User()
            {
                FirstName        = firstName,
                LastName         = lastName,
                Email            = email,
                Username         = username,
                IpAddress        = ip,
                IsDeleted        = isDeleted,
                RegistrationDate = registrationDate
            };

            var gameMessages = new List <string>();
            var games        = user.Elements();

            foreach (var game in games.Elements())
            {
                var userGame = ProcessGame(context, game);

                xmlUser.UsersGames.Add(userGame);
                var gameMessage = string.Format("User {0} successfully added to game {1}", xmlUser.Username, userGame.Game.Name);
                gameMessages.Add(gameMessage);
            }

            context.Users.Add(xmlUser);
            context.SaveChanges();
            Console.WriteLine("Successfully added user {0}", xmlUser.Username);
            Console.WriteLine(string.Join("\n", gameMessages));
        }
    public static void Main()
    {
        Thread.CurrentThread.CurrentCulture = new CultureInfo("DE-de");
        var context = new DiabloEntities();

        XmlDocument docUsers = new XmlDocument();

        docUsers.Load("..//..//..//..//data//users-and-games.xml");
        string      usersPath = "/users/user";
        XmlNodeList userNodes = docUsers.SelectNodes(usersPath);
        string      gamesPath = "games/game";

        foreach (XmlNode userNode in userNodes)
        {
            string username = userNode.Attributes["username"].Value;
            User   user     = context.Users.Where(u => u.Username == username).FirstOrDefault();

            if (user != null)
            {
                Console.WriteLine("User {0} already exists", user.Username);
                continue;
            }

            user = new User()
            {
                FirstName = userNode.Attributes["first-name"] != null ?
                            userNode.Attributes["first-name"].Value
                : null,
                LastName = userNode.Attributes["last-name"] != null ?
                           userNode.Attributes["last-name"].Value
                : null,
                Username = username,
                Email    = userNode.Attributes["email"] != null ?
                           userNode.Attributes["email"].Value
                : null,
                IpAddress        = userNode.Attributes["ip-address"].Value,
                IsDeleted        = Convert.ToBoolean(int.Parse(userNode.Attributes["is-deleted"].Value)),
                RegistrationDate = DateTime.Parse(userNode.Attributes["registration-date"].Value)
            };

            context.Users.Add(user);

            XmlNodeList xmlGames = userNode.SelectNodes(gamesPath);
            foreach (XmlNode xmlGame in xmlGames)
            {
                string   gameName      = xmlGame.SelectSingleNode("game-name").InnerText;
                string   characterName = xmlGame.SelectSingleNode("character").Attributes["name"].Value;
                decimal  cash          = decimal.Parse(xmlGame.SelectSingleNode("character").Attributes["cash"].Value);
                int      level         = int.Parse(xmlGame.SelectSingleNode("character").Attributes["level"].Value);
                DateTime joinedOn      = DateTime.Parse(xmlGame.SelectSingleNode("joined-on").InnerText);

                var userGame = new UsersGame()
                {
                    //Game name is a non-unique field in the database and duplicates exist. For the task we
                    //admit that we take the first game with this name.
                    Game      = context.Games.Where(g => g.Name == gameName).First(),
                    User      = user,
                    Character = context.Characters.Where(c => c.Name == characterName).First(),
                    Cash      = cash,
                    Level     = level,
                    JoinedOn  = joinedOn
                };

                context.UsersGames.Add(userGame);
            }

            context.SaveChanges();

            //As per the problem terms we can't add a user if any of his games fail to add.
            //That's why we save changes after all the UserGames are in context. If agame fails to add,
            //the user won't be added. We print the user and its games only in case of a successful add in
            //the context

            var addedUser = context.Users
                            .Where(u => u.Username == username)
                            .Select(u => new
            {
                u.Username,
                UserGames = u.UsersGames.Select(ug => ug.Game.Name)
            })
                            .First();

            Console.WriteLine("Successfully added user " + addedUser.Username);
            foreach (var game in user.UsersGames)
            {
                Console.WriteLine("User {0} successfully added to game {1}", user.Username, game.Game.Name);
            }
        }
    }
Example #44
0
 public static void Main(string[] args)
 {
     var context = new DiabloEntities();
     var characterNames = context.Characters.Select(c => c.Name).ToList();
     characterNames.ForEach(Console.WriteLine);
 }
        static void Main()
        {
            string fileName = "../../users-and-games.xml";

            var         context     = new DiabloEntities();
            XmlDocument xmlDocument = new XmlDocument();

            xmlDocument.Load(fileName);

            XmlNode rootNode = xmlDocument.DocumentElement;

            foreach (XmlNode user in rootNode.ChildNodes)
            {
                try
                {
                    if (user.Attributes.Count > 0)
                    {
                        string   firstName = null, lastName = null, email = null, username = null, ip = null;
                        DateTime regDate    = DateTime.MinValue;
                        bool     isDeleted  = false;
                        User     userFromDb = new User();
                        foreach (XmlAttribute attribute in user.Attributes)
                        {
                            if (attribute.Name == "first-name")
                            {
                                firstName = attribute.Value;
                            }

                            if (attribute.Name == "last-name")
                            {
                                lastName = attribute.Value;
                            }

                            if (attribute.Name == "username")
                            {
                                username = attribute.Value;
                            }

                            if (attribute.Name == "email")
                            {
                                email = attribute.Value;
                            }

                            if (attribute.Name == "ip-address")
                            {
                                ip = attribute.Value;
                            }

                            if (attribute.Name == "is-deleted")
                            {
                                isDeleted = attribute.Value == "1";
                            }

                            if (attribute.Name == "registration-date")
                            {
                                regDate = DateTime.ParseExact(attribute.Value, "dd/mm/yyyy",
                                                              CultureInfo.InvariantCulture);
                            }
                        }

                        userFromDb = context.Users
                                     .FirstOrDefault(u => u.Username == username);
                        if (userFromDb == null)
                        {
                            userFromDb = new User()
                            {
                                Username         = username,
                                FirstName        = firstName,
                                LastName         = lastName,
                                Email            = email,
                                RegistrationDate = regDate,
                                IsDeleted        = isDeleted,
                                IpAddress        = ip
                            };
                            context.Users.Add(userFromDb);
                            Console.WriteLine("Successfully added user {0}", username);
                        }
                        else
                        {
                            Console.WriteLine("User {0} already exists", username);
                            throw new ArgumentException("User already exists");
                        }

                        foreach (XmlNode game in user.FirstChild.ChildNodes)
                        {
                            string   gameName = "", characterName = "";
                            int?     gameId, userId, characterId, level = null;
                            DateTime?joinedOn   = null;
                            decimal? cash       = null;
                            Game     gameFromDb = new Game();
                            if (game["game-name"] != null)
                            {
                                gameName = game["game-name"].InnerText;
                            }
                            if (game["character"] != null)
                            {
                                foreach (XmlAttribute attribute in game["character"].Attributes)
                                {
                                    if (attribute.Name == "name")
                                    {
                                        characterName = attribute.Value;
                                    }

                                    if (attribute.Name == "cash")
                                    {
                                        cash = decimal.Parse(attribute.Value);
                                    }

                                    if (attribute.Name == "level")
                                    {
                                        level = int.Parse(attribute.Value);
                                    }
                                }
                            }

                            if (game["joined-on"] != null)
                            {
                                joinedOn = DateTime.ParseExact(game["joined-on"].InnerText, "dd/mm/yyyy",
                                                               CultureInfo.InvariantCulture);
                            }

                            gameFromDb = context.Games
                                         .FirstOrDefault(g => g.Name == gameName);

                            if (gameFromDb == null)
                            {
                                throw new ArgumentException("No such game exists");
                            }
                            gameId = gameFromDb.Id;

                            if (userFromDb == null)
                            {
                                throw new ArgumentException("User already exists");
                            }
                            userId = userFromDb.Id;

                            Character character = context.Characters
                                                  .FirstOrDefault(c => c.Name == characterName);
                            characterId = character.Id;

                            context.UsersGames.Add(new UsersGame()
                            {
                                GameId      = gameId.Value,
                                User        = userFromDb,
                                CharacterId = characterId.Value,
                                Level       = level.Value,
                                JoinedOn    = joinedOn.Value,
                                Cash        = cash.Value
                            });
                            Console.WriteLine("User {0} successfully added to game {1}", username, gameName);
                        }
                    }
                    context.SaveChanges();
                }
                catch (ArgumentException ex)
                {
                }
            }
        }