public ProductModel(Product product)
: this()
{
Id = product.Id;
Name = product.Name;
IsPublished = product.IsPublished;
ProductTypeId = product.ProductType.Id;
}
public ProductRowModel(Product product)
: this()
{
this.Id = product.Id;
this.Name = product.Name;
this.IsPublished = product.IsPublished;
this.ProductTypeId = product.ProductTypeId;
}
public bool Publish(Product product)
{
if (product.IsPublished)
{
return false;
}
product.IsPublished = true;
_database.SaveChanges();
Event.Raise(new ProductPublished(product), _instance);
return true;
}
public ShoppingCartItem AddItem(ShoppingCart cart, Product product, ProductPrice productPrice, int quantity)
{
Require.NotNull(cart, "cart");
Require.NotNull(product, "product");
Require.NotNull(productPrice, "productPrice");
Require.That(quantity > 0, "quantity", "Quantity should be greater than zero.");
var item = cart.Items.FirstOrDefault(i => i.ProductPrice.Id == productPrice.Id);
if (item == null)
{
item = new ShoppingCartItem(productPrice, quantity, cart);
AddItem(cart, item);
}
else
{
ChangeItemQuantity(cart, item, item.Quantity + quantity);
}
return item;
}
private void UpdateProduct(Product product, ProductEditorModel model)
{
product.Name = model.Name;
product.Brand = model.Brand == null ? null : _brandService.Find(model.Brand.Id);
product.Categories.Clear();
foreach (var category in model.Categories)
{
product.Categories.Add(_categoryService.Find(category.Id));
}
product.SetCustomFields(model.CustomFields);
product.SetImages(model.Images);
foreach (var variant in product.Variants.ToList())
{
if (!model.Variants.Any(v => v.Id == variant.Id))
{
product.Variants.Remove(variant);
}
}
foreach (var variantModel in model.Variants)
{
ProductVariant variant;
if (variantModel.Id > 0)
{
variant = product.Variants.FirstOrDefault(v => v.Id == variantModel.Id);
}
else
{
variant = new ProductVariant();
product.Variants.Add(variant);
}
variant.Sku = variantModel.Sku;
variant.Price = variantModel.Price;
variant.SetVariantFields(variantModel.VariantFields);
}
}
public void Delete(Product model)
{
var product = _database.Repository<Product>().Find(model.Id);
_database.Repository<Product>().Delete(product);
Event.Raise(new ProductDeleted(product), _instance);
}
public void Create(Product product)
{
SyncPriceRange(product);
_database.Repository<Product>().Insert(product);
Event.Raise(new ProductCreated(product), _instance);
}
private void SyncPriceRange(Product product)
{
if (product.Variants.Count == 0)
{
product.LowestPrice = product.HighestPrice = 0;
}
else
{
product.LowestPrice = product.Variants.Min(v => v.Price);
product.HighestPrice = product.Variants.Max(v => v.Price);
}
}
public ProductCustomFieldValue(Product product, int fieldId, string value)
{
Product = product;
CustomFieldId = fieldId;
FieldValue = value;
}
public ActionResult Save(Product obj)
{
try
{
Product product = null;
if (obj.Id > 0)
{
product = _productService.GetById(obj.Id);
}
else
{
product = new Product(obj.Name, _productTypeService.GetById(obj.ProductTypeId));
}
// Update basic info
product.Name = obj.Name;
if (obj.BrandId != null)
{
product.Brand = _brandService.GetById(obj.BrandId.Value);
}
else
{
product.Brand = null;
}
product.UpdateCustomFieldValues(obj.CustomFieldValues);
product.UpdateImages(obj.Images);
product.UpdateCategories(obj.Categories);
if (product.Id == 0)
{
_productService.Create(product);
}
else
{
_db.SaveChanges();
product.NotifyUpdated();
}
// Update product prices
foreach (var price in product.PriceList.ToList())
{
if (!obj.PriceList.Any(p => p.Id == price.Id))
{
_productService.RemovePrice(product, price.Id);
}
}
foreach (var priceModel in obj.PriceList)
{
var price = product.FindPrice(priceModel.Id);
if (price == null)
{
price = product.CreatePrice(priceModel.Name, priceModel.Sku);
price.UpdateFrom(priceModel);
_productService.AddPrice(product, price);
}
else
{
price.UpdateFrom(priceModel);
_db.SaveChanges();
price.NotifyUpdated();
}
if (priceModel.IsPublished)
{
_productService.PublishPrice(product, price.Id);
}
else
{
_productService.UnpublishPrice(product, price.Id);
}
}
if (obj.IsPublished)
{
_productService.Publish(product);
}
else
{
_productService.Unpublish(product);
}
return this.JsonNet(new { status = 0, message = "product succssfully saved." });
}
catch (Exception ex)
{
return this.JsonNet(new { status = 1, message = ex.Message });
}
}
public ProductUnpublished(Product product)
{
ProductId = product.Id;
}
private void PrepareProductEditing(ProductType productType, Product product)
{
if (product != null)
{
ViewBag.Product = product;
ViewBag.ToolbarCommands = TopbarCommands.GetCommands(ControllerContext, product, CurrentInstance);
}
ViewBag.ProductType = productType;
ViewBag.DefaultVariantModel = CreateDefaultVariantModel(productType);
ViewBag.ImageTypes = _settingService.Get<GlobalSettings>().Image.Types;
var settings = _settingService.Get<GlobalSettings>();
if (settings != null && !String.IsNullOrEmpty(settings.Currency))
{
ViewBag.CurrencySymbol = CurrencyInfo.GetCurrencyInfoByISOSymbol(settings.Currency).Symbol;
}
this.LoadTabPlugins();
}
public ProductVariant(Product product)
: this()
{
Product = product;
}
private Product DoSave(ProductEditorModel model)
{
Product product = null;
if (model.Id == 0)
{
product = new Product
{
ProductType = _productTypeService.Find(model.ProductTypeId)
};
UpdateProduct(product, model);
_productService.Create(product);
}
else
{
product = _productService.Find(model.Id);
UpdateProduct(product, model);
_productService.Update(product);
}
if (model.IsPublished)
{
_productService.Publish(product);
}
else
{
_productService.Unpublish(product);
}
return product;
}
public ActionResult Get(int? id = null, int? productTypeId = null)
{
Product product = null;
if (id.HasValue)
{
product = _productService.Find(id.Value);
}
if (product == null)
{
product = new Product
{
ProductType = _productTypeService.Find(productTypeId.Value)
};
}
var model = Mapper.Map<Product, ProductEditorModel>(product);
return JsonNet(model).UsingClientConvention();
}
public ProductDeleted(Product product)
{
ProductId = product.Id;
ProductName = product.Name;
}
public ProductCreated(Product product)
{
ProductId = product.Id;
}
public ProductEditorModel(Product product)
: this()
{
}
public override bool CanExecute(Kooboo.Commerce.Products.Product product, CommerceInstance instance)
{
return(!product.IsPublished);
}
public ProductPriceDeleted(Product product, ProductPrice price)
{
ProductId = product.Id;
ProductPriceId = price.Id;
}
public abstract bool CanExecute(Product product, CommerceInstance instance);
public static ProductModel Create(Product product, CultureInfo culture, CategoryTree categoryCache)
{
var doc = new ProductModel
{
Id = product.Id,
Name = product.GetText("Name", culture) ?? product.Name
};
// Brand
if (product.Brand != null)
{
doc.Brand = product.Brand.GetText("Name", culture) ?? product.Brand.Name;
doc.BrandId = product.Brand.Id;
}
// Categories
var categoryNames = new HashSet<string>();
var categoryIds = new HashSet<int>();
foreach (var category in product.Categories)
{
foreach (var each in categoryCache.Find(category.Id).PathFromRoot())
{
var name = Localizer.GetText(new EntityKey(typeof(Category), each.Id), "Name", culture);
if (String.IsNullOrEmpty(name))
{
name = each.Name;
}
categoryNames.Add(name);
categoryIds.Add(each.Id);
}
}
doc.Categories = categoryNames.ToList();
doc.CategoryIds = categoryIds.ToList();
// Prices
foreach (var variant in product.Variants)
{
doc.Prices.Add(variant.Price);
}
doc.LowestPrice = product.LowestPrice;
doc.HighestPrice = product.HighestPrice;
// Variant fields
var controls = FormControls.Controls().ToList();
foreach (var variant in product.Variants)
{
foreach (var fieldDef in product.ProductType.VariantFieldDefinitions)
{
var variantField = variant.VariantFields.FirstOrDefault(f => f.FieldName == fieldDef.Name);
if (variantField != null)
{
string fieldValue = null;
var control = controls.Find(c => c.Name == fieldDef.ControlType);
if (control.IsSelectionList)
{
var item = fieldDef.SelectionItems.FirstOrDefault(i => i.Value == variantField.FieldValue);
if (item != null)
{
fieldValue = product.ProductType.GetText("VariantFieldDefinitions[" + fieldDef.Name + "].SelectionItems[" + item.Value + "]", culture) ?? item.Text;
}
}
else if (control.IsValuesPredefined)
{
fieldValue = product.ProductType.GetText("VariantFieldDefinitions[" + fieldDef.Name + "].DefaultValue", culture) ?? fieldDef.DefaultValue;
}
else
{
fieldValue = variant.GetText("VariantFields[" + fieldDef.Name + "]", culture) ?? variantField.FieldValue;
}
if (!String.IsNullOrEmpty(fieldValue))
{
if (doc.VariantFieldValues.ContainsKey(fieldDef.Name))
{
doc.VariantFieldValues[fieldDef.Name].Add(fieldValue);
}
else
{
doc.VariantFieldValues.Add(fieldDef.Name, new HashSet<string> { fieldValue });
}
}
}
}
}
// Search text
var searchText = new StringBuilder();
searchText.Append(doc.Name);
searchText.Append(" ").Append(doc.Brand);
searchText.Append(" ").Append(String.Join(" ", doc.Categories));
foreach (var each in doc.VariantFieldValues)
{
searchText.Append(" ").Append(String.Join(" ", each.Value));
}
doc.SearchText = searchText.ToString();
return doc;
}
public ProductUpdated(Product product)
{
ProductId = product.Id;
}
public ActionResult Get(int? id = null, int? productTypeId = null)
{
Product product = null;
if (id.HasValue)
{
product = _productService.GetById(id.Value);
}
if (product == null)
{
product = new Product();
product.ProductTypeId = productTypeId.Value;
product.Name = "New Product";
}
return JsonNet(product);
}