public ScheduleTaskValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.System.ScheduleTasks.Name.Required"));
RuleFor(x => x.Seconds).GreaterThan(0).WithMessageAwait(localizationService.GetResourceAsync("Admin.System.ScheduleTasks.Seconds.Positive"));
SetDatabaseValidationRules <ScheduleTask>(mappingEntityAccessor);
}
public ReviewTypeValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Settings.ReviewType.Fields.Name.Required"));
RuleFor(x => x.Description).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Settings.ReviewType.Fields.Description.Required"));
SetDatabaseValidationRules <ReviewType>(mappingEntityAccessor);
}
public LanguageValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Languages.Fields.Name.Required"));
RuleFor(x => x.LanguageCulture)
.Must(x =>
{
try
{
//let's try to create a CultureInfo object
//if "DisplayLocale" is wrong, then exception will be thrown
var unused = new CultureInfo(x);
return(true);
}
catch
{
return(false);
}
})
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Languages.Fields.LanguageCulture.Validation"));
RuleFor(x => x.UniqueSeoCode).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Languages.Fields.UniqueSeoCode.Required"));
RuleFor(x => x.UniqueSeoCode).Length(2).WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Languages.Fields.UniqueSeoCode.Length"));
SetDatabaseValidationRules <Language>(mappingEntityAccessor, "UniqueSeoCode");
}
public ManufacturerValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Manufacturers.Fields.Name.Required"));
RuleFor(x => x.PageSizeOptions).Must(ValidatorUtilities.PageSizeOptionsValidator).WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Manufacturers.Fields.PageSizeOptions.ShouldHaveUniqueItems"));
RuleFor(x => x.PageSize).Must((x, context) =>
{
if (!x.AllowCustomersToSelectPageSize && x.PageSize <= 0)
{
return(false);
}
return(true);
}).WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Manufacturers.Fields.PageSize.Positive"));
RuleFor(x => x.SeName).Length(0, NopSeoDefaults.SearchEngineNameLength)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.SEO.SeName.MaxLengthValidation"), NopSeoDefaults.SearchEngineNameLength);
RuleFor(x => x.PriceFrom)
.GreaterThanOrEqualTo(0)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Manufacturers.Fields.PriceFrom.GreaterThanOrEqualZero"))
.When(x => x.PriceRangeFiltering && x.ManuallyPriceRange);
RuleFor(x => x.PriceTo)
.GreaterThan(x => x.PriceFrom > decimal.Zero ? x.PriceFrom : decimal.Zero)
.WithMessage(x => string.Format(localizationService.GetResourceAsync("Admin.Catalog.Manufacturers.Fields.PriceTo.GreaterThanZeroOrPriceFrom").Result, x.PriceFrom > decimal.Zero ? x.PriceFrom : decimal.Zero))
.When(x => x.PriceRangeFiltering && x.ManuallyPriceRange);
SetDatabaseValidationRules <Manufacturer>(mappingEntityAccessor);
}
public CurrencyValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name)
.NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Currencies.Fields.Name.Required"))
.Length(1, 50).WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Currencies.Fields.Name.Range"));
RuleFor(x => x.CurrencyCode)
.NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Currencies.Fields.CurrencyCode.Required"))
.Length(1, 5).WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Currencies.Fields.CurrencyCode.Range"));
RuleFor(x => x.Rate)
.GreaterThan(0).WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Currencies.Fields.Rate.Range"));
RuleFor(x => x.CustomFormatting)
.Length(0, 50).WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Currencies.Fields.CustomFormatting.Validation"));
RuleFor(x => x.DisplayLocale)
.Must(x =>
{
try
{
if (string.IsNullOrEmpty(x))
{
return(true);
}
//let's try to create a CultureInfo object
//if "DisplayLocale" is wrong, then exception will be thrown
var unused = new CultureInfo(x);
return(true);
}
catch
{
return(false);
}
})
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Currencies.Fields.DisplayLocale.Validation"));
SetDatabaseValidationRules <Currency>(mappingEntityAccessor);
}
public ForumValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.Forums.Forum.Fields.Name.Required"));
RuleFor(x => x.ForumGroupId).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.Forums.Forum.Fields.ForumGroupId.Required"));
SetDatabaseValidationRules <Forum>(mappingEntityAccessor);
}
public MessageTemplateValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Subject).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.MessageTemplates.Fields.Subject.Required"));
RuleFor(x => x.Body).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.MessageTemplates.Fields.Body.Required"));
SetDatabaseValidationRules <MessageTemplate>(mappingEntityAccessor);
}
public ReturnRequestValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.ReasonForReturn).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.ReasonForReturn.Required"));
RuleFor(x => x.RequestedAction).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.RequestedAction.Required"));
SetDatabaseValidationRules <ReturnRequest>(mappingEntityAccessor);
}
public StoreValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Stores.Fields.Name.Required"));
RuleFor(x => x.Url).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Stores.Fields.Url.Required"));
SetDatabaseValidationRules <Store>(mappingEntityAccessor);
}
public MeasureWeightValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Shipping.Measures.Weights.Fields.Name.Required"));
RuleFor(x => x.SystemKeyword).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Shipping.Measures.Weights.Fields.SystemKeyword.Required"));
SetDatabaseValidationRules <MeasureWeight>(mappingEntityAccessor);
}
public CategoryTemplateValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.System.Templates.Category.Name.Required"));
RuleFor(x => x.ViewPath).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.System.Templates.Category.ViewPath.Required"));
SetDatabaseValidationRules <CategoryTemplate>(mappingEntityAccessor);
}
public EmailAccountValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Email).NotEmpty();
RuleFor(x => x.Email).EmailAddress().WithMessageAwait(localizationService.GetResourceAsync("Admin.Common.WrongEmail"));
RuleFor(x => x.DisplayName).NotEmpty();
SetDatabaseValidationRules <EmailAccount>(mappingEntityAccessor);
}
public GdprConsentValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Message).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Settings.Gdpr.Consent.Message.Required"));
RuleFor(x => x.RequiredMessage)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Settings.Gdpr.Consent.RequiredMessage.Required"))
.When(x => x.IsRequired);
SetDatabaseValidationRules <GdprConsent>(mappingEntityAccessor);
}
public CampaignValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Promotions.Campaigns.Fields.Name.Required"));
RuleFor(x => x.Subject).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Promotions.Campaigns.Fields.Subject.Required"));
RuleFor(x => x.Body).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Promotions.Campaigns.Fields.Body.Required"));
SetDatabaseValidationRules <Campaign>(mappingEntityAccessor);
}
public QueuedEmailValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.From).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.System.QueuedEmails.Fields.From.Required"));
RuleFor(x => x.To).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.System.QueuedEmails.Fields.To.Required"));
RuleFor(x => x.SentTries).NotNull().WithMessageAwait(localizationService.GetResourceAsync("Admin.System.QueuedEmails.Fields.SentTries.Required"))
.InclusiveBetween(0, 99999).WithMessageAwait(localizationService.GetResourceAsync("Admin.System.QueuedEmails.Fields.SentTries.Range"));
SetDatabaseValidationRules <QueuedEmail>(mappingEntityAccessor);
}
public ReturnRequestValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.ReasonForReturn).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.ReasonForReturn.Required"));
RuleFor(x => x.RequestedAction).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.RequestedAction.Required"));
RuleFor(x => x.Quantity).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.Quantity.Required"));
RuleFor(x => x.Quantity).Must((model, value) => value >= model.ReturnedQuantity).WithMessage(model => string.Format(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.Quantity.MustBeEqualOrGreaterThanReturnedQuantityField").Result, model.ReturnedQuantity));
RuleFor(x => x.ReturnedQuantity).GreaterThan(-1).WithMessageAwait(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.ReturnedQuantity.MustBeEqualOrGreaterThanZero"));
RuleFor(x => x.ReturnedQuantity).Must((model, value) => value <= model.Quantity).WithMessage(model => string.Format(localizationService.GetResourceAsync("Admin.ReturnRequests.Fields.ReturnedQuantity.MustBeLessOrEqualQuantityField").Result, model.Quantity));
SetDatabaseValidationRules <ReturnRequest>(mappingEntityAccessor);
}
public ProductReviewValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor, IWorkContext workContext)
{
var isLoggedInAsVendor = workContext.GetCurrentVendorAsync().Result != null;
//vendor can edit "Reply text" only
if (!isLoggedInAsVendor)
{
RuleFor(x => x.Title).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.ProductReviews.Fields.Title.Required"));
RuleFor(x => x.ReviewText).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.ProductReviews.Fields.ReviewText.Required"));
}
SetDatabaseValidationRules <ProductReview>(mappingEntityAccessor);
}
public NewsItemValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Title).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.News.NewsItems.Fields.Title.Required"));
RuleFor(x => x.Short).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.News.NewsItems.Fields.Short.Required"));
RuleFor(x => x.Full).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.News.NewsItems.Fields.Full.Required"));
RuleFor(x => x.SeName).Length(0, NopSeoDefaults.SearchEngineNameLength)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.SEO.SeName.MaxLengthValidation"), NopSeoDefaults.SearchEngineNameLength);
SetDatabaseValidationRules <NewsItem>(mappingEntityAccessor);
}
/// <summary>
/// Sets validation rule(s) to appropriate database model
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <param name="mappingEntityAccessor">An object implements accessor methods to mapped entities</param>
/// <param name="filterStringPropertyNames">Properties to skip</param>
protected virtual void SetDatabaseValidationRules <TEntity>(IMappingEntityAccessor mappingEntityAccessor, params string[] filterStringPropertyNames)
where TEntity : BaseEntity
{
if (mappingEntityAccessor is null)
{
throw new ArgumentNullException(nameof(mappingEntityAccessor));
}
var entityDescriptor = mappingEntityAccessor.GetEntityDescriptor(typeof(TEntity));
SetStringPropertiesMaxLength(entityDescriptor, filterStringPropertyNames);
SetDecimalMaxValue(entityDescriptor);
}
public TopicValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.SeName)
.Length(0, NopSeoDefaults.ForumTopicLength)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.SEO.SeName.MaxLengthValidation"), NopSeoDefaults.ForumTopicLength);
RuleFor(x => x.Password)
.NotEmpty()
.When(x => x.IsPasswordProtected)
.WithMessageAwait(localizationService.GetResourceAsync("Validation.Password.IsNotEmpty"));
SetDatabaseValidationRules <Topic>(mappingEntityAccessor);
}
public PollAnswerValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
//if validation without this set rule is applied, in this case nothing will be validated
//it's used to prevent auto-validation of child models
RuleSet(NopValidationDefaults.ValidationRuleSet, () =>
{
RuleFor(model => model.Name)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.Polls.Answers.Fields.Name.Required"));
SetDatabaseValidationRules <PollAnswer>(mappingEntityAccessor);
});
}
public ProductValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Products.Fields.Name.Required"));
RuleFor(x => x.SeName)
.Length(0, NopSeoDefaults.SearchEngineNameLength)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.SEO.SeName.MaxLengthValidation"), NopSeoDefaults.SearchEngineNameLength);
RuleFor(x => x.RentalPriceLength)
.GreaterThan(0)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Products.Fields.RentalPriceLength.ShouldBeGreaterThanZero"))
.When(x => x.IsRental);
SetDatabaseValidationRules <Product>(mappingEntityAccessor);
}
public LanguageResourceValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
//if validation without this set rule is applied, in this case nothing will be validated
//it's used to prevent auto-validation of child models
RuleSet(NopValidationDefaults.ValidationRuleSet, () =>
{
RuleFor(model => model.ResourceName)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Languages.Resources.Fields.Name.Required"));
RuleFor(model => model.ResourceValue)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Languages.Resources.Fields.Value.Required"));
SetDatabaseValidationRules <LocaleStringResource>(mappingEntityAccessor);
});
}
public BlogPostValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Title)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.Blog.BlogPosts.Fields.Title.Required"));
RuleFor(x => x.Body)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.Blog.BlogPosts.Fields.Body.Required"));
//blog tags should not contain dots
//current implementation does not support it because it can be handled as file extension
RuleFor(x => x.Tags)
.Must(x => x == null || !x.Contains("."))
.WithMessageAwait(localizationService.GetResourceAsync("Admin.ContentManagement.Blog.BlogPosts.Fields.Tags.NoDots"));
RuleFor(x => x.SeName).Length(0, NopSeoDefaults.SearchEngineNameLength)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.SEO.SeName.MaxLengthValidation"), NopSeoDefaults.SearchEngineNameLength);
SetDatabaseValidationRules <BlogPost>(mappingEntityAccessor);
}
public CountryValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Countries.Fields.Name.Required"));
RuleFor(p => p.Name).Length(1, 100);
RuleFor(x => x.TwoLetterIsoCode)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Countries.Fields.TwoLetterIsoCode.Required"));
RuleFor(x => x.TwoLetterIsoCode)
.Length(2)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Countries.Fields.TwoLetterIsoCode.Length"));
RuleFor(x => x.ThreeLetterIsoCode)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Countries.Fields.ThreeLetterIsoCode.Required"));
RuleFor(x => x.ThreeLetterIsoCode)
.Length(3)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Configuration.Countries.Fields.ThreeLetterIsoCode.Length"));
SetDatabaseValidationRules <Country>(mappingEntityAccessor);
}
public ProductAttributeValueModelValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Products.ProductAttributes.Attributes.Values.Fields.Name.Required"));
RuleFor(x => x.Quantity)
.GreaterThanOrEqualTo(1)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Products.ProductAttributes.Attributes.Values.Fields.Quantity.GreaterThanOrEqualTo1"))
.When(x => x.AttributeValueTypeId == (int)AttributeValueType.AssociatedToProduct && !x.CustomerEntersQty);
RuleFor(x => x.AssociatedProductId)
.GreaterThanOrEqualTo(1)
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Products.ProductAttributes.Attributes.Values.Fields.AssociatedProduct.Choose"))
.When(x => x.AttributeValueTypeId == (int)AttributeValueType.AssociatedToProduct);
SetDatabaseValidationRules <ProductAttributeValue>(mappingEntityAccessor);
}
public CustomerValidator(CustomerSettings customerSettings,
ICustomerService customerService,
ILocalizationService localizationService,
IMappingEntityAccessor mappingEntityAccessor,
IStateProvinceService stateProvinceService)
{
//ensure that valid email address is entered if Registered role is checked to avoid registered customers with empty email address
RuleFor(x => x.Email)
.NotEmpty()
.EmailAddress()
//.WithMessage("Valid Email is required for customer to be in 'Registered' role")
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Common.WrongEmail"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
//form fields
if (customerSettings.CountryEnabled && customerSettings.CountryRequired)
{
RuleFor(x => x.CountryId)
.NotEqual(0)
.WithMessageAwait(localizationService.GetResourceAsync("Account.Fields.Country.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.CountryEnabled &&
customerSettings.StateProvinceEnabled &&
customerSettings.StateProvinceRequired)
{
RuleFor(x => x.StateProvinceId).MustAwait(async(x, context) =>
{
//does selected country have states?
var hasStates = (await stateProvinceService.GetStateProvincesByCountryIdAsync(x.CountryId)).Any();
if (hasStates)
{
//if yes, then ensure that a state is selected
if (x.StateProvinceId == 0)
{
return(false);
}
}
return(true);
}).WithMessageAwait(localizationService.GetResourceAsync("Account.Fields.StateProvince.Required"));
}
if (customerSettings.CompanyRequired && customerSettings.CompanyEnabled)
{
RuleFor(x => x.Company)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.Company.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.StreetAddressRequired && customerSettings.StreetAddressEnabled)
{
RuleFor(x => x.StreetAddress)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.StreetAddress.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.StreetAddress2Required && customerSettings.StreetAddress2Enabled)
{
RuleFor(x => x.StreetAddress2)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.StreetAddress2.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.ZipPostalCodeRequired && customerSettings.ZipPostalCodeEnabled)
{
RuleFor(x => x.ZipPostalCode)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.ZipPostalCode.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.CityRequired && customerSettings.CityEnabled)
{
RuleFor(x => x.City)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.City.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.CountyRequired && customerSettings.CountyEnabled)
{
RuleFor(x => x.County)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.County.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.PhoneRequired && customerSettings.PhoneEnabled)
{
RuleFor(x => x.Phone)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.Phone.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
if (customerSettings.FaxRequired && customerSettings.FaxEnabled)
{
RuleFor(x => x.Fax)
.NotEmpty()
.WithMessageAwait(localizationService.GetResourceAsync("Admin.Customers.Customers.Fields.Fax.Required"))
//only for registered users
.WhenAwait(async x => await IsRegisteredCustomerRoleCheckedAsync(x, customerService));
}
SetDatabaseValidationRules <Customer>(mappingEntityAccessor);
}
public NewsLetterSubscriptionValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Email).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Promotions.NewsLetterSubscriptions.Fields.Email.Required"));
RuleFor(x => x.Email).EmailAddress().WithMessageAwait(localizationService.GetResourceAsync("Admin.Common.WrongEmail"));
SetDatabaseValidationRules <NewsLetterSubscription>(mappingEntityAccessor);
}
public SpecificationAttributeOptionValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Catalog.Attributes.SpecificationAttributes.SpecificationAttribute.Options.Fields.Name.Required"));
SetDatabaseValidationRules <SpecificationAttributeOption>(mappingEntityAccessor);
}
public VendorAttributeValidator(ILocalizationService localizationService, IMappingEntityAccessor mappingEntityAccessor)
{
RuleFor(x => x.Name).NotEmpty().WithMessageAwait(localizationService.GetResourceAsync("Admin.Vendors.VendorAttributes.Fields.Name.Required"));
SetDatabaseValidationRules <VendorAttribute>(mappingEntityAccessor);
}