public AddCICard()
{
InitializeComponent();
callBack = new Action(ShowMessage);
vm = new AddCardViewModel(callBack);
BindingContext = vm;
}
public ActionResult AddCard([Bind(Include = "CollectionId,CardId,EditionId,GameId,Quantity")] AddCardViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Collection collection = db.CardLists.OfType <Collection>().FirstOrDefault(c => c.Id == viewModel.CollectionId);
if (collection == null)
{
return(HttpNotFound());
}
if (viewModel.CardId != null)
{
var card = db.Cards.Find(viewModel.CardId);
collection.AddCard(card, viewModel.Quantity);
db.SaveChanges();
return(RedirectToAction("Details", new { id = viewModel.CollectionId }));
}
if (viewModel.GameId == null)
{
viewModel.GameId = db.Games.Select(g => g.Id).Min();
}
ViewBag.GameId = new SelectList(db.Games, "Id", "Name", viewModel.GameId);
ViewBag.EditionId = new SelectList(db.Editions.Where(e => e.GameId == viewModel.GameId), "Id", "Name");
ViewBag.CardId = new SelectList(new Card[0], "Id", "Name");
if (viewModel.GameId != null)
{
ViewBag.EditionId = new SelectList(db.Editions.Where(edition => edition.GameId == viewModel.GameId),
"Id", "Name", viewModel.GameId);
}
if (viewModel.EditionId != null)
{
var edition = db.Editions.Find(viewModel.EditionId);
if (viewModel.GameId == edition.GameId)
{
ViewBag.CardId = new SelectList(db.Cards.ToList().Where(c => c.Edition.Id == viewModel.EditionId),
"Id", "Name", viewModel.CardId);
}
}
ViewBag.Collection = collection;
return(View(viewModel));
}
public async Task Add(AddCardViewModel addCard)
{
Card card = new Card();
card.Name = addCard.Name;
card.Value = addCard.Value;
try
{
await _cardRepository.InsertCard(card);
}
catch (Exception e) {
throw e;
}
}
public async Task <IViewComponentResult> InvokeAsync()
{
var cardTypes = Enum.GetValues(typeof(CardType)).Cast <CardType>();
var cardTypesSelectList = cardTypes.Select(c => new SelectListItem {
Value = c.ToString(), Text = c.ToString()
}).ToList();
var addCardVM = new AddCardViewModel()
{
CardTypes = cardTypesSelectList
};
return(View("Default", addCardVM));
}
public void AddCardViaAddCardViewModel()
{
var dataStoreMock = new Mock <IDataStore>();
var cardRepo = new CardRepository(dataStoreMock.Object);
var addCardVM = new AddCardViewModel(cardRepo);
addCardVM.Title = "title";
addCardVM.Text = "text";
addCardVM.Hint = "hint";
addCardVM.AddCard.Execute(this);
addCardVM.IsClosed.Should().BeTrue();
}
public async Task <IActionResult> AddCard(AddCardViewModel model)
{
var userId = this.userManager.GetUserId(HttpContext.User);
if (!ModelState.IsValid)
{
return(Json(new { message = $"Invalid parameters!" }));
}
DateTime expiryDate = model.Expiry;
var card = await this.cardService.AddCardAsync(model.CardNumber, model.CardholderName, model.Cvv, expiryDate, model.CardType, userId);
return(ViewComponent("SelectCard"));
}
public async Task <IHttpActionResult> AddCard(long gameId)
{
try
{
AddCardViewModel addCardViewModel = await _gameService.AddCard(gameId);
return(Ok(addCardViewModel));
}
catch (Exception ex)
{
string message = $"{ex.Source}|{ex.TargetSite}|{ex.StackTrace}|{ex.Message}";
_logger.Error(message);
return(BadRequest(GameMessageHelper.GameError));
}
}
public IActionResult AddCard()
{
var cardTypes = Enum.GetValues(typeof(CardType)).Cast <CardType>();
var cardTypesSelectList = cardTypes.Select(c => new SelectListItem {
Value = ((int)c).ToString(), Text = c.ToString()
}).ToList();
var addCardVM = new AddCardViewModel()
{
CardTypes = cardTypesSelectList
};
return(View(addCardVM));
}
public async Task <ActionResult> Add(AddCardViewModel card)
{
try
{
await _cardService.Add(card);
//await _cardService.Save();
return(RedirectToAction("Index"));
return(View());
}
catch (Exception e)
{
return(View("Error"));
}
}
public async Task <AddCardViewModel> AddCard(long gameId)
{
GamePlayer human = await _gamePlayerRepository.GetWithCards(gameId, (int)PlayerType.Human);
await AddOneCardToHuman(human, gameId);
await _gamePlayerRepository.UpdateAddingCard(human);
AddCardViewModel addCardViewModel = Mapper.Map <GamePlayer, AddCardViewModel>(human);
addCardViewModel.CanTakeCard = true;
if (human.RoundScore >= CardValueHelper.BlackJackScore)
{
addCardViewModel.CanTakeCard = false;
}
return(addCardViewModel);
}
public async Task <IActionResult> AddCard(AddCardViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var userName = HttpContext.User.Identity.Name;
var user = await this.userManager.FindByNameAsync(userName);
var dateStrings = model.ExpiryDate.Split('/');
var expiryDate = $"01.{dateStrings[0]}.20{dateStrings[1]}";
var cardToAdd = await this.cardService.AddCard(model.CardNumber.Replace(" ", ""), model.CVV, DateTime.Parse(expiryDate), user);
return(RedirectToAction("Deposit", "Transaction"));
}
return(this.View());
}
public ActionResult AddCard(AddCardViewModel model)
{
if (ModelState.IsValid)
{
var mapper = new MapperConfiguration(
cfg => cfg.CreateMap <AddCardViewModel, CreditCardDTO>()).CreateMapper();
var card = mapper.Map <AddCardViewModel, CreditCardDTO>(model);
var userId = AuthenticationManager.User.Identity.GetUserId();
OperationDetails operationDetails = CardService.Create(card, userId);
if (operationDetails.Succedeed)
{
return(Redirect("/Account/UserProfile"));
}
else
{
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
}
}
return(View(model));
}
public IActionResult AddCard(AddCardViewModel cardModel)
{
string currUserEmail = HttpContext.Session.GetString("User");
User currUser = dbContext.Users.Where(u => u.email == currUserEmail).FirstOrDefault();
CreditCard card = new CreditCard();
card.CardNumber = cardModel.CardNumber;
card.CardType = cardModel.CardType;
card.ExpiryMonth = cardModel.ExpiryMonth;
card.ExpiryYear = cardModel.ExpiryYear;
card.Users = new List <User>();
card.Users.Add(currUser);
if (currUser.CreditCards == null)
{
currUser.CreditCards = new List <CreditCard>();
}
currUser.CreditCards.Add(card);
dbContext.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public void InvokeCorrectServiceMethod_WhenCalled()
{
// Arrange
var cardServiceMock = new Mock <ICardService>();
var dateTimeProvMock = new Mock <IDateTimeProvider>();
var controller = SetupController(cardServiceMock, dateTimeProvMock);
var viewModel = new AddCardViewModel()
{
CardNumber = "1111111111111111"
};
// Act
var result = controller.AddCard(viewModel);
// Assert
cardServiceMock.Verify(x => x.AddCardAsync(It.IsAny <string>(), It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <DateTime>(),
It.IsAny <CardType>(),
It.IsAny <string>()
), Times.Once);
}
public AddCardCommand(AddCardViewModel addCardViewModel, ICardService cardService)
{
_addCardViewModel = addCardViewModel;
_cardService = cardService;
}
public IActionResult AddCard()
{
AddCardViewModel cardModel = new AddCardViewModel();
return(View(cardModel));
}
public AddCardPage(Deck deck, MainWindowViewModel mainWinVM)
{
InitializeComponent();
DataContext = new AddCardViewModel(deck, mainWinVM);
}
public AddCardPage()
{
InitializeComponent();
BindingContext = new AddCardViewModel();
}
