public async Task <IActionResult> UpdateDeck([FromRoute] int id, [FromBody] DeckDTO deckDTO)
{
if (!ModelState.IsValid)
{
_logger.LogError("ModelState is invalid in the UpdateDeck() method");
return(BadRequest(ModelState));
}
var deck = await _context.Decks.FindAsync(id);
if (deck == null)
{
_logger.LogWarning("Deck not found in the UpdateDeck({0}) method", id);
return(NotFound());
}
deck.Name = deckDTO.Name;
deck.Content = deckDTO.Content;
deck.Module = deckDTO.Module;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) when(!DeckExists(id))
{
return(NotFound());
}
_logger.LogInformation("Updating deck in the UpdateDeck({0}) method", id);
return(NoContent());
}
public async Task UpdateDeck_UnknownIdPassed_ReturnsNotFound()
{
// Arrange
var controller = new DecksController(flashcardDbContextMock.Object, orderService, logger);
int unknownId = 15;
var rightDeck = new DeckDTO
{
Name = "Uj csomag neve",
Content = "Uj Teszt csomag tartalma",
Module = Module.B,
Deck_number = 3,
ApplicationUser = new ApplicationUserDTO
{
Id = "268e543e-2020-ue63-a111-98321798c21",
Email = "*****@*****.**",
Name = "Teszt User 2",
Phone = "063012345672",
Workplace = "Teszt kornyezet2",
Create_module = Module.E,
Will_create_module = Module.F,
Activated = true
}
};
// Act
var result = await controller.UpdateDeck(unknownId, rightDeck);
// Asssert
Assert.IsType <NotFoundResult>(result);
}
public async Task CreateDeck_InvalidObjectPassed_ReturnsBadRequest()
{
// Arrange
var controller = new DecksController(flashcardDbContextMock.Object, orderService, logger);
var nameMissingDeck = new DeckDTO
{
Content = "Uj Teszt csomag tartalma",
Module = Module.B,
Deck_number = 3,
ApplicationUser = new ApplicationUserDTO
{
Id = "268e543e-2020-ue63-a111-98321798c21",
Email = "*****@*****.**",
Name = "Teszt User 2",
Phone = "063012345672",
Workplace = "Teszt kornyezet2",
Create_module = Module.E,
Will_create_module = Module.F,
Activated = true
}
};
controller.ModelState.AddModelError("Name", "Required");
// Act
var result = await controller.CreateDeck(nameMissingDeck);
// Asssert
Assert.IsType <BadRequestObjectResult>(result.Result);
}
public async Task <ActionResult <DeckDTO> > CreateDeck([FromBody] DeckDTO deckDTO)
{
if (!ModelState.IsValid)
{
_logger.LogError("ModelState is invalid in the CreateDeck() method");
return(BadRequest(ModelState));
}
var deck = new Deck
{
Name = deckDTO.Name,
Content = deckDTO.Content,
Module = deckDTO.Module,
Deck_number = deckDTO.Deck_number,
Activated = false,
Status = DeckStatus.Initial,
ApplicationUserId = deckDTO.ApplicationUser.Id
};
_context.Decks.Add(deck);
await _context.SaveChangesAsync();
_logger.LogInformation("Creating deck in the CreateDeck() method");
return(CreatedAtAction(nameof(GetDeck), new { id = deck.Id }, deck));
}
public IHttpActionResult GetCardsForSubscribedDeck(string deckLink, int numberOfCards, string userLogin)
{
try
{
DeckDTO currentDeck = moderation.FindDeckByLinking(deckLink);
IEnumerable <Statistics> deckStatistics = statistics.GetDeckStatistics(userLogin, currentDeck.Id);
if (numberOfCards > deckStatistics.Count())
{
numberOfCards = deckStatistics.Count();
}
List <CardDTO> cards = quiz.GetCardsForSubscription(numberOfCards, deckStatistics);
return(Ok(cards));
}
catch (ArgumentNullException ex)
{
var message = $"Deck with name = {deckLink} not found. {ex.Message}";
return(BadRequest(message));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
private Deck FromDTO(DeckDTO deck) => new Deck
{
OwnerId = deck.OwnerId,
CardId = deck.CardId,
Playable = deck.Playable,
Available = deck.Available
};
public ActionResult <DeckDTO> CreateDeck(DeckDTO deck)
{
_context.Decks.Add(deck);
_context.SaveChanges();
return(CreatedAtAction("GetDeck", new CardDTO {
Id = deck.Id
}, deck));
}
public static model.Deck DeckDTOToDeckEntity(this DeckDTO deck)
{
var config = new MapperConfiguration(cfg => {
cfg.CreateMap <DeckDTO, model.Deck>();
cfg.CreateMap <GameDTO, model.Game>();
});
IMapper iMapper = config.CreateMapper();
return(iMapper.Map <DeckDTO, model.Deck>(deck));
}
public DeckDTO DecodeDeck(DeckDTO deck)
{
deck.Name = Encoding.UTF8.GetString(
Convert.FromBase64String(deck.Name));
deck.Linking = Encoding.UTF8.GetString(
Convert.FromBase64String(deck.Linking));
deck.Description = Encoding.UTF8.GetString(
Convert.FromBase64String(deck.Description));
return(deck);
}
public Deck ConvertToDeck(DeckDTO deckDTO)
{
return(new Deck
{
Id = deckDTO.Id,
Name = deckDTO.Name,
Linking = deckDTO.Linking,
Price = deckDTO.Price,
Description = deckDTO.Description
});
}
private GameDTO DrawCard(GameDTO game)
{
DeckDTO pickableDeck = game.connectedPlayers[1].deck;
int cardId = rnd.Next(0, pickableDeck.cards.cards.Count());
CardDTO card = pickableDeck.cards.cards[cardId];
if (CanDraw(game))
{
pickableDeck.cards.cards.RemoveAt(cardId);
game.connectedPlayers[1].cardsInHand.Add(card);
game.connectedPlayers[1].cardsInDeck = pickableDeck.cards.cards;
return(game);
}
//send error function "Your hand is full!"
return(game);
}
protected void handleMonsterFor(DeckDTO deck, Card card, string lowerCardType)
{
handleXYZPendulumMonster(deck, card, lowerCardType);
handlePendulumSynchroMonster(deck, card, lowerCardType);
handlePendulumFusionMonster(deck, card, lowerCardType);
handleXYZMonster(deck, card, lowerCardType);
handleSynchroMonster(deck, card, lowerCardType);
handleFusionMonster(deck, card, lowerCardType);
handleLinkMonster(deck, card, lowerCardType);
handleNonExtraPendulumNormalMonster(deck, card, lowerCardType);
handleNonExtraPendulumEffectMonster(deck, card, lowerCardType);
handleRitualMonster(deck, card, lowerCardType);
handleEffectMonster(deck, card, lowerCardType);
handleNormalMonster(deck, card, lowerCardType);
}
public Deck FindDeckAndUpdateValues(DeckDTO deckDTO)
{
Deck deck = moderation.GetDeck(deckDTO.Id);
deck.Name = deckDTO.Name;
deck.Linking = deckDTO.Linking;
deck.Description = deckDTO.Description;
deck.Price = deckDTO.Price;
deck.Photo = deckDTO.Photo;
Category category = moderation.FindCategoryByName(deckDTO.CategoryName);
deck.Category = category;
return(deck);
}
public IHttpActionResult UpdateDeck(DeckDTO deckDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
Deck deck = moderation.FindDeckAndUpdateValues(deckDTO);
moderation.UpdateDeck(deck);
return(Ok(deckDTO));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IHttpActionResult GetDeckByLinking(string linking)
{
try
{
DeckDTO deck = catalog.GetDeckDTO(linking);
// PhotoUrlLoader.LoadDecksPhotos(deck);
return(Ok(deck));
}
catch (ArgumentNullException ex)
{
var message = $"DEck with linking = {linking} not found. {ex.Message}";
return(BadRequest(message));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
/// <inheritdoc />
public DeckDTO CreateDeckDto(IEnumerable <Card> cards)
{
var deck = new DeckDTO();
foreach (var card in cards)
{
var lowerCardType = card.Type.ToLower();
if (lowerCardType.Contains("monster"))
{
handleMonsterFor(deck, card, lowerCardType);
}
else
{
handleTraps(deck, card, lowerCardType);
handleSpells(deck, card, lowerCardType);
}
}
return(deck);
}
public IHttpActionResult CreateDeck(DeckDTO deckDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
Deck deck = converter.ConvertToDeck(deckDTO);
deck.Category = moderation
.FindCategoryByName(deckDTO.CategoryName);
moderation.CreateDeck(deck);
return(Ok(moderation.FindDeckDTOByName(deckDTO.Name)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult <DeckDTO> GetDeck(int id)
{
var deck = _context.Decks.Find(id);
if (deck == null)
{
return(NotFound());
}
DeckDTO deckDTO = new DeckDTO
{
Id = deck.Id,
Name = deck.Name,
Description = deck.Description,
Cards = deck.Cards
};
return(deckDTO);
}
/// <inheritdoc />
public DeckDTO CreateDeckDto(Decklist decklist)
{
var deck = new DeckDTO();
foreach (var card in decklist.SideDeck)
{
var lowerCardType = card.Type.ToLower();
if (lowerCardType.Contains("monster"))
{
handleMonsterFor(deck, card, lowerCardType);
}
else
{
handleTraps(deck, card, lowerCardType);
handleSpells(deck, card, lowerCardType);
}
}
return(deck);
}
public IHttpActionResult PostSaveDeck([FromBody] DeckDTO deck)
{
if (deck.Id == 0)
{
//when the front-end sends no new ID, this creates a new deck
var newDeck = new Deck();
newDeck.Id = deck.Id;
newDeck.Name = deck.Name;
newDeck.IsActive = deck.IsActive;
newDeck.UserId = deck.UserId;
database.Decks.Add(newDeck);
}
else
{
//when the front-end sends an ID, this section is updatng an old deck
var existingDeck = database.Decks.SingleOrDefault(x => x.Id == deck.Id);
existingDeck.Name = deck.Name;
existingDeck.IsActive = deck.IsActive;
existingDeck.UserId = deck.UserId;
}
database.SaveChanges();
return(Ok());
}
public IHttpActionResult PostSaveDeck([FromBody] DeckDTO deck)
{
if (deck.Id == 0)
{
//new deck
var newDeck = new Deck();
newDeck.Id = deck.Id;
newDeck.Name = deck.Name;
newDeck.IsActive = deck.IsActive;
newDeck.UserId = deck.UserId;
database.Decks.Add(newDeck);
}
else
{
//updating existing deck
var existingDeck = database.Decks.SingleOrDefault(x => x.Id == deck.Id);
existingDeck.Name = deck.Name;
existingDeck.UserId = deck.UserId;
existingDeck.IsActive = deck.IsActive;
}
database.SaveChanges();
return(Ok());
}
// POST: api/Deck
public void Post([FromBody] DeckDTO value)
{
this._deckService.AddDeck(value);
}
public void AddDeck(DeckDTO deck)
{
this._deckProvider.Insert(deck.DeckDTOToDeckEntity());
}
private IDeck MapDeckFromDTO(DeckDTO deck)
{
return(new DeckEntity(deck.Name, deck.Cards.Select(
c => MapCardFromDTO(c)).ToList()));
}
