Esempio n. 1
0
        public async Task <CardSearchResultOutputModel> Handle(CardSearchQuery request, CancellationToken cancellationToken)
        {
            var response = new CardSearchResultOutputModel();

            var searchCriteria = new CardSearchCriteria
            {
                BanlistId     = request.BanlistId,
                LimitId       = request.LimitId,
                CategoryId    = request.CategoryId,
                SubCategoryId = request.SubCategoryId,
                AttributeId   = request.AttributeId,
                TypeId        = request.TypeId,
                LvlRank       = request.LvlRank,
                Atk           = request.Atk,
                Def           = request.Def,
                SearchTerm    = request.SearchTerm,
                PageSize      = request.PageSize,
                PageIndex     = request.PageIndex
            };

            var searchResult = await _cardService.Search(searchCriteria);

            response.TotalRecords = searchResult.TotalRecords;
            response.Cards        = searchResult.Cards.Select(card => CardSearchMapperHelper.MapToCardOutputModel(_mapper, card)).ToList();

            return(response);
        }
        public void Given_An_Invalid_BanlistCardSearch_Should_Throw_ArgumentOutOfRangeException()
        {
            // Arrange
            var deckCardSearch = new BanlistCardSearch();

            // Act
            Action act = () => CardSearchMapperHelper.MapToCardOutputModel(_mapper, deckCardSearch);

            // Assert
            act.Should().Throw <ArgumentOutOfRangeException>();
        }
        public async Task <CardOutputModel> Handle(CardByNameQuery request, CancellationToken cancellationToken)
        {
            if (!string.IsNullOrWhiteSpace(request.Name))
            {
                var result = await _cardService.GetCardByName(request.Name);

                if (result != null)
                {
                    return(CardSearchMapperHelper.MapToCardOutputModel(_mapper, result));
                }
            }

            return(null);
        }
        public async Task <ArchetypeSearchOutputModel> Handle(ArchetypeByIdQuery request, CancellationToken cancellationToken)
        {
            var result = await _archetypeService.ArchetypeById(request.ArchetypeId);

            if (result == null)
            {
                return(null);
            }

            var response = ArchetypeSearchOutputModel.From(result.Archetype);

            response.Cards      = result.Cards.Select(card => CardSearchMapperHelper.MapToCardOutputModel(_mapper, card)).ToList();
            response.TotalCards = result.Cards.Count;

            return(response);
        }
        public async Task <LatestBanlistOutputModel> Handle(LatestBanlistQuery request, CancellationToken cancellationToken)
        {
            var response = new LatestBanlistOutputModel();

            var banlistCardSearchResult = await _banlistService.LatestBanlistByFormatAcronym(request.Format.ToString());

            if (banlistCardSearchResult.Cards.Any())
            {
                var groupedCards =
                    banlistCardSearchResult
                    .Cards
                    .GroupBy(c => c.Limit)
                    .Select(nc => nc)
                    .ToList();

                var forbiddenCards   = groupedCards.SingleOrDefault(grp => grp.Key == LimitConstants.Forbidden);
                var limnitCards      = groupedCards.SingleOrDefault(grp => grp.Key == LimitConstants.Limited);
                var semiLimitedCards = groupedCards.SingleOrDefault(grp => grp.Key == LimitConstants.SemiLimited);
                var unlimitedCards   = groupedCards.SingleOrDefault(grp => grp.Key == LimitConstants.Unlimited);

                response.Format      = request.Format.ToString().ToUpper();
                response.ReleaseDate = banlistCardSearchResult.ReleaseDate.ToString(BanlistConstants.ReleaseDateFormat);

                if (forbiddenCards != null)
                {
                    response.Forbidden = forbiddenCards.Select(card => CardSearchMapperHelper.MapToCardOutputModel(_mapper, card)).ToList();
                }

                if (limnitCards != null)
                {
                    response.Limited = limnitCards.Select(card => CardSearchMapperHelper.MapToCardOutputModel(_mapper, card)).ToList();
                }

                if (semiLimitedCards != null)
                {
                    response.SemiLimited = semiLimitedCards.Select(card => CardSearchMapperHelper.MapToCardOutputModel(_mapper, card)).ToList();
                }

                if (unlimitedCards != null)
                {
                    response.Unlimited = unlimitedCards.Select(card => CardSearchMapperHelper.MapToCardOutputModel(_mapper, card)).ToList();
                }
            }

            return(response);
        }
        public void Given_A_Trap_BanlistCardSearch_Should_Return_Monster_CardOutputModel()
        {
            // Arrange

            var deckCardDetail = new BanlistCardSearch
            {
                CategoryId    = 23424,
                Category      = "Trap",
                SubCategories = "Normal"
            };


            // Act
            var result = CardSearchMapperHelper.MapToCardOutputModel(_mapper, deckCardDetail);

            // Assert
            result.Types.Should().Contain("Trap");
        }
        public void Given_A_Monster_BanlistCardSearch_Should_Return_Monster_CardOutputModel()
        {
            // Arrange

            var deckCardDetail = new BanlistCardSearch
            {
                CategoryId    = 23424,
                Category      = "Monster",
                SubCategories = "Normal,Fairy",
                AttributeId   = 43,
                Attribute     = "Light",
                TypeId        = 234,
                Type          = "Ritual"
            };


            // Act
            var result = CardSearchMapperHelper.MapToCardOutputModel(_mapper, deckCardDetail);

            // Assert
            result.Types.Should().Contain("Monster");
        }