public ActionResult PaymentInformation(CreditCardModel cardInfo, ChangeStepType changeStep)
{
if (changeStep == ChangeStepType.Previous)
{
return(this.RedirectToAction("PaymentMethod"));
}
string paymentMethod = Session["payment_method_provider"].ToString();
if (paymentMethod.Equals("Payments.SamplePaymentService", StringComparison.OrdinalIgnoreCase))
{
var actionResult = this.checkoutService.GetPaymentServiceActionResult(cardInfo.ResultAccessCode);
if (!actionResult.Success ||
!string.Equals(actionResult.AuthorizationResult, AuthorizationResult.Success.ToString(), StringComparison.OrdinalIgnoreCase))
{
// authorization failed.
return(PaymentInformationViewSelector(paymentMethod));
}
cardInfo.CardToken = actionResult.CardToken;
}
if (changeStep == ChangeStepType.Next && cardInfo != null)
{
if (!paymentMethod.Equals("Payments.Manual") || this.ModelState.IsValid)
{
//session save
Session["order_payment_info"] = cardInfo;
return(RedirectToAction("Confirmation"));
}
}
return(PaymentInformationViewSelector(paymentMethod));
}
internal static string Get(string companyToken, string transactionToken, CreditCardModel model)
{
var xmlDocument = new XDocument(new XDeclaration("1.0", "utf-8", "no"));
var root = new XElement("API3G",
new XElement("CompanyToken", companyToken),
new XElement("Request", RequestTypes.ChargeToken),
new XElement("TransactionToken", transactionToken)
);
if (model != null)
{
root.Add(new XElement("CreditCardNumber", model.CreditCardNumber));
root.Add(new XElement("CreditCardExpiry", model.CreditCardExpiry));
root.Add(new XElement("CreditCardCVV", model.CreditCardCvv));
root.Add(new XElement("CardHolderName", model.CardHolderName));
}
xmlDocument.Add(root);
using (var sw = new Utf8StringWriter())
{
xmlDocument.Save(sw, SaveOptions.None);
return(sw.ToString());
}
}
public ActionResult Checkout(Order order)
{
if (ModelState.IsValid)
{
if (_orderService.SaveOrderWhitAllData(order))
{
_cartService.RemoveCart(HttpContext.Session.GetString("CartId"));
HttpContext.Session.Remove(SessionCartId);
}
if (!order.Anonymous)
{
var user = _context.Users.FirstOrDefault(u => u.Id == order.UserId);
ViewBag.UserAddress = user.Address;
ViewBag.UserZipCode = user.ZipCode;
ViewBag.UserCity = user.City;
}
if (order.PayMethod == PayMethods.CreditCard)
{
//ViewBag.OrderId = order.OrderId;
var creditCardModel = new CreditCardModel();
creditCardModel.OrderId = order.OrderId;
return(View("CreditCardView", creditCardModel));
}
return(View("BakeConfirmed", order));
}
var orderTwo = _context.Orders.Include(o => o.CartItems).First(o => o.OrderId == order.OrderId);
return(View(orderTwo));
}
public PaymentGatwayPageViewModel(int id)
{
CreditCardModel = new CreditCardModel();
Title = "Card Details";
redVoznjeID = id;
SubmitCommand = new Command(async() => await DelegateCommand());
}
public void CartaoCreditoData(CreditCardModel cartao)
{
_browser.FindCss("input[placeholder='Nome do titular']").SendKeys(cartao.Name);
_browser.FindCss("input[placeholder='Número do cartão']").SendKeys(cartao.NumberCard);
_browser.FindCss("input[placeholder='Validade']").SendKeys(cartao.ValidationCard);
_browser.FindCss("input[placeholder='CVV']").SendKeys(cartao.NumberCardSegrete);
}
public async Task <IHttpActionResult> PayCreditCard(CreditCardModel creditCard)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
string Email = User.Identity.GetUserName();
ResponceSession SessionData = new ResponceSession();
long UserId = db.Users.Where(c => c.Email == Email).Select(s => s.Id).FirstOrDefault();
var currency = Utilities._currencyDTO.Where(c => c.UserIdentity == User.Identity.GetUserId()).Select(s => s.Name).FirstOrDefault();
try
{
long result = Utilities.SetOrderDetails(db, false, null, User.Identity.GetUserId(), UserId, currency);
if (result == -1)
{
return(NotFound());
}
string APIURL = WebConfigurationManager.AppSettings["APIURL"];
SessionData = await Utilities.CallOutAPI <ResponceSession>(APIURL, new ResponceSession());
SessionData.merchantName = "Merchant.MODERNMOTORS";
return(Ok(new { orderId = result, currency = currency, sessionId = SessionData.session?.id, merchantName = SessionData.merchantName, merchantId = SessionData.merchant }));
}
catch (Exception ex)
{
return(Ok(new { ex = ex, responce = SessionData }));
}
}
public IActionResult placeOrder(string cardholderName, int cardNumber, DateTime expiryDate, int securityCode,
string name, string address, string city, string state, int zipCode)
{
var card = new CreditCardModel();
if (validateCardInfo(name, cardNumber, expiryDate, securityCode))
{
card.cardholderName = name;
card.cardNumber = cardNumber;
card.expiryDate = expiryDate;
card.securityCode = securityCode;
}
else
{
ViewBag.Info = "One or more fields are invalid. Please re-enter your information.";
return(View("Order"));
}
if (validateShippingInfo(name, address, city, state, zipCode))
{
var thisAddress = new ShippingAddressModel();
thisAddress.name = name;
thisAddress.address = address;
thisAddress.city = city;
thisAddress.state = state;
thisAddress.zipCode = zipCode;
}
else
{
ViewBag.Info = "One or more fields are invalid. Please re-enter your information.";
return(View("Order"));
}
return(View("Views/Home/Index.cshtml"));
}
public Error InsertOrUpdateCreditCard(CreditCardModel card, string lockGuid)
{
var error = validateCreditCardModel(card);
if (!error.IsError)
{
// Check that the lock is still current
if (!db.IsLockStillValid(typeof(CreditCard).ToString(), card.Id, lockGuid))
{
error.SetError(EvolutionResources.errRecordChangedByAnotherUser, "CreditCardNo");
}
else
{
CreditCard temp = null;
if (card.Id != 0)
{
temp = db.FindCreditCard(card.Id);
}
if (temp == null)
{
temp = new CreditCard();
}
MapToEntity(card, temp);
db.InsertOrUpdateCreditCard(temp);
card.Id = temp.Id;
}
}
return(error);
}
/// <summary>
/// Save credit card
/// </summary>
/// <param name="creditCardModel">Model of credit card</param>
public void Save(CreditCardModel creditCardModel)
{
if (IsValid(creditCardModel.CreditCardId, out _))
{
var creditCard = GetCreditCard(creditCardModel.CreditCardId);
var isNew = creditCard == null;
if (isNew)
{
creditCard = Mediachase.Commerce.Customers.CreditCard.CreateInstance();
}
MapToCreditCard(creditCardModel, ref creditCard);
if (isNew)
{
//Create CC for user
if (creditCard.OrganizationId == null)
{
creditCard.ContactId = PrimaryKeyId.Parse(_customerService.GetCurrentContactViewModel().ContactId.ToString());
}
BusinessManager.Create(creditCard);
}
else
{
BusinessManager.Update(creditCard);
}
}
}
public static void Run()
{
// I am showing this in code, but you would normally
// do this with your DI container in your composition
// root, and the instance would be created by injecting
// it somewhere.
var paymentStrategy = new PaymentStrategy(
new IPaymentService[]
{
new CreditCardPayment(), // <-- inject any dependencies here
new PayPalPayment() // <-- inject any dependencies here
});
// Then once it is injected, you simply do this...
var cc = new CreditCardModel()
{
CardHolderName = "Bob"
};
paymentStrategy.MakePayment(cc);
// Or this...
var pp = new PayPalModel()
{
UserName = "******"
};
paymentStrategy.MakePayment(pp);
}
public CreditCardModel GetCard(int id)
{
var card = new CreditCardModel();
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
using (var command = new SqlCommand())
{
command.CommandText =
"SELECT Id, Name, Number, ExpiryMonth, ExpiryYear, CVV FROM CreditCards WHERE Id = " + id;
command.CommandType = CommandType.Text;
command.Connection = connection;
var reader = command.ExecuteReader();
if (reader.HasRows)
{
reader.Read();
card.Id = reader.GetInt32(0);
card.Name = reader.GetString(1);
card.Number = reader.GetString(2);
card.ExpiryMonth = reader.GetInt32(3);
card.ExpiryYear = reader.GetInt32(4);
card.Cvv = reader.GetString(5);
}
reader.Close();
}
}
return(card);
}
//Change this to IConsumerDebt
public void SaveData(CreditCardModel ccData)
{
var ccTableData = new CreditCardTableData
{
VendorName = ccData.CardVendor,
AccountNickName = ccData.CardNickname,
CreditCardType = ccData.CardType,
OwingBalance = ccData.CardBalance,
CreditLine = ccData.CardBalance
};
int CreditCardId = CreditCardDbService.Add(ccTableData);
foreach (InterestRateModel item in ccData.InterestRates)
{
var interestData = new InterestRateTableData
{
CreditCardFK = CreditCardId,
StartDate = item.StartDate,
EndDate = item.EndDate,
InterestRate = item.InterestRate
};
InterestRateDbService.Add(interestData);
}
}
private CreditCardModel addCreditCard(CompanyModel company, CustomerModel customer)
{
var now = DateTime.Now;
var cardProvider = LookupService.FindCreditCardProviders().First();
CreditCardModel model = new CreditCardModel {
CompanyId = company.Id,
CustomerId = customer.Id,
CreditCardProviderId = Convert.ToInt32(cardProvider.Id),
CardProviderName = cardProvider.Text,
CardProviderLogo = "/Content/CreditCards/" + cardProvider.ImageURL,
CreditCardNo = RandomString().Left(16),
NameOnCard = RandomString().Left(42),
Expiry = $"{now.Day}/18",
CCV = RandomInt().ToString().PadLeft(3).Right(3),
Notes = "",
Enabled = true
};
var error = CustomerService.InsertOrUpdateCreditCard(model, "");
Assert.IsTrue(!error.IsError, error.Message);
model.CreditCardNo = model.CreditCardNo.ObscureString(true);
return(model);
}
public static AuthOrSaleRequestModel GetDummyAuthRequestModel()
{
var card = new CreditCardModel();
var transaction = new TransactionModel();
var customer = new CustomerInfoModel
{
BillingAddress = new BillingAddressModel(),
ShippingAddress = new ShippingAddressModel()
};
var orderItem1 = new OrderItemModel();
var orderItem2 = new OrderItemModel();
var orderItems = new[] { orderItem1, orderItem2 };
var order = new OrderModel {
OrderItems = orderItems
};
var request = new AuthOrSaleRequestModel
{
CreditCard = card,
CustomerInfo = customer,
Transaction = transaction,
Order = order
};
return(request);
}
public void PaymnentCreditCardSaved()
{
var cartaoCreditoData = new CreditCardModel()
{
Name = "Meu Cartao",
NumberCard = "4242424242424242",
ValidationCard = "1120",
NumberCardSegrete = "123",
};
_product.AddProductCartPay();
_cart.ConfirmPaymentCart();
_cartao.SelectCreditCard();
_dataAccess.InputDataFirstAccess();
_cartao.CartaoCreditoData(cartaoCreditoData);
_cartao.ConfirmPaymentCreditCard();
Assert.AreEqual("Pedido Recebido!", _cartao.MessagePaymentSuccess());
Browser.Visit("/");
_product.AddProductCartPay();
_cart.ConfirmPaymentCart();
_cartao.SelectCreditCard();
_cartao.ConfirmPaymentCreditCard();
Assert.AreEqual("Pedido Recebido!", _cartao.MessagePaymentSuccess());
}
private bool FillForPhysical()
{
using SqlConnection sqlConnection = new SqlConnection(DataBase.ConnectionString);
try
{
sqlConnection.Open();
SqlCommand command = new SqlCommand("SELECT * FROM [CreditCardPhysical] WHERE (Id = @Id AND Password = @Password)", sqlConnection);
command.Parameters.AddWithValue("Id", Id);
command.Parameters.AddWithValue("Password", Password);
SqlDataReader sqlReader = command.ExecuteReader();
sqlReader.Read();
CurrentCreditLimit = Convert.ToDecimal(sqlReader["CurrentCreditLimit"]);
ValidityStart = Convert.ToDateTime(sqlReader["ValidityStart"]);
int idModel = Convert.ToInt32(sqlReader["IdCardModel"]);
sqlReader.Close();
SqlCommand command1 = new SqlCommand("SELECT * FROM [CreditCardModel] WHERE (Id = @Id)", sqlConnection);
command1.Parameters.AddWithValue("Id", idModel);
SqlDataReader sqlReader1 = command1.ExecuteReader();
sqlReader1.Read();
string name = Convert.ToString(sqlReader1["Name"]);
CardModel = new CreditCardModel(name);
sqlReader1.Close();
sqlConnection.Close();
return(true);
}
catch (SqlException ex)
{
throw new Exception("Работа базы данных нарушена", ex);
}
finally
{
sqlConnection.Close();
}
}
/// <summary>
/// Create Charge with customer
/// </summary>
/// <param name="creditCard"></param>
/// <returns></returns>
public async Task <StripeCharge> ChargeCardAsync(CreditCardModel creditCard, Citation citation, CommonAccount account, ChargeTypeEnum chargeType)
{
Check.NotNull(creditCard, nameof(creditCard));
var metaData = new Dictionary <string, string>();
metaData["Account"] = account.Name;
metaData["AccountNumber"] = account.Number.ToString();
metaData["CitationNumber"] = citation.CitationNumber.ToString();
metaData["Type"] = chargeType.GetDescription();
// Token is created using Checkout or Elements!
// Get the payment token submitted by the form:
var token = creditCard.SourceToken; // Using ASP.NET MVC
var options = new StripeChargeCreateOptions
{
Amount = creditCard.Amount,
Currency = "usd",
Description = chargeType.GetDescription(),
SourceTokenOrExistingSourceId = token,
Metadata = metaData
};
var service = new StripeChargeService();
StripeCharge charge = await service.CreateAsync(options);
return(charge);
}
/// <inheritdoc />
public ChargeTokenResponse ChargeToken(string transactionToken, CreditCardModel model)
{
if (string.IsNullOrWhiteSpace(transactionToken))
{
return(new ChargeTokenResponse
{
Result = "-99",
ResultExplanation = "a TransactionToken is required"
});
}
var validationResults = model.Validate().ToList();
if (validationResults.Any())
{
return(new ChargeTokenResponse
{
Result = "-99",
ResultExplanation = validationResults.Select(x => x.ErrorMessage).Aggregate((i, j) => i + "," + j)
});
}
var xml = ChargeTokenRequestXml.Get(_companyToken, transactionToken, model);
//Get the response
var responseXml = _url.PostXmlToUrl(xml).AddResultExplanationCdata(_bypassCdataMod);
var response = responseXml.FromXml <ChargeTokenResponse>();
Debug.WriteLine(response);
return(response);
}
/// <summary>
/// این متد عملیات انقال وجه را آماده سازی میکند و اطلاعات حساب مقصد (نام حساب) را بر میگرداند
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public string ReadyForTransfer(CreditCardModel model)
{
var creditCardEntity = _mapper.Map <CreditCardEntity>(model);
List <string> responseText = new List <string>();
if (!model.CardNumber.ToString().Substring(6, 1).Equals("3"))
{
throw ExManager.CreditCardException();
}
if (!model.DestinationCardNumber.ToString().Substring(6, 1).Equals("3"))
{
throw ExManager.CreditCardException();
}
if (!(model.CVV2.ToString().Trim().Length >= 3 && model.CVV2.ToString().Trim().Length <= 4))
{
throw ExManager.CVV2Exception();
}
if (model.ExpireYear < CurrentDate || model.ExpireYear.ToString().Trim().Length != 2)
{
throw ExManager.YearException();
}
if (!(model.ExpireMonth > 0 && model.ExpireMonth <= 12) || model.ExpireMonth.ToString().Trim().Length != 2)
{
throw ExManager.MonthException();
}
if (!(Convert.ToInt64(model.Amount) >= 10000 && Convert.ToInt64(model.Amount) <= 3000000))
{
throw ExManager.AmountException();
}
return(_portalRepository.ReadyForTransfer(creditCardEntity));
}
public void PayDebtCreditCard(CreditCardModel creditCard)
{
using (var ts = new TransactionScope())
{
var account = usersFcd.GetUserAccountById(creditCard.AccountId);
var provisionAmount = creditCard.CashAmount - creditCard.Debit;
if (provisionAmount < 0)
{
provisionAmount = 0;
}
var debitAmount = creditCard.CashAmount - provisionAmount;
creditCard.Debit -= debitAmount;
creditCard.Provision -= provisionAmount;
cardsDAO.UpdateCreditCard(creditCard);
cardsDAO.DepositMoneyToAccount((int)Consts.Consts.AccountNumbers.SystemAccountId, creditCard.CashAmount);
cardsDAO.WithdrawMoneyFromAccount(creditCard.AccountId, creditCard.CashAmount);
cardsDAO.CreateOperationHistory(new DAL.PaymentCardsOperationHistory()
{
BalanceChange = creditCard.CashAmount * (-1),
CreditCardId = creditCard.Id,
CreditCardTypeId = 1001,
DateIssued = DateTime.Now,
OperationTypeId = 3006,
UserId = account.UserId
});
ts.Complete();
}
}
public static IEnumerable <ValidationResult> Validate(this CreditCardModel requestData)
{
var validationResults = new List <ValidationResult>();
validationResults.AddRange(ClassValidator <CreditCardModel> .Validate(requestData));
return(validationResults);
}
public void MapToEntity(CreditCardModel model, CreditCard entity)
{
Mapper.Map <CreditCardModel, CreditCard>(model, entity);
entity.CreditCardNo = RFC2898.Encrypt(model.CreditCardNo, Password);
entity.NameOnCard = RFC2898.Encrypt(model.NameOnCard, Password);
entity.Expiry = RFC2898.Encrypt(model.Expiry, Password);
entity.CCV = RFC2898.Encrypt(model.CCV, Password);
}
public async Task <IActionResult> AddCreditCardDb(CreditCardModel res)
{
await _userRepository.AddCreditCard(res);
CinemaCreditCardGetDetailsRes created = await _userRepository.GetUserCreditCard(res);
return(View("CardAdded", (object)created));
}
public PaymentVM(int TuristRutaId, int KorisnikId, INavigation nav)
{
_TuristRutaId = TuristRutaId;
_KorisnikId = KorisnikId;
this.Navigation = nav;
CreditCardModel = new CreditCardModel();
Title = "Card Details";
}
public CreditCardControl(CreditCardModel debitCardModel, IPerson person)
{
InitializeComponent();
_person = person;
_creditCardModel = debitCardModel;
DataContext = debitCardModel;
}
/// <summary>
/// Load data for a credit card
/// </summary>
/// <param name="creditCardModel">Model of credit card</param>
public void LoadCreditCard(CreditCardModel creditCardModel)
{
var creditCard = GetCreditCard(creditCardModel.CreditCardId);
if (creditCard != null)
{
MapToModel(creditCard, ref creditCardModel);
}
}
public ActionResult Preview(CreditCardModel model)
{
if (!ModelState.IsValid)
{
return(null);
}
return(View(model));
}
public void UpdateCreditCard(CreditCardModel model)
{
var card = GetCreditCardById(model.BaseCardId);
card.Debit = model.Debit;
card.Provision = model.Provision;
context.Entry(card).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
}
public ServiceResponse <string> Create([FromBody] CreateCreditCardModel createModel)
{
var response = new ServiceResponse <string>();
int expirationYear;
Int32.TryParse(createModel.ExpirationYear, out expirationYear);
int expirationMonth;
Int32.TryParse(createModel.ExpirationMonth, out expirationMonth);
int cvv;
Int32.TryParse(createModel.Cvv, out cvv);
var model = new CreditCardModel();
model.ExpirationMonth = expirationMonth;
model.ExpirationYear = expirationYear;
model.BinNumber = createModel.CardNumber.Substring(0, Math.Min(createModel.CardNumber.Length, 6));
model.LastFour = createModel.CardNumber.Substring(createModel.CardNumber.Length - Math.Min(createModel.CardNumber.Length, 4));
model.UserId = CurrentUser.ID;
model.IsActive = true;
model.IsDeleted = false;
var validationResult = _creditCardModelValidator.Validate(model);
if (validationResult.IsValid)
{
var token = _braintreeWarpper.Tokenize(CurrentUser.FirstName, CurrentUser.LastName, CurrentUser.UserName, createModel.CardNumber, expirationYear, expirationMonth, cvv);
model.Token = token;
if (!string.IsNullOrWhiteSpace(token))
{
var entity = new CreditCardConverter().Convert(model);
var serviceResponse = _creditCardService.Create(entity);
response.IsSuccessed = serviceResponse.IsSuccessed;
response.Errors = serviceResponse.Errors;
response.Data = model.Token;
}
else
{
response.IsSuccessed = false;
response.Errors.Add(new ServiceError()
{
Code = "2009062323", InnerMessage = "Token can not created.", Message = "Credit card can not accepted!"
});
}
}
else
{
_logger.Error("{source} {template} {logtype} {ValidationError}", "controller", "CreditCardEntity", "validationerror", validationResult.Errors);
response.IsSuccessed = false;
response.Errors = new ValidationFailureConverter().Convert(validationResult.Errors.ToList());
}
return(response);
}
public void TestInitialize()
{
_card2 = new CreditCardModel
{
CardNumber = "11122233344455",
CardType = "Vista",
ExpMonth = 6,
ExpYear = 21
};
}
public static void CreateTransactionWithCustomer(string enviroment, string merchantId, string publicKey, string privateKey, CustomerModel customer, CreditCardModel creditCard, PaymentModel payment)
{
try
{
// var transactionRequest = new TransactionRequest
// {
// Amount = payment.Amount,
// Customer = new CustomerRequest
// {
// FirstName = customer.FirstName,
// LastName = customer.LastName,
// Email = customer.Email
// },
// CreditCard = new TransactionCreditCardRequest
// {
// Number = creditCard.CardNumber,
// CVV = creditCard.SecurityNumber,
// ExpirationMonth = creditCard.ExpiryMonth.ToString(),
// ExpirationYear = creditCard.ExpiryYear.ToString(),
// }
// };
// var result = BrainTreeSerivce.Instance.GetBrainTreeGateway(enviroment, merchantId, publicKey,privateKey).Transaction.Sale(transactionRequest);
// Result<Transaction> settle = BrainTreeSerivce.Instance.GetBrainTreeGateway(enviroment, merchantId, publicKey, privateKey).Transaction.SubmitForSettlement("");
// var settleAmount = settle.Transaction.Amount;
// if (!result.IsSuccess())
// throw new Exception(result.Message);
}
catch (Braintree.Exceptions.AuthenticationException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.AuthorizationException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.DownForMaintenanceException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.InvalidChallengeException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.InvalidSignatureException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.NotFoundException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.ServerException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.UnexpectedException ex)
{
throw new ApplicationException(ex.Message);
}
catch (Braintree.Exceptions.UpgradeRequiredException ex)
{
throw new ApplicationException(ex.Message);
}
}
