//edit
        public virtual IActionResult Edit(int id)
        {
            if (!_permissionService.Authorize(StandardPermissionProvider.ManageAttributes))
            {
                return(AccessDeniedView());
            }

            //try to get a specification attribute with the specified id
            var specificationAttribute = _specificationAttributeService.GetSpecificationAttributeById(id);

            if (specificationAttribute == null)
            {
                return(RedirectToAction("List"));
            }

            //prepare model
            var model = _specificationAttributeModelFactory.PrepareSpecificationAttributeModel(null, specificationAttribute);

            return(View(model));
        }
Пример #2
0
        public async Task <IList <ProductSpecificationModel> > Handle(GetProductSpecification request, CancellationToken cancellationToken)
        {
            if (request.Product == null)
            {
                throw new ArgumentNullException("product");
            }

            string cacheKey = string.Format(ModelCacheEventConst.PRODUCT_SPECS_MODEL_KEY, request.Product.Id, request.Language.Id);

            return(await _cacheManager.GetAsync(cacheKey, async() =>
            {
                var spa = new List <ProductSpecificationModel>();
                foreach (var item in request.Product.ProductSpecificationAttributes.Where(x => x.ShowOnProductPage).OrderBy(x => x.DisplayOrder))
                {
                    var specificationAttribute = await _specificationAttributeService.GetSpecificationAttributeById(item.SpecificationAttributeId);
                    var m = new ProductSpecificationModel {
                        SpecificationAttributeId = item.SpecificationAttributeId,
                        SpecificationAttributeName = specificationAttribute.GetLocalized(x => x.Name, request.Language.Id),
                        ColorSquaresRgb = specificationAttribute.SpecificationAttributeOptions.Where(x => x.Id == item.SpecificationAttributeOptionId).FirstOrDefault() != null ? specificationAttribute.SpecificationAttributeOptions.Where(x => x.Id == item.SpecificationAttributeOptionId).FirstOrDefault().ColorSquaresRgb : "",
                    };

                    switch (item.AttributeType)
                    {
                    case SpecificationAttributeType.Option:
                        m.ValueRaw = WebUtility.HtmlEncode(specificationAttribute.SpecificationAttributeOptions.Where(x => x.Id == item.SpecificationAttributeOptionId).FirstOrDefault().GetLocalized(x => x.Name, request.Language.Id));
                        break;

                    case SpecificationAttributeType.CustomText:
                        m.ValueRaw = WebUtility.HtmlEncode(item.CustomValue);
                        break;

                    case SpecificationAttributeType.CustomHtmlText:
                        m.ValueRaw = item.CustomValue;
                        break;

                    case SpecificationAttributeType.Hyperlink:
                        m.ValueRaw = string.Format("<a href='{0}' target='_blank'>{0}</a>", item.CustomValue);
                        break;

                    default:
                        break;
                    }
                    spa.Add(m);
                }
                return spa;
            }

                                                ));
        }
Пример #3
0
        public IActionResult GetSpecificationAttributeById(int id, string fields = "")
        {
            if (id <= 0)
            {
                return(Error(HttpStatusCode.BadRequest, "id", "invalid id"));
            }

            var specificationAttribute = _specificationAttributeService.GetSpecificationAttributeById(id);

            if (specificationAttribute == null)
            {
                return(Error(HttpStatusCode.NotFound, "specification attribute", "not found"));
            }

            var specificationAttributeDto = _dtoHelper.PrepareSpecificationAttributeDto(specificationAttribute);

            var specificationAttributesRootObject = new SpecificationAttributesRootObjectDto();

            specificationAttributesRootObject.SpecificationAttributes.Add(specificationAttributeDto);

            var json = JsonFieldsSerializer.Serialize(specificationAttributesRootObject, fields);

            return(new RawJsonActionResult(json));
        }
Пример #4
0
        //edit
        public ActionResult Edit(int id)
        {
            if (!_permissionService.Authorize(StandardPermissionProvider.ManageCatalog))
            {
                return(AccessDeniedView());
            }

            var specificationAttribute = _specificationAttributeService.GetSpecificationAttributeById(id);

            if (specificationAttribute == null)
            {
                return(RedirectToAction("List"));
            }

            var model = specificationAttribute.ToModel();

            //locales
            AddLocales(_languageService, model.Locales, (locale, languageId) =>
            {
                locale.Name = specificationAttribute.GetLocalized(x => x.Name, languageId, false, false);
            });

            return(View(model));
        }
        public async Task <IList <ProductSpecificationModel> > Handle(GetProductSpecification request, CancellationToken cancellationToken)
        {
            if (request.Product == null)
            {
                throw new ArgumentNullException(nameof(request.Product));
            }

            var spa = new List <ProductSpecificationModel>();

            foreach (var item in request.Product.ProductSpecificationAttributes.Where(x => x.ShowOnProductPage).OrderBy(x => x.DisplayOrder))
            {
                var specificationAttribute = await _specificationAttributeService.GetSpecificationAttributeById(item.SpecificationAttributeId);

                var m = new ProductSpecificationModel {
                    SpecificationAttributeId   = item.SpecificationAttributeId,
                    SpecificationAttributeName = specificationAttribute.GetTranslation(x => x.Name, request.Language.Id),
                    ColorSquaresRgb            = specificationAttribute.SpecificationAttributeOptions.Where(x => x.Id == item.SpecificationAttributeOptionId).FirstOrDefault() != null?specificationAttribute.SpecificationAttributeOptions.Where(x => x.Id == item.SpecificationAttributeOptionId).FirstOrDefault().ColorSquaresRgb : "",
                    UserFields = specificationAttribute.UserFields,
                };

                switch (item.AttributeTypeId)
                {
                case SpecificationAttributeType.Option:
                    m.ValueRaw = WebUtility.HtmlEncode(specificationAttribute.SpecificationAttributeOptions.Where(x => x.Id == item.SpecificationAttributeOptionId).FirstOrDefault().GetTranslation(x => x.Name, request.Language.Id));
                    break;

                case SpecificationAttributeType.CustomText:
                    m.ValueRaw = WebUtility.HtmlEncode(item.CustomValue);
                    break;

                case SpecificationAttributeType.CustomHtmlText:
                    m.ValueRaw = item.CustomValue;
                    break;

                case SpecificationAttributeType.Hyperlink:
                    m.ValueRaw = string.Format("<a href='{0}' target='_blank'>{0}</a>", item.CustomValue);
                    break;

                default:
                    break;
                }
                spa.Add(m);
            }
            return(spa);
        }
        //edit
        public IActionResult Edit(string id)
        {
            var specificationAttribute = _specificationAttributeService.GetSpecificationAttributeById(id);

            if (specificationAttribute == null)
            {
                //No specification attribute found with the specified id
                return(RedirectToAction("List"));
            }

            var model = specificationAttribute.ToModel();

            //locales
            AddLocales(_languageService, model.Locales, (locale, languageId) =>
            {
                locale.Name = specificationAttribute.GetLocalized(x => x.Name, languageId, false, false);
            });

            return(View(model));
        }
Пример #7
0
        public async Task <SpecificationAttributeDto> Handle(UpdateSpecificationAttributeCommand request, CancellationToken cancellationToken)
        {
            var specificationAttribute = await _specificationAttributeService.GetSpecificationAttributeById(request.Model.Id);

            foreach (var option in specificationAttribute.SpecificationAttributeOptions)
            {
                if (request.Model.SpecificationAttributeOptions.FirstOrDefault(x => x.Id == option.Id) == null)
                {
                    await _specificationAttributeService.DeleteSpecificationAttributeOption(option);
                }
            }
            specificationAttribute = request.Model.ToEntity(specificationAttribute);
            await _specificationAttributeService.UpdateSpecificationAttribute(specificationAttribute);

            //activity log
            await _customerActivityService.InsertActivity("EditSpecAttribute",
                                                          specificationAttribute.Id, _translationService.GetResource("ActivityLog.EditSpecAttribute"), specificationAttribute.Name);

            return(specificationAttribute.ToModel());
        }
Пример #8
0
            /// <summary>
            /// Prepare model
            /// </summary>
            /// <param name="alreadyFilteredSpecOptionIds">IDs of already filtered specification options</param>
            /// <param name="filterableSpecificationAttributeOptionIds">IDs of filterable specification options</param>
            /// <param name="specificationAttributeService"></param>
            /// <param name="localizationService">Localization service</param>
            /// <param name="webHelper">Web helper</param>
            /// <param name="workContext">Work context</param>
            /// <param name="cacheManager">Cache manager</param>
            public virtual void PrepareSpecsFilters(IList <int> alreadyFilteredSpecOptionIds,
                                                    int[] filterableSpecificationAttributeOptionIds,
                                                    ISpecificationAttributeService specificationAttributeService, ILocalizationService localizationService,
                                                    IWebHelper webHelper, IWorkContext workContext, ICacheManager cacheManager)
            {
                Enabled = false;
                var optionIds = filterableSpecificationAttributeOptionIds != null
                    ? string.Join(",", filterableSpecificationAttributeOptionIds) : string.Empty;

                var cacheKey = string.Format(NopModelCacheDefaults.SpecsFilterModelKey, optionIds, workContext.WorkingLanguage.Id);

                var allOptions = specificationAttributeService.GetSpecificationAttributeOptionsByIds(filterableSpecificationAttributeOptionIds);
                var allFilters = cacheManager.Get(cacheKey, () => allOptions.Select(sao =>
                {
                    var specAttribute = specificationAttributeService.GetSpecificationAttributeById(sao.SpecificationAttributeId);

                    return(new SpecificationAttributeOptionFilter
                    {
                        SpecificationAttributeId = specAttribute.Id,
                        SpecificationAttributeName = localizationService.GetLocalized(specAttribute, x => x.Name, workContext.WorkingLanguage.Id),
                        SpecificationAttributeDisplayOrder = specAttribute.DisplayOrder,
                        SpecificationAttributeOptionId = sao.Id,
                        SpecificationAttributeOptionName = localizationService.GetLocalized(sao, x => x.Name, workContext.WorkingLanguage.Id),
                        SpecificationAttributeOptionColorRgb = sao.ColorSquaresRgb,
                        SpecificationAttributeOptionDisplayOrder = sao.DisplayOrder
                    });
                }).ToList());

                if (!allFilters.Any())
                {
                    return;
                }

                //sort loaded options
                allFilters = allFilters.OrderBy(saof => saof.SpecificationAttributeDisplayOrder)
                             .ThenBy(saof => saof.SpecificationAttributeName)
                             .ThenBy(saof => saof.SpecificationAttributeOptionDisplayOrder)
                             .ThenBy(saof => saof.SpecificationAttributeOptionName).ToList();

                //prepare the model properties
                Enabled = true;
                var removeFilterUrl = webHelper.RemoveQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM);

                RemoveFilterUrl = ExcludeQueryStringParams(removeFilterUrl, webHelper);

                //get already filtered specification options
                var alreadyFilteredOptions = allFilters.Where(x => alreadyFilteredSpecOptionIds.Contains(x.SpecificationAttributeOptionId));

                AlreadyFilteredItems = alreadyFilteredOptions.Select(x =>
                                                                     new SpecificationFilterItem
                {
                    SpecificationAttributeName           = x.SpecificationAttributeName,
                    SpecificationAttributeOptionName     = x.SpecificationAttributeOptionName,
                    SpecificationAttributeOptionColorRgb = x.SpecificationAttributeOptionColorRgb
                }).ToList();

                //get not filtered specification options
                NotFilteredItems = allFilters.Except(alreadyFilteredOptions).Select(x =>
                {
                    //filter URL
                    var alreadyFiltered = alreadyFilteredSpecOptionIds.Concat(new List <int> {
                        x.SpecificationAttributeOptionId
                    });
                    var filterUrl = webHelper.ModifyQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM,
                                                                alreadyFiltered.OrderBy(id => id).Select(id => id.ToString()).ToArray());

                    return(new SpecificationFilterItem()
                    {
                        SpecificationAttributeName = x.SpecificationAttributeName,
                        SpecificationAttributeOptionName = x.SpecificationAttributeOptionName,
                        SpecificationAttributeOptionColorRgb = x.SpecificationAttributeOptionColorRgb,
                        FilterUrl = ExcludeQueryStringParams(filterUrl, webHelper)
                    });
                }).ToList();
            }