public async Task <bool> AddOrUpdateCreditCard(CreditCardInfos creditCard, string kountSessionId, bool isUpdate = false)
{
try
{
await TokenizeCard(creditCard, kountSessionId);
}
catch
{
return(false);
}
var request = new CreditCardRequest
{
CreditCardCompany = creditCard.CreditCardCompany,
CreditCardId = creditCard.CreditCardId,
NameOnCard = creditCard.NameOnCard,
Last4Digits = creditCard.Last4Digits,
Token = creditCard.Token,
ExpirationMonth = creditCard.ExpirationMonth,
ExpirationYear = creditCard.ExpirationYear,
Label = creditCard.Label,
ZipCode = creditCard.ZipCode,
StreetNumber = creditCard.StreetNumber,
StreetName = creditCard.StreetName,
Email = creditCard.Email,
Phone = creditCard.Phone,
Country = creditCard.Country
};
await UseServiceClientAsync <IAccountServiceClient> (client =>
!isUpdate
?client.AddCreditCard (request)
: client.UpdateCreditCard(request));
if (isUpdate || CurrentAccount.DefaultCreditCard == null)
{
var creditCardDetails = new CreditCardDetails
{
AccountId = CurrentAccount.Id,
CreditCardId = request.CreditCardId,
CreditCardCompany = request.CreditCardCompany,
NameOnCard = request.NameOnCard,
Token = request.Token,
Last4Digits = request.Last4Digits,
ExpirationMonth = request.ExpirationMonth,
ExpirationYear = request.ExpirationYear,
IsDeactivated = false,
StreetNumber = request.StreetNumber,
StreetName = request.StreetName,
Email = request.Email,
Phone = request.Phone,
Country = request.Country
};
UpdateCachedAccount(creditCardDetails, ChargeTypes.CardOnFile.Id, false, true);
}
return(true);
}
//IClonable Override
public virtual object Clone()
{
CreditCardDetails instance = new CreditCardDetails() ;
instance.CCNumber = CCNumber ;
instance.ExpirationDate = ExpirationDate ;
instance.Rating = Rating ;
return instance;
}
public void TestProceessAmount_VerifyMethodCalls(decimal amount, string creditCardNumber, string creditCardHolder, string expiryDate,
string securityCode, string guid, string status)
{
//arrange
PaymentModel model = new PaymentModel()
{
Amount = amount,
CardHolder = creditCardHolder,
CreditCardNumber = creditCardNumber,
ExpirationDate = DateTime.Parse(expiryDate),
SecurityCode = securityCode
};
CreditCardDetails creditCardDetails = new CreditCardDetails()
{
CardHolder = creditCardHolder,
CreditCardNumber = creditCardNumber,
ExpirationDate = DateTime.Parse(expiryDate),
SecurityCode = securityCode
};
PaymentState paymentState = new PaymentState()
{
Amount = amount,
CreditCardNo = creditCardNumber,
StateOfTransation = status,
TransactionId = Guid.Parse(guid)
};
mockMapper.Setup(x => x.Map <CreditCardDetails>(model)).Returns(creditCardDetails);
mockDataDal.Setup(x => x.InsertCreditCardDetails(creditCardDetails));
mockPaymentFactory.Setup(x => x.GetPaymentGateway(amount)).Returns(PaymentStatus.Processed);
mockMapper.Setup(x => x.Map <PaymentState>(model)).Returns(paymentState);
mockDataDal.Setup(x => x.InsertTransactionDetails(paymentState));
//act
sut = new ProcessGateway(mockPaymentFactory.Object, mockMapper.Object, mockDataDal.Object);
sut.ProceessAmount(model);
//Verify
mockMapper.Verify(x => x.Map <CreditCardDetails>(model), Times.Once());
mockDataDal.Verify(x => x.InsertCreditCardDetails(creditCardDetails), Times.Once());
mockPaymentFactory.Verify(x => x.GetPaymentGateway(amount), Times.Once());
mockMapper.Verify(x => x.Map <PaymentState>(model), Times.Once());
mockDataDal.Verify(x => x.InsertTransactionDetails(paymentState), Times.Once());
}
//IClonable Override
public virtual object Clone()
{
CreditCardDetails instance = new CreditCardDetails();
instance.CCNumber = CCNumber;
instance.ExpirationDate = ExpirationDate;
instance.Rating = Rating;
return(instance);
}
private bool HasValidDate(string month, string year)
{
var creditCard = new CreditCardDetails
{
ExpirationMonth = month,
ExpirationYear = year
};
return(!creditCard.IsExpired());
}
public void LauraBuyAndThePurchaseIsValid()
{
List <Item> items = NewItems("pull rouge", "pantalon noir");
CreditCardDetails creditCardDetails = new CreditCardDetails("6546597543445912");
Address address = new Address("55 Rue du Faubourg Saint-Honoré");
PurchaseResult purchaseResult = NewPurchase.Confirm(items, address, creditCardDetails);
Assert.True(purchaseResult.IsValid);
}
public void JohnBuyButAddressIsInexistant()
{
List <Item> items = NewItems("pull rouge", "pull violet");
CreditCardDetails creditCardDetails = new CreditCardDetails("7526215354358945");
Address address = new Address("77 Avenue du Jambon");
PurchaseResult purchaseResult = NewPurchase.Confirm(items, address, creditCardDetails);
Assert.False(purchaseResult.IsValid);
Assert.NotEmpty(purchaseResult.Errors);
Assert.Equal("adresse inexistante", purchaseResult.Errors.First());
}
public void KevinBuyButOneArticleIsNoLongerAvailable()
{
List <Item> items = NewItems("tee-shirt rouge", "short blanc", "pull violet");
CreditCardDetails creditCardDetails = new CreditCardDetails("7895265452543153");
Address address = new Address("1 Avenue du Colonel Henri Rol-Tanguy");
PurchaseResult purchaseResult = NewPurchase.Confirm(items, address, creditCardDetails);
Assert.False(purchaseResult.IsValid);
Assert.NotEmpty(purchaseResult.Errors);
Assert.Equal("tee-shirt rouge indisponible", purchaseResult.Errors.First());
}
public void AnnaBuyButBankRejectPayment()
{
List <Item> items = NewItems("chemise verte", "pantalon noir");
CreditCardDetails creditCardDetails = new CreditCardDetails("9745965412543654");
Address address = new Address("55 Rue du Faubourg Saint-Honoré");
PurchaseResult purchaseResult = NewPurchase.Confirm(items, address, creditCardDetails);
Assert.False(purchaseResult.IsValid);
Assert.NotEmpty(purchaseResult.Errors);
Assert.Equal("solde insuffisant", purchaseResult.Errors.First());
}
private void UpdateCachedAccount(CreditCardDetails defaultCreditCard, int?chargeTypeId, bool isPayPalAccountLinked, bool shouldUpdateChargeType = false)
{
var account = CurrentAccount;
account.DefaultCreditCard = defaultCreditCard;
account.Settings.ChargeTypeId = chargeTypeId;
account.IsPayPalAccountLinked = isPayPalAccountLinked;
CurrentAccount = account;
if (shouldUpdateChargeType)
{
UpdateChargeTypes(_marketSettings).FireAndForget();
}
}
public void MarieBuyButAddressIsInexistantAndOneArticleIsNoLongerAvailableAndBankRejectPayment()
{
List <Item> items = NewItems("tee-shirt rouge", "pull rose");
CreditCardDetails creditCardDetails = new CreditCardDetails("1265599754346544");
Address address = new Address("98 Avenue du saucisson");
PurchaseResult purchaseResult = NewPurchase.Confirm(items, address, creditCardDetails);
Assert.False(purchaseResult.IsValid);
Assert.NotEmpty(purchaseResult.Errors);
Assert.Contains(purchaseResult.Errors, _ => _ == "tee-shirt rouge indisponible");
Assert.Contains(purchaseResult.Errors, _ => _ == "pull rose indisponible");
Assert.Contains(purchaseResult.Errors, _ => _ == "adresse inexistante");
Assert.Contains(purchaseResult.Errors, _ => _ == "solde insuffisant");
}
public void TestProceessAmount_WithStatus(decimal amount, string creditCardNumber, string creditCardHolder, string expiryDate,
string securityCode, string guid, string status)
{
PaymentModel model = new PaymentModel()
{
Amount = amount,
CardHolder = creditCardHolder,
CreditCardNumber = creditCardNumber,
ExpirationDate = DateTime.Parse(expiryDate),
SecurityCode = securityCode
};
CreditCardDetails creditCardDetails = new CreditCardDetails()
{
CardHolder = creditCardHolder,
CreditCardNumber = creditCardNumber,
ExpirationDate = DateTime.Parse(expiryDate),
SecurityCode = securityCode
};
PaymentState paymentState = new PaymentState()
{
Amount = amount,
CreditCardNo = creditCardNumber,
StateOfTransation = status,
TransactionId = Guid.Parse(guid)
};
mockMapper.Setup(x => x.Map <CreditCardDetails>(model)).Returns(creditCardDetails);
mockDataDal.Setup(x => x.InsertCreditCardDetails(creditCardDetails));
mockPaymentFactory.Setup(x => x.GetPaymentGateway(amount)).Returns(PaymentStatus.Processed);
mockMapper.Setup(x => x.Map <PaymentState>(model)).Returns(paymentState);
mockDataDal.Setup(x => x.InsertTransactionDetails(paymentState));
sut = new ProcessGateway(mockPaymentFactory.Object, mockMapper.Object, mockDataDal.Object);
var result = sut.ProceessAmount(model);
Assert.NotNull(result);
Assert.Equal(paymentState.Amount, result.Amount);
Assert.Equal(paymentState.CreditCardNo, result.CreditCardNo);
Assert.Equal(paymentState.TransactionId, result.TransactionId);
Assert.Equal(paymentState.StateOfTransation, result.StateOfTransation);
}
public void InsertCreditCardDetails(CreditCardDetails creditCardDetails)
{
try
{
var entity = _appDBContext.CreditCardDetails.FirstOrDefault(x => x.CreditCardNumber == creditCardDetails.CreditCardNumber);
if (entity == null)
{
_appDBContext.CreditCardDetails.Add(creditCardDetails);
_appDBContext.SaveChanges();
}
}
catch (Exception ex)
{
//log erro
}
}
public async Task <BasePaymentResponse> ValidateTokenizedCard(CreditCardDetails creditCard, string cvv, string kountSessionId, Account account)
{
try
{
var request = new TokenizeValidateRequest
{
Token = creditCard.Token,
Cvv = cvv,
SessionId = kountSessionId,
Email = account.Email,
BillingFullName = creditCard.NameOnCard,
CustomerIpAddress = _ipAddressManager.GetIPAddress()
};
if (creditCard.ZipCode.HasValue())
{
request.ZipCode = creditCard.ZipCode;
}
var response = await CmtPaymentServiceClient.PostAsync(request);
return(new BasePaymentResponse
{
IsSuccessful = response.ResponseCode == 1,
Message = response.ResponseMessage
});
}
catch (Exception e)
{
_logger.Maybe(x => x.LogMessage("Error during card validation"));
_logger.Maybe(x => x.LogError(e));
var message = e.Message;
var exception = e as AggregateException;
if (exception != null)
{
message = exception.InnerException.Message;
}
return(new BasePaymentResponse
{
IsSuccessful = false,
Message = message
});
}
}
public bool ProcessPayment(string merchantId,
string cardNumber, string expiration,
decimal amount)
{
var provider = new PayPalProvider();
try
{
var cardInfo = new CreditCardDetails(cardNumber, expiration);
provider.ProcessPayment(merchantId, cardInfo, amount);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Does the parking transaction.
/// </summary>
/// <param name="card_string">The card_string.</param>
/// <param name="swipe">The swipe.</param>
/// <returns></returns>
internal bool DoParkingTransaction(KioskMsgType card_string, string swipe)
{
bool isValid = false;
try
{
CreditCardDetails creditCard = new CreditCardDetails();
creditCard.CreditCardNumber = swipe;
creditCard.ValidTillDate = "1/1";
isValid = CCManagerSerivceProxy.IsValidCreditCard(creditCard);
}
catch (Exception ex)
{
//TODO: log exception
}
return isValid;
}
/// <summary>
/// Does the parking transaction.
/// </summary>
/// <param name="card_string">The card_string.</param>
/// <param name="swipe">The swipe.</param>
/// <returns></returns>
internal bool DoParkingTransaction(KioskMsgType card_string, string swipe)
{
bool isValid = false;
try
{
CreditCardDetails creditCard = new CreditCardDetails();
creditCard.CreditCardNumber = swipe;
creditCard.ValidTillDate = "1/1";
isValid = CCManagerSerivceProxy.IsValidCreditCard(creditCard);
}
catch (Exception ex)
{
//TODO: log exception
}
return(isValid);
}
// POST: api/CreditCard
public CreditCard Post(CreditCardDetails creditCardDetails)
{
var apiContext = Models.Configuration.GetApiContext();
// A resource representing a credit card that can be used to fund a payment.
var card = new CreditCard()
{
expire_month = int.Parse(creditCardDetails.ExpirationMonth),
expire_year = int.Parse(creditCardDetails.ExpirationYear),
number = creditCardDetails.CardNumber,
type = "visa",
cvv2 = creditCardDetails.Cvv,
};
var createdCard = card.Create(apiContext);
return(CreditCard.Get(apiContext, createdCard.id));
}
public void TestProceessAmount_Exception2(decimal amount, string creditCardNumber, string creditCardHolder, string expiryDate,
string securityCode, string guid, string status)
{
PaymentModel model = new PaymentModel()
{
Amount = amount,
CardHolder = creditCardHolder,
CreditCardNumber = creditCardNumber,
ExpirationDate = DateTime.Parse(expiryDate),
SecurityCode = securityCode
};
CreditCardDetails creditCardDetails = new CreditCardDetails()
{
CardHolder = creditCardHolder,
CreditCardNumber = creditCardNumber,
ExpirationDate = DateTime.Parse(expiryDate),
SecurityCode = securityCode
};
PaymentState paymentState = new PaymentState()
{
Amount = amount,
CreditCardNo = creditCardNumber,
StateOfTransation = status,
TransactionId = Guid.Parse(guid)
};
mockMapper.Setup(x => x.Map <CreditCardDetails>(model)).Returns(creditCardDetails);
mockDataDal.Setup(x => x.InsertCreditCardDetails(creditCardDetails));
mockPaymentFactory.Setup(x => x.GetPaymentGateway(amount)).Returns(PaymentStatus.Processed);
mockMapper.Setup(x => x.Map <PaymentState>(model)).Returns(paymentState);
mockDataDal.Setup(x => x.InsertTransactionDetails(paymentState)).Throws(new Exception());
mockMapper.Setup(x => x.Map <PaymentState>(model)).Returns(paymentState);
Assert.Equal(amount, paymentState.Amount);
Assert.Equal(creditCardNumber, paymentState.CreditCardNo);
Assert.Equal(Guid.Parse(guid), paymentState.TransactionId);
Assert.Equal(status, paymentState.StateOfTransation);
}
protected void BtnUpdateClick(object sender, EventArgs e)
{
if (Page.IsValid)
{
try
{
long cardId = Convert.ToInt64(Request.QueryString["card"]);
long number = Convert.ToInt64(txtCreditNumber.Text);
int verification = Convert.ToInt32(txtVerificationCode.Text);
System.DateTime date = DateTime.ParseExact(txtExpirationDate.Text, "MM/yy", null);
if (date.Year.CompareTo(System.DateTime.Now.Year) < 0 || (date.Year.CompareTo(System.DateTime.Now.Year) == 0 && date.Month.CompareTo(System.DateTime.Now.Month) < 0))
{
lblDateError.Visible = true;
lblNumberError.Visible = false;
return;
}
CreditCardDetails creditCardDetails =
new CreditCardDetails(comboCreditType.SelectedValue, number,
verification, date, 0, SessionManager.GetUserSession(Context).UserProfileId);
SessionManager.UpdateCreditCardDetails(Context, cardId, checkDefault.Checked, creditCardDetails);
Response.Redirect(
Response.ApplyAppPathModifier("~/Pages/User/ListCreditCards.aspx"));
}
catch (DuplicateInstanceException)
{
lblNumberError.Visible = true;
}
catch (FormatException)
{
lblDateError.Visible = true;
lblNumberError.Visible = false;
}
}
}
///<summary>To add credit card details</summary>
///<param name="creditcardmodel">EmpModel class</param>
/// <returns>Returns success message</returns>
public string AddCreditCardDetails(CreditCardDetails ccDetails)
{
responseMsg = string.Empty;
try
{
this.sqlConn.Open();
SqlCommand sqlCmd = new SqlCommand("spAddCreditCardDetails", this.sqlConn);
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.Parameters.Add("@EmpID", SqlDbType.Int).Value = ccDetails.Emp_ID;
sqlCmd.Parameters.Add("@CardHolder", SqlDbType.NVarChar).Value = ccDetails.CardHolder;
sqlCmd.Parameters.Add("@CardType", SqlDbType.Int).Value = ccDetails.CardTypeID;
sqlCmd.Parameters.Add("@CardNumber", SqlDbType.NVarChar).Value = ccDetails.CardNumber;
sqlCmd.Parameters.Add("@CardExpMonth", SqlDbType.Int).Value = ccDetails.Card_Exp_Month_ID;
sqlCmd.Parameters.Add("@CardExpYear", SqlDbType.Int).Value = ccDetails.Card_Exp_Year_ID;
sqlCmd.Parameters.Add("@CreatedBy", SqlDbType.NVarChar).Value = ccDetails.Created_By;
sqlCmd.Parameters.Add("@Name", SqlDbType.NVarChar).Value = ccDetails.Name;
sqlCmd.Parameters.Add("@Address", SqlDbType.NVarChar).Value = ccDetails.Address;
sqlCmd.Parameters.Add("@CountryID", SqlDbType.Int).Value = ccDetails.Country_ID;
sqlCmd.Parameters.Add("@PostalCode", SqlDbType.NVarChar).Value = ccDetails.PostalCode;
sqlCmd.Parameters.Add("@MobileNumber", SqlDbType.NVarChar).Value = ccDetails.BillingPhoneNumber;
sqlCmd.Parameters.Add("@Email", SqlDbType.NVarChar).Value = ccDetails.BillingEmail;
sqlCmd.Parameters.Add("@ResponseMsg", SqlDbType.NVarChar, 2000).Direction = ParameterDirection.Output;
sqlCmd.ExecuteNonQuery();
responseMsg = Convert.ToString(sqlCmd.Parameters["@ResponseMsg"].Value);
}
catch (Exception ex)
{
throw ex;
}
finally
{
this.sqlConn.Close();
this.sqlConn.Dispose();
}
return(responseMsg);
}
public string CreditCardAndBillingDetails(string cardHolderName, int cardType, string cardNumber, int CVV, int cardExpMonth, int cardExpYear,
string Name, string address, int country, string postalCode, string phoneNumber, string email)
{
empDetails = new EmployeeDetails();
ccDetails = new CreditCardDetails();
repository = new ICONHRRepository();
responseMsg = string.Empty;
int empId = 0;
try
{
//Employee details
empDetails = (EmployeeDetails)Session["EmployeeModel"];
empDetails.Country_ID = Convert.ToInt32(country);
responseMsg = repository.AddNewEmpDetails(empDetails);
string[] arrResponse = responseMsg.Split(',');
if (response.Length > 1)
{
responseMsg = Convert.ToString(arrResponse[0]);
empId = Convert.ToInt32(arrResponse[1]);
if (empId != 0)
{
// Card Card details
repository = new ICONHRRepository();
ccDetails.Emp_ID = empId;
ccDetails.CardHolder = cardHolderName;
ccDetails.CardTypeID = cardType;
ccDetails.CardNumber = cardNumber;
ccDetails.CVV = CVV;
ccDetails.Card_Exp_Month_ID = cardExpMonth;
ccDetails.Card_Exp_Year_ID = cardExpYear;
// Billing details
ccDetails.Name = Name;
ccDetails.Address = address;
ccDetails.Country_ID = country;
ccDetails.PostalCode = postalCode;
ccDetails.BillingEmail = email;
ccDetails.BillingPhoneNumber = phoneNumber;
ccDetails.Created_By = empDetails.Created_By;
responseMsg = repository.AddCreditCardDetails(ccDetails);
if (responseMsg == response)
{
Session["EmployeeModel"] = null;
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace(ex, true);
var frame = trace.FrameCount > 1 ? trace.GetFrame(1) : trace.GetFrame(0);
int Line = (int)frame.GetFileLineNumber();
string methodName = this.ControllerContext.RouteData.Values["action"].ToString();
string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
LogClass.CreateLogXml(ex.Message, controllerName, Convert.ToString(ex.InnerException), methodName, Line);
}
return(responseMsg);
}
public Task <BasePaymentResponse> ValidateTokenizedCard(CreditCardDetails creditCard, string cvv, string kountSessionId, Account account)
{
return(GetClient().ValidateTokenizedCard(creditCard, cvv, kountSessionId, account));
}
public PersistedCheckoutContextBuilder WithCreditCard(CreditCardDetails creditCard)
{
CreditCard = creditCard;
CreditCardSet = true;
return(this);
}
public Task<BasePaymentResponse> ValidateTokenizedCard(CreditCardDetails creditCard, string cvv, string kountSessionId, Account account)
{
return Task.FromResult(new BasePaymentResponse { IsSuccessful = true });
}
public override async void BaseStart()
{
using (this.Services().Message.ShowProgress())
{
IsPayPalAccountLinked = _accountService.CurrentAccount.IsPayPalAccountLinked;
CreditCardCompanies = new List <ListItem>
{
new ListItem {
Display = Visa, Id = 0
},
new ListItem {
Display = MasterCard, Id = 1
},
new ListItem {
Display = Amex, Id = 2
},
new ListItem {
Display = VisaElectron, Id = 3
},
new ListItem {
Display = Discover, Id = 4
},
new ListItem {
Display = CreditCardGeneric, Id = 5
}
};
ExpirationYears = new List <ListItem>();
for (var i = 0; i <= 15; i++)
{
ExpirationYears.Add(new ListItem {
Id = DateTime.Today.AddYears(i).Year, Display = DateTime.Today.AddYears(i).Year.ToString(CultureInfo.InvariantCulture)
});
}
ExpirationMonths = new List <ListItem>
{
new ListItem {
Display = this.Services().Localize["January"], Id = 1
},
new ListItem {
Display = this.Services().Localize["February"], Id = 2
},
new ListItem {
Display = this.Services().Localize["March"], Id = 3
},
new ListItem {
Display = this.Services().Localize["April"], Id = 4
},
new ListItem {
Display = this.Services().Localize["May"], Id = 5
},
new ListItem {
Display = this.Services().Localize["June"], Id = 6
},
new ListItem {
Display = this.Services().Localize["July"], Id = 7
},
new ListItem {
Display = this.Services().Localize["August"], Id = 8
},
new ListItem {
Display = this.Services().Localize["September"], Id = 9
},
new ListItem {
Display = this.Services().Localize["October"], Id = 10
},
new ListItem {
Display = this.Services().Localize["November"], Id = 11
},
new ListItem {
Display = this.Services().Localize["December"], Id = 12
}
};
Data = new CreditCardInfos();
CreditCardDetails creditCard = null;
try
{
var creditCards = (await _accountService.GetCreditCards()).ToList();
_numberOfCreditCards = creditCards.Count;
if (!_isAddingNew)
{
creditCard = _creditCardId == default(Guid)
? await _accountService.GetDefaultCreditCard()
: creditCards.First(c => c.CreditCardId == _creditCardId);
}
}
catch (Exception ex)
{
Logger.LogMessage(ex.Message, ex.ToString());
this.Services().Message.ShowMessage(this.Services().Localize["Error"], this.Services().Localize["PaymentLoadError"]);
}
if (creditCard == null)
{
IsAddingNewCard = true;
Data.NameOnCard = _accountService.CurrentAccount.Name;
Data.Label = string.Empty;
var id = CreditCardCompanies.Find(x => x.Display == CreditCardGeneric).Id;
CreditCardType = (int)id;
#if DEBUG
if (PaymentSettings.PaymentMode == PaymentMethod.Braintree)
{
CreditCardNumber = DummyVisa.BraintreeNumber;
}
else
{
CreditCardNumber = DummyVisa.CmtNumber;
}
Data.CCV = DummyVisa.AvcCvvCvv2 + "";
Data.ZipCode = DummyVisa.ZipCode;
ExpirationMonth = DummyVisa.ExpirationDate.Month;
ExpirationYear = DummyVisa.ExpirationDate.Year;
Data.StreetName = DummyVisa.StreetName;
Data.StreetNumber = DummyVisa.StreetNumber;
#endif
Data.Email = _accountService.CurrentAccount.Email;
Data.Phone = _accountService.CurrentAccount.Settings.Phone;
Data.Country = _accountService.CurrentAccount.Settings.Country;
}
else
{
IsAddingNewCard = false;
Data.CreditCardId = creditCard.CreditCardId;
Data.CardNumber = "************" + creditCard.Last4Digits;
Data.NameOnCard = creditCard.NameOnCard;
Data.CreditCardCompany = creditCard.CreditCardCompany;
Data.Label = creditCard.Label;
Data.ZipCode = creditCard.ZipCode;
Data.Email = creditCard.Email;
Data.Phone = creditCard.Phone;
Data.Country = creditCard.Country;
Data.StreetName = creditCard.StreetName;
Data.StreetNumber = creditCard.StreetNumber;
ExpirationMonth = creditCard.ExpirationMonth.HasValue() ? int.Parse(creditCard.ExpirationMonth) : (int?)null;
ExpirationYear = creditCard.ExpirationYear.HasValue() ? int.Parse(creditCard.ExpirationYear) : (int?)null;
var id = CreditCardCompanies.Find(x => x.Display == creditCard.CreditCardCompany).Id;
if (id != null)
{
CreditCardType = (int)id;
}
_originalLabel = creditCard.Label;
}
RaisePropertyChanged(() => Data);
RaisePropertyChanged(() => CreditCardNumber);
RaisePropertyChanged(() => CanDeleteCreditCard);
RaisePropertyChanged(() => IsPayPalOnly);
RaisePropertyChanged(() => CanSetCreditCardAsDefault);
RaisePropertyChanged(() => SelectedCountryCode);
RaisePropertyChanged(() => Phone);
if (_hasPaymentToSettle)
{
return;
}
if (!_isFromCreditCardListView)
{
await GoToOverduePayment();
}
}
}
//DeepCopy
public void DeepCopy(CreditCardDetails from)
{
CCNumber = from.CCNumber ;
ExpirationDate = from.ExpirationDate ;
Rating = from.Rating ;
}
public void PayCreditCard(CreditCardDetails ccDetails)
{
this.PaymentMgr.EnterCreditCardNumberInfo(
ccDetails.Number.ToString(),
ccDetails.CvvCode,
ExpirationMonthEntry[ccDetails.ExpirationDate.Month],
ccDetails.ExpirationDate.Year.ToString());
this.PaymentMgr.EnterCreditCardNameCountryType(
ccDetails.CardholderName,
ccDetails.Country,
ccDetails.Type.ToString());
this.PaymentMgr.EnterCreditCardAddressInfo(
ccDetails.Line1,
ccDetails.Line2,
ccDetails.City,
ccDetails.State,
ccDetails.PostalCode,
PaymentManager.DefaultPaymentInfo.BillingPhone);
}
// throws exception if payment is rejected
public void ProcessPayment(string merchantId, CreditCardDetails cardInfo, decimal amount)
{
}
public static SendReceipt GetSendReceiptCommand(OrderDetail order, AccountDetail account, int?orderId, string vehicleNumber, DriverInfos driverInfos,
double?fare, double?toll, double?extra, double?surcharge, double?bookingFees, double?tip, double?tax, OrderPaymentDetail orderPayment = null, double?amountSavedByPromotion = null,
PromotionUsageDetail promotionUsed = null, CreditCardDetails creditCard = null, SendReceipt.CmtRideLinqReceiptFields cmtRideLinqFields = null)
{
var command = new SendReceipt
{
Id = Guid.NewGuid(),
OrderId = order.Id,
EmailAddress = account.Email,
IBSOrderId = orderId ?? 0,
PickupDate = order.PickupDate,
UtcDropOffDate = order.DropOffDate,
VehicleNumber = vehicleNumber,
DriverInfos = driverInfos,
Fare = fare.GetValueOrDefault(),
Extra = extra.GetValueOrDefault(),
Tip = tip.GetValueOrDefault(),
Tax = tax.GetValueOrDefault(),
Toll = toll.GetValueOrDefault(),
Surcharge = surcharge.GetValueOrDefault(),
BookingFees = bookingFees.GetValueOrDefault(),
PickupAddress = order.PickupAddress,
DropOffAddress = order.DropOffAddress,
ClientLanguageCode = order.ClientLanguageCode,
CmtRideLinqFields = cmtRideLinqFields
};
if (promotionUsed != null)
{
command.AmountSavedByPromotion = amountSavedByPromotion.GetValueOrDefault();
command.PromoCode = promotionUsed.Code;
command.PromoDiscountType = promotionUsed.DiscountType;
command.PromoDiscountValue = promotionUsed.DiscountValue;
}
if (orderPayment != null)
{
command.PaymentInfo = new SendReceipt.Payment(
orderPayment.Amount,
orderPayment.TransactionId,
orderPayment.AuthorizationCode,
orderPayment.Type == PaymentType.CreditCard ? "Credit Card" : orderPayment.Type.ToString());
if ((orderPayment.CardToken.HasValue()) && (creditCard != null))
{
command.PaymentInfo.Last4Digits = creditCard.Last4Digits;
command.PaymentInfo.Company = creditCard.CreditCardCompany;
command.PaymentInfo.NameOnCard = creditCard.NameOnCard;
command.PaymentInfo.ExpirationMonth = creditCard.ExpirationMonth;
command.PaymentInfo.ExpirationYear = creditCard.ExpirationYear;
}
}
return(command);
}
//DeepCopy
public void DeepCopy(CreditCardDetails from)
{
CCNumber = from.CCNumber;
ExpirationDate = from.ExpirationDate;
Rating = from.Rating;
}
public bool Process(CreditCardDetails creditCardDetails)
{
return(!accountInTheRedNumber.Contains(creditCardDetails.Number));
}
public static void UpdateCreditCardDetails(HttpContext context, long cardId, Boolean defaultCard, CreditCardDetails creditCardDetails)
{
userService.UpdateCreditCard(cardId, creditCardDetails);
if (defaultCard)
{
AssignDefaultCardToUser(context, cardId, creditCardDetails.cardNumber);
}
else
{
DesAssignDefaultCardToUser(context, cardId);
}
}
public void PayMoney(PaymentMethod method)
{
Assert.IsTrue(OnCheckoutPage());
Assert.AreEqual(CurrentEmail, CheckoutVerifyValue(CheckoutVerifyColumn.Email, 1));
switch (method)
{
case PaymentMethod.Check:
this.SelectPaymentMethod(PaymentMethod.Check);
break;
case PaymentMethod.CreditCard:
this.SelectPaymentMethod(PaymentMethod.CreditCard);
CreditCardDetails ccDetails = new CreditCardDetails()
{
Number = PaymentManager.DefaultPaymentInfo.CCNumber,
ExpirationDate = DateTime.Parse("12/" + PaymentManager.DefaultPaymentInfo.ExpirationYear),//PaymentManager.DefaultPaymentInfo.ExpirationMonth is "12 - Dec"
CardholderName = PaymentManager.DefaultPaymentInfo.HolderName,
CvvCode = PaymentManager.DefaultPaymentInfo.CVV,
Country = PaymentManager.DefaultPaymentInfo.HolderCountry,
Line1 = PaymentManager.DefaultPaymentInfo.BillingAddressLineOne,
Line2 = null,
City = PaymentManager.DefaultPaymentInfo.BillingCity,
State = PaymentManager.DefaultPaymentInfo.BillingState,
PostalCode = PaymentManager.DefaultPaymentInfo.ZipCode,
Type = PaymentManager.CCType.Visa
};
PayCreditCard(ccDetails);
break;
default:
break;
}
}
private void SendTripReceipt(Guid orderId, decimal meter, decimal tip, decimal tax, decimal amountSavedByPromotion = 0m,
decimal toll = 0m, decimal extra = 0m, decimal surcharge = 0m, decimal bookingFees = 0m, SendReceipt.CmtRideLinqReceiptFields cmtRideLinqFields = null)
{
using (var context = _contextFactory.Invoke())
{
var order = _orderDao.FindById(orderId);
var orderStatus = _orderDao.FindOrderStatusById(orderId);
if (orderStatus != null)
{
var account = context.Find <AccountDetail>(orderStatus.AccountId);
var orderPayment = context.Set <OrderPaymentDetail>().FirstOrDefault(p => p.OrderId == orderStatus.OrderId && p.IsCompleted);
CreditCardDetails card = null;
if (orderPayment != null && orderPayment.CardToken.HasValue())
{
card = _creditCardDao.FindByToken(orderPayment.CardToken);
}
// Payment was handled by app, send receipt
if (orderStatus.IsPrepaid && orderPayment != null)
{
// Order was prepaid, all the good amounts are in OrderPaymentDetail
meter = orderPayment.Meter;
tip = orderPayment.Tip;
tax = orderPayment.Tax;
}
var promoUsed = _promotionDao.FindByOrderId(orderId);
var ibsOrderId = order.IBSOrderId;
decimal fare;
if (order.IsManualRideLinq)
{
var manualRideLinqDetail = context.Find <OrderManualRideLinqDetail>(orderStatus.OrderId);
ibsOrderId = manualRideLinqDetail.TripId;
fare = meter;
}
else
{
if (cmtRideLinqFields != null)
{
fare = meter;
}
else
{
// Meter also contains toll and surcharge, to send an accurate receipt, we need to remove both toll and surcharge.
fare = orderPayment.SelectOrDefault(payment => payment.Meter - payment.Toll - surcharge, meter - toll - surcharge);
}
}
if (cmtRideLinqFields != null && cmtRideLinqFields.DriverId.HasValue())
{
orderStatus.DriverInfos.DriverId = cmtRideLinqFields.DriverId;
}
var command = SendReceiptCommandBuilder.GetSendReceiptCommand(
order,
account,
ibsOrderId,
orderStatus.VehicleNumber,
orderStatus.DriverInfos,
Convert.ToDouble(fare),
Convert.ToDouble(toll),
Convert.ToDouble(extra),
Convert.ToDouble(surcharge),
Convert.ToDouble(bookingFees),
orderPayment.SelectOrDefault(payment => Convert.ToDouble(payment.Tip), Convert.ToDouble(tip)),
Convert.ToDouble(tax),
orderPayment,
Convert.ToDouble(amountSavedByPromotion),
promoUsed,
card,
cmtRideLinqFields);
_commandBus.Send(command);
}
}
}
