public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var theatres = context.Theatres
.ToArray()
.Where(t => t.NumberOfHalls >= numbersOfHalls && t.Tickets.Count >= 20)
.Select(t => new
{
Name = t.Name,
Halls = t.NumberOfHalls,
TotalIncome = t.Tickets
.Where(r => r.RowNumber >= 1 && r.RowNumber <= 5)
.Sum(p => p.Price),
Tickets = t.Tickets
.Where(r => r.RowNumber >= 1 && r.RowNumber <= 5)
.Select(i => new
{
Price = Math.Round(i.Price, 2),
RowNumber = i.RowNumber
})
.OrderByDescending(i => i.Price)
.ToArray()
})
.OrderByDescending(t => t.Halls)
.ThenBy(t => t.Name)
.ToArray();
return(JsonConvert.SerializeObject(theatres, Formatting.Indented));
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var topTheaters = context.Theatres
.ToArray()
.Where(x => x.NumberOfHalls >= numbersOfHalls && x.Tickets.Count >= 20)
.Select(x => new
{
Name = x.Name,
Halls = x.NumberOfHalls,
TotalIncome = x.Tickets.Where(y => y.RowNumber >= 1 && y.RowNumber <= 5).Sum(x => x.Price),
Tickets = x.Tickets.Where(p => p.RowNumber >= 1 && p.RowNumber <= 5).Select(s => new
{
Price = s.Price,
RowNumber = s.RowNumber,
})
.OrderByDescending(x => x.Price)
.ToList()
})
.OrderByDescending(x => x.Halls)
.ThenBy(x => x.Name)
.ToList();
var serialized = JsonConvert.SerializeObject(topTheaters, Formatting.Indented);
return(serialized);
}
public async Task ValidTheatre()
{
//Arrange
var options = Utilities.GetOptions(nameof(ValidTheatre));
var testTheatre = new Theatre()
{
Id = Guid.NewGuid(),
Name = "TestName",
AboutInfo = "TestAboutInfo",
Location = "TestLocation",
Phone = "0896663554",
};
using (var assertContext = new TheatreContext(options))
{
var sut = new TheatreService(assertContext);
var result = await sut.CreateTheatreAsync(testTheatre);
Assert.IsInstanceOfType(result, typeof(Theatre));
Assert.AreEqual(testTheatre.Name, result.Name);
Assert.AreEqual(testTheatre.AboutInfo, result.AboutInfo);
Assert.AreEqual(testTheatre.Location, result.Location);
Assert.AreEqual(testTheatre.Phone, result.Phone);
}
}
public async Task CreateInstanceOfBan()
{
var options = Utilities.GetOptions(nameof(CreateInstanceOfBan));
var testGuid = Guid.NewGuid();
var user = new User {
Id = testGuid, UserName = "******"
};
using (var actContext = new TheatreContext(options))
{
var sut = new BanServices(actContext);
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
await sut.CreateBanAsync(testGuid, "ImproperLanguage", 31);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TheatreContext(options))
{
var ban = assertContext.Bans.FirstOrDefault(x => x.User == user);
Assert.IsInstanceOfType(ban, typeof(Ban));
};
}
private static void ResetDatabase(TheatreContext context, bool shouldDropDatabase = false)
{
if (shouldDropDatabase)
{
context.Database.EnsureDeleted();
}
if (context.Database.EnsureCreated())
{
return;
}
var disableIntegrityChecksQuery = "EXEC sp_MSforeachtable @command1='ALTER TABLE ? NOCHECK CONSTRAINT ALL'";
context.Database.ExecuteSqlCommand(disableIntegrityChecksQuery);
var deleteRowsQuery = "EXEC sp_MSforeachtable @command1='SET QUOTED_IDENTIFIER ON;DELETE FROM ?'";
context.Database.ExecuteSqlCommand(deleteRowsQuery);
var enableIntegrityChecksQuery =
"EXEC sp_MSforeachtable @command1='ALTER TABLE ? WITH CHECK CHECK CONSTRAINT ALL'";
context.Database.ExecuteSqlCommand(enableIntegrityChecksQuery);
var reseedQuery =
"EXEC sp_MSforeachtable @command1='IF OBJECT_ID(''?'') IN (SELECT OBJECT_ID FROM SYS.IDENTITY_COLUMNS) DBCC CHECKIDENT(''?'', RESEED, 0)'";
context.Database.ExecuteSqlCommand(reseedQuery);
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var theatres = context
.Theatres
.ToArray()
.Where(t => t.NumberOfHalls >= numbersOfHalls && t.Tickets.Count() >= 20)
.Select(t => new
{
Name = t.Name,
Halls = t.NumberOfHalls,
TotalIncome = decimal.Parse(t.Tickets
.Where(x => x.RowNumber >= 1 && x.RowNumber <= 5)
.Sum(t => t.Price).ToString("f2")),
Tickets = t.Tickets.Where(x => x.RowNumber >= 1 && x.RowNumber <= 5).Select(c => new
{
Price = decimal.Parse(c.Price.ToString("f2")),
RowNumber = c.RowNumber
})
.OrderByDescending(c => c.Price)
.ToArray()
})
.OrderByDescending(t => t.Halls)
.ThenBy(t => t.Name)
.ToArray();
var result = JsonConvert.SerializeObject(theatres, Formatting.Indented);
return(result.ToString().TrimEnd());
}
public async Task CreateValidReview()
{
//Arrange
var options = Utilities.GetOptions(nameof(CreateValidReview));
var idReview = Guid.NewGuid();
var idTheatre = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var review = new Review()
{
Id = idReview,
TheatreId = idTheatre,
ReviewText = "TestReviewText",
Rating = 2,
Author = "testAuthor",
CreatedOn = createdOn
};
//Assert
using (var assertContext = new TheatreContext(options))
{
var sut = new ReviewServices(assertContext);
var result = await sut.CreateReviewAsync(review);
Assert.IsInstanceOfType(result, typeof(Review));
Assert.AreEqual(idReview, result.Id);
Assert.AreEqual(idTheatre, result.TheatreId);
Assert.AreEqual(createdOn, result.CreatedOn);
Assert.AreEqual("TestReviewText", result.ReviewText);
Assert.AreEqual("testAuthor", result.Author);
}
}
public static string ImportTtheatersTickets(TheatreContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
var theatreModels = JsonConvert.DeserializeObject <IEnumerable <TheatreInputModel> >(jsonString);
HashSet <Theatre> validTheatres = new HashSet <Theatre>();
foreach (var theatreModel in theatreModels)
{
if (!IsValid(theatreModel))
{
sb.AppendLine(ErrorMessage);
continue;
}
Theatre theatre = new Theatre()
{
Name = theatreModel.Name,
NumberOfHalls = theatreModel.NumberOfHalls,
Director = theatreModel.Director,
};
HashSet <Ticket> validTickets = new HashSet <Ticket>();
foreach (var ticketModel in theatreModel.Tickets)
{
if (!IsValid(ticketModel))
{
sb.AppendLine(ErrorMessage);
continue;
}
/*if(!context.Plays.Any(p => p.Id == ticketModel.PlayId))
* {
* sb.AppendLine(ErrorMessage);
* continue;
* }*/
Ticket ticket = new Ticket()
{
Price = ticketModel.Price,
RowNumber = ticketModel.RowNumber,
PlayId = ticketModel.PlayId
};
validTickets.Add(ticket);
}
theatre.Tickets = validTickets;
//context.AddRange(validTickets);
//context.SaveChanges();
validTheatres.Add(theatre);
sb.AppendLine(String.Format(SuccessfulImportTheatre, theatre.Name, theatre.Tickets.Count));
}
context.AddRange(validTheatres);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportCasts(TheatreContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
List <Cast> casts = new List <Cast>();
var castDtos = XmlConverter.Deserializer <ImportCastDto>(xmlString, "Casts");
foreach (var castDto in castDtos)
{
if (!IsValid(castDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
Cast cast = new Cast
{
FullName = castDto.FullName,
IsMainCharacter = castDto.IsMainCharacter,
PhoneNumber = castDto.PhoneNumber,
PlayId = castDto.PlayId
};
casts.Add(cast);
sb.AppendLine(string.Format(SuccessfulImportActor, cast.FullName,
cast.IsMainCharacter ? "main" : "lesser"));
}
context.Casts.AddRange(casts);
context.SaveChanges();
return(sb.ToString());
}
public static string ExportPlays(TheatreContext context, double rating)
{
var plays = context.Plays
.Where(x => x.Rating <= rating)
.OrderBy(o => o.Title)
.ThenByDescending(o => o.Genre)
.Select(x => new ExportPlayDto
{
Title = x.Title,
Duration = x.Duration.ToString("c"),
Rating = x.Rating == 0 ? "Premier" : x.Rating.ToString(),
Genre = x.Genre.ToString(),
Actors = x.Casts
.Where(a => a.IsMainCharacter)
.Select(a => new ExportActorDto
{
FullName = a.FullName,
MainCharacter = $"Plays main character in '{a.Play.Title}'."
})
.OrderByDescending(o => o.FullName)
.ToArray()
})
.ToArray();
string xml = XmlConverter.Serialize(plays, "Plays");
return(xml);
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var theaters = context.Theatres
.ToArray()
.Where(t => t.NumberOfHalls >= numbersOfHalls && t.Tickets.Count >= 20)
.Select(t => new
{
Name = t.Name,
Halls = t.NumberOfHalls,
TotalIncome = t.Tickets.Where(t => t.RowNumber >= 1 && t.RowNumber <= 5).Sum(t => t.Price),
Tickets = t.Tickets
.ToArray()
.Where(t => t.RowNumber >= 1 && t.RowNumber <= 5)
.Select(tt => new
{
Price = tt.Price,
RowNumber = tt.RowNumber
})
.OrderByDescending(t => t.Price)
.ToArray()
})
.OrderByDescending(t => t.Halls)
.ThenBy(t => t.Name)
.ToArray();
string result = JsonConvert.SerializeObject(theaters, Formatting.Indented);
return(result);
}
public async Task ThrowWhen_BanIsNull()
{
//Arrange
var options = Utilities.GetOptions(nameof(CorrectlyDeleteBan));
var testGuid = Guid.NewGuid();
var userTest = new User
{
Id = testGuid,
UserName = "******",
IsBanned = true,
LockoutEnabled = true,
LockoutEnd = DateTime.UtcNow.AddDays(1)
};
using (var assertContext = new TheatreContext(options))
{
//Act & Assert
await assertContext.Users.AddAsync(userTest);
await assertContext.SaveChangesAsync();
var sut = new BanServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.RemoveBanAsync(testGuid));
}
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var theaters = context.Theatres.ToList()
.Where(x => x.NumberOfHalls >= numbersOfHalls && x.Tickets.Count >= 20)
.Select(x => new
{
Name = x.Name,
Halls = x.NumberOfHalls,
TotalIncome = x.Tickets
.Where(y => y.RowNumber >= 1 && y.RowNumber <= 5)
.Sum(y => y.Price),
Tickets = x.Tickets
.Where(y => y.RowNumber >= 1 && y.RowNumber <= 5)
.Select(y => new
{
Price = decimal.Parse(y.Price.ToString("F2", CultureInfo.InvariantCulture)),
RowNumber = y.RowNumber
})
.OrderByDescending(y => y.Price)
.ToList()
})
.OrderByDescending(x => x.Halls)
.ThenBy(x => x.Name)
.ToList();
return(JsonConvert.SerializeObject(theaters, Formatting.Indented));
}
public async Task ReturnCorrectTheatre()
{
var options = Utilities.GetOptions(nameof(DeleteTheatreTest));
var testTheatre02 = new Theatre()
{
Id = Guid.NewGuid(),
Name = "TestName",
AboutInfo = "TestAboutInfo",
Location = "TestLocation",
Phone = "0896663554",
};
using (var assertContext = new TheatreContext(options))
{
await assertContext.Theatres.AddAsync(testTheatre02);
await assertContext.SaveChangesAsync();
}
using (var assertContext = new TheatreContext(options))
{
var sut = new TheatreService(assertContext);
var result = await sut.DeleteTheatreAsync(testTheatre02.Id);
Assert.IsInstanceOfType(result, typeof(Theatre));
Assert.AreEqual(testTheatre02.Id, result.Id);
Assert.AreEqual(testTheatre02.Name, result.Name);
Assert.AreEqual(testTheatre02.AboutInfo, result.AboutInfo);
Assert.AreEqual(testTheatre02.Location, result.Location);
Assert.AreEqual(testTheatre02.Phone, result.Phone);
}
}
private void AddTestData(TheatreContext context)
{
context.Shows.Add(new Show()
{
ShowId = 1,
Name = "Hamlet vs. Hamlet"
});
context.Shows.Add(new Show()
{
ShowId = 2,
Name = "Branden"
});
context.TimeSlots.AddRange(new List <TimeSlot>()
{
new TimeSlot()
{
TimeSlotId = 1,
Start = Convert.ToDateTime("01-06-2018 20:00", CultureInfo.CurrentCulture),
End = Convert.ToDateTime("01-06-2018 22:00", CultureInfo.CurrentCulture),
ShowId = 1
},
new TimeSlot()
{
TimeSlotId = 2,
Start = Convert.ToDateTime("02-06-2018 20:00", CultureInfo.CurrentCulture),
End = Convert.ToDateTime("02-06-2018 22:00", CultureInfo.CurrentCulture),
ShowId = 1
},
new TimeSlot()
{
TimeSlotId = 3,
Start = Convert.ToDateTime("03-06-2018 14:00", CultureInfo.CurrentCulture),
End = Convert.ToDateTime("03-06-2018 16:00", CultureInfo.CurrentCulture),
ShowId = 1
},
new TimeSlot()
{
TimeSlotId = 4,
Start = Convert.ToDateTime("03-06-2018 20:00", CultureInfo.CurrentCulture),
End = Convert.ToDateTime("03-06-2018 22:00", CultureInfo.CurrentCulture),
ShowId = 1
},
new TimeSlot()
{
TimeSlotId = 5,
Start = Convert.ToDateTime("08-06-2018 20:00", CultureInfo.CurrentCulture),
End = Convert.ToDateTime("08-06-2018 22:00", CultureInfo.CurrentCulture),
ShowId = 2
},
new TimeSlot()
{
TimeSlotId = 6,
Start = Convert.ToDateTime("09-06-2018 20:00", CultureInfo.CurrentCulture),
End = Convert.ToDateTime("09-06-2018 22:00", CultureInfo.CurrentCulture),
ShowId = 2
}
});
context.SaveChanges();
}
public async Task DeleteTheatreTest()
{
//Arrange
var options = Utilities.GetOptions(nameof(DeleteTheatreTest));
var testTheatre00 = new Theatre()
{
Id = Guid.NewGuid(),
Name = "TestName",
AboutInfo = "TestAboutInfo",
Location = "TestLocation",
Phone = "0896663554",
};
using (var assertContext = new TheatreContext(options))
{
await assertContext.Theatres.AddAsync(testTheatre00);
await assertContext.SaveChangesAsync();
var serviceTest = new TheatreService(assertContext);
var result = await serviceTest.DeleteTheatreAsync(testTheatre00.Id);
await assertContext.SaveChangesAsync();
}
using (var assertContext = new TheatreContext(options))
{
var result = await assertContext.Theatres.FirstAsync();
Assert.AreEqual(true, result.IsDeleted);
}
}
public static string ExportPlays(TheatreContext context, double rating)
{
var plays = context
.Plays
.Where(p => p.Rating <= rating)
.Select(p => new ExportPlaysDto()
{
Title = p.Title,
Duration = p.Duration.ToString("c"),
Rating = p.Rating == 0.00 ? "Premier" : p.Rating.ToString(),
Genre = p.Genre,
Actors = p.Casts
.Where(a => a.IsMainCharacter)
.Select(a => new ExportActorsDto()
{
FullName = a.FullName,
MainCharacter = $"Plays main character in '{a.Play.Title}'.",
})
.OrderByDescending(a => a.FullName)
.ToArray()
})
.OrderBy(p => p.Title)
.ThenByDescending(p => p.Genre)
.ToArray();
var result = XmlConverter.Serialize(plays, "Plays");
return(result);
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var topTheatres = context
.Theatres
.Where(t => t.NumberOfHalls >= numbersOfHalls && t.Tickets.Count >= 20)
.ToList()
.OrderByDescending(t => t.NumberOfHalls)
.ThenBy(t => t.Name)
.Select(t => new
{
Name = t.Name,
Halls = t.NumberOfHalls,
TotalIncome = t.Tickets.Where(t => t.RowNumber >= 1 && t.RowNumber <= 5).Sum(p => p.Price),
Tickets = t.Tickets
.OrderByDescending(tic => tic.Price)
.Where(t => t.RowNumber >= 1 && t.RowNumber <= 5)
.Select(tic => new
{
Price = Decimal.Parse(String.Format($"{tic.Price:0.00}")),
RowNumber = tic.RowNumber
})
.ToList()
})
.ToList();
var result = JsonConvert.SerializeObject(topTheatres, Formatting.Indented);
return(result);
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var topTheatres = context
.Theatres
.ToArray()
.Where(x => x.NumberOfHalls >= numbersOfHalls && x.Tickets.Count >= 20)
.Select(x => new
{
Name = x.Name,
Halls = x.NumberOfHalls,
TotalIncome = (x.Tickets.Where(y => y.RowNumber >= 1 && y.RowNumber <= 5).Sum(z => z.Price)),
Tickets = x.Tickets.Where(y => y.RowNumber >= 1 && y.RowNumber <= 5).Select(z => new
{
Price = z.Price,
RowNumber = z.RowNumber
}).OrderByDescending(t => t.Price).ToArray()
})
.OrderByDescending(x => x.Halls)
.ThenBy(x => x.Name)
.ToArray();
string json = JsonConvert.SerializeObject(topTheatres, Formatting.Indented);
return(json);
}
public static string ImportPlays(TheatreContext context, string xmlString)
{
var sb = new StringBuilder();
XmlRootAttribute root = new XmlRootAttribute("Plays");
XmlSerializer serializer = new XmlSerializer(typeof(PlayDto[]), root);
PlayDto[] plays;
using (StringReader sr = new StringReader(xmlString))
{
plays = (PlayDto[])serializer.Deserialize(sr);
}
foreach (var play in plays)
{
if (!IsValid(play))
{
sb.AppendLine("Invalid data!");
continue;
}
sb.AppendLine($"Successfully imported {play.Title} with genre {play.Genre} and a rating of {play.Rating}!");
}
return(sb.ToString());
}
public async Task ReturnCorrectType_BannedUsers()
{
//Arrange
var options = Utilities.GetOptions(nameof(ReturnCorrectType_BannedUsers));
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var users = new List <User>
{
new User {
Id = testGuid, UserName = "******", IsBanned = true
},
new User {
Id = testGuid2, UserName = "******", IsBanned = true
},
};
using (var actContext = new TheatreContext(options))
{
//Act & Assert
var sut = new BanServices(actContext);
await actContext.Users.AddAsync(users[0]);
await actContext.Users.AddAsync(users[1]);
await actContext.SaveChangesAsync();
var result = await sut.GetAllBannedUsersAsync("banned");
Assert.IsInstanceOfType(result, typeof(ICollection <User>));
}
}
public static string ImportCasts(TheatreContext context, string xmlString)
{
var sb = new StringBuilder();
XmlRootAttribute root = new XmlRootAttribute("Casts");
XmlSerializer serializer = new XmlSerializer(typeof(CastDto[]), root);
CastDto[] casts;
using (StringReader sr = new StringReader(xmlString))
{
casts = (CastDto[])serializer.Deserialize(sr);
}
foreach (var cast in casts)
{
if (!IsValid(cast))
{
sb.AppendLine("Invalid data!");
continue;
}
if (cast.IsMainCharacter == true)
{
sb.AppendLine($"Successfully imported actor {cast.FullName} as a main character!");
}
else if (cast.IsMainCharacter == false)
{
sb.AppendLine($"Successfully imported actor {cast.FullName} as a lesser character!");
}
}
return(sb.ToString());
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var theatres = context.Theatres.ToArray()
.Where(x => x.NumberOfHalls >= numbersOfHalls && x.Tickets.Count() >= 20)
.Select(x => new
{
Name = x.Name,
Halls = x.NumberOfHalls,
TotalIncome = x.Tickets
.Where(ti => ti.RowNumber >= 1 && ti.RowNumber <= 5)
.Sum(ti => ti.Price),
Tickets = x.Tickets
.Where(t => t.RowNumber >= 1 && t.RowNumber <= 5)
.Select(t => new
{
Price = t.Price,
RowNumber = t.RowNumber
})
.OrderByDescending(o => o.Price)
})
.OrderByDescending(o => o.Halls)
.ThenBy(o => o.Name);
string json = JsonConvert.SerializeObject(theatres, Formatting.Indented, new DecimalFormatConverter());
return(json);
}
public async Task CreateValidComment()
{
//Arrange
var options = Utilities.GetOptions(nameof(CreateValidComment));
var idComment = Guid.NewGuid();
var idUser = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var comment = new Comment()
{
Id = idComment,
UserId = idUser,
CommentText = "TestCommentText",
Author = "testAuthor",
CreatedOn = createdOn
};
//Assert
using (var assertContext = new TheatreContext(options))
{
var sut = new CommentServices(assertContext);
var result = await sut.CreateCommentAsync(comment);
Assert.IsInstanceOfType(result, typeof(Comment));
Assert.AreEqual(idComment, result.Id);
Assert.AreEqual(idUser, result.UserId);
Assert.AreEqual(createdOn, result.CreatedOn);
Assert.AreEqual("TestCommentText", result.CommentText);
Assert.AreEqual("testAuthor", result.Author);
}
}
public static string ExportPlays(TheatreContext context, double rating)
{
var plays = context
.Plays
.Where(x => x.Rating <= rating)
.ToList()
.Select(x => new PlayExportModel
{
Title = x.Title,
Duration = x.Duration.ToString("c", CultureInfo.InvariantCulture),
Rating = x.Rating == 0 ? "Premier" : x.Rating.ToString(),
Genre = x.Genre.ToString(),
Actors = x.Casts
.Where(x => x.IsMainCharacter)
.Select(a => new ActorExportModel()
{
FullName = a.FullName,
MainCharacter = $"Plays main character in '{x.Title}'."
})
.OrderByDescending(a => a.FullName)
.ToList()
})
.OrderBy(p => p.Title)
.ThenByDescending(p => p.Genre)
.ToList();
var xml = XMLConverter.Serialize(plays, "Plays");
return(xml);
}
public async Task SetCorrectParams()
{
//Arrange
var options = Utilities.GetOptions(nameof(SetCorrectParams));
var testGuid = Guid.NewGuid();
var user = new User {
Id = testGuid, UserName = "******"
};
using (var actContext = new TheatreContext(options))
{
//Act
var sut = new BanServices(actContext);
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
await sut.CreateBanAsync(testGuid, "Improper language", 31);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TheatreContext(options))
{
//Assert
var ban = assertContext.Bans.Include(b => b.User).FirstOrDefault(b => b.User.UserName == "Mariika");
Assert.AreEqual("Mariika", ban.User.UserName);
Assert.AreEqual("Improper language", ban.ReasonBanned);
}
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var theatres = context
.Theatres
.ToArray()
.Where(t => t.NumberOfHalls >= numbersOfHalls)
.Where(t => t.Tickets.Count >= 20)
.Select(t => new
{
Name = t.Name,
Halls = t.NumberOfHalls,
TotalIncome = t.Tickets
.Where(ticket => ticket.RowNumber >= 1 && ticket.RowNumber <= 5)
.Sum(ticket => ticket.Price),
Tickets = t.Tickets
.Where(ticket => ticket.RowNumber >= 1 && ticket.RowNumber <= 5)
.OrderByDescending(ticket => ticket.Price)
.Select(ticket => new
{
Price = decimal.Parse(ticket.Price.ToString("f2")),
RowNumber = ticket.RowNumber
})
})
.OrderByDescending(t => t.Halls)
.ThenBy(t => t.Name);
string theatresAsString = JsonConvert.SerializeObject(theatres, Formatting.Indented);
return(theatresAsString);
}
public static string ExportTheatres(TheatreContext context, int numbersOfHalls)
{
var result = context.Theatres
.ToArray()
.Where(t => t.NumberOfHalls >= numbersOfHalls && t.Tickets.Count >= 20)
.Select(x => new
{
Name = x.Name,
Halls = x.NumberOfHalls,
TotalIncome = x.Tickets.Where(ti => ti.RowNumber >= 1 && ti.RowNumber <= 5).Sum(ti => ti.Price),
Tickets = x.Tickets
.Where(ti => ti.RowNumber >= 1 && ti.RowNumber <= 5)
.Select(y => new
{
Price = y.Price,
RowNumber = y.RowNumber // could be different
})
.OrderByDescending(y => y.Price)
.ToArray()
})
.OrderByDescending(x => x.Halls)
.ThenBy(x => x.Name)
.ToArray();
string json = JsonConvert.SerializeObject(result, Formatting.Indented);
return(json);
}
public async Task ThorwWhenNoTheatreFound()
{
var options = Utilities.GetOptions(nameof(ReturnCorrectTheatre));
var secondId = Guid.NewGuid();
var testTheatre05 = new Theatre()
{
Id = Guid.NewGuid(),
Name = "TestName",
AboutInfo = "TestAboutInfo",
Location = "TestLocation",
Phone = "0896663554",
};
using (var assertContext = new TheatreContext(options))
{
await assertContext.Theatres.AddAsync(testTheatre05);
await assertContext.SaveChangesAsync();
}
using (var assertContext = new TheatreContext(options))
{
var sut = new TheatreService(assertContext);
await Assert.ThrowsExceptionAsync <Exception>(() => sut.GetTheatreAsync(secondId));
}
}
public static TheatreContext InitializeContextInMemoryDb()
{
var builder = new DbContextOptionsBuilder <TheatreContext>()
.UseInMemoryDatabase(new Guid().ToString());
var context = new TheatreContext(builder.Options);
return(context);
}
