public JsonResult SaveCcAttributes(int productId, int attributeId, int attributeOptionId, string attributeValue)
{
try
{
var specificationAttributes = _specificationAttributeService.GetProductSpecificationAttributes(productId);
var prodSpecAttr = specificationAttributes.FirstOrDefault(
x => x.SpecificationAttributeOption.SpecificationAttributeId == attributeId);
if (prodSpecAttr == null)
{
prodSpecAttr = new ProductSpecificationAttribute
{
AttributeType = SpecificationAttributeType.CustomText,
ProductId = productId,
SpecificationAttributeOptionId = attributeOptionId,
DisplayOrder = 0,
ShowOnProductPage = false,
AllowFiltering = false,
CustomValue = attributeValue,
};
_specificationAttributeService.InsertProductSpecificationAttribute(prodSpecAttr);
}
else
{
prodSpecAttr.CustomValue = attributeValue;
prodSpecAttr.ShowOnProductPage = false;
_specificationAttributeService.UpdateProductSpecificationAttribute(prodSpecAttr);
}
var productAttributeMappings = _productAttributeService.GetProductAttributeMappingsByProductId(productId);
foreach (var attrId in _ccService.GetCcAttrIds())
{
if (productAttributeMappings.All(map => map.ProductAttributeId != attrId))
{
_productAttributeService.InsertProductAttributeMapping(new ProductAttributeMapping
{
AttributeControlType = AttributeControlType.TextBox,
DefaultValue = "",
DisplayOrder = 100,
ProductId = productId,
ProductAttributeId = attrId
});
}
}
return(Json(new { status = "success" }));
}
catch (Exception ex)
{
return(Json(new { status = "error", message = ex.Message }));
}
}
public IActionResult UpdateProductSpecificationAttribute([ModelBinder(typeof(JsonModelBinder <ProductSpecificationAttributeDto>))] Delta <ProductSpecificationAttributeDto> productSpecificationAttributeDelta)
{
// Here we display the errors if the validation has failed at some point.
if (!ModelState.IsValid)
{
return(Error());
}
// We do not need to validate the product attribute id, because this will happen in the model binder using the dto validator.
int productSpecificationAttributeId = productSpecificationAttributeDelta.Dto.Id;
var productSpecificationAttribute = _specificationAttributeService.GetProductSpecificationAttributeById(productSpecificationAttributeId);
if (productSpecificationAttribute == null)
{
return(Error(HttpStatusCode.NotFound, "product specification attribute", "not found"));
}
productSpecificationAttributeDelta.Merge(productSpecificationAttribute);
_specificationAttributeService.UpdateProductSpecificationAttribute(productSpecificationAttribute);
CustomerActivityService.InsertActivity("EditProductSpecificationAttribute", productSpecificationAttribute.Id.ToString());
// Preparing the result dto of the new product attribute
var productSpecificationAttributeDto = _dtoHelper.PrepareProductSpecificationAttributeDto(productSpecificationAttribute);
var productSpecificatoinAttributesRootObjectDto = new ProductSpecificationAttributesRootObjectDto();
productSpecificatoinAttributesRootObjectDto.ProductSpecificationAttributes.Add(productSpecificationAttributeDto);
var json = JsonFieldsSerializer.Serialize(productSpecificatoinAttributesRootObjectDto, string.Empty);
return(new RawJsonActionResult(json));
}
public virtual void UpdateProductSpecification(ProductDto product, ProductSpecificationAttributeDto model)
{
var productdb = _productService.GetProductById(product.Id);
var psa = productdb.ProductSpecificationAttributes.FirstOrDefault(x => x.Id == model.Id);
if (psa != null)
{
if (model.AttributeType == SpecificationAttributeType.Option)
{
psa.AllowFiltering = model.AllowFiltering;
psa.SpecificationAttributeOptionId = model.SpecificationAttributeOptionId;
}
else
{
psa.CustomValue = model.CustomValue;
}
psa.SpecificationAttributeId = model.SpecificationAttributeId;
psa.SpecificationAttributeOptionId = model.SpecificationAttributeOptionId;
psa.AttributeTypeId = (int)model.AttributeType;
psa.ShowOnProductPage = model.ShowOnProductPage;
psa.DisplayOrder = model.DisplayOrder;
psa.ProductId = product.Id;
_specificationAttributeService.UpdateProductSpecificationAttribute(psa);
}
}
public async Task <bool> Handle(UpdateProductSpecificationCommand request, CancellationToken cancellationToken)
{
var product = await _productService.GetProductById(request.Product.Id, true);
var psa = product.ProductSpecificationAttributes.FirstOrDefault(x => x.Id == request.Model.Id);
if (psa != null)
{
if (request.Model.AttributeType == SpecificationAttributeType.Option)
{
psa.AllowFiltering = request.Model.AllowFiltering;
psa.SpecificationAttributeOptionId = request.Model.SpecificationAttributeOptionId;
}
else
{
psa.CustomValue = request.Model.CustomValue;
}
psa.SpecificationAttributeId = request.Model.SpecificationAttributeId;
psa.SpecificationAttributeOptionId = request.Model.SpecificationAttributeOptionId;
psa.AttributeTypeId = (int)request.Model.AttributeType;
psa.ShowOnProductPage = request.Model.ShowOnProductPage;
psa.DisplayOrder = request.Model.DisplayOrder;
psa.ProductId = product.Id;
await _specificationAttributeService.UpdateProductSpecificationAttribute(psa);
}
return(true);
}
public ActionResult SetAttributeValue(string pk, string value, string name, FormCollection form)
{
var success = false;
var message = string.Empty;
// name is the entity id of product specification attribute mapping
var attribute = _specificationAttributeService.GetProductSpecificationAttributeById(Convert.ToInt32(name));
if (_permissionService.Authorize(StandardPermissionProvider.ManageCatalog))
{
try
{
attribute.SpecificationAttributeOptionId = Convert.ToInt32(value);
_specificationAttributeService.UpdateProductSpecificationAttribute(attribute);
success = true;
}
catch (Exception exception)
{
message = exception.Message;
}
}
else
{
NotifyAccessDenied();
}
// we give back the name to xeditable to overwrite the grid data in success event when a grid element got updated
return(Json(new { success = success, message = message, name = attribute.SpecificationAttributeOption?.Name }));
}
public ActionResult SetAttributeValue(string pk, string value, string name, FormCollection form)
{
try
{
//name is the entity id of product specification attribute mapping
var specificationAttribute = _specificationAttributeService.GetProductSpecificationAttributeById(Convert.ToInt32(name));
specificationAttribute.SpecificationAttributeOptionId = Convert.ToInt32(value);
_specificationAttributeService.UpdateProductSpecificationAttribute(specificationAttribute);
Response.StatusCode = 200;
// we give back the name to xeditable to overwrite the grid data in success event when a grid element got updated
return(Json(new { name = specificationAttribute.SpecificationAttributeOption.Name }));
}
catch (Exception ex)
{
return(new HttpStatusCodeResult(501, ex.Message));
}
}
public ActionResult SetAttributeValue(string pk, string value, string name, FormCollection form)
{
var success = false;
var message = string.Empty;
// name is the entity id of product specification attribute mapping.
var attribute = _specificationAttributeService.GetProductSpecificationAttributeById(Convert.ToInt32(name));
try
{
attribute.SpecificationAttributeOptionId = Convert.ToInt32(value);
_specificationAttributeService.UpdateProductSpecificationAttribute(attribute);
success = true;
}
catch (Exception ex)
{
message = ex.Message;
}
// we give back the name to xeditable to overwrite the grid data in success event when a grid element got updated.
return(Json(new { success, message, name = attribute.SpecificationAttributeOption?.Name }));
}
internal static void Import(КоммерческаяИнформация source,
ICategoryService categoryService,
ISpecificationAttributeService specificationAttributeService,
IManufacturerService manufacturerService,
IProductService productService,
IUrlRecordService urlRecordService,
IPictureService pictureService,
List <Category> categories,
Dictionary <string, int> categoryMappings,
List <SpecificationAttribute> attributes,
Dictionary <string, int> attributesMappings,
List <Manufacturer> manufacturers,
Dictionary <string, int> manufacturersMappings,
string mappingsFile,
string logFile,
ImportCatalogSettings importSettings)
{
logFile.Log("Начало импорта товаров");
var stats = new[] { 0, 0 };
var mappings = File.Exists(mappingsFile)
? JsonConvert.DeserializeObject <Dictionary <string, int> >(File.ReadAllText(mappingsFile))
: new Dictionary <string, int>();
foreach (var prod in source.Каталог.Товары)
{
try
{
var product = mappings.ContainsKey(prod.Ид)
? productService.GetProductById(mappings[prod.Ид])
: null;
var deleted = prod.Статус == "Удален";
if (product == null)
{
product = new Product
{
CreatedOnUtc = DateTime.Now,
UpdatedOnUtc = DateTime.Now,
ProductType = ProductType.SimpleProduct,
ProductTemplateId = 1,
VisibleIndividually = true,
Name = prod.Наименование,
Sku = prod.Артикул,
ShortDescription = prod.Описание,
FullDescription = prod.Описание,
AllowCustomerReviews = true,
Deleted = deleted,
Published = !deleted,
OrderMinimumQuantity = 1,
OrderMaximumQuantity = 10000
};
productService.InsertProduct(product);
var seName = product.ValidateSeName(null, product.Name, true);
urlRecordService.SaveSlug(product, seName, 0);
//logFile.Log($"Новый товар {product.Name} ({product.Id}): {prod.Ид}");
stats[0]++;
}
else
{
if (!importSettings.UpdateExisting)
{
//logFile.Log($"Пропущен товар {product.Name} ({product.Id}): {prod.Ид}");
stats[1]++;
continue;
}
product.UpdatedOnUtc = DateTime.Now;
product.Deleted = deleted;
product.Published = !deleted;
productService.UpdateProduct(product);
//logFile.Log($"Обновлен товар {product.Name} ({product.Id}): {prod.Ид}");
stats[1]++;
}
mappings[prod.Ид] = product.Id;
if (importSettings.OverwriteManufacturers)
{
foreach (var manufacturer in product.ProductManufacturers.ToList())
{
manufacturerService.DeleteProductManufacturer(manufacturer);
}
}
if (prod.Изготовитель != null && manufacturersMappings.ContainsKey(prod.Изготовитель.Ид))
{
var manufacturerId = manufacturersMappings[prod.Изготовитель.Ид];
var manufacturer = product.ProductManufacturers.FirstOrDefault(m => m.ManufacturerId == manufacturerId);
if (manufacturer == null)
{
manufacturer = new ProductManufacturer
{
ProductId = product.Id,
ManufacturerId = manufacturerId
};
manufacturerService.InsertProductManufacturer(manufacturer);
product.ProductManufacturers.Add(manufacturer);
}
}
if (importSettings.OverwriteCategories)
{
foreach (var category in product.ProductCategories.ToList())
{
categoryService.DeleteProductCategory(category);
}
}
if (prod.Группы != null && categoryMappings.ContainsKey(prod.Группы.Ид))
{
var categoryId = categoryMappings[prod.Группы.Ид];
var category = product.ProductCategories.FirstOrDefault(c => c.CategoryId == categoryId);
if (category == null)
{
category = new ProductCategory
{
ProductId = product.Id,
CategoryId = categoryId
};
categoryService.InsertProductCategory(category);
product.ProductCategories.Add(category);
}
}
if (importSettings.ImportSpecificationAttributes && prod.ЗначенияСвойств != null)
{
foreach (var attr in prod.ЗначенияСвойств)
{
if (attributesMappings.ContainsKey(attr.Ид))
{
var emptyOptionKey = $"{attr.Ид}.";
if (attributesMappings.ContainsKey(emptyOptionKey))
{
var option = product.ProductSpecificationAttributes
.FirstOrDefault(a => a.SpecificationAttributeOptionId == attributesMappings[emptyOptionKey]);
if (option == null)
{
option = new ProductSpecificationAttribute
{
ProductId = product.Id,
ShowOnProductPage = true,
AllowFiltering = false,
SpecificationAttributeOptionId = attributesMappings[emptyOptionKey],
AttributeType = SpecificationAttributeType.CustomText,
CustomValue = attr.Значение
};
specificationAttributeService.InsertProductSpecificationAttribute(option);
product.ProductSpecificationAttributes.Add(option);
}
else if (option.CustomValue != attr.Значение)
{
option.CustomValue = attr.Значение;
specificationAttributeService.UpdateProductSpecificationAttribute(option);
}
}
else
{
var optionKey = $"{attr.Ид}.{attr.Значение}";
var option = product.ProductSpecificationAttributes
.FirstOrDefault(o => o.SpecificationAttributeOptionId == attributesMappings[optionKey]);
if (option == null)
{
var attribute = attributes.FirstOrDefault(a => a.Id == attributesMappings[attr.Ид]);
var optionIds = attribute.SpecificationAttributeOptions.Select(o => o.Id);
var options = product.ProductSpecificationAttributes
.Where(a => optionIds.Contains(a.SpecificationAttributeOptionId)).ToList();
if (options != null && options.Count > 0)
{
foreach (var opt in options)
{
product.ProductSpecificationAttributes.Remove(opt);
specificationAttributeService.DeleteProductSpecificationAttribute(opt);
}
}
option = new ProductSpecificationAttribute
{
ProductId = product.Id,
ShowOnProductPage = true,
AllowFiltering = true,
SpecificationAttributeOptionId = attributesMappings[optionKey],
AttributeType = SpecificationAttributeType.Option
};
specificationAttributeService.InsertProductSpecificationAttribute(option);
product.ProductSpecificationAttributes.Add(option);
}
}
}
}
}
if (!string.IsNullOrEmpty(prod.Картинка))
{
// todo: compare with existing images
var picturePath = HttpContext.Current.Request.MapPath($"~/Content/{prod.Картинка}");
var picture = LoadPicture(pictureService, picturePath, product.Name);
if (picture != null)
{
product.ProductPictures.Add(new ProductPicture
{
DisplayOrder = 1,
PictureId = picture.Id,
ProductId = product.Id
});
}
}
File.WriteAllText(mappingsFile, JsonConvert.SerializeObject(mappings, Formatting.Indented), Encoding.UTF8);
}
catch (Exception ex)
{
logFile.Log($"Ошибка при обработке товара {prod.Ид} ({prod.Наименование}): {ex}");
}
}
logFile.Log($"Импорт товаров завершен. Добавлено: {stats[0]}. Обновлено: {stats[1]}.");
}
