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); } }