示例#1
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            StringBuilder sb       = new StringBuilder();
            var           usersDto = JsonConvert.DeserializeObject <IEnumerable <UserImportModel> >(jsonString);


            foreach (var currentUser in usersDto)
            {
                if (!IsValid(currentUser) || !currentUser.Cards.All(IsValid))
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }

                var user = new User
                {
                    FullName = currentUser.FullName,
                    Username = currentUser.Username,
                    Age      = currentUser.Age,
                    Email    = currentUser.Email,
                    Cards    = currentUser.Cards.Select(x => new Card
                    {
                        Number = x.Number,
                        Cvc    = x.Cvc,
                        Type   = Enum.Parse <CardType>(x.Type)
                    }).ToList()
                };
                context.Users.Add(user);
                sb.AppendLine($"Imported {user.Username} with {user.Cards.Count} cards");
            }

            context.SaveChanges();

            return(sb.ToString().TrimEnd());
        }
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(PurchaseDto[]), new XmlRootAttribute("Purchases"));

            PurchaseDto[] purchaseDtos = (PurchaseDto[])serializer.Deserialize(new StringReader(xmlString));

            StringBuilder   sb             = new StringBuilder();
            List <Purchase> validPurchases = new List <Purchase>();

            foreach (var purchaseDto in purchaseDtos)
            {
                if (!IsValid(purchaseDto))
                {
                    sb.AppendLine(ERROR_MESSAGE);
                    continue;
                }

                Purchase purchase = Mapper.Map <Purchase>(purchaseDto);
                purchase.CardId = context.Cards.SingleOrDefault(c => c.Number == purchaseDto.Card).Id;
                purchase.GameId = context.Games.SingleOrDefault(c => c.Name == purchaseDto.Title).Id;
                purchase.Card   = context.Cards.SingleOrDefault(c => c.Number == purchaseDto.Card);
                purchase.Game   = context.Games.SingleOrDefault(c => c.Name == purchaseDto.Title);

                validPurchases.Add(purchase);
                sb.AppendLine($"Imported {purchaseDto.Title} for {purchase.Card.User.Username}");
            }

            context.Purchases.AddRange(validPurchases);
            context.SaveChanges();

            var result = sb.ToString();

            return(result);
        }
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            var xmlSerializer         = new XmlSerializer(typeof(PurchaseDto[]), new XmlRootAttribute("Purchases"));
            var deserializedPurchases = (PurchaseDto[])xmlSerializer.Deserialize(new StringReader(xmlString));

            var sb = new StringBuilder();

            var purchases = new List <Purchase>();

            foreach (var purchaseDto in deserializedPurchases)
            {
                if (!IsValid(purchaseDto))
                {
                    sb.AppendLine(FailureMsg);
                    continue;
                }

                var isTypeValid = Enum.TryParse(purchaseDto.Type, out PurchaseType purType);

                if (!isTypeValid)
                {
                    sb.AppendLine(FailureMsg);
                    continue;
                }

                var card = context.Cards.FirstOrDefault(c => c.Number == purchaseDto.Card);
                if (card == null)
                {
                    sb.AppendLine(FailureMsg);
                    continue;
                }

                var game = context.Games.FirstOrDefault(g => g.Name == purchaseDto.Title);
                if (game == null)
                {
                    sb.AppendLine(FailureMsg);
                    continue;
                }

                var date = DateTime.ParseExact(purchaseDto.Date, XmlDateFormat, CultureInfo.InvariantCulture);

                var purchase = new Purchase()
                {
                    Game       = game,
                    Card       = card,
                    Date       = date,
                    ProductKey = purchaseDto.Key,
                    Type       = purType
                };

                purchases.Add(purchase);

                sb.AppendLine($"Imported {purchaseDto.Title} for {card.User.Username}");
            }

            context.AddRange(purchases);
            context.SaveChanges();

            return(sb.ToString().Trim());
        }
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            var serializer = new XmlSerializer(typeof(PurchaseDto[]), new XmlRootAttribute("Purchases"));

            var deserialized = (PurchaseDto[])serializer.Deserialize(new StringReader(xmlString));

            StringBuilder result = new StringBuilder();

            foreach (var purchaseDto in deserialized)
            {
                if (!IsValid(purchaseDto))
                {
                    result.AppendLine("Invalid Data");
                    continue;
                }

                var purchase = new Purchase
                {
                    Type       = purchaseDto.Type,
                    ProductKey = purchaseDto.Key,
                    Card       = context.Cards.FirstOrDefault(c => c.Number == purchaseDto.Card),
                    Date       = DateTime.ParseExact(purchaseDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture),
                    Game       = context.Games.FirstOrDefault(x => x.Name == purchaseDto.Title)
                };

                context.Purchases.Add(purchase);


                result.AppendLine($"Imported {purchaseDto.Title} for {purchase.Card.User.Username}");
            }
            context.SaveChanges();
            return(result.ToString().Trim());
        }
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            UserDto[] userDtos = JsonConvert.DeserializeObject <UserDto[]>(jsonString);

            StringBuilder sb         = new StringBuilder();
            List <User>   validUsers = new List <User>();

            foreach (var userDto in userDtos)
            {
                bool cardsAreValid = userDto.Cards.All(IsValid);
                if (!IsValid(userDto) || !cardsAreValid)
                {
                    sb.AppendLine(ERROR_MESSAGE);
                    continue;
                }

                User user = Mapper.Map <User>(userDto);
                userDto.Cards.ToList().ForEach(c => Mapper.Map <Card>(c));

                validUsers.Add(user);
                sb.AppendLine($"Imported {user.Username} with {user.Cards.Count} cards");
            }

            context.Users.AddRange(validUsers);
            context.SaveChanges();

            var result = sb.ToString();

            return(result);
        }
示例#6
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var userDtos = JsonConvert.DeserializeObject <UserImportDto[]>(jsonString);

            var users  = new HashSet <User>();
            var result = new StringBuilder();

            foreach (var dto in userDtos)
            {
                if (IsValid(dto) == false)
                {
                    result.AppendLine(ErrorMsg);
                    continue;
                }

                var user = AutoMapper.Mapper.Map <User>(dto);
                users.Add(user);
                result.AppendLine(String.Format(UserAddedMsg, user.Username, user.Cards.Count));
            }

            context.Users.AddRange(users);
            context.SaveChanges();

            return(result.ToString().TrimEnd());
        }
        public static string UpdateEmail(VaporStoreDbContext context, string username, string newEmail)
        {
            StringBuilder sb = new StringBuilder();

            var user = context
                       .Users
                       .SingleOrDefault(u => u.Username == username);

            if (user == null)
            {
                return$ "User {username} not found";
            }

            var emailAlreadyTaken = context.Users.Any(u => u.Email == newEmail);

            if (emailAlreadyTaken)
            {
                return($"Email {newEmail} is already taken");
            }

            user.Email = newEmail;
            context.SaveChanges();

            return($"Changed {user.Username}'s email successfully");

            return(sb.ToString());
        }
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            var sb = new StringBuilder();

            var serializer = new XmlSerializer(typeof(PurchaseImportDto[]), new XmlRootAttribute("Purchases"));

            var deserialized = (PurchaseImportDto[])serializer.Deserialize(new StringReader(xmlString));

            var validPurchases = new List <Purchase>();

            foreach (var purchaseDto in deserialized)
            {
                if (!IsValid(purchaseDto))
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }

                var game = context.Games.Single(g => g.Name == purchaseDto.Title);
                var card = context.Cards.Include(c => c.User).Single(c => c.Number == purchaseDto.Card);
                var date = DateTime.ParseExact(purchaseDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);

                var purchase = new Purchase(game, purchaseDto.Type, card, purchaseDto.Key, date);

                validPurchases.Add(purchase);
                sb.AppendLine($"Imported {purchase.Game.Name} for {purchase.Card.User.Username}");
            }

            context.Purchases.AddRange(validPurchases);
            context.SaveChanges();

            var result = sb.ToString();

            return(result);
        }
示例#9
0
        public static string UpdateEmail(VaporStoreDbContext context, string username, string newEmail)
        {
            var user = context
                       .Users
                       .FirstOrDefault(u => u.Username == username);

            if (user == null)
            {
                return($"User {username} not found");
            }

            var userWithEmail = context
                                .Users
                                .FirstOrDefault(u => u.Email == newEmail);

            if (userWithEmail != null)
            {
                return($"Email {newEmail} is already taken");
            }

            user.Email = newEmail;
            context.SaveChanges();

            return($"Changed {username}'s email successfully");
        }
示例#10
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var deserializedUsers = JsonConvert.DeserializeObject <UserDto[]>(jsonString);

            var users = new List <User>();

            StringBuilder sb = new StringBuilder();

            foreach (var dto in deserializedUsers)
            {
                if (!IsValid(dto) || !dto.Cards.All(IsValid))
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                var user = new User(dto.FullName, dto.Username, dto.Email, dto.Age, dto.Cards);

                users.Add(user);
                sb.AppendLine(string.Format(SuccessImportUsers, user.Username, user.Cards.Count));
            }

            context.Users.AddRange(users);
            context.SaveChanges();

            string result = sb.ToString();

            return(result);
        }
        public static string UpdateEmail(VaporStoreDbContext context, string username, string newEmail)
        {
            var    targetUser = context.Users.FirstOrDefault(x => x.Username == username);
            string result;

            if (targetUser != null)
            {
                var isTaken = context.Users.FirstOrDefault(x => x.Email == newEmail) != null;
                if (!isTaken)
                {
                    targetUser.Email = newEmail;
                    result           = String.Format(SuccessChangeOfEmailMessage, username);
                    context.SaveChanges();
                }

                else
                {
                    result = String.Format(TakenEmailMessage, newEmail);
                }
            }

            else
            {
                result = String.Format(InvalidUserMessage, username);
            }

            return(result);
        }
示例#12
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            StringBuilder sb = new StringBuilder();

            var usersDto = JsonConvert.DeserializeObject <IEnumerable <ImportUserDTO> >(jsonString);

            List <User> users = new List <User>();

            foreach (var userDTO in usersDto)
            {
                if (!IsValid(userDTO) || !userDTO.Cards.All(IsValid))
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }


                bool isValidEnum = false;

                var currUser = new User
                {
                    Username = userDTO.Username,
                    FullName = userDTO.FullName,
                    Email    = userDTO.Email,
                    Age      = userDTO.Age
                };

                foreach (var card in userDTO.Cards)
                {
                    bool isParsed = Enum.TryParse <CardType>(card.Type, out CardType result);
                    if (!isParsed)
                    {
                        isValidEnum = true;
                        break;
                    }

                    if (isValidEnum)
                    {
                        sb.AppendLine("Invalid Data");
                        continue;
                    }


                    currUser.Cards.Add(new Card
                    {
                        Number = card.Number,
                        Cvc    = card.CVC,
                        Type   = Enum.Parse <CardType>(card.Type)
                    });
                }

                users.Add(currUser);
                sb.AppendLine($"Imported {userDTO.Username} with {userDTO.Cards.Count()} cards");
            }

            context.Users.AddRange(users);
            context.SaveChanges();

            return(sb.ToString().TrimEnd());
        }
示例#13
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            jsonUser_inp_dto[] usersDTOs = JsonConvert.DeserializeObject <jsonUser_inp_dto[]>(jsonString);
            StringBuilder      sb        = new StringBuilder();
            List <User>        users     = new List <User>();

            foreach (var dto in usersDTOs)
            {
                if (!AttributeValidation.IsValid(dto))
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }
                var user = new User()
                {
                    FullName = dto.FullName,
                    Age      = dto.Age,
                    Email    = dto.Email,
                    Username = dto.Username,
                    Cards    = dto.Cards.Select(x => new Card()
                    {
                        Cvc    = x.Cvc,
                        Number = x.Number,
                        Type   = (CardType)Enum.Parse(typeof(CardType), x.Type, true)
                    }).ToArray()
                };
                sb.AppendLine($"Imported {user.Username} with {user.Cards.Count} cards");
                users.Add(user);
            }
            context.Users.AddRange(users);
            context.SaveChanges();
            return(sb.ToString().Trim());
        }
示例#14
0
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            var outputResult        = new StringBuilder();
            var validPurchasesToAdd = new List <Purchase>();

            var purchasesDtos = XmlConverter.Deserializer <ImportPurchaseDto>(xmlString, "Purchases");

            foreach (var purchaseDto in purchasesDtos)
            {
                PurchaseType purchaseType;
                var          isGenreValid = Enum.TryParse <PurchaseType>(purchaseDto.Type, true, out purchaseType);

                var targetGame = context.Games.FirstOrDefault(x => x.Name == purchaseDto.Title);
                var targetCard = context.Cards.FirstOrDefault(x => x.Number == purchaseDto.Card);

                if (!IsValid(purchaseDto) || targetGame == null || !isGenreValid || targetCard == null)
                {
                    outputResult.AppendLine(ErrorMessage);
                    continue;
                }
                var newPurchase = new Purchase
                {
                    Game       = targetGame,
                    Type       = purchaseType,
                    ProductKey = purchaseDto.ProductKey,
                    Date       = DateTime.ParseExact(purchaseDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture),
                    Card       = targetCard
                };
                validPurchasesToAdd.Add(newPurchase);
                outputResult.AppendLine(string.Format(SuccessfullyImportedPurchase, newPurchase.Game.Name, newPurchase.Card.User.Username));
            }
            context.AddRange(validPurchasesToAdd);
            context.SaveChanges();
            return(outputResult.ToString().TrimEnd());
        }
示例#15
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var sb = new StringBuilder();

            var usersDtos = JsonConvert.DeserializeObject <ImportUserDto[]>(jsonString);

            List <User> users = new List <User>();

            foreach (var userDto in usersDtos)
            {
                if (!IsValid(userDto))
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }


                var validUser = new User
                {
                    FullName = userDto.FullName,
                    Username = userDto.Username,
                    Email    = userDto.Email,
                    Age      = userDto.Age,
                };

                foreach (var cardDto in userDto.Cards)
                {
                    if (!IsValid(cardDto))
                    {
                        sb.AppendLine(ErrorMessage);
                        break;
                    }

                    CardType type;
                    bool     isValidCardType = Enum.TryParse(cardDto.Type, out type);
                    if (!isValidCardType)
                    {
                        sb.AppendLine(ErrorMessage);
                        break;
                    }
                    Card card = new Card
                    {
                        Number = cardDto.Number,
                        Cvc    = cardDto.CVC,
                        Type   = type,
                        User   = validUser
                    };

                    validUser.Cards.Add(card);
                }

                users.Add(validUser);
                sb.AppendLine($"Imported {validUser.Username} with {validUser.Cards.Count} cards");
            }

            context.Users.AddRange(users);
            context.SaveChanges();

            return(sb.ToString().Trim());
        }
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var userDtos = JsonConvert.DeserializeObject <UserDto[]>(jsonString);

            var validUsers = new List <User>();

            StringBuilder sb = new StringBuilder();

            foreach (var userDto in userDtos)
            {
                if (!IsValid(userDto) || userDto.Cards.Length == 0 ||
                    userDto.Cards.Any(c => !IsValid(c)))
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }

                var user = Mapper.Map <User>(userDto);

                validUsers.Add(user);

                sb.AppendLine($"Imported {user.Username} with {user.Cards.Count} cards");
            }

            context.Users.AddRange(validUsers);
            context.SaveChanges();

            return(sb.ToString());
        }
示例#17
0
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            var serializer   = new XmlSerializer(typeof(List <PurchaseDto>), new XmlRootAttribute("Purchases"));
            var importedDtos = (List <PurchaseDto>)serializer.Deserialize(new StringReader(xmlString));

            var result = new StringBuilder();

            var validPurchases = new List <Purchase>();

            foreach (var purchaseDto in importedDtos)
            {
                if (!IsValid(purchaseDto))
                {
                    result.AppendLine(ErrorMessage);
                    continue;
                }

                if (!Enum.TryParse <PurchaseType>(purchaseDto.Type, out PurchaseType type))
                {
                    result.AppendLine(ErrorMessage);
                    continue;
                }

                var card = context.Cards.Include(c => c.User).FirstOrDefault(c => c.Number == purchaseDto.Card);

                if (card is null)
                {
                    result.AppendLine(ErrorMessage);
                    continue;
                }

                var date = DateTime.ParseExact(purchaseDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);

                var game = context.Games.FirstOrDefault(g => g.Name == purchaseDto.Game);

                if (game is null)
                {
                    result.AppendLine(ErrorMessage);
                    continue;
                }

                var purchase = new Purchase
                {
                    Type       = type,
                    ProductKey = purchaseDto.Key,
                    Card       = card,
                    Date       = date,
                    Game       = game
                };

                validPurchases.Add(purchase);

                result.AppendLine($"Imported {purchase.Game.Name} for {purchase.Card.User.Username}");
            }

            context.Purchases.AddRange(validPurchases);
            context.SaveChanges();

            return(result.ToString());
        }
示例#18
0
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            StringBuilder sb         = new StringBuilder();
            var           serializer = new XmlSerializer(typeof(PurchaseDto[]), new XmlRootAttribute("Purchases"));
            var           purchases  = (PurchaseDto[])serializer.Deserialize(new StringReader(xmlString));
            var           pList      = new List <Purchase>();

            foreach (var purchase in purchases)
            {
                if (!IsValid(purchase))
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }
                var cPurchase = new Purchase
                {
                    Date       = DateTime.ParseExact(purchase.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture),
                    ProductKey = purchase.Key,
                    Type       = (PurchaseType)Enum.Parse(typeof(PurchaseType), purchase.Type)
                };
                var Card = context.Cards.FirstOrDefault(x => x.Number == purchase.Card);
                var Game = context.Games.FirstOrDefault(x => x.Name == purchase.Title);
                cPurchase.Card = Card;
                cPurchase.Game = Game;
                sb.AppendLine($"Imported {cPurchase.Game.Name} for {cPurchase.Card.User.Username}");
                pList.Add(cPurchase);
            }
            context.Purchases.AddRange(pList);
            context.SaveChanges();
            return(sb.ToString().TrimEnd());
        }
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            StringBuilder sb = new StringBuilder();

            List <User> users = new List <User>();


            ImportUsersDto[] importUsers = JsonConvert.DeserializeObject <ImportUsersDto[]>(jsonString);

            foreach (var userToAdd in importUsers)
            {
                if (!IsValid(userToAdd))
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                if (userToAdd.Cards.Length == 0)
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }
                User user = new User()
                {
                    FullName = userToAdd.FullName,
                    Username = userToAdd.Username,
                    Email    = userToAdd.Email,
                    Age      = userToAdd.Age
                };
                foreach (var itemCard in userToAdd.Cards)
                {
                    if (!IsValid(itemCard))
                    {
                        sb.AppendLine(ErrorMessage);
                        continue;
                    }

                    CardType typeCard;
                    bool     isValid = Enum.TryParse(itemCard.Type, out typeCard);

                    if (!isValid)
                    {
                        sb.AppendLine(ErrorMessage);
                    }
                    Card card = new Card()
                    {
                        Cvc    = itemCard.Cvc,
                        Number = itemCard.Number,
                        Type   = typeCard,
                        User   = user
                    };
                    user.Cards.Add(card);
                }
                users.Add(user);
                sb.AppendLine(string.Format(SuccessfullyAddedUser, user.Username, user.Cards.Count));
            }
            context.Users.AddRange(users);
            context.SaveChanges();
            return(sb.ToString().TrimEnd());
        }
示例#20
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            StringBuilder sb = new StringBuilder();

            ImportUserJsonDto[] jsonDto = JsonConvert.DeserializeObject <ImportUserJsonDto[]>(jsonString);

            List <User> users = new List <User>();

            foreach (var obj in jsonDto)
            {
                if (!IsValid(obj))
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                User user = new User()
                {
                    Username = obj.Username,
                    FullName = obj.FullName,
                    Email    = obj.FullName,
                    Age      = obj.Age
                };

                foreach (var card in obj.Cards)
                {
                    if (!IsValid(card))
                    {
                        sb.AppendLine(ErrorMessage);
                        continue;
                    }
                    int cardType = -1;
                    if (card.Type == "Debit")
                    {
                        cardType = 0;
                    }
                    else if (card.Type == "Credit")
                    {
                        cardType = 1;
                    }
                    else
                    {
                        sb.AppendLine(ErrorMessage);
                        continue;
                    }
                    Card addCard = new Card
                    {
                        Number = card.Number,
                        Cvc    = card.CVC,
                        Type   = (CardType)cardType
                    };
                    user.Cards.Add(addCard);
                }
                users.Add(user);
                sb.AppendLine($"Imported {user.Username} with {user.Cards.Count} cards");
            }
            context.Users.AddRange(users);
            context.SaveChanges();
            return(sb.ToString().TrimEnd());
        }
示例#21
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var userDtos = JsonConvert.DeserializeObject <ImportUserDto[]>(jsonString);

            List <User> users = new List <User>();

            var sb = new StringBuilder();

            foreach (var userDto in userDtos)
            {
                bool validCardType = true;

                if (!IsValid(userDto) || userDto.Cards.Count == 0)
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }

                User user = new User
                {
                    FullName = userDto.FullName,
                    Username = userDto.Username,
                    Email    = userDto.Email,
                    Age      = userDto.Age
                };



                foreach (var card in userDto.Cards)
                {
                    if (!IsValid(card) || userDto.Cards.Any(x => x.Type != "Debit" && x.Type != "Credit"))
                    {
                        sb.AppendLine("Invalid Data");
                        validCardType = false;
                        break;
                    }
                }

                if (validCardType == false)
                {
                    continue;
                }

                foreach (var card in userDto.Cards)
                {
                    user.Cards.Add(GetCard(context, card));
                }

                sb.AppendLine($"Imported {user.Username} with {user.Cards.Count} cards");

                users.Add(user);
            }
            context.Users.AddRange(users);
            context.SaveChanges();

            string result = sb.ToString().TrimEnd();

            return(result);
        }
示例#22
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var usersDTO = JsonConvert.DeserializeObject <IEnumerable <ImportUserDTO> >(jsonString);

            var sb    = new StringBuilder();
            var users = new List <User>();

            foreach (var userDTO in usersDTO)
            {
                if (!IsValid(userDTO))
                {
                    sb.AppendLine(errorMessage);
                    continue;
                }

                var user = new User()
                {
                    Username = userDTO.Username,
                    FullName = userDTO.FullName,
                    Email    = userDTO.Email,
                    Age      = userDTO.Age
                };

                foreach (var cardDTO in userDTO.Cards)
                {
                    if (!IsValid(cardDTO))
                    {
                        sb.AppendLine(errorMessage);
                        continue;
                    }

                    CardType cardType;
                    var      isValidEnum = Enum.TryParse(cardDTO.Type, out cardType);

                    if (!isValidEnum)
                    {
                        sb.AppendLine(errorMessage);
                        continue;
                    }

                    var card = new Card()
                    {
                        Number = cardDTO.Number,
                        Cvc    = cardDTO.CVC,
                        Type   = cardType,
                    };

                    user.Cards.Add(card);
                }

                users.Add(user);
                sb.AppendLine(string.Format(successsMessageImportUser, user.Username, user.Cards.Count));
            }

            context.Users.AddRange(users);
            context.SaveChanges();

            return(sb.ToString().Trim());
        }
        public static string ImportGames(VaporStoreDbContext context, string jsonString)
        {
            StringBuilder sb = new StringBuilder();

            ImportGameDto[] gamesDto = JsonConvert.DeserializeObject <ImportGameDto[]>(jsonString);

            List <Game> games = new List <Game>();

            foreach (var jsonGame in gamesDto)
            {
                if (!IsValid(jsonGame) || jsonGame.Tags.Count() == 0)
                {
                    sb.AppendLine(ERROR_MESSAGE);
                    continue;
                }

                Genre genre = context.Genres
                              .FirstOrDefault(x => x.Name == jsonGame.Genre)
                              ?? new Genre {
                    Name = jsonGame.Genre
                };

                Developer developer = context.Developers
                                      .FirstOrDefault(x => x.Name == jsonGame.Developer)
                                      ?? new Developer {
                    Name = jsonGame.Developer
                };

                Game game = new Game
                {
                    Name        = jsonGame.Name,
                    Genre       = genre,
                    Developer   = developer,
                    Price       = jsonGame.Price,
                    ReleaseDate = jsonGame.ReleaseDate.Value
                };

                foreach (var jsonTag in jsonGame.Tags)
                {
                    Tag tag = context.Tags
                              .FirstOrDefault(x => x.Name == jsonTag)
                              ?? new Tag {
                        Name = jsonTag
                    };

                    game.GameTags.Add(new GameTag {
                        Tag = tag
                    });
                }
                context.Games.Add(game);
                context.SaveChanges();

                sb.AppendLine(string.Format(SUCCESSFULL_GAME_IMPORT,
                                            game.Name,
                                            game.Genre.Name,
                                            game.GameTags.Count));
            }
            return(sb.ToString().TrimEnd());
        }
示例#24
0
        public static string ImportGames(VaporStoreDbContext context, string jsonString)
        {
            //var gamesDto = JsonConvert.DeserializeObject<List<ImportGameDto>>(jsonString)
            //    .Where(x=> String.IsNullOrEmpty(x.Name)==false
            //    && x.Price>=0 && x.Price<= decimal.MaxValue
            //    && String.IsNullOrEmpty(x.Developer)==false
            //    && String.IsNullOrEmpty(x.Genre)==false
            //    && x.Tags.Count>=1)
            //    .ToList();

            var gamesDto = JsonConvert.DeserializeObject <List <ImportGameDto> >(jsonString)
                           .ToList();

            ;
            var sb = new StringBuilder();

            var gamesList = new List <Game>();

            foreach (var gameDto in gamesDto)
            {
                if (!IsValid(gameDto) || gameDto.Tags.Count == 0)
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }

                var developer = GetDeveloper(context, gameDto.Developer);
                var genre     = GetGenre(context, gameDto.Genre);


                var releaseDate = DateTime.ParseExact(gameDto.ReleaseDate, "yyyy-MM-dd", CultureInfo.InvariantCulture);

                var game = new Game()
                {
                    Name        = gameDto.Name,
                    Price       = gameDto.Price,
                    ReleaseDate = releaseDate,
                    Genre       = genre,
                    Developer   = developer
                };

                foreach (var currentTag in gameDto.Tags)
                {
                    var tag = GetTag(context, currentTag);
                    game.GameTags.Add(new GameTag
                    {
                        Game = game,
                        Tag  = tag
                    });
                }
                gamesList.Add(game);
                sb.AppendLine($"Added {gameDto.Name} ({game.Genre.Name}) with {game.GameTags.Count} tags");
            }

            context.Games.AddRange(gamesList);
            context.SaveChanges();

            return(sb.ToString().TrimEnd());
        }
示例#25
0
        public static string ImportGames(VaporStoreDbContext context, string jsonString)
        {
            var games = JsonConvert.DeserializeObject <IEnumerable <ImportGamesDevsGenresTagsDTO> >(jsonString);

            var sb = new StringBuilder();

            foreach (var jsonGame in games)
            {
                if (!IsValid(jsonGame) || jsonGame.Tags.Count() == 0)
                {
                    sb.AppendLine("Invalid Data");
                    continue;
                }

                var genre = context.Genres.FirstOrDefault(x => x.Name == jsonGame.Genre)
                            ?? new Genre {
                    Name = jsonGame.Genre
                };

                var developer = context.Developers.FirstOrDefault(x => x.Name == jsonGame.Developer)
                                ?? new Developer {
                    Name = jsonGame.Developer
                };

                //var developer = context.Developers.FirstOrDefault(x => x.Name == jsonGame.Developer);
                //if (developer == null)
                //{
                //	developer = new Developer { Name = jsonGame.Developer };
                //}

                var game = new Game
                {
                    Name        = jsonGame.Name,
                    Price       = jsonGame.Price,
                    ReleaseDate = jsonGame.ReleaseDate.Value,
                    Developer   = developer,
                    Genre       = genre
                };

                foreach (var jsonTag in jsonGame.Tags)
                {
                    var tag = context.Tags.FirstOrDefault(x => x.Name == jsonTag)
                              ?? new Tag {
                        Name = jsonTag
                    };
                    game.GameTags.Add(new GameTag {
                        Tag = tag
                    });
                }

                context.Games.Add(game);

                context.SaveChanges();

                sb.AppendLine($"Added {jsonGame.Name} ({jsonGame.Genre}) with {jsonGame.Tags.Count()} tags");
            }

            return(sb.ToString().TrimEnd());
        }
示例#26
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            StringBuilder sb = new StringBuilder();

            ImportUserDto[] importUserDtos = JsonConvert.DeserializeObject <ImportUserDto[]>(jsonString);

            foreach (var userDto in importUserDtos)
            {
                if (!IsValid(userDto))
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                User currentUser = new User()
                {
                    FullName = userDto.FullName,
                    Username = userDto.Username,
                    Email    = userDto.Email,
                    Age      = int.Parse(userDto.Age)
                };

                bool AreCardsValid = true;

                ICollection <Card> userCards = new List <Card>();
                foreach (var cardDto in userDto.Cards)
                {
                    if (!IsValid(cardDto) || (cardDto.Type != "Debit" && cardDto.Type != "Credit"))
                    {
                        AreCardsValid = false;
                        break;
                    }

                    Card currentCard = new Card()
                    {
                        Number = cardDto.Number,
                        Cvc    = cardDto.Cvc,
                        Type   = (CardType)Enum.Parse(typeof(CardType), cardDto.Type)
                    };

                    userCards.Add(currentCard);
                }

                if (!AreCardsValid)
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                currentUser.Cards = userCards;

                sb.AppendLine($"Imported {currentUser.Username} with {currentUser.Cards.Count} cards");
                context.Users.Add(currentUser);
            }

            context.SaveChanges();

            return(sb.ToString().TrimEnd());
        }
示例#27
0
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            var attr       = new XmlRootAttribute("Purchases");
            var serializer = new XmlSerializer(typeof(List <PurchaseImportDto>), attr);

            StringBuilder sb             = new StringBuilder();
            var           validPurchases = new List <Purchase>();

            using (StringReader reader = new StringReader(xmlString))
            {
                var purchasesDto = (List <PurchaseImportDto>)serializer.Deserialize(reader);

                foreach (var dto in purchasesDto)
                {
                    if (!IsValid(dto))
                    {
                        sb.AppendLine("Invalid Data");
                        continue;
                    }

                    var resultType = Enum.TryParse(dto.Type, out PurchaseType type);

                    var card = context
                               .Cards
                               .FirstOrDefault(c => c.Number == dto.Card);

                    var game = context
                               .Games
                               .FirstOrDefault(g => g.Name == dto.Title);

                    if (resultType == false ||
                        card == null ||
                        game == null)
                    {
                        sb.AppendLine("Invalid Data");
                        continue;
                    }

                    var purchase = new Purchase
                    {
                        Type       = type,
                        ProductKey = dto.ProductKey,
                        Date       = DateTime.ParseExact(dto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture),
                        Card       = card,
                        Game       = game
                    };

                    validPurchases.Add(purchase);

                    sb.AppendLine($"Imported {purchase.Game.Name} for {purchase.Card.User.Username}");
                }
            }

            context.Purchases.AddRange(validPurchases);
            context.SaveChanges();

            return(sb.ToString().TrimEnd());
        }
示例#28
0
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var cardsDto = JsonConvert.DeserializeObject <ImportUsersDto[]>(jsonString);

            StringBuilder sb = new StringBuilder();

            var users = new List <User>();

            foreach (var cardDto in cardsDto)
            {
                bool isValidCard = IsValid(cardDto);

                if (!isValidCard)
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                User user = new User
                {
                    FullName = cardDto.FullName,
                    Username = cardDto.Username,
                    Email    = cardDto.Username,
                    Age      = cardDto.Age,
                };

                user.Cards = new HashSet <Card>();

                bool cardsHaveValidType = cardDto.Cards.All(x => Enum.IsDefined(typeof(CardType), x.Type));
                bool cardsAreValid      = cardDto.Cards.All(x => IsValid(x));

                if (cardsHaveValidType && cardsAreValid)
                {
                    foreach (var card in cardDto.Cards)
                    {
                        user.Cards.Add(new Card
                        {
                            Number = card.Number,
                            Cvc    = card.Cvc,
                            Type   = card.Type
                        });
                    }
                    users.Add(user);
                }
                else
                {
                    sb.AppendLine(ErrorMessage);
                    continue;
                }

                sb.AppendLine($"Imported {user.Email} with {user.Cards.Count()} cards");
                //bool isValidCardType = Enum.IsDefined(typeof(CardType), cardDto.Cards);
            }
            context.Users.AddRange(users);
            context.SaveChanges();

            return(sb.ToString().TrimEnd());
        }
        public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
        {
            StringBuilder sb = new StringBuilder();

            ImportPurchaseDto[] purchasesDto = XmlConverter.Deserializer <ImportPurchaseDto>(xmlString, "Purchases");

            List <Purchase> purchases = new List <Purchase>();

            foreach (var pDto in purchasesDto)
            {
                if (!IsValid(pDto))
                {
                    sb.AppendLine(ERROR_MESSAGE);
                    continue;
                }

                DateTime date;
                bool     isValidDate = DateTime.TryParseExact(pDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out date);

                if (!isValidDate)
                {
                    sb.AppendLine(ERROR_MESSAGE);
                    continue;
                }

                Game game = context.Games.FirstOrDefault(x => x.Name == pDto.Title);
                if (game == null)
                {
                    sb.AppendLine(ERROR_MESSAGE);
                    continue;
                }

                Card card = context.Cards.FirstOrDefault(x => x.Number == pDto.Card);
                if (card == null)
                {
                    sb.AppendLine(ERROR_MESSAGE);
                    continue;
                }

                Purchase purchase = new Purchase
                {
                    Type       = pDto.Type.Value,
                    ProductKey = pDto.Key,
                    Date       = date,
                    Card       = card,
                    Game       = game
                };
                purchases.Add(purchase);

                sb.AppendLine(string.Format(SUCCESSFULL_PURCHASE_IMPORT,
                                            game.Name,
                                            card.User.Username));
            }
            context.Purchases.AddRange(purchases);
            context.SaveChanges();

            return(sb.ToString().TrimEnd());
        }
        public static string ImportUsers(VaporStoreDbContext context, string jsonString)
        {
            var resultMessages = new List <string>();

            var usersDto = JsonConvert.DeserializeObject <ImportUsersDto[]>(jsonString);
            var users    = new List <User>();

            foreach (var userDto in usersDto)
            {
                if (!Regex.Match(userDto.FullName, @"[A-Z][a-z]+ [A-Z][a-z]+").Success ||
                    userDto.FullName == "" ||
                    userDto.Username.Length < 3 || userDto.Username.Length > 20 ||
                    userDto.Email == null || userDto.Email == "" ||
                    userDto.Age < 3 || userDto.Age > 103 ||
                    userDto.Cards == null || userDto.Cards.Count == 0)
                {
                    resultMessages.Add(InvalidMessage);
                    continue;
                }

                var user = new User()
                {
                    FullName = userDto.FullName,
                    Username = userDto.Username,
                    Email    = userDto.Email,
                    Age      = userDto.Age
                };

                foreach (var userDtoCard in userDto.Cards)
                {
                    var cardTypeParse = Enum.TryParse <CardType>(userDtoCard.Type, out CardType cardType);
                    if (!Regex.Match(userDtoCard.Number, @"[0-9]{4} [0-9]{4} [0-9]{4} [0-9]{4}").Success ||
                        !Regex.Match(userDtoCard.Cvc, @"[0-9]{3}").Success ||
                        cardTypeParse == false ||
                        cardType == null)
                    {
                        resultMessages.Add(InvalidMessage);
                        continue;
                    }
                    Card card = new Card()
                    {
                        Number = userDtoCard.Number,
                        Cvc    = userDtoCard.Cvc,
                        Type   = cardType
                    };

                    user.Cards.Add(card);
                }

                users.Add(user);
                resultMessages.Add($"Imported {user.Username} with {user.Cards.Count} cards");
            }

            context.Users.AddRange(users);
            context.SaveChanges();

            return(string.Join(Environment.NewLine, resultMessages));
        }