public ActionResult _AddOrUpdate(int _id=0)
{
var data = ProductAttribute.GetByID(_id);
if (data == null)
data = new ProductAttribute();
data.ListAttributeExt = ProductAttribute.GetListAttribute(int.Parse(data.AttributeID.ToString()));
return PartialView(data);
}
protected void SaveButton_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
try
{
ProductAttribute productAttribute = ctrlProductAttributeInfo.SaveInfo();
Response.Redirect("ProductAttributeDetails.aspx?ProductAttributeID=" + productAttribute.ProductAttributeID.ToString());
}
catch (Exception exc)
{
ProcessException(exc);
}
}
}
public void UpdateLocales(ProductAttribute productAttribute, ProductAttributeModel model)
{
foreach (var localized in model.Locales)
{
_localizedEntityService.SaveLocalizedValue(productAttribute,
x => x.Name,
localized.Name,
localized.LanguageId);
_localizedEntityService.SaveLocalizedValue(productAttribute,
x => x.Description,
localized.Description,
localized.LanguageId);
}
}
public virtual void UpdateProductAttribute(ProductAttribute productAttribute)
{
if (productAttribute == null)
{
throw new ArgumentNullException("productAttribute");
}
_productAttributeRepository.Update(productAttribute);
_requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
_requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
//event notification
_eventPublisher.EntityUpdated(productAttribute);
}
/// <returns>A task that represents the asynchronous operation</returns>
protected virtual async Task UpdateLocalesAsync(ProductAttribute productAttribute, ProductAttributeModel model)
{
foreach (var localized in model.Locales)
{
await _localizedEntityService.SaveLocalizedValueAsync(productAttribute,
x => x.Name,
localized.Name,
localized.LanguageId);
await _localizedEntityService.SaveLocalizedValueAsync(productAttribute,
x => x.Description,
localized.Description,
localized.LanguageId);
}
}
private void RemoveAttributes(Product product, string removedAttributeIds)
{
if (string.IsNullOrEmpty(removedAttributeIds))
{
return;
}
foreach (string removedAttributeId in removedAttributeIds.Split(','))
{
ProductAttribute productAttribute = this.Storage.GetRepository <IProductAttributeRepository>().WithKey(product.Id, int.Parse(removedAttributeId));
this.Storage.GetRepository <IProductAttributeRepository>().Delete(productAttribute);
}
this.Storage.Save();
}
public IActionResult AddProductAttribute([FromBody] ProductAttribute request)
{
var response = new OperationResponse <bool>();
try
{
response.Data = _productService.AddProductAttribute(request);
}
catch (Exception exception)
{
response.State = ResponseState.Error;
response.Messages.Add(exception.Message);
_logger.LogError(exception, "Error in AddProductAttribute ==>" + exception.StackTrace, request);
}
return(new JsonResult(response));
}
/// <summary>
/// Inserts a product attribute
/// </summary>
/// <param name="productAttribute">Product attribute</param>
public virtual void InsertProductAttribute(ProductAttribute productAttribute)
{
if (productAttribute == null)
{
throw new ArgumentNullException("productAttribute");
}
_productAttributeRepository.Insert(productAttribute);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
//event notification
_eventPublisher.EntityInserted(productAttribute);
}
public static ProductAttributeChange CreateWithLog(
this ProductAttribute attribute,
Guid userId,
Action <ProductAttribute> action)
{
action(attribute);
return(new ProductAttributeChange
{
AttributeId = attribute.Id,
ChangerUserId = userId,
CreateDateTime = DateTime.UtcNow,
OldValueJson = string.Empty,
NewValueJson = attribute.ToJsonString()
});
}
private void CreateAttributes(Product product)
{
foreach (string key in this.Request.Form.Keys)
{
if (key.StartsWith("newAttribute"))
{
ProductAttribute productAttribute = new ProductAttribute();
productAttribute.ProductId = product.Id;
productAttribute.AttributeId = int.Parse(key.Replace("newAttribute", string.Empty));
this.Storage.GetRepository <IProductAttributeRepository>().Create(productAttribute);
}
}
this.Storage.Save();
}
public void PrepareShoppingCartModel(ShoppingCartModel model,
IList <ShoppingCartItem> cart, bool isEditable = true)
{
if (cart == null)
{
throw new ArgumentNullException("cart");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
if (cart.Count == 0)
{
return;
}
#region 属性
model.IsEditable = isEditable;
model.OrderFreeShip = _settingService.GetSettingByKey <decimal>(OrderSettingNames.OrderFreeShip);
#endregion
#region Cart items
foreach (var sci in cart)
{
var product = _productService.GetProductById(sci.ProductId);
ProductAttribute attribute = null;
var cartItemModel = new ShoppingCartModel.ShoppingCartItemModel
{
Id = sci.Id,
ProductId = product.Id,
ProductName = product.Name,
Picture = product.ProductImage,
Quantity = sci.Quantity,
SubTotal = sci.Quantity * sci.Price,
UnitPrice = sci.Price,
ProductImage = product.ProductImage,
MaxStockQuantity = product.StockQuantity,
};
model.Items.Add(cartItemModel);
}
#endregion
}
protected void SaveLocalizableContent(ProductAttribute productAttribute)
{
if (productAttribute == null)
{
return;
}
if (!this.HasLocalizableContent)
{
return;
}
foreach (RepeaterItem item in rptrLanguageDivs.Items)
{
if (item.ItemType == ListItemType.Item || item.ItemType == ListItemType.AlternatingItem)
{
var txtLocalizedName = (TextBox)item.FindControl("txtLocalizedName");
var txtLocalizedDescription = (TextBox)item.FindControl("txtLocalizedDescription");
var lblLanguageId = (Label)item.FindControl("lblLanguageId");
int languageId = int.Parse(lblLanguageId.Text);
string name = txtLocalizedName.Text;
string description = txtLocalizedDescription.Text;
bool allFieldsAreEmpty = (string.IsNullOrEmpty(name) && string.IsNullOrEmpty(description));
var content = ProductAttributeManager.GetProductAttributeLocalizedByProductAttributeIdAndLanguageId(productAttribute.ProductAttributeId, languageId);
if (content == null)
{
if (!allFieldsAreEmpty && languageId > 0)
{
//only insert if one of the fields are filled out (avoid too many empty records in db...)
content = ProductAttributeManager.InsertProductAttributeLocalized(productAttribute.ProductAttributeId,
languageId, name, description);
}
}
else
{
if (languageId > 0)
{
content = ProductAttributeManager.UpdateProductAttributeLocalized(content.ProductAttributeLocalizedId, content.ProductAttributeId,
languageId, name, description);
}
}
}
}
}
public ActionResult InsertAttr(ProductAttribute pAttr)
{
dynamic result = new ExpandoObject();
result.status = true;
result.message = "";
if (pAttr.ProductID == 0 || pAttr.AttrID == 0 || String.IsNullOrEmpty(pAttr.Value))
{
result.status = false;
result.message = "Thiếu thuộc tính";
return(Content(JsonConvert.SerializeObject(result), "application/json"));
}
var product = Repository.Product.FindById(pAttr.ProductID);
var attr = Repository.Create <WebBanHang.Models.Attribute>().FindById(pAttr.AttrID);
if (product == null)
{
result.status = false;
result.message = "Không tồn tại sản phẩm";
return(Content(JsonConvert.SerializeObject(result), "application/json"));
}
if (attr == null)
{
result.status = false;
result.message = "Không tồn thuộc tính";
return(Content(JsonConvert.SerializeObject(result), "application/json"));
}
var existpAttr = product.ProductAttributes.Any(p => p.AttrID == pAttr.AttrID);
if (existpAttr)
{
result.status = false;
result.message = "Sản phẩm đã có thuộc tính này";
return(Content(JsonConvert.SerializeObject(result), "application/json"));
}
pAttr.Priority = 0;
product.ProductAttributes.Add(pAttr);
if (Repository.SaveChanges() == 0)
{
result.status = false;
result.message = "Lỗi xảy ra";
return(Content(JsonConvert.SerializeObject(result), "application/json"));
}
result.status = true;
result.message = "Thêm thuộc tính thành công!!!";
return(Content(JsonConvert.SerializeObject(result), "application/json"));
}
public static ProductAttribute CreateProductAttribute(string productAttributeTypeName,
string attributeName,
global::System.DateTimeOffset defaultDateTimeValue,
decimal defaultCurrencyValue,
decimal defaultDecimalValue,
int defaultIntegerValue)
{
ProductAttribute productAttribute = new ProductAttribute();
productAttribute.ProductAttributeTypeName = productAttributeTypeName;
productAttribute.AttributeName = attributeName;
productAttribute.DefaultDateTimeValue = defaultDateTimeValue;
productAttribute.DefaultCurrencyValue = defaultCurrencyValue;
productAttribute.DefaultDecimalValue = defaultDecimalValue;
productAttribute.DefaultIntegerValue = defaultIntegerValue;
return(productAttribute);
}
/// <summary>
/// All the attribute term import stuff. Attributes Terms in Woo are Attributed Varieties to us. Could we have generalised this for each item import with an object?
/// </summary>
#region AttrbiuteStuff
// Retrieve data from Woo
async Task <List <ProductAttributeTerm> > GetWooAttributeTermData(ProductAttribute currProductAttribute)
{
WooAPISettings _wooAPISettings = new WooAPISettings(AppWooSettings);
//
// ConsumerKey = WooSettingsModel.ConsumerKey,
// ConsumerSecret = WooSettingsModel.ConsumerSecret,
// QueryURL = WooSettingsModel.QueryURL,
// IsSecureURL = WooSettingsModel.IsSecureURL,
// JSONAPIPostFix = WooSettingsModel.JSONAPIPostFix,
// RootAPIPostFix = WooSettingsModel.RootAPIPostFix
//};
IWooProductAttributeTerm _WooProductAttributeTerm = new WooProductAttributeTerm(_wooAPISettings, _Logger);
List <ProductAttributeTerm> wooProductAttributeTerms = await _WooProductAttributeTerm.GetAttributeTermsByAtttribute(currProductAttribute);
return(wooProductAttributeTerms);
}
private ProductAttribute DataRowToProductAttribute(DataRow data)
{
if (data == null)
{
return(null);
}
var contact = new ProductAttribute();
contact.Id = new Guid(data["Id"].ToString());
contact.LangName = data["LangName"].ToString();
contact.ValueType = (int)data["ValueType"];
contact.IsNull = (bool)data["IsNull"];
contact.IsLock = (bool)data["IsLock"];
return(contact);
}
public ActionResult Add_Attr(ProductAttribute model)
{
if (model.AttributeID == 0)
{
var addAttr = CatalogBLL.ProductAttribute_Add(model);
return(RedirectToAction("Input", "Product", new { id = model.ProductID }));
//return Content(addAttr.ToString());
}
else
{
var editAttr = CatalogBLL.ProductAttribute_Update(model);
return(RedirectToAction("Input", "Product", new { id = model.ProductID }));
//return Content(editAttr.ToString());
}
}
async Task <Guid> AddOrUpdateItemAttribute(ProductAttribute pPA, Guid pWooMappedItemAttributeId)
{
Guid _ItemAttributeId = Guid.Empty;
IAppRepository <ItemAttributeLookup> _ItemAttributeRepository = _AppUnitOfWork.Repository <ItemAttributeLookup>();
// check if the Attribute exists
ItemAttributeLookup _ItemAttribute = await _ItemAttributeRepository.FindFirstAsync(ic => ic.ItemAttributeLookupId == pWooMappedItemAttributeId);
if (_ItemAttribute != null)
{
_ItemAttributeId = await UpdateItemAttribute(pPA, _ItemAttribute);
}
else
{
_ItemAttributeId = await AddOrGetIDItemAttribute(pPA);
}
return(_ItemAttributeId);
}
private void BindData()
{
ProductVariantAttribute productVariantAttribute = ProductAttributeManager.GetProductVariantAttributeById(this.ProductVariantAttributeId);
if (productVariantAttribute != null)
{
if (this.HasLocalizableContent)
{
var languages = this.GetLocalizableLanguagesSupported();
rptrLanguageTabs.DataSource = languages;
rptrLanguageTabs.DataBind();
rptrLanguageDivs.DataSource = languages;
rptrLanguageDivs.DataBind();
}
ProductVariant productVariant = productVariantAttribute.ProductVariant;
if (productVariant == null)
{
Response.Redirect("Products.aspx");
}
ProductAttribute productAttribute = productVariantAttribute.ProductAttribute;
if (productAttribute == null)
{
Response.Redirect("Products.aspx");
}
this.lblTitle.Text = string.Format(GetLocaleResourceString("Admin.ProductVariantAttributeValues.AddEdit"), Server.HtmlEncode(productAttribute.Name), Server.HtmlEncode(productVariant.FullProductName));
this.hlProductURL.NavigateUrl = CommonHelper.GetStoreAdminLocation() + "ProductVariantDetails.aspx?ProductVariantID=" + productVariant.ProductVariantId;
var productVariantAttributeValues = ProductAttributeManager.GetProductVariantAttributeValues(productVariantAttribute.ProductVariantAttributeId);
if (productVariantAttributeValues.Count > 0)
{
this.gvProductVariantAttributeValues.Visible = true;
this.gvProductVariantAttributeValues.DataSource = productVariantAttributeValues;
this.gvProductVariantAttributeValues.DataBind();
}
else
{
this.gvProductVariantAttributeValues.Visible = false;
}
}
else
{
Response.Redirect("Products.aspx");
}
}
//string _wooOrderBy = "menu_order";
//switch (v.ToLower())
//{
// case "id": // OrderBys.Id.ToString().ToLower():
// _wooOrderBy = "id";
// break;
// case "name": //OrderBys.Name
// _wooOrderBy = "name";
// break;
// case "number": //OrderBys.Number
// _wooOrderBy = "name_num";
// break;
// default:
// break;
//}
//return _wooOrderBy;
private async Task <ProductAttribute> AddItemToWooOnlySync(ItemAttributeLookup addEntity)
{
IWooProductAttribute _wooProductAttributeRepository = await GetIWooProductAttribute();
if (_wooProductAttributeRepository == null)
{
return(null);
}
ProductAttribute _wooProductAttribute = new ProductAttribute
{
name = addEntity.AttributeName,
order_by = ConvertToWooOrderBy(addEntity.OrderBy),
};
return(await _wooProductAttributeRepository.AddProductAttributeAsync(_wooProductAttribute)); // should return a new version with ID
}
public async Task <int> CreateAsync(ProductAttributeModifyRequest productAttribute)
{
var newProductAttribute = new ProductAttribute
{
Description = productAttribute.Description,
Name = productAttribute.Name,
StatusId = ProductAttributeStatus.Actived.GetCode(),
CreatedById = productAttribute.CreatedById,
UpdatedById = productAttribute.UpdatedById,
UpdatedDate = DateTime.UtcNow,
CreatedDate = DateTime.UtcNow,
};
var id = await _productAttributeRepository.AddWithInt32EntityAsync(newProductAttribute);
return(id);
}
public IActionResult Create(ProductPictureModifierModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageWidgets))
{
return(AccessDeniedView());
}
//todo find out why model state validation failed even though product id is only validated and model has product id
if (model.ProductId < 1)
{
ModelState.AddModelError(nameof(model.ProductId),
_localizationService.GetResource("Admin.Widgets.ProductPictureModifier.Fields.Product.Required"));
return(View("~/Plugins/Widgets.ProductPictureModifier/Views/Admin/Create.cshtml", model));
}
ProductAttribute productAttribute = _productPictureModifierService.
GetProductAttributeByName(ProductPictureModifierDefault.ProductAttributeName).First();
var productAttributeMapping = new ProductAttributeMapping
{
ProductAttributeId = productAttribute.Id,
ProductId = model.ProductId,
DefaultValue = model.ColorCode,
AttributeControlTypeId = (int)AttributeControlType.TextBox
};
_productAttributeService.InsertProductAttributeMapping(productAttributeMapping);
//Logo Default Value
_logoPositionService.Insert(new LogoPosition
{
ProductId = model.ProductId,
ColorCode = model.ColorCode
});
//Clear the cache for product picture preparation
_cacheManager.RemoveByPattern(string.Format(ModelCacheEventConsumer.PRODUCT_DEFAULTPICTURE_PATTERN_KEY_BY_ID, model.ProductId));
SuccessNotification(_localizationService.GetResource("Widgets.ProductPictureModifier.Mapping.Created"));
if (!continueEditing)
{
return(RedirectToAction("Configure"));
}
return(RedirectToAction("Edit", new { id = productAttributeMapping.Id }));
}
public IActionResult Post([FromBody] ProductAttributeFormVm model)
{
if (ModelState.IsValid)
{
var productAttribute = new ProductAttribute
{
Name = model.Name,
GroupId = model.GroupId
};
_productAttrRepository.Add(productAttribute);
_productAttrRepository.SaveChanges();
return(Ok());
}
return(BadRequest(ModelState));
}
public static ResponseViewModel <ProductAttribute> UpdateProductAttribute(ProductAttributeViewModel viewModel)
{
ResponseViewModel <ProductAttribute> responseViewModel = new ResponseViewModel <ProductAttribute>();
using (EcommerceEntities entities = new EcommerceEntities())
{
ProductAttribute productAtributeDb = entities.ProductAttributes.Where(entry => entry.ID == viewModel.ID).FirstOrDefault();
productAtributeDb.Name = viewModel.attributeName;
productAtributeDb.ProductCategoryID = viewModel.productCategoryId;
productAtributeDb.ProductSubCategoryID = viewModel.productSubCategoryId;
entities.SaveChanges();
ProductAttributeManager.AddOption(viewModel.options, productAtributeDb.ID);
responseViewModel.Data = productAtributeDb;
entities.SaveChanges();
return(responseViewModel);
}
}
private async Task MergeGiftsAsync(AbcMattressModel model, ProductAttribute pa, Product product)
{
var displayOrder = 50;
var pam = (await _productAttributeService.GetProductAttributeMappingsByProductIdAsync(product.Id))
.Where(pam => pam.ProductAttributeId == pa.Id && pam.DisplayOrder == displayOrder)
.FirstOrDefault();
var modelHasGifts = _abcMattressGiftService.GetAbcMattressGiftsByModelId(model.Id).Any();
if (pam == null && modelHasGifts)
{
pam = new ProductAttributeMapping()
{
ProductId = product.Id,
ProductAttributeId = pa.Id,
IsRequired = false,
AttributeControlType = AttributeControlType.DropdownList,
DisplayOrder = displayOrder
};
await _productAttributeService.InsertProductAttributeMappingAsync(pam);
}
else if (pam != null && !modelHasGifts)
{
await _productAttributeService.DeleteProductAttributeMappingAsync(pam);
}
if (!modelHasGifts)
{
return;
}
var existingGifts = (await _productAttributeService.GetProductAttributeValuesAsync(pam.Id))
.Where(pav =>
pav.ProductAttributeMappingId == pam.Id
);
var gifts = _abcMattressGiftService.GetAbcMattressGiftsByModelId(model.Id);
var newGifts = gifts.Select(g => g.ToProductAttributeValue(pam.Id)).ToList();
var toBeDeleted = existingGifts
.Where(e => !newGifts.Any(n => n.Name == e.Name && n.DisplayOrder == e.DisplayOrder));
var toBeInserted = newGifts
.Where(n => !existingGifts.Any(e => n.Name == e.Name && n.DisplayOrder == e.DisplayOrder));
toBeInserted.ToList().ForEach(async n => await _productAttributeService.InsertProductAttributeValueAsync(n));
toBeDeleted.ToList().ForEach(async e => await _productAttributeService.DeleteProductAttributeValueAsync(e));
}
/// <summary>
/// Inserts a product attribute
/// </summary>
/// <param name="productAttribute">Product attribute</param>
public virtual async Task InsertProductAttribute(ProductAttribute productAttribute)
{
if (productAttribute == null)
{
throw new ArgumentNullException("productAttribute");
}
await _productAttributeRepository.InsertAsync(productAttribute);
//cache
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTEMAPPINGS_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTEVALUES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTECOMBINATIONS_PATTERN_KEY);
//event notification
await _eventPublisher.EntityInserted(productAttribute);
}
/// <summary>
/// Updates the product attribute
/// </summary>
/// <param name="productAttribute">Product attribute</param>
public virtual void UpdateProductAttribute(ProductAttribute productAttribute)
{
if (productAttribute == null)
{
throw new ArgumentNullException("productAttribute");
}
_productAttributeRepository.Update(productAttribute);
//cache
_cacheManager.GetCache(CACHE_NAME_PRODUCTATTRIBUTES).Clear();
_cacheManager.GetCache(CACHE_NAME_PRODUCTATTRIBUTEMAPPINGS).Clear();
_cacheManager.GetCache(CACHE_NAME_PRODUCTATTRIBUTEVALUES).Clear();
_cacheManager.GetCache(CACHE_NAME_PRODUCTATTRIBUTECOMBINATIONS).Clear();
//event notification
//_eventPublisher.EntityUpdated(productAttribute);
}
/// <summary>
/// Updates the product attribute
/// </summary>
/// <param name="productAttribute">Product attribute</param>
public virtual void UpdateProductAttribute(ProductAttribute productAttribute)
{
if (productAttribute == null)
{
throw new ArgumentNullException("productAttribute");
}
_productAttributeRepository.Update(productAttribute);
//cache
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTEMAPPINGS_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTEVALUES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTECOMBINATIONS_PATTERN_KEY);
//event notification
_eventPublisher.EntityUpdated(productAttribute);
}
public ProductAttributeEntity(ProductAttribute ProductAttribute, params object[] args) : base(ProductAttribute)
{
foreach (object arg in args)
{
if (arg is Category Category)
{
CategoryEntity = new CategoryEntity(Category);
}
if (arg is ICollection <ProductAttributeName> ProductAttributeNames)
{
ProductAttributeNameEntities = ProductAttributeNames.Select(model => new ProductAttributeNameEntity(model, model.Language)).ToList();
}
if (arg is ICollection <ProductValue> ProductValues)
{
ProductValueEntities = ProductValues.Select(model => new ProductValueEntity(model, model.Language, model.Product)).ToList();
}
}
}
/// <summary>
/// Deletes a product attribute
/// </summary>
/// <param name="productAttribute">Product attribute</param>
public virtual void DeleteProductAttribute(ProductAttribute productAttribute)
{
if (productAttribute == null)
{
throw new ArgumentNullException(nameof(productAttribute));
}
_productAttributeRepository.Delete(productAttribute);
//cache
_cacheManager.RemoveByPattern(NopCatalogDefaults.ProductAttributesPatternCacheKey);
_cacheManager.RemoveByPattern(NopCatalogDefaults.ProductAttributeMappingsPatternCacheKey);
_cacheManager.RemoveByPattern(NopCatalogDefaults.ProductAttributeValuesPatternCacheKey);
_cacheManager.RemoveByPattern(NopCatalogDefaults.ProductAttributeCombinationsPatternCacheKey);
//event notification
_eventPublisher.EntityDeleted(productAttribute);
}
public ProductAttribute SaveInfo()
{
ProductAttribute productAttribute = ProductAttributeManager.GetProductAttributeById(this.ProductAttributeId, 0);
if (productAttribute != null)
{
productAttribute = ProductAttributeManager.UpdateProductAttribute(productAttribute.ProductAttributeId,
txtName.Text, txtDescription.Text);
}
else
{
productAttribute = ProductAttributeManager.InsertProductAttribute(txtName.Text, txtDescription.Text);
}
SaveLocalizableContent(productAttribute);
return(productAttribute);
}
/// <summary>
/// Submit button click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnSubmit_Click(object sender, EventArgs e)
{
//Declarations
AttributeTypeAdmin _AdminAccess = new AttributeTypeAdmin();
ProductAttribute _ProductAttribute = new ProductAttribute();
//Check for Edit Mode
if (AttributeID > 0)
{
_ProductAttribute = _AdminAccess.GetByAttributeID(AttributeID);
}
//Set Values
_ProductAttribute.Name = Name.Text.Trim();
_ProductAttribute.DisplayOrder = int.Parse(DisplayOrder.Text.Trim());
_ProductAttribute.AttributeTypeId = ItemID;
_ProductAttribute.ExternalId = null;
_ProductAttribute.OldAttributeId = null;
_ProductAttribute.IsActive = true;
bool status = false;
if (AttributeID > 0)
{
//Update Product Attribute
status = _AdminAccess.UpdateProductAttribute(_ProductAttribute);
}
else
{
status = _AdminAccess.AddProductAttribute(_ProductAttribute);
}
if (status)
{
//redirect to main page
Response.Redirect(viewLink + ItemID);
}
else
{
//display error message
lblError.Text = "An error occurred while updating. Please try again.";
}
}
public static ProductAttribute CreateProductAttribute(string ID)
{
ProductAttribute productAttribute = new ProductAttribute();
productAttribute.Id = ID;
return productAttribute;
}
public void AddToProductAttributes(ProductAttribute productAttribute)
{
base.AddObject("ProductAttributes", productAttribute);
}
