public override UpdateCartResult Execute(IUnitOfWork unitOfWork, UpdateCartParameter parameter, UpdateCartResult result)
{
if (!parameter.Status.EqualsIgnoreCase("Submitted"))
{
return(this.NextHandler.Execute(unitOfWork, parameter, result));
}
if (parameter.PaymentProfileId != null)
{
UserPaymentProfile userPaymentProfile = unitOfWork.GetRepository <UserPaymentProfile>().GetTable().FirstOrDefault(p => p.CardIdentifier == parameter.PaymentProfileId);
if (userPaymentProfile != null)
{
CreditCardDto cc = new CreditCardDto();
cc.CardNumber = userPaymentProfile.MaskedCardNumber;
cc.CardType = userPaymentProfile.CardType;
if (!string.IsNullOrEmpty(userPaymentProfile.ExpirationDate))
{
cc.ExpirationMonth = Convert.ToInt32(userPaymentProfile.ExpirationDate.Substring(0, 2));
cc.ExpirationYear = Convert.ToInt32(userPaymentProfile.ExpirationDate.Substring(2, 2));
}
parameter.CreditCard = cc;
}
}
return(this.NextHandler.Execute(unitOfWork, parameter, result));
}
public async Task <ICommandHandlerAggregateAnswer> Create(Guid personId, CreditCardDto dto)
{
var command = Mapper.Map(dto).OnTo(new CreditCardCreateCommand());
command.CreditCardType = CreditCardType.FromName(dto.CreditCardType);
return(await dispatcher.Send <CreditCardCreateCommand, Person>(command));
}
public void Given_ValidCreditCardPaymentMethodDto_When_AdaptToCreditCardPaymentMethodDomain_TheRightObjectIsReturned()
{
// arrange
var creditCardDto = new CreditCardDto(
"785",
"Mark Simons",
"7845856965232145",
"12",
"2022");
// act
var result = paymentMethodDtoToPaymentMethodAdapter.Adapt(creditCardDto);
// assert
Assert.NotNull(result);
Assert.True(result is CreditCard);
var creditCard = result as CreditCard;
Assert.Equal(creditCardDto.CVV, creditCard.CVV);
Assert.Equal(creditCardDto.CardNumber, creditCard.CardNumber.ToString());
Assert.Equal(creditCardDto.Name, creditCard.Name);
Assert.Equal(creditCardDto.ExpiryMonth, creditCard.ExpiryDate.Month);
Assert.Equal(creditCardDto.ExpiryYear, creditCard.ExpiryDate.Year);
}
public async Task <ResultDto> PutMoneyOnMobilePhone(CreditCardDto creditCardDto, AtmMobilePhoneDto mobilePhoneDto)
{
var creditCard = await _unitOfWork.CreditCards.GetFirstWhereAsync(card => card.Number == creditCardDto.Number);
if (creditCard.CreditAccount.Balance < mobilePhoneDto.Amount)
{
return(new ResultDto
{
Success = false,
Message = "Insufficient funds."
});
}
var cashboxAccount = await _unitOfWork.Accounts.GetBankCashboxAccount();
var transaction = await _transactionsService.CreateTransaction(creditCard.CreditAccount, cashboxAccount, mobilePhoneDto.Amount);
cashboxAccount.CreditValue += mobilePhoneDto.Amount;
await _unitOfWork.SaveAsync();
return(new ResultDto {
Success = true, Message = transaction.ID.ToString()
});
}
public async Task <ActionResult> CreditCardEdit(CreditCardDto card)
{
try
{
if (ModelState.IsValid)
{
var cardRepo = _uow.GetGenericRepository <CreditCard>();
var user = await _userManager.GetUserAsync(HttpContext.User);
//???
//should we be finding by cardID? e.g. single customer may have many cards
var temp = cardRepo.Find(x => x.CustomerId == user.CustomerId).FirstOrDefault();
temp.CardNumber = card.CardNumber;
temp.Cvc = card.Cvc;
temp.ExpiryDate = card.ExpiryDate;
temp.FullName = card.FullName;
cardRepo.Update(temp);
_uow.Commit();
return(RedirectToAction("CreditCard"));
}
return(View("CreditCardDetail")); // error message should be returned.
}
catch
{
return(View());
}
}
public bool CheckCreditCart(CreditCardDto creditCard)
{
int firstCardNumber = Convert.ToInt32(creditCard.creditNumber.Substring(0, 1));
int firstCardCVV = Convert.ToInt32(creditCard.cardCVV.Substring(0, 1));
if (firstCardNumber % 2 == 0)
{
if (firstCardCVV % 2 == 0)
{
return(true);
}
else
{
return(false);
}
}
else
{
if (firstCardCVV % 2 == 1)
{
return(true);
}
else
{
return(false);
}
}
}
public void Given_ValidPaymentDto_When_AdaptToPaymentDomain_TheRightObjectIsReturned()
{
// arrange
var creditCardDto = new CreditCardDto(
"785",
"Mark Simons",
"7845856965232145",
"12",
"2019");
var paymentDto = new PaymentDto(
457.5D,
"USD",
creditCardDto);
// act
var result = paymentDtoToPaymentDomainAdapter.Adapt(paymentDto);
// assert
Assert.NotNull(result);
Assert.Equal(paymentDto.Amount, result.Amount);
Assert.Equal(paymentDto.Currency, result.Currency);
Assert.NotNull(result.PaymentMethod);
var creditCard = result.PaymentMethod as CreditCard;
Assert.Equal(creditCardDto.CVV, creditCard.CVV);
Assert.Equal(creditCardDto.CardNumber, creditCard.CardNumber.ToString());
Assert.Equal(creditCardDto.Name, creditCard.Name);
Assert.Equal(creditCardDto.ExpiryMonth, creditCard.ExpiryDate.Month);
Assert.Equal(creditCardDto.ExpiryYear, creditCard.ExpiryDate.Year);
}
public async Task <ICommandHandlerAggregateAnswer> Update(Guid personId, CreditCardDto dto)
{
var command = Mapper.Map(dto).ToANew <CreditCardUpdateCommand>
(cfg => cfg.Map((p, d) => CreditCardType.FromName(p.CreditCardType)).To(d => d.CreditCardType));
return(await dispatcher.Send <CreditCardUpdateCommand, Person>(command));
}
public void Given_ValidCreditCard_When_SecureCardInformationIsUsed_Then_SensibleValuesAreMasked(
string cvv,
string cardNumber)
{
// arrange
var creditCard =
new CreditCardDto(
cvv,
"John Doe",
cardNumber,
"12",
"2020");
// act
var creditCardMaskedValues =
this.secureCardInformation.MaskCardSensibleInformation(creditCard);
// assert
Assert.NotNull(creditCardMaskedValues);
Assert.True(creditCardMaskedValues.CVV.All(c => c == 'X'));
var cardNumberExpectLastFourDigits =
creditCardMaskedValues.CardNumber.Substring(0, creditCardMaskedValues.CardNumber.Length - 4);
var cardNumberOnlyLastFourDigits =
creditCardMaskedValues.CardNumber.Substring(creditCardMaskedValues.CardNumber.Length - 4);
Assert.True(cardNumberExpectLastFourDigits.All(c => c == 'X'));
Assert.True(cardNumberOnlyLastFourDigits.All(c => int.TryParse(c.ToString(), out var digit)));
}
public IActionResult Pay(CreditCardDto creditCardDto)
{
var result = GetPaymentResult(creditCardDto.CardNumber);
if (result)
{
return(Ok(new SuccessResult("Ödeme başarıyla gerçekleştirildi.")));
}
return(BadRequest(new ErrorResult("Ödeme gerçekleştirilemedi lütfen daha sonra tekrar deneyiniz.")));
}
public async Task CreateAsync_Fail_When_Arg_Null()
{
CreditCardDto dto = null;
this.creditCardRepositoryMock.Setup(x => x.CreateAsync(It.IsAny <CreditCardEntity>()));
var creditCardService = this.serviceProvider.GetService <ICreditCardService>();
await creditCardService.CreateAsync(dto);
}
private async Task <bool> ValidatePayment(CreditCardDto creditCard)
{
Console.WriteLine($"Number: {creditCard.Number}," +
$"Name: {creditCard.Name}," +
$"Expiry: {creditCard.Expiry}," +
$"CVC: {creditCard.Cvc}");
await Task.Delay(2000);
return(true);
}
public IActionResult Pay(CreditCardDto creditCard)
{
var result = _paymentService.Pay(creditCard);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public async Task CreateAsync(CreditCardDto creditCard)
{
if (creditCard == null)
{
throw new ArgumentNullException(nameof(creditCard));
}
await this.creditCardRepository
.CreateAsync(this.mapper.Map <CreditCardEntity>(creditCard))
.ConfigureAwait(false);
}
public void Given_NullPaymentMethodDto_When_AdaptToPaymentMethodDomain_TheNullReturned()
{
// arrange
CreditCardDto creditCardDto = null;
// act
var result = paymentMethodDtoToPaymentMethodAdapter.Adapt(creditCardDto);
// assert
Assert.Null(result);
}
public async Task <CommandHandlerAnswerDto <CreditCardDto> > Save(CreditCardDto card)
{
using (busyIndicatorService.Show())
{
if (card.Id != Guid.Empty)
{
return(await creditCardService.Put(card));
}
return(await creditCardService.Post(card));
}
}
public IResult Pay(CreditCardDto creditCard)
{
var result = CheckCreditCart(creditCard);
if (result == true)
{
return(new SuccessResult("Çekim Başarılı"));
}
else
{
return(new ErrorResult("Çekim Başarısız"));
}
}
public async Task <BalanceInquiryDto> InquiryBalace(CreditCardDto creditCardDto)
{
var creditCard = await _unitOfWork.CreditCards.GetFirstWhereAsync(card => card.Number == creditCardDto.Number);
var creditAccount = creditCard.CreditAccount;
return(new BalanceInquiryDto
{
Balance = creditAccount.Balance + creditAccount.DebitValue - creditAccount.CreditValue,
Number = $"{creditCard.Number.Substring(0, 4)}*********{creditCard.Number.Substring(12)}",
ClientFullName = $"{creditCard.Owner.Surname.ToUpper()} {creditCard.Owner.Name.ToUpper()}"
});
}
private PaymentMethodDto ConverToCreditCardDto(CreditCard creditCard)
{
var secureCardInformation = new SecureCardInformation();
var creditCardDto = new CreditCardDto(
creditCard.CVV,
creditCard.Name,
creditCard.CardNumber.ToString(),
creditCard.ExpiryDate.Month,
creditCard.ExpiryDate.Year);
return(secureCardInformation.MaskCardSensibleInformation(creditCardDto));
}
public async Task <Guid> Insert(CreditCardDto creditCardDto)
{
var connection = await _sqlDbConnection.OpenConnectionAsync();
var parameters = new
{
Name = creditCardDto.Name,
CardNumber = creditCardDto.CardNumber,
CVC = creditCardDto.CVC,
ExpiryDate = creditCardDto.ExpiryDate
};
return((await connection.QueryAsync <Guid>("[dbo].InsertCreditCard", param: parameters, transaction: _sqlDbConnection.SqlTransaction, commandType: CommandType.StoredProcedure)).SingleOrDefault());
}
public async Task <IActionResult> Get(int creditCardId)
{
try{
CreditCard CreditCardModel = await _repo.GetCreditCardById(creditCardId);
// match date to dto
CreditCardDto result = _mapper.Map <CreditCardDto>(CreditCardModel);
return(Ok(result));
}
catch (System.Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Banco dados falhou {ex.Message}"));
}
}
private CreditCardAddressDto CreateCreditCardAddress(Customer customer, CreditCardDto creditCard = null)
{
CreditCardAddressDto creditCardAddressDto1 = new CreditCardAddressDto()
{
Company = customer.CompanyName,
FirstName = customer.FirstName,
MiddleName = customer.MiddleName,
LastName = customer.LastName,
Email = customer.Email,
Phone = customer.Phone
};
if (creditCard != null && !creditCard.UseBillingAddress)
{
creditCardAddressDto1.Address1 = creditCard.Address1;
creditCardAddressDto1.City = creditCard.City;
creditCardAddressDto1.State = creditCard.StateAbbreviation;
creditCardAddressDto1.PostalCode = creditCard.PostalCode;
creditCardAddressDto1.Country = creditCard.CountryAbbreviation;
}
else
{
bool isNewUser = false;
if (SiteContext.Current.UserProfile != null)
{
isNewUser = (SiteContext.Current.UserProfileDto != null && !SiteContext.Current.UserProfileDto.IsGuest &&
customer.CustomerNumber.ContainsIgnoreCase("1055357"));
}
creditCardAddressDto1.Address1 = isNewUser ? SiteContext.Current.UserProfile.CustomProperties.Where(x => x.Name == "NewUsrBTAddress1").Select(x => x.Value).FirstOrDefault().ToString() : customer.Address1;
creditCardAddressDto1.Address2 = isNewUser ? SiteContext.Current.UserProfile.CustomProperties.Where(x => x.Name == "NewUsrBTAddress2").Select(x => x.Value).FirstOrDefault().ToString() : customer.Address2;
creditCardAddressDto1.City = isNewUser ? SiteContext.Current.UserProfile.CustomProperties.Where(x => x.Name == "NewUsrBTCity").Select(x => x.Value).FirstOrDefault().ToString() : customer.City;
CreditCardAddressDto creditCardAddressDto2 = creditCardAddressDto1;
var customerState = isNewUser ? SiteContext.Current.UserProfile.CustomProperties.Where(x => x.Name == "NewUsrBTState").Select(x => x.Value).FirstOrDefault().ToString() : string.Empty;
State state = isNewUser ? UnitOfWork.GetRepository <State>().GetTable().FirstOrDefault(s => s.Name == customerState) ?? customer.State : customer.State;
string str1 = (state != null ? state.Abbreviation : (string)null) ?? string.Empty;
creditCardAddressDto2.State = str1;
creditCardAddressDto1.PostalCode = isNewUser ? SiteContext.Current.UserProfile.CustomProperties.Where(x => x.Name == "NewUsrBTPostalCode").Select(x => x.Value).FirstOrDefault().ToString() : customer.PostalCode;
CreditCardAddressDto creditCardAddressDto3 = creditCardAddressDto1;
var customerCountry = isNewUser ? SiteContext.Current.UserProfile.CustomProperties.Where(x => x.Name == "NewUsrBTCountry").Select(x => x.Value).FirstOrDefault().ToString() : string.Empty;
Country country = isNewUser ? UnitOfWork.GetRepository <Country>().GetTable().FirstOrDefault(s => s.Name == customerCountry) ?? customer.Country : customer.Country;
string str2 = (country != null ? country.Abbreviation : (string)null) ?? string.Empty;
creditCardAddressDto3.Country = str2;
}
return(creditCardAddressDto1);
}
public async Task <CashWithdrawlDto> GetCashWithdrawlDtoAsync(CreditCardDto creditCardDto, Guid transactionID)
{
var creditCard = await _unitOfWork.CreditCards.GetFirstWhereAsync(card => card.Number == creditCardDto.Number);
var transaction = await _unitOfWork.Transactions.FindAsync(transactionID);
return(new CashWithdrawlDto
{
Number = $"{creditCard.Number.Substring(0, 4)}*********{creditCard.Number.Substring(12)}",
ClientFullName = $"{creditCard.Owner.Surname.ToUpper()} {creditCard.Owner.Name.ToUpper()}",
TransactionTime = transaction.TransactionTime,
CreditAccountNumber = creditCard.CreditAccountNumber,
Amount = transaction.Amount
});
}
public CreditCardDto MaskCardSensibleInformation(CreditCardDto creditCard)
{
Regex cvvRegex = new Regex(".", RegexOptions.Compiled | RegexOptions.IgnoreCase);
Regex cardNumberRegex = new Regex(".(?=.{4})", RegexOptions.Compiled | RegexOptions.IgnoreCase);
var cvvMasked = cvvRegex.Replace(creditCard.CVV, "X");
var cardNumberMasked = cardNumberRegex.Replace(creditCard.CardNumber, "X");
return(new CreditCardDto(
cvvMasked,
creditCard.Name,
cardNumberMasked,
creditCard.ExpiryMonth,
creditCard.ExpiryYear));
}
public async System.Threading.Tasks.Task <IActionResult> CreditCardDetail(int cardId)
{
var cardRepo = _uow.GetGenericRepository <CreditCard>();
var temp = cardRepo.Find(x => x.Id == cardId).FirstOrDefault();
var dto = new CreditCardDto()
{
CardNumber = temp.CardNumber,
Cvc = temp.Cvc,
FullName = temp.FullName,
ExpiryDate = temp.ExpiryDate
};
return(View(dto)); // error message should be returned.
}
public async Task CreateAsync_Success()
{
var dto = new CreditCardDto()
{
CreditCardNumber = "9876-6534-1234-5249",
Name = "Micheal Smith",
CVC = "534",
Expiry = DateTime.Parse("2023-05-01")
};
this.creditCardRepositoryMock.Setup(x => x.CreateAsync(It.IsAny <CreditCardEntity>()));
var creditCardService = this.serviceProvider.GetService <ICreditCardService>();
await creditCardService.CreateAsync(dto);
}
public async Task <Guid> Insert(CreditCardViewModel creditCardViewModel)
{
if (creditCardViewModel == null)
{
return(Guid.Empty);
}
var creditCardDto = new CreditCardDto()
{
Name = _tokenisationService.Encrypt(creditCardViewModel.Name),
CardNumber = _tokenisationService.Encrypt(creditCardViewModel.CardNumber),
CVC = _tokenisationService.Encrypt(creditCardViewModel.CVC.ToString()),
ExpiryDate = creditCardViewModel.ExpiryDate
};
return(await _creditCardRepository.Insert(creditCardDto));
}
/// <summary>
/// Mapper from Dto to ViewModel with decryption.
/// </summary>
private CreditCardViewModel ConvertToCreditCardViewModel(CreditCardDto creditCardDto)
{
if (creditCardDto == null)
{
return(null);
}
var creditCardViewModel = new CreditCardViewModel()
{
Name = _tokenisationService.Decrypt(creditCardDto.Name),
CardNumber = _tokenisationService.Decrypt(creditCardDto.CardNumber),
CVC = Int32.Parse(_tokenisationService.Decrypt(creditCardDto.CVC)),
ExpiryDate = creditCardDto.ExpiryDate
};
return(creditCardViewModel);
}
public async Task Pay(int orderId,
CreditCardDto creditCard,
string address,
string userId)
{
if (await ValidatePayment(creditCard))
{
(await _context.Orders
.Include(x => x.User)
.FirstOrDefaultAsync(x =>
x.User != null && x.User.Id == userId &&
x.Id == orderId)).IsPaid = true;
Console.WriteLine($"Address is {address}");
}
await _context.SaveChangesAsync();
}
public async Task SaveAsync_Success()
{
var cc = new CreditCardDto()
{
CreditCardNumber = "9876-6534-1234-5249",
Name = "Micheal Smith",
CVC = "534",
Expiry = DateTime.Parse("2023-05-01")
};
this.creditCardServiceMock.Setup(x => x.CreateAsync(cc));
var creditCardController = this.serviceProvider.GetService <CreditCardController>();
var okResult = (OkResult)await creditCardController.SaveAsync(cc);
Assert.IsInstanceOfType(okResult, typeof(OkResult));
}
