public RequestTokenModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <RequestTokenModelValidator> localizer) : base(validationResultProvider, localizer)
{
CascadeMode = CascadeMode.Stop;
var invalidRequest = OAuthException.InvalidRequest();
RuleFor(request => request.GrantType).NotEmpty()
.WithState(request => invalidRequest);
When(request => request.GrantType == SecurityConsts.GrantTypes.Password, () =>
{
RuleFor(request => request.Username).NotEmpty()
.WithState(request => invalidRequest);
RuleFor(request => request.Password).NotEmpty()
.WithState(request => invalidRequest);
});
When(request => request.GrantType == SecurityConsts.GrantTypes.RefreshToken, () =>
{
RuleFor(request => request.RefreshToken).NotEmpty()
.WithState(request => invalidRequest);
});
}
public RegisterModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <RegisterModelValidator> localizer,
AppEntitySchema entitySchema) : base(validationResultProvider, localizer)
{
var appUserType = typeof(AppUserEntity);
RuleFor(model => model.Username)
.NotEmpty().InvalidState()
.MinimumLength(SecurityConsts.AccountConstraints.UsernameMinLength).InvalidState()
.FollowSchema(entitySchema, appUserType, nameof(AppUserEntity.UserName)).InvalidState();
RuleFor(model => model.Password)
.NotEmpty().InvalidState()
.Length(SecurityConsts.AccountConstraints.PasswordMinLength,
SecurityConsts.AccountConstraints.PasswordMaxLength).InvalidState();
RuleFor(model => model.ConfirmPassword)
.Equal(model => model.Password).WithMessage(localizer[Resources.ConfirmPasswordDoesNotMatch])
.InvalidState();
RuleFor(model => model.FullName)
.FollowSchema(entitySchema, appUserType, nameof(AppUserEntity.FullName)).InvalidState();
RuleFor(model => model.Email)
.EmailAddress().InvalidState()
.FollowSchema(entitySchema, appUserType, nameof(AppUserEntity.Email)).InvalidState();
}
public ChangeSmtpOptionModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <ChangeSmtpOptionModelValidator> localizer) : base(validationResultProvider, localizer)
{
RuleFor(model => model.UserName).NotEmpty()
.WithState(model => ResultCode.Setting_InvalidChangeSmtpOptionRequest);
RuleFor(model => model.Password).NotEmpty()
.WithState(model => ResultCode.Setting_InvalidChangeSmtpOptionRequest);
}
public BaseGetListRequestModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <BaseGetListRequestModelValidator> localizer) : base(validationResultProvider, localizer)
{
RuleFor(request => request.page)
.GreaterThanOrEqualTo(0)
.WithState(request => ResultCode.InvalidPagingRequest);
RuleFor(request => request.pageLimit)
.GreaterThan(0)
.WithState(request => ResultCode.InvalidPagingRequest);
}
public ChangeUserRolesBaseModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <ChangeUserRolesBaseModelValidator> localizer) : base(validationResultProvider, localizer)
{
RuleFor(model => model.Username).NotEmpty()
.WithState(model => ResultCode.Identity_InvalidChangeUserRolesRequest);
RuleFor(model => model.Roles).Cascade(CascadeMode.Stop)
.NotEmpty()
.Must(roles => roles.All(role => RoleName.All.Contains(role)))
.WithMessage(localizer[Message.InvalidRoleName])
.WithState(model => ResultCode.Identity_InvalidChangeUserRolesRequest);
}
public LocalizationModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <Context> localizer) : base(validationResultProvider, localizer)
{
var lang = RuleFor(model => model.Lang).NotEmpty();
lang = HandleEmptyLang(lang).Length(2);
lang = HandleInvalidLangLength(lang);
var region = RuleFor(model => model.Region).NotNull();
region = HandleNullRegion(region).Length(2)
.When(model => !string.IsNullOrEmpty(model.Region), ApplyConditionTo.CurrentValidator);
region = HandleInvalidRegionLength(region);
}
public ChangeUserRolesBaseModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <ChangeUserRolesBaseModelValidator> localizer,
AppEntitySchema entitySchema) : base(validationResultProvider, localizer)
{
RuleFor(model => model.Username).NotEmpty()
.WithState(model => ResultCode.Identity_InvalidChangeUserRolesRequest)
.FollowSchema(entitySchema, typeof(AppUserEntity), nameof(AppUserEntity.UserName))
.WithState(model => ResultCode.Identity_InvalidChangeUserRolesRequest);
RuleFor(model => model.Roles).Cascade(CascadeMode.Stop)
.NotEmpty()
.Must(roles => roles.All(role => RoleName.All.Contains(role)))
.WithMessage(localizer[Resources.InvalidRoleName])
.WithState(model => ResultCode.Identity_InvalidChangeUserRolesRequest);
}
public PostCategoryLocalizationEditableModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <PostCategoryLocalizationEditableModelValidator> localizer,
AppEntitySchema entitySchema) : base(validationResultProvider, localizer)
{
var pcLocalizationType = typeof(PostCategoryLocalizationEntity);
RuleFor(model => model.Title).NotEmpty()
.WithState(model => ResultCode.PostCategory_InvalidCreatePostCategoryRequest)
.FollowSchema(entitySchema, pcLocalizationType, nameof(PostCategoryLocalizationEntity.Title))
.WithState(model => ResultCode.PostCategory_InvalidCreatePostCategoryRequest);
RuleFor(model => model.Description)
.FollowSchema(entitySchema, pcLocalizationType, nameof(PostCategoryLocalizationEntity.Description))
.WithState(model => ResultCode.PostCategory_InvalidCreatePostCategoryRequest);
}
public CreateLocalizedModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <Context> localizer) : base(validationResultProvider, localizer)
{
var list = RuleFor(model => model.ListOfLocalization).NotEmpty();
list = HandleEmptyList(list)
.Must(model =>
{
return(!model.GroupBy(o => new
{
o.Lang,
o.Region
}).Any(group => group.Count() > 1));
});
list = HandleInvalidList(list);
}
public ListAppUserRequestModelValidator(IValidationResultProvider validationResultProvider,
IServiceProvider serviceProvider,
IStringLocalizer <ListAppUserRequestModelValidator> localizer) : base(validationResultProvider, localizer)
{
IncludeBaseValidators(serviceProvider);
When(request => request.GetFieldsArr() != null, () =>
{
RuleForEach(request => request.GetFieldsArr()).Cascade(CascadeMode.Stop)
.Must(field => ListAppUserRequestModel.Projections.ContainsKey(field))
.WithName(BaseListRequestModel.Parameters.Fields)
.WithState(request => ResultCode.InvalidProjectionRequest);
});
When(request => request.GetSortByArr() != null, () =>
{
RuleForEach(request => request.GetSortByArr()).Cascade(CascadeMode.Stop)
.MinimumLength(2)
.Must(field => ListAppUserRequestModel.SortOptions.Contains(field.Substring(1)))
.WithName(BaseListRequestModel.Parameters.SortBy)
.WithState(request => ResultCode.InvalidSortingRequest);
});
}
public RegisterModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <RegisterModelValidator> localizer) : base(validationResultProvider, localizer)
{
RuleFor(model => model.username)
.NotEmpty().MinimumLength(5).MaximumLength(100)
.WithState(model => ResultCode.Identity_InvalidRegisterRequest);
RuleFor(model => model.password)
.NotEmpty().MinimumLength(6).MaximumLength(100)
.WithState(model => ResultCode.Identity_InvalidRegisterRequest);
RuleFor(model => model.confirmPassword)
.Equal(model => model.password).WithMessage(localizer[Message.ConfirmPasswordDoesNotMatch])
.WithState(model => ResultCode.Identity_InvalidRegisterRequest);
RuleFor(model => model.fullName)
.NotEmpty().MaximumLength(100)
.WithState(model => ResultCode.Identity_InvalidRegisterRequest);
RuleFor(model => model.email)
.EmailAddress().MaximumLength(100)
.WithState(model => ResultCode.Identity_InvalidRegisterRequest);
}
public GetAppUserListRequestModelValidator(IValidationResultProvider validationResultProvider,
IServiceProvider serviceProvider,
IStringLocalizer <GetAppUserListRequestModelValidator> localizer) : base(validationResultProvider, localizer)
{
IncludeBaseValidators(serviceProvider);
When(request => request.GetFieldsArr() != null, () =>
{
RuleForEach(request => request.GetFieldsArr())
.Must(field => DynamicQueryAppUserModel.Projections.ContainsKey(field))
.WithName(nameof(GetListAppUsersRequestModel.fields))
.WithState(request => ResultCode.InvalidProjectionRequest);
});
When(request => request.GetSortByArr() != null, () =>
{
RuleForEach(request => request.GetSortByArr())
.MinimumLength(2)
.Must(field => DynamicQueryAppUserModel.SortOptions.Contains(field.Substring(1)))
.WithName(nameof(GetListAppUsersRequestModel.sortBy))
.WithState(request => ResultCode.InvalidSortingRequest);
});
}
public CreatePostCategoryLocalizationModelValidator(IValidationResultProvider validationResultProvider,
IServiceProvider serviceProvider,
IStringLocalizer <CreatePostCategoryLocalizationModelValidator> localizer) : base(validationResultProvider, localizer)
{
IncludeBaseValidators(serviceProvider);
}
protected SafeValidator(IValidationResultProvider validationResultProvider)
{
this.validationResultProvider = validationResultProvider;
validatedObjects = new HashSet <object>();
}
public LocalizedSafeValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <Context> localizer) : base(validationResultProvider)
{
this.localizer = localizer;
}
public PostCategoryEditableModelValidator(IValidationResultProvider validationResultProvider,
IStringLocalizer <PostCategoryEditableModelValidator> localizer) : base(validationResultProvider, localizer)
{
}
