public ActionResult AddProductOptionValue(int id)
{
ProductOptionValue pov = new ProductOptionValue();
pov.ProductOptionId = id;
var optionValues = unitOfWork.optionRepository.Get(unitOfWork.productRepository.GetProductOption(id).OptionId).Values;
ViewBag.OptionValues = new SelectList(optionValues, "OptionValueId", "Name");
return(View(pov));
}
public ActionResult DeleteProductOptionValue(int id)
{
ProductOptionValue productOptionValue = unitOfWork.productRepository.GetProductOptionValue(id);
if (productOptionValue == null)
{
return(View("NotFound"));
}
unitOfWork.productRepository.DeleteProductOptionValue(productOptionValue);
unitOfWork.Save();
return(RedirectToAction("EditProductOption", new { id = productOptionValue.ProductOptionId }));
}
private ProductOptionValue CreateValue(ProductVariant product, ProductOption option, string value)
{
var specValue = new ProductOptionValue
{
ProductVariant = product,
ProductOption = option,
Value = value
};
Session.Transact(session => session.Save(specValue));
return(specValue);
}
public ActionResult AddProductOptionValue(int id, FormCollection formValues)
{
ProductOptionValue pov = new ProductOptionValue();
if (TryUpdateModel(pov))
{
unitOfWork.productRepository.GetProductOption(id).Values.Add(pov);
unitOfWork.Save();
return(RedirectToAction("EditProductOption", new { id = pov.ProductOptionId }));
}
var optionValues = unitOfWork.optionRepository.Get(id).Values;
ViewBag.OptionValues = new SelectList(optionValues, "OptionValueId", "Name");
return(View(pov));
}
private static ProductVariant CreateCartesianProductVariant(NopImportContext nopImportContext, ProductVariantData variantData, Product product, IEnumerable <ProductOptionValueData> cartesianProduct, int index)
{
var variant = new ProductVariant
{
Name = variantData.Name,
SKU = variantData.SKU + "-" + (index + 1),
Weight = variantData.Weight,
TrackingPolicy = variantData.TrackingPolicy,
StockRemaining = variantData.StockRemaining,
RequiresShipping = variantData.RequiresShipping,
AllowedNumberOfDaysForDownload = variantData.DownloadDays,
AllowedNumberOfDownloads = variantData.MaxDownloads,
IsDownloadable = variantData.Download,
BasePrice = variantData.BasePrice,
DownloadFileUrl = variantData.DownloadUrl,
GiftCardType = variantData.GiftCardType,
IsGiftCard = variantData.GiftCard,
Product = product,
PreviousPrice = variantData.PreviousPrice,
ManufacturerPartNumber = variantData.PartNumber,
TaxRate = nopImportContext.FindNew <TaxRate>(variantData.TaxRate)
};
foreach (ProductOptionValueData valueData in cartesianProduct)
{
variant.Weight += valueData.WeightAdjustment;
variant.BasePrice += valueData.PriceAdjustment;
var productOptionValue = new ProductOptionValue
{
ProductVariant = variant,
Value = valueData.Value,
ProductOption = nopImportContext.FindNew <ProductOption>(valueData.OptionId)
};
variant.OptionValues.Add(productOptionValue);
if (!product.Options.Contains(productOptionValue.ProductOption))
{
product.Options.Add(productOptionValue.ProductOption);
}
nopImportContext.AddEntry(valueData.Id, productOptionValue);
}
product.Variants.Add(variant);
nopImportContext.AddEntry(variantData.Id, variant);
return(variant);
}
public void SetAttributeValue(ProductVariant productVariant, string attributeName, string value)
{
ProductOption specificationOption =
_session.QueryOver <ProductOption>()
.Where(option => option.Name == attributeName)
.Take(1)
.SingleOrDefault();
if (specificationOption == null)
{
return;
}
IList <ProductOptionValue> values =
_session.QueryOver <ProductOptionValue>()
.Where(
specificationValue => specificationValue.ProductOption == specificationOption &&
specificationValue.ProductVariant == productVariant)
.Cacheable()
.List();
if (values.Any())
{
ProductOptionValue specificationValue = values.First();
specificationValue.Value = value;
_session.Transact(session => session.Update(specificationValue));
}
else
{
_session.Transact(session => session.Save(new ProductOptionValue
{
ProductVariant = productVariant,
ProductOption = specificationOption,
Value = value
}));
}
}
void SyncLocalOptions()
{
_connection.Open();
//Load Options(Values)
var command = _connection.CreateCommand();
command.LoadScript("SelectOptions_Included_OptionValue");
var dataReader = command.ExecuteReader();
while (dataReader.Read())
{
var optionId = (int)dataReader["option_id"];
var option = _dbContext.Options.FirstOrDefault(o => o.option_id == optionId);
var isOptionExist = option != null;
if (!isOptionExist)
{
option = new Option();
option.option_id = optionId;
option.type = (string)dataReader["option_type"];
option.name = (string)dataReader["option_name"];
option.sort_order = (int)dataReader["option_sort_order"];
}
if (dataReader["option_value_id"] != DBNull.Value)
{
var optionValue = _dbContext.OptionValues.FirstOrDefault(ov => ov.option_value_id == (int)dataReader["option_value_id"]);
if (optionValue != null)
{
optionValue.name = (string)dataReader["option_value_name"];
optionValue.sort_order = (int)dataReader["option_value_sort_order"];
_dbContext.OptionValues.Update(optionValue);
}
else
{
optionValue = new OptionValue
{
option_value_id = (int)dataReader["option_value_id"],
option_id = optionId,
name = (string)dataReader["option_value_name"],
sort_order = (int)dataReader["option_value_sort_order"]
};
_dbContext.OptionValues.Add(optionValue);
}
}
if (isOptionExist)
{
_dbContext.Options.Update(option);
}
else
{
_dbContext.Options.Add(option);
}
_dbContext.SaveChanges();
}
//Load ProductOptions(Values)
_connection.Close();
_connection.Open();
command = _connection.CreateCommand();
command.LoadScript("SelectProductOptions_Included_ProductOptionValue");
dataReader = command.ExecuteReader();
while (dataReader.Read())
{
var productOptionId = (int)dataReader["product_option_id"];
var productOption = _dbContext.ProductOptions.FirstOrDefault(o => o.product_option_id == productOptionId);
var isProductOptionExsist = productOption != null;
if (!isProductOptionExsist)
{
productOption = new ProductOption
{
product_option_id = (int)dataReader["product_option_id"],
option_id = (int)dataReader["product_option_option_id"],
product_id = (int)dataReader["product_option_product_id"],
is_required = (bool)dataReader["product_option_required"],
value = (string)dataReader["product_option_value"]
};
}
else
{
productOption.is_required = (bool)dataReader["product_option_required"];
productOption.value = (string)dataReader["product_option_value"];
}
if (dataReader["product_option_value_id"] != DBNull.Value)
{
var productOptionValue = _dbContext.ProductOptionValues.FirstOrDefault(po => po.product_option_value_id == (int)dataReader["product_option_value_id"]);
if (productOptionValue != null && !productOptionValue.IsChanged)
{
productOptionValue.option_value_id = (int)dataReader["option_value_id"];
productOptionValue.product_option_id = productOptionId;
productOptionValue.quantity = (int)dataReader["product_option_value_quantity"];
productOptionValue.subtract = (bool)dataReader["product_option_value_subtract"];
productOptionValue.point = int.Parse((string)dataReader["product_option_value_points"]);
productOptionValue.price = decimal.Parse((string)dataReader["product_option_value_price"], CultureInfo.InvariantCulture);
productOptionValue.weight = decimal.Parse((string)dataReader["product_option_value_weight"], CultureInfo.InvariantCulture);
_dbContext.ProductOptionValues.Update(productOptionValue);
}
else
{
productOptionValue = new ProductOptionValue()
{
product_option_value_id = (int)dataReader["product_option_value_id"],
option_value_id = (int)dataReader["option_value_id"],
product_option_id = productOptionId,
quantity = (int)dataReader["product_option_value_quantity"],
subtract = (bool)dataReader["product_option_value_subtract"],
point = int.Parse((string)dataReader["product_option_value_points"]),
price = decimal.Parse((string)dataReader["product_option_value_price"], CultureInfo.InvariantCulture),
weight = decimal.Parse((string)dataReader["product_option_value_weight"], CultureInfo.InvariantCulture)
};
_dbContext.ProductOptionValues.Add(productOptionValue);
}
}
if (isProductOptionExsist)
{
_dbContext.ProductOptions.Update(productOption);
}
else
{
_dbContext.ProductOptions.Add(productOption);
}
_dbContext.SaveChanges();
}
_connection.Close();
command.Dispose();
dataReader.Dispose();
}
//extended method
public void DeleteProductOptionValue(ProductOptionValue productOptionValue)
{
context.ProductOptionValues.Remove(productOptionValue);
}
public IEnumerable <ProductVariant> ImportVariants(ProductImportDataTransferObject dataTransferObject,
Product product)
{
foreach (ProductVariantImportDataTransferObject item in dataTransferObject.ProductVariants)
{
ProductVariant productVariant =
_session.QueryOver <ProductVariant>()
.Where(variant => variant.SKU.IsInsensitiveLike(item.SKU, MatchMode.Exact))
.Take(1)
.SingleOrDefault();
if (productVariant == null)
{
productVariant = new ProductVariant();
_session.Transact(session => session.Save(productVariant));
}
if (!product.Variants.Contains(productVariant))
{
product.Variants.Add(productVariant);
}
productVariant.Name = item.Name;
productVariant.SKU = item.SKU;
productVariant.Barcode = item.Barcode;
productVariant.ManufacturerPartNumber = item.ManufacturerPartNumber;
productVariant.BasePrice = item.Price;
productVariant.PreviousPrice = item.PreviousPrice;
productVariant.StockRemaining = item.Stock.HasValue ? item.Stock.Value : 0;
productVariant.Weight = item.Weight.HasValue ? item.Weight.Value : 0;
productVariant.TrackingPolicy = item.TrackingPolicy;
productVariant.TaxRate = (item.TaxRate.HasValue && item.TaxRate.Value != 0)
? _taxRateManager.Get(item.TaxRate.Value)
: _taxRateManager.GetDefaultRate();
productVariant.Product = product;
if (!string.IsNullOrEmpty(item.ETag))
{
var eTag = _eTagAdminService.GetETagByName(item.ETag);
if (eTag == null)
{
eTag = new ETag
{
Name = item.ETag
};
_eTagAdminService.Add(eTag);
}
productVariant.ETag = eTag;
}
else
{
productVariant.ETag = null;
}
List <KeyValuePair <string, string> > optionsToAdd =
item.Options.Where(
s =>
!productVariant.OptionValues.Select(value => value.ProductOption.Name)
.Contains(s.Key, StringComparer.OrdinalIgnoreCase)).ToList();
List <ProductOptionValue> optionsToRemove =
productVariant.OptionValues.Where(
value => !item.Options.Keys.Contains(value.ProductOption.Name, StringComparer.OrdinalIgnoreCase))
.ToList();
List <ProductOptionValue> optionsToUpdate =
productVariant.OptionValues.Where(value => !optionsToRemove.Contains(value)).ToList();
foreach (var option in optionsToAdd)
{
ProductOption productOption = product.Options.FirstOrDefault(po => po.Name == option.Key);
if (productOption != null)
{
var productOptionValue = new ProductOptionValue
{
ProductOption = productOption,
ProductVariant = productVariant,
Value = option.Value
};
productVariant.OptionValues.Add(productOptionValue);
productOption.Values.Add(productOptionValue);
}
}
foreach (ProductOptionValue value in optionsToRemove)
{
ProductOption productOption = value.ProductOption;
productVariant.OptionValues.Remove(value);
productOption.Values.Remove(value);
ProductOptionValue closureValue = value;
_session.Transact(session => session.Delete(closureValue));
}
foreach (ProductOptionValue value in optionsToUpdate)
{
string key =
item.Options.Keys.FirstOrDefault(
s => s.Equals(value.ProductOption.Name, StringComparison.OrdinalIgnoreCase));
if (key != null)
{
value.Value = item.Options[key];
}
}
//Price Breaks
_importProductVariantPriceBreaksService.ImportVariantPriceBreaks(item, productVariant);
_session.SaveOrUpdate(productVariant);
}
List <ProductVariant> variantsToRemove =
product.Variants.Where(
variant => !dataTransferObject.ProductVariants.Select(o => o.SKU).Contains(variant.SKU)).ToList();
foreach (ProductVariant variant in variantsToRemove)
{
product.Variants.Remove(variant);
ProductVariant closureVariant = variant;
_session.Transact(session => session.Delete(closureVariant));
}
return(dataTransferObject.ProductVariants.Any() ? product.Variants : null);
}
public void DeleteProductAttributeValue(ProductOptionValue value)
{
_session.Transact(session => session.Delete(value));
}
public void SetPrice(OrderLine orderLine)
{
try
{
if (orderLine == null)
{
return;
}
Product prod = Products.FirstOrDefault(p => p.Id == orderLine.ProductId);
Catalog catalog = Catalogs.FirstOrDefault(c => c.Id == prod.CatalogId);
if (prod == null || catalog == null)
{
return;
}
if (string.IsNullOrWhiteSpace(orderLine.Description))
{
orderLine.Description = prod.Name;
}
// if the orderline has a custom price, then we will NOT re-evaluate it
if (!orderLine.IsCustomPrice)
{
decimal price = 0;
// price component 1: sales price defined on product
price = prod.SalesPrice;
// price component 2: prices of all the selected option values
if (orderLine.OrderLineOptions != null && orderLine.OrderLineOptions.Count > 0)
{
foreach (OrderLineOption olo in orderLine.OrderLineOptions.Where(olo => !string.IsNullOrWhiteSpace(olo.ProductOptionValueId)))
{
ProductOptionValue productOptionValue = cache.GetProductOptionValue(olo.ProductOptionValueId);
if (productOptionValue != null)
{
price += productOptionValue.Price;
}
}
}
// price component 3: if there is a formula defined, add the result to the price
if (!string.IsNullOrWhiteSpace(prod.SalesPriceFormulaInternal))
{
CalculationSvc calcSvc = new CalculationSvc();
decimal formulaPrice = calcSvc.Calculate(prod.SalesPriceFormulaInternal, orderLine);
price += formulaPrice;
}
orderLine.UnitPrice = price;
}
orderLine.TotalPrice = Math.Round(orderLine.UnitPrice * orderLine.Quantity, 2);
string taxClassId = null;
if (prod.SalesTaxClassId != null)
{
taxClassId = prod.SalesTaxClassId;
}
else
{
taxClassId = catalog.DefaultSalesTaxClassId;
}
orderLine.TaxPctg = 0;
if (taxClassId != null)
{
SysObject taxClass = TaxClasses.FirstOrDefault(so => so.Id == taxClassId);
if (taxClass != null && taxClass.Value.HasValue)
{
orderLine.TaxPctg = taxClass.Value.Value;
}
}
orderLine.Tax = Math.Round(orderLine.CalculateTotalTax(), 2);
}
catch (Exception ex)
{
_Logger.Error(ex.ToString());
throw;
}
}
private ParseOrderLineResult ParseOrderLine(Organisation org, List <string> catalogIds, string orderLinesAsString)
{
var olElements = orderLinesAsString.Split(new string[] { " x " }, StringSplitOptions.None).ToList();
if (olElements.Count != 2)
{
return(new ParseOrderLineResult(ParseOrderLineResultState.ParseError));
}
string quantityString = olElements[0].Trim();
decimal quantity = 1;
if (!decimal.TryParse(quantityString, out quantity))
{
return(new ParseOrderLineResult(ParseOrderLineResultState.ParseError));
}
string productName = olElements[1].Trim();
bool productHasOptions = false;
string[] productOptionElements = null;
if (productName.Contains('?'))
{
var productNameElements = productName.Split('?').ToList();
productName = productNameElements[0].Trim();
productHasOptions = true;
productOptionElements = productNameElements[1].Split('&');
}
Product product = _Ctx.Product.FirstOrDefault(p => p.Name == productName && catalogIds.Contains(p.CatalogId));
if (product == null)
{
string msg = string.Format("Product '{0}' not found for line: {1}", productName, orderLinesAsString);
return(new ParseOrderLineResult(ParseOrderLineResultState.ProductNotFound, msg));
}
_Ctx.Entry(product).State = System.Data.Entity.EntityState.Detached;
OrderLine orderLine = new OrderLine()
{
Quantity = quantity,
ProductId = product.Id,
Product = product,
PlanningOrder = product.PlanningOrder
};
if (productHasOptions)
{
orderLine.OrderLineOptions = new List <OrderLineOption>();
for (int i = 0; i < productOptionElements.Length; i++)
{
string optionString = productOptionElements[i].Trim();
var optionElements = optionString.Split('=');
string optionCode = optionElements[0].Trim();
string optionValue = optionElements[1].Trim();
if (optionCode.ToLower() == "persons")
{
orderLine.Persons = optionValue;
continue;
}
ProductOption option = _Ctx.ProductOption.FirstOrDefault(po => po.Code == optionCode && po.OrganisationId == org.Id);
if (option == null)
{
string msg = string.Format("Product option '{0}' not found for line: {1}", optionCode, orderLinesAsString);
return(new ParseOrderLineResult(ParseOrderLineResultState.ProductOptionNotFound, msg));
}
/*
* OrderLineOption olOption = new OrderLineOption()
* {
* ProductOptionId = option.Id
* };*/
OrderLineOption olOption = OrderLineOption.CreateNew();
olOption.ProductOptionId = option.Id;
if (option.HasValueObjects)
{
ProductOptionValue value = _Ctx.ProductOptionValue.FirstOrDefault(v => v.ProductOptionId == option.Id && v.Code == optionValue);
if (value != null)
{
olOption.ProductOptionValueId = value.Id;
}
else
{
throw new ApplicationException(string.Format("Product option value not found: {0}!", optionValue));
}
}
else
{
decimal optionNumValue = 0;
if (!decimal.TryParse(optionValue, out optionNumValue))
{
string msg = string.Format("Could not parse value '{0}' for option '{1}' for line: {2}", optionValue, optionCode, orderLinesAsString);
return(new ParseOrderLineResult(ParseOrderLineResultState.InvalidProductOptionValue));
}
olOption.ProductOptionValue = optionNumValue;
}
orderLine.OrderLineOptions.Add(olOption);
}
}
return(new ParseOrderLineResult(orderLine));
}
