public IValidator Create(IValidatorInstance validatorInstance)
        {
            BillingValidatorSettings settings = (BillingValidatorSettings)this._validatorInstances[validatorInstance];

            if (settings == null)
            {
                throw new Exception(string.Format("Billing Validator Instance not found: {0}", validatorInstance.Name));
            }

            log.Debug("BillingValidator: Creating BillingValidator ValidatorInstance  Name: {name}  Description: {description}", validatorInstance.Name, validatorInstance.Description);

            return(this._childKernel.Get <BillingRanValidator>(new ConstructorArgument(BillingRanValidator.BillingSettingsConstructorParameterName, settings)));
        }
        private void VerifyScheduleRequestValidity(IEnumerable <IScheduleRequest> scheduleRequests)
        {
            foreach (var scheduleRequest in scheduleRequests)
            {
                IValidatorProxy    proxy    = this._validatorProvider.GetValidatorProxy(scheduleRequest.ValidatorId);
                IValidatorInstance instance = this._validatorProvider.GetValidatorInstance(scheduleRequest.ValidatorId, scheduleRequest.ValidatorInstanceId);

                bool jobExists = this._validationScheduler.IsValidationScheduled(proxy.ValidatorId, instance.ValidatorInstanceId);

                if (jobExists)
                {
                    throw new Exception(string.Format("Validation already scheduled for validator instance {0}", scheduleRequest.ValidatorInstanceId));
                }
            }
        }
Exemple #3
0
        private List <IValidatorRunEntry> RunValidatorInstance(ValidatorInstanceInfo info)
        {
            var             startTime      = DateTime.Now;
            IValidatorProxy validatorProxy = null;

            try
            {
                validatorProxy = _validatorProvider.GetValidatorProxy(info.ValidatorId);
                IValidatorInstance validatorInstance = _validatorProvider.GetValidatorInstance(info.ValidatorId, info.ValidatorInstanceId);

                log.Debug("Validator: {ValidatorId}  Version:  {ValidatorVersion}{NewLine}   Description:  {Description}", validatorProxy.ValidatorId, validatorProxy.Version.ToString(), Environment.NewLine, validatorProxy.Description);
                log.Debug("ValidatorInstance: {Name}  Description: {Description} beginning to validate.", validatorInstance.Name, validatorInstance.Description);

                IValidator               validator = validatorProxy.Create(validatorInstance);
                IValidatorContext        vc        = new ValidatorContext();
                IList <IValidatorResult> results   = validator.Execute(vc);

                var endTime = DateTime.Now;

                log.Debug("ValidatorInstance: {Name} finished validating. Start: {start}  End: {end}", validatorInstance.Name, startTime.ToString(), endTime.ToString());
                log.Debug("ValidatorInstance: {Name} returned {resultCount} results.", validatorInstance.Name, results.Count);

                List <IValidatorRunEntry> runEntries = results.Select(x =>
                                                                      new ValidatorRunEntry(startTime, endTime, x, validator.FilterSequence)
                {
                } as IValidatorRunEntry).ToList();

                return(runEntries);
            }
            catch (Exception ex)
            {
                log.Error(ex, "{ValidatorProxy} execution caused Error: {Message}", validatorProxy.ValidatorId, ex.Message);

                var vr = new ValidatorResult(validatorProxy.ValidatorId, ex.Message, ValidatorResultCode.Error, UnhandledExceptionResultCode);

                var vre = new ValidatorRunEntry(startTime, DateTime.Now, vr);

                return(new List <IValidatorRunEntry>()
                {
                    vre
                });
            }
        }
        public IValidator Create(IValidatorInstance validatorInstance)
        {
            Guard.NotNull(validatorInstance, "validatorInstance", log);

            log.Info("RabbitMQValidatorProxy create validator instance for {Name}", validatorInstance.Name);

            if (this._validatorInstances == null)
            {
                throw new Exception(string.Format("ValidatorInstance Dictionary was null - GetAvailableValidators not called: {0}", validatorInstance.Name));
            }

            RabbitMQValidatorSettings settings = (RabbitMQValidatorSettings)this._validatorInstances[validatorInstance];

            if (settings == null)
            {
                throw new Exception(string.Format("RabbitMQ Validator Instance not found: {0}", validatorInstance.Name));
            }

            return(this._childKernel.Get <RabbitMQErrorValidator>(new ConstructorArgument(RabbitMQErrorValidator.RabbitMQValidatorSettingsParamName, settings)));
        }
        public IValidator Create(IValidatorInstance validatorInstance)
        {
            Guard.NotNull(validatorInstance, "validatorInstance", log);

            return(this._childKernel.Get <TemplateTestValidator>());
        }
        public IValidator Create(IValidatorInstance validatorInstance)
        {
            Guard.NotNull(validatorInstance, "validatorInstance", log);

            return(this._childKernel.Get <ResultAlwaysErrorValidator>());
        }
Exemple #7
0
        public IValidator Create(IValidatorInstance validationInstance)
        {
            TestValidatorSettings testValidatorSettings = new TestValidatorSettings();

            return(new TestValidator(testValidatorSettings));
        }