protected virtual void SaveStoreMappings(CheckoutAttribute checkoutAttribute, CheckoutAttributeModel model)
        {
            checkoutAttribute.LimitedToStores = model.SelectedStoreIds.Any();
            _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);

            var existingStoreMappings = _storeMappingService.GetStoreMappings(checkoutAttribute);
            var allStores             = _storeService.GetAllStores();

            foreach (var store in allStores)
            {
                if (model.SelectedStoreIds.Contains(store.Id))
                {
                    //new store
                    if (existingStoreMappings.Count(sm => sm.StoreId == store.Id) == 0)
                    {
                        _storeMappingService.InsertStoreMapping(checkoutAttribute, store.Id);
                    }
                }
                else
                {
                    //remove store
                    var storeMappingToDelete = existingStoreMappings.FirstOrDefault(sm => sm.StoreId == store.Id);
                    if (storeMappingToDelete != null)
                    {
                        _storeMappingService.DeleteStoreMapping(storeMappingToDelete);
                    }
                }
            }
        }
        public async Task UpdateCheckoutAttribute_InvokeExpectedMethods()
        {
            await _service.UpdateCheckoutAttribute(new CheckoutAttribute());

            _repositoryMock.Verify(c => c.UpdateAsync(It.IsAny <CheckoutAttribute>()), Times.Once);
            _cacheMock.Verify(c => c.RemoveByPrefix(It.IsAny <string>(), It.IsAny <bool>()), Times.AtLeast(1));
            _mediatorMock.Verify(c => c.Publish(It.IsAny <EntityUpdated <CheckoutAttribute> >(), default(CancellationToken)), Times.Once);
        }
Beispiel #3
0
        public virtual CheckoutAttribute UpdateCheckoutAttributeModel(CheckoutAttribute checkoutAttribute, CheckoutAttributeModel model)
        {
            checkoutAttribute = model.ToEntity(checkoutAttribute);
            SaveConditionAttributes(checkoutAttribute, model);
            _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);

            //activity log
            _customerActivityService.InsertActivity("EditCheckoutAttribute", checkoutAttribute.Id, _localizationService.GetResource("ActivityLog.EditCheckoutAttribute"), checkoutAttribute.Name);
            return(checkoutAttribute);
        }
Beispiel #4
0
        public virtual async Task <CheckoutAttribute> UpdateCheckoutAttributeModel(CheckoutAttribute checkoutAttribute, CheckoutAttributeModel model)
        {
            checkoutAttribute = model.ToEntity(checkoutAttribute);
            await SaveConditionAttributes(checkoutAttribute, model);

            await _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);

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

            return(checkoutAttribute);
        }
        public IActionResult Edit(CheckoutAttributeModel model, bool continueEditing)
        {
            if (!_permissionService.Authorize(StandardPermissionProvider.ManageAttributes))
            {
                return(AccessDeniedView());
            }

            var checkoutAttribute = _checkoutAttributeService.GetCheckoutAttributeById(model.Id);

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

            if (ModelState.IsValid)
            {
                checkoutAttribute = model.ToEntity(checkoutAttribute);
                SaveConditionAttributes(checkoutAttribute, model);
                checkoutAttribute.CustomerRoles = model.SelectedCustomerRoleIds != null?model.SelectedCustomerRoleIds.ToList() : new List <string>();

                checkoutAttribute.Locales = UpdateAttributeLocales(checkoutAttribute, model);
                checkoutAttribute.Stores  = model.SelectedStoreIds != null?model.SelectedStoreIds.ToList() : new List <string>();

                _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);

                //activity log
                _customerActivityService.InsertActivity("EditCheckoutAttribute", checkoutAttribute.Id, _localizationService.GetResource("ActivityLog.EditCheckoutAttribute"), checkoutAttribute.Name);

                SuccessNotification(_localizationService.GetResource("Admin.Catalog.Attributes.CheckoutAttributes.Updated"));
                if (continueEditing)
                {
                    //selected tab
                    SaveSelectedTabIndex();

                    return(RedirectToAction("Edit", new { id = checkoutAttribute.Id }));
                }
                return(RedirectToAction("List"));
            }

            //If we got this far, something failed, redisplay form

            //tax categories
            PrepareTaxCategories(model, checkoutAttribute, true);
            //Stores
            PrepareStoresMappingModel(model, checkoutAttribute, true);
            //ACL
            PrepareAclModel(model, checkoutAttribute, false);
            return(View(model));
        }
        public ActionResult Edit(CheckoutAttributeModel model, bool continueEditing)
        {
            var checkoutAttribute = _checkoutAttributeService.GetCheckoutAttributeById(model.Id);

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

            if (ModelState.IsValid)
            {
                checkoutAttribute = model.ToEntity(checkoutAttribute);
                _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);

                UpdateAttributeLocales(checkoutAttribute, model);
                SaveStoreMappings(checkoutAttribute, model.SelectedStoreIds);

                _customerActivityService.InsertActivity("EditCheckoutAttribute", T("ActivityLog.EditCheckoutAttribute"), checkoutAttribute.Name);

                NotifySuccess(T("Admin.Catalog.Attributes.CheckoutAttributes.Updated"));
                return(continueEditing ? RedirectToAction("Edit", checkoutAttribute.Id) : RedirectToAction("List"));
            }

            PrepareCheckoutAttributeModel(model, checkoutAttribute, true);

            return(View(model));
        }
        public ActionResult Edit(CheckoutAttributeModel model, bool continueEditing)
        {
            if (!_permissionService.Authorize(StandardPermissionProvider.ManageCatalog))
            {
                return(AccessDeniedView());
            }

            var checkoutAttribute = _checkoutAttributeService.GetCheckoutAttributeById(model.Id);

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

            if (ModelState.IsValid)
            {
                checkoutAttribute = model.ToEntity(checkoutAttribute);
                _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);

                UpdateAttributeLocales(checkoutAttribute, model);

                //activity log
                _customerActivityService.InsertActivity("EditCheckoutAttribute", _localizationService.GetResource("ActivityLog.EditCheckoutAttribute"), checkoutAttribute.Name);

                SuccessNotification(_localizationService.GetResource("Admin.Catalog.Attributes.CheckoutAttributes.Updated"));
                return(continueEditing ? RedirectToAction("Edit", checkoutAttribute.Id) : RedirectToAction("List"));
            }

            //If we got this far, something failed, redisplay form
            PrepareCheckoutAttributeModel(model, checkoutAttribute, true);
            return(View(model));
        }
Beispiel #8
0
        public virtual IActionResult Edit(CheckoutAttributeModel model, bool continueEditing)
        {
            if (!_permissionService.Authorize(StandardPermissionProvider.ManageAttributes))
            {
                return(AccessDeniedView());
            }

            //try to get a checkout attribute with the specified id
            var checkoutAttribute = _checkoutAttributeService.GetCheckoutAttributeById(model.Id);

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

            if (ModelState.IsValid)
            {
                checkoutAttribute = model.ToEntity(checkoutAttribute);
                SaveConditionAttributes(checkoutAttribute, model);
                _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);

                //locales
                UpdateAttributeLocales(checkoutAttribute, model);

                //stores
                SaveStoreMappings(checkoutAttribute, model);

                //activity log
                _customerActivityService.InsertActivity("EditCheckoutAttribute",
                                                        string.Format(_localizationService.GetResource("ActivityLog.EditCheckoutAttribute"), checkoutAttribute.Name), checkoutAttribute);

                SuccessNotification(_localizationService.GetResource("Admin.Catalog.Attributes.CheckoutAttributes.Updated"));

                if (!continueEditing)
                {
                    return(RedirectToAction("List"));
                }

                //selected tab
                SaveSelectedTabName();

                return(RedirectToAction("Edit", new { id = checkoutAttribute.Id }));
            }

            //prepare model
            model = _checkoutAttributeModelFactory.PrepareCheckoutAttributeModel(model, checkoutAttribute, true);

            //if we got this far, something failed, redisplay form
            return(View(model));
        }
        public IActionResult ValueDelete(string id, string checkoutAttributeId)
        {
            var checkoutAttribute = _checkoutAttributeService.GetCheckoutAttributeById(checkoutAttributeId);
            var cav = checkoutAttribute.CheckoutAttributeValues.Where(x => x.Id == id).FirstOrDefault();

            if (cav == null)
            {
                throw new ArgumentException("No checkout attribute value found with the specified id");
            }

            if (ModelState.IsValid)
            {
                checkoutAttribute.CheckoutAttributeValues.Remove(cav);
                _checkoutAttributeService.UpdateCheckoutAttribute(checkoutAttribute);
                return(new NullJsonResult());
            }
            return(ErrorForKendoGridJson(ModelState));
        }