public void RubberStamp_ValidationRule_When_Valid_AfterCondition_WithValidation_Test()
{
var rule = new ValidationRule <TestClass, string>(r => r.Name)
.AddCondition(new IsEqualCondition <TestClass, string>(i => i.Firstname, "Tester"))
.When(r => r.Firstname != null);
var result = rule.Validate(new TestClass());
Assert.That(result, Is.Null);
}
public ValidationRule <Order> RuleCustomersCannotHaveMoreThanFiveOrdersAMonth()
=>
ValidationRule.NewRule <Order>()
.OnlyCheckIf(order => !order.OrderId.HasValue)
.ValidIf(order =>
{
var orders = _orderRepository.GetOrdersForCustomerForMonth(order.CustomerId, order.OrderDateTime);
return(orders.Count() < 5);
})
.SetErrorMessage("Customers can only place 5 orders a month.");
private static IValidationRuleSet GetValidationRules()
{
var sameInformationAuthorityRule = new ValidationRule <Order>(
OrderRules.VisitAndPerformingFacilitiesHaveSameInformationAuthority);
return(new ValidationRuleSet(new[]
{
sameInformationAuthorityRule
}));
}
public void Validate_Returns_True_When_Specification_Returns_True()
{
ISpecification<object> mockSpecification = MockRepository.GenerateMock<ISpecification<object>>();
mockSpecification.Expect(x => x.IsSatisfiedBy(null))
.IgnoreArguments()
.Return(true);
ValidationRule<object> rule = new ValidationRule<object>(mockSpecification, "Error message", "Property");
Assert.That(rule.Validate(new object()));
}
private void propertyGrid1_PropertyValueChanged(object s, System.Windows.Forms.PropertyValueChangedEventArgs e)
{
ValidationRule vr = this.propertyGrid1.SelectedObject as ValidationRule;
Control ctrl = this._ValidationComponents[this.ControlsDropDownList.SelectedItem] as Control;
if (vr != null && ctrl != null & vr.IsRequired == true && !ctrl.Text.Equals(string.Empty) && !ctrl.Text.Equals(vr.InitialValue))
{
vr.InitialValue = ctrl.Text;
}
}
/// <summary>
/// Adds the errortypes to the rule with the specified checkType and the notEntered-errorType
/// </summary>
public void AddErrorTypes(ValidationRule rule, string checkType)
{
foreach (var et in _errorTypes.Where(et => et.Check_Type == checkType))
{
rule.Errortypes.Add(et);
}
var notEntered = _errorTypes.Single(et => et.Check_Type == "Common" && et.Description == "not entered");
rule.Errortypes.Add(notEntered);
}
/// <summary>
/// Sets the validation rule that is used for this argument.
/// Validation rules verify the input is valid.
/// </summary>
/// <example>
/// <c>Argument.Create("email").SetValidator(Argument.ValidationRule.Email))</c>
/// This will cause the email argument to only allow valid emails.
/// Custom validators can also be created.
/// </example>
/// <remarks>
/// ValidationRules are run when the command is parsed, while <c>CanExecute</c> on the <c>Command</c> object verifies a command can run.
/// </remarks>
/// <param name="rule">Represents a rule to validate an argument value on.</param>
public Argument SetValidator(ValidationRule rule)
{
if (rule == null)
{
throw new ArgumentNullException("rule");
}
Rule = rule;
return(this);
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
return(ValidationRules.Validate(validationContext,
new PostalCodeRule(PostalCode, Country, nameof(PostalCode), nameof(Country)),
ValidationRule.For(
(cxt) => cxt.GetSevice <AddressService>()?.PostalCodeExists(PostalCode),
() => "Postal code does not exist.",
nameof(PostalCode))));
}
public void Validation_Validate()
{
WorkerResult result = new WorkerResult()
{
ReturnID = 123
};
ValidationRule <WorkerResult> rule = new ValidationRule <WorkerResult>("ReturnID", x => x.ReturnID > 0);
Assert.IsTrue(rule.Validate(result) == true, "Did not work");
}
public void DoesAddingANewValidationRuleIncrementListCount()
{
var ruleSet = new StringTestSubjectRules();
var rule = new ValidationRule <StringTestSubject>(x => !String.IsNullOrEmpty(x.TestString1), "Rule");
var count = ruleSet.ValidationRules.Count;
var newCount = ruleSet.AddRule(rule);
Assert.AreEqual(count + 1, newCount);
}
public IEnumerable <ValidationResult> Validate(ValidationRule rule)
{
if (rule.Object is TextBox)
{
yield return(new ValidationResult(rule, ValidationHelper.Range(
decimal.Parse(ValidationHelper.GetValue(rule.Object, Members.Text).ToString()),
decimal.Parse(rule.Criteria.ToString()),
decimal.Parse(rule.SecondCriteria.ToString()))));
}
}
/// <summary>
/// When implemented in a derived class, returns metadata for client validation.
/// </summary>
/// <returns>
/// The metadata for client validation.
/// </returns>
public override IEnumerable <ModelClientValidationRule> GetClientValidationRules()
{
string message = ValidationRule.GetValidationMessage(Metadata.Model);
yield return(new ModelClientValidationRule
{
ValidationType = "email",
ErrorMessage = message
});
}
public void ApplyRuleToSubFieldOrPropertyToAndFromJson()
{
var rule = new ValidationRule <Game>
{
OperatorToUse = "GreaterThan",
ValueToValidateAgainst = new ConstantRule <int> {
Value = "3"
},
ObjectToValidate = "Name.Length",
RuleError = new RuleError {
Code = "c1", Message = "Name length must be greater than 3"
}
};
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var validationResult = rule.IsValid(_game);
validationResult.Should().BeTrue();
var someGameWithShortName = new Game {
Name = "foo"
};
validationResult = rule.IsValid(someGameWithShortName);
validationResult.Should().BeFalse();
_testOutputHelper.WriteLine($"with {nameof(someGameWithShortName.Name)}={someGameWithShortName.Name} " +
$"{nameof(rule)} failed. " +
$"Error code={rule.RuleError.Code}, " +
$"message={rule.RuleError.Message}");
// convert to json
var ruleJson = JsonConvert.SerializeObject(rule, new JsonConverterForRule());
_testOutputHelper.WriteLine($"{nameof(ruleJson)}:{Environment.NewLine}{ruleJson}");
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <ValidationRule <Game> >(ruleJson, new JsonConverterForRule());
compileResult = ruleFromJson.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleFromJson)}:{Environment.NewLine}" +
$"{ruleFromJson.ExpressionDebugView()}");
var validationResult2 = ruleFromJson.IsValid(_game);
validationResult2.Should().BeTrue();
validationResult2 = ruleFromJson.IsValid(new Game {
Name = "foo"
});
validationResult2.Should().BeFalse();
}
internal static ValidationAttribute BuildValidation(Rule cfg, ValidationRule svc)
{
var validation = GetValidationAttribute(cfg, svc);
if (!IsDefaultError(cfg))
{
validation.ErrorMessage = cfg.ErrorMessage;
}
return(validation);
}
private void AddStringLengthRule(IFieldDefinition <T> definition, IFieldConfiguration <T> configuration, ValidationPropertyInfo validationProperty)
{
if (configuration.ValueInteger.HasValue)
{
var ruleName = configuration.ConfigurationType == FieldConfigurationType.MinLength ? "MinLength" : "MaxLength";
var rule = new ValidationRule {
Rule = ruleName, Value = configuration.ValueInteger.Value
};
validationProperty.Rules.Add(rule);
}
}
public void Validation_Integration_ValidationRule_SmallerThan_Test()
{
var rule = new ValidationRule <TestClass, int>(i => i.Index)
.AddCondition(new LessThanCondition <TestClass, int>(1));
var result = rule.Validate(new TestClass {
Index = 5
});
Assert.IsNotNull(result);
}
public RowValidationError(
ValidationRule ruleInError,
Row rowInError,
object errorContent,
Exception exception)
{
m_ruleInError = ruleInError;
m_rowInError = rowInError;
m_errorContent = errorContent;
m_exception = exception;
}
public void Validation_Integration_ValidationRule_Null_Valid_Test()
{
var rule = new ValidationRule <TestClass, string>(i => i.Name)
.AddCondition(new IsNotNullCondition <TestClass, string>());
var result = rule.Validate(new TestClass {
Name = "Test"
});
Assert.IsNull(result);
}
public void Validation_Integration_ValidationRule_GreaterThan_Valid_Test()
{
var rule = new ValidationRule <TestClass, int>(i => i.Index)
.AddCondition(new GreaterThanCondition <TestClass, int>(t => t.Index, 1));
var result = rule.Validate(new TestClass {
Index = 5
});
Assert.IsNull(result);
}
private void ControlsDropDownList_SelectedIndexChanged(object sender, System.EventArgs e)
{
this.NewButton.Enabled = (this.ControlsDropDownList.SelectedItem != null);
this.SaveButton.Enabled = this.NewButton.Enabled;
if (this.NewButton.Enabled)
{
ValidationRule vr = this._ValidationProvider.GetValidationRule(
this._ValidationComponents[this.ControlsDropDownList.SelectedItem]);
this.propertyGrid1.SelectedObject = vr;
}
}
public void Validation_Integration_ValidationRule_Equals_Valid_Test()
{
var rule = new ValidationRule <TestClass, int>(i => i.Index)
.AddCondition(new IsEqualCondition <TestClass, int>(5));
var result = rule.Validate(new TestClass {
Index = 5
});
Assert.IsNull(result);
}
/// <inheritdoc />
protected override void SetValidationRules(List <IValidationRule> validationRules)
{
base.SetValidationRules(validationRules);
foreach (var editorFieldInfo in _editorFields.Where(e => e.Attribute.IsRequired))
{
var property = Expression.Property(Expression.Constant(this), editorFieldInfo.Property.Name);
var lambda = Expression.Lambda <Func <object> >(property).Compile();
var rule = new ValidationRule(ValidationType.Error, Validators.GetValidator(editorFieldInfo.Property.PropertyType), editorFieldInfo.Property.Name, lambda);
validationRules.Add(rule);
}
}
public void SuccedesWhenItHasItems()
{
ICollection <string> val = new List <string>
{
"a"
};
ValidationRule <ICollection <string> > sut = GetSut(val, "a");
sut.HasItems();
}
private void InitDiffusionInputField(TextBox inputField, ValidationRule validationRule, IValueConverter converter, string bindingPath)
{
Binding binding = new Binding(bindingPath)
{
Mode = BindingMode.TwoWay, Converter = converter
};
binding.ValidationRules.Add(validationRule);
inputField.SetBinding(TextBox.TextProperty, binding);
EditingCommands.ToggleInsert.Execute(null, inputField);
}
private static IValidationRuleSet GetValidationRules()
{
// modalities must be associated with performing facility
var modalityAlignsWithPerformingFacilityRule = new ValidationRule <ModalityProcedureStep>(
OrderRules.ModalityAlignsWithPerformingFacility);
return(new ValidationRuleSet(new[]
{
modalityAlignsWithPerformingFacilityRule
}));
}
private void tabControl1_SelectedIndexChanged(object sender, System.EventArgs e)
{
ValidationRule vr = this.propertyGrid1.SelectedObject as ValidationRule;
if (this.tabControl1.SelectedIndex == 1 && vr != null)
{
this.RegExPatternsDropDownList.Text = string.Empty;
this.RegExPatternTextBox.Text = vr.RegExPattern;
this.RegExErrorMessageTextBox.Text = vr.ErrorMessage;
}
}
public void RubberStamp_ValidationRule_DifferentCondition_Valid_WithValidation_Test()
{
var rule = new ValidationRule <TestClass, string>(r => r.Name)
.AddCondition(new IsEqualCondition <TestClass, string>(i => i.Firstname, "Test"));
var result = rule.Validate(new TestClass {
Firstname = "Test"
});
Assert.That(result, Is.Null);
}
public void RubberStamp_Validator_AddRule_Test()
{
var rule = new ValidationRule <TestClass, string>(p => p.Name)
.AddCondition(new IsNotNullCondition <TestClass, string>(p => p.Name));
IValidator <TestClass> validator = new Validator <TestClass>()
.AddRule(rule);
Assert.AreSame(rule, validator.Rules.Single());
Assert.That(validator.Rules.Single().Conditions.Single(), Is.Not.Null);
}
public void Category_Is_Valid()
{
Category category = _expenditureCategory;
ValidationRule rule = new ValidationRule("name", "required");
bool expected = true;
bool actual = _validator.Validate(rule, category);
Assert.AreEqual(expected, actual);
}
public void Test3()
{
var rule = new ValidationRule <Game>
{
OperatorToUse = "AndAlso",
RuleError = new RuleError {
Code = "c", Message = "m"
},
ChildrenRules =
{
new ValidationRule <Game>
{
OperatorToUse = "NotEqual",
ValueToValidateAgainst = new ConstantRule <Game>{
Value = "null"
}
},
new ValidationRule <Game>
{
ValueToValidateAgainst = new ConstantRule <string>{
Value = "null"
},
ObjectToValidate = "Name",
OperatorToUse = "NotEqual"
},
new ValidationRule <Game>
{
ValueToValidateAgainst = new ConstantRule <int>{
Value = "3"
},
ObjectToValidate = "Name.Length",
OperatorToUse = "GreaterThan"
}
}
};
var settings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.Indented
};
settings.Converters.Add(new JsonConverterForRule());
var json = JsonConvert.SerializeObject(rule, settings);
_testOutputHelper.WriteLine(json);
var rule2 = JsonConvert.DeserializeObject <Rule>(json, settings);
var foo = rule2.Compile();
foo.Should().BeTrue();
_testOutputHelper.WriteLine(rule2.ExpressionDebugView());
}
public IEnumerable <ValidationResult> Validate(ValidationRule rule)
{
if (rule.Object is TextBox)
{
yield return(new ValidationResult(rule, ValidationHelper.StringNullOrWhitespace(ValidationHelper.GetValue(rule.Object, Members.Text).ToString())));
}
if (rule.Object is ComboBox)
{
yield return(new ValidationResult(rule, ValidationHelper.NotNull(ValidationHelper.GetValue(rule.Object, Members.SelectedValue))));
}
}
public void TestOneValidationRule()
{
//---------------Set up test pack-------------------
ValidationProvider validationProvider = new ValidationProvider(GetControlFactory().CreateErrorProvider());
ITextBox textBox1 = GetControlFactory().CreateTextBox();
ValidationRule validationRule1 = new ValidationRule();
//---------------Execute Test ----------------------
validationProvider.SetValidationRule(textBox1,validationRule1);
//---------------Test Result -----------------------
Assert.AreEqual(1,validationProvider.GetValidationRules(textBox1).Count);
// Assert.AreEqual(validationRule1,textBox1Rule);
//---------------Tear down -------------------------
}
public static BaseConstraintGenerator Create(BaseFieldGenerator field, ValidationRule rule)
{
if (rule is LengthConstraint)
return new LengthConstraintGenerator(field, (LengthConstraint)rule);
if (rule is RangeConstraint)
return new RangeConstraintGenerator(field, (RangeConstraint)rule);
if (rule is MatchConstraint)
return new MatchConstraintGenerator(field, (MatchConstraint)rule);
if (rule is PredefinedValue)
return new ListConstraintGenerator(field, (PredefinedValue)rule);
if (rule is CodedConstraint)
return new CodeConstraintGenerator(field, (CodedConstraint) rule);
throw new ApplicationException("Invalid constraint type " + rule.GetType());
}
private static IValidationRuleSet GetValidationRules()
{
// modalities must be associated with performing facility
var modalityAlignsWithPerformingFacilityRule = new ValidationRule<ModalityProcedureStep>(
OrderRules.ModalityAlignsWithPerformingFacility);
return new ValidationRuleSet(new[]
{
modalityAlignsWithPerformingFacilityRule
});
}
public void TestValidation_RequiredFieldOnOneControl()
{
//---------------Set up test pack-------------------
ValidationProvider validationProvider = new ValidationProvider(GetControlFactory().CreateErrorProvider());
ITextBox textBox1 = GetControlFactory().CreateTextBox();
ValidationRule validationRule1 = new ValidationRule();
validationRule1.IsRequired = true;
validationRule1.DataType = ValidationDataType.Integer;
validationRule1.MinimumValue = Convert.ToString(2);
validationRule1.MaximumValue = Convert.ToString(10);
validationProvider.SetValidationRule(textBox1, validationRule1);
bool result = false;
//-------------------Test PreConditions------------
Assert.IsFalse(result);
//---------------Execute Test ----------------------
textBox1.Text = Convert.ToString(5);
result = validationProvider.Validate();
//---------------Test Result -----------------------
Assert.IsTrue(result);
//---------------Tear down -------------------------
}
public void TestValidation_RequiredField_Fails_TwoControls_OneControl_IsIncorrect()
{
//---------------Set up test pack-------------------
ValidationProvider validationProvider = new ValidationProvider(GetControlFactory().CreateErrorProvider());
ITextBox textBox1 = GetControlFactory().CreateTextBox();
ITextBox textBox2 = GetControlFactory().CreateTextBox();
ValidationRule validationRule1 = new ValidationRule();
validationRule1.IsRequired = true;
validationProvider.SetValidationRule(textBox1, validationRule1);
validationProvider.SetValidationRule(textBox2, validationRule1);
bool result = true;
//-------------------Test PreConditions------------
Assert.IsTrue(result);
//---------------Execute Test ----------------------
textBox1.Text = "";
textBox2.Text = "World";
result = validationProvider.Validate();
//---------------Test Result -----------------------
Assert.IsFalse(result);
//---------------Tear down -------------------------
}
private static IValidationRuleSet GetValidationRules()
{
var sameInformationAuthorityRule = new ValidationRule<Order>(
OrderRules.VisitAndPerformingFacilitiesHaveSameInformationAuthority);
return new ValidationRuleSet(new[]
{
sameInformationAuthorityRule
});
}
public SimulationLogAnalysisMainViewModel(IViewAwareStatus viewAwareStatus,
IMessageBoxService messageBox,
IUIVisualizerService visualizer,
IHRCSaveFileService saveFile)
{
_viewAwareStatus = viewAwareStatus;
_messageBox = messageBox;
_visualizer = visualizer;
_saveFile = saveFile;
_simulationStartTime = new TimeSpan(0);
_simulationEndTime = new TimeSpan(0);
_viewAwareStatus.ViewLoaded += () =>
{
_dispatcher = ((Window)_viewAwareStatus.View).Dispatcher;
SelectedFileName = (string)Application.Current.Properties["SelectedFileName"];
};
_propertyObserver = new PropertyObserver<SimulationLogAnalysisMainViewModel>(this)
.RegisterHandler(p => p.SelectedFileName, SelectedFileNameChanged)
.RegisterHandler(p => p.AreAnyPlatformsSelected, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.AreAnyModesSelected, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.AreAnySpeciesSelected, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.PerformOurOnlyAnalysis, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.StartTimeString, StartOrStopTimeStringsChanged)
.RegisterHandler(p => p.StopTimeString, StartOrStopTimeStringsChanged)
.RegisterHandler(p => p.AllTimes,
() =>
{
if (!AllTimes || SelectedFileName == null || !File.Exists(SelectedFileName)) return;
_filterStartTime = new TimeSpan(_simulationStartTime.Ticks);
_filterEndTime = new TimeSpan(_simulationEndTime.Ticks);
StartTimeString = _filterStartTime.ToString(TimeSpanFormatString);
StopTimeString = _filterEndTime.ToString(TimeSpanFormatString);
});
AddValidationRules(new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StartTimeString",
Description = "Must be a valid, non-negative time span value in the format hh:mm:ss where 00 <= hh <= 23; 00 <= mm <= 59; 00 <= ss <= 59",
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (string.IsNullOrEmpty(target.StartTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StartTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan.Ticks >= 0;
},
}, new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StopTimeString",
Description = "Must be a valid, non-negative time span value in the format hh:mm:ss where 00 <= hh <= 23; 00 <= mm <= 59; 00 <= ss <= 59",
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (string.IsNullOrEmpty(target.StopTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StopTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan.Ticks > 0;
},
});
_startTimeValidationRule = new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StartTimeString",
Description = string.Format("Must be between {0} and {1}", _simulationStartTime.ToString(TimeSpanFormatString), _filterEndTime.ToString(TimeSpanFormatString)),
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (_simulationStartTime.Ticks == 0 && _simulationEndTime.Ticks == 0) return true;
if (string.IsNullOrEmpty(target.StartTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StartTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan >= _simulationStartTime && timeSpan < _filterEndTime;
},
};
_endTimeValidationRule = new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StopTimeString",
Description = string.Format("Must be between {0} and {1}", _filterStartTime.ToString(TimeSpanFormatString), _simulationEndTime.ToString(TimeSpanFormatString)),
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (_simulationStartTime.Ticks == 0 && _simulationEndTime.Ticks == 0) return true;
if (string.IsNullOrEmpty(target.StopTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StopTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan > _filterStartTime && timeSpan <= _simulationEndTime;
},
};
AddValidationRules(_startTimeValidationRule, _endTimeValidationRule);
}
public ValidationState(ValidationRule rule, EfgGrouping group) : this(rule)
{
TakeRateId = group.TakeRateId;
MarketId = group.MarketId;
ModelId = group.ModelId;
FeatureId = group.FeatureId;
ExclusiveFeatureGroup = group.ExclusiveFeatureGroup;
}
private static IValidationRuleSet GetValidationRules()
{
// ensure that not both the procedure type and procedure type groups filters are being applied
var procedureTypeRule = new ValidationRule<Worklist>(
delegate(Worklist w)
{
var filterByBothProcedureTypeAndProcedureTypeGroup = w.ProcedureTypeFilter.IsEnabled &&
w.ProcedureTypeGroupFilter.IsEnabled;
return new TestResult(!filterByBothProcedureTypeAndProcedureTypeGroup, SR.MessageValidateWorklistProcedureTypeAndGroupFilters);
});
// ensure time filter meets constraints specified in settings
var timeFilterRule = new ValidationRule<Worklist>(
delegate(Worklist w)
{
var settings = new WorklistSettings();
var maxDays = settings.TimeWindowMaxSpanDays;
if (settings.TimeWindowRequired && maxDays > 0)
{
return new TestResult(w.CheckTimeFilterSpan(TimeSpan.FromDays(maxDays)),
string.Format(SR.MessageValidateWorklistTimeFilter, maxDays));
}
return new TestResult(true);
});
return new ValidationRuleSet(new[] { procedureTypeRule, timeFilterRule });
}
public ValidationState(ValidationRule rule, RawTakeRateSummaryItem summaryItem)
: this(rule)
{
TakeRateId = summaryItem.FdpVolumeHeaderId;
MarketId = summaryItem.MarketId;
ModelId = summaryItem.ModelId;
FdpModelId = summaryItem.FdpModelId;
Volume = summaryItem.Volume;
PercentageTakeRate = summaryItem.PercentageTakeRate;
FdpTakeRateSummaryId = summaryItem.FdpTakeRateSummaryId;
FdpChangesetDataItemId = summaryItem.FdpChangesetDataItemId;
}
private static IValidationRuleSet GetValidationRules()
{
// ensure that not both the procedure type and procedure type groups filters are being applied
var exactlyOneDefaultContactPointRule = new ValidationRule<ExternalPractitioner>(
delegate(ExternalPractitioner externalPractitioner)
{
// The rule is not applicable to deactivated external practitioner
if (externalPractitioner.Deactivated)
return new TestResult(true, "");
var activeDefaultContactPoints = CollectionUtils.Select(
externalPractitioner.ContactPoints,
contactPoint => contactPoint.IsDefaultContactPoint && !contactPoint.Deactivated);
var success = activeDefaultContactPoints.Count == 1;
return new TestResult(success, SR.MessageValidateExternalPractitionerRequiresExactlyOneDefaultContactPoint);
});
return new ValidationRuleSet(new[] { exactlyOneDefaultContactPointRule });
}
public ValidationState(ValidationRule rule, RawTakeRateDataItem dataItem) : this(rule)
{
TakeRateId = dataItem.FdpVolumeHeaderId;
MarketId = dataItem.MarketId;
ModelId = dataItem.ModelId;
FdpModelId = dataItem.FdpModelId;
FeatureId = dataItem.FeatureId;
FdpFeatureId = dataItem.FdpFeatureId;
FeaturePackId = dataItem.FeaturePackId;
Volume = dataItem.Volume;
PercentageTakeRate = dataItem.PercentageTakeRate;
ExclusiveFeatureGroup = dataItem.ExclusiveFeatureGroup;
FdpVolumeDataItemId = dataItem.FdpVolumeDataItemId;
FdpChangesetDataItemId = dataItem.FdpChangesetDataItemId;
}
private static IValidationRuleSet GetValidationRules()
{
var sameInformationAuthorityRule = new ValidationRule<Procedure>(
procedure => OrderRules.VisitAndPerformingFacilitiesHaveSameInformationAuthority(procedure.Order));
var samePerformingFacilityRule = new ValidationRule<Procedure>(
procedure => OrderRules.AllNonDefunctProceduresHaveSamePerformingFacility(procedure.Order));
var samePerformingDepartmentRule = new ValidationRule<Procedure>(
procedure => OrderRules.AllNonDefunctProceduresHaveSamePerformingDepartment(procedure.Order));
// performing department must be associated with performing facility
var performingDepartmentIsInPerformingFacilityRule = new ValidationRule<Procedure>(
OrderRules.PerformingDepartmentAlignsWithPerformingFacility);
// modalities must be associated with performing facility
var modalitiesAlignWithPerformingFacilityRule = new ValidationRule<Procedure>(
OrderRules.ModalitiesAlignWithPerformingFacility);
// patient must have a profile at the performing facility
var patientProfileExistsForPerformingFacilityRule = new ValidationRule<Procedure>(
OrderRules.PatientProfileExistsForPerformingFacility);
return new ValidationRuleSet(new[]
{
sameInformationAuthorityRule,
samePerformingFacilityRule,
samePerformingDepartmentRule,
performingDepartmentIsInPerformingFacilityRule,
modalitiesAlignWithPerformingFacilityRule,
patientProfileExistsForPerformingFacilityRule
});
}
public ValidationState(ValidationRule rule)
{
ValidationRule = rule;
ChildStates = Enumerable.Empty<ValidationState>();
}
public ValidationState(ValidationRule rule, IEnumerable<RawTakeRateDataItem> dataItems) : this(rule)
{
ChildStates = dataItems.Select(dataItem => new ValidationState(ValidationRule.VolumeForFeatureGreaterThanModel, dataItem));
}
public ValidationState(ValidationRule rule, FeaturePack pack) : this(rule)
{
TakeRateId = pack.TakeRateId;
MarketId = pack.MarketId;
ModelId = pack.ModelId;
FeaturePackId = pack.FeaturePackId;
PackName = pack.PackName;
}
protected void AddValidationRule(ValidationRule rule)
{
_validationRules.Add(rule);
}
private static IValidationRuleSet GetRules()
{
var rule = new ValidationRule<BarA>(i => new TestResult(false, "This rule always fails."));
return new ValidationRuleSet(new ISpecification[] { rule });
}
public ValidationBreak(ValidationRule Rule, bool breaker = false)
{
this.validationRule = Rule;
this.isBreaker = breaker;
}
public ValidationState(ValidationRule rule, RawTakeRateFeatureMixItem mixItem)
: this(rule)
{
TakeRateId = mixItem.FdpVolumeHeaderId;
MarketId = mixItem.MarketId;
FeatureId = mixItem.FeatureId;
FdpFeatureId = mixItem.FdpFeatureId;
FeaturePackId = mixItem.FeaturePackId;
Volume = mixItem.Volume;
PercentageTakeRate = mixItem.PercentageTakeRate;
FdpTakeRateFeatureMixId = mixItem.FdpTakeRateFeatureMixId;
FdpChangesetDataItemId = mixItem.FdpChangesetDataItemId;
}
