public IHttpActionResult Post([FromBody] DeckDto deck)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
User user;
if (!TryGetUser(out user))
{
return(BadRequest());
}
var newDeck = DeckDtoToDeck(deck);
newDeck.IsPrimaryDeck = !user.Decks.Any();
try
{
ValidateDeck(newDeck);
}
catch (InvalidDeckException e)
{
return(BadRequest(e.Message));
}
user.Decks.Add(newDeck);
Context.SaveChanges();
return(Ok(newDeck.ToDto()));
}
public async Task <IActionResult> Join(long id = 1)
{
var user = await this.GetCurrentUser();
System.Console.WriteLine($"Fetching presentation {id}");
var presentation = await retrievePresentationToViewQuery.Fetch(id);
long conversationId = presentation.ConversationId;
System.Console.WriteLine($"Fetching conversation {conversationId}");
var conversation = await conversations.GetConversation(conversationId);
var conversationDto = new ConversationDto {
Id = conversation.Id,
Topic = conversation.Topic,
CreatedAt = conversation.CreatedAt,
CreatedBy = conversation.CreatedBy.Name,
CurrentUserIsMod = await CurrentUserIsMod(user, conversationId),
Schema = currentSchema.Name
};
var viewModel = new DeckDto
{
Presentation = presentation,
Conversation = conversationDto
};
return(View(viewModel));
}
private Deck DeckDtoToDeck(DeckDto deck)
{
Deck newDeck = new Deck
{
BattleKingCard = Context.Cards.Find(deck.BattleKingCard).ToDeckCard(),
Faction = deck.Faction,
Cards = deck.Cards.Select(id => Context.Cards.Find(id).ToDeckCard()).ToList()
};
return(newDeck);
}
public async Task <IActionResult> AddDeck([FromBody] DeckDto deck)
{
try
{
await _deckService.AddItem(GetUserName(), deck);
}
catch (Exception e)
{
return(BadRequest(e));
}
return(Ok());
}
public IActionResult UpdateDeck([FromBody] DeckDto deck)
{
try
{
_deckService.UpdateItem(deck);
}
catch (Exception e)
{
return(BadRequest(e));
}
return(Ok());
}
/// <summary>
/// This routine essentially replaces the manual Dto mapping in the handlers. Database storage details can be managed here.
/// </summary>
/// <param name="writer"></param>
/// <param name="value"></param>
/// <param name="serializer"></param>
public override void WriteJson(JsonWriter writer, Deck value, JsonSerializer serializer)
{
IReadOnlyList <PlayingCard> cards = value.ShowCards();
var cardDtos = cards.Select(x => new CardDto()
{
Id = x.Id.ToString(),
Rank = x.Template.Rank,
Suit = x.Template.Suit,
CardTemplateId = string.Format(IdConventions.CardTemplateIdFormatString, x.Template.Rank.Name, x.Template.Suit.Name) // todo: reuse the existing Func
//CardTemplateId = x.CardTemplateId
}).ToArray();
var deckDto = new DeckDto()
{
Id = value.Id,
Cards = cardDtos,
};
JObject obj = JObject.FromObject(deckDto);
string debug = obj.ToString();
obj.WriteTo(writer);
}
public IHttpActionResult Put(int userId, int deckId, [FromBody] DeckDto deck)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
User user = Context.Users.Find(userId);
if (user == null)
{
return(NotFound());
}
Deck existingDeck = user.Decks.ElementAtOrDefault(deckId);
if (existingDeck == null)
{
return(NotFound());
}
var newDeck = DeckDtoToDeck(deck);
try
{
ValidateDeck(newDeck);
}
catch (InvalidDeckException e)
{
return(BadRequest(e.Message));
}
existingDeck.BattleKingCard = newDeck.BattleKingCard;
existingDeck.Cards.Clear();
existingDeck.Cards.AddRange(newDeck.Cards);
existingDeck.Faction = newDeck.Faction;
Context.SaveChanges();
return(Ok());
}
public static DeckResponse FromDeckInfo(
DeckTrackedDetails deckInfo,
UtilManaCurve utilManaCurve,
IMapper mapper)
{
var hCards = new Dictionary <bool, HashSet <string> >
{
{ true, new HashSet <string>() },
{ false, new HashSet <string>() },
};
var cards = new List <(bool IsSideboard, DeckCardDto Card)>();
foreach (var i in deckInfo.Deck.Cards.All
.OrderBy(i => i.Card.type.Contains("Land") ? 0 : 1)
.ThenBy(i => i.Card.GetSimpleType())
.ThenBy(i => i.Card.cmc)
.ThenBy(i => i.Card.name))
{
//if (i.Card.name.StartsWith("Treasure"))
// System.Diagnostics.Debugger.Break();
var info = (
i.Zone == DeckCardZoneEnum.Sideboard,
//new DeckCardDto
//{
// Name = i.Card.name,
// ImageCardUrl = i.Card.imageCardUrl,//.images["normal"],
// //ImageArtUrl = i.Card.imageArtUrl,//.images["normal"],
// Rarity = i.Card.GetRarityEnum(false).ToString(),
// Type = i.Card.GetSimpleType(),
// Amount = i.Amount,
// NbMissing =
// hCards[i.IsSideboard].Contains(i.Card.name) ? 0 : (deckInfo.CardsRequired.ByCard.ContainsKey(i.Card) ?
// (i.IsSideboard ? deckInfo.CardsRequired.ByCard[i.Card].NbMissingSideboard : deckInfo.CardsRequired.ByCard[i.Card].NbMissingMain) : 0),
//}
mapper.Map <DeckCardDto>(i)
);
info.Item2.NbMissing =
hCards[i.Zone == DeckCardZoneEnum.Sideboard].Contains(i.Card.name) ? 0 : (deckInfo.CardsRequired.ByCard.ContainsKey(i.Card.name) ?
(i.Zone == DeckCardZoneEnum.Sideboard ? deckInfo.CardsRequired.ByCard[i.Card.name].NbMissingSideboard : deckInfo.CardsRequired.ByCard[i.Card.name].NbMissingMain) : 0);
//if (i.Card.name.Contains("Guildgate"))
// System.Diagnostics.Debugger.Break();
if (hCards[i.Zone == DeckCardZoneEnum.Sideboard].Contains(i.Card.name) == false)
{
hCards[i.Zone == DeckCardZoneEnum.Sideboard].Add(i.Card.name);
}
cards.Add(info);
}
var compareResults = deckInfo.CompareResult.GetModelSummary()
.Select(i => new DeckCompareResultDto
{
Set = i.Key,
NbMissing = i.Value.Sum(x => x.NbMissing),
MissingWeightTotal = i.Value.Sum(x => x.MissingWeight),
})
.OrderByDescending(i => i.MissingWeightTotal)
.ThenByDescending(i => i.NbMissing)
.ToArray();
var deck = new DeckDto
{
OriginalDeckId = deckInfo.OriginalDeckId,
Id = deckInfo.Deck.Id,
Hash = Fnv1aHasher.To32BitFnv1aHash(deckInfo.OriginalDeckId),
Name = deckInfo.Deck.Name,
Url = deckInfo.Config.Url,
ScraperTypeId = deckInfo.Deck.ScraperType.Id,
CardsMain = cards.Where(i => i.IsSideboard == false).Select(i => i.Card).ToArray(),
CardsSideboard = cards.Where(i => i.IsSideboard).Select(i => i.Card).ToArray(),
MtgaImportFormat = deckInfo.MtgaImportFormat,
CompareResults = compareResults,
ManaCurve = utilManaCurve.CalculateManaCurve(deckInfo.Deck.Cards.QuickCardsMain.Values
.Cast <CardWithAmount>().ToArray())
};
if (deckInfo.Deck is DeckAverageArchetype archetype)
{
throw new Exception("TO REVISE");
deck.CardsMainOther = archetype.CardsMainOther.Select(i => new DeckCardDto
{
Name = i.name,
Rarity = i.GetRarityEnum(false).ToString(),
Type = i.GetSimpleType(),
NbMissing = i.NbMissing,
ImageCardUrl = i.imageCardUrl,//.images["normal"]
//ImageArtUrl = i.imageArtUrl,//.images["normal"]
}).ToArray();
}
return(new DeckResponse(deck));
}
public DeckResponse(DeckDto deck)
{
Deck = deck;
}
