/// <summary>
/// 设置验证处理器，默认是用ValidationHandler，已在初始化基类的时候实例化了
/// </summary>
/// <param name="handler"></param>
public void SetValidationHandler(IValidationHandler handler)
{
if (handler != null)
{
_handler = handler;
}
}
public App(ILog logger, IDataHandler dataHandler, IValidationHandler rowValidator, ISerializeObjects objectSerializer)
{
this.logger = logger;
this.dataHandler = dataHandler;
this.validationHandler = rowValidator;
this.objectSerializer = objectSerializer;
}
public void UserCreateTest()
{
using (var lifetime = container.BeginLifetimeScope())
{
DefaultCommandBus commandBus = lifetime.Resolve <DefaultCommandBus>();
IMappingEngine mapper = lifetime.Resolve <IMappingEngine>();
User user = new User()
{
FirstName = "Test",
LastName = "User",
Email = "*****@*****.**",
DateCreated = DateTime.Now,
RoleId = 1,
Activated = true
};
UserRegisterCommand command = mapper.Map <UserRegisterCommand>(user);
command.Password = "******";
IValidationHandler <UserRegisterCommand> validationHandler = lifetime.Resolve <IValidationHandler <UserRegisterCommand> >();
IEnumerable <ValidationResult> validations = commandBus.Validate(command, validationHandler);
foreach (var val in validations)
{
Assert.IsNull(val, "Error: User creation did not validate " + val.Message);
}
ICommandHandler <UserRegisterCommand> commnadHandler = lifetime.Resolve <ICommandHandler <UserRegisterCommand> >();
ICommandResult result = commandBus.Submit(command, commnadHandler);
Assert.IsNotNull(result, "Error: User was not created by CommandBus");
Assert.IsTrue(result.Success, "Error: User was not created by CommandBus");
}
}
public void CategoryCreateTest()
{
using (var lifetime = container.BeginLifetimeScope())
{
ICategoryRepository categoryRepository = lifetime.Resolve <ICategoryRepository>();
DefaultCommandBus commandBus = lifetime.Resolve <DefaultCommandBus>();
IMappingEngine mapper = lifetime.Resolve <IMappingEngine>();
Category category = new Category()
{
Name = "Test Category",
Description = "This is a test category"
};
CreateOrUpdateCategoryCommand command = mapper.Map <CreateOrUpdateCategoryCommand>(category);
IValidationHandler <CreateOrUpdateCategoryCommand> validationHandler = lifetime.Resolve <IValidationHandler <CreateOrUpdateCategoryCommand> >();
IEnumerable <ValidationResult> validations = commandBus.Validate(command, validationHandler);
foreach (var val in validations)
{
Assert.IsNull(val, "Error: Category creation did not validate " + val.Message);
}
ICommandHandler <CreateOrUpdateCategoryCommand> commnadHandler = lifetime.Resolve <ICommandHandler <CreateOrUpdateCategoryCommand> >();
ICommandResult result = commandBus.Submit(command, commnadHandler);
Assert.IsNotNull(result, "Error: Category was not created by commandBus");
Assert.IsTrue(result.Success, "Error: Category was not created by commandBus");
}
}
public CreateCustomerValidationDecorator(
ICommandHandlerAsync <CreateCustomerCommand> commandHandler,
IValidationHandler <CreateCustomerCommand> validationHandler)
{
_commandHandler = commandHandler;
_validationHandler = validationHandler;
}
public async Task <IValidationResult> ValidateAsync <TModel>(TModel model)
{
IValidatableModel validatable = model as IValidatableModel;
if (validatable != null)
{
if (validatable.IsValid != null)
{
return(new ValidationResult(validatable.IsValid.Value));
}
}
Type modelType = typeof(TModel);
object validationHandler;
if (TryGetValidationHandler(modelType, out validationHandler))
{
IValidationHandler <TModel> validator = (IValidationHandler <TModel>)validationHandler;
IValidationResult result = await validator.HandleAsync(model);
if (validatable != null)
{
validatable.IsValid = result.IsValid;
}
return(result);
}
return(ProcessMissingHandler(model));
}
public CommandResult Dispatch <TParameter>(TParameter command) where TParameter : class, ICommand
{
ICommandHandler <TParameter> commandHandler = null;
IValidationHandler <TParameter> vlidationHandler = null;
commandHandler = this.context.Resolve <ICommandHandler <TParameter> >();
try
{
vlidationHandler = this.context.Resolve <IValidationHandler <TParameter> >();
}
catch (Exception) { }
if (vlidationHandler != null)
{
ValidationResult validationResult = vlidationHandler.Validate(command);
if (!string.IsNullOrEmpty(validationResult.Message))
{
return new CommandResult {
Success = false, Message = validationResult.Message
}
}
;
}
return(commandHandler.Execute(command));
}
}
public void UserChangePasswordTest()
{
using (var lifetime = container.BeginLifetimeScope())
{
IUserRepository userRepository = lifetime.Resolve <IUserRepository>();
DefaultCommandBus commandBus = lifetime.Resolve <DefaultCommandBus>();
User user = userRepository.Get(c => c.Email == "*****@*****.**");
Assert.IsNotNull(user, "Error: User was not found");
ChangePasswordCommand command = new ChangePasswordCommand();
command.UserId = user.UserId;
command.OldPassword = "******";
command.NewPassword = "******";
IValidationHandler <ChangePasswordCommand> validationHandler = lifetime.Resolve <IValidationHandler <ChangePasswordCommand> >();
IEnumerable <ValidationResult> validations = commandBus.Validate(command, validationHandler);
foreach (var val in validations)
{
Assert.IsNull(val, "Error: User password change did not validate " + val.Message);
}
ICommandHandler <ChangePasswordCommand> commnadHandler = lifetime.Resolve <ICommandHandler <ChangePasswordCommand> >();
ICommandResult result = commandBus.Submit(command, commnadHandler);
Assert.IsNotNull(result, "Error: User password change did not work");
Assert.IsTrue(result.Success, "Error: User password change did not work");
}
}
/// <summary>
/// Creates a new instance which uses <paramref name="validationHandler"/> to validate all incoming commands.
/// </summary>
/// <param name="validationHandler">A validation handler used for validating commands.</param>
/// <param name="innerHandler">An inner (real) commands handler for validated commands handling.</param>
public ValidationCommandHandler(IValidationHandler <T> validationHandler, ICommandHandler <T> innerHandler)
{
Ensure.NotNull(validationHandler, "validationHandler");
Ensure.NotNull(innerHandler, "innerHandler");
this.validationHandler = validationHandler;
this.innerHandler = innerHandler;
}
public IEnumerable <ValidationResult> Validate <TCommand>(TCommand command)
where TCommand : ICommand
{
IValidationHandler <TCommand> handler = container.GetInstance <IValidationHandler <TCommand> >();
return(handler.Validate(command));
}
public IValidationHandlerCollection Add <TModel>(IValidationHandler <TModel> handler)
{
Ensure.NotNull(handler, "handler");
Type modelType = typeof(TModel);
storage[modelType] = new DefaultValidationHandlerDefinition(handler, model => handler.HandleAsync((TModel)model));
return(this);
}
protected DefaultEditorConfiguration()
{
#if CREATOR_PRO
Validation = new DefaultValidationHandler();
#else
Validation = new DisabledValidationHandler();
#endif
}
/// <summary>
/// 设置验证处理器
/// </summary>
/// <param name="handler">验证处理器</param>
public void SetValidationHandler(IValidationHandler handler)
{
if (handler == null)
{
return;
}
_handler = handler;
}
public LsControllerActionInvoker(
IValidation validation,
IValidationHandler validatorHandler,
IPermissionValidator permissionValidator)
{
_validation = validation;
_validatorHandler = validatorHandler;
_permissionValidator = permissionValidator;
}
public AltinnApp(
IAppResources appResourcesService,
ILogger <AltinnApp> logger,
IData dataService,
IProcess processService,
IValidationHandler validationHandler) : base(appResourcesService, logger, dataService, processService)
{
_validationHandler = validationHandler;
}
public BaseCommand(IUser author, IConfiguration config, IMessageChannel channel,
IMessageWriter messageWriter, IValidationHandler validationHandler, params string[] parameters)
{
Parameters = parameters;
Author = author;
Channel = channel;
_config = config;
_messageWriter = messageWriter;
_validationHandler = validationHandler;
}
public static ValidationHandleOperation HandleForStrategy(this ValidationHandleOperation op, string name,
IValidationHandler handler)
{
op.CheckNull(nameof(op));
handler.CheckNull(nameof(handler));
op.Handle(handler, name);
return(op);
}
public CommandBuilder(IConfiguration config, IMessageWriter messageWriter, ICommandsInfo commandsInfo,
IConnectionHandler connectionHandler, IAudioService audioService, IValidationHandler validationHandler)
{
_config = config;
_messageWriter = messageWriter;
_commandsInfo = commandsInfo;
_connectionHandler = connectionHandler;
_audioService = audioService;
_validationHandler = validationHandler;
}
public IEnumerable <ValidationResult> Validate <TCommand>(TCommand command)
where TCommand : ICommand
{
IValidationHandler <TCommand> handler = DependencyResolver.Current.GetService <IValidationHandler <TCommand> >();
if (!((handler != null) && handler is IValidationHandler <TCommand>))
{
throw new ValidationHandlerNotFoundException(typeof(TCommand));
}
return(handler.Validate(command));
}
internal void Handle(IValidationHandler handler, string strategyName)
{
handler.CheckNull(nameof(handler));
var coll = _collection.Filter(strategyName);
if (coll == null)
{
return;
}
handler.Handle(coll);
}
internal void Handle(IValidationHandler handler, Action <IEnumerable <ValidationResult> > filterFunc = null)
{
handler.CheckNull(nameof(handler));
var coll = filterFunc == null ? _collection : _collection.Filter(filterFunc);
if (coll == null)
{
return;
}
handler.Handle(coll);
}
public async Task <IValidationResult> ValidateAsync <TModel>(TModel model)
{
Type modelType = typeof(TModel);
object validationHandler;
if (TryGetValidationHandler(modelType, out validationHandler))
{
IValidationHandler <TModel> validator = (IValidationHandler <TModel>)validationHandler;
IValidationResult result = await validator.HandleAsync(model);
return(result);
}
return(ProcessMissingHandler(model));
}
internal void Handle(IValidationHandler handler, string strategyName)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
var coll = _collection.Filter(strategyName);
if (coll == null)
{
return;
}
handler.Handle(coll);
}
internal void Handle(IValidationHandler handler, Action <IEnumerable <ValidationResult> > filterFunc = null)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
var coll = filterFunc == null ? _collection : _collection.Filter(filterFunc);
if (coll == null)
{
return;
}
handler.Handle(coll);
}
public override void Draw()
{
EditorDrawingHelper.DrawRoundedRect(Owner.BoundingBox, CurrentColor, 10f);
IValidationHandler validation = EditorConfigurator.Instance.Validation;
if (validation.IsAllowedToValidate())
{
IContextResolver resolver = validation.ContextResolver;
IContext context = resolver.FindContext(Owner.Step.Data, GlobalEditorHandler.GetCurrentCourse());
if (validation.LastReport != null)
{
List <EditorReportEntry> errors = validation.LastReport.GetEntriesFor(context);
if (errors.Count > 0)
{
string tooltip = ValidationTooltipGenerator.CreateStepTooltip(errors,
resolver.FindContext(Owner.ActiveChapter.Data, GlobalEditorHandler.GetCurrentCourse()));
GUIContent content = new GUIContent("", null, tooltip);
Rect rect = new Rect(Owner.BoundingBox.x + Owner.BoundingBox.width * 0.70f, Owner.BoundingBox.y - 8, 16, 16);
// Label icons are too small so we draw a label for the tool tip and icon separated.
GUI.Label(rect, content);
GUI.DrawTexture(rect, EditorGUIUtility.IconContent("Warning").image);
}
}
}
float labelX = Owner.BoundingBox.x + labelBorderOffsetInwards;
float labelY = Owner.BoundingBox.y + labelBorderOffsetInwards;
float labelWidth = Owner.BoundingBox.width - labelBorderOffsetInwards * 2f;
float labelHeight = Owner.BoundingBox.height - labelBorderOffsetInwards * 2f;
Rect labelPosition = new Rect(labelX, labelY, labelWidth, labelHeight);
GUIStyle labelStyle = new GUIStyle
{
alignment = TextAnchor.MiddleCenter,
normal = { textColor = TextColor },
wordWrap = false,
};
string name = EditorDrawingHelper.TruncateText(Owner.Step.Data.Name, labelStyle, labelPosition.width);
GUIContent labelContent = new GUIContent(name);
GUI.Label(labelPosition, labelContent, labelStyle);
}
public async Task <ValidationResult> ValidateAsync <TCommand>(TCommand command) where TCommand : ICommand
{
IValidationHandler <TCommand> handler = null;
try
{
handler = ioCContainer.GetInstance <IValidationHandler <TCommand> >();
if (!((handler != null) && handler is IValidationHandler <TCommand>))
{
throw new ValidationHandlerNotFoundException(typeof(TCommand));
}
return(handler.Validate(command));
}
catch (StructureMapConfigurationException)
{
throw new ValidationHandlerNotFoundException(typeof(TCommand));
}
}
public ValidationResult Validate <TDomainModel>(TDomainModel validate) where TDomainModel : IDomainModel
{
IValidationHandler <TDomainModel> handler = null;
try
{
handler = ioCContainer.GetInstance <IValidationHandler <TDomainModel> >();
if (!((handler != null) && handler is IValidationHandler <TDomainModel>))
{
throw new Exception(string.Format("Validation handler not found for command type: {0}", typeof(TDomainModel)));
}
return(handler.Validate(validate));
}
catch (StructureMapConfigurationException ex)
{
return(new ValidationResult());
//throw new Exception(string.Format("Validation handler not found for command type: {0}", typeof(TDomainModel)));
}
}
public bool TryGet <TModel>(out IValidationHandler <TModel> handler)
{
Type modelType = typeof(TModel);
DefaultValidationHandlerDefinition definition;
if (storage.TryGetValue(modelType, out definition))
{
handler = (IValidationHandler <TModel>)definition.ValidationHandler;
return(true);
}
object rawHandler;
if (onSearchHandler.TryExecute(modelType, out rawHandler))
{
handler = definition.ValidationHandler as IValidationHandler <TModel>;
return(handler != null);
}
handler = null;
return(false);
}
public void CategoryUpdateTest()
{
Category category;
using (var lifetime = container.BeginLifetimeScope())
{
ICategoryRepository categoryRepository = lifetime.Resolve <ICategoryRepository>();
DefaultCommandBus commandBus = lifetime.Resolve <DefaultCommandBus>();
IMappingEngine mapper = lifetime.Resolve <IMappingEngine>();
category = categoryRepository.Get(c => c.Name == "Test Category");
Assert.IsNotNull(category, "Error: Category was now found.");
category.Name = "Updated Test Category";
CreateOrUpdateCategoryCommand command = mapper.Map <CreateOrUpdateCategoryCommand>(category);
IValidationHandler <CreateOrUpdateCategoryCommand> validationHandler = lifetime.Resolve <IValidationHandler <CreateOrUpdateCategoryCommand> >();
IEnumerable <ValidationResult> validations = commandBus.Validate(command, validationHandler);
foreach (var val in validations)
{
Assert.IsNull(val, "Error: Category creation did not validate " + val.Message);
}
}
using (var lifetime = container.BeginLifetimeScope())
{
DefaultCommandBus commandBus = lifetime.Resolve <DefaultCommandBus>();
IMappingEngine mapper = lifetime.Resolve <IMappingEngine>();
CreateOrUpdateCategoryCommand command = mapper.Map <CreateOrUpdateCategoryCommand>(category);
ICommandHandler <CreateOrUpdateCategoryCommand> commnadHandler = lifetime.Resolve <ICommandHandler <CreateOrUpdateCategoryCommand> >();
ICommandResult result = commandBus.Submit(command, commnadHandler);
Assert.IsNotNull(result, "Error: Category was not updated by CommandBus");
Assert.IsTrue(result.Success, "Error: Provincia was not updated by CommandBus");
}
}
public ValidationBehaviour(ILogger <ValidationBehaviour <TRequest, TResponse> > logger, IValidationHandler <TRequest> validationHandler)
{
this.logger = logger;
this.validationHandler = validationHandler;
}
/// <summary>
/// 设置验证处理器
/// </summary>
/// <param name="handler">验证处理器</param>
public void SetValidationHandler( IValidationHandler handler ) {
if ( handler == null )
return;
_handler = handler;
}
