/// <summary>
/// получить все масти
/// </summary>
/// <returns></returns>
public async Task <List <Suit> > GetAllSuits()
{
using (var db = new DeckContext())
{
return(db.Suits.OrderBy(x => x.Title).ToList());
}
}
/// <summary>
/// получить все значения
/// </summary>
/// <returns></returns>
public async Task <List <Value> > GetAllValues()
{
using (var db = new DeckContext())
{
return(db.Values.OrderBy(x => x.Title).ToList());
}
}
private static Deck SaveDecktoDatabase(DeckContext context, Deck updatedDeck)
{
var savedDetails = updatedDeck;
if (updatedDeck.DeckId == -1)
#region Insert new deck
{
var newDeck = JsonConvert.DeserializeObject <Deck>(JsonConvert.SerializeObject(savedDetails));
newDeck.DeckId = 0;
newDeck.DeckCards.Clear();
context.Add(newDeck);
savedDetails = newDeck;
}
#endregion
else
#region Update Deck
{
savedDetails = context.Decks.First(g => g.DeckId == updatedDeck.DeckId);
}
#endregion
savedDetails.Description = updatedDeck.Description;
savedDetails.Name = updatedDeck.Name;
return(savedDetails);
}
/// <summary>
/// получить масть по ид
/// </summary>
/// <param name="id">ид масти</param>
/// <returns></returns>
public async Task <Suit> GetSuitById(long id)
{
using (var db = new DeckContext())
{
return(await db.Suits.FindAsync(id));
}
}
/// <summary>
/// создание колоды
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <Deck> CreateDeck(CreateDeckRequest request)
{
using (var db = new DeckContext())
{
var result = new Deck();
var exist = db.Decks.FirstOrDefault(x => x.Title.ToLower() == request.Title.ToLower());
if (exist != null)
{
throw new Exception($"deck with title {request.Title} exist");
}
var cardsToDeck = string.Empty;
if (request.Cards.Any())
{
var selectedCards = request.Cards.Where(x => x.IsEnabled).OrderBy(x => x.SuitTitle).ThenBy(x => x.ValueTitle).ToList();
var cardsIds = selectedCards.Select(x => x.Id).ToList();
cardsToDeck = cardsIds.SerializeToJson();
}
else
{
cardsToDeck = new List <long>().SerializeToJson();
}
db.Decks.Add(new Deck()
{
Title = request.Title,
CardsIds = cardsToDeck,
DateModify = DateTime.UtcNow
});
await db.SaveChangesAsync();
return(result);
}
}
/// <summary>
/// удаление карты
/// </summary>
/// <param name="id">ид карты</param>
/// <returns></returns>
public async Task DeleteCard(long id)
{
using (var db = new DeckContext())
{
var exist = await db.Cards.FindAsync(id);
if (exist != null)
{
var decks = db.Decks.ToList();
foreach (var deck in decks)
{
var cardsIds = new JsonSerializer().Deserialize <List <long> >
(new JsonTextReader
(new StringReader(deck.CardsIds)));
if (cardsIds.Contains(exist.Id))
{
cardsIds.Remove(exist.Id);
deck.CardsIds = cardsIds.SerializeToJson();
}
}
db.Cards.Remove(exist);
await db.SaveChangesAsync();
}
}
}
/// <summary>
/// получить значение по ид
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <Value> GetValueById(long id)
{
using (var db = new DeckContext())
{
return(await db.Values.FindAsync(id));
}
}
/// <summary>
/// удалить доску
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task DeleteDeck(long id)
{
using (var db = new DeckContext())
{
var exist = await db.Decks.FindAsync(id);
if (exist != null)
{
db.Decks.Remove(exist);
await db.SaveChangesAsync();
}
}
}
/// <summary>
/// сохранить новый порядок карт
/// </summary>
/// <param name="deck"></param>
/// <returns></returns>
private async Task SaveMixingDeck(DeckDetailResponse deck)
{
using (var db = new DeckContext())
{
var exist = await db.Decks.FindAsync(deck.Id);
if (exist != null)
{
exist.CardsIds = deck.CardsIds;
exist.DateModify = DateTime.UtcNow;
await db.SaveChangesAsync();
}
}
}
/// <summary>
/// изменить значение
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public async Task <Value> EditValue(Value value)
{
using (var db = new DeckContext())
{
var exist = await db.Values.FindAsync(value.Id);
if (exist != null && exist.Title != value.Title)
{
exist.Title = value.Title;
await db.SaveChangesAsync();
}
return(exist);
}
}
/// <summary>
/// создать значение
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task CreateValue(CreateValueRequest request)
{
using (var db = new DeckContext())
{
var exist = db.Values.FirstOrDefault(x => x.Title.ToLower() == request.Title.ToLower());
if (exist != null)
{
throw new Exception($"value with title {request.Title} exist");
}
db.Values.Add(new Value {
Title = request.Title
});
await db.SaveChangesAsync();
}
}
/// <summary>
/// изменить масть
/// </summary>
/// <param name="suit"></param>
/// <returns></returns>
public async Task <Suit> EditSuit(Suit suit)
{
using (var db = new DeckContext())
{
var exist = await db.Suits.FindAsync(suit.Id);
if (exist != null && exist.Title != suit.Title)
{
exist.Title = suit.Title;
await db.SaveChangesAsync();
}
return(exist);
}
}
/// <summary>
/// создание карты
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task CreateCard(CreateCardRequest request)
{
using (var db = new DeckContext())
{
if (long.TryParse(request.SelectedSuitId.ToString(), out long suitId) &&
suitId > 0 &&
long.TryParse(request.SelectedValueId.ToString(), out long valueId) &&
valueId > 0)
{
db.Cards.Add(new Card {
SuitId = suitId, ValueId = valueId
});
await db.SaveChangesAsync();
}
}
}
public static void SaveDeckCards(DeckContext context, int deckId, List <DeckCard> existing, List <DeckCard> updated)
{
updated.ForEach(c => c.DeckId = deckId);
var itemsToAdd = updated.Where(d => !existing.Any(c => c.DeckId == d.DeckId && c.CardId == d.CardId));
var itemsToUpdate = existing.Where(d => updated.Any(c => c.DeckId == d.DeckId && c.CardId == d.CardId));
var itemsToRemove = existing.Where(d => !updated.Any(c => c.DeckId == d.DeckId && c.CardId == d.CardId));
foreach (var update in itemsToUpdate)
{
context.Entry(update).CurrentValues
.SetValues(updated.Where(d => d.DeckId == update.DeckId && d.CardId == update.CardId).SingleOrDefault());
}
context.DeckCard.RemoveRange(itemsToRemove);
context.DeckCard.AddRange(itemsToAdd);
}
/// <summary>
/// получить карту по ид
/// </summary>
/// <param name="id">ид карты</param>
/// <returns></returns>
public async Task <CardResponse> GetCardById(long id)
{
using (var db = new DeckContext())
{
var card = await db.Cards.FindAsync(id);
var value = await _valueService.GetValueById(card.ValueId);
var suit = await _suitService.GetSuitById(card.SuitId);
var response = card.Transform <CardResponse>();
response.ValueTitle = value.Title;
response.SuitTitle = suit.Title;
return(response);
}
}
/// <summary>
/// получить все доски
/// </summary>
/// <returns></returns>
public async Task <List <DeckResponse> > GetAllDecks()
{
using (var db = new DeckContext())
{
var decks = db.Decks.ToList();
var resp = decks.Select(x => x.Transform <DeckResponse>()).OrderByDescending(x => x.DateModify).ToList();
foreach (var deck in resp)
{
var cardsIds = new JsonSerializer().Deserialize <List <long> >
(new JsonTextReader
(new StringReader(deck.CardsIds)));
deck.Count = cardsIds.Count;
}
return(resp);
}
}
/// <summary>
/// список карт
/// </summary>
/// <returns></returns>
public async Task <List <CardResponse> > GetAllCards()
{
using (var db = new DeckContext())
{
var cards = db.Cards.ToList();
var valuesIds = cards.Select(c => c.ValueId).Distinct().ToList();
var values = db.Values.Where(x => valuesIds.Contains(x.Id)).ToList();
var suitsIds = cards.Select(c => c.SuitId).Distinct().ToList();
var suits = db.Suits.Where(x => suitsIds.Contains(x.Id)).ToList();
var response = new List <CardResponse>();
foreach (var card in cards)
{
var cardResponse = card.Transform <CardResponse>();
cardResponse.ValueTitle = values.FirstOrDefault(x => x.Id == card.ValueId)?.Title;
cardResponse.SuitTitle = suits.FirstOrDefault(x => x.Id == card.SuitId)?.Title;
response.Add(cardResponse);
}
return(response.OrderBy(x => x.SuitTitle).ThenBy(x => x.ValueTitle).ToList());
}
}
/// <summary>
/// получить детально колоду по ид
/// </summary>
/// <param name="id">ид колоды</param>
/// <returns></returns>
public async Task <DeckDetailResponse> GetDeckDetailById(long id)
{
using (var db = new DeckContext())
{
var deck = await db.Decks.FindAsync(id);
var response = deck.Transform <DeckDetailResponse>();
var cardsIds = new JsonSerializer().Deserialize <List <long> >
(new JsonTextReader
(new StringReader(deck.CardsIds)));
response.Count = cardsIds.Count;
foreach (var cardId in cardsIds)
{
var cardResp = await _cardService.GetCardById(cardId);
response.Cards.Add(cardResp);
}
return(response);
}
}
/// <summary>
/// удалить значение
/// </summary>
/// <param name="id">ид значения</param>
/// <returns></returns>
public async Task DeleteValue(long id)
{
using (var db = new DeckContext())
{
var exist = await db.Values.FindAsync(id);
if (exist != null)
{
var cards = db.Cards.ToList();
foreach (var card in cards)
{
if (card.ValueId == id)
{
var cardService = new CardService();
await cardService.DeleteCard(card.Id);
}
}
db.Values.Remove(exist);
await db.SaveChangesAsync();
}
}
}
public DecksController(DeckContext context)
{
_context = context;
}
