public void Can_save_and_load_download()
{
var guid = Guid.NewGuid();
var download = new Download
{
DownloadGuid = guid,
UseDownloadUrl = true,
DownloadUrl = "http://www.someUrl.com/file.zip",
DownloadBinary = new byte[] { 1, 2, 3 },
ContentType = "application/x-zip-co",
Filename = "file",
Extension = ".zip",
IsNew = true
};
var fromDb = SaveAndLoadEntity(download);
fromDb.ShouldNotBeNull();
fromDb.DownloadGuid.ShouldEqual(guid);
fromDb.UseDownloadUrl.ShouldEqual(true);
fromDb.DownloadUrl.ShouldEqual("http://www.someUrl.com/file.zip");
fromDb.DownloadBinary.ShouldEqual(new byte[] { 1, 2, 3 });
fromDb.ContentType.ShouldEqual("application/x-zip-co");
fromDb.Filename.ShouldEqual("file");
fromDb.Extension.ShouldEqual(".zip");
fromDb.IsNew.ShouldEqual(true);
}
/// <summary>
/// Deletes a download
/// </summary>
/// <param name="download">Download</param>
public virtual void DeleteDownload(Download download)
{
if (download == null)
throw new ArgumentNullException("download");
_downloadRepository.Delete(download);
_eventPubisher.EntityDeleted(download);
}
public ActionResult AsyncUpload()
{
//we process it distinct ways based on a browser
//find more info here http://stackoverflow.com/questions/4884920/mvc3-valums-ajax-file-upload
Stream stream = null;
var fileName = "";
var contentType = "";
if (String.IsNullOrEmpty(Request["qqfile"]))
{
// IE
HttpPostedFileBase httpPostedFile = Request.Files[0];
if (httpPostedFile == null)
throw new ArgumentException("No file uploaded");
stream = httpPostedFile.InputStream;
fileName = Path.GetFileName(httpPostedFile.FileName);
contentType = httpPostedFile.ContentType;
}
else
{
//Webkit, Mozilla
stream = Request.InputStream;
fileName = Request["qqfile"];
}
var fileBinary = new byte[stream.Length];
stream.Read(fileBinary, 0, fileBinary.Length);
var fileExtension = Path.GetExtension(fileName);
if (!String.IsNullOrEmpty(fileExtension))
fileExtension = fileExtension.ToLowerInvariant();
var download = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = false,
DownloadUrl = "",
DownloadBinary = fileBinary,
ContentType = contentType,
//we store filename without extension for downloads
Filename = Path.GetFileNameWithoutExtension(fileName),
Extension = fileExtension,
IsNew = true
};
_downloadService.InsertDownload(download);
//when returning JSON the mime-type must be set to text/plain
//otherwise some browsers will pop-up a "Save As" dialog.
return Json(new { success = true,
downloadId = download.Id,
downloadUrl = Url.Action("DownloadFile", new { downloadId = download.Id }) },
"text/plain");
}
protected void ParseAndSaveCheckoutAttributes(List<ShoppingCartItem> cart, FormCollection form)
{
string selectedAttributes = "";
var checkoutAttributes = _checkoutAttributeService.GetAllCheckoutAttributes();
if (!cart.RequiresShipping())
{
//remove attributes which require shippable products
checkoutAttributes = checkoutAttributes.RemoveShippableAttributes();
}
foreach (var attribute in checkoutAttributes)
{
string controlId = string.Format("checkout_attribute_{0}", attribute.Id);
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.ColorSquares:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
int selectedAttributeId = int.Parse(ctrlAttributes);
if (selectedAttributeId > 0)
selectedAttributes = _checkoutAttributeParser.AddCheckoutAttribute(selectedAttributes,
attribute, selectedAttributeId.ToString());
}
}
break;
case AttributeControlType.Checkboxes:
{
var cblAttributes = form[controlId];
if (!String.IsNullOrEmpty(cblAttributes))
{
foreach (var item in cblAttributes.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
int selectedAttributeId = int.Parse(item);
if (selectedAttributeId > 0)
selectedAttributes = _checkoutAttributeParser.AddCheckoutAttribute(selectedAttributes,
attribute, selectedAttributeId.ToString());
}
}
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
string enteredText = ctrlAttributes.Trim();
selectedAttributes = _checkoutAttributeParser.AddCheckoutAttribute(selectedAttributes,
attribute, enteredText);
}
}
break;
case AttributeControlType.Datepicker:
{
var date = form[controlId + "_day"];
var month = form[controlId + "_month"];
var year = form[controlId + "_year"];
DateTime? selectedDate = null;
try
{
selectedDate = new DateTime(Int32.Parse(year), Int32.Parse(month), Int32.Parse(date));
}
catch { }
if (selectedDate.HasValue)
{
selectedAttributes = _checkoutAttributeParser.AddCheckoutAttribute(selectedAttributes,
attribute, selectedDate.Value.ToString("D"));
}
}
break;
case AttributeControlType.FileUpload:
{
var httpPostedFile = this.Request.Files[controlId];
if ((httpPostedFile != null) && (!String.IsNullOrEmpty(httpPostedFile.FileName)))
{
int fileMaxSize = _catalogSettings.FileUploadMaximumSizeBytes;
if (httpPostedFile.ContentLength > fileMaxSize)
{
//TODO display warning
//warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.MaximumUploadedFileSize"), (int)(fileMaxSize / 1024)));
}
else
{
//save an uploaded file
var download = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = false,
DownloadUrl = "",
DownloadBinary = httpPostedFile.GetDownloadBits(),
ContentType = httpPostedFile.ContentType,
Filename = System.IO.Path.GetFileNameWithoutExtension(httpPostedFile.FileName),
Extension = System.IO.Path.GetExtension(httpPostedFile.FileName),
IsNew = true
};
_downloadService.InsertDownload(download);
//save attribute
selectedAttributes = _checkoutAttributeParser.AddCheckoutAttribute(selectedAttributes,
attribute, download.DownloadGuid.ToString());
}
}
}
break;
default:
break;
}
}
//save checkout attributes
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, SystemCustomerAttributeNames.CheckoutAttributes, selectedAttributes);
}
public ActionResult UploadFileProductAttribute(int productVariantId, int productAttributeId)
{
var productVariant = _productService.GetProductVariantById(productVariantId);
if (productVariant == null ||
!productVariant.Published ||
productVariant.Deleted ||
productVariant.Product == null ||
!productVariant.Product.Published ||
productVariant.Product.Deleted)
{
return Json(new
{
success = false,
downloadGuid = Guid.Empty,
}, "text/plain");
}
//ensure that this attribute belong to this product variant and has "file upload" type
var pva = _productAttributeService
.GetProductVariantAttributesByProductVariantId(productVariantId)
.FirstOrDefault(pa => pa.ProductAttributeId == productAttributeId);
if (pva == null || pva.AttributeControlType != AttributeControlType.FileUpload)
{
return Json(new
{
success = false,
downloadGuid = Guid.Empty,
}, "text/plain");
}
//we process it distinct ways based on a browser
//find more info here http://stackoverflow.com/questions/4884920/mvc3-valums-ajax-file-upload
Stream stream = null;
var fileName = "";
var contentType = "";
if (String.IsNullOrEmpty(Request["qqfile"]))
{
// IE
HttpPostedFileBase httpPostedFile = Request.Files[0];
if (httpPostedFile == null)
throw new ArgumentException("No file uploaded");
stream = httpPostedFile.InputStream;
fileName = Path.GetFileName(httpPostedFile.FileName);
contentType = httpPostedFile.ContentType;
}
else
{
//Webkit, Mozilla
stream = Request.InputStream;
fileName = Request["qqfile"];
}
var fileBinary = new byte[stream.Length];
stream.Read(fileBinary, 0, fileBinary.Length);
var fileExtension = Path.GetExtension(fileName);
if (!String.IsNullOrEmpty(fileExtension))
fileExtension = fileExtension.ToLowerInvariant();
int fileMaxSize = _catalogSettings.FileUploadMaximumSizeBytes;
if (fileBinary.Length > fileMaxSize)
{
//when returning JSON the mime-type must be set to text/plain
//otherwise some browsers will pop-up a "Save As" dialog.
return Json(new
{
success = false,
message = string.Format(_localizationService.GetResource("ShoppingCart.MaximumUploadedFileSize"), (int)(fileMaxSize / 1024)),
downloadGuid = Guid.Empty,
}, "text/plain");
}
var download = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = false,
DownloadUrl = "",
DownloadBinary = fileBinary,
ContentType = contentType,
//we store filename without extension for downloads
Filename = Path.GetFileNameWithoutExtension(fileName),
Extension = fileExtension,
IsNew = true
};
_downloadService.InsertDownload(download);
//when returning JSON the mime-type must be set to text/plain
//otherwise some browsers will pop-up a "Save As" dialog.
return Json(new
{
success = true,
message = _localizationService.GetResource("ShoppingCart.FileUploaded"),
downloadGuid = download.DownloadGuid,
}, "text/plain");
}
/// <summary>
/// Inserts a download
/// </summary>
/// <param name="download">Download</param>
public virtual void InsertDownload(Download download)
{
if (download == null)
throw new ArgumentNullException("download");
_downloadRepository.Insert(download);
_eventPubisher.EntityInserted(download);
}
public ActionResult AddProductToOrderDetails(int orderId, int productVariantId, FormCollection form)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageOrders))
return AccessDeniedView();
//a vendor does not have to this functionality
if (_workContext.CurrentVendor != null)
return RedirectToAction("Edit", "Order", new { id = orderId });
var order = _orderService.GetOrderById(orderId);
var productVariant = _productService.GetProductVariantById(productVariantId);
//save order item
//basic properties
var unitPriceInclTax = decimal.Zero;
decimal.TryParse(form["UnitPriceInclTax"], out unitPriceInclTax);
var unitPriceExclTax = decimal.Zero;
decimal.TryParse(form["UnitPriceExclTax"], out unitPriceExclTax);
var quantity = 1;
int.TryParse(form["Quantity"], out quantity);
var priceInclTax = decimal.Zero;
decimal.TryParse(form["SubTotalInclTax"], out priceInclTax);
var priceExclTax = decimal.Zero;
decimal.TryParse(form["SubTotalExclTax"], out priceExclTax);
//attributes
//warnings
var warnings = new List<string>();
string attributes = "";
#region Product attributes
string selectedAttributes = string.Empty;
var productVariantAttributes = _productAttributeService.GetProductVariantAttributesByProductVariantId(productVariant.Id);
foreach (var attribute in productVariantAttributes)
{
string controlId = string.Format("product_attribute_{0}_{1}", attribute.ProductAttributeId, attribute.Id);
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.ColorSquares:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
int selectedAttributeId = int.Parse(ctrlAttributes);
if (selectedAttributeId > 0)
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, selectedAttributeId.ToString());
}
}
break;
case AttributeControlType.Checkboxes:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
foreach (var item in ctrlAttributes.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
int selectedAttributeId = int.Parse(item);
if (selectedAttributeId > 0)
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, selectedAttributeId.ToString());
}
}
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
string enteredText = ctrlAttributes.Trim();
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, enteredText);
}
}
break;
case AttributeControlType.Datepicker:
{
var day = form[controlId + "_day"];
var month = form[controlId + "_month"];
var year = form[controlId + "_year"];
DateTime? selectedDate = null;
try
{
selectedDate = new DateTime(Int32.Parse(year), Int32.Parse(month), Int32.Parse(day));
}
catch { }
if (selectedDate.HasValue)
{
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, selectedDate.Value.ToString("D"));
}
}
break;
case AttributeControlType.FileUpload:
{
var httpPostedFile = this.Request.Files[controlId];
if ((httpPostedFile != null) && (!String.IsNullOrEmpty(httpPostedFile.FileName)))
{
int fileMaxSize = _catalogSettings.FileUploadMaximumSizeBytes;
if (httpPostedFile.ContentLength > fileMaxSize)
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.MaximumUploadedFileSize"), (int)(fileMaxSize / 1024)));
}
else
{
//save an uploaded file
var download = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = false,
DownloadUrl = "",
DownloadBinary = httpPostedFile.GetDownloadBits(),
ContentType = httpPostedFile.ContentType,
Filename = System.IO.Path.GetFileNameWithoutExtension(httpPostedFile.FileName),
Extension = System.IO.Path.GetExtension(httpPostedFile.FileName),
IsNew = true
};
_downloadService.InsertDownload(download);
//save attribute
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, download.DownloadGuid.ToString());
}
}
}
break;
default:
break;
}
}
attributes = selectedAttributes;
#endregion
#region Gift cards
string recipientName = "";
string recipientEmail = "";
string senderName = "";
string senderEmail = "";
string giftCardMessage = "";
if (productVariant.IsGiftCard)
{
foreach (string formKey in form.AllKeys)
{
if (formKey.Equals("giftcard.RecipientName", StringComparison.InvariantCultureIgnoreCase))
{
recipientName = form[formKey];
continue;
}
if (formKey.Equals("giftcard.RecipientEmail", StringComparison.InvariantCultureIgnoreCase))
{
recipientEmail = form[formKey];
continue;
}
if (formKey.Equals("giftcard.SenderName", StringComparison.InvariantCultureIgnoreCase))
{
senderName = form[formKey];
continue;
}
if (formKey.Equals("giftcard.SenderEmail", StringComparison.InvariantCultureIgnoreCase))
{
senderEmail = form[formKey];
continue;
}
if (formKey.Equals("giftcard.Message", StringComparison.InvariantCultureIgnoreCase))
{
giftCardMessage = form[formKey];
continue;
}
}
attributes = _productAttributeParser.AddGiftCardAttribute(attributes,
recipientName, recipientEmail, senderName, senderEmail, giftCardMessage);
}
#endregion
//warnings
warnings.AddRange(_shoppingCartService.GetShoppingCartItemAttributeWarnings(ShoppingCartType.ShoppingCart, productVariant, attributes));
warnings.AddRange(_shoppingCartService.GetShoppingCartItemGiftCardWarnings(ShoppingCartType.ShoppingCart, productVariant, attributes));
if (warnings.Count == 0)
{
//no errors
//attributes
string attributeDescription = _productAttributeFormatter.FormatAttributes(productVariant, attributes, order.Customer);
//save item
var opv = new OrderProductVariant()
{
OrderProductVariantGuid = Guid.NewGuid(),
Order = order,
ProductVariantId = productVariant.Id,
UnitPriceInclTax = unitPriceInclTax,
UnitPriceExclTax = unitPriceExclTax,
PriceInclTax = priceInclTax,
PriceExclTax = priceExclTax,
AttributeDescription = attributeDescription,
AttributesXml = attributes,
Quantity = quantity,
DiscountAmountInclTax = decimal.Zero,
DiscountAmountExclTax = decimal.Zero,
DownloadCount = 0,
IsDownloadActivated = false,
LicenseDownloadId = 0
};
order.OrderProductVariants.Add(opv);
_orderService.UpdateOrder(order);
//gift cards
if (productVariant.IsGiftCard)
{
for (int i = 0; i < opv.Quantity; i++)
{
var gc = new GiftCard()
{
GiftCardType = productVariant.GiftCardType,
PurchasedWithOrderProductVariant = opv,
Amount = unitPriceExclTax,
IsGiftCardActivated = false,
GiftCardCouponCode = _giftCardService.GenerateGiftCardCode(),
RecipientName = recipientName,
RecipientEmail = recipientEmail,
SenderName = senderName,
SenderEmail = senderEmail,
Message = giftCardMessage,
IsRecipientNotified = false,
CreatedOnUtc = DateTime.UtcNow
};
_giftCardService.InsertGiftCard(gc);
}
}
//redirect to order details page
return RedirectToAction("Edit", "Order", new { id = order.Id });
}
else
{
//errors
var model = PrepareAddProductToOrderModel(order.Id, productVariant.Id);
model.Warnings.AddRange(warnings);
return View(model);
}
}
public ActionResult AddProductVariantToCart(int productId, FormCollection form)
{
var product = _productService.GetProductById(productId);
if (product == null || product.Deleted || !product.Published)
return RedirectToRoute("HomePage");
//manually process form
int productVariantId = 0;
ShoppingCartType cartType = ShoppingCartType.ShoppingCart;
foreach (string formKey in form.AllKeys)
{
if (formKey.StartsWith("addtocartbutton-"))
{
productVariantId = Convert.ToInt32(formKey.Substring(("addtocartbutton-").Length));
cartType = ShoppingCartType.ShoppingCart;
}
else if (formKey.StartsWith("addtowishlistbutton-"))
{
productVariantId = Convert.ToInt32(formKey.Substring(("addtowishlistbutton-").Length));
cartType = ShoppingCartType.Wishlist;
}
}
var productVariant = _productService.GetProductVariantById(productVariantId);
if (productVariant == null)
return RedirectToRoute("HomePage");
#region Customer entered price
decimal customerEnteredPrice = decimal.Zero;
decimal customerEnteredPriceConverted = decimal.Zero;
if (productVariant.CustomerEntersPrice)
{
foreach (string formKey in form.AllKeys)
if (formKey.Equals(string.Format("addtocart_{0}.CustomerEnteredPrice", productVariantId), StringComparison.InvariantCultureIgnoreCase))
{
if (decimal.TryParse(form[formKey], out customerEnteredPrice))
customerEnteredPriceConverted = _currencyService.ConvertToPrimaryStoreCurrency(customerEnteredPrice, _workContext.WorkingCurrency);
break;
}
}
#endregion
#region Quantity
int quantity = 1;
foreach (string formKey in form.AllKeys)
if (formKey.Equals(string.Format("addtocart_{0}.EnteredQuantity", productVariantId), StringComparison.InvariantCultureIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
break;
}
#endregion
var addToCartWarnings = new List<string>();
string attributes = "";
#region Product attributes
string selectedAttributes = string.Empty;
var productVariantAttributes = _productAttributeService.GetProductVariantAttributesByProductVariantId(productVariant.Id);
foreach (var attribute in productVariantAttributes)
{
string controlId = string.Format("product_attribute_{0}_{1}_{2}", attribute.ProductVariantId, attribute.ProductAttributeId, attribute.Id);
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.ColorSquares:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
int selectedAttributeId = int.Parse(ctrlAttributes);
if (selectedAttributeId > 0)
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, selectedAttributeId.ToString());
}
}
break;
case AttributeControlType.Checkboxes:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
foreach (var item in ctrlAttributes.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
int selectedAttributeId = int.Parse(item);
if (selectedAttributeId > 0)
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, selectedAttributeId.ToString());
}
}
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
string enteredText = ctrlAttributes.Trim();
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, enteredText);
}
}
break;
case AttributeControlType.Datepicker:
{
var day = form[controlId + "_day"];
var month = form[controlId + "_month"];
var year = form[controlId + "_year"];
DateTime? selectedDate = null;
try
{
selectedDate = new DateTime(Int32.Parse(year), Int32.Parse(month), Int32.Parse(day));
}
catch {}
if (selectedDate.HasValue)
{
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, selectedDate.Value.ToString("D"));
}
}
break;
case AttributeControlType.FileUpload:
{
var httpPostedFile = this.Request.Files[controlId];
if ((httpPostedFile != null) && (!String.IsNullOrEmpty(httpPostedFile.FileName)))
{
int fileMaxSize = _catalogSettings.FileUploadMaximumSizeBytes;
if (httpPostedFile.ContentLength > fileMaxSize)
{
addToCartWarnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.MaximumUploadedFileSize"), (int)(fileMaxSize / 1024)));
}
else
{
//save an uploaded file
var download = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = false,
DownloadUrl = "",
DownloadBinary = httpPostedFile.GetDownloadBits(),
ContentType = httpPostedFile.ContentType,
Filename = System.IO.Path.GetFileNameWithoutExtension(httpPostedFile.FileName),
Extension = System.IO.Path.GetExtension(httpPostedFile.FileName),
IsNew = true
};
_downloadService.InsertDownload(download);
//save attribute
selectedAttributes = _productAttributeParser.AddProductAttribute(selectedAttributes,
attribute, download.DownloadGuid.ToString());
}
}
}
break;
default:
break;
}
}
attributes = selectedAttributes;
#endregion
#region Gift cards
string recipientName = "";
string recipientEmail = "";
string senderName = "";
string senderEmail = "";
string giftCardMessage = "";
if (productVariant.IsGiftCard)
{
foreach (string formKey in form.AllKeys)
{
if (formKey.Equals(string.Format("giftcard_{0}.RecipientName", productVariantId), StringComparison.InvariantCultureIgnoreCase))
{
recipientName = form[formKey];
continue;
}
if (formKey.Equals(string.Format("giftcard_{0}.RecipientEmail", productVariantId), StringComparison.InvariantCultureIgnoreCase))
{
recipientEmail = form[formKey];
continue;
}
if (formKey.Equals(string.Format("giftcard_{0}.SenderName", productVariantId), StringComparison.InvariantCultureIgnoreCase))
{
senderName = form[formKey];
continue;
}
if (formKey.Equals(string.Format("giftcard_{0}.SenderEmail", productVariantId), StringComparison.InvariantCultureIgnoreCase))
{
senderEmail = form[formKey];
continue;
}
if (formKey.Equals(string.Format("giftcard_{0}.Message", productVariantId), StringComparison.InvariantCultureIgnoreCase))
{
giftCardMessage = form[formKey];
continue;
}
}
attributes = _productAttributeParser.AddGiftCardAttribute(attributes,
recipientName, recipientEmail, senderName, senderEmail, giftCardMessage);
}
#endregion
//save item
addToCartWarnings.AddRange(_shoppingCartService.AddToCart(_workContext.CurrentCustomer,
productVariant, cartType, _storeContext.CurrentStore.Id,
attributes, customerEnteredPriceConverted, quantity, true));
#region Set already entered values
//set already entered values (quantity, customer entered price, gift card attributes, product attributes
//we do it manually because views do not use HTML helpers for rendering controls
Action<ProductDetailsModel> setEnteredValues = (productModel) =>
{
//find product variant model
var productVariantModel = productModel.ProductVariantModels
.FirstOrDefault(x => x.Id == productVariant.Id);
if (productVariantModel == null)
return;
#region 'Add to cart' model
//entered quantity
productVariantModel.AddToCart.EnteredQuantity = quantity;
//allowed quantities
var allowedQuantities = productVariant.ParseAllowedQuatities();
if (allowedQuantities.Length > 0)
{
var allowedQuantitySelectedItem = productVariantModel.AddToCart.AllowedQuantities
.FirstOrDefault(x => x.Text == quantity.ToString());
if (allowedQuantitySelectedItem != null)
{
allowedQuantitySelectedItem.Selected = true;
}
}
//customer entered price
if (productVariantModel.AddToCart.CustomerEntersPrice)
{
productVariantModel.AddToCart.CustomerEnteredPrice = customerEnteredPrice;
}
#endregion
#region Gift card attributes
if (productVariant.IsGiftCard)
{
productVariantModel.GiftCard.RecipientName = recipientName;
productVariantModel.GiftCard.RecipientEmail = recipientEmail;
productVariantModel.GiftCard.SenderName = senderName;
productVariantModel.GiftCard.SenderEmail = senderEmail;
productVariantModel.GiftCard.Message = giftCardMessage;
}
#endregion
#region Product attributes
//clear pre-defined values)
foreach (var pvaModel in productVariantModel.ProductVariantAttributes)
{
foreach (var pvavModel in pvaModel.Values)
pvavModel.IsPreSelected = false;
}
//select the previously entered ones
foreach (var attribute in productVariantAttributes)
{
string controlId = string.Format("product_attribute_{0}_{1}_{2}", attribute.ProductVariantId, attribute.ProductAttributeId, attribute.Id);
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.ColorSquares:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
int selectedAttributeId = int.Parse(ctrlAttributes);
if (selectedAttributeId > 0)
{
var pvavModel = productVariantModel.ProductVariantAttributes
.SelectMany(x => x.Values)
.FirstOrDefault(y => y.Id == selectedAttributeId);
if (pvavModel != null)
pvavModel.IsPreSelected = true;
}
}
}
break;
case AttributeControlType.Checkboxes:
{
var ctrlAttributes = form[controlId];
if (!String.IsNullOrEmpty(ctrlAttributes))
{
foreach (var item in ctrlAttributes.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
int selectedAttributeId = int.Parse(item);
if (selectedAttributeId > 0)
{
var pvavModel = productVariantModel.ProductVariantAttributes
.SelectMany(x => x.Values)
.FirstOrDefault(y => y.Id == selectedAttributeId);
if (pvavModel != null)
pvavModel.IsPreSelected = true;
}
}
}
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
{
var txtAttribute = form[controlId];
if (!String.IsNullOrEmpty(txtAttribute))
{
var pvaModel = productVariantModel
.ProductVariantAttributes
.FirstOrDefault(y => y.Id == attribute.Id);
if (pvaModel != null)
pvaModel.TextValue = txtAttribute;
}
}
break;
case AttributeControlType.Datepicker:
{
var pvaModel = productVariantModel
.ProductVariantAttributes
.FirstOrDefault(y => y.Id == attribute.Id);
if (pvaModel != null)
{
int day, month, year;
if (int.TryParse(form[controlId + "_day"], out day))
pvaModel.SelectedDay = day;
if (int.TryParse(form[controlId + "_month"], out month))
pvaModel.SelectedMonth = month;
if (int.TryParse(form[controlId + "_year"], out year))
pvaModel.SelectedYear = year;
}
}
break;
default:
break;
}
}
#endregion
};
#endregion
#region Return the view
if (addToCartWarnings.Count == 0)
{
switch (cartType)
{
case ShoppingCartType.Wishlist:
{
if (_shoppingCartSettings.DisplayWishlistAfterAddingProduct)
{
//redirect to the wishlist page
return RedirectToRoute("Wishlist");
}
else
{
//redisplay the page with "Product has been added to the wishlist" notification message
var model = PrepareProductDetailsPageModel(product);
this.SuccessNotification(_localizationService.GetResource("Products.ProductHasBeenAddedToTheWishlist"), false);
//set already entered values (quantity, customer entered price, gift card attributes, product attributes)
setEnteredValues(model);
//activity log
_customerActivityService.InsertActivity("PublicStore.AddToWishlist", _localizationService.GetResource("ActivityLog.PublicStore.AddToWishlist"), productVariant.FullProductName);
return View(model.ProductTemplateViewPath, model);
}
}
case ShoppingCartType.ShoppingCart:
default:
{
if (_shoppingCartSettings.DisplayCartAfterAddingProduct)
{
//redirect to the shopping cart page
return RedirectToRoute("ShoppingCart");
}
else
{
//redisplay the page with "Product has been added to the cart" notification message
var model = PrepareProductDetailsPageModel(product);
this.SuccessNotification(_localizationService.GetResource("Products.ProductHasBeenAddedToTheCart"), false);
//set already entered values (quantity, customer entered price, gift card attributes, product attributes)
setEnteredValues(model);
//activity log
_customerActivityService.InsertActivity("PublicStore.AddToShoppingCart", _localizationService.GetResource("ActivityLog.PublicStore.AddToShoppingCart"), productVariant.FullProductName);
return View(model.ProductTemplateViewPath, model);
}
}
}
}
else
{
//Errors
foreach (string error in addToCartWarnings)
ModelState.AddModelError("", error);
//If we got this far, something failed, redisplay form
var model = PrepareProductDetailsPageModel(product);
//set already entered values (quantity, customer entered price, gift card attributes, product attributes
setEnteredValues(model);
return View(model.ProductTemplateViewPath, model);
}
#endregion
}
public ActionResult SaveDownloadUrl(string downloadUrl)
{
//insert
var download = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = true,
DownloadUrl = downloadUrl,
IsNew = true
};
_downloadService.InsertDownload(download);
return Json(new { downloadId = download.Id }, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// Create a copy of product variant with all depended data
/// </summary>
/// <param name="productVariant">The product variant to copy</param>
/// <param name="productId">The product identifier</param>
/// <param name="newName">The name of product variant duplicate</param>
/// <param name="isPublished">A value indicating whether the product variant duplicate should be published</param>
/// <param name="copyImage">A value indicating whether the product variant image should be copied</param>
/// <returns>Product variant copy</returns>
public virtual ProductVariant CopyProductVariant(ProductVariant productVariant, int productId,
string newName, bool isPublished, bool copyImage)
{
if (productVariant == null)
throw new ArgumentNullException("productVariant");
var languages = _languageService.GetAllLanguages(true);
// product variant picture
int pictureId = 0;
if (copyImage)
{
var picture = _pictureService.GetPictureById(productVariant.PictureId);
if (picture != null)
{
var pictureCopy = _pictureService.InsertPicture(
_pictureService.LoadPictureBinary(picture),
picture.MimeType,
_pictureService.GetPictureSeName(productVariant.Name),
true);
pictureId = pictureCopy.Id;
}
}
// product variant download & sample download
int downloadId = productVariant.DownloadId;
int sampleDownloadId = productVariant.SampleDownloadId;
if (productVariant.IsDownload)
{
var download = _downloadService.GetDownloadById(productVariant.DownloadId);
if (download != null)
{
var downloadCopy = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = download.UseDownloadUrl,
DownloadUrl = download.DownloadUrl,
DownloadBinary = download.DownloadBinary,
ContentType = download.ContentType,
Filename = download.Filename,
Extension = download.Extension,
IsNew = download.IsNew,
};
_downloadService.InsertDownload(downloadCopy);
downloadId = downloadCopy.Id;
}
if (productVariant.HasSampleDownload)
{
var sampleDownload = _downloadService.GetDownloadById(productVariant.SampleDownloadId);
if (sampleDownload != null)
{
var sampleDownloadCopy = new Download()
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = sampleDownload.UseDownloadUrl,
DownloadUrl = sampleDownload.DownloadUrl,
DownloadBinary = sampleDownload.DownloadBinary,
ContentType = sampleDownload.ContentType,
Filename = sampleDownload.Filename,
Extension = sampleDownload.Extension,
IsNew = sampleDownload.IsNew
};
_downloadService.InsertDownload(sampleDownloadCopy);
sampleDownloadId = sampleDownloadCopy.Id;
}
}
}
// product variant
var productVariantCopy = new ProductVariant()
{
ProductId = productId,
Name = newName,
Sku = productVariant.Sku,
Description = productVariant.Description,
AdminComment = productVariant.AdminComment,
ManufacturerPartNumber = productVariant.ManufacturerPartNumber,
Gtin = productVariant.Gtin,
IsGiftCard = productVariant.IsGiftCard,
GiftCardType = productVariant.GiftCardType,
RequireOtherProducts = productVariant.RequireOtherProducts,
RequiredProductVariantIds = productVariant.RequiredProductVariantIds,
AutomaticallyAddRequiredProductVariants = productVariant.AutomaticallyAddRequiredProductVariants,
IsDownload = productVariant.IsDownload,
DownloadId = downloadId,
UnlimitedDownloads = productVariant.UnlimitedDownloads,
MaxNumberOfDownloads = productVariant.MaxNumberOfDownloads,
DownloadExpirationDays = productVariant.DownloadExpirationDays,
DownloadActivationType = productVariant.DownloadActivationType,
HasSampleDownload = productVariant.HasSampleDownload,
SampleDownloadId = sampleDownloadId,
HasUserAgreement = productVariant.HasUserAgreement,
UserAgreementText = productVariant.UserAgreementText,
IsRecurring = productVariant.IsRecurring,
RecurringCycleLength = productVariant.RecurringCycleLength,
RecurringCyclePeriod = productVariant.RecurringCyclePeriod,
RecurringTotalCycles = productVariant.RecurringTotalCycles,
IsShipEnabled = productVariant.IsShipEnabled,
IsFreeShipping = productVariant.IsFreeShipping,
AdditionalShippingCharge = productVariant.AdditionalShippingCharge,
IsTaxExempt = productVariant.IsTaxExempt,
TaxCategoryId = productVariant.TaxCategoryId,
ManageInventoryMethod = productVariant.ManageInventoryMethod,
StockQuantity = productVariant.StockQuantity,
DisplayStockAvailability = productVariant.DisplayStockAvailability,
DisplayStockQuantity = productVariant.DisplayStockQuantity,
MinStockQuantity = productVariant.MinStockQuantity,
LowStockActivityId = productVariant.LowStockActivityId,
NotifyAdminForQuantityBelow = productVariant.NotifyAdminForQuantityBelow,
BackorderMode = productVariant.BackorderMode,
AllowBackInStockSubscriptions = productVariant.AllowBackInStockSubscriptions,
OrderMinimumQuantity = productVariant.OrderMinimumQuantity,
OrderMaximumQuantity = productVariant.OrderMaximumQuantity,
AllowedQuantities = productVariant.AllowedQuantities,
DisableBuyButton = productVariant.DisableBuyButton,
DisableWishlistButton = productVariant.DisableWishlistButton,
CallForPrice = productVariant.CallForPrice,
Price = productVariant.Price,
OldPrice = productVariant.OldPrice,
ProductCost = productVariant.ProductCost,
SpecialPrice = productVariant.SpecialPrice,
SpecialPriceStartDateTimeUtc = productVariant.SpecialPriceStartDateTimeUtc,
SpecialPriceEndDateTimeUtc = productVariant.SpecialPriceEndDateTimeUtc,
CustomerEntersPrice = productVariant.CustomerEntersPrice,
MinimumCustomerEnteredPrice = productVariant.MinimumCustomerEnteredPrice,
MaximumCustomerEnteredPrice = productVariant.MaximumCustomerEnteredPrice,
Weight = productVariant.Weight,
Length = productVariant.Length,
Width = productVariant.Width,
Height = productVariant.Height,
PictureId = pictureId,
AvailableStartDateTimeUtc = productVariant.AvailableStartDateTimeUtc,
AvailableEndDateTimeUtc = productVariant.AvailableEndDateTimeUtc,
Published = isPublished,
Deleted = productVariant.Deleted,
DisplayOrder = productVariant.DisplayOrder,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
_productService.InsertProductVariant(productVariantCopy);
//localization
foreach (var lang in languages)
{
var name = productVariant.GetLocalized(x => x.Name, lang.Id, false, false);
if (!String.IsNullOrEmpty(name))
_localizedEntityService.SaveLocalizedValue(productVariantCopy, x => x.Name, name, lang.Id);
var description = productVariant.GetLocalized(x => x.Description, lang.Id, false, false);
if (!String.IsNullOrEmpty(description))
_localizedEntityService.SaveLocalizedValue(productVariantCopy, x => x.Description, description, lang.Id);
}
// product variant <-> attributes mappings
var associatedAttributes = new Dictionary<int, int>();
var associatedAttributeValues = new Dictionary<int, int>();
foreach (var productVariantAttribute in _productAttributeService.GetProductVariantAttributesByProductVariantId(productVariant.Id))
{
var productVariantAttributeCopy = new ProductVariantAttribute()
{
ProductVariantId = productVariantCopy.Id,
ProductAttributeId = productVariantAttribute.ProductAttributeId,
TextPrompt = productVariantAttribute.TextPrompt,
IsRequired = productVariantAttribute.IsRequired,
AttributeControlTypeId = productVariantAttribute.AttributeControlTypeId,
DisplayOrder = productVariantAttribute.DisplayOrder
};
_productAttributeService.InsertProductVariantAttribute(productVariantAttributeCopy);
//save associated value (used for combinations copying)
associatedAttributes.Add(productVariantAttribute.Id, productVariantAttributeCopy.Id);
// product variant attribute values
var productVariantAttributeValues = _productAttributeService.GetProductVariantAttributeValues(productVariantAttribute.Id);
foreach (var productVariantAttributeValue in productVariantAttributeValues)
{
var pvavCopy = new ProductVariantAttributeValue()
{
ProductVariantAttributeId = productVariantAttributeCopy.Id,
Name = productVariantAttributeValue.Name,
ColorSquaresRgb = productVariantAttributeValue.ColorSquaresRgb,
PriceAdjustment = productVariantAttributeValue.PriceAdjustment,
WeightAdjustment = productVariantAttributeValue.WeightAdjustment,
IsPreSelected = productVariantAttributeValue.IsPreSelected,
DisplayOrder = productVariantAttributeValue.DisplayOrder
};
_productAttributeService.InsertProductVariantAttributeValue(pvavCopy);
//save associated value (used for combinations copying)
associatedAttributeValues.Add(productVariantAttributeValue.Id, pvavCopy.Id);
//localization
foreach (var lang in languages)
{
var name = productVariantAttributeValue.GetLocalized(x => x.Name, lang.Id, false, false);
if (!String.IsNullOrEmpty(name))
_localizedEntityService.SaveLocalizedValue(pvavCopy, x => x.Name, name, lang.Id);
}
}
}
foreach (var combination in _productAttributeService.GetAllProductVariantAttributeCombinations(productVariant.Id))
{
//generate new AttributesXml according to new value IDs
string newAttributesXml = "";
var parsedProductVariantAttributes = _productAttributeParser.ParseProductVariantAttributes(combination.AttributesXml);
foreach (var oldPva in parsedProductVariantAttributes)
{
if (associatedAttributes.ContainsKey(oldPva.Id))
{
int newPvaId = associatedAttributes[oldPva.Id];
var newPva = _productAttributeService.GetProductVariantAttributeById(newPvaId);
if (newPva != null)
{
var oldPvaValuesStr = _productAttributeParser.ParseValues(combination.AttributesXml, oldPva.Id);
foreach (var oldPvaValueStr in oldPvaValuesStr)
{
if (newPva.ShouldHaveValues())
{
//attribute values
int oldPvaValue = int.Parse(oldPvaValueStr);
if (associatedAttributeValues.ContainsKey(oldPvaValue))
{
int newPvavId = associatedAttributeValues[oldPvaValue];
var newPvav = _productAttributeService.GetProductVariantAttributeValueById(newPvavId);
if (newPvav != null)
{
newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
newPva, newPvav.Id.ToString());
}
}
}
else
{
//just a text
newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
newPva, oldPvaValueStr);
}
}
}
}
}
var combinationCopy = new ProductVariantAttributeCombination()
{
ProductVariantId = productVariantCopy.Id,
AttributesXml = newAttributesXml,
StockQuantity = combination.StockQuantity,
AllowOutOfStockOrders = combination.AllowOutOfStockOrders,
Sku = combination.Sku,
ManufacturerPartNumber = combination.ManufacturerPartNumber,
Gtin = combination.Gtin
};
_productAttributeService.InsertProductVariantAttributeCombination(combinationCopy);
}
// product variant tier prices
foreach (var tierPrice in productVariant.TierPrices)
{
_productService.InsertTierPrice(
new TierPrice()
{
ProductVariantId = productVariantCopy.Id,
CustomerRoleId = tierPrice.CustomerRoleId,
Quantity = tierPrice.Quantity,
Price = tierPrice.Price
});
}
// product variant <-> discounts mapping
foreach (var discount in productVariant.AppliedDiscounts)
{
productVariantCopy.AppliedDiscounts.Add(discount);
_productService.UpdateProductVariant(productVariantCopy);
}
//update "HasTierPrices" and "HasDiscountsApplied" properties
_productService.UpdateHasTierPricesProperty(productVariantCopy);
_productService.UpdateHasDiscountsApplied(productVariantCopy);
return productVariantCopy;
}
