public async Task <bool> CopyDeckAsync(Guid userId, Guid deckId)
{
var deck = await deckRepository.FindByIdAsync(deckId);
if (deck == null)
{
return(false);
}
var newDeck = new DeckEntity(userId, deck.Title);
var result = await deckRepository.InsertAsync(newDeck);
var cards = await cardRepository.GetCardsByDeckAsync(deck.Id);
if (result == null || cards == null)
{
return(false);
}
var tasks = cards.Select(c => Task.Run(() =>
cardRepository.InsertAsync(new CardEntity(result.Id, c.Question, c.Answer))
));
var results = await Task.WhenAll(tasks);
return(results.All(c => c != null));
}
public void ToToEntity_WithValidObject_ShouldBeExecuteCorrectly()
{
// Arrange
var deck = new Deck(
deckId: Guid.NewGuid(),
nPlayers: _fixture.Create <int>(),
playerTurn: _fixture.Create <int>(),
lastCardValue: _fixture.Create <int>(),
deckCardJson: "{}",
cards: GenerateRandomCards(52).ToList());
var expected = new DeckEntity()
{
DeckId = deck.DeckId,
NPlayers = deck.NPlayers,
PlayerTurn = deck.PlayerTurn,
LastCardValue = deck.LastCardValue,
LastCardJson = deck.LastCardJson,
Cards = deck.Cards.Select(a => a.ToEntity()).ToList(),
};
// Act
var result = deck.ToEntity();
// Assert
result
.Should()
.BeEquivalentTo(expected);
}
public async Task InsertAsync_ReturnsTheSameObject()
{
var expected = new DeckEntity(Guid.Empty, "d");
var actual = await _repository.InsertAsync(expected);
actual.Should().Be(expected);
}
public async Task InsertAsync_SetsNewId()
{
var deck = new DeckEntity(Guid.Empty, "d");
await _repository.InsertAsync(deck);
deck.Id.Should().NotBeEmpty();
}
public DeckModel Map(DeckEntity entity)
{
return(new DeckModel
{
Id = entity.Id,
Title = entity.Title
});
}
/// <summary>
/// Создать колоду.
/// </summary>
/// <param name="name">Имя колоды.</param>
public async Task <Guid> Create(string name)
{
var deck = DeckEntity.GenerateDeck(name, _settings.CurrentValue.Size);
var dto = MapDeckToDTO(Guid.NewGuid(), deck);
await _storage.Add(dto);
return(dto.Id);
}
public async Task InsertAsync_SavesDeck()
{
var expected = new DeckEntity(Guid.NewGuid(), "new deck");
await _repository.InsertAsync(expected);
var actual = await _collection.Find(d => d.Id == expected.Id).FirstOrDefaultAsync();
actual.Should().BeEquivalentTo(expected);
}
public async Task UpdateAsync_ChangesDeck()
{
var old = Decks[0];
var expected = new DeckEntity(old.Id, old.UserId, "updated deck");
await _repository.UpdateAsync(expected);
var actual = await _collection.Find(d => d.Id == expected.Id).FirstOrDefaultAsync();
actual.Should().BeEquivalentTo(expected);
}
public void Update(DeckEntity entity, SqliteDatabase mdb = null)
{
StringBuilder sb = new StringBuilder();
sb.Append("UPDATE deck SET ")
.Append("id = ")
.Append(entity.Id)
.Append(",")
.Append("display_name = ")
.Append("'")
.Append(entity.DisplayName)
.Append("'")
.Append(",")
.Append("character1 = ")
.Append(entity.Character1)
.Append(",")
.Append("character2 = ")
.Append(entity.Character2)
.Append(",")
.Append("character3 = ")
.Append(entity.Character3)
.Append(",")
.Append("leader = ")
.Append(entity.Leader)
.Append(" WHERE id = ")
.Append(entity.Id)
.Append(";");
if (mdb == null)
{
DbManager.Instance.ExecuteNonQuery(sb.ToString());
}
else
{
DbManager.Instance.ExecuteNonQuery(sb.ToString(), mdb);
}
}
public async Task <bool> UpdateDeckTitleAsync(Guid deckId, string title)
{
var deck = await deckRepository.FindByIdAsync(deckId);
if (deck == null)
{
return(false);
}
var updatedDeck = new DeckEntity(deck.Id, deck.UserId, title);
var result = await deckRepository.UpdateAsync(updatedDeck);
return(result != null);
}
public async Task <Guid?> AddDeckAsync(Guid userId)
{
var emptyDeck = new DeckEntity(userId, "");
var deck = await deckRepository.InsertAsync(emptyDeck);
if (deck == null)
{
return(null);
}
var cardId = await AddCardAsync(deck.Id);
return(cardId != null ? deck?.Id : null);
}
public async Task <AddDeckPayload> AddDeckAsync(
AddDeckInput input,
[Service] MtgDbContext context)
{
var deck = new DeckEntity
{
Id = Guid.NewGuid(),
UserId = input.UserId,
Name = input.Name,
};
await context.Decks.AddAsync(deck);
await context.SaveChangesAsync();
return(new AddDeckPayload(input.ClientMutationId, deck));
}
public void Insert(DeckEntity entity, SqliteDatabase mdb = null)
{
StringBuilder sb = new StringBuilder();
sb.Append("INSERT INTO deck VALUES (")
.Append(entity.Id)
.Append(",")
.Append("'")
.Append(entity.DisplayName)
.Append("'")
.Append(",")
.Append(entity.Character1)
.Append(",")
.Append(entity.Character2)
.Append(",")
.Append(entity.Character3)
.Append(",")
.Append(entity.Leader)
.Append(");");
if (mdb == null)
{
DbManager.Instance.ExecuteNonQuery(sb.ToString());
}
else
{
DbManager.Instance.ExecuteNonQuery(sb.ToString(), mdb);
}
}
//[Property(DisplayName = "Submitting default FollowDeckCommand _ displays validation error", Arbitrary = new[] { typeof(FollowButtonTestsArb) })]
public bool _1(UserClaims userClaims, DeckWithFollowMeta deckWithFollowMeta, DeckEntity usersDefaultDeck)
{
Setup(Services, db => new UserEntity {
Id = userClaims.Id,
DefaultDeckId = usersDefaultDeck.Id,
Decks = new List <DeckEntity> {
usersDefaultDeck
}
}.Pipe(db.User.Add));
var counter = RenderComponent <FollowButtons>(
(nameof(FollowButtons.Deck), deckWithFollowMeta),
CascadingValue(Task.FromResult(userClaims))
);
counter.Find("form").Submit();
return("'New Deck Name' must not be empty." == counter.Find(".validation-message").TextContent);
}
private DeckEntity CreateEntity(DataRow row)
{
DeckEntity entity = new DeckEntity();
entity.Id = DaoSupport.GetIntValue(row, "id");
entity.DisplayName = DaoSupport.GetStringValue(row, "display_name");
entity.Character1 = DaoSupport.GetIntValue(row, "character1");
entity.Character2 = DaoSupport.GetIntValue(row, "character2");
entity.Character3 = DaoSupport.GetIntValue(row, "character3");
entity.Leader = DaoSupport.GetIntValue(row, "leader");
return(entity);
}
public async Task <DeckEntity> UpdateAsync(DeckEntity deck)
{
await _deckCollection.ReplaceOneAsync(d => d.Id == deck.Id, deck);
return(deck);
}
public async Task <DeckEntity> InsertAsync(DeckEntity deck)
{
await _deckCollection.InsertOneAsync(deck);
return(deck);
}
public AddDeckPayload(IReadOnlyList <UserError> errors, string?clientMutationId, DeckEntity deck)
: base(errors, clientMutationId)
{
Deck = deck;
}
public AddDeckPayload(string?clientMutationId, DeckEntity deck)
: base(clientMutationId)
{
Deck = deck;
}
