public OrderAddressViewModel(OrderAddress addressItem, ICountryRepository countryRepository)
{
_countryRepository = countryRepository;
this.AddressItem = addressItem;
this.AddressItem.PropertyChanged += InnerItem_PropertyChanged;
}
/// <summary>
/// Updates the cart.
/// </summary>
/// <param name="model">The checkout model.</param>
/// <param name="isFinalStep">if set to <c>true</c> [is final step].</param>
private void UpdateCart(CheckoutModel model, bool isFinalStep = false)
{
PrepareCheckoutModel(model);
var errors = new List<string>();
var form = Ch.OrderForm;
#region Process billing address
var billingAddress = Ch.FindAddressByName("Billing");
if (billingAddress == null)
{
billingAddress = new OrderAddress();
Ch.Cart.OrderAddresses.Add(billingAddress);
}
var orderAddressId = billingAddress.OrderAddressId;
// if not empty, then we use existing customer address
if (!String.IsNullOrEmpty(model.AddressBook.BillingAddressId))
{
// load address from the customer address book
var userAddress = _userClient.GetUserAddress(model.AddressBook.BillingAddressId);
if (userAddress != null)
{
billingAddress.InjectFrom(userAddress);
}
}
else
{
billingAddress.InjectFrom(
new IgnorePropertiesInjection("OrderGroupId", "OrderGroup", "OrderAddressId", "Created"),
model.BillingAddress.Address);
}
billingAddress.Name = "Billing";
billingAddress.OrderAddressId = orderAddressId;
model.BillingAddress.Address = ConvertToAddressModel(billingAddress);
var hasValidBillingAddress = DoValidateModel(billingAddress);
if (hasValidBillingAddress)
{
Ch.Cart.AddressId = orderAddressId;
Ch.OrderForm.BillingAddressId = orderAddressId;
}
else
{
//Remove invalid address from cart if not final step
//otherwise saving cart will fail
if (!isFinalStep)
{
Ch.Cart.OrderAddresses.Remove(billingAddress);
}
errors.Add("Billing address is invalid");
}
#endregion
#region Process shipping address
var shippingAddress = Ch.FindAddressByName("Shipping");
if (shippingAddress == null)
{
shippingAddress = new OrderAddress();
Ch.Cart.OrderAddresses.Add(shippingAddress);
}
var shippingAddressId = shippingAddress.OrderAddressId;
if (model.UseForShipping)
{
shippingAddress.InjectFrom(billingAddress);
}
else if (!String.IsNullOrEmpty(model.AddressBook.ShippingAddressId))
{
// load address from the customer address book
var userAddress = _userClient.GetUserAddress(model.AddressBook.ShippingAddressId);
if (userAddress != null)
{
shippingAddress.InjectFrom(userAddress);
}
}
else
{
shippingAddress.InjectFrom(
new IgnorePropertiesInjection("OrderGroupId", "OrderGroup", "OrderAddressId", "Created"),
model.ShippingAddress.Address);
}
shippingAddress.Name = "Shipping";
shippingAddress.OrderAddressId = shippingAddressId;
model.ShippingAddress.Address = ConvertToAddressModel(shippingAddress);
var hasValidShippingAddress = DoValidateModel(shippingAddress);
if (!hasValidShippingAddress)
{
//Remove invalid address from cart if not final step
//otherwise saving cart will fail
if (!isFinalStep)
{
Ch.Cart.OrderAddresses.Remove(shippingAddress);
}
errors.Add("Shipping address is invalid");
}
#endregion
#region Update payment info
var paymentmethod = model.PaymentMethod;
var paymentCreated = false;
if (!String.IsNullOrEmpty(paymentmethod))
{
var paymentModel = model.Payments.Single(p => p.Name.Equals(paymentmethod, StringComparison.OrdinalIgnoreCase));
var payment = CreatePayment(form, paymentmethod, paymentModel);
form.Payments.Clear();
if (DoValidateModel(payment))
{
form.Payments.Add(payment);
paymentCreated = true;
}
}
if (!paymentCreated)
{
errors.Add("Failed to create payment".Localize());
}
#endregion
#region Update shipment delivery method
if (!string.IsNullOrEmpty(model.ShippingMethod))
{
foreach (var lineItem in form.LineItems)
{
var shippingMethod = Ch.GetShippingMethods(new List<string> { model.ShippingMethod }).First();
lineItem.ShippingMethodName = shippingMethod.DisplayName;
lineItem.ShippingMethodId = shippingMethod.Id;
}
}
#endregion
#region Update Shipment ShipmentAddressId
//If ShipmentSplitActivity is not called ShipmentAddressId must be updated manually
if (hasValidShippingAddress)
{
foreach (var shipment in form.Shipments)
{
shipment.ShippingAddressId = model.ShippingAddress.Address.AddressId;
}
foreach (var lineItem in form.LineItems)
{
lineItem.ShippingAddressId = model.ShippingAddress.Address.AddressId;
}
}
#endregion
foreach (var err in errors)
{
ModelState.AddModelError("", err);
}
}
/// <summary>
/// Converts to address model.
/// </summary>
/// <param name="address">The address.</param>
/// <returns>AddressModel.</returns>
private static AddressModel ConvertToAddressModel(OrderAddress address)
{
var addr = new AddressModel();
addr.InjectFrom(address);
addr.AddressId = address.OrderAddressId;
return addr;
}
/// <summary>
/// Paypal IPN callback
/// </summary>
/// <param name="token"></param>
/// <param name="payerId"></param>
/// <param name="cancel"></param>
/// <returns></returns>
public ActionResult PaypalExpressSuccess(string token, string payerId, bool? cancel)
{
var model = PrepareCheckoutModel(new CheckoutModel());
Payment payment = null;
var order = _orderClient.GetOrderByAuthCode(token);
if (order == null)
{
ModelState.AddModelError("", "Order cannot be found for current payment!".Localize());
}
else
{
payment = order.OrderForms.SelectMany(f => f.Payments).First(p => p.AuthorizationCode == token);
//If payment not cancelled proceed
if (!cancel.HasValue || !cancel.Value)
{
var paymentMethod = _paymentClient.GetPaymentMethod(payment.PaymentMethodName ?? "Paypal");
var configMap = paymentMethod.CreateSettings();
var service = new PayPalAPIInterfaceServiceService(configMap);
var getEcWrapper = new GetExpressCheckoutDetailsReq
{
GetExpressCheckoutDetailsRequest = new GetExpressCheckoutDetailsRequestType(token)
};
GetExpressCheckoutDetailsResponseType getEcResponse = null;
try
{
getEcResponse = service.GetExpressCheckoutDetails(getEcWrapper);
}
catch (Exception ex)
{
ModelState.AddModelError("", @"Paypal failure".Localize());
ModelState.AddModelError("", ex.Message);
}
if (getEcResponse != null)
{
if (getEcResponse.Ack.Equals(AckCodeType.FAILURE) ||
(getEcResponse.Errors != null && getEcResponse.Errors.Count > 0))
{
ModelState.AddModelError("", @"Paypal failure".Localize());
foreach (var error in getEcResponse.Errors)
{
ModelState.AddModelError("", error.LongMessage);
}
}
else
{
var details = getEcResponse.GetExpressCheckoutDetailsResponseDetails;
if (details.CheckoutStatus.Equals("PaymentActionCompleted",
StringComparison.OrdinalIgnoreCase))
{
return RedirectToAction("ProcessCheckout", "Checkout", new {id = order.OrderGroupId});
}
model.PaymentMethod = paymentMethod.Name;
model.ShippingMethod = details.UserSelectedOptions.ShippingOptionName;
if (!string.IsNullOrEmpty(details.UserSelectedOptions.ShippingOptionName))
{
foreach (var lineItem in order.OrderForms.SelectMany(f => f.LineItems))
{
var shippingMethod =
Ch.GetShippingMethods(new List<string> {model.ShippingMethod}).First();
lineItem.ShippingMethodName = shippingMethod.DisplayName;
lineItem.ShippingMethodId = shippingMethod.Id;
}
}
var paymentDetails = details.PaymentDetails[0];
model.BillingAddress.Address = ConvertFromPaypalAddress(paymentDetails.ShipToAddress,
"Billing");
model.BillingAddress.Address.Email = details.PayerInfo.Payer;
model.ShippingAddress.Address = ConvertFromPaypalAddress(paymentDetails.ShipToAddress,
"Shipping");
model.ShippingAddress.Address.Email = details.PayerInfo.Payer;
#region Process billing address
var billingAddress = OrderClient.FindAddressByName(order, "Billing");
if (billingAddress == null)
{
billingAddress = new OrderAddress();
order.OrderAddresses.Add(billingAddress);
var orderAddressId = billingAddress.OrderAddressId;
billingAddress.InjectFrom(
new IgnorePropertiesInjection("OrderGroupId", "OrderGroup", "OrderAddressId",
"Created"), model.BillingAddress.Address);
billingAddress.Name = "Billing";
billingAddress.OrderAddressId = orderAddressId;
order.AddressId = orderAddressId;
order.OrderForms[0].BillingAddressId = orderAddressId;
}
#endregion
#region Process shipping address
var shippingAddress = OrderClient.FindAddressByName(order, "Shipping");
if (shippingAddress == null)
{
shippingAddress = new OrderAddress();
order.OrderAddresses.Add(shippingAddress);
}
shippingAddress.InjectFrom(
new IgnorePropertiesInjection("OrderGroupId", "OrderGroup", "OrderAddressId", "Created"),
model.ShippingAddress.Address);
shippingAddress.Name = "Shipping";
shippingAddress.OrderAddressId = shippingAddress.OrderAddressId;
//Update shipping address id
foreach (var shipment in order.OrderForms.SelectMany(f => f.Shipments))
{
shipment.ShippingAddressId = shippingAddress.OrderAddressId;
}
foreach (var lineItem in order.OrderForms.SelectMany(f => f.LineItems))
{
lineItem.ShippingAddressId = shippingAddress.OrderAddressId;
}
#endregion
//Recalcualte totals (User could have changed shipping method in paypal).
Ch.RunWorkflow("ShoppingCartPrepareWorkflow", order);
if (ModelState.IsValid)
{
payment.ContractId = payerId;
payment.AuthorizationCode = token;
payment.Amount = order.Total;
//Normally this message should be shown to user when. This happens because address changes and Tax is recalculated
if (decimal.Parse(paymentDetails.OrderTotal.value, CultureInfo.InvariantCulture) !=
order.Total)
{
ModelState.AddModelError("",
"Paypal payment total does not match order total! Check the totals and try to pay again."
.Localize());
}
else
{
try
{
Ch.RunWorkflow("ShoppingCartCheckoutWorkflow", order);
Ch.OrderRepository.UnitOfWork.Commit();
return RedirectToAction("ProcessCheckout", "Checkout",
new {id = order.OrderGroupId});
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
}
}
}
}
}
}
if (order != null)
{
//Cancel old order
order.Status = OrderStatus.Cancelled.ToString();
payment.Status = PaymentStatus.Canceled.ToString();
//Restore cart if order fails
Ch.ToCart(order);
//Add paypal payment to make it selected in UI
var paypalPayment = new OtherPayment
{
PaymentMethodId = payment.PaymentMethodId,
PaymentMethodName = payment.PaymentMethodName,
Amount = payment.Amount
};
Ch.OrderForm.Payments.Add(paypalPayment);
Ch.SaveChanges();
}
return View("Index", model);
}
public static OrderAddress ConvertToOrderAddress(Address address)
{
var addr = new OrderAddress();
addr.InjectFrom(address);
return addr;
}
public static Address ConvertToCustomerAddress(OrderAddress address)
{
var addr = new Address();
addr.InjectFrom(address);
return addr;
}