/// <summary>
/// Specify on of the rule's conditions to be the ommision of a section that has a field with a given operation
/// </summary>
/// <param name="field"></param>
/// <param name="values"></param>
/// <returns></returns>
public Validation SectionDoesNotExist(ValidationField field, List <string> values)
{
InitializeConditions();
_rule.SelfValidation = true;
_rule.ConditionOperations.Add(SectionDoesNotExistFieldOperationComparison(field, values));
return(this);
}
public ValidationOperation DoesNotContainsOperation(ValidationField validationField, List <string> containsValues)
{
var operation = ContainsOperation(validationField, containsValues);
operation.Operand = ValidationOperand.NotIn;
return(operation);
}
public ValidationOperation NotRequiredOperation(ValidationField validationField)
{
var rule = RequiredOperation(validationField);
rule.Operand = ValidationOperand.Not;
return(rule);
}
/// <summary>
/// Specify one off the rule's conditions to be a Contains Operation Type
/// </summary>
public Validation Contains(ValidationField field, List <string> containsValues)
{
InitializeConditions();
_rule.SelfValidation = false;
_rule.ConditionOperations.Add(ContainsOperation(field, containsValues));
return(this);
}
/// <summary>
/// Specify one off the rule's conditions to be a Required Operation Type
/// </summary>
public Validation Required(ValidationField field)
{
InitializeConditions();
_rule.SelfValidation = false;
_rule.ConditionOperations.Add(RequiredOperation(field));
return(this);
}
public ValidationOperation RequiredOperation(ValidationField validationField)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
SectionName = validationField.SectionName,
OperationType = ValidationOperationType.Required,
ControlType = validationField.ControlType,
};
return(operation);
}
/// <summary>
/// Specify one off the rule's conditions to be a Does Not Contains Operation Type
/// </summary>
public Validation DoesNotContain(ValidationField field, List <string> containsValues)
{
InitializeConditions();
_rule.SelfValidation = false;
var operation = ContainsOperation(field, containsValues);
operation.Operand = ValidationOperand.NotIn;
_rule.ConditionOperations.Add(operation);
return(this);
}
public List <ValidationRule> BuildComparisonConditionValidationRule(ValidationMessage message,
ValidationField field1, ValidationField field2, string operand, List <ValidationOperation> conditions)
{
var rules = BuildComparisonValidationRule(message, field1, field2, operand);
foreach (var rule in rules)
{
rule.ValidationReBroadcast = true;
rule.ConditionOperations = conditions;
}
return(rules);
}
/// <summary>
/// Specify one off the rule's conditions to be a Not Required Operation Type
/// </summary>
public Validation NotRequired(ValidationField field)
{
InitializeConditions();
_rule.SelfValidation = false;
var operation = RequiredOperation(field);
operation.Operand = ValidationOperand.Not;
_rule.ConditionOperations.Add(operation);
return(this);
}
public ValidationOperation ContainsOperation(ValidationField validationField, List <string> containsValues)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
SectionName = validationField.SectionName,
OperationType = ValidationOperationType.Contains,
ContainsValues = containsValues,
Operand = ValidationOperand.In,
ControlType = validationField.ControlType,
};
return(operation);
}
public ValidationOperation UniqueOperation(ValidationField validationField)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
FieldType = (int)validationField.FieldType,
SectionName = validationField.SectionName,
ControlType = validationField.ControlType,
OperationType = ValidationOperationType.Unique,
PropertyOverride = validationField.PropertyOverride
};
return(operation);
}
/// <summary>
/// Constructs a Required Operation for a field
/// </summary>
private ValidationOperation RequiredOperation(ValidationField validationField)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
FieldType = (int)validationField.FieldType, // todo: change property type to FieldType
SectionName = validationField.SectionName,
OperationType = ValidationOperationType.Required,
ControlType = validationField.ControlType,
PropertyOverride = validationField.PropertyOverride
};
return(operation);
}
public ValidationOperation CompareToCurrentDateOperation(ValidationField validationField)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
SectionName = validationField.SectionName,
OperationType = ValidationOperationType.CompareToCurrentDate,
ControlType = validationField.ControlType,
Operand = ValidationOperand.LessThanEqual,
FieldMask = validationField.Mask,
CompareToMask = validationField.CompareToMask
};
return(operation);
}
public Validation(Guid id, ValidationMessage validationMessage, ValidationField validationField)
{
_rule = new ValidationRule
{
Id = id,
ValidationId = validationMessage.Message,
Message = validationMessage.Message,
FieldPath = validationField.FieldPath,
SectionName = validationField.SectionName,
TargetPath = validationMessage.TargetPath,
AlwaysShowMessage = validationMessage.AlwaysShowMessage,
};
_operationField = validationField;
}
/// <summary>
/// Constructs a Value Count Operaration for a field
/// </summary>
public ValidationOperation ValueCountOperation(ValidationField validationField, string limit)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
FieldType = (int)validationField.FieldType,
SectionName = validationField.SectionName,
OperationType = ValidationOperationType.ValueCount,
CompareValue = limit,
ControlType = validationField.ControlType,
PropertyOverride = validationField.PropertyOverride
};
return(operation);
}
public ValidationOperation ComparisonOperation(ValidationField validationField, string operand)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
SectionName = validationField.SectionName,
OperationType = ValidationOperationType.Comparison,
ControlType = validationField.ControlType,
Operand = operand,
FieldMask = validationField.Mask,
CompareToMask = validationField.CompareToMask
};
return(operation);
}
public ValidationOperation MaxRecordCountOperation(ValidationField validationField, string count)
{
var operation = new ValidationOperation
{
FieldPath = validationField.FieldPath,
SectionName = validationField.SectionName,
ControlType = validationField.ControlType,
CompareValue = count,
FieldType = (int)validationField.FieldType,
OperationType = ValidationOperationType.MaxRecordCount,
PropertyOverride = validationField.PropertyOverride
};
return(operation);
}
public ValidationRule BuildContainsValidationRule(ValidationMessage message, ValidationField field, List <string> containsValues)
{
var containsRule = new ValidationRule(RuleSource)
{
Id = Guid.NewGuid(),
ValidationId = message.Message,
Message = message.Message,
FieldPath = field.FieldPath,
SectionName = field.SectionName,
SelfValidation = true,
TargetPath = message.TargetPath,
Operation = ContainsOperation(field, containsValues),
};
return(containsRule);
}
public ValidationRule BroadcastOnlyRule(ValidationMessage message, ValidationField field)
{
var validationRule = new ValidationRule(RuleSource)
{
Id = Guid.NewGuid(),
ValidationId = message.Message,
Message = message.Message,
FieldPath = field.FieldPath,
SectionName = field.SectionName,
TargetPath = message.TargetPath,
SelfValidation = false,
ValidationReBroadcast = true,
};
return(validationRule);
}
public ValidationRule BuildRequiredValidationRule(ValidationMessage message, ValidationField field)
{
var requiredRule = new ValidationRule(RuleSource)
{
Id = Guid.NewGuid(),
ValidationId = message.Message,
Message = message.Message,
FieldPath = field.FieldPath,
SectionName = field.SectionName,
SelfValidation = true,
TargetPath = message.TargetPath,
Operation = RequiredOperation(field),
};
return(requiredRule);
}
public ValidationRule BuildRegularExpressionRule(ValidationMessage message, ValidationField field, string operand)
{
var compareToCurrentDateRule = new ValidationRule(RuleSource)
{
Id = Guid.NewGuid(),
ValidationId = message.Message,
Message = message.Message,
FieldPath = field.FieldPath,
SectionName = field.SectionName,
SelfValidation = true,
TargetPath = message.TargetPath,
Operation = RegularExpressionOperation(field, operand),
};
return(compareToCurrentDateRule);
}
/// <summary>
/// Constructs a Comparison Operation for a field
/// </summary>
private ValidationOperation ComparisonOperation(ValidationField field, string operand)
{
var operation = new ValidationOperation
{
FieldPath = field.FieldPath,
FieldType = (int)field.FieldType,
SectionName = field.SectionName,
OperationType = ValidationOperationType.Comparison,
ContainsValues = null,
Operand = operand,
ControlType = field.ControlType,
PropertyOverride = field.PropertyOverride
};
return(operation);
}
private ValidationOperation RelatedOffenseContainsOperation(ValidationField offenseField, List <string> containsValues)
{
var operation = new ValidationOperation
{
FieldPath = offenseField.FieldPath,
FieldType = (int)offenseField.FieldType,
SectionName = offenseField.SectionName,
OperationType = ValidationOperationType.RelatedOffenseContains,
ContainsValues = containsValues,
Operand = ValidationOperand.In,
ControlType = offenseField.ControlType,
PropertyOverride = offenseField.PropertyOverride
};
return(operation);
}
private ValidationOperation RegularExpressionOperation(ValidationField field, string expression)
{
var operation = new ValidationOperation
{
FieldPath = field.FieldPath,
FieldType = (int)field.FieldType,
SectionName = field.SectionName,
OperationType = ValidationOperationType.RegularExpression,
ControlType = field.ControlType,
Operand = expression,
FieldMask = field.Mask,
CompareToMask = field.CompareToMask,
PropertyOverride = field.PropertyOverride
};
return(operation);
}
/// <summary>
/// Constructs a Compare to Current Date Operation for a field
/// </summary>
private ValidationOperation CompareToCurrentDateOperation(ValidationField field)
{
var operation = new ValidationOperation
{
FieldPath = field.FieldPath,
FieldType = (int)field.FieldType,
SectionName = field.SectionName,
OperationType = ValidationOperationType.CompareToCurrentDate,
ControlType = field.ControlType,
Operand = ValidationOperand.LessThanEqual,
FieldMask = field.Mask,
CompareToMask = field.CompareToMask,
PropertyOverride = field.PropertyOverride
};
return(operation);
}
public void CreateAssociatedRule()
{
//arrange
var validationField = new AdminValidation.ValidationField();
validationField.SectionName = "Section";
var rule = new ValidationRule();
rule.SelfValidation = true;
//action
var validationRule = AdminValidation.Validation.CreateAssociatedRule(validationField, rule);
//assertion
validationRule.Should().NotBeNull();
validationRule.Should().BeOfType(typeof(ValidationRule));
validationRule.SectionName.Should().Be(validationField.SectionName);
validationRule.SelfValidation.Should().BeTrue();
}
public Validation CompareVictimFieldToOffender(ValidationField field, string operation)
{
_rule.SelfValidation = true;
_rule.Operation = new ValidationOperation
{
FieldPath = field.FieldPath,
FieldType = (int)field.FieldType,
SectionName = field.SectionName,
OperationType = ValidationOperationType.CompareVictimFieldToOffender,
ControlType = field.ControlType,
PropertyOverride = field.PropertyOverride,
Operand = operation,
FieldMask = field.Mask,
CompareToMask = field.CompareToMask
};
return(this);
}
private ValidationOperation RangeOperation(ValidationField field, string lowerBound, string upperBound)
{
var operation = new ValidationOperation
{
FieldPath = field.FieldPath,
FieldType = (int)field.FieldType,
SectionName = field.SectionName,
OperationType = ValidationOperationType.Range,
ControlType = field.ControlType,
PropertyOverride = field.PropertyOverride,
Operand = null,
FieldMask = field.Mask,
CompareToMask = field.CompareToMask,
LowerBound = lowerBound,
UpperBound = upperBound
};
return(operation);
}
public Validation RelatedOffenseContains(ValidationField offenseField, List <string> containsValues)
{
var relatedOffenseContains = RelatedOffenseContainsOperation(offenseField, containsValues);
if (_withConditions)
{
if (_rule.ConditionOperations == null)
{
_rule.ConditionOperations = new List <ValidationOperation>();
}
_rule.ConditionOperations.Add(relatedOffenseContains);
}
else
{
_rule.Operation = relatedOffenseContains;
}
return(this);
}
/// <summary>
/// Create a new Validation Rule for an associated field based off of an existing rule
/// </summary>
public static ValidationRule CreateAssociatedRule(ValidationField associatedField, ValidationRule sourceRule)
{
var rule = new ValidationRule
{
Id = Guid.NewGuid(),
ValidationId = sourceRule.ValidationId,
Message = sourceRule.Message,
FieldPath = associatedField.FieldPath,
SectionName = associatedField.SectionName,
TargetPath = sourceRule.TargetPath,
AlwaysShowMessage = sourceRule.AlwaysShowMessage,
SelfValidation = sourceRule.SelfValidation,
RuleSource = sourceRule.RuleSource,
Operation = sourceRule.Operation,
ConditionOperations = sourceRule.ConditionOperations,
ValidationReBroadcast = sourceRule.ValidationReBroadcast,
RuleImplementation = sourceRule.RuleImplementation,
ConditionOperator = sourceRule.ConditionOperator,
};
return(rule);
}