public async Task <bool> UpdateCard(UpdateCardRequest updateCardRequest)
{
try
{
if (updateCardRequest.value)
{
List <UserCreditCard> creditCards = await this.therapistContext.UserCreditCard.Where(x => x.UserId == updateCardRequest.userId).ToListAsync();
foreach (var item in creditCards)
{
if (item.UserCreditCardId == updateCardRequest.userCreditCardId)
{
item.IsPrimary = true;
}
else
{
item.IsPrimary = false;
}
}
}
else
{
UserCreditCard creditCard = await this.therapistContext.UserCreditCard.Where(x => x.UserCreditCardId == updateCardRequest.userCreditCardId).FirstOrDefaultAsync();
creditCard.IsPrimary = false;
}
await this.therapistContext.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> CreditCardsCreate([Bind("Id,UserId,CreditCardType,CreditCardNumber,SecurityCode,ExpirationDate,NameOnCard,Address1,Address2,City,ProvinceId,CountryId,PostalZipCode")] UserCreditCard userCreditCard)
{
if (visa.IsMatch(userCreditCard.CreditCardNumber))
{
Boolean x = visa.IsMatch(userCreditCard.CreditCardNumber);
userCreditCard.CreditCardType = "Visa";
}
else if (mastercard.IsMatch(userCreditCard.CreditCardNumber))
{
Boolean x = mastercard.IsMatch(userCreditCard.CreditCardNumber);
userCreditCard.CreditCardType = "Mastercard";
}
else if (express.IsMatch(userCreditCard.CreditCardNumber))
{
Boolean x = express.IsMatch(userCreditCard.CreditCardNumber);
userCreditCard.CreditCardType = "American Express";
}
else
{
TempData["message"] = "Invalid Card Type.";
return(Redirect("/Member/CreditCardsCreate"));
}
if (ModelState.IsValid)
{
_context.Add(userCreditCard);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(CreditCardsIndex)));
}
ViewData["CountryId"] = new SelectList(_context.LookupCountry, "Id", "Country", userCreditCard.CountryId);
ViewData["ProvinceId"] = new SelectList(_context.LookupProvince, "Id", "Province", userCreditCard.ProvinceId);
ViewData["UserId"] = new SelectList(_context.User, "UserId", "Email", userCreditCard.UserId);
return(View(userCreditCard));
}
public CardPaymentResult AuthorizeCreditCardPayment(UserCreditCard card, decimal amount)
{
var payResult = new CardPaymentResult();
try
{
var result = modClient.AuthorizeCreditCardPayment(
this.clientId, this.clientCode, card.Alias.Value, amount);
payResult = new CardPaymentResult()
{
TransactionId = result.transId.ToString(),
Approved = result.approved,
AuthString = result.authString,
MessageText = result.messageText,
};
}
catch (Exception exc)
{
payResult = new CardPaymentResult()
{
Approved = false,
ServiceUnavailable = true,
MessageText = exc.Message
};
}
return(payResult);
}
public IActionResult Payment(UserCreditCard card)
{
Thread.Sleep(2000);
var result = _paymentService.Payment(card);
return(Ok(result));
}
public CardPaymentResult AuthorizeCreditCardPayment(UserCreditCard card, decimal amount)
{
var payResult = new CardPaymentResult();
try
{
var result = modClient.AuthorizeCreditCardPayment(
this.clientId, this.clientCode, card.Alias.Value, amount);
payResult = new CardPaymentResult()
{
TransactionId = result.transId.ToString(),
Approved = result.approved,
AuthString = result.authString,
MessageText = result.messageText,
};
}
catch(Exception exc)
{
payResult = new CardPaymentResult()
{
Approved = false,
ServiceUnavailable = true,
MessageText = exc.Message
};
}
return payResult;
}
public async Task <IActionResult> CreditCardsEdit(int id, [Bind("Id,UserId,CreditCardType,CreditCardNumber,SecurityCode,ExpirationDate,NameOnCard,Address1,Address2,City,ProvinceId,CountryId,PostalZipCode")] UserCreditCard userCreditCard)
{
if (id != userCreditCard.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userCreditCard);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserCreditCardExists(userCreditCard.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(CreditCardsIndex)));
}
ViewData["CountryId"] = new SelectList(_context.LookupCountry, "Id", "Country", userCreditCard.CountryId);
ViewData["ProvinceId"] = new SelectList(_context.LookupProvince, "Id", "Province", userCreditCard.ProvinceId);
ViewData["UserId"] = new SelectList(_context.User, "UserId", "Email", userCreditCard.UserId);
return(View(userCreditCard));
}
public void DeleteUserCreditCard(UserCreditCard card)
{
card.IsDeleted = true;
manager.UpdateCustomerCard(card);
UpdateCreditCardForUser(card);
}
public Status <UserCreditCard> UpdateUserCreditCard(string username, UserCreditCard card)
{
if (string.IsNullOrWhiteSpace(username))
{
return(Status.ValidationError <UserCreditCard>(null, "username", "The username is required"));
}
if (card == null)
{
return(Status.ValidationError <UserCreditCard>(null, "card", "card is null"));
}
card = manager.UpdateCustomerCard(card);
if (card.UserCreditCardId == 0)
{
return(AddUserCreditCard(username, card));
}
using (RentlerContext context = new RentlerContext())
{
try
{
var userCreditCard = (from uc in context.UserCreditCards
where uc.User.IsDeleted == false &&
uc.User.Username == username &&
uc.UserCreditCardId == card.UserCreditCardId
select uc).SingleOrDefault();
userCreditCard.Alias = card.Alias;
userCreditCard.AccountReference = card.AccountReference;
userCreditCard.CardName = card.CardName;
userCreditCard.CardNumber = card.CardNumber;
userCreditCard.ExpirationMonth = card.ExpirationMonth;
userCreditCard.ExpirationYear = card.ExpirationYear;
userCreditCard.Address1 = card.Address1;
userCreditCard.Address2 = card.Address2;
userCreditCard.City = card.City;
userCreditCard.Email = card.Email;
userCreditCard.FirstName = card.FirstName;
userCreditCard.LastName = card.LastName;
userCreditCard.Phone = card.Phone;
userCreditCard.State = card.State;
userCreditCard.Zip = card.Zip;
userCreditCard.IsDeleted = card.IsDeleted;
userCreditCard.UpdatedBy = "orderadapter";
userCreditCard.UpdateDate = DateTime.UtcNow;
context.SaveChanges();
return(Status.OK <UserCreditCard>(card));
}
catch (Exception ex)
{
return(Status.Error <UserCreditCard>(ex.Message, card));
}
}
}
public IActionResult Add(UserCreditCard card)
{
var userId = _customerService.GetById(card.UserId);
card.UserId = userId.Data.UserId;
var result = _userCreditCardService.Add(card);
return(Ok(result));
}
/// <summary>
/// Creates a one-time payment, to be processed on a specific date.
/// Use this method for move in/out stuff like security deposits, pro-rated rent, etc.
/// </summary>
/// <param name="card">The user's credit card.</param>
/// <param name="amount">The amount to charge the user.</param>
/// <param name="payDate">The date to process the transaction.</param>
public SinglePaymentResult CreateSinglePayment(UserCreditCard card, decimal amount, DateTime payDate)
{
if (card.Alias == null)
{
throw new ArgumentNullException("Credit Card alias is null.");
}
return(manager.CreateSinglePayment(card.Alias.Value, amount, payDate, PaymentType.CreditCard));
}
public IActionResult Add(UserCreditCard creditCard)
{
var result = _userCreditCardService.Add(creditCard);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IActionResult Delete(UserCreditCard userCreditCard)
{
var result = _userCreditCardService.Delete(userCreditCard);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public Status <UserCreditCard> AddUserCreditCard(string username, UserCreditCard card)
{
if (string.IsNullOrWhiteSpace(username))
{
return(Status.ValidationError <UserCreditCard>(null, "username", "The username is required"));
}
if (card == null)
{
return(Status.ValidationError <UserCreditCard>(null, "card", "card is null"));
}
card.CreatedBy = "orderadapter";
card.CreateDate = DateTime.UtcNow;
// validate the contactinfo
var cardValidation = Status.Validatate <UserCreditCard>(card);
if (cardValidation.StatusCode != 200)
{
return(Status.ValidationError <UserCreditCard>(card, "", "credit card is not valid"));
}
card.AccountReference = Guid.NewGuid();
card = manager.CreateCustomerCard(card);
if (card == null)
{
return(Status.Error("Problem creating card on payment service.", card));
}
using (RentlerContext context = new RentlerContext())
{
try
{
var user = (from u in context.Users
where u.IsDeleted == false &&
u.Username == username
select u).SingleOrDefault();
user.UserCreditCards.Add(card);
context.SaveChanges();
return(Status.OK <UserCreditCard>(card));
}
catch (Exception ex)
{
return(Status.Error <UserCreditCard>(ex.Message, card));
}
}
}
public UserCreditCard CreateCreditCardForUser(UserCreditCard card)
{
card = manager.CreateCustomerCard(card);
if (card == null)
{
return(null);
}
using (var context = new RentlerContext())
{
context.UserCreditCards.Add(card);
context.SaveChanges();
}
return(card);
}
/// <summary>
/// Takes care of storing the user's credit card information.
/// If it is a new card, it will create a new entry in the payment system
/// and in our own storage. If it is just an update (e.g. the user changing their
/// address information), it will act accordingly.
/// </summary>
/// <param name="card">The user's credit card.</param>
public void UpdateCreditCardForUser(UserCreditCard card)
{
card = manager.UpdateCustomerCard(card);
if (card.UserCreditCardId == 0)
{
CreateCreditCardForUser(card);
}
else
{
UserCreditCard toUpdate = null;
using (var context = new RentlerContext())
{
toUpdate = (from u in context.UserCreditCards
where u.UserId == card.UserId &&
u.UserCreditCardId == card.UserCreditCardId
select u).SingleOrDefault();
if (toUpdate == null)
{
throw new ArgumentNullException();
}
toUpdate.Alias = card.Alias;
toUpdate.AccountReference = card.AccountReference;
toUpdate.CardName = card.CardName;
toUpdate.CardNumber = card.CardNumber;
toUpdate.ExpirationMonth = card.ExpirationMonth;
toUpdate.ExpirationYear = card.ExpirationYear;
toUpdate.Address1 = card.Address1;
toUpdate.Address2 = card.Address2;
toUpdate.City = card.City;
toUpdate.Email = card.Email;
toUpdate.FirstName = card.FirstName;
toUpdate.LastName = card.LastName;
toUpdate.Phone = card.Phone;
toUpdate.State = card.State;
toUpdate.Zip = card.Zip;
toUpdate.IsDeleted = card.IsDeleted;
context.SaveChanges();
}
}
}
public async Task <bool> DeleteCard(int Id)
{
try
{
UserCreditCard userCredit = await this.therapistContext.UserCreditCard.FirstOrDefaultAsync(x => x.UserCreditCardId.Equals(Id));
userCredit.IsActive = false;
userCredit.IsDeleted = true;
userCredit.ModifiedDate = DateTime.UtcNow;
await this.therapistContext.SaveChangesAsync();
return(true);
}
catch (Exception)
{
throw;
}
}
public UserCreditCard CreateCustomerCard(UserCreditCard card)
{
string addressLine = string.Format("{0} {1}", card.Address1, card.Address2);
card.AccountReference = Guid.NewGuid();
var customer = new ModpayCustomer()
{
AccountReference = card.AccountReference.ToString(),
Address = addressLine,
City = card.City,
PayerAlias = card.Alias,
FirstName = card.FirstName,
LastName = card.LastName,
Phone = card.Phone,
Email = card.Email,
State = card.State,
Zip = card.Zip
};
try
{
//store the customer info
customer.PayerAlias = CreatePayerCustomer(customer);
card.Alias = customer.PayerAlias;
//and then store the card
modClient.ModifyCustomerCreditCard(
clientId, clientCode, card.Alias.Value,
card.CardName, card.CardNumber, card.ExpirationMonth, card.ExpirationYear);
//mask account info
card.CardNumber = this.MaskNumber(card.CardNumber);
}
catch (Exception exc)
{
return(null);
}
return(card);
}
/// <summary>
/// In order to allow a user to store multiple credit cards,
/// we create a 'customer' for each card. This will create the
/// customer and store the card information.
/// </summary>
/// <param name="card"></param>
/// <returns>The UserCreditCard. If it is a new entry, the object will be
/// returned with the Alias created for the card.</returns>
public UserCreditCard UpdateCustomerCard(UserCreditCard card)
{
//if they haven't stored this card before,
//create a customer
string addressLine = string.Format("{0} {1}", card.Address1, card.Address2);
var customer = new ModpayCustomer()
{
AccountReference = card.UserId.ToString(),
Address = addressLine,
City = card.City,
PayerAlias = card.Alias,
FirstName = card.FirstName,
LastName = card.LastName,
Phone = card.Phone,
Email = card.Email,
State = card.State,
Zip = card.Zip
};
//store the customer info
if (!card.Alias.HasValue)
{
customer.PayerAlias = CreatePayerCustomer(customer);
card.Alias = customer.PayerAlias;
}
else
{
ModifyPayerCustomer(customer);
}
//if or when we add support to modify the card
////and then store the card
//modClient.ModifyCustomerCreditCard(
// clientId, clientCode, card.Alias.Value,
// card.CardName, card.CardNumber, card.ExpirationMonth, card.ExpirationYear);
////mask account info
//card.CardNumber = this.MaskNumber(card.CardNumber);
return(card);
}
public UserCreditCard CreateCustomerCard(UserCreditCard card)
{
string addressLine = string.Format("{0} {1}", card.Address1, card.Address2);
card.AccountReference = Guid.NewGuid();
var customer = new ModpayCustomer()
{
AccountReference = card.AccountReference.ToString(),
Address = addressLine,
City = card.City,
PayerAlias = card.Alias,
FirstName = card.FirstName,
LastName = card.LastName,
Phone = card.Phone,
Email = card.Email,
State = card.State,
Zip = card.Zip
};
try
{
//store the customer info
customer.PayerAlias = CreatePayerCustomer(customer);
card.Alias = customer.PayerAlias;
//and then store the card
modClient.ModifyCustomerCreditCard(
clientId, clientCode, card.Alias.Value,
card.CardName, card.CardNumber, card.ExpirationMonth, card.ExpirationYear);
//mask account info
card.CardNumber = this.MaskNumber(card.CardNumber);
}
catch(Exception exc)
{
return null;
}
return card;
}
public ActionResult Checkout(OrderCheckoutInputModel input)
{
if (ModelState.IsValid)
{
// process payment with cc, and save or update the card if requested.
var order = this.orderAdapter.ProcessOrder(
User.Identity.Name, input.OrderId, input.SelectedPaymentMethod, input.SaveCard);
//if it didn't work, build the viewmodel, add errors, and return the view.
if (order.StatusCode != 200)
{
ValidationResult error = null;
if (order.Errors != null)
{
error = order.Errors.FirstOrDefault();
}
if (error != null)
{
ModelState.AddModelError(error.MemberNames.First(), error.ErrorMessage);
}
else
{
ModelState.AddModelError("Order", "There was an error processing your order.");
}
UserCreditCard card = null;
if (order.Result.UserCreditCardId != null)
{
card = orderAdapter.GetUserCreditCard(
User.Identity.Name, order.Result.UserCreditCardId.Value);
}
else
{
card = new UserCreditCard();
}
var model = new OrderCheckoutModel
{
Order = order.Result,
Input = new OrderCheckoutInputModel
{
SaveCard = input.SaveCard,
SelectedPaymentMethod = card
}
};
return(View(model));
}
//otherwise, we're good
// activate building, move reserved ribbon to purchased ribbon on building
// if payment is successful
this.propertyAdapter.ActivateBuilding(input.BuildingId, User.Identity.Name);
//fulfill order here
this.orderAdapter.FulfillCompletedOrder(User.Identity.Name, order.Result.OrderId);
}
else
{
var order = this.orderAdapter.GetOrderForCheckout(User.Identity.Name, input.OrderId);
return(View(new OrderCheckoutModel
{
Order = order.Result,
Input = input
}));
}
//redirect to our complete page
return(Redirect("/ksl/property/complete/" + input.BuildingId));
}
public ActionResult Checkout(OrderCheckoutInputModel input)
{
if (ModelState.IsValid)
{
// process payment with cc, and save or update the card if requested.
var order = this.orderAdapter.ProcessOrder(
User.Identity.Name, input.OrderId, input.SelectedPaymentMethod, input.SaveCard);
//if it didn't work, build the viewmodel, add errors, and return the view.
if (order.StatusCode != 200)
{
ValidationResult error = null;
if (order.Errors != null)
error = order.Errors.FirstOrDefault();
if (error != null)
ModelState.AddModelError(error.MemberNames.First(), error.ErrorMessage);
else
ModelState.AddModelError("Order", "There was an error processing your order.");
UserCreditCard card = null;
if (order.Result.UserCreditCardId != null)
card = orderAdapter.GetUserCreditCard(
User.Identity.Name, order.Result.UserCreditCardId.Value);
else
card = new UserCreditCard();
var model = new OrderCheckoutModel
{
Order = order.Result,
Input = new OrderCheckoutInputModel
{
SaveCard = input.SaveCard,
SelectedPaymentMethod = card
}
};
return View(model);
}
//otherwise, we're good
// activate building, move reserved ribbon to purchased ribbon on building
// if payment is successful
this.propertyAdapter.ActivateBuilding(input.BuildingId, User.Identity.Name);
//fulfill order here
this.orderAdapter.FulfillCompletedOrder(User.Identity.Name, order.Result.OrderId);
}
else
{
var order = this.orderAdapter.GetOrderForCheckout(User.Identity.Name, input.OrderId);
return View(new OrderCheckoutModel
{
Order = order.Result,
Input = input
});
}
//redirect to our complete page
return Redirect("/ksl/property/complete/" + input.BuildingId);
}
public IResult Delete(UserCreditCard userCreditCard)
{
_userCreditCardDal.Delete(userCreditCard);
return(new SuccessResult());
}
public IResult Add(UserCreditCard userCreditCard)
{
_userCreditCardDal.Add(userCreditCard);
return(new SuccessResult(Messages.CardAdded));
}
/// <summary>
/// In order to allow a user to store multiple credit cards,
/// we create a 'customer' for each card. This will create the
/// customer and store the card information.
/// </summary>
/// <param name="card"></param>
/// <returns>The UserCreditCard. If it is a new entry, the object will be
/// returned with the Alias created for the card.</returns>
public UserCreditCard UpdateCustomerCard(UserCreditCard card)
{
//if they haven't stored this card before,
//create a customer
string addressLine = string.Format("{0} {1}", card.Address1, card.Address2);
var customer = new ModpayCustomer()
{
AccountReference = card.UserId.ToString(),
Address = addressLine,
City = card.City,
PayerAlias = card.Alias,
FirstName = card.FirstName,
LastName = card.LastName,
Phone = card.Phone,
Email = card.Email,
State = card.State,
Zip = card.Zip
};
//store the customer info
if(!card.Alias.HasValue)
{
customer.PayerAlias = CreatePayerCustomer(customer);
card.Alias = customer.PayerAlias;
}
else
ModifyPayerCustomer(customer);
//if or when we add support to modify the card
////and then store the card
//modClient.ModifyCustomerCreditCard(
// clientId, clientCode, card.Alias.Value,
// card.CardName, card.CardNumber, card.ExpirationMonth, card.ExpirationYear);
////mask account info
//card.CardNumber = this.MaskNumber(card.CardNumber);
return card;
}
public IResult Add(UserCreditCard card)
{
_userCreditCardDal.Add(card);
return(new SuccessResult(Messages.UserCreditCardAddSuccess));
}
/// <summary>
/// Charges a customer's credit card for the amount, immediately.
/// Use this for subscription/fee's.
/// </summary>
/// <param name="card">The user's credit card.</param>
/// <param name="amount">The amount to charge the user.</param>
/// <returns>A SinglePaymentResult, stating whether the card was approved and
/// if not, why.</returns>
public CardPaymentResult AuthorizePayment(UserCreditCard card, decimal amount)
{
return(manager.AuthorizeCreditCardPayment(card, amount));
}
public IResult Payment(UserCreditCard card)
{
return(new SuccessResult(Messages.PaymentSuccess));
}
public Status <Order> ProcessOrder(
string username, int orderId, UserCreditCard card, bool saveCard)
{
bool isNewCard = card.UserCreditCardId == 0;
if (isNewCard)
{
// we're adding the new card regardless but we don't know if its valid
// if the user requested to save it we will make it active after the payment
// is successful, otherwise it will remain inactive
card.IsDeleted = true;
var cardResult = AddUserCreditCard(username, card);
if (cardResult.StatusCode != 200)
{
var orderStatus = GetOrderForCheckout(username, orderId);
orderStatus.StatusCode = 500;
orderStatus.Errors = new ValidationResult[] {
new ValidationResult("An unexpected failure occurred: payment was not processed", new string[] { "Order" })
};
return(orderStatus);
}
}
else
{
//get the card
var storedCard = GetUserCreditCard(username, card.UserCreditCardId);
if (storedCard == null)
{
var orderStatus = GetOrderForCheckout(username, orderId);
orderStatus.StatusCode = 500;
orderStatus.Errors = new ValidationResult[] {
new ValidationResult("Failed to locate credit card on file: payment was not processed", new string[] { "Order" })
};
return(orderStatus);
}
//update the billing address if anything changed
if (storedCard.Address1 != card.Address1 ||
storedCard.Address2 != card.Address2 ||
storedCard.City != card.City ||
storedCard.FirstName != card.FirstName ||
storedCard.LastName != card.LastName ||
storedCard.State != card.State ||
storedCard.Zip != card.Zip)
{
storedCard.Address1 = card.Address1;
storedCard.Address2 = card.Address2;
storedCard.City = card.City;
storedCard.FirstName = card.FirstName;
storedCard.LastName = card.LastName;
storedCard.State = card.State;
storedCard.Zip = card.Zip;
var updateStatus = UpdateUserCreditCard(username, storedCard);
if (updateStatus.StatusCode != 200)
{
var orderStatus = GetOrderForCheckout(username, orderId);
orderStatus.StatusCode = 500;
orderStatus.Errors = new ValidationResult[] {
new ValidationResult("Failed to update card address: payment was not processed", new string[] { "Order" })
};
return(orderStatus);
}
}
card = storedCard;
}
//grab the order
var order = GetOrderForCheckout(username, orderId);
//attach the credit card to the order for our records
order.Result.UserCreditCardId = card.UserCreditCardId;
if (order.StatusCode != 200)
{
return(order);
}
//let's pay for stuff!
CardPaymentResult result;
if (App.StorePricing == "Penny")
{
result = manager.AuthorizeCreditCardPayment(card, 0.01m);
}
else
{
result = manager.AuthorizeCreditCardPayment(card, order.Result.OrderTotal);
}
//did it work?
if (result.Approved)
{
order.Result.OrderStatus = OrderStatus.Succeeded;
}
else
{
order.StatusCode = 500;
// the payment method used is not valid so it should not be attached to
// the order. Clear it here and the change will be persisted later
order.Result.UserCreditCardId = null;
//gateway might be down
if (result.ServiceUnavailable)
{
order.Result.OrderStatus = OrderStatus.ServiceUnavailable;
order.Errors = new ValidationResult[] {
new ValidationResult("Payment service is unavailable. Please try again later.", new string[] { "Order" })
};
}
//or it was declined
else
{
order.Result.OrderStatus = OrderStatus.CardDeclined;
order.Errors = new ValidationResult[] {
new ValidationResult("Credit Card was declined", new string[] { "Order" })
};
}
}
//update the order status
using (var context = new RentlerContext())
{
var toUpdate = (from o in context.Orders
.Include("Building")
where o.OrderId == order.Result.OrderId
select o).SingleOrDefault();
toUpdate.OrderStatus = order.Result.OrderStatus;
toUpdate.UserCreditCardId = order.Result.UserCreditCardId;
//remove temporary order if we're good
if (order.Result.OrderStatus == OrderStatus.Succeeded)
{
toUpdate.Building.TemporaryOrderId = null;
// allow credit card to be used again if requested
if (isNewCard && saveCard)
{
context.Entry(toUpdate).Reference(o => o.UserCreditCard).Load();
toUpdate.UserCreditCard.IsDeleted = false;
}
}
context.SaveChanges();
}
// send receipt only if order was successful
if (order.Result.OrderStatus == OrderStatus.Succeeded)
{
//send a receipt
EmailOrderReceiptModel model = new EmailOrderReceiptModel()
{
To = order.Result.User.Email,
Name = string.Format("{0} {1}", order.Result.User.FirstName, order.Result.User.LastName),
BuildingId = (order.Result.BuildingId.HasValue) ? order.Result.BuildingId.Value : 0,
OrderItems = order.Result.OrderItems.ToList(),
OrderTotal = order.Result.OrderTotal
};
mailer.Receipt(model);
}
return(order);
}
