// Fills the array of cards with the retrieved data
        public void fillObservableCardArray(System.Collections.Generic.List <Business.Network.Cards.Models.Card> cardsList)
        {
            CardMapper cardMapper = new CardMapper();

            Cards = new ObservableCollection <DataModels.Card>();

            foreach (Business.Network.Cards.Models.Card item in cardsList)
            {
                DataModels.Card card = cardMapper.MapFrom(item);
                // For UI Update
                if (!AppServiceParameters.IsWithdrawalMBWayFunctionalityActive && card.CardInhibitionParameters != null)
                {
                    card.CardInhibitionParameters.IsAllowedToWithdrawalMBWAY = false;
                }
                Cards.Add(card);
            }

            if (SelectedIndexCard >= Cards.Count)
            {
                SelectedIndexCard = 0;
            }

            SelectedCard = Cards[SelectedIndexCard];

            checkAndSetAvailableSelectedCard();
        }
示例#2
0
        public static void InsertCard(CardApiDm cardApi, string setId)
        {
            using (var db = new MtgEntities())
            {
                try
                {
                    cardApi.Editions = cardApi.Editions.Where(e => e.Set_Id == setId).ToList();
                    var em = CardMapper.Map(cardApi);

                    if (db.Cards.Any(c => c.CardId == em.CardId))
                    {
                        foreach (var cardSet in em.CardSets.Where(s => !db.CardSets.Any(dbSet => dbSet.CardId == s.CardId && dbSet.SetId == s.SetId)))
                        {
                            db.CardSets.Add(cardSet);
                        }
                    }
                    else
                    {
                        db.Cards.Add(em);
                    }

                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"Unable to save the card '{cardApi.Name}' Excpetion:");
                    Console.WriteLine(e);
                    Console.WriteLine();
                    Console.ForegroundColor = ConsoleColor.White;
                }
            }
        }
示例#3
0
        public static IEnumerable <CardDm> QueryCards(string tribal, string name, bool?commader, List <string> colors, string type, string tag, int numberToReturn = -1)
        {
            using (var db = new MtgEntities())
            {
                var invalidColors = GetInvalidColors(colors);
                var white         = "";
                var blue          = "";
                var black         = "";
                var red           = "";
                var green         = "";

                foreach (var color in invalidColors)
                {
                    switch (color)
                    {
                    case "{W}":
                        white = color;
                        break;

                    case "{U}":
                        blue = color;
                        break;

                    case "{B}":
                        black = color;
                        break;

                    case "{R}":
                        red = color;
                        break;

                    case "{G}":
                        green = color;
                        break;
                    }
                }
                var takeNumber = numberToReturn > 0 ? numberToReturn : int.MaxValue;

                var cards = db.Cards.Where(c =>
                                           (tag == null || c.CardTags.Any(ct => ct.Tag.TagName == tag)) &&
                                           (tribal == null || c.SubTypes.ToLower().Contains(tribal) || c.RulesText.ToLower().Contains(tribal)) &&
                                           (commader == null || c.Types.Contains("Legendary")) &&
                                           (name == null || c.CardName.ToLower() == name.ToLower()) &&
                                           (white == "" || (!c.Cost.Contains(white) && !c.RulesText.Contains(white))) &&
                                           (blue == "" || (!c.Cost.Contains(blue) && !c.RulesText.Contains(blue))) &&
                                           (black == "" || (!c.Cost.Contains(black) && !c.RulesText.Contains(black))) &&
                                           (red == "" || (!c.Cost.Contains(red) && !c.RulesText.Contains(red))) &&
                                           (green == "" || (!c.Cost.Contains(green) && !c.RulesText.Contains(green))) &&
                                           //(colors == null || invalidColors.All(i => !c.Cost.Contains(i) && !c.RulesText.Contains(i))) && //Super Wish this wouldn't blow up.
                                           (type == null || c.Types.Contains(type))
                                           ).Take(takeNumber);

                foreach (var card in cards)
                {
                    yield return(CardMapper.Map(card));
                }
            }
        }
示例#4
0
        public void CardMapperMapsNullCardToEmptyCardDto()
        {
            var mapper = new CardMapper();

            var card = mapper.Map((Card)null);

            card.Should().NotBeNull();
            card.Should().BeEquivalentTo(CardDto.Empty);
        }
 public DeckManager(IDeckRepository deckRepository, ICardRepository cardRepository,
                    DeckMapper deckMapper, CardMapper cardMapper, Random rng)
 {
     this.deckRepository = deckRepository;
     this.cardRepository = cardRepository;
     this.deckMapper     = deckMapper;
     this.cardMapper     = cardMapper;
     this.rng            = rng;
 }
示例#6
0
 public static IEnumerable <CardDm> GetAllCards()
 {
     using (var db = new MtgEntities())
     {
         foreach (var dbCard in db.Cards)
         {
             yield return(CardMapper.Map(dbCard));
         }
     }
 }
示例#7
0
        public void Mapper_ShouldReturnValidCard()
        {
            var card = CardMapper.Map("ad");

            Assert.Multiple(() =>
            {
                Assert.IsTrue(card.Rank == Rank.Ace);
                Assert.IsTrue(card.Suit == Suit.Diamond);
            });
        }
示例#8
0
        /// <summary>
        /// get list of cards associated with a customer
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task <List <CardDto> > ListAllCard(ListAllCardsDto dto)
        {
            var service = new CardService();
            var options = new CardListOptions
            {
                Limit = dto.CardsLimit
            };
            var cards = await service.ListAsync(dto.CustomerId, options);

            return(CardMapper.MapCardListToCardDtoList(cards.Data));
        }
        public void CardMapper_GetCardType_ShouldReturnEmv_IfApplicationTypeIsContactlessEmv()
        {
            // Arrange
            this.GcrResponse.GCR_CARDTYPE.Value = ApplicationType.ContactlessEmv;

            // Act
            CardType cardType = CardMapper.GetCardType(this.GcrResponse.GCR_CARDTYPE.Value);

            // Assert
            Assert.AreEqual(CardType.Emv, cardType);
        }
示例#10
0
        /// <summary>
        /// discarded, this method is not required because as of now we are using vue stripe component
        /// it will be updated if required for other project in future
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task <CardDto> CreateCard(CreateCardDto dto)
        {
            var cardOptions = new CardCreateOptions()
            {
                SourceToken = dto.SourceToken
            };

            var cardService = new CardService();

            return(CardMapper.MapCardToCardDto(await
                                               cardService.CreateAsync(dto.CustomerId, cardOptions)));
        }
        public void CardMapper_GetCardType_ShouldReturnMagneticStripe_IfApplicationTypeIsMagneticStripe()
        {
            // Arrange
            this.GcrResponse.GCR_CARDTYPE.Value = ApplicationType.MagneticStripe;

            // Act
            CardType cardType = CardMapper.GetCardType(
                this.GcrResponse.GCR_CARDTYPE.Value);

            // Assert
            Assert.AreEqual(CardType.MagneticStripe, cardType);
        }
示例#12
0
        public async Task <Card> Update(CardModel cardModel)
        {
            var cardToUpdate = await _cardRepository.CardById(cardModel.Id);

            if (cardToUpdate != null)
            {
                CardMapper.UpdateTrapCardWith(cardToUpdate, cardModel);
                return(await _cardRepository.Update(cardToUpdate));
            }

            return(null);
        }
示例#13
0
        public static IEnumerable <CardVm> GetDeckLands(string deckName)
        {
            Console.WriteLine("Getting Deck");
            var deck = DeckRepository.GetDeck(deckName);

            Console.WriteLine("Looking for legal cards");
            var legalCards = CardRepository.GetAllCommanderLegalCardInGivenColors(CardBLL.GetCardColors(CardMapper.Map(deck.Commander)));

            Console.WriteLine($"Attempting to find lands in {legalCards.Count()} cards.");

            return(CardMapper.Map(legalCards.Where(c => c.Types.Contains("land"))));
        }
示例#14
0
        public static IEnumerable <CardDm> GetAllCardsByGivenSubtype(string subtype)
        {
            using (var db = new MtgEntities())
            {
                var legalCards = db.Cards
                                 .Where(c => c.SubTypes.Contains(subtype));

                foreach (var card in legalCards)
                {
                    yield return(CardMapper.Map(card));
                }
            }
        }
        public void CardMapper_MapCardFromTracks_ShouldNotReturnNull()
        {
            // Arrange
            this.GcrResponse.GCR_CARDTYPE.Value = ApplicationType.ContactlessEmv;

            // Act
            CardEntry mappedCard = CardMapper.MapCardFromTracks(
                this.GcrResponse,
                CardBrandMocker.Mock());

            // Assert
            Assert.IsNotNull(mappedCard);
        }
示例#16
0
 public Mapper()
 {
     _accountMapper           = new AccountMapper();
     _bazaarItemMapper        = new BazaarItemMapper();
     _bCardMapper             = new BCardMapper();
     _boxItemMapper           = new ItemInstanceMapper();
     _cardMapper              = new CardMapper();
     _cellonOptionMapper      = new CellonOptionMapper();
     _characterMapper         = new CharacterMapper();
     _characterRelationMapper = new CharacterRelationMapper();
     _characterSkillMapper    = new CharacterSkillMapper();
     _comboMapper             = new ComboMapper();
     _dropMapper              = new DropMapper();
     _familyCharacterMapper   = new FamilyCharacterMapper();
     _familyLogMapper         = new FamilyLogMapper();
     _familyMapper            = new FamilyMapper();
     _generalLogMapper        = new GeneralLogMapper();
     _itemInstanceMapper      = new ItemInstanceMapper();
     _itemMapper              = new ItemMapper();
     _mailMapper              = new MailMapper();
     _maintenanceLogMapper    = new MaintenanceLogMapper();
     _mapMapper               = new MapMapper();
     _mapMonsterMapper        = new MapMonsterMapper();
     _mapNPCMapper            = new MapNPCMapper();
     _mapTypeMapMapper        = new MapTypeMapMapper();
     _mapTypeMapper           = new MapTypeMapper();
     _mateMapper              = new MateMapper();
     _minilandObjectMapper    = new MinilandObjectMapper();
     _npcMonsterMapper        = new NpcMonsterMapper();
     _npcMonsterSkillMapper   = new NpcMonsterSkillMapper();
     _penaltyLogMapper        = new PenaltyLogMapper();
     _portalMapper            = new PortalMapper();
     _questMapper             = new QuestMapper();
     _questProgressMapper     = new QuestProgressMapper();
     _quicklistEntryMapper    = new QuicklistEntryMapper();
     _recipeItemMapper        = new RecipeItemMapper();
     _recipeListMapper        = new RecipeListMapper();
     _recipeMapper            = new RecipeMapper();
     _respawnMapper           = new RespawnMapper();
     _respawnMapTypeMapper    = new RespawnMapTypeMapper();
     _rollGeneratedItemMapper = new RollGeneratedItemMapper();
     _scriptedInstanceMapper  = new ScriptedInstanceMapper();
     _shellEffectMapper       = new ShellEffectMapper();
     _shopItemMapper          = new ShopItemMapper();
     _shopMapper              = new ShopMapper();
     _shopSkillMapper         = new ShopSkillMapper();
     _skillMapper             = new SkillMapper();
     _staticBonusMapper       = new StaticBonusMapper();
     _staticBuffMapper        = new StaticBuffMapper();
     _teleporterMapper        = new TeleporterMapper();
 }
        public void CardMapper_MapCardFromTracks_ShouldThrowException_IfApplicationTypeIsEasyEntryOverTIBCv1()
        {
            // Assert
            Assert.Throws <NotImplementedException>(() =>
            {
                // Arrange
                this.GcrResponse.GCR_CARDTYPE.Value = ApplicationType.EasyEntryOverTIBCv1;

                // Act
                CardEntry mappedCard = CardMapper.MapCardFromTracks(
                    this.GcrResponse,
                    CardBrandMocker.Mock());
            });
        }
示例#18
0
        public static IEnumerable <CardDm> GetCommandersByPartialName(string cardName)
        {
            using (var db = new MtgEntities())
            {
                cardName = cardName.ToLower();
                var commanders = db.Cards
                                 .Where(c => c.Types.Contains("Legendary") && c.CardName.ToLower().Contains(cardName));

                foreach (var card in commanders)
                {
                    yield return(CardMapper.Map(card));
                }
            }
        }
示例#19
0
        public static IEnumerable <CardDm> FindTribalCommandersForType(string tribalType)
        {
            using (var db = new MtgEntities())
            {
                tribalType = tribalType.ToLower();
                var commanders = db.Cards
                                 .Where(c => c.Types.Contains("Legendary") &&
                                        (c.SubTypes.ToLower().Contains(tribalType) || c.RulesText.ToLower().Contains(tribalType)));

                foreach (var card in commanders)
                {
                    yield return(CardMapper.Map(card));
                }
            }
        }
示例#20
0
 public static CardDm GetCardByName(string cardName)
 {
     using (var db = new MtgEntities())
     {
         try
         {
             return(CardMapper.Map(db.Cards.Single(c => c.CardName == cardName)));
         }
         catch (Exception)
         {
             Console.WriteLine();
             Console.WriteLine($"Unable to find the card {cardName}.");
             return(null);
         }
     }
 }
示例#21
0
 static public void MakeActOfWorkInExcel(string idRepair, string unloadPath)
 {
     rowStartForDelete = 0;
     try
     {
         xlApp      = new Excel.Application();
         xlWorkBook = xlApp.Workbooks.Open(ConfigurationManager.AppSettings.Get("PathForOpenAct"));
         xlSheet    = xlWorkBook.Sheets[1];
         SystemOwner  systemOwner  = new OwnerMapper().Get();
         CardOfRepair card         = new CardMapper().Get(idRepair.ToString());
         FileOperator fileOperator = new FileOperator();
         xlSheet.Cells[1, "A"]  = systemOwner.ToString();
         xlSheet.Cells[59, "F"] = systemOwner.Director.GetShortName();
         xlSheet.Cells[3, "G"]  = card.IdRepair;
         xlSheet.Cells[3, "J"]  = ((DateTime)card.TimeOfFinish).ToString("dd/MM/yyyy");
         if (card.Car.Owner != null)
         {
             xlSheet.Cells[4, "D"] = $"{card.Car.Owner.Name}, ИНН {card.Car.Owner.INN}";
         }
         xlSheet.Cells[5, "E"] = $"{card.Car.Mark} {card.Car.Number}";
         List <Malfunctions> MalfList  = card.ListOfMalf.Select(n => n).Where(n => n.MalfOrSpare == 0).ToList <Malfunctions>();
         List <Malfunctions> SpareList = card.ListOfMalf.Select(n => n).Where(n => n.MalfOrSpare == 1).ToList <Malfunctions>();
         FillRowsWithMalf(xlSheet, rowStartAct1, rowFinishAct1, MalfList);
         FillRowsWithSpares(xlSheet, rowStartAct2, rowFinishAct2, SpareList);
         xlSheet.Cells[34, "Q"] = Malfunctions.GetTotalPriceFromList(MalfList);
         xlSheet.Cells[54, "Q"] = Malfunctions.GetTotalPriceFromList(SpareList);
         xlSheet.Cells[55, "Q"] = card.TotalPrice;
         xlWorkBook.SaveAs(fileOperator.MakeActPath(card, mainPath));
         xlWorkBook.Close();
         xlApp.Quit();
         while (System.Runtime.InteropServices.Marshal.ReleaseComObject(xlApp) > 0)
         {
         }
         //MessageBox.Show($"Акт № {idRepair} выгружен в формате Excel!");
     }
     catch (Exception ex)
     {
         MessageBox.Show($"Не удалось сделать акт выполненных работ № {idRepair}\n" +
                         $"{ex.Message}");
         xlWorkBook.Close(false);
         xlApp.Quit();
         while (System.Runtime.InteropServices.Marshal.ReleaseComObject(xlApp) > 0)
         {
         }
     }
 }
示例#22
0
        public static IEnumerable <CardDm> GetAllCommanderLegalCardInGivenColors(List <string> desiredColors)
        {
            Console.WriteLine("Attempting to pull from DBs");
            using (var db = new MtgEntities())
            {
                var invalidColors = GetInvalidColors(desiredColors);
                var legalCards    = db.Cards
                                    .Where(c => c.Commander == "legal")
                                    .Where(c => invalidColors.All(i => !c.Cost.Contains(i) && !c.RulesText.Contains(i)));

                foreach (var card in legalCards)
                {
                    yield return(CardMapper.Map(card));
                }
            }
            Console.WriteLine("finished db");
        }
示例#23
0
            public void SetUp()
            {
                var cardNumber = "1234123412341234";
                var expiryDate = "1220";
                var cvv        = "123";
                var name       = "Mr J Bloggs";

                _cardRequest = new CardRequest
                {
                    CardNumber = cardNumber,
                    ExpiryDate = expiryDate,
                    Cvv        = cvv,
                    Name       = name
                };

                _sut = new CardMapper();
            }
        public void Given_A_CardModel_When_Mapped_To_Card_Then_CardSubCategory_Should_Have_A_Count_Of_2()
        {
            // Arrange
            var cardModel = new CardModel
            {
                SubCategoryIds = new List <int> {
                    4, 23
                },
                TypeIds      = new List <int>(),
                LinkArrowIds = new List <int>()
            };

            // Act
            var result = CardMapper.MapToSpellOrTrapCard(cardModel);

            // Assert
            result.CardSubCategory.Should().HaveCount(2);
        }
示例#25
0
 static public void MakeOrderInExcel(string idRepair, string unloadPath)
 {
     rowStartForDelete = 0;
     try
     {
         xlApp      = new Excel.Application();
         xlWorkBook = xlApp.Workbooks.Open(ConfigurationManager.AppSettings.Get("PathForOpenOrder"));
         xlSheet    = xlWorkBook.Sheets[1];
         CardOfRepair card         = new CardMapper().Get(idRepair.ToString());
         SystemOwner  systemOwner  = new OwnerMapper().Get();
         FileOperator fileOperator = new FileOperator();
         xlSheet.Cells[3, "G"]  = card.IdRepair;
         xlSheet.Cells[5, "O"]  = card.TimeOfStart.ToString("dd/MM/yyyy");
         xlSheet.Cells[7, "O"]  = ((DateTime)card.TimeOfFinish).ToString("dd/MM/yyyy");
         xlSheet.Cells[9, "A"]  = $"Заказчик: {card.Car.Owner.Name}";
         xlSheet.Cells[1, "J"]  = $"Исполнитель: {systemOwner.Name} {systemOwner.Address} {systemOwner.PhoneNumber}";
         xlSheet.Cells[64, "I"] = systemOwner.Director.GetShortName();
         xlSheet.Cells[10, "D"] = card.Car.Mark;
         xlSheet.Cells[11, "G"] = card.Car.Number;
         List <Malfunctions> MalfList  = card.ListOfMalf.Select(n => n).Where(n => n.MalfOrSpare == 0).ToList <Malfunctions>();
         List <Malfunctions> SpareList = card.ListOfMalf.Select(n => n).Where(n => n.MalfOrSpare == 1).ToList <Malfunctions>();
         FillRowsWithMalf(xlSheet, rowStartOrder1, rowFinishOrder1, MalfList);
         FillRowsWithSpares(xlSheet, rowStartOrder2, rowFinishOrder2, SpareList);
         xlSheet.Cells[41, "Q"] = Malfunctions.GetTotalPriceFromList(MalfList);
         xlSheet.Cells[61, "Q"] = Malfunctions.GetTotalPriceFromList(SpareList);
         xlSheet.Cells[62, "Q"] = card.TotalPrice;
         xlWorkBook.SaveAs(fileOperator.MakeOrderPath(card, mainPath));
         xlWorkBook.Close();
         xlApp.Quit();
         while (System.Runtime.InteropServices.Marshal.ReleaseComObject(xlApp) > 0)
         {
         }
     }
     catch (Exception ex)
     {
         MessageBox.Show($"Не удалось сделать акт выполненных работ № {idRepair}\n" +
                         $"{ex.Message}");
         xlWorkBook.Close(false);
         xlApp.Quit();
         while (System.Runtime.InteropServices.Marshal.ReleaseComObject(xlApp) > 0)
         {
         }
     }
 }
示例#26
0
 public void MakeBillInExcel(string idRepair)
 {
     try
     {
         xlApp      = new Excel.Application();
         xlWorkBook = xlApp.Workbooks.Open(ConfigurationManager.AppSettings.Get("PathForOpenBill"));
         xlSheet    = xlWorkBook.Sheets[1];
         SystemOwner  systemOwner  = new OwnerMapper().Get();
         CardOfRepair card         = new CardMapper().Get(idRepair.ToString());
         FileOperator fileOperator = new FileOperator();
         xlSheet.Cells[5, "B"]  = systemOwner.Bank.Name;
         xlSheet.Cells[5, "X"]  = systemOwner.Bank.BIK;
         xlSheet.Cells[6, "X"]  = systemOwner.Bank.KorBill;
         xlSheet.Cells[9, "B"]  = systemOwner.Name;
         xlSheet.Cells[8, "D"]  = systemOwner.INN;
         xlSheet.Cells[8, "X"]  = systemOwner.Bill;
         xlSheet.Cells[17, "F"] = systemOwner.ToString();
         xlSheet.Cells[30, "H"] = systemOwner.Director.GetFullName();
         xlSheet.Cells[13, "K"] = card.IdRepair;
         xlSheet.Cells[13, "Q"] = ((DateTime)card.TimeOfFinish).ToString("dd/MM/yyyy");
         xlSheet.Cells[19, "F"] = $"{card.Car.Owner.Name}, ИНН {card.Car.Owner.INN}, {card.Car.Owner.Address}";
         xlSheet.Cells[22, "D"] = $"Ремонт автомобиля: {card.Car.ToString()} по заявке № {idRepair}" +
                                  $" от {((DateTime)card.TimeOfFinish).ToString("dd/MM/yyyy")}";
         xlSheet.Cells[22, "AB"] = card.TotalPrice;
         xlSheet.Cells[28, "B"]  = RuDateAndMoneyConverter.CurrencyToTxt(card.TotalPrice, true);
         xlWorkBook.SaveAs(fileOperator.MakeBillPath(card, mainPath));
         xlWorkBook.Close();
         xlApp.Quit();
         while (System.Runtime.InteropServices.Marshal.ReleaseComObject(xlApp) > 0)
         {
         }
     }
     catch (Exception ex)
     {
         MessageBox.Show($"Не удалось сделать счет на оплату № {idRepair}\n" +
                         $"{ex.Message}");
         xlWorkBook.Close(false);
         xlApp.Quit();
         while (System.Runtime.InteropServices.Marshal.ReleaseComObject(xlApp) > 0)
         {
         }
     }
 }
示例#27
0
        public void CardMapperMapsFilledCardToCardDto()
        {
            var card = new Card
            {
                CardNumber  = "1234123412341234",
                Cvv         = 123,
                ExpiryMonth = 12,
                ExpiryYear  = 20
            };

            var mapper = new CardMapper();

            var cardDto = mapper.Map(card);

            cardDto.Should().NotBeNull();
            cardDto.Cvv.Should().Be(123);
            cardDto.CardNumber.Should().Be("1234123412341234");
            cardDto.ExpiryMonth.Should().Be(12);
            cardDto.ExpiryYear.Should().Be(20);
        }
        public void Given_A_CardModel_When_Mapped_To_Card_Then_CardSubCategory_Should_Contain_All_SubCategory_Ids()
        {
            // Arrange
            var expected = new[] { 4, 23 };

            var cardModel = new CardModel
            {
                SubCategoryIds = new List <int> {
                    4, 23
                },
                TypeIds      = new List <int>(),
                LinkArrowIds = new List <int>()
            };

            // Act
            var result = CardMapper.MapToSpellOrTrapCard(cardModel);

            // Assert
            result.CardSubCategory.Select(cs => cs.SubCategoryId).Should().ContainInOrder(expected);
        }
示例#29
0
        public void Given_A_MonsterCard_When_Updated_With_CardModel_Then_CardType_Should_Have_A_Count_Of_2()
        {
            // Arrange
            var monsterCard = new Card();

            var cardModel = new CardModel
            {
                SubCategoryIds = new List <int>(),
                TypeIds        = new List <int> {
                    4, 23
                },
                LinkArrowIds = new List <int>()
            };

            // Act
            CardMapper.UpdateMonsterCardWith(monsterCard, cardModel);

            // Assert
            monsterCard.CardType.Should().HaveCount(2);
        }
示例#30
0
        public void Given_A_MonsterCard_When_Updated_With_CardModel_Then_CardType_Should_Contain_All_SubCategory_Ids()
        {
            // Arrange
            var expected = new[] { 4, 23 };

            var monsterCard = new Card();

            var cardModel = new CardModel
            {
                SubCategoryIds = new List <int>(),
                TypeIds        = new List <int> {
                    4, 23
                },
                LinkArrowIds = new List <int>()
            };

            // Act
            CardMapper.UpdateMonsterCardWith(monsterCard, cardModel);

            // Assert
            monsterCard.CardType.Select(cs => cs.TypeId).Should().ContainInOrder(expected);
        }