public static string ExportUserPurchasesByType(VaporStoreDbContext context, string storeType)
{
StringBuilder result = new StringBuilder();
XmlRootAttribute xmlRoot = new XmlRootAttribute("Users");
XmlSerializer serializer = new XmlSerializer(typeof(ExportUserDto[]), xmlRoot);
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
namespaces.Add(string.Empty, string.Empty);
using StringWriter sw = new StringWriter(result);
PurchaseType purchaseTypeEnum = Enum.Parse <PurchaseType>(storeType);
ExportUserDto[] users = context.Users
.ToArray()
.Where(u => u.Cards.Any(c => c.Purchases.Any()))
.Select(u => new ExportUserDto()
{
Username = u.Username,
TotalSpent = context.Purchases
.ToArray()
.Where(p => p.Card.User.Username == u.Username && p.Type == purchaseTypeEnum)
.Sum(p => p.Game.Price),
Purchases = context.Purchases
.ToArray()
.Where(p => p.Card.User.Username == u.Username && p.Type == purchaseTypeEnum)
.OrderBy(p => p.Date)
.Select(p => new ExportUserPurchaseDto()
{
Card = p.Card.Number,
Cvc = p.Card.Cvc,
Date = p.Date.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture),
Game = new ExportUserPurchaseGameDto()
{
Title = p.Game.Name,
Genre = p.Game.Genre.Name,
Price = p.Game.Price
}
})
.ToArray(),
})
.Where(u => u.Purchases.Length > 0)
.OrderByDescending(u => u.TotalSpent)
.ThenBy(u => u.Username)
.ToArray();
serializer.Serialize(sw, users, namespaces);
return(result.ToString().TrimEnd());
}
public static string ExportUserPurchasesByType(VaporStoreDbContext context, string storeType)
{
var purchaseType = Enum.Parse <PurchaseType>(storeType);
var users =
context
.Users
.Select(x => new ExportUserDto
{
Username = x.Username,
Purchases = x.Cards
.SelectMany(p => p.Purchases)
.Where(t => t.Type == purchaseType)
.Select(p => new ExportPurchaseDto
{
Card = p.Card.Number,
Cvc = p.Card.Cvc,
Date = p.Date.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture),
Game = new ExportGameDto
{
Genre = p.Game.Genre.Name,
Title = p.Game.Name,
Price = p.Game.Price
}
})
.OrderBy(d => d.Date)
.ToArray(),
TotalSpent = x.Cards.SelectMany(p => p.Purchases)
.Where(t => t.Type == purchaseType)
.Sum(p => p.Game.Price)
})
.Where(p => p.Purchases.Any())
.OrderByDescending(t => t.TotalSpent)
.ThenBy(u => u.Username)
.ToArray();
var sb = new StringBuilder();
var xmlSerializer = new XmlSerializer(typeof(ExportUserDto[]),
new XmlRootAttribute("Users"));
var namespaces = new XmlSerializerNamespaces();
namespaces.Add("", "");
xmlSerializer.Serialize(new StringWriter(sb), users, namespaces);
return(sb.ToString().TrimEnd());
}
public static string ImportGames(VaporStoreDbContext context, string jsonString)
{
var output = new StringBuilder();
var games = JsonConvert
.DeserializeObject <IEnumerable <GameJsonImportModel> >(jsonString);
foreach (var jsonGame in games)
{
if (!IsValid(jsonGame) || jsonGame.Tags.Count() == 0)
{
// Invalid data
output.AppendLine("Invalid Data");
continue;
}
// Valid data
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 game = new Game
{
Name = jsonGame.Name,
Genre = genre,
Developer = developer,
Price = jsonGame.Price,
ReleaseDate = jsonGame.ReleaseDate.Value,
};
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();
output.AppendLine($"Added {jsonGame.Name} ({jsonGame.Genre}) with {jsonGame.Tags.Count()} tags");
}
return(output.ToString());
}
public static string ImportGames(VaporStoreDbContext context, string jsonString)
{
var gamesDto = JsonConvert.DeserializeObject <ImportGameDto[]>(jsonString);
var sb = new StringBuilder();
var games = new List <Game>();
foreach (var gameDto in gamesDto)
{
if (!IsValid(gameDto) || gameDto.Tags.Count == 0)
{
sb.AppendLine("Invalid Data");
continue;
}
var game = new Game
{
Name = gameDto.Name,
Price = gameDto.Price,
ReleaseDate = DateTime.ParseExact(gameDto.ReleaseDate, "yyyy-MM-dd", CultureInfo.InvariantCulture)
};
var developer = GetDeveloper(context, gameDto.Developer);
var genre = GetGenre(context, gameDto.Genre);
game.Developer = developer;
game.Genre = genre;
foreach (var currentTag in gameDto.Tags)
{
var tag = GetTag(context, currentTag);
game.GameTags.Add(new GameTag
{
Game = game,
Tag = tag
});
}
games.Add(game);
sb.AppendLine($"Added {game.Name} ({game.Genre.Name}) with {game.GameTags.Count} tags");
}
context.Games.AddRange(games);
context.SaveChanges();
string result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportUsers(VaporStoreDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
var users = JsonConvert.DeserializeObject <List <UserDto> >(jsonString);
var userList = new List <User>();
foreach (var user in users)
{
if (IsValid(user))
{
var nUser = new User();
nUser.FullName = user.FullName;
nUser.Username = user.UserName;
nUser.Email = user.Email;
nUser.Age = user.Age;
var cardList = new List <Card>();
foreach (var card in user.Cards)
{
if (IsValid(card))
{
var purchases = context.Purchases.Where(x => x.Card.Number == card.Number).ToList();
cardList.Add(new Card {
Number = card.Number, Cvc = card.CVC, Type = card.Type, User = nUser, Purchases = purchases
});
}
if (cardList.Count > 0)
{
nUser.Cards = cardList;
}
else
{
sb.AppendLine("Invalid Data");
continue;
}
}
if (nUser.Cards.Count > 0)
{
userList.Add(nUser);
sb.AppendLine($"Imported {nUser.Username} with {nUser.Cards.Count} cards");
}
}
else
{
sb.AppendLine("Invalid Data");
continue;
}
}
context.Users.AddRange(userList);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ExportUserPurchasesByType(VaporStoreDbContext context, string storeType)
{
var att = new XmlRootAttribute("Users");
var serializer = new XmlSerializer(typeof(UserPurchasesDTO[]), att);
var type = (PurchaseType)Enum.Parse(typeof(PurchaseType), storeType);
var purchases = context.Purchases
.Where(p => p.Type == type)
.Select(p => new PurchaseDTO
{
Username = p.Card.User.Username,
Card = p.Card.Number,
Cvc = p.Card.Cvc,
Date = p.Date,
Game = new GameDTO
{
Title = p.Game.Name,
Genre = p.Game.Genre.Name,
Price = p.Game.Price
}
})
.ToList();
var usernames = context.Users
.Select(u => new UserPurchasesDTO
{
Username = u.Username,
Purchases = purchases
.Where(p => p.Username == u.Username)
.OrderBy(p => p.Date)
.ToList(),
TotalSpent = purchases
.Where(p => p.Username == u.Username)
.Sum(p => p.Game.Price)
})
.Where(p => p.Purchases.Count > 0)
.OrderByDescending(p => p.TotalSpent)
.ThenBy(p => p.Username)
.ToArray();
var sb = new StringBuilder();
var namespaces = new XmlSerializerNamespaces(new[] {
XmlQualifiedName.Empty
});
serializer.Serialize(new StringWriter(sb), usernames, namespaces);
return(sb.ToString());
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
XmlSerializer serializer = new XmlSerializer(typeof(PurchaseInputModel[]), new XmlRootAttribute("Purchases"));
var purchasesDtos = (PurchaseInputModel[])serializer.Deserialize(new StringReader(xmlString));
foreach (var purchase in purchasesDtos)
{
if (!IsValid(purchase))
{
sb.AppendLine(ErrorMessage);
continue;
}
bool parsedDate = DateTime.TryParseExact(purchase.Date,
"dd/MM/yyyy HH:mm",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out var date);
if (!parsedDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var currPurchase = new Purchase
{
Date = date,
Type = purchase.Type.Value,
ProductKey = purchase.Key
};
currPurchase.Card =
context.Cards.FirstOrDefault(x => x.Number == purchase.Card);
currPurchase.Game =
context.Games.FirstOrDefault(x => x.Name == purchase.Title);
var username = context.Users.Where(x => x.Id == currPurchase.Card.UserId)
.Select(x => x.Username).FirstOrDefault();
context.Purchases.Add(currPurchase);
sb.AppendLine(String.Format(SuccessfullyImportedPurchase, purchase.Title, username));
}
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
// The given method in the project skeleton receives an array of genre names.
// Export all games in those genres, which have any purchases.
// For each genre, export its id, genre name, games and total players(total purchase count).
// For each game, export its id, name, developer, tags(separated by ", ") and total player count(purchase count).
// Order the games by player count(descending), then by game id(ascending).
//Order the genres by total player count(descending), then by genre id(ascending)
//"Id": 4,
// "Genre": "Violent",
// "Games": [
// {
// "Id": 49,
// "Title": "Warframe",
// "Developer": "Digital Extremes",
// "Tags": "Single-player, In-App Purchases, Steam Trading Cards, Co-op, Multi-player, Partial Controller Support",
// "Players": 6
public static string ExportUserPurchasesByType(VaporStoreDbContext context, string storeType)
{
var sb = new StringBuilder();
var enumType = Enum.Parse <PurchaseType>(storeType);
var userPurchases = context.Users
.Where(u => u.Cards.SelectMany(p => p.Purchases).Count() >= 1)
.ToList()
.Select(x => new ExportUserPurchasesDto
{
Username = x.Username,
Purchases = x.Cards.SelectMany(p => p.Purchases)
.Where(p => p.Type == enumType)
.OrderBy(x => x.Date)
.Select(p => new ExportPurchasesDto
{
Card = p.Card.Number,
Cvc = p.Card.Cvc,
Date = p.Date.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture),
Game = new ExportGameDto
{
Title = p.Game.Name,
Genre = p.Game.Genre.Name,
Price = p.Game.Price
}
}).ToArray(),
TotalSpent = x.Cards.SelectMany(x => x.Purchases).Where(p => p.Type == enumType).Sum(x => x.Game.Price)
}).Where(p => p.Purchases.Any())
.OrderByDescending(x => x.TotalSpent)
.ThenBy(x => x.Username)
.ToList();
var xmlSerializer = new XmlSerializer(typeof(List <ExportUserPurchasesDto>)
, new XmlRootAttribute("Users"));
var namespaces = new XmlSerializerNamespaces();
namespaces.Add("", "");
using (var writer = new StringWriter(sb))
{
xmlSerializer.Serialize(writer, userPurchases, namespaces);
}
return(sb.ToString().Trim());
}
public static string ImportGames(VaporStoreDbContext context, string jsonString)
{
var gameDtos = JsonConvert.DeserializeObject <GameDto[]>(jsonString);
StringBuilder sb = new StringBuilder();
var games = new List <Game>();
var existingTags = context.Tags.ToList();
var existingGenres = context.Genres.ToList();
var existingDevs = context.Developers.ToList();
foreach (var dto in gameDtos)
{
if (!IsValid(dto))
{
sb.AppendLine(InvalidData);
continue;
}
var dev = GetDev(existingDevs, dto);
var genre = GetGenre(existingGenres, dto);
var tags = GetTags(existingTags, dto);
var game = new Game()
{
Name = dto.Name,
Price = dto.Price,
ReleaseDate = DateTime.ParseExact(dto.ReleaseDate, "yyyy-MM-dd", CultureInfo.InvariantCulture),
Developer = dev,
Genre = genre,
};
foreach (var tag in tags)
{
var gameTag = new GameTag()
{
Tag = tag
};
game.GameTags.Add(gameTag);
}
games.Add(game);
sb.AppendLine($"Added {game.Name} ({game.Genre.Name}) with {tags.Count} tags");
}
context.Games.AddRange(games);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
XmlSerializer serializer = new XmlSerializer(typeof(ImportPurchaseDto[]), new XmlRootAttribute("Purchases"));
ImportPurchaseDto[] purchaseDtos = (ImportPurchaseDto[])serializer.Deserialize(new StringReader(xmlString));
StringBuilder sb = new StringBuilder();
List <Purchase> purchases = new List <Purchase>();
foreach (var purchaseDto in purchaseDtos)
{
if (!IsValid(purchaseDto))
{
sb.AppendLine("Invalid Data");
continue;
}
bool typeIsValid = Enum.TryParse(purchaseDto.Type, out PurchaseType purchaseType);
if (!typeIsValid)
{
sb.AppendLine("Invalid Data");
continue;
}
Game game = context.Games.FirstOrDefault(g => g.Name == purchaseDto.Title);
Card card = context.Cards.FirstOrDefault(c => c.Number == purchaseDto.Card);
if (card == null || game == null)
{
sb.AppendLine("Invalid Data");
continue;
}
Purchase purchase = new Purchase()
{
ProductKey = purchaseDto.Key,
Date = DateTime.ParseExact(purchaseDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture),
Type = purchaseType,
GameId = game.Id,
CardId = card.Id
};
purchases.Add(purchase);
sb.AppendLine($"Imported {game.Name} for {card.User.Username}");
}
context.Purchases.AddRange(purchases);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ExportGamesByGenres(VaporStoreDbContext context, string[] genreNames)
{
var genres = context
.Genres
.Where(g => genreNames.Contains(g.Name))
.ProjectTo <ExportJsonGenreDto>()
.OrderByDescending(g => g.TotalPlayers)
.ThenBy(g => g.Id)
.ToArray();
var jsonGenres = JsonConvert.SerializeObject(genres);
return(jsonGenres);
}
public static string ExportUserPurchasesByType(VaporStoreDbContext context, string storeType)
{
Console.ReadLine();
var serializer = new XmlSerializer(typeof(export_userXML_dto[]), new XmlRootAttribute("Users"));
PurchaseType purchaseType = Enum.Parse <PurchaseType>(storeType);
var usersSet = context.Users
.Include(x => x.Cards)
.ThenInclude(c => c.Purchases)
.ThenInclude(p => p.Game)
.Where(x => x.Cards.Any(c => c.Purchases.Any(p => p.Type == purchaseType)))
.Select(x => new export_userXML_dto()
{
Username = x.Username,
TotalSpent = x.Cards
.SelectMany(c => c.Purchases)
.Where(p => p.Type == purchaseType)
.Sum(p => p.Game.Price),
Purchases = x.Cards
.SelectMany(c => c.Purchases)
.Where(p => p.Type == purchaseType)
.OrderBy(p => p.Date)
.Select(p => new export_purchaseXML_dto()
{
Card = p.Card.Number,
Cvc = p.Card.Cvc,
Date = p.Date.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture),
Game = new export_gameXML_dto()
{
GameName = p.Game.Name,
Genre = p.Game.Genre.Name,
Price = p.Game.Price
}
}).ToList()
})
.OrderByDescending(x => x.TotalSpent)
.ThenBy(x => x.Username).ToArray();
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
{
serializer.Serialize(sw, usersSet, ns);
}
return(sb.ToString().Trim());
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(ImportPurchaseDto[]), new XmlRootAttribute("Purchases"));
var deserialized = (ImportPurchaseDto[])xmlSerializer.Deserialize(new StringReader(xmlString));
StringBuilder sb = new StringBuilder();
List <Game> games = context.Games.Select(x => x).ToList();
List <Card> cards = context.Cards.Select(x => x).ToList();
List <Purchase> purchases = new List <Purchase>();
foreach (ImportPurchaseDto purchaseDto in deserialized)
{
if (!IsValid(purchaseDto))
{
sb.AppendLine("Invalid data");
continue;
}
DateTime date;
var datastring = DateTime.TryParseExact(purchaseDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out date);
var card = cards.FirstOrDefault(x => x.Name == purchaseDto.Card);
var game = games.FirstOrDefault(x => x.Name == purchaseDto.Title);
var type = Enum.Parse <PurchaseType>(purchaseDto.Type);
if (card == null || game == null)
{
sb.AppendLine("Invalid data");
continue;
}
Purchase newPucrhase = new Purchase()
{
ProductKey = purchaseDto.Key,
Date = date,
Card = card,
Game = game,
Type = type
};
purchases.Add(newPucrhase);
sb.AppendLine($"Imported {purchaseDto.Title} for {card.User.Username}");
}
context.Purchases.AddRange(purchases);
context.SaveChanges();
var result = sb.ToString();
return(result);
}
public static string ImportUsers(VaporStoreDbContext context, string jsonString)
{
var userDtos = JsonConvert.DeserializeObject <IEnumerable <ImportUserDto> >(jsonString);
var sb = new StringBuilder();
foreach (var userDto in userDtos)
{
if (userDto.Cards.Count < 1 || userDto.Cards.Any(c => !IsValid(c) || (c.Type != "Debit" && c.Type != "Credit")))
{
sb.AppendLine(ErrorMessage);
continue;
}
if (!IsValid(userDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var user = new User
{
FullName = userDto.FullName,
Email = userDto.Email,
Username = userDto.Username,
Age = userDto.Age
};
context.Users.Add(user);
sb.AppendLine($"Imported {user.Username} with {userDto.Cards.Count} cards");
foreach (var cardDto in userDto.Cards)
{
var card = new Card
{
Number = cardDto.Number,
Cvc = cardDto.Cvc,
Type = Enum.Parse <CardType>(cardDto.Type),
UserId = user.Id,
User = user
};
context.Cards.Add(card);
}
}
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportUsers(VaporStoreDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
var importUsersDto = JsonConvert.DeserializeObject <ImportUsersAndCardsDto[]>(jsonString);
var usersList = new List <User>();
var cardsList = new List <Card>();
foreach (var user in importUsersDto)
{
if (!IsValid(user) || !IsValidFullName(user.FullName) || user.Cards.IsNullOrEmpty())
{
sb.AppendLine(ErrorMessage);
continue;
}
var currentUser = new User
{
FullName = user.FullName,
Username = user.Username,
Email = user.Email,
Age = user.Age
};
foreach (var card in user.Cards)
{
if (!ValideteTypeCard(card.Type) || !IsValid(card))
{
sb.AppendLine(ErrorMessage);
continue;
}
var currentCard = new Card
{
Number = card.Number,
Cvc = card.CVC,
Type = (CardType)Enum.Parse(typeof(CardType), card.Type)
};
cardsList.Add(currentCard);
currentUser.Cards.Add(currentCard);
}
usersList.Add(currentUser);
sb.AppendLine($"Imported {currentUser.Username} with {currentUser.Cards.Count} cards");
}
context.Users.AddRange(usersList);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
private static void ImportEntities(VaporStoreDbContext context, string baseDir, string exportDir)
{
string games = Deserializer.ImportGames(context, File.ReadAllText(baseDir + "games.json"));
PrintAndExportEntityToFile(games, exportDir + "ImportGames.txt");
string users = Deserializer.ImportUsers(context, File.ReadAllText(baseDir + "users.json"));
PrintAndExportEntityToFile(users, exportDir + "ImportUsers.txt");
string purchases = Deserializer.ImportPurchases(context, File.ReadAllText(baseDir + "purchases.xml"));
PrintAndExportEntityToFile(purchases, exportDir + "ImportPurchases.txt");
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
var purchasesToImport = XmlConverter.Deserializer <PurchaseInputModel>(xmlString, "Purchases");
foreach (var purchase in purchasesToImport)
{
var isValidDate = DateTime.TryParseExact(
purchase.Date,
"dd/MM/yyyy HH:mm",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime currentDate);
if (!IsValid(purchase) || !isValidDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
Card currentCard = context.Cards.FirstOrDefault(c => c.Number == purchase.Card);
if (currentCard == null)
{
sb.AppendLine(ErrorMessage);
continue;
}
Game currentGame = context.Games.FirstOrDefault(g => g.Name == purchase.Title);
if (currentGame == null)
{
sb.AppendLine(ErrorMessage);
continue;
}
var purchaseToAdd = new Purchase
{
Type = Enum.Parse <PurchaseType>(purchase.Type),
ProductKey = purchase.ProductKey,
Date = currentDate,
Card = currentCard,
Game = currentGame
};
context.Purchases.Add(purchaseToAdd);
sb.AppendLine($"Imported {currentGame.Name} for {purchaseToAdd.Card.User.Username}");
}
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
private static Tag GetTag(VaporStoreDbContext context, string currentTag)
{
var tag = context.Tags.FirstOrDefault(x => x.Name == currentTag);
if (tag == null)
{
tag = new Tag
{
Name = currentTag
};
}
return(tag);
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(List <ImportPurchasesDto>),
new XmlRootAttribute("Purchases"));
var reader = new StringReader(xmlString);
var purchasesDto = (List <ImportPurchasesDto>)serializer.Deserialize(reader);
var purchases = new List <Purchase>();
var sb = new StringBuilder();
foreach (var purchaseDto in purchasesDto)
{
bool isTypeValid = Enum.IsDefined(typeof(PurchaseType), purchaseDto.Type);
var card = context.Cards.FirstOrDefault(card1 => card1.Number == purchaseDto.Card);
var game = context.Games.FirstOrDefault(game1 => game1.Name == purchaseDto.Title);
if (!IsValid(purchaseDto) || !isTypeValid || card == null || game == null)
{
sb.AppendLine(ErrorMessage);
continue;
}
var purchase = new Purchase
{
Type = Enum.Parse <PurchaseType>(purchaseDto.Type),
Card = card,
Game = game,
ProductKey = purchaseDto.Key,
Date = DateTime.ParseExact(purchaseDto.Date, @"dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)
};
if (!IsValid(purchase))
{
sb.AppendLine(ErrorMessage);
continue;
}
purchases.Add(purchase);
// TO DO FORMAT
sb.AppendLine(String.Format(CultureInfo.InvariantCulture, SuccessfullyImportedPurchase, purchase.Game.Name, purchase.Card.User.Username));
}
context.Purchases.AddRange(purchases);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportUsers(VaporStoreDbContext context, string jsonString)
{
var users = JsonConvert.DeserializeObject <User[]>(jsonString);
StringBuilder result = new StringBuilder();
foreach (var user in users)
{
if (!IsValid(user) || user.Cards.Count == 0)
{
result.AppendLine("Invalid Data");
continue;
}
User newUser = new User
{
Username = user.Username,
FullName = user.FullName,
Email = user.Email,
Age = user.Age,
Cards = new List <Card>()
};
foreach (var card in user.Cards)
{
if (!IsValid(card))
{
result.AppendLine("Invalid Data");
continue;
}
Card newCard = new Card
{
Number = card.Number,
Cvc = card.Cvc,
Type = card.Type,
User = newUser,
Purchases = new List <Purchase>()
};
newUser.Cards.Add(newCard);
}
context.Users.Add(newUser);
result.AppendLine($"Imported {newUser.Username} with {newUser.Cards.Count} cards");
}
context.SaveChanges();
return(result.ToString().TrimEnd());
}
private static Genre GetGenre(VaporStoreDbContext context, ImportGameDTO game)
{
var genre = context.Genres.FirstOrDefault(x => x.Name == game.Genre);
if (genre == null)
{
genre = new Genre {
Name = game.Genre
};
context.Genres.Add(genre);
context.SaveChanges();
}
return(genre);
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
var sb = new StringBuilder();
List <Purchase> purchasesToAdd = new List <Purchase>();
PurchaseXmlInputModel[] purchases = XmlConverter.Deserializer <PurchaseXmlInputModel>(xmlString, "Purchases");
foreach (var currentPurchase in purchases)
{
if (!IsValid(currentPurchase))
{
sb.AppendLine("Invalid Data");
continue;
}
Card card = context.Cards.FirstOrDefault(c => c.Number == currentPurchase.Card);
Game game = context.Games.FirstOrDefault(g => g.Name == currentPurchase.gameTitle);
DateTime date;
bool isDateValid = DateTime.TryParseExact(
currentPurchase.Date,
"dd/MM/yyyy HH:mm",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out date);
if (!isDateValid)
{
sb.AppendLine("Invalid Data");
continue;
}
Purchase purchase = new Purchase
{
ProductKey = currentPurchase.Key,
Type = Enum.Parse <PurchaseType>(currentPurchase.Type),
Game = game,
Card = card,
Date = date
};
purchasesToAdd.Add(purchase);
sb.AppendLine($"Imported {purchase.Game.Name} for {purchase.Card.User.Username}");
}
context.Purchases.AddRange(purchasesToAdd);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportUsers(VaporStoreDbContext context, string jsonString)
{
var sb = new StringBuilder();
var dtos = JsonConvert.DeserializeObject <ImportUserDto[]>(jsonString);
var users = new List <User>();
foreach (var dto in dtos)
{
if (!IsValid(dto) || !dto.Cards.All(IsValid))
{
sb.AppendLine("Invalid Data");
continue;
}
foreach (var card in dto.Cards)
{
var cardType = Enum.TryParse <CardType>(card.Type, out CardType result);
if (!cardType)
{
sb.AppendLine("Invalid Data");
break;
}
}
var user = new User
{
FullName = dto.FullName,
Username = dto.Username,
Email = dto.Email,
Age = dto.Age
};
foreach (var card in dto.Cards)
{
user.Cards.Add(new Card
{
Number = card.Number,
Cvc = card.Cvc,
Type = Enum.Parse <CardType>(card.Type)
});
}
sb.AppendLine($"Imported {user.Username} with {user.Cards.Count} cards");
users.Add(user);
}
context.AddRange(users);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ExportUserPurchasesByType(VaporStoreDbContext context, string storeType)
{
var type = Enum.Parse <PurchaseType>(storeType);
var user = context.Users
.Select(u => new ExportUserDto
{
Username = u.Username,
Purchases = u.Cards
.SelectMany(x => x.Purchases)
.Where(j => j.Type == type)
.Select(c => new PurcheseDto
{
Card = c.Card.Number,
Cvc = c.Card.Cvc,
Date = c.Date.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture),
Game = new GameDto
{
Genre = c.Game.Genre.Name,
Title = c.Game.Name,
Price = c.Game.Price
}
})
.OrderBy(g => g.Date)
.ToArray(),
TotalSpent = u.Cards.SelectMany(h => h.Purchases)
.Where(l => l.Type == type)
.Sum(i => i.Game.Price)
})
.Where(d => d.Purchases.Any())
.OrderByDescending(j => j.TotalSpent)
.ThenBy(k => k.Username)
.ToArray();
var xml = new XmlSerializer(typeof(ExportUserDto[]), new XmlRootAttribute("Users"));
var sb = new StringBuilder();
var ns = new XmlSerializerNamespaces();
ns.Add(string.Empty, string.Empty);
using (var writer = new StringWriter(sb))
{
xml.Serialize(writer, user, ns);
}
return(sb.ToString().TrimEnd());
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
var converter = new XmlSerializer(typeof(PurchaseImportModel[]), new XmlRootAttribute("Purchases"));
var purchasesDTOs = converter.Deserialize(new StringReader(xmlString)) as PurchaseImportModel[];
StringBuilder result = new StringBuilder();
foreach (var purchaseDTO in purchasesDTOs)
{
if (!IsValid(purchaseDTO))
{
result.Append(ErrorMessage);
continue;
}
var game = context.Games.Where(x => x.Name == purchaseDTO.GameName).FirstOrDefault();
var card = context.Cards.Where(x => x.Number == purchaseDTO.CardNumber).FirstOrDefault();
DateTime.TryParseExact(purchaseDTO.Date,
"dd/MM/yyyy HH:mm",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime puchaseDate);
if (game == null || card == null || puchaseDate == null)
{
result.Append(ErrorMessage);
continue;
}
Purchase purchase = new Purchase
{
Type = Enum.Parse <PurchaseType>(purchaseDTO.Type),
ProductKey = purchaseDTO.ProductKey,
Date = puchaseDate,
Game = game,
Card = card,
};
context.Purchases.Add(purchase);
result.Append(string.Format(SuccessfullyAddedPurchaseMessage,
purchaseDTO.GameName,
card.User.Username));
}
context.SaveChanges();
return(result.ToString());
}
public static string ExportUserPurchasesByType(VaporStoreDbContext context, string storeType)
{
var storeTypeValue = Enum.Parse <PurchaseType>(storeType);
var purchase = context
.Users
.Select(u => new UserDto
{
Username = u.Username,
Purchases = u.Cards
.SelectMany(s => s.Purchases)
.Where(a => a.Type == storeTypeValue)
.Select(p => new PurchaseDtos
{
Card = p.Card.Number,
Cvc = p.Card.Cvc,
Date = p.Date.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture),
Game = new PurchaseGameDtos
{
Title = p.Game.Name,
Genre = p.Game.Genre.Name,
Price = p.Game.Price
}
})
.OrderBy(uu => uu.Date)
.ToArray(),
TotalSpent = u.Cards
.SelectMany(y => y.Purchases)
.Where(q => q.Type == storeTypeValue)
.Sum(d => d.Game.Price)
})
.Where(p => p.Purchases.Any())
.OrderByDescending(ts => ts.TotalSpent)
.ThenBy(un => un.Username)
.ToArray();
XmlSerializer xmlSerializer = new XmlSerializer(typeof(UserDto[]), new XmlRootAttribute("Users"));
var sb = new StringBuilder();
var namespaces = new XmlSerializerNamespaces(new[]
{
new XmlQualifiedName("", ""),
});
xmlSerializer.Serialize(new StringWriter(sb), purchase, namespaces);
return(sb.ToString().TrimEnd());
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
var output = new StringBuilder();
var xmlSerializer = new XmlSerializer(typeof(PurchaseXmlInputModel[]),
new XmlRootAttribute("Purchases"));
var purchases = (PurchaseXmlInputModel[])xmlSerializer.Deserialize(new StringReader(xmlString));
foreach (var xmlPurchase in purchases)
{
if (!IsValid(xmlPurchase))
{
output.AppendLine("Invalid Data");
continue;
}
// проверка дали е парснало датата
bool parsedDate = DateTime.TryParseExact(xmlPurchase.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out var date);
if (!parsedDate)
{
output.AppendLine("Invalid Data");
continue;
}
var purchase = new Purchase // за card и Game бъркаме в базата да ги вземем !!!
{
Date = date,
Type = xmlPurchase.Type.Value,
ProductKey = xmlPurchase.Key,
Card = context.Cards.FirstOrDefault(x => x.Number == xmlPurchase.Card),
Game = context.Games.FirstOrDefault(x => x.Name == xmlPurchase.GameName)
};
context.Purchases.Add(purchase);
// взимаме юзъра, който си е купил играта
var username = context.Users.Where(x => x.Id == purchase.Card.UserId).Select(x => x.Username).FirstOrDefault();
output.AppendLine($"Imported {xmlPurchase.GameName} for {username}");
}
context.SaveChanges();
return(output.ToString().TrimEnd());
}
public static string ImportUsers(VaporStoreDbContext context, string jsonString)
{
var usersDto = JsonConvert.DeserializeObject <ImportUsersDto[]>(jsonString);
var users = new List <User>();
var cards = new List <Card>();
var sb = new StringBuilder();
foreach (var userDto in usersDto)
{
bool isValidTypes = userDto.CardsDto.Any(dto => Enum.IsDefined(typeof(CardType), dto.Type));
if (!IsValid(userDto) || userDto.CardsDto.Count < 1 || !userDto.CardsDto.All(IsValid) || !isValidTypes)
{
sb.AppendLine(ErrorMessage);
continue;
}
User user = new User()
{
Username = userDto.Username,
FullName = userDto.FullName,
Email = userDto.Email,
Age = userDto.Age
};
foreach (var cardDto in userDto.CardsDto)
{
var card = new Card
{
Number = cardDto.Number,
Cvc = cardDto.Cvc,
Type = Enum.Parse <CardType>(cardDto.Type),
User = user
};
users.Add(user);
cards.Add(card);
}
sb.AppendLine(String.Format(CultureInfo.InvariantCulture, SuccessfullyImportedUserWithCards, user.Username, userDto.CardsDto.Count));
}
context?.Users.AddRange(users);
context?.Cards.AddRange(cards);
context?.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportUsers(VaporStoreDbContext context, string jsonString)
{
var output = new StringBuilder();
var usersJson = JsonConvert.DeserializeObject <IEnumerable <ImportUserJsonModel> >(jsonString);
foreach (var userJson in usersJson)
{
if (!IsValid(userJson))
{
output.AppendLine("Invalid Data");
continue;
}
var user = new User
{
FullName = userJson.FullName,
Username = userJson.Username,
Email = userJson.Email,
Age = userJson.Age
};
foreach (var cardJson in userJson.Cards)
{
if (!IsValid(cardJson))
{
output.AppendLine("Invalid Data");
continue;
}
user.Cards.Add(new Card
{
Number = cardJson.Number,
Cvc = cardJson.CVC,
Type = cardJson.Type
});
}
if (user.Cards.Any())
{
context.Users.Add(user);
context.SaveChanges();
output.AppendLine($"Imported {user.Username} with {user.Cards.Count()} cards");
}
}
return(output.ToString());
}
public static string ImportPurchases(VaporStoreDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(ImportPurchaseDto[]), new XmlRootAttribute("Purchases"));
var purchasesDto = (ImportPurchaseDto[])xmlSerializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
var purchases = new List <Purchase>();
foreach (var purchaseDto in purchasesDto)
{
var validTypeEnum = Enum.TryParse <PurchaseType>(purchaseDto.Type, out PurchaseType purchaseType);
if (!IsValid(purchaseDto) ||
!validTypeEnum)
{
sb.AppendLine("Invalid Data");
continue;
}
var game = context.Games.FirstOrDefault(g => g.Name == purchaseDto.Title);
var card = context.Cards.FirstOrDefault(c => c.Number == purchaseDto.Card);
if (game == null ||
card == null)
{
sb.AppendLine("Invalid Data");
continue;
}
var purchase = new Purchase
{
Game = game,
Type = Enum.Parse <PurchaseType>(purchaseDto.Type),
ProductKey = purchaseDto.Key,
Card = card,
Date = DateTime.ParseExact(purchaseDto.Date, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)
};
purchases.Add(purchase);
purchases.Add(purchase);
sb.AppendLine($"Imported {purchase.Game.Name} for {purchase.Card.User.Username}");
}
context.Purchases.AddRange(purchases);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
