private async Task ApplyFilters()
{
if (AllCards != null && !_suspendFilters)
{
var filtered =
from c in AllCards
where (!FilteredByFaction || (FactionFilter != Faction.UNALIGNED && c.ValidFactions.Contains(FactionFilter) && c.ValidFactions.Count() != FACTION_COUNT) ||
(FactionFilter == Faction.UNALIGNED && c.Faction == Faction.UNALIGNED && c.ValidFactions.Count() == FACTION_COUNT)) &&
(!FilteredByType || c.Type == TypeFilter) &&
(CostFilter == MAX_COSTS_FILTER || ((CostFilter == MAX_COSTS_FILTER - 1 && c.Cost >= CostFilter) || c.Cost == CostFilter)) &&
(RarityFilter == 0 || (int)c.Rarity == RarityFilter) &&
((TraitFilter == null || !TraitFilter.Any()) || TraitFilter.Intersect(c.Traits).Any()) &&
(CurrentDeck == null || !FilterByDeck || CurrentDeck.Contains(c) || CurrentDeck.Champion == c) &&
(string.IsNullOrEmpty(CardSetFilter) || CardSetFilter == _CARD_SET_FILTER_DEFAULT || c.CardSet == (CardSet)Enum.Parse(typeof(CardSet), CardSetFilter)) &&
(string.IsNullOrEmpty(SearchText) ||
c.Text.ToLower().Contains(SearchText.ToLower()) ||
c.Name.ToLower().Contains(SearchText.ToLower()) ||
c.Race.ToString().ToLower().Contains(SearchText.ToLower()) ||
SearchText.ToUpper().Contains(c.CardSet.ToString()))
orderby c.Rarity == Rarity.TOKEN, c.Type == CardType.CHAMPION descending, c.Faction descending, c.Cost, c.Name
select c;
IsBusy = true;
var newList = await Task.Run(() => filtered.ToList());
FilteredCards = newList;
IsBusy = false;
UpdateStatus();
ResetFiltersCommand.RaiseCanExecuteChanged();
}
}
protected virtual async Task <List <Trait> > GetAllTraits()
{
var filter = new TraitFilter();
var results = await _traitRepository.SearchAsync(filter);
return(results.ToList());
}
public async Task <IActionResult> Get([FromBody] TraitFilter filter)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var traits = await _traitRepository.SearchAsync(filter);
return(Ok(_mapper.Map <List <TraitDto> >(traits)));
}
public async Task <IEnumerable <Trait> > SearchAsync(TraitFilter filter)
{
var query = entities.AsQueryable();
if (filter.AnimalTypeId.HasValue)
{
query = query.Where(t => t.AnimalTypeId == filter.AnimalTypeId);
}
if (!string.IsNullOrWhiteSpace(filter.TraitName))
{
query = query.Where(t => t.Name.Contains(filter.TraitName));
}
query = base.SearchAsync(query, filter);
return(await query.ToListAsync());
}
public async Task <IActionResult> Post(PetDto pet)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var petToInsert = new Pet
{
Name = pet.Name,
Gender = pet.Gender,
Birthday = pet.Birthday,
Description = pet.Description,
Source = pet.Source,
SourceLink = pet.SourceLink,
AnimalTypeId = pet.AnimalTypeId,
UserId = pet.UserId
};
petToInsert.MetaFileLinks = new List <MetaFileLink>();
foreach (var mflId in pet.MetaFileLinkIds)
{
MetaFileLink mfl = _mflRepository.GetByIdAsync(mflId).Result;
petToInsert.MetaFileLinks.Add(mfl);
}
var traitsFilter = new TraitFilter
{
AnimalTypeId = pet.AnimalTypeId
};
//get list of all traits by AnimalTypeId
List <Trait> traitsByAnimal = _traitRepository.SearchAsync(traitsFilter).Result.ToList();
petToInsert.PetTraits = new List <PetTrait>();
foreach (KeyValuePair <string, string> entry in pet.Traits)
{
//Use entry.Value & entry.Key
var foundTrait = traitsByAnimal.FirstOrDefault(traitItem => traitItem.Id == int.Parse(entry.Key));
var foundTraitOption = foundTrait.TraitOptions.FirstOrDefault(op => op.Id == int.Parse(entry.Value));
petToInsert.PetTraits.Add(
new PetTrait
{
Trait = foundTrait,
TraitOption = foundTraitOption
});
}
await _petHandler.AddPet(petToInsert);
await _unitOfWork.SaveChangesAsync();
return(Ok(_mapper.Map <PetDto>(petToInsert)));
}
catch (Exception ex)
{
return(BadRequest());
}
}
