public IRuleSet GetRuleSet(string propertyName) { var ruleSet = new RuleSet(); return ruleSet; }
public override IRuleSet GetRuleSet(string propertyName, string datalist) { var ruleSet = new RuleSet(); if(IsEmpty()) { return ruleSet; } switch(propertyName) { case "OutputVariable": var outputExprRule = new IsValidExpressionRule(() => OutputVariable,datalist, "1"); ruleSet.Add(outputExprRule); ruleSet.Add(new IsValidExpressionRule(() => outputExprRule.ExpressionValue, datalist)); if(!string.IsNullOrEmpty(XPath)) { ruleSet.Add(new IsStringEmptyRule(() => OutputVariable)); } break; case "XPath": if(!string.IsNullOrEmpty(OutputVariable)) { ruleSet.Add(new IsStringEmptyRule(() => XPath)); if(!string.IsNullOrEmpty(XPath) && !DataListUtil.IsEvaluated(XPath)) { ruleSet.Add(new IsValidXpathRule(() => XPath)); } } break; } return ruleSet; }
protected virtual string ValidatePath(string label, string path, Action onError, bool pathIsRequired) { if (!pathIsRequired && string.IsNullOrWhiteSpace(path)) { return string.Empty; } var errors = new List<IActionableErrorInfo>(); RuleSet fileActivityRuleSet = new RuleSet(); IsValidExpressionRule isValidExpressionRule = new IsValidExpressionRule(() => path, DataListSingleton.ActiveDataList.Resource.DataList); fileActivityRuleSet.Add(isValidExpressionRule); errors.AddRange(fileActivityRuleSet.ValidateRules(label, onError)); string pathValue; path.TryParseVariables(out pathValue, onError, variableValue: ValidUriSchemes[0] + "://temp"); if (errors.Count == 0) { IsStringEmptyOrWhiteSpaceRule isStringEmptyOrWhiteSpaceRuleUserName = new IsStringEmptyOrWhiteSpaceRule(() => path) { LabelText = label, DoError = onError }; IsValidFileNameRule isValidFileNameRule = new IsValidFileNameRule(() => path) { LabelText = label, DoError = onError }; fileActivityRuleSet.Add(isStringEmptyOrWhiteSpaceRuleUserName); fileActivityRuleSet.Add(isValidExpressionRule); errors.AddRange(fileActivityRuleSet.ValidateRules(label, onError)); } UpdateErrors(errors); return pathValue; }
protected virtual string ValidateArchivePassword(string password, string label, Action onError, bool contentIsRequired = true) { var errors = new List<IActionableErrorInfo>(); RuleSet fileActivityRuleSet = new RuleSet(); IsValidExpressionRule isValidExpressionRule = new IsValidExpressionRule(() => password, DataListSingleton.ActiveDataList.Resource.DataList); fileActivityRuleSet.Add(isValidExpressionRule); errors.AddRange(fileActivityRuleSet.ValidateRules(label, onError)); UpdateErrors(errors); return password; }
public override IRuleSet GetRuleSet(string propertyName, string datalist) { RuleSet ruleSet = new RuleSet(); if (IsEmpty()) { return ruleSet; } switch (propertyName) { case "FieldName": if(FieldName.Length == 0) { ruleSet.Add(new IsStringEmptyRule(() => FieldName)); } break; case "ValueToMatch": if(ValueToMatch.Length == 0) { ruleSet.Add(new IsStringEmptyRule(() => ValueToMatch)); } ruleSet.Add(new IsValidExpressionRule(() => ValueToMatch, datalist, "1")); break; } return ruleSet; }
private RuleSet GetFieldNameRuleSet() { var ruleSet = new RuleSet(); return ruleSet; }
public override IRuleSet GetRuleSet(string propertyName, string datalist) { RuleSet ruleSet = new RuleSet(); if (IsEmpty()) { return ruleSet; } switch (propertyName) { case "Input": if (!string.IsNullOrEmpty(InputVariable)) { var inputExprRule = new IsValidExpressionRule(() => InputVariable, datalist, "0"); ruleSet.Add(inputExprRule); } else ruleSet.Add(new IsStringEmptyRule(() => InputVariable)); break; case "At": if (MergeType == MergeTypeIndex) { var atExprRule = new IsValidExpressionRule(() => At, datalist, "1"); ruleSet.Add(atExprRule); ruleSet.Add(new IsStringEmptyRule(() => atExprRule.ExpressionValue)); ruleSet.Add(new IsPositiveNumberRule(() => atExprRule.ExpressionValue)); } break; case "Padding": if (!string.IsNullOrEmpty(Padding)) { var paddingExprRule = new IsValidExpressionRule(() => Padding, datalist, "0"); ruleSet.Add(paddingExprRule); ruleSet.Add(new IsSingleCharRule(() => paddingExprRule.ExpressionValue)); } break; } return ruleSet; }
public override IRuleSet GetRuleSet(string propertyName, string datalist) { var ruleSet = new RuleSet(); if(IsEmpty()) { return ruleSet; } switch(propertyName) { case "OutputVariable": if (!string.IsNullOrEmpty(OutputVariable)) { var outputExprRule = new IsValidExpressionRule(() => OutputVariable, datalist, "0"); ruleSet.Add(outputExprRule); ruleSet.Add(new IsValidExpressionRule(() => outputExprRule.ExpressionValue, datalist)); } break; case "At": switch(SplitType) { case SplitTypeIndex: var atIndexExprRule = new IsValidExpressionRule(() => At, datalist, "1"); ruleSet.Add(atIndexExprRule); ruleSet.Add(new IsPositiveNumberRule(() => atIndexExprRule.ExpressionValue)); break; case SplitTypeChars: var atCharsExprRule = new IsValidExpressionRule(() => At, datalist, ","); ruleSet.Add(atCharsExprRule); ruleSet.Add(new IsStringEmptyRule(() => atCharsExprRule.ExpressionValue)); break; } break; } return ruleSet; }
public void ActivityDTO_Validate_Executed_SetErrorsProperty() { //------------Setup for test-------------------------- var activityDTO = new ActivityDTO { FieldName = null }; var ruleSet = new RuleSet(); ruleSet.Add(new IsNullRule(() => activityDTO.FieldName)); //------------Execute Test--------------------------- activityDTO.Validate("FieldName", ruleSet); //------------Assert Results------------------------- Assert.AreEqual(1, activityDTO.Errors.Count); }
public void ActivityDTO_Validate_GivenRules_HasPassingRuleReturnTrue() { //------------Setup for test-------------------------- var activityDTO = new ActivityDTO { FieldName = "FeildName" }; var ruleSet = new RuleSet(); ruleSet.Add(new IsNullRule(() => activityDTO.FieldName)); //------------Execute Test--------------------------- bool isValid = activityDTO.Validate("FieldName", ruleSet); //------------Assert Results------------------------- Assert.IsTrue(isValid); }
public override IRuleSet GetRuleSet(string propertyName, string datalist) { RuleSet ruleSet = new RuleSet(); if (IsEmpty()) { return ruleSet; } switch (propertyName) { case "SearchType": if (SearchType == "Starts With" || SearchType == "Ends With" || SearchType == "Doesn't Start With" || SearchType == "Doesn't End With") { ruleSet.Add(new IsStringEmptyRule(() => SearchType)); ruleSet.Add(new IsValidExpressionRule(() => SearchType, datalist, "1")); } break; case "From": if (SearchType == "Is Between" || SearchType == "Is Not Between") { ruleSet.Add(new IsStringEmptyRule(() => From)); ruleSet.Add(new IsValidExpressionRule(() => From, datalist, "1")); } break; case "To": if (SearchType == "Is Between" || SearchType == "Is Not Between") { ruleSet.Add(new IsStringEmptyRule(() => To)); ruleSet.Add(new IsValidExpressionRule(() => To, datalist, "1")); } break; case "SearchCriteria": ruleSet.Add(new IsValidExpressionRule(() => SearchCriteria, datalist, "1")); break; } return ruleSet; }
void ValidateUserNameAndPassword(string userNameValue, string userNameLabel, Action onUserNameError, string passwordValue, string passwordLabel, Action onPasswordError) { var errors = new List<IActionableErrorInfo>(); var credentialUserRuleSet = new RuleSet(); var dataListViewModel = DataListSingleton.ActiveDataList; if(dataListViewModel != null) { var isValidExpressionRule = new IsValidExpressionRule(() => userNameValue, dataListViewModel.Resource.DataList); credentialUserRuleSet.Add(isValidExpressionRule); errors.AddRange(credentialUserRuleSet.ValidateRules(userNameLabel, onUserNameError)); var credentialPasswordRuleSet = new RuleSet(); isValidExpressionRule = new IsValidExpressionRule(() => passwordValue, dataListViewModel.Resource.DataList); credentialPasswordRuleSet.Add(isValidExpressionRule); errors.AddRange(credentialPasswordRuleSet.ValidateRules(passwordLabel, onPasswordError)); } if(errors.Count == 0) { var isStringEmptyOrWhiteSpaceRuleUserName = new IsStringEmptyOrWhiteSpaceRule(() => userNameValue) { LabelText = userNameLabel, DoError = onUserNameError }; var userNameBlankError = isStringEmptyOrWhiteSpaceRuleUserName.Check(); var isStringEmptyOrWhiteSpaceRulePassword = new IsStringEmptyOrWhiteSpaceRule(() => passwordValue) { LabelText = passwordLabel, DoError = onPasswordError }; var passwordBlankError = isStringEmptyOrWhiteSpaceRulePassword.Check(); if (userNameBlankError == null && passwordBlankError != null) { errors.Add(passwordBlankError); } else { if (passwordBlankError == null && userNameBlankError != null) { errors.Add(userNameBlankError); } } } UpdateErrors(errors); }
public override IRuleSet GetRuleSet(string propertyName, string datalist) { RuleSet ruleSet = new RuleSet(); if (String.IsNullOrEmpty( SourceName)) { return ruleSet; } if(propertyName == "SourceName") { ruleSet.Add(new IsValidJsonCreateMappingSourceExpression(() => SourceName)); } if(propertyName == "DestinationName") { ruleSet.Add(new IsStringEmptyOrWhiteSpaceRule(()=>DestinationName)); ruleSet.Add(new ShouldNotBeVariableRule(()=>DestinationName)); } return ruleSet; }