public virtual IActionResult EditProductAvailabilityRange(ProductAvailabilityRangeModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageShippingSettings))
{
return(AccessDeniedView());
}
var productAvailabilityRange = _dateRangeService.GetProductAvailabilityRangeById(model.Id);
if (productAvailabilityRange == null)
{
//No availability range found with the specified id
return(RedirectToAction("DatesAndRanges"));
}
if (ModelState.IsValid)
{
productAvailabilityRange = model.ToEntity(productAvailabilityRange);
_dateRangeService.UpdateProductAvailabilityRange(productAvailabilityRange);
//locales
UpdateLocales(productAvailabilityRange, model);
SuccessNotification(_localizationService.GetResource("Admin.Configuration.Shipping.ProductAvailabilityRanges.Updated"));
return(continueEditing ? RedirectToAction("EditProductAvailabilityRange", productAvailabilityRange.Id) : RedirectToAction("DatesAndRanges"));
}
//If we got this far, something failed, redisplay form
return(View(model));
}
public virtual IActionResult CreateProductAvailabilityRange(ProductAvailabilityRangeModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageShippingSettings))
{
return(AccessDeniedView());
}
if (ModelState.IsValid)
{
var productAvailabilityRange = model.ToEntity <ProductAvailabilityRange>();
_dateRangeService.InsertProductAvailabilityRange(productAvailabilityRange);
//locales
UpdateLocales(productAvailabilityRange, model);
SuccessNotification(_localizationService.GetResource("Admin.Configuration.Shipping.ProductAvailabilityRanges.Added"));
return(continueEditing ? RedirectToAction("EditProductAvailabilityRange", new { id = productAvailabilityRange.Id }) : RedirectToAction("DatesAndRanges"));
}
//prepare model
model = _shippingModelFactory.PrepareProductAvailabilityRangeModel(model, null, true);
//if we got this far, something failed, redisplay form
return(View(model));
}
public virtual async Task <IActionResult> EditProductAvailabilityRange(ProductAvailabilityRangeModel model, bool continueEditing)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageShippingSettings))
{
return(AccessDeniedView());
}
//try to get a product availability range with the specified id
var productAvailabilityRange = await _dateRangeService.GetProductAvailabilityRangeByIdAsync(model.Id);
if (productAvailabilityRange == null)
{
return(RedirectToAction("DatesAndRanges"));
}
if (ModelState.IsValid)
{
productAvailabilityRange = model.ToEntity(productAvailabilityRange);
await _dateRangeService.UpdateProductAvailabilityRangeAsync(productAvailabilityRange);
//locales
await UpdateLocalesAsync(productAvailabilityRange, model);
_notificationService.SuccessNotification(await _localizationService.GetResourceAsync("Admin.Configuration.Shipping.ProductAvailabilityRanges.Updated"));
return(continueEditing ? RedirectToAction("EditProductAvailabilityRange", productAvailabilityRange.Id) : RedirectToAction("DatesAndRanges"));
}
//prepare model
model = await _shippingModelFactory.PrepareProductAvailabilityRangeModelAsync(model, productAvailabilityRange, true);
//if we got this far, something failed, redisplay form
return(View(model));
}
public virtual IActionResult CreateProductAvailabilityRange()
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageShippingSettings))
{
return(AccessDeniedView());
}
var model = new ProductAvailabilityRangeModel();
//locales
AddLocales(_languageService, model.Locales);
return(View(model));
}
public static ProductAvailabilityRange ToEntity(this ProductAvailabilityRangeModel model, ProductAvailabilityRange destination)
{
return(model.MapTo(destination));
}
public static ProductAvailabilityRange ToEntity(this ProductAvailabilityRangeModel model)
{
return(model.MapTo <ProductAvailabilityRangeModel, ProductAvailabilityRange>());
}
protected virtual void UpdateLocales(ProductAvailabilityRange productAvailabilityRange, ProductAvailabilityRangeModel model)
{
foreach (var localized in model.Locales)
{
_localizedEntityService.SaveLocalizedValue(productAvailabilityRange, x => x.Name, localized.Name, localized.LanguageId);
}
}
/// <returns>A task that represents the asynchronous operation</returns>
protected virtual async Task UpdateLocalesAsync(ProductAvailabilityRange productAvailabilityRange, ProductAvailabilityRangeModel model)
{
foreach (var localized in model.Locales)
{
await _localizedEntityService.SaveLocalizedValueAsync(productAvailabilityRange, x => x.Name, localized.Name, localized.LanguageId);
}
}
/// <summary>
/// Prepare product availability range model
/// </summary>
/// <param name="model">Product availability range model</param>
/// <param name="productAvailabilityRange">Product availability range</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Product availability range model</returns>
public virtual ProductAvailabilityRangeModel PrepareProductAvailabilityRangeModel(ProductAvailabilityRangeModel model,
ProductAvailabilityRange productAvailabilityRange, bool excludeProperties = false)
{
Action <ProductAvailabilityRangeLocalizedModel, int> localizedModelConfiguration = null;
if (productAvailabilityRange != null)
{
//fill in model values from the entity
model = model ?? productAvailabilityRange.ToModel();
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Name = productAvailabilityRange.GetLocalized(entity => entity.Name, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare product availability range model
/// </summary>
/// <param name="model">Product availability range model</param>
/// <param name="productAvailabilityRange">Product availability range</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the product availability range model
/// </returns>
public virtual async Task <ProductAvailabilityRangeModel> PrepareProductAvailabilityRangeModelAsync(ProductAvailabilityRangeModel model,
ProductAvailabilityRange productAvailabilityRange, bool excludeProperties = false)
{
Action <ProductAvailabilityRangeLocalizedModel, int> localizedModelConfiguration = null;
if (productAvailabilityRange != null)
{
//fill in model values from the entity
model ??= productAvailabilityRange.ToModel <ProductAvailabilityRangeModel>();
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(productAvailabilityRange, entity => entity.Name, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
