public async Task ReduceVisibility_OtherUserHasView_NoUserHasInDeck_OnlyAuthor()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var otherUser = await UserHelper.CreateInDbAsync(db);
var card = await CardHelper.CreateAsync(db, cardCreator, language : languageId, userWithViewIds : new[] { cardCreator, otherUser });
using (var dbContext = new MemCheckDbContext(db))
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, card.Id);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, otherUser, card.Id);
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, cardCreator.AsArray());
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
using (var dbContext = new MemCheckDbContext(db))
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, card.Id);
Assert.ThrowsException <InvalidOperationException>(() => CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, otherUser, card.Id));
}
}
public async Task CheckValidityAsync(CallContext context)
{
QueryValidationHelper.CheckNotReservedGuid(CurrentUserId);
QueryValidationHelper.CheckNotReservedGuid(CardId);
await QueryValidationHelper.CheckCardExistsAsync(context.DbContext, CardId);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(context.DbContext, CurrentUserId, CardId);
}
public async Task ReduceVisibility_OtherUserHasInDeck_OtherAuthor()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, cardCreator, language : languageId, userWithViewIds : Array.Empty <Guid>());
var userWithCardInDeck = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, userWithCardInDeck);
await DeckHelper.AddCardAsync(db, deck, card.Id, 0);
var otherUser = await UserHelper.CreateInDbAsync(db);
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForFrontSideChange(card, RandomHelper.String(), otherUser);
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, cardCreator.AsArray());
await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateCard(dbContext.AsCallContext()).RunAsync(r));
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, otherUser.AsArray(), otherUser);
await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateCard(dbContext.AsCallContext()).RunAsync(r));
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, new[] { userWithCardInDeck }, userWithCardInDeck);
await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateCard(dbContext.AsCallContext()).RunAsync(r));
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, new[] { cardCreator, otherUser, userWithCardInDeck });
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
using (var dbContext = new MemCheckDbContext(db))
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, card.Id);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, otherUser, card.Id);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, userWithCardInDeck, card.Id);
}
}
public async Task CheckValidityAsync(CallContext callContext)
{
if (QueryValidationHelper.IsReservedGuid(UserId))
{
throw new InvalidOperationException("Invalid user ID");
}
await QueryValidationHelper.CheckUserIsOwnerOfDeckAsync(callContext.DbContext, UserId, DeckId);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(callContext.DbContext, UserId, CardIds);
}
public async Task CheckValidityAsync(CallContext callContext)
{
QueryValidationHelper.CheckNotReservedGuid(UserId);
if (CardIds.Any(cardId => QueryValidationHelper.IsReservedGuid(cardId)))
{
throw new RequestInputException($"Invalid card id");
}
foreach (var cardId in CardIds)
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(callContext.DbContext, UserId, cardId);
}
await Task.CompletedTask;
}
public async Task CheckValidityAsync(CallContext callContext)
{
await QueryValidationHelper.CheckUserExistsAsync(callContext.DbContext, UserId);
if (CardIds.Any(cardId => QueryValidationHelper.IsReservedGuid(cardId)))
{
throw new RequestInputException($"Invalid card id");
}
CardVisibilityHelper.CheckUserIsAllowedToViewCards(callContext.DbContext, UserId, CardIds.ToArray());
foreach (var cardId in CardIds)
{
await CheckUsersWithCardInADeckAsync(cardId, callContext.DbContext, callContext.Localized);
await CheckCardVersionsCreatorsAsync(cardId, callContext.DbContext, callContext.Localized);
}
}
public async Task ReduceVisibility_NoUserHasInDeck_OtherAuthor()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreatorName = RandomHelper.String();
var cardCreator = await UserHelper.CreateInDbAsync(db, userName : cardCreatorName);
var languageId = await CardLanguagHelper.CreateAsync(db);
var card = await CardHelper.CreateAsync(db, cardCreator, language : languageId, userWithViewIds : Array.Empty <Guid>());
var newVersionCreatorName = RandomHelper.String();
var newVersionCreator = await UserHelper.CreateInDbAsync(db, userName : newVersionCreatorName);
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForFrontSideChange(card, RandomHelper.String(), newVersionCreator);
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, cardCreator.AsArray(), cardCreator);
var e = await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateCard(dbContext.AsCallContext()).RunAsync(r));
Assert.IsTrue(e.Message.Contains(newVersionCreatorName));
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, new[] { newVersionCreator }, newVersionCreator);
var e = await Assert.ThrowsExceptionAsync <RequestInputException>(async() => await new UpdateCard(dbContext.AsCallContext()).RunAsync(r));
Assert.IsTrue(e.Message.Contains(cardCreatorName));
}
using (var dbContext = new MemCheckDbContext(db))
{
var r = UpdateCardHelper.RequestForVisibilityChange(card, new[] { cardCreator, newVersionCreator });
await new UpdateCard(dbContext.AsCallContext()).RunAsync(r);
}
using (var dbContext = new MemCheckDbContext(db))
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, card.Id);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, newVersionCreator, card.Id);
}
}
public async Task CheckValidityAsync(CallContext callContext)
{
if (!CardIds.Any())
{
throw new RequestInputException("No card to add label to");
}
if (QueryValidationHelper.IsReservedGuid(VersionCreator.Id))
{
throw new RequestInputException("Invalid user id");
}
if (QueryValidationHelper.IsReservedGuid(TagId))
{
throw new RequestInputException("Reserved tag id");
}
foreach (var cardId in CardIds)
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(callContext.DbContext, VersionCreator.Id, cardId);
}
if (!await callContext.DbContext.Tags.Where(tag => tag.Id == TagId).AnyAsync())
{
throw new RequestInputException("Invalid tag id");
}
}
public async Task UpdateAllFields()
{
var db = DbHelper.GetEmptyTestDB();
var cardCreator = await UserHelper.CreateInDbAsync(db);
var languageId = await CardLanguagHelper.CreateAsync(db);
var originalCard = await CardHelper.CreateAsync(db, cardCreator, language : languageId, userWithViewIds : Array.Empty <Guid>());
var newVersionCreator = await UserHelper.CreateInDbAsync(db);
var frontSide = RandomHelper.String();
var backSide = RandomHelper.String();
var additionalInfo = RandomHelper.String();
var versionDescription = RandomHelper.String();
var newLanguageId = await CardLanguagHelper.CreateAsync(db);
var imageOnFrontSideId = await ImageHelper.CreateAsync(db, cardCreator);
var imageOnBackSide1Id = await ImageHelper.CreateAsync(db, cardCreator);
var imageOnBackSide2Id = await ImageHelper.CreateAsync(db, cardCreator);
var imageOnAdditionalInfoId = await ImageHelper.CreateAsync(db, cardCreator);
var tagId = await TagHelper.CreateAsync(db);
using (var dbContext = new MemCheckDbContext(db))
{
var request = new UpdateCard.Request(
originalCard.Id,
newVersionCreator,
frontSide,
new Guid[] { imageOnFrontSideId },
backSide,
new Guid[] { imageOnBackSide1Id, imageOnBackSide2Id },
additionalInfo,
new Guid[] { imageOnAdditionalInfoId },
languageId,
new Guid[] { tagId },
new Guid[] { cardCreator, newVersionCreator },
versionDescription);
await new UpdateCard(dbContext.AsCallContext()).RunAsync(request);
}
using (var dbContext = new MemCheckDbContext(db))
{
var updatedCard = dbContext.Cards
.Include(c => c.VersionCreator)
.Include(c => c.CardLanguage)
.Include(c => c.UsersWithView)
.Include(c => c.Images)
.Include(c => c.TagsInCards)
.Single(c => c.Id == originalCard.Id);
Assert.AreEqual(newVersionCreator, updatedCard.VersionCreator.Id);
Assert.AreEqual(frontSide, updatedCard.FrontSide);
Assert.AreEqual(backSide, updatedCard.BackSide);
Assert.AreEqual(additionalInfo, updatedCard.AdditionalInfo);
Assert.AreEqual(versionDescription, updatedCard.VersionDescription);
Assert.AreEqual(languageId, updatedCard.CardLanguage.Id);
Assert.AreEqual(ImageInCard.FrontSide, updatedCard.Images.Single(i => i.ImageId == imageOnFrontSideId).CardSide);
Assert.AreEqual(ImageInCard.BackSide, updatedCard.Images.Single(i => i.ImageId == imageOnBackSide1Id).CardSide);
Assert.AreEqual(ImageInCard.BackSide, updatedCard.Images.Single(i => i.ImageId == imageOnBackSide2Id).CardSide);
Assert.AreEqual(ImageInCard.AdditionalInfo, updatedCard.Images.Single(i => i.ImageId == imageOnAdditionalInfoId).CardSide);
Assert.IsTrue(updatedCard.TagsInCards.Any(t => t.TagId == tagId));
}
using (var dbContext = new MemCheckDbContext(db))
{
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, cardCreator, originalCard.Id);
CardVisibilityHelper.CheckUserIsAllowedToViewCards(dbContext, newVersionCreator, originalCard.Id);
}
}
