public async Task OneCardWithImages()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var image1 = await ImageHelper.CreateAsync(db, user);
var image2 = await ImageHelper.CreateAsync(db, user);
var createdCard = await CardHelper.CreateAsync(db, user, frontSideImages : new[] { image1, image2 });
var addDate = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, createdCard.Id, 1, addDate);
using var dbContext = new MemCheckDbContext(db);
var request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 10);
var cards = await new GetCardsToRepeat(dbContext.AsCallContext(), addDate.AddDays(1)).RunAsync(request);
var resultImages = cards.Cards.Single().Images;
Assert.AreEqual(2, resultImages.Count());
Assert.AreEqual(image1, resultImages.First().ImageId);
Assert.AreEqual(image2, resultImages.Last().ImageId);
}
private void CleanCache()
{
int num = this.m_cardCache.Count - 60;
if (num > 0)
{
CollectionDeck currentlyOpenDeck = null;
if (CollectionManager.Get() != null)
{
currentlyOpenDeck = CollectionManager.Get().GetTaggedDeck(CollectionManager.DeckTag.Editing);
}
List <string> deckHelperCardChoices = (DeckHelper.Get() != null) ? DeckHelper.Get().GetCardIDChoices() : null;
List <string> names = new List <string>();
int index = 0;
while (index < this.m_cardCache.Count)
{
CardCacheItem item = this.m_cardCache[index];
if (!this.CanClearItem(item, currentlyOpenDeck, deckHelperCardChoices))
{
index++;
}
else
{
names.Add(item.m_cardId);
this.m_cardCache.RemoveAt(index);
DefLoader.Get().ClearCardDef(item.m_cardId);
if (names.Count == num)
{
break;
}
}
}
AssetCache.ClearCardPrefabs(names);
}
}
public async Task RequestedCount()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DeveloperHeapingAlgorithm.ID);
var loadTime = RandomHelper.Date();
const int cardCount = 50;
for (int i = 0; i < cardCount; i++)
{
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card.Id, RandomHelper.Heap(true), RandomHelper.DateBefore(loadTime));
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount / 2);
var cards = await new GetCardsToRepeat(dbContext.AsCallContext(), loadTime).RunAsync(request);
Assert.AreEqual(request.CardsToDownload, cards.Cards.Count());
request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount);
cards = await new GetCardsToRepeat(dbContext.AsCallContext(), loadTime).RunAsync(request);
Assert.AreEqual(request.CardsToDownload, cards.Cards.Count());
request = new GetCardsToRepeat.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount * 2);
cards = await new GetCardsToRepeat(dbContext.AsCallContext(), loadTime).RunAsync(request);
Assert.AreEqual(cardCount, cards.Cards.Count());
}
public async Task LearnMoveToSameHeap()
{
//This could happen due to multiple sessions by the user
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
var initialTime = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1, lastLearnUtcTime : initialTime);
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardToHeap(dbContext.AsCallContext(), RandomHelper.Date(initialTime)).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, 1));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(1, cardInDeck.CurrentHeap);
Assert.AreEqual(initialTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(1, cardInDeck.BiggestHeapReached);
Assert.AreEqual(initialTime.AddDays(1), cardInDeck.ExpiryUtcTime);
}
}
public async Task OneDeck()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : HeapingAlgorithms.DefaultAlgoId);
var tag1 = await TagHelper.CreateAsync(db);
var tag2 = await TagHelper.CreateAsync(db);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user, tagIds: tag1.AsArray())).Id, 0);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 0);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 1);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user, tagIds: new[] { tag1, tag2 })).Id, 1);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 2);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 4);
await DeckHelper.AddCardAsync(db, deck, (await CardHelper.CreateAsync(db, user)).Id, 4);
using var dbContext = new MemCheckDbContext(db);
var result = await new GetUserDecksWithHeapsAndTags(dbContext.AsCallContext()).RunAsync(new GetUserDecksWithHeapsAndTags.Request(user));
var resultDeck = result.Single();
Assert.AreEqual(deck, resultDeck.DeckId);
Assert.IsTrue(resultDeck.Heaps.SequenceEqual(new[] { 0, 1, 2, 4 }));
Assert.AreEqual(2, resultDeck.Tags.Count());
Assert.IsTrue(resultDeck.Tags.Any(tag => tag.TagId == tag1));
Assert.IsTrue(resultDeck.Tags.Any(tag => tag.TagId == tag2));
}
public static Deck GetMostPopular(CardClass heroClass)
{
string query = $"select * from AllInfo where num_games = (select max(num_games) from AllInfo where hero_class = '{heroClass.ToString()}');";
var Deck = new DataTable();
using (var conn = new SQLiteConnection(connection))
{
//var cmd = new SQLiteCommand(query, conn);
using (var adapter = new SQLiteDataAdapter {
SelectCommand = new SQLiteCommand(query, conn)
})
{
adapter.Fill(Deck);
}
}
var cards = new List <Card>();
//var col = Deck.Columns[4];
foreach (DataRow row in Deck.Rows)
{
cards.Add(Cards.FromName(row.ItemArray[4].ToString()));
}
Archetype archetype = DeckHelper.Map <Archetype>(Deck.Rows[0].ItemArray[1].ToString());
string deckName = Deck.Rows[0].ItemArray[2].ToString();
int numGames = (int)(long)Deck.Rows[0].ItemArray[3];
return(new Deck(heroClass, archetype, deckName, numGames, cards));
}
public async Task MoveToZeroTwice()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
var addTime = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 8, lastLearnUtcTime : addTime);
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardsToHeap(dbContext.AsCallContext()).RunAsync(new MoveCardsToHeap.Request(user, deck, CardInDeck.UnknownHeap, card.Id.AsArray()));
for (int i = 0; i < 2; i++)
{
using (var dbContext = new MemCheckDbContext(db))
{
var loadedCard = dbContext.CardsInDecks.Single();
Assert.AreEqual(CardInDeck.UnknownHeap, loadedCard.CurrentHeap);
Assert.AreEqual(addTime, loadedCard.LastLearnUtcTime);
Assert.AreEqual(DateTime.MinValue, loadedCard.ExpiryUtcTime);
Assert.AreEqual(2, loadedCard.NbTimesInNotLearnedHeap);
Assert.AreEqual(8, loadedCard.BiggestHeapReached);
}
}
}
public async Task MoveToSameHeap()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
var lastLearnTime = RandomHelper.Date();
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1, lastLearnUtcTime : lastLearnTime);
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardsToHeap(dbContext.AsCallContext()).RunAsync(new MoveCardsToHeap.Request(user, deck, 1, card.Id.AsArray()));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(1, cardInDeck.CurrentHeap);
Assert.AreEqual(lastLearnTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(lastLearnTime.AddDays(1), cardInDeck.ExpiryUtcTime);
Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(1, cardInDeck.BiggestHeapReached);
}
}
public async Task ReduceVisibility_OnlyUserWithView_NoOtherUserHasInDeck_OnlyAuthor()
{
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 deck = await DeckHelper.CreateAsync(db, cardCreator);
await DeckHelper.AddCardAsync(db, deck, card.Id, 0);
var otherUser = await UserHelper.CreateInDbAsync(db);
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));
}
}
/// <summary>
/// Returns the specified deck from hearth_decks.db
/// </summary>
/// <param name="deckName"></param>
/// <returns></returns>
public static Deck DeckFromName(string deckName, CardClass heroClass)
{
string query = $"select archetype, num_games, card_name from AllInfo where deck_name = '{deckName}';";
var Deck = new DataTable();
using (var conn = new SQLiteConnection(connection))
{
conn.Open();
//var cmd = new SQLiteCommand(query, conn);
using (var adapter = new SQLiteDataAdapter {
SelectCommand = new SQLiteCommand(query, conn)
})
{
adapter.Fill(Deck);
}
}
var cards = new List <Card>();
//var col = Deck.Columns[4];
foreach (DataRow row in Deck.Rows)
{
cards.Add(Cards.FromName(row.ItemArray[2].ToString()));
}
Archetype archetype = DeckHelper.Map <Archetype>(Deck.Rows[0].ItemArray[0].ToString());
int numGames = (int)(long)Deck.Rows[0].ItemArray[1];
return(new Deck(heroClass, archetype, deckName, numGames, cards));
}
public async Task TestSearchExcludingDeck()
{
var testDB = DbHelper.GetEmptyTestDB();
var userId = await UserHelper.CreateInDbAsync(testDB);
var deckId = await DeckHelper.CreateAsync(testDB, userId);
using (var dbContext = new MemCheckDbContext(testDB))
{
var request = new SubscribeToSearch.Request(userId, deckId, RandomHelper.String(), "", Array.Empty <Guid>(), Array.Empty <Guid>());
await new SubscribeToSearch(dbContext.AsCallContext()).RunAsync(request);
}
using (var dbContext = new MemCheckDbContext(testDB))
{
var subscription = await dbContext.SearchSubscriptions
.Include(subscription => subscription.ExcludedTags)
.Include(subscription => subscription.RequiredTags)
.SingleAsync();
Assert.AreEqual(userId, subscription.UserId);
Assert.AreEqual(deckId, subscription.ExcludedDeck);
Assert.AreEqual("", subscription.RequiredText);
Assert.AreEqual(0, subscription.RequiredTags.Count());
Assert.IsFalse(subscription.ExcludeAllTags);
Assert.AreEqual(0, subscription.ExcludedTags !.Count());
}
}
public async Task TwoDecks()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck1Name = RandomHelper.String();
var deck1Algo = RandomHelper.HeapingAlgorithm();
var deck1 = await DeckHelper.CreateAsync(db, user, deck1Name, deck1Algo);
var deck2Name = RandomHelper.String();
var deck2Algo = RandomHelper.HeapingAlgorithm();
var deck2 = await DeckHelper.CreateAsync(db, user, deck2Name, deck2Algo);
using var dbContext = new MemCheckDbContext(db);
var result = await new GetUserDecks(dbContext.AsCallContext()).RunAsync(new GetUserDecks.Request(user));
Assert.AreEqual(2, result.Count());
var resultDeck1 = result.Single(d => d.DeckId == deck1);
Assert.AreEqual(deck1Name, resultDeck1.Description);
Assert.AreEqual(deck1Algo, resultDeck1.HeapingAlgorithmId);
var resultDeck2 = result.Single(d => d.DeckId == deck2);
Assert.AreEqual(deck2Name, resultDeck2.Description);
Assert.AreEqual(deck2Algo, resultDeck2.HeapingAlgorithmId);
}
public async Task Complex()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card1 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card1.Id);
var card2 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card2.Id);
var card3 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card3.Id);
using (var dbContext = new MemCheckDbContext(db))
await new RemoveCardFromDeck(dbContext.AsCallContext()).RunAsync(new RemoveCardFromDeck.Request(user, deck, card2.Id));
await DeckHelper.CheckDeckDoesNotContainCard(db, deck, card2.Id);
await DeckHelper.CheckDeckContainsCards(db, deck, card1.Id, card3.Id);
}
public async Task UnknownCardsLearnt_CheckOrder()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DeveloperHeapingAlgorithm.ID);
const int cardCount = 100;
for (int i = 0; i < cardCount; i++)
{
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card.Id, 0);
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount);
var cards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.ToImmutableArray();
Assert.AreEqual(cardCount, cards.Length);
for (int i = 1; i < cards.Length; i++)
{
Assert.IsTrue(cards[i].LastLearnUtcTime >= cards[i - 1].LastLearnUtcTime);
}
}
public async Task ComplexCaseWithLessCardsThanRequested()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DeveloperHeapingAlgorithm.ID);
const int cardCount = 10;
for (int i = 0; i < cardCount / 2; i++)
{
await DeckHelper.AddNeverLearntCardAsync(db, deck, await CardHelper.CreateIdAsync(db, user));
await DeckHelper.AddCardAsync(db, deck, await CardHelper.CreateIdAsync(db, user), 0);
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount * 2);
var cards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.ToImmutableArray();
Assert.AreEqual(cardCount, cards.Length);
for (int i = 1; i < cardCount / 2; i++)
{
Assert.AreEqual(CardInDeck.NeverLearntLastLearnTime, cards[i].LastLearnUtcTime);
}
for (int i = cardCount / 2; i < cards.Length; i++)
{
Assert.IsTrue(cards[i].LastLearnUtcTime >= cards[i - 1].LastLearnUtcTime);
}
}
public async Task DoesNotDeleteOtherUserDeck()
{
var db = DbHelper.GetEmptyTestDB();
var loggedUser = await UserHelper.CreateInDbAsync(db);
var deckNotToDelete = await DeckHelper.CreateAsync(db, loggedUser);
var userToDelete = await UserHelper.CreateInDbAsync(db);
var deckToDelete = await DeckHelper.CreateAsync(db, userToDelete);
var card = await CardHelper.CreateAsync(db, userToDelete);
await DeckHelper.AddCardAsync(db, deckToDelete, card.Id);
await DeckHelper.AddCardAsync(db, deckNotToDelete, card.Id);
using (var dbContext = new MemCheckDbContext(db))
{
using var userManager = UserHelper.GetUserManager(dbContext);
await new DeleteUserAccount(dbContext.AsCallContext(new TestRoleChecker(loggedUser)), userManager).RunAsync(new DeleteUserAccount.Request(loggedUser, userToDelete));
}
using (var dbContext = new MemCheckDbContext(db))
{
Assert.IsFalse(await dbContext.Decks.AnyAsync(deck => deck.Id == deckToDelete));
Assert.IsFalse(await dbContext.CardsInDecks.AnyAsync(cardInDeck => cardInDeck.Deck.Id == deckToDelete));
Assert.IsTrue(await dbContext.Decks.AnyAsync(deck => deck.Id == deckNotToDelete));
Assert.IsTrue(await dbContext.CardsInDecks.AnyAsync(cardInDeck => cardInDeck.Deck.Id == deckNotToDelete));
}
}
public async Task CardsNeverLearnt_NotTheSameOrderOnSuccessiveRuns()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DefaultHeapingAlgorithm.ID);
const int cardCount = 100;
for (int i = 0; i < cardCount; i++)
{
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddNeverLearntCardAsync(db, deck, card.Id);
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), cardCount);
var firstRunCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableArray();
Assert.AreEqual(cardCount, firstRunCards.Length);
var secondRunCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableArray();
Assert.AreEqual(cardCount, secondRunCards.Length);
var thirdRunCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableArray();
Assert.AreEqual(cardCount, thirdRunCards.Length);
Assert.IsFalse(firstRunCards.SequenceEqual(secondRunCards));
Assert.IsFalse(firstRunCards.SequenceEqual(thirdRunCards));
Assert.IsFalse(secondRunCards.SequenceEqual(thirdRunCards));
}
public async Task LearnMoveToUnknown()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 4);
var runTime = RandomHelper.Date();
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardToHeap(dbContext.AsCallContext(), runTime).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, CardInDeck.UnknownHeap));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(CardInDeck.UnknownHeap, cardInDeck.CurrentHeap);
Assert.AreEqual(runTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(2, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(4, cardInDeck.BiggestHeapReached);
Assert.AreEqual(DateTime.MinValue, cardInDeck.ExpiryUtcTime);
}
}
public async Task Complex()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var tag1 = await TagHelper.CreateAsync(db);
var card1 = await CardHelper.CreateAsync(db, user, tagIds : tag1.AsArray());
await DeckHelper.AddCardAsync(db, deck, card1.Id);
var tag2 = await TagHelper.CreateAsync(db);
var card2 = await CardHelper.CreateAsync(db, user, tagIds : tag2.AsArray());
await DeckHelper.AddCardAsync(db, deck, card2.Id);
var card3 = await CardHelper.CreateAsync(db, user, tagIds : new[] { tag1, tag2 });
await DeckHelper.AddCardAsync(db, deck, card3.Id);
var card4 = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card4.Id);
using var dbContext = new MemCheckDbContext(db);
var request = new GetTagsOfDeck.Request(user, deck);
var result = await new GetTagsOfDeck(dbContext).RunAsync(request);
Assert.AreEqual(2, result.Count());
Assert.IsTrue(result.Any(t => t.TagId == tag1));
Assert.IsTrue(result.Any(t => t.TagId == tag2));
}
public async Task LearnMoveUp()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : UnitTestsHeapingAlgorithm.ID);
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddCardAsync(db, deck, card.Id, heap : 1);
var runTime = RandomHelper.Date();
using (var dbContext = new MemCheckDbContext(db))
await new MoveCardToHeap(dbContext.AsCallContext(), runTime).RunAsync(new MoveCardToHeap.Request(user, deck, card.Id, 2));
using (var dbContext = new MemCheckDbContext(db))
{
var cardInDeck = dbContext.CardsInDecks.Single();
Assert.AreEqual(2, cardInDeck.CurrentHeap);
Assert.AreEqual(runTime, cardInDeck.LastLearnUtcTime);
Assert.AreEqual(1, cardInDeck.NbTimesInNotLearnedHeap);
Assert.AreEqual(2, cardInDeck.BiggestHeapReached);
Assert.AreEqual(runTime.AddDays(2), cardInDeck.ExpiryUtcTime);
}
}
public async Task TwoCardsWithLanguages()
{
var db = DbHelper.GetEmptyTestDB();
var french = await CardLanguagHelper.CreateAsync(db, "Français");
var otherLanguage = await CardLanguagHelper.CreateAsync(db, RandomHelper.String());
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
var frenchCreatedCard = await CardHelper.CreateAsync(db, user, language : french);
var otherLanguageCard = await CardHelper.CreateAsync(db, user, language : otherLanguage);
await DeckHelper.AddNeverLearntCardAsync(db, deck, frenchCreatedCard.Id);
await DeckHelper.AddNeverLearntCardAsync(db, deck, otherLanguageCard.Id);
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 10);
var cards = await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request);
Assert.IsTrue(cards.Cards.Single(card => card.CardId == frenchCreatedCard.Id).IsInFrench);
Assert.IsFalse(cards.Cards.Single(card => card.CardId == otherLanguageCard.Id).IsInFrench);
}
public async Task OrderingOfNeverLearnt()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user, algorithmId : DefaultHeapingAlgorithm.ID);
var randomDate = RandomHelper.Date();
var cardAddedLater = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddNeverLearntCardAsync(db, deck, cardAddedLater.Id, randomDate.AddDays(1));
for (int i = 0; i < 9; i++)
{
var card = await CardHelper.CreateAsync(db, user);
await DeckHelper.AddNeverLearntCardAsync(db, deck, card.Id, randomDate);
}
using var dbContext = new MemCheckDbContext(db);
var request = new GetUnknownCardsToLearn.Request(user, deck, Array.Empty <Guid>(), Array.Empty <Guid>(), 3);
var downloadedCards = (await new GetUnknownCardsToLearn(dbContext.AsCallContext()).RunAsync(request)).Cards.Select(c => c.CardId).ToImmutableHashSet();
Assert.IsFalse(downloadedCards.Contains(cardAddedLater.Id));
}
public void ChooseThisCard()
{
KeywordHelpPanelManager.Get().HideKeywordHelp();
this.m_chosen = true;
this.m_actor.GetSpell(SpellType.DEATHREVERSE).ActivateState(SpellStateType.BIRTH);
CollectionDeckTray.Get().AddCard(this.m_actor.GetEntityDef(), this.m_actor.GetCardFlair(), null, false, this.m_actor);
DeckHelper.Get().UpdateChoices();
}
public ActionResult DeleteConfirmed(int cardId)
{
Card card = cardRepository.GetSingle(cardId);
var deckId = card.DeckID;
cardRepository.Remove(card);
DeckHelper.UpdateDeckNumbers(deckId, deckRepository);
return(RedirectToAction("Details", "MyDeck", new { deckId = deckId }));
}
public bool AddCard(EntityDef cardEntityDef, CardFlair cardFlair, DeckTrayDeckTileVisual deckTileToRemove, bool playSound, Actor animateFromActor = null)
{
if (!base.IsModeActive())
{
return(false);
}
if (cardEntityDef == null)
{
UnityEngine.Debug.LogError("Trying to add card EntityDef that is null.");
return(false);
}
string cardId = cardEntityDef.GetCardId();
CollectionDeck taggedDeck = CollectionManager.Get().GetTaggedDeck(this.m_deckType);
if (taggedDeck == null)
{
return(false);
}
if (playSound)
{
SoundManager.Get().LoadAndPlay("collection_manager_place_card_in_deck", base.gameObject);
}
if (taggedDeck.GetTotalCardCount() == 30)
{
if (deckTileToRemove == null)
{
UnityEngine.Debug.LogWarning(string.Format("CollectionDeckTray.AddCard(): Cannot add card {0} (flair {1}) without removing one first.", cardEntityDef.GetCardId(), cardFlair));
return(false);
}
string cardID = deckTileToRemove.GetCardID();
CardFlair flair = deckTileToRemove.GetCardFlair();
if (!taggedDeck.RemoveCard(cardID, flair.Premium, deckTileToRemove.IsOwnedSlot()))
{
object[] args = new object[] { cardId, cardFlair, cardID, flair };
UnityEngine.Debug.LogWarning(string.Format("CollectionDeckTray.AddCard({0},{1}): Tried to remove card {2} with flair {3}, but it failed!", args));
return(false);
}
}
if (!taggedDeck.AddCard(cardEntityDef, cardFlair.Premium))
{
UnityEngine.Debug.LogWarning(string.Format("CollectionDeckTray.AddCard({0},{1}): deck.AddCard failed!", cardId, cardFlair));
return(false);
}
if (taggedDeck.GetTotalOwnedCardCount() == 30)
{
DeckHelper.Get().Hide();
}
this.UpdateCardList(cardEntityDef, true, animateFromActor);
CollectionManagerDisplay.Get().UpdateCurrentPageCardLocks(true);
if ((!Options.Get().GetBool(Option.HAS_ADDED_CARDS_TO_DECK, false) && (taggedDeck.GetTotalCardCount() >= 2)) && (!DeckHelper.Get().IsActive() && (taggedDeck.GetTotalCardCount() < 15)))
{
NotificationManager.Get().CreateInnkeeperQuote(GameStrings.Get("VO_INNKEEPER_CM_PAGEFLIP_28"), "VO_INNKEEPER_CM_PAGEFLIP_28", 0f, null);
Options.Get().SetBool(Option.HAS_ADDED_CARDS_TO_DECK, true);
}
return(true);
}
public async Task UserDoesNotExist()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
using var dbContext = new MemCheckDbContext(db);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new GetUserDecksWithHeapsAndTags(dbContext.AsCallContext()).RunAsync(new GetUserDecksWithHeapsAndTags.Request(Guid.NewGuid())));
}
public async Task UserNotLoggedIn()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
using var dbContext = new MemCheckDbContext(db);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new GetTagsOfDeck(dbContext).RunAsync(new GetTagsOfDeck.Request(Guid.Empty, deck)));
}
private async Task <IEnumerable <ShowGameViewItem> > TakeCard(IEnumerable <ShowGameViewItem> gameStatistics)
{
DeckHelper deck = new DeckHelper(gameStatistics);
await DoRoundWithoutPlayerWithType(gameStatistics, deck, PlayerType.Dealer);
CheckPoint(gameStatistics);
return(gameStatistics);
}
public async Task CardDoesNotExist()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
using var dbContext = new MemCheckDbContext(db);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await new RemoveCardFromDeck(dbContext.AsCallContext()).RunAsync(new RemoveCardFromDeck.Request(user, deck, Guid.NewGuid())));
}
public async Task DoesNotThrowWhenCardDoesNotExist()
{
var db = DbHelper.GetEmptyTestDB();
var user = await UserHelper.CreateInDbAsync(db);
var deck = await DeckHelper.CreateAsync(db, user);
using var dbContext = new MemCheckDbContext(db);
await new RemoveCardsFromDeck(dbContext.AsCallContext()).RunAsync(new RemoveCardsFromDeck.Request(user, deck, Guid.NewGuid().AsArray()));
}
