public IActionResult Hold(int id)
{
var asset = _repository.GetById(id);
var model = new CheckoutModel
{
AssetId = id,
ImageUrl = asset.ImageUrl,
Title = asset.Title,
LibraryCardId = "",
IsCheckedOut = _checkout.IsCheckedOut(id),
HoldCount = _checkout.GetCurrentHolds(id).Count()
};
return(View(model));
}
public IActionResult Checkout(int id)
{
var asset = _assets.GetById(id);
var model = new CheckoutModel
{
AssetId = asset.Id,
Title = asset.Title,
ImageUrl = asset.ImgUrl,
LibraryCardId = "",
HoldCount = _checkout.CheckoutHistory(id).Count(),
IsCheckedOut = _checkout.IsCheckedOut(id)
};
return(View(model));
}
public IActionResult Index()
{
string ps_store_id = configuration.GetSection("MonerisConfiguration").GetSection("ps_store_id").Value;
string hpp_key = configuration.GetSection("MonerisConfiguration").GetSection("hpp_key").Value;
string checkoutUrl = configuration.GetSection("MonerisConfiguration").GetSection("checkouturl").Value;
CheckoutModel checkoutModel = new CheckoutModel();
checkoutModel.PaymentGatewayConfig = new MonerisConfig()
{
StoreID = ps_store_id, HPPKey = hpp_key, CheckOutUrl = checkoutUrl
};
checkoutModel.OrderID = Guid.NewGuid().ToString();
checkoutModel.Amount = "50.00";
checkoutModel.CheckOurUrl = checkoutUrl;
return(View(checkoutModel));
}
public HistoryForm(CheckoutModel checkoutModel, ModelTets modelTetsTemp)
{
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
this.model = checkoutModel;
this.modelTets = modelTetsTemp;
InitializeComponent();
Timer = new System.Windows.Forms.Timer()
{
Interval = 100
};
Timer.Tick += new EventHandler(Timer_Tick);
base.Opacity = 0;
Timer.Start();
}
public ViewResult Checkout(Cart cart, CheckoutModel cm)
{
if (cart.Lines.Count() == 0)
{
ModelState.AddModelError("CustomError", "Sorry, your cart is empty!");
}
if (ModelState.IsValid)
{
// order processing logic
cart.Clear();
return(View("Completed"));
}
else
{
return(View(cm));
}
}
// GET: Checkout/Create
public ActionResult Create()
{
var checkout = new CheckoutModel();
var currentUser = System.Web.HttpContext.Current.User as CustomPrincipal;
if (currentUser == null)
{
return(RedirectToAction("Index", "Account"));
}
using (var proxy = new ClientesTouresBalonClient())
{
var c = proxy.ConsultarPorIdentificacionCliente((int)currentUser.CustId);
checkout.Firstname = c.nombres;
checkout.LastName = c.apellidos;
checkout.CreditCardType = c.tipo_tarjeta;
checkout.Creditcard = c.numero_tarjeta;
checkout.CustomerId = c.id_cliente;
if (c.email == null)
{
return(RedirectToAction("Index", "Account"));
}
}
var clientConfiguration = new MemcachedClientConfiguration {
Protocol = MemcachedProtocol.Binary
};
clientConfiguration.Servers.Add(new IPEndPoint(IPAddress.Parse("192.168.99.100"), 32768));
using (var cartCacheClient = new MemcachedClient(clientConfiguration))
{
checkout.Cart = cartCacheClient.Get <Cart>("Cart-" + currentUser.UserName);
foreach (var item in checkout.Cart.Items)
{
checkout.Total = checkout.Total + item.Cantidad * (item.Producto.tipo_espectaculo.precio + item.Producto.tipo_hospedaje.precio + item.Producto.tipo_transporte.precio);
}
if (checkout.Cart == null)
{
return(RedirectToAction("Index", "Home"));
}
}
return(View("Create", checkout));
}
public async Task <IActionResult> Submit(CheckoutModel model)
{
if (model == null)
{
return(Redirect("/Cart/Cart"));
}
if (model.Cart == null || model.Cart.Count == 0)
{
return(Redirect("/Cart/Cart"));
}
var userId = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var purchase = new Purchase()
{
UserId = int.Parse(userId)
};
_context.Add(purchase);
foreach (var eve in model.Cart)
{
var eventId = eve.Key;
var count = eve.Value;
var eveDb = await _context.Set <Event>().FirstOrDefaultAsync(x => x.ID == eventId);
if (eveDb == null)
{
return(BadRequest());
}
for (int i = 0; i < count; i++)
{
var ticket = new Ticket();
ticket.Event = eveDb;
ticket.Purchase = purchase;
ticket.PricePLN = eveDb.TicketPrice;
_context.Add(ticket);
}
}
_context.SaveChanges();
return(Redirect("/History/MyEvents"));
}
// GET: Checkout
public ActionResult Index()
{
var vm = new CheckoutModel();
using (ShoppingCartActions usersShoppingCart = new ShoppingCartActions(cartId, items, categories))
{
var shoppingCartItems = usersShoppingCart.GetCartItems();
var cartItemsVM = Mapper.Map <List <CartItemModel> >(shoppingCartItems);
vm.CartItems = cartItemsVM;
vm.OrderTotal = usersShoppingCart.GetTotal();
vm.ItemsTotal = usersShoppingCart.GetCount();
}
var user = (User)Session["User"];
var email = "*****@*****.**";
if (user != null && !string.IsNullOrWhiteSpace(user.Email))
{
email = user.Email;
}
// To make filling out the form faster for demo purposes, pre-fill the values:
vm.Order = new OrderModel
{
// Important! Keep this property here!
Total = vm.OrderTotal,
// Prefill properties for convenience:
FirstName = "Bob",
LastName = "Loblaw",
Address = "1313 Mockingbird Lane",
City = "Virginia Beach",
State = "VA",
PostalCode = "23456",
Country = "United States",
Email = email,
NameOnCard = "Bob Loblaw",
CreditCardType = "Visa",
CreditCardNumber = "4111111111111111",
ExpirationDate = "12/25",
CCV = "987",
SMSOptIn = true
};
return(View(vm));
}
public async Task <CheckoutModel> CreateModel(CheckOutInputModel checkOutInputModel, string command)
{
var cart = await _mediator.Send(CartContentRequest.Create());
var jurisdictions = JurisdictionManager.GetJurisdictions(JurisdictionManager.JurisdictionType.Tax);
var jurisdictionContrys = jurisdictions.Jurisdiction;
var contrys = jurisdictionContrys.Select(x => new SelectEntry()
{
DisplayName = x.DisplayName, Key = x.CountryCode, Selected = false
}).ToList();
var checkoutModel = new CheckoutModel()
{
Customer = checkOutInputModel, Cart = cart, Step = NextStep(command), JurisdictionContrys = contrys
};
return(checkoutModel);
}
public ActionResult Checkout()
{
var cookie = Request.Cookies[".cart"];
if (cookie == null)
{
return(RedirectToAction("Cart"));
}
var cart = ArtContext.Carts.Single(where : "Cookie = @0", parms: cookie.Value);
var items = ArtContext.CartItems.All(where : "CartId = @0", parms: cart.Id);
var model = new CheckoutModel();
model.GrandTotal = items.Aggregate(0D, (runningTotal, next) => runningTotal + (next.Quantity * next.Price));
return(View(model));
}
public CheckoutModel MakeModel(CapstoneShoppingListDBContext context)
{
var cart = context.ShoppingListDetails;
var table2 = context.ProductList;
var checkout = new CheckoutModel();
var productQuery = (from s in cart
join p in table2
on s.ProductId equals p.Id
select s.Product).ToList();
checkout.Items = productQuery;
checkout.Total = (double)productQuery.Sum(_ => _.Price);
checkout.Tax = Math.Round((checkout.Total * .06), 2, MidpointRounding.AwayFromZero);
checkout.GrandTotal = checkout.Total + checkout.Tax;
return(checkout);
}
public async Task <IActionResult> Checkout()
{
string sessionKey = MethodHelper.IsThereSomeone(HttpContext.Session);
userSession = SessionHelper.GetObjectFromJson <UserModel>(HttpContext.Session, "userObject");
if (userSession != null)
{
List <ProductModel> productFromSessionCard = SessionHelper.GetObjectFromJson <List <ProductModel> >(HttpContext.Session, sessionKey);
StringContent content = new StringContent(JsonConvert.SerializeObject(productFromSessionCard), Encoding.UTF8, "application/json");
CheckoutModel checkoutModel = JsonConvert.DeserializeObject <CheckoutModel>(await MVCHelper.PostLoginAPI(configuration.GetSection("baseUrl").Value + "api/ProductToCard/" + sessionKey, content));
HttpContext.Session.Remove("card");
return(View("Checkout", checkoutModel));
}
else
{
return(RedirectToAction("Login", "Login"));
}
}
public UserSelectForm(CheckData checkModel, CheckoutModel checkoutModel, EDZ eDZ, ResultJSON resultJSONTemp)
{
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
this.objEDZ = eDZ;
this.resultJSON = resultJSONTemp;
this.model = checkoutModel;
this.checkData = checkModel;
InitializeComponent();
Timer = new System.Windows.Forms.Timer()
{
Interval = 100
};
Timer.Tick += new EventHandler(Timer_Tick);
base.Opacity = 0;
Timer.Start();
}
// GET: Checkout
public ActionResult Index()
{
CheckoutModel model = new CheckoutModel();
// TODO: check this order id = cust's order id
int orderId = int.Parse(Request.Cookies["OrderId"].Value);
using (WebStoreDatabaseEntities e = new WebStoreDatabaseEntities())
{
var cart = e.OrderHeaders.Single(x => x.OrderId == orderId);
//gets shipping method for display
model.ShippingList = e.Shippings.Select(x => x.Method).ToList();
var shipPrice = e.Shippings.Single(x => x.Method == model.ShippingMethod).Price;
model.TotalDue = cart.SubTotal + shipPrice;
// TODO: eventually add state tax, but for now assume the ship price includes some type of tax
}
return(View(model));
}
public bool AddToOrders(CheckoutModel orders)
{
using (var connection = new MySqlConnection(this.connectionString))
{
try
{
connection.Execute(
"insert into orders (price, adress, email, name) values (@price, @adress, @email, @name)",
new { price = @orders.price, adress = @orders.adress, email = @orders.email, name = @orders.name });
}
catch (Exception)
{
return(false);
}
}
return(true);
}
public ReadIdCardFrm(CheckoutModel checkModel, ResultJSON resultJSONTemp)
{
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
this.model = checkModel;
this.resultJson = resultJSONTemp;
InitializeComponent();
Timer = new System.Windows.Forms.Timer()
{
Interval = 100
};
Timer.Tick += new EventHandler(Timer_Tick);
base.Opacity = 0;
Timer.Start();
}
public IActionResult Hold(int id) //Giu sach
{
var asset = _assets.Get(id);
//HttpContext.Session.SetInt32("LibraryCard", patron_id.LibraryCard.Id);
// msg += HttpContext.Session.GetInt32("LibraryCard");
//msg += HttpContext.Session.GetString("username");
var libCard = HttpContext.Session.GetInt32("LibraryCard");
var model = new CheckoutModel
{
AssetId = id,
ImageUrl = asset.ImageUrl,
Title = asset.Title,
LibraryCardId = libCard.ToString(),
HoldCount = _checkouts.GetCurrentHold(id).Count()
};
return(View(model));
//return Content(msg);
}
public IActionResult Hold(int id)
{
var device = _devices.GetById(id);
//var user = _users.Get(Int32.Parse(this.User.FindFirstValue(ClaimTypes.NameIdentifier)));
var user = _users.GetAll().FirstOrDefault(u => u.Username == this.User.Identity.Name);
var model = new CheckoutModel
{
DeviceID = id,
ImageUrl = device.ImageUrl,
Description = device.Description,
//UserCardId = user.UserCard.Id.ToString(),
UserId = user.Id.ToString(),
IsCheckedOut = _checkouts.IsCheckedOut(id),
HoldCount = _checkouts.GetCurrentHolds(id).Count()
};
return(View(model));
}
public IActionResult Checkout(int id)
{
var device = _devices.GetById(id);
//Need to update the following line after implementing the new Authentication system
//var user = _users.Get(Int32.Parse(this.User.FindFirstValue(ClaimTypes.NameIdentifier)));
var user = _users.GetAll().FirstOrDefault(u => u.Username == this.User.Identity.Name);
var model = new CheckoutModel
{
DeviceID = id,
ImageUrl = device.ImageUrl,
Description = device.Description,
//UserCardId = user.UserCard.Id.ToString(),
UserId = user.Id.ToString(),
IsCheckedOut = _checkouts.IsCheckedOut(id)
};
return(View(model));
}
public ActionResult Result()
{
// Get values from model and send to view
CheckoutModel checkout = new CheckoutModel();
string checkoutStr = HttpContext.Session.GetString("checkout");
checkout = JsonConvert.DeserializeObject <CheckoutModel>(checkoutStr);
ViewBag.Name = checkout.Name;
ViewBag.Ssn = checkout.Ssn;
ViewBag.Address = checkout.Address;
ViewBag.Zip = checkout.Zip;
ViewBag.City = checkout.City;
ViewBag.Phone = checkout.Phone;
ViewBag.Email = checkout.Email;
HttpContext.Session.Remove("SelectedItems");
ViewData["CartItems"] = 0;
return(View());
}
public CheckoutModel GetCheckout()
{
//kiem tra coi da dang nhap hay chua de hien thi View tuong ung
string username = SessionHelper.GetUserSession();
CheckoutModel checkout = new CheckoutModel();
if (username != null)
{
checkout.listCartSession = SessionHelper.GetCartSession(username);
//checkout.user = (from u in db.THANHVIENs where u.TENDANGNHAP == username select u).SingleOrDefault();
//ViewBag.summoney = Summoney(checkout.listCartSession);
return(checkout);
}
else
{
checkout.listCartSession = SessionHelper.GetCartSession("cart");
return(checkout);
}
}
/// <summary>
/// Populate and return the custom checkout model, containing billing and shipping information, along with the shopping cart.
/// </summary>
/// <param name="customerId">the customer to get the cart information for</param>
/// <returns></returns>
public ActionResult Checkout(int customerId)
{
CheckoutModel cart = new CheckoutModel();
// initialize the sub-model as well
cart.billing = new BillingModel();
try
{
// query entity model for customer and relevant addresses/billing information
Customer customer = _db.Customer
.Include(cust => cust.Address)
.ThenInclude(add => add.BillingInformation)
.First(m => m.CustomerId == customerId);
cart.customer = customer;
cart.shoppingCart = GetCart(cart.customer.CustomerId)
.Where(x => !x.IsWishList)
.ToList();
// sum the total cost of the cart items
cart.amount = 0;
foreach (var item in cart.shoppingCart)
{
cart.amount += (item.Inventory.Price * item.Quantity);
}
cart.billing.billingAddress = customer.Address.Where(m => m.AddressType == "Billing").FirstOrDefault();
cart.billing.shippingAddress = customer.Address.Where(m => m.AddressType == "Shipping").FirstOrDefault();
if (cart.billing.billingAddress != null)
{
cart.billing.billingInformation = cart.billing.billingAddress.BillingInformation.FirstOrDefault();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
return(View(cart));
}
// POST: /Imprimir/CheckoutPagamento
public IActionResult AjaxCheckoutPagamento(CheckoutModel checkout)
{
try
{
var validation = new CheckoutValidation().Validate(checkout);
if (validation.IsValid)
{
PedidoModel pedido = PedidoFromSession();
pedido.Checkout = checkout;
db.Pedidos.Insert(pedido);
int valor = (int)((pedido.valor_total) * 100);
return(Json(new
{
res = true,
amount = valor.ToString(),
/*customer = new
* {
* external_id = "123",
* }*/
}));
}
else
{
var errors = validation.Errors.Select(e => e.ErrorMessage).ToList();
return(Json(new
{
res = false,
errors
}));
}
}
catch (Exception)
{
return(Json(new
{
res = false,
errors = new[] { "Erro no servidor" }
}));
}
}
public async Task <IActionResult> Checkout([FromBody] CheckoutModel checkoutModel)
{
using (var transaction = scvContext.Database.BeginTransaction(IsolationLevel.Serializable))
{
var order = await scvContext.Orders
.Include(o => o.OrderItems)
.Where(o => o.Id == checkoutModel.CartId)
.Cacheable()
.SingleAsync();
var orderNumber = await scvContext.Orders
.MaxAsync(o => o.OrderNumber) ?? 0;
order.OrderNumber = ++orderNumber;
order.OrderStatus = OrderStatus.Closed;
order.CloseDate = DateTime.Now;
scvContext.Orders.Update(order);
var orderDetails = new OrderDetails
{
OrderId = checkoutModel.CartId,
Street = checkoutModel.Street,
City = checkoutModel.City,
State = checkoutModel.State,
Country = checkoutModel.Country,
PostalCode = checkoutModel.PostalCode,
CreditCardNumber = checkoutModel.CreditCardNumber,
VerificationCode = checkoutModel.VerificationCode
};
scvContext.OrderDetails.Add(orderDetails);
await scvContext.SaveChangesAsync();
await providerService.SellProductsAsync(order);
transaction.Commit();
return(Ok(orderNumber));
}
}
public ActionResult Index(CheckoutModel model)
{
if (ModelState.IsValid)
{
// TODO: if check out...
using (WebStoreDatabaseEntities entities = new WebStoreDatabaseEntities())
{
int orderNumber = int.Parse(Request.Cookies["OrderId"].Value);
var orderHeader = entities.OrderHeaders.Single(x => x.OrderId == orderNumber);
//looks at shipping table, gets method that equals model.method, then finds the ID for that method.
var shipMethod = entities.Shippings.Single(x => x.Method == model.ShippingMethod).ShippingMethodId;
var address = entities.Addresses.FirstOrDefault(
x => x.Line1 == model.ShippingAddress1 &&
x.Line2 == model.ShippingAddress2 &&
x.City == model.ShippingCity &&
x.State == model.ShippingState &&
x.Zipcode == model.ShippingZipcode);
if (address == null)
{
address = new Address
{
AddressId = entities.Addresses.Max(x => x.AddressId) + 1,
Line1 = model.ShippingAddress1,
Line2 = model.ShippingAddress2,
City = model.ShippingCity,
State = model.ShippingState,
Zipcode = model.ShippingZipcode,
};
entities.Addresses.Add(address);
}
orderHeader.ShipToAddress = address.AddressId;
entities.SaveChanges();
}
return(RedirectToAction("Index", "Receipt"));
}
else
{
return(View(model));
}
}
public ActionResult UpdateUserToBasket(CheckoutModel model)
{
if (!ModelState.IsValid)
{
return(JsonValidationError());
}
var responseresult = new ResponseModel <Omnicx.WebStore.Models.Commerce.BasketModel>();
var response = _customerRepository.GetUserdetailsByUserName(Sanitizer.GetSafeHtmlFragment(model.Email));
var existingUser = response.Result;
if (existingUser.Count > 0)
{
var customerId = existingUser[0].UserId;
if (model.CustomerId == null)
{
responseresult = _checkoutApi.UpdateUserToBasket(model.BasketId, customerId.ToString());
}
}
return(JsonSuccess(responseresult, JsonRequestBehavior.AllowGet));
}
public IActionResult PlaceCheckout(int assetId, int libraryCardId)
{
if (_checkouts.CheckHoldExist(assetId, libraryCardId) || _checkouts.CheckLibraryCardId(libraryCardId))
{
ViewBag.error = "Invalid";
var asset = _assets.Get(assetId);
var model = new CheckoutModel
{
AssetId = assetId,
ImageUrl = asset.ImageUrl,
Title = asset.Title,
LibraryCardId = "",
HoldCount = _checkouts.GetCurrentHold(assetId).Count()
};
return(View("Checkout", model));
}
_checkouts.CheckoutItem(assetId, libraryCardId);
return(RedirectToAction("Detail", new { id = assetId }));
}
public ActionResult Betaal()
{
//haal de sessie op
List <ShoppingCartItem> lijst = HaalCartSessieOp();
//vul checkoutmodel met juiste events
CartPresentationModel reservingen = presentation.FillPresentationModel(lijst);
CheckoutModel Model = new CheckoutModel(reservingen);
if (Model.Reserveringen.Items.Count > 0 && Model.Email != "")
{
return(View(Model));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public ActionResult Index(BillingInfo info)
{
CheckoutModel model = new CheckoutModel()
{
Info = new CheckoutInfo
{
BillingInfo = info
}
};
// get Cart list items from sesion
var sesionList = (List<CartItem>)Session["CART_SESSION"];
CartModel cartModel = new CartModel();
if (sesionList != null)
{
cartModel.get_Item_Details(sesionList);
}
else
{
List<CartItem> list = new List<CartItem>();
cartModel.itemList = list;
}
model.Info.CartItems = cartModel.itemList;
// create orders
var helper = new Cart_CheckoutModel();
try
{
helper.Create_Order_Infomation(model.Info);
ViewBag.isSuccess = true;
}
catch (Exception ex)
{
ViewBag.isSuccess = false;
}
return View("ThongBao");
}
public ViewResult Checkout()
{
CheckoutModel model = new CheckoutModel()
{
};
foreach (var item in cart.Lines)
{
model.Movies.Add(item.Movie);
}
//foreach (var item in cart.Lines)
//{
// model.games.Add(item.Game);
//}
return(View(new CartIndexViewModel
{
Cart = GetCart()
}));
}
public CheckoutModel GetMyWallet(string providerUserKey)
{
using (var context = new greenMoneyEntities())
{
var user = context.Users1.Find(new Guid(providerUserKey));
var vaucerItems = user.Vouchers.Select(i => new WalletItemSummary
{
VoucherId = i.Id,
Name = i.Rewards.PartnerName,
Description = i.Rewards.Name,
Price = i.Rewards.Price,
DollarPrice = i.Rewards.DollarPrice,
ImageId = i.Rewards.ImageId,
DateAdded = i.Issued,
DateExpired = i.Issued.AddDays(30),
ValidFrom = i.Rewards.ValidFrom,
ValidTo = i.Rewards.ValidTo,
Mobile = i.Rewards.Mobile
}).ToList();
//vaucerItems = vaucerItems.Where(v => v.ValidTo != null && v.DateAdded > DateTime.Now.AddDays(-30)).ToList();
List<WalletItemSummary> vouchersToShow = vaucerItems.Where(v => v.DateExpired >= DateTime.Now).ToList();
var model = new CheckoutModel
{
Items = vouchersToShow.OrderBy(v=>v.DateExpired).ThenBy(v=>v.DateAdded),
CartTotal = user.CartItems.Sum(i => i.Cost),
CartDollarTotal = user.CartItems.Sum(i => i.DollarCost),
//a reward is a voucher if it has a $0 price
HasVouchers = user.CartItems.Any(i => i.Rewards.DollarPrice == 0)
};
return model;
}
}
public CheckoutModel GetMyCartCheckout(string providerUserKey)
{
using (var context = new greenMoneyEntities())
{
var user = context.Users1.Find(new Guid(providerUserKey));
var items = user.CartItems.Select(i => new WalletItemSummary
{
Id = i.Id,
Name = i.Rewards.Name,
Description = i.Rewards.Description,
Quantity = i.Quantity,
Price = i.Rewards.Price,
DollarPrice = i.Rewards.DollarPrice,
ImageId = i.Rewards.ImageId,
DateAdded = i.Rewards.DateAdded,
ValidFrom = i.Rewards.AvailableFrom,
ValidTo = i.Rewards.AvailableTo
});
var model = new CheckoutModel
{
Items = items.OrderByDescending(c=>c.DateExpired).ThenByDescending(c=>c.DateAdded),
CartTotal = user.CartItems.Sum(i => i.Cost),
CartDollarTotal = user.CartItems.Sum(i => i.DollarCost),
//a reward is a voucher if it has a $0 price
HasVouchers = user.CartItems.Any(i => i.Rewards.DollarPrice == 0)
};
return model;
}
}
/// <summary>
/// Prepares the checkout model.
/// </summary>
/// <param name="model">The checkout model.</param>
/// <returns>CheckoutModel.</returns>
private CheckoutModel PrepareCheckoutModel(CheckoutModel model)
{
model.ButtonText = "Already registered? Click here to login.";
model.Type = PopupType.LinkButton;
model.ViewName = "~/Account/LogOnAsync";
model.PopupTitle = "Login or Create New Account";
var countries = _countryClient.GetAllCountries();
// Bind addresses
if (model.BillingAddress == null)
{
model.BillingAddress = new CheckoutAddressModel { Address = new AddressModel { Name = "Billing" } };
}
if (model.ShippingAddress == null)
{
model.ShippingAddress = new CheckoutAddressModel { Address = new AddressModel { Name = "Shipping" } };
}
model.BillingAddress.Countries = countries;
model.ShippingAddress.Countries = countries;
if (model.AddressBook == null)
{
model.AddressBook = new AddressBook();
}
if (UserHelper.CustomerSession.IsRegistered)
{
model.AddressBook.Addresses = UserHelper.GetAllCustomerAddresses().ToArray();
}
return model;
}
public CheckoutModel GetMyChallengesWallet(string providerUserKey)
{
using (var context = new greenMoneyEntities())
{
DateTime monthBeforeDate = DateTime.Today.AddDays(-30);
var userChallenges = context.UserChallenges.Where(c => c.UserId == new Guid(providerUserKey)
&& c.Issued > monthBeforeDate && c.PointsClaimed == false);
List<WalletItemSummary> challenges = new List<WalletItemSummary>();
foreach (var challenge in userChallenges)
{
WalletItemSummary summaryModel = new WalletItemSummary
{
Id = challenge.ChallengeId.HasValue ? challenge.ChallengeId.Value : 0,
Name = challenge.Challenges.Name,
Description = challenge.Challenges.EarnAmount,
ChallengeCategoryShortName = challenge.Challenges.ChallengeCategories.ShortName,
CategoryImageId = challenge.Challenges.ChallengeCategories.ImageId,
ImageId = challenge.Challenges.LogoImageId,
DateAdded = challenge.Issued,
DateExpired = challenge.Challenges.EndDate,
PointsClaimed = challenge.PointsClaimed != null && (bool)challenge.PointsClaimed
};
challenges.Add(summaryModel);
}
var model = new CheckoutModel
{
Items = challenges.OrderBy(c => c.DateExpired).ThenBy(c => c.DateAdded)
};
return model;
}
}
/// <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);
}
}
private void RecalculateCart(CheckoutModel checkoutModel)
{
// reset the cart
Ch.Reset();
// Update cart from the post back
UpdateCart(checkoutModel);
// run workflow
Ch.RunWorkflow("ShoppingCartPrepareWorkflow");
// save changes
Ch.SaveChanges();
}
public ActionResult PaypalExpress(CheckoutModel model, SolutionTypeType solutionType = SolutionTypeType.SOLE)
{
// Create request object
var request = new SetExpressCheckoutRequestType();
var ecDetails = new SetExpressCheckoutRequestDetailsType
{
CallbackTimeout = "3",
ReturnURL = Url.Action("PaypalExpressSuccess", "Checkout", null, "http"),
CancelURL = Url.Action("Index", "Checkout", null, "http"),
SolutionType = solutionType
};
var currency = (CurrencyCodeType)Enum.Parse(typeof(CurrencyCodeType), Ch.CustomerSession.Currency.ToUpper());
model = PrepareCheckoutModel(model);
model.Payments = model.Payments ?? GetPayments().ToArray();
var payment = _paymentClient.GetPaymentMethod(model.PaymentMethod ?? "Paypal");
var configMap = payment.CreateSettings();
//Create Shipping methods
var shippingMethods = GetShipinngMethodModels();
var noShippingMethod = !shippingMethods.Any(x => x.IsCurrent);
string currentShippingOption = null;
for (var i = 0; i < shippingMethods.Length; i++)
{
var shipping = shippingMethods[i];
var shippingOptionIsDefault = "0";
if (shipping.IsCurrent || noShippingMethod && i == 0)
{
shippingOptionIsDefault = "1";
currentShippingOption = shipping.Method.Name;
}
ecDetails.FlatRateShippingOptions.Add(new ShippingOptionType
{
ShippingOptionAmount = new BasicAmountType(currency, FormatMoney(shipping.Price)),
ShippingOptionIsDefault = shippingOptionIsDefault,
ShippingOptionName = shipping.Method.Name,
});
}
var recalcualteCart = false;
if (!string.Equals(model.ShippingMethod,currentShippingOption))
{
model.ShippingMethod = currentShippingOption;
recalcualteCart = true;
}
if (!string.Equals(model.PaymentMethod, payment.Name))
{
model.PaymentMethod = payment.Name;
recalcualteCart = true;
}
if (recalcualteCart)
{
//Must recalculate cart as prices could have changed
RecalculateCart(model);
}
// (Optional) Email address of the buyer as entered during checkout. PayPal uses this value to pre-fill the PayPal membership sign-up portion on the PayPal pages.
if (model.BillingAddress != null && !string.IsNullOrEmpty(model.BillingAddress.Address.Email))
{
ecDetails.BuyerEmail = model.BillingAddress.Address.Email;
}
ecDetails.NoShipping = "2";
ecDetails.PaymentDetails.Add(GetPaypalPaymentDetail(currency, PaymentActionCodeType.SALE));
ecDetails.MaxAmount = new BasicAmountType(currency, FormatMoney(Math.Max(Ch.Cart.Total, Ch.Cart.Subtotal)));
ecDetails.LocaleCode = new RegionInfo(Thread.CurrentThread.CurrentUICulture.LCID).TwoLetterISORegionName;
//paymentDetails.OrderDescription = Ch.Cart.Name;
AddressModel modelAddress = null;
if (!model.UseForShipping && model.ShippingAddress != null && DoValidateModel(model.ShippingAddress.Address))
{
modelAddress = model.ShippingAddress.Address;
}
else if (model.BillingAddress != null && DoValidateModel(model.BillingAddress.Address))
{
modelAddress = model.BillingAddress.Address;
}
if (modelAddress != null)
{
ecDetails.AddressOverride = "1";
var shipAddress = new AddressType
{
Name = string.Format("{0} {1}", modelAddress.FirstName, modelAddress.LastName),
Street1 = modelAddress.Line1,
Street2 = modelAddress.Line2,
CityName = modelAddress.City,
StateOrProvince = modelAddress.StateProvince,
Country = (CountryCodeType)Enum.Parse(typeof(CountryCodeType), modelAddress.CountryCode.Substring(0, 2)),
PostalCode = modelAddress.PostalCode,
Phone = modelAddress.DaytimePhoneNumber
};
ecDetails.PaymentDetails[0].ShipToAddress = shipAddress;
}
request.SetExpressCheckoutRequestDetails = ecDetails;
// Invoke the API
var wrapper = new SetExpressCheckoutReq { SetExpressCheckoutRequest = request };
// Create the PayPalAPIInterfaceServiceService service object to make the API call
var service = new PayPalAPIInterfaceServiceService(configMap);
SetExpressCheckoutResponseType setEcResponse = null;
try
{
setEcResponse = service.SetExpressCheckout(wrapper);
}
catch (Exception ex)
{
ModelState.AddModelError("", @"Paypal failure".Localize());
ModelState.AddModelError("", ex.Message);
}
if (setEcResponse != null)
{
// Check for API return status
if (setEcResponse.Ack.Equals(AckCodeType.FAILURE) ||
(setEcResponse.Errors != null && setEcResponse.Errors.Count > 0))
{
ModelState.AddModelError("", @"Paypal failure".Localize());
foreach (var error in setEcResponse.Errors)
{
ModelState.AddModelError("", error.LongMessage);
}
}
else
{
var redirectUrl =
string.Format(
configMap.ContainsKey("URL")
? configMap["URL"]
: "https://www.sandbox.paypal.com/webscr&cmd={0}",
"_express-checkout&token=" + setEcResponse.Token);
TempData.Add("checkout_" + setEcResponse.Token,model);
return Redirect(redirectUrl);
}
}
return View("Index", model);
}
public ActionResult ProcessCheckout(CheckoutModel checkoutModel)
{
//Need to submit changes again to make sure cart is still valid
RecalculateCart(checkoutModel);
if (!ModelState.IsValid)
{
return View("Index", checkoutModel);
}
if (checkoutModel.PaymentMethod.Equals("PayPal", StringComparison.OrdinalIgnoreCase))
{
return PaypalExpress(checkoutModel, SolutionTypeType.MARK);
}
if (UserHelper.CustomerSession.IsRegistered)
{
var orgs = _userClient.GetOrganizationsForCurrentUser();
if (orgs != null)
{
var org = orgs.SingleOrDefault();
if (org != null)
Ch.Cart.OrganizationId = org.MemberId;
}
var user = _userClient.GetCurrentCustomer(false);
// Save addresses to customer address book
if (checkoutModel.AddressBook.SaveBillingAddress)
{
var billing = ConvertToCustomerAddress(checkoutModel.BillingAddress.Address);
billing.AddressId = Guid.NewGuid().ToString();
user.Addresses.Add(billing);
}
if (checkoutModel.AddressBook.SaveShippingAddress)
{
var shipping = ConvertToCustomerAddress(checkoutModel.ShippingAddress.Address);
shipping.AddressId = Guid.NewGuid().ToString();
user.Addresses.Add(shipping);
}
//Save last ordered date&time to customer profile
var lastOrdered = user.ContactPropertyValues.FirstOrDefault(x => x.Name == ContactPropertyValueName.LastOrder);
if (lastOrdered != null)
{
lastOrdered.DateTimeValue = DateTime.UtcNow;
}
else
{
user.ContactPropertyValues.Add(new ContactPropertyValue
{
DateTimeValue = DateTime.UtcNow,
Name = ContactPropertyValueName.LastOrder,
ValueType = PropertyValueType.DateTime.GetHashCode()
});
}
_userClient.SaveCustomerChanges(user.MemberId);
}
else if (checkoutModel.CreateAccount)
{
var regModel = new RegisterModel();
regModel.InjectFrom(checkoutModel, checkoutModel.BillingAddress.Address);
//Save billing address to book
var billing = ConvertToCustomerAddress(checkoutModel.BillingAddress.Address);
billing.AddressId = Guid.NewGuid().ToString();
regModel.Addresses.Add(billing);
//save shipping address to book
if (!checkoutModel.UseForShipping)
{
var shipping = ConvertToCustomerAddress(checkoutModel.ShippingAddress.Address);
shipping.AddressId = Guid.NewGuid().ToString();
regModel.Addresses.Add(shipping);
}
string message;
if (!UserHelper.Register(regModel, out message))
{
ModelState.AddModelError("", message);
return View("Index", checkoutModel);
}
UserHelper.OnPostLogon(regModel.Email);
}
if (DoCheckout())
{
return RedirectToAction("ProcessCheckout", "Checkout", new { id = Ch.Cart.OrderGroupId });
}
return View("Index", checkoutModel);
}
public ActionResult SubmitChanges(CheckoutModel checkoutModel)
{
RecalculateCart(checkoutModel);
return DisplayCart();
}
/// <summary>
/// Checkout home page
/// </summary>
/// <returns>ActionResult.</returns>
public ActionResult Index()
{
if (Ch.IsEmpty)
return RedirectToAction("Index", "Cart");
var model = new CheckoutModel();
//Need to make sure we are displaying correct cart
RecalculateCart(model);
//Dont show any errors initially
ModelState.Clear();
return View(model);
}
public ActionResult ProcessCheckout(CheckoutModel checkoutModel)
{
//Need to submit changes again to make sure cart is still valid
RecalculateCart(checkoutModel);
if (!ModelState.IsValid)
{
return View("Index", checkoutModel);
}
if (checkoutModel.PaymentMethod.Equals("PayPal", StringComparison.OrdinalIgnoreCase))
{
return PaypalExpress(checkoutModel, SolutionTypeType.MARK);
}
if (UserHelper.CustomerSession.IsRegistered)
{
var orgs = _userClient.GetOrganizationsForCurrentUser();
if (orgs != null)
{
var org = orgs.SingleOrDefault();
if (org != null)
Ch.Cart.OrganizationId = org.MemberId;
}
var user = _userClient.GetCurrentCustomer(false);
// Save addresses to customer address book
if (checkoutModel.AddressBook.SaveBillingAddress)
{
var billing = ConvertToCustomerAddress(checkoutModel.BillingAddress.Address);
billing.AddressId = Guid.NewGuid().ToString();
user.Addresses.Add(billing);
}
if (checkoutModel.AddressBook.SaveShippingAddress)
{
var shipping = ConvertToCustomerAddress(checkoutModel.ShippingAddress.Address);
shipping.AddressId = Guid.NewGuid().ToString();
user.Addresses.Add(shipping);
}
//Save last ordered date&time to customer profile
var lastOrdered = user.ContactPropertyValues.FirstOrDefault(x => x.Name == ContactPropertyValueName.LastOrder);
if (lastOrdered != null)
{
lastOrdered.DateTimeValue = DateTime.UtcNow;
}
else
{
user.ContactPropertyValues.Add(new ContactPropertyValue
{
DateTimeValue = DateTime.UtcNow,
Name = ContactPropertyValueName.LastOrder,
ValueType = PropertyValueType.DateTime.GetHashCode()
});
}
_userClient.SaveCustomerChanges(user.MemberId);
}
else if (checkoutModel.CreateAccount)
{
var regModel = new RegisterModel();
regModel.InjectFrom(checkoutModel, checkoutModel.BillingAddress.Address);
//Save billing address to book
var billing = ConvertToCustomerAddress(checkoutModel.BillingAddress.Address);
billing.AddressId = Guid.NewGuid().ToString();
regModel.Addresses.Add(billing);
//save shipping address to book
if (!checkoutModel.UseForShipping)
{
var shipping = ConvertToCustomerAddress(checkoutModel.ShippingAddress.Address);
shipping.AddressId = Guid.NewGuid().ToString();
regModel.Addresses.Add(shipping);
}
string message,token;
var requireConfirmation = StoreHelper.GetSettingValue("RequireAccountConfirmation", false);
if (!UserHelper.Register(regModel, requireConfirmation, out message, out token))
{
ModelState.AddModelError("", message);
return View("Index", checkoutModel);
}
if (requireConfirmation)
{
var user = string.Format("{0} {1}", regModel.FirstName, regModel.LastName);
var linkUrl = Url.Action("ConfirmAccount", "Account", new { token, username = regModel.Email }, Request.Url.Scheme);
if (
UserHelper.SendEmail(linkUrl, user, regModel.Email, "confirm-account",
emailMessage =>
{
//Use default template
emailMessage.Html =
string.Format(
"<b>{0}</b> <br/><br/> To confirm your account, click on the following link:<br/> <br/> <a href='{1}'>{1}</a> <br/>",
user,
linkUrl);
emailMessage.Subject = "Account confirmation";
}))
{
TempData[GetMessageTempKey(MessageType.Success)] = new[]
{
"Your account was succesfully created. To confirm your account follow the instruction received in email.".Localize()
};
}
else
{
TempData[GetMessageTempKey(MessageType.Error)] = new[] { string.Format("Failed to send confirmation email to {0}.".Localize(), regModel.Email) };
}
}
else
{
UserHelper.OnPostLogon(regModel.Email);
}
}
if (DoCheckout())
{
return RedirectToAction("ProcessCheckout", "Checkout", new { id = Ch.Cart.OrderGroupId });
}
return View("Index", checkoutModel);
}
