public async Task TestOtherUserCreatesVersion()
{
var testDB = DbHelper.GetEmptyTestDB();
var ownerId = await UserHelper.CreateInDbAsync(testDB);
var card = await CardHelper.CreateAsync(testDB, ownerId);
var newVersionCreatorId = await UserHelper.CreateInDbAsync(testDB, subscribeToCardOnEdit : true);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new PreviousVersionCreator(dbContext);
await request.RunAsync(card.Id, newVersionCreatorId, RandomHelper.String());
await dbContext.SaveChangesAsync();
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var previousVersion = await dbContext.CardPreviousVersions.Where(previous => previous.Card == card.Id).SingleAsync();
Assert.AreNotEqual(card.Id, previousVersion.Id);
}
Assert.IsTrue(await CardSubscriptionHelper.UserIsSubscribedToCardAsync(testDB, newVersionCreatorId, card.Id));
}
async public Task RunAsync(MemCheckDbContext dbContext)
{
var user = dbContext.Users.Where(user => user.UserName == "Toto1").Single();
var images = dbContext.Images.Where(image => image.Owner == null);
logger.LogInformation($"Found {images.Count()} images to modify");
foreach (var image in images)
{
logger.LogDebug($"Changing image '{image.Name}'");
image.Owner = user;
}
var imagePreviousVersions = dbContext.ImagePreviousVersions.Where(image => image.Owner == null);
logger.LogInformation($"Found {imagePreviousVersions.Count()} imagePreviousVersions to modify");
foreach (var imagePreviousVersion in imagePreviousVersions)
{
logger.LogDebug($"Changing imagePreviousVersion '{imagePreviousVersion.Name}'");
imagePreviousVersion.Owner = user;
}
var cards = dbContext.Cards.Where(card => card.VersionCreator == null);
logger.LogInformation($"Found {cards.Count()} cards to modify");
foreach (var card in cards)
{
logger.LogDebug($"Changing card with front side {card.FrontSide}");
card.VersionCreator = user;
}
await dbContext.SaveChangesAsync();
logger.LogInformation($"Finished");
}
public async Task CardWithoutPreviousVersion_ToBeNotified()
{
var testDB = DbServices.GetEmptyTestDB(typeof(UserCardVersionsNotifierTests));
var user = await CreateUserAsync(testDB);
var card = await CreateCardAsync(testDB, user.Id, new DateTime(2020, 11, 2));
await CreateCardNotificationAsync(testDB, user.Id, card.Id, new DateTime(2020, 11, 1));
using (var dbContext = new MemCheckDbContext(testDB))
{
var notifier = new UserCardVersionsNotifier(dbContext);
var versions = notifier.Run(user);
Assert.AreEqual(1, versions.Length);
Assert.AreEqual(card.Id, versions[0].CardId);
Assert.IsTrue(versions[0].CardIsViewable);
Assert.AreEqual(card.FrontSide, versions[0].FrontSide);
Assert.AreEqual(card.VersionDescription, versions[0].VersionDescription);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user.Id);
Assert.IsTrue(notif.LastNotificationUtcDate > new DateTime(2020, 11, 1));
}
}
public async Task CardWitPreviousVersions_ToBeNotified_LastNotifBeforePreviousVersionCreation()
{
var testDB = DbServices.GetEmptyTestDB(typeof(UserCardVersionsNotifierTests));
var user1 = await CreateUserAsync(testDB);
var card = await CreateCardAsync(testDB, user1.Id, new DateTime(2020, 11, 5));
var user2 = await CreateUserAsync(testDB);
var previousVersion1 = await CreateCardPreviousVersionAsync(testDB, user2.Id, card.Id, new DateTime(2020, 11, 3));
await CreatePreviousVersionPreviousVersionAsync(testDB, user2.Id, previousVersion1, new DateTime(2020, 11, 1));
await CreateCardNotificationAsync(testDB, user1.Id, card.Id, new DateTime(2020, 11, 2));
var now = new DateTime(2020, 11, 5);
using (var dbContext = new MemCheckDbContext(testDB))
{
var notifier = new UserCardVersionsNotifier(dbContext);
var versions = notifier.Run(user1, now);
Assert.AreEqual(1, versions.Length);
Assert.AreEqual(card.Id, versions[0].CardId);
Assert.IsTrue(versions[0].CardIsViewable);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user1.Id);
Assert.AreEqual(now, notif.LastNotificationUtcDate);
}
}
public static async Task <Guid> CreateAsync(DbContextOptions <MemCheckDbContext> testDB, Guid creatorId, string?name = null, string?versionDescription = null, DateTime?lastChangeUtcDate = null, string?source = null, string?description = null)
{
using var dbContext = new MemCheckDbContext(testDB);
var creator = await dbContext.Users.SingleAsync(u => u.Id == creatorId);
var originalBlob = new[] { (byte)0, (byte)0, (byte)0, (byte)0 };
var smallBlob = new[] { (byte)0 };
var mediumBlob = new[] { (byte)0, (byte)0 };
var bigBlob = new[] { (byte)0, (byte)0, (byte)0 };
var result = new Image
{
Owner = creator,
Name = name ?? RandomHelper.String(),
Description = description ?? RandomHelper.String(),
Source = source ?? RandomHelper.String(),
InitialUploadUtcDate = lastChangeUtcDate ?? DateTime.UtcNow,
LastChangeUtcDate = lastChangeUtcDate ?? DateTime.UtcNow,
VersionDescription = versionDescription ?? RandomHelper.String(),
VersionType = ImageVersionType.Creation,
OriginalContentType = "InvalidForUnitTests",
OriginalSize = originalBlob.Length,
OriginalBlob = originalBlob,
SmallBlobSize = smallBlob.Length,
SmallBlob = smallBlob,
MediumBlobSize = mediumBlob.Length,
MediumBlob = mediumBlob,
BigBlobSize = bigBlob.Length,
BigBlob = bigBlob
};
dbContext.Images.Add(result);
await dbContext.SaveChangesAsync();
return(result.Id);
}
public static async Task AddCardAsync(DbContextOptions <MemCheckDbContext> testDB, Guid deck, Guid card, int?heap = null, DateTime?lastLearnUtcTime = null, DateTime?addToDeckUtcTime = null)
{
heap ??= RandomHelper.Heap();
lastLearnUtcTime ??= RandomHelper.Date();
using var dbContext = new MemCheckDbContext(testDB);
DateTime expiryTime;
if (heap.Value != CardInDeck.UnknownHeap)
{
var heapingAlgo = await HeapingAlgorithm.OfDeckAsync(dbContext, deck);
expiryTime = heapingAlgo.ExpiryUtcDate(heap.Value, lastLearnUtcTime.Value);
}
else
{
expiryTime = DateTime.MinValue;
}
var cardForUser = new CardInDeck()
{
CardId = card,
DeckId = deck,
CurrentHeap = heap.Value,
LastLearnUtcTime = lastLearnUtcTime.Value,
ExpiryUtcTime = expiryTime,
AddToDeckUtcTime = addToDeckUtcTime ?? DateTime.UtcNow,
NbTimesInNotLearnedHeap = 1,
BiggestHeapReached = heap.Value
};
dbContext.CardsInDecks.Add(cardForUser);
await dbContext.SaveChangesAsync();
}
private async Task <CardPreviousVersion> CreateCardPreviousVersionAsync(DbContextOptions <MemCheckDbContext> testDB, Guid versionCreatorId, Guid cardId, DateTime versionDate)
{
using var dbContext = new MemCheckDbContext(testDB);
var creator = await dbContext.Users.Where(u => u.Id == versionCreatorId).SingleAsync();
var result = new CardPreviousVersion();
result.Card = cardId;
result.VersionCreator = creator;
result.VersionUtcDate = versionDate;
result.VersionType = CardPreviousVersionType.Creation;
result.FrontSide = StringServices.RandomString();
result.BackSide = StringServices.RandomString();
result.AdditionalInfo = StringServices.RandomString();
result.VersionDescription = StringServices.RandomString();
dbContext.CardPreviousVersions.Add(result);
var card = await dbContext.Cards.Where(c => c.Id == cardId).SingleAsync();
card.PreviousVersion = result;
card.VersionType = CardVersionType.Changes;
await dbContext.SaveChangesAsync();
return(result);
}
private static async Task <CardPreviousVersion> CreatePreviousVersionPreviousVersionAsync(DbContextOptions <MemCheckDbContext> testDB, Guid versionCreatorId, CardPreviousVersion previousVersion, DateTime versionDate)
{
using var dbContext = new MemCheckDbContext(testDB);
var creator = await dbContext.Users.Where(u => u.Id == versionCreatorId).SingleAsync();
var cardLanguage = await dbContext.CardLanguages.SingleAsync(cardLanguage => cardLanguage.Id == previousVersion.CardLanguage.Id);
var result = new CardPreviousVersion
{
Card = previousVersion.Card,
CardLanguage = cardLanguage,
VersionCreator = creator,
VersionUtcDate = versionDate,
VersionType = CardPreviousVersionType.Creation,
FrontSide = RandomHelper.String(),
BackSide = RandomHelper.String(),
AdditionalInfo = RandomHelper.String(),
VersionDescription = RandomHelper.String()
};
dbContext.CardPreviousVersions.Add(result);
previousVersion.PreviousVersion = result;
previousVersion.VersionType = CardPreviousVersionType.Changes;
await dbContext.SaveChangesAsync();
return(result);
}
async public Task RunAsync()
{
var user = dbContext.Users.Where(user => user.UserName == "Voltan").Single().Id;
var deck = dbContext.Decks.Where(deck => deck.Owner.Id == user).First().Id;
var algo = await HeapingAlgorithm.OfDeckAsync(dbContext, deck);
logger.LogInformation($"Algo: {algo.GetType().Name}, id: {algo.Id}");
var allCardsNotUnkown = dbContext.CardsInDecks.Where(c => c.DeckId == deck && c.CurrentHeap != CardInDeck.UnknownHeap).OrderBy(c => c.LastLearnUtcTime);
int count = allCardsNotUnkown.Count();
logger.LogInformation($"Will recompute expiration dates of {count} cards");
var doneCount = 0;
foreach (var card in allCardsNotUnkown)
{
var initialExpiryDate = card.ExpiryUtcTime;
var expiryDate = algo.ExpiryUtcDate(card.CurrentHeap, card.LastLearnUtcTime);
doneCount++;
logger.LogInformation($"Will update card {doneCount} of {count} in heap {card.CurrentHeap} expiry from {initialExpiryDate} to {expiryDate}");
card.ExpiryUtcTime = expiryDate;
}
await dbContext.SaveChangesAsync();
logger.LogInformation($"Expiration dates updating of {count} cards finished");
}
public async Task <bool> RunAsync(Guid deckId)
{
var deck = dbContext.Decks.Where(deck => deck.Id == deckId).Single();
dbContext.Decks.Remove(deck);
await dbContext.SaveChangesAsync();
return(true);
}
private async Task CreateCardNotificationAsync(DbContextOptions <MemCheckDbContext> db, Guid subscriberId, Guid cardId)
{
using var dbContext = new MemCheckDbContext(db);
var notif = new CardNotificationSubscription();
notif.CardId = cardId;
notif.UserId = subscriberId;
dbContext.CardNotifications.Add(notif);
await dbContext.SaveChangesAsync();
}
private async Task <MemCheckUser> CreateUserAsync(DbContextOptions <MemCheckDbContext> testDB)
{
using var dbContext = new MemCheckDbContext(testDB);
var result = new MemCheckUser();
dbContext.Users.Add(result);
await dbContext.SaveChangesAsync();
return(result);
}
private async Task CreateCardNotificationAsync(DbContextOptions <MemCheckDbContext> testDB, Guid subscriberId, Guid cardId, DateTime lastNotificationDate)
{
using var dbContext = new MemCheckDbContext(testDB);
var notif = new CardNotificationSubscription();
notif.CardId = cardId;
notif.UserId = subscriberId;
notif.LastNotificationUtcDate = lastNotificationDate;
dbContext.CardNotifications.Add(notif);
await dbContext.SaveChangesAsync();
}
public static async Task <Guid> CreateAsync(DbContextOptions <MemCheckDbContext> testDB, string?name = null, string?description = null)
{
using var dbContext = new MemCheckDbContext(testDB);
var result = new Tag {
Name = name ?? RandomHelper.String(), Description = description ?? RandomHelper.String()
};
dbContext.Tags.Add(result);
await dbContext.SaveChangesAsync();
return(result.Id);
}
public async Task <bool> RunAsync(string name)
{
name = name.Trim();
CheckNameValidity(dbContext, name);
dbContext.Tags.Add(new Tag()
{
Name = name
});
await dbContext.SaveChangesAsync();
return(true);
}
public static async Task CreateAsync(DbContextOptions <MemCheckDbContext> testDB, Guid subscriberId, Guid cardId, DateTime?lastNotificationDate = null)
{
using var dbContext = new MemCheckDbContext(testDB);
var notif = new CardNotificationSubscription {
CardId = cardId, UserId = subscriberId
};
if (lastNotificationDate != null)
{
notif.LastNotificationUtcDate = lastNotificationDate.Value;
}
dbContext.CardNotifications.Add(notif);
await dbContext.SaveChangesAsync();
}
async public Task RunAsync(MemCheckDbContext dbContext)
{
var geoInfo = new GeoInfo();
var user = await dbContext.Users.Where(u => u.UserName == "VoltanBot").SingleAsync();
await UpdateCards_WhatIsThisRegionAsync(user.Id, geoInfo);
await UpdateCards_WhereIsThisRegionAsync(user.Id, geoInfo);
await UpdateCards_HowManyDepartmentsInThisRegionAsync(user.Id, geoInfo);
await UpdateCards_WhatAreTheDepartmentsInThisRegionAsync(user.Id, geoInfo);
await dbContext.SaveChangesAsync();
logger.LogInformation($"Generation finished");
}
public static async Task <Guid> CreateInDbAsync(DbContextOptions <MemCheckDbContext> db, int minimumCountOfDaysBetweenNotifs = 0, DateTime?lastNotificationUtcDate = null, bool subscribeToCardOnEdit = false, string?userName = null, string?userEMail = null)
{
using var dbContext = new MemCheckDbContext(db);
var result = Create(minimumCountOfDaysBetweenNotifs, lastNotificationUtcDate, subscribeToCardOnEdit, userName);
if (userEMail != null)
{
result.Email = userEMail;
result.EmailConfirmed = true;
}
dbContext.Users.Add(result);
await dbContext.SaveChangesAsync();
return(result.Id);
}
public static async Task <Guid> CreateAsync(DbContextOptions <MemCheckDbContext> testDB, Guid ownerId, string?description = null, int algorithmId = UnitTestsHeapingAlgorithm.ID)
{
using var dbContext = new MemCheckDbContext(testDB);
var result = new Deck
{
Owner = await dbContext.Users.SingleAsync(u => u.Id == ownerId),
Description = description ?? RandomHelper.String(),
CardInDecks = Array.Empty <CardInDeck>(),
HeapingAlgorithmId = algorithmId
};
dbContext.Decks.Add(result);
await dbContext.SaveChangesAsync();
return(result.Id);
}
private async Task <Card> CreateCardAsync(DbContextOptions <MemCheckDbContext> db, MemCheckUser versionCreator)
{
using var dbContext = new MemCheckDbContext(db);
var creator = await dbContext.Users.Where(u => u.Id == versionCreator.Id).SingleAsync();
var result = new Card();
result.VersionCreator = creator;
result.FrontSide = StringServices.RandomString();
result.BackSide = StringServices.RandomString();
result.AdditionalInfo = StringServices.RandomString();
result.VersionDescription = StringServices.RandomString();
dbContext.Cards.Add(result);
await dbContext.SaveChangesAsync();
return(result);
}
private static async Task <CardPreviousVersion> CreateDeletedCardAsync(DbContextOptions <MemCheckDbContext> testDB, Guid versionCreatorId, DateTime versionDate, IEnumerable <Guid>?userWithViewIds = null)
{
//userWithViewIds null means public card
var cardLanguageId = await CardLanguagHelper.CreateAsync(testDB);
using var dbContext = new MemCheckDbContext(testDB);
var creator = await dbContext.Users.Where(u => u.Id == versionCreatorId).SingleAsync();
var cardLanguage = await dbContext.CardLanguages.SingleAsync(cardLanguage => cardLanguage.Id == cardLanguageId);
var result = new CardPreviousVersion
{
Card = Guid.NewGuid(),
CardLanguage = cardLanguage,
VersionCreator = creator,
FrontSide = Guid.NewGuid().ToString(),
BackSide = Guid.NewGuid().ToString(),
AdditionalInfo = Guid.NewGuid().ToString(),
VersionDescription = Guid.NewGuid().ToString(),
VersionType = CardPreviousVersionType.Deletion,
VersionUtcDate = versionDate
};
dbContext.CardPreviousVersions.Add(result);
var usersWithView = new List <UserWithViewOnCardPreviousVersion>();
if (userWithViewIds != null)
{
Assert.IsTrue(userWithViewIds.Any(id => id == versionCreatorId), "Version creator must be allowed to view");
foreach (var userWithViewId in userWithViewIds)
{
var userWithView = new UserWithViewOnCardPreviousVersion {
CardPreviousVersionId = result.Id, AllowedUserId = userWithViewId
};
dbContext.UsersWithViewOnCardPreviousVersions.Add(userWithView);
usersWithView.Add(userWithView);
}
}
result.UsersWithView = usersWithView;
await dbContext.SaveChangesAsync();
return(result);
}
async public Task RunAsync()
{
var user = dbContext.Users.Where(user => user.UserName == "Voltan").Single();
logger.LogInformation($"DB contains {dbContext.ImagePreviousVersions.Count()} image versions");
var images = dbContext.ImagePreviousVersions.Include(img => img.Owner).Where(image => image.Owner == null);
logger.LogInformation($"Found {images.Count()} image versions to modify");
foreach (var image in images)
{
logger.LogInformation($"Changing image '{image.Name}'");
image.Owner = user;
}
await dbContext.SaveChangesAsync();
logger.LogInformation($"Finished");
}
async public Task RunAsync()
{
var author = await dbContext.Users.Where(u => u.UserName == "VoltanBot").SingleAsync();
var ratingUser = await dbContext.Users.Where(u => u.UserName == "VoltanBot").SingleAsync();
var cardIds = await dbContext.Cards.Where(card => card.VersionCreator.Id == author.Id).Select(card => card.Id).ToListAsync();
var rater = new SetCardRating(dbContext.AsCallContext());
foreach (var cardId in cardIds)
{
var request = new SetCardRating.Request(ratingUser.Id, cardId, 5);
await rater.RunAsync(request);
}
await dbContext.SaveChangesAsync();
logger.LogInformation($"Rating finished");
}
async public Task RunAsync(MemCheckDbContext dbContext)
{
var user = await dbContext.Users.Where(u => u.UserName == "VoltanBot").SingleAsync();
var cardIds = await dbContext.Cards.Where(card => card.VersionCreator.Id == user.Id).Select(card => card.Id).ToListAsync();
foreach (var cardId in cardIds)
{
if (!dbContext.UserCardRatings.Where(ranking => ranking.UserId == user.Id && ranking.CardId == cardId).Any())
{
dbContext.UserCardRatings.Add(new UserCardRating()
{
UserId = user.Id, CardId = cardId, Rating = 5
});
}
}
await dbContext.SaveChangesAsync();
logger.LogInformation($"Rating finished");
}
async public Task RunAsync(MemCheckDbContext dbContext)
{
var cardLanguage = dbContext.CardLanguages.First();
var user = dbContext.Users.First();
//for (int i = 0; i < cardCount; i++)
//{
// var card = new Card();
// card.Owner = null;
// card.CardLanguage = cardLanguage;
// card.FrontSide = "Bulk added card front side, " + Guid.NewGuid();
// card.BackSide = "Bulk added card back side, " + Guid.NewGuid();
// card.AdditionalInfo = "Bulk added additional info, " + Guid.NewGuid();
// card.CreationUtcDate = DateTime.Now.ToUniversalTime();
// card.LastChangeUtcDate = DateTime.Now.ToUniversalTime();
// card.UsersWithView = new List<Guid>() { user.Id };
// dbContext.Cards.Add(card);
//}
await dbContext.SaveChangesAsync();
}
public static async Task <SearchSubscription> CreateAsync(DbContextOptions <MemCheckDbContext> testDB, Guid subscriberId, string?name = null, string requiredText = "", Guid?excludedDeckId = null, DateTime?lastNotificationDate = null)
{
using var dbContext = new MemCheckDbContext(testDB);
var result = new SearchSubscription
{
UserId = subscriberId,
Name = name ?? RandomHelper.String(),
ExcludedDeck = excludedDeckId == null ? Guid.Empty : excludedDeckId.Value,
RequiredText = requiredText,
RequiredTags = Array.Empty <RequiredTagInSearchSubscription>(),
ExcludeAllTags = false,
ExcludedTags = Array.Empty <ExcludedTagInSearchSubscription>(),
LastRunUtcDate = lastNotificationDate != null ? lastNotificationDate.Value : DateTime.MinValue,
RegistrationUtcDate = lastNotificationDate != null ? lastNotificationDate.Value : DateTime.MinValue
};
dbContext.SearchSubscriptions.Add(result);
await dbContext.SaveChangesAsync();
return(result);
}
public async Task <GetCardsInDeck.ViewModel> RunAsync(Guid deckId, Guid cardId)
{
var card = dbContext.Cards.Single(card => card.Id.Equals(cardId));
var cardForUser = new CardInDeck()
{
CardId = card.Id,
Card = card,
DeckId = deckId,
CurrentHeap = 0,
LastLearnUtcTime = DateTime.MinValue.ToUniversalTime(),
AddToDeckUtcTime = DateTime.UtcNow,
NbTimesInNotLearnedHeap = 1,
BiggestHeapReached = 0
};
dbContext.CardsInDecks.Add(cardForUser);
await dbContext.SaveChangesAsync();
return(new GetCardsInDeck.ViewModel(cardForUser.Card.Id, cardForUser.CurrentHeap, cardForUser.LastLearnUtcTime,
cardForUser.BiggestHeapReached, cardForUser.NbTimesInNotLearnedHeap, cardForUser.Card.FrontSide, cardForUser.Card.BackSide));
}
async public Task RunAsync()
{
var cards = await dbContext.Cards.Where(c => (c.VersionCreator.UserName == "Toto2" || c.VersionCreator.UserName == "Voltan" || c.VersionCreator.UserName == "VoltanBot") && c.TagsInCards.Count() == 1 && c.TagsInCards.First().Tag.Name == "États américains").ToListAsync();
foreach (var card in cards)
{
logger.LogInformation($"\t {card.FrontSide.Substring(0, Math.Min(100, card.FrontSide.Length))}");
}
logger.LogInformation($"{cards.Count} cards selected");
logger.LogWarning("Opportunity to cancel. Please confirm with Y");
var input = Console.ReadLine();
if (input == null || !input.Trim().Equals("y", StringComparison.OrdinalIgnoreCase))
{
logger.LogError("User cancellation");
return;
}
dbContext.Cards.RemoveRange(cards);
//var user = dbContext.Users.Where(u => u.UserName == "VoltanBot").Single();//
//var frenchLanguageId = dbContext.CardLanguages.Where(lang => lang.Name == "Français").Select(lang => lang.Id).Single();
//var tagId = dbContext.Tags.Where(tag => tag.Name == "États américains").Select(tag => tag.Id).Single();
//var statesWithNamesImageId = dbContext.Images.Where(img => img.Name == "Carte.Amérique.USA.États").Select(img => img.Id).Single();
//var statesWithoutNamesImageId = dbContext.Images.Where(img => img.Name == "États américains sans noms").Select(img => img.Id).Single();
//foreach (var state in infoFileContents.States)
//{
// logger.LogDebug($"Working on state '{state.FrenchName}'");
// await CreateCard_WhatIsTheNameOfThisStateAsync(state, user, statesWithNamesImageId, frenchLanguageId, tagId);
// await CreateCard_WhereIsThisStateAsync(state, user, statesWithoutNamesImageId, frenchLanguageId, tagId);
// await CreateCard_WhatIsTheCapitalOfAsync(state, user, frenchLanguageId, tagId);
// await CreateCard_WhatIsTheStateOfThisCapitalAsync(state, user, frenchLanguageId, tagId);
//}
await dbContext.SaveChangesAsync();
logger.LogInformation($"Deletion finished");
}
private async Task <Card> CreateCardAsync(DbContextOptions <MemCheckDbContext> testDB, Guid versionCreatorId, DateTime versionDate, IEnumerable <Guid>?userWithViewIds = null)
{
//userWithViewIds null means public card
using var dbContext = new MemCheckDbContext(testDB);
var creator = await dbContext.Users.Where(u => u.Id == versionCreatorId).SingleAsync();
var result = new Card();
result.VersionCreator = creator;
result.FrontSide = StringServices.RandomString();
result.BackSide = StringServices.RandomString();
result.AdditionalInfo = StringServices.RandomString();
result.VersionDescription = StringServices.RandomString();
result.VersionType = CardVersionType.Creation;
result.InitialCreationUtcDate = versionDate;
result.VersionUtcDate = versionDate;
dbContext.Cards.Add(result);
var usersWithView = new List <UserWithViewOnCard>();
if (userWithViewIds != null)
{
Assert.IsTrue(userWithViewIds.Any(id => id == versionCreatorId), "Version creator must be allowed to view");
foreach (var userWithViewId in userWithViewIds)
{
var userWithView = new UserWithViewOnCard();
userWithView.CardId = result.Id;
userWithView.UserId = userWithViewId;
dbContext.UsersWithViewOnCards.Add(userWithView);
usersWithView.Add(userWithView);
}
}
result.UsersWithView = usersWithView;
await dbContext.SaveChangesAsync();
return(result);
}
public async Task CardWitOnePreviousVersion_ToBeNotifiedWithoutAccessibility()
{
var testDB = DbServices.GetEmptyTestDB(typeof(UserCardVersionsNotifierTests));
var user1 = await CreateUserAsync(testDB);
var card = await CreateCardAsync(testDB, user1.Id, new DateTime(2020, 11, 2), new[] { user1.Id });
await CreateCardPreviousVersionAsync(testDB, user1.Id, card.Id, new DateTime(2020, 11, 1));
var user2 = await CreateUserAsync(testDB);
await CreateCardNotificationAsync(testDB, user2.Id, card.Id, new DateTime(2020, 11, 1));
var now = new DateTime(2020, 11, 2);
using (var dbContext = new MemCheckDbContext(testDB))
{
var notifier = new UserCardVersionsNotifier(dbContext);
var user1versions = notifier.Run(user1, now);
Assert.AreEqual(0, user1versions.Length);
var user2versions = notifier.Run(user2, now);
Assert.AreEqual(1, user2versions.Length);
Assert.AreEqual(card.Id, user2versions[0].CardId);
Assert.IsFalse(user2versions[0].CardIsViewable);
Assert.IsNull(user2versions[0].VersionDescription);
Assert.IsNull(user2versions[0].FrontSide);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var notif = dbContext.CardNotifications.Single(cn => cn.CardId == card.Id && cn.UserId == user2.Id);
Assert.AreEqual(now, notif.LastNotificationUtcDate);
}
}
