/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { string objectType = this.GetObjectType(entry); this.MaxLength = objectType.Equals("user", StringComparison.CurrentCultureIgnoreCase) ? 20 : 256; return(base.Execute(parent, entry, attributeValue)); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { if (Constants.PeriodsRegex.IsMatch(attributeValue)) { this.GetErrorResult(ErrorType.Format, this.Fixer(entry, attributeValue)); } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { if (entry.Attributes.Contains(StringLiterals.UserPrincipalName)) { return(this.GetSuccessResult()); } return(base.Execute(parent, entry, attributeValue)); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { if (string.IsNullOrEmpty(attributeValue)) { var updatedValue = this.Fixer(entry, attributeValue); return(this.GetErrorResult(ErrorType.Blank, updatedValue)); } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { string objectType = this.GetObjectType(entry); if (objectType.Equals("group", StringComparison.CurrentCultureIgnoreCase)) { return(base.Execute(parent, entry, attributeValue)); } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { if (attributeValue.Length > this.MaxLength) { var updatedValue = this.Fixer != null?this.Fixer(entry, attributeValue) : attributeValue.Substring(0, this.MaxLength); return(this.GetErrorResult(ErrorType.Length, updatedValue)); } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { string objectType = this.GetObjectType(entry); if (objectType.Equals("contact", StringComparison.CurrentCultureIgnoreCase) && parent.AttributeName == StringLiterals.MailNickName) { return(base.Execute(parent, entry, attributeValue)); } return(this.GetSuccessResult()); }
/// <summary> /// Creates a new instance of <see cref="TargetAddressBlankRule"/> /// </summary> public TargetAddressBlankRule() : base((entry, value) => { var objectType = ComposedRule.GetObjectType(entry); // the orginal code doesn't provide a fix if the type isn't "contact" if (objectType.Equals("contact", StringComparison.CurrentCultureIgnoreCase)) { value = "SMTP:" + entry.Attributes[StringLiterals.Mail][0].ToString(); return(value.Length > 256 ? value.Substring(0, 256) : value); } return(value); }) { }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { int colonPosn = attributeValue.IndexOf(":"); if (colonPosn > 0) { //In case the suffix has a colon, we need to show a character error. //And replace it. string suffix = attributeValue.Substring(colonPosn + 1); if (suffix.Contains(":")) { return(this.GetErrorResult(ErrorType.Character, attributeValue.Substring(0, colonPosn) + ":" + suffix.Replace(":", ""))); } } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { string objectType = this.GetObjectType(entry); var homeMdb = entry.Attributes[StringLiterals.HomeMdb]; // When the entry is a contact or user if (objectType.Equals("contact", StringComparison.CurrentCultureIgnoreCase) || objectType.Equals("user", StringComparison.CurrentCultureIgnoreCase)) { // and homeMdb is not defined if (homeMdb == null || homeMdb.Count == 0 || homeMdb[0] == null || string.IsNullOrWhiteSpace(homeMdb[0].ToString())) { // targetAddress cannot be blank return(base.Execute(parent, entry, attributeValue)); } } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { if (this.CheckExpression.IsMatch(attributeValue)) { string updated; if (this.Fixer == null) { var tempVal = this.CheckExpression.Replace(attributeValue, string.Empty); updated = string.IsNullOrEmpty(tempVal) ? entry.Attributes[StringLiterals.Cn][0].ToString() : tempVal; } else { updated = this.Fixer(entry, attributeValue); } return(this.GetErrorResult(ErrorType.Character, updated)); } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { // record in memory the entry details with a list of the attributes that end up needing to be checked if (DuplicateStore.IsDuplicate(parent.AttributeName, attributeValue, entry)) { // we now need to execute some complicated logic from the original application depending // settings, etc. this isn't pretty but it follows the original for now var actionType = ActionType.Edit; var originalValue = entry.Attributes[parent.AttributeName][0].ToString(); // if nothing else has changed the value prior to this (which is why no duplicate rule needs to be run last) if (originalValue == attributeValue) { switch (parent.AttributeName.ToLowerInvariant()) { case "proxyaddresses": if (Constants.SMTPRegex.IsMatch(attributeValue)) { if (entry.Attributes.Contains(StringLiterals.MailNickName)) { if (attributeValue.ToLowerInvariant().Substring(0, 5) == "smtp:") { actionType = ActionType.Complete; } } else { actionType = ActionType.Remove; } } break; case "userprincipalname": if (entry.Attributes.Contains(StringLiterals.MailNickName)) { actionType = ActionType.Complete; } break; case "mail": if (entry.Attributes.Contains(StringLiterals.MailNickName)) { actionType = ActionType.Complete; } break; case "mailnickname": if (entry.Attributes.Contains(StringLiterals.HomeMdb)) { actionType = ActionType.Complete; } break; case "samaccountname": if (entry.Attributes.Contains(StringLiterals.MailNickName)) { actionType = ActionType.Complete; } break; } } return(this.GetErrorResult(ErrorType.Duplicate, attributeValue, actionType)); } return(this.GetSuccessResult()); }
/// <summary> /// Executes implementation for this rule /// </summary> /// <param name="parent">The composed rule containing this rule</param> /// <param name="entry">The search result we are checking</param> /// <param name="attributeValue">The current attribute value as pass through the chain</param> /// <returns>Either a success or error result</returns> public override RuleResult Execute(ComposedRule parent, SearchResultEntry entry, string attributeValue) { var tldList = new ValidTLDList(); bool success = true; ErrorType errors = ErrorType.None; string validateAttribute = Constants.SMTPRegex.IsMatch(attributeValue) ? attributeValue.Substring(attributeValue.IndexOf(":") + 1) : attributeValue; if (validateAttribute.LastIndexOf(".") != -1) { string tldDomain = validateAttribute.ToLowerInvariant().Substring(validateAttribute.LastIndexOf(".")); if (tldDomain.Length > 1) { if (!tldList.IsValid(tldDomain)) { success = false; errors |= ErrorType.TopLevelDomain; } } } if (!Constants.DomainPartRegex.IsMatch(validateAttribute)) { success = false; errors |= ErrorType.DomainPart; if (validateAttribute.LastIndexOf("@") != -1) { validateAttribute = validateAttribute.Substring(0, validateAttribute.LastIndexOf("@") + 1) + (new Regex(@"[^a-z0-9.-]", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)).Replace(validateAttribute.Substring(validateAttribute.LastIndexOf("@") + 1), ""); } } if (!Constants.LocalPartRegex.IsMatch(validateAttribute) || (validateAttribute.Split('@').Length - 1 > 1)) { success = false; errors |= ErrorType.LocalPart; if (validateAttribute.LastIndexOf("@") != -1) { string validateLocal = (new Regex(@"[^a-z0-9.!#$%&'*+/=?^_`{|}~-]", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)).Replace(validateAttribute.Substring(0, validateAttribute.LastIndexOf("@")), ""); validateAttribute = (validateLocal + validateAttribute.Substring(validateAttribute.LastIndexOf("@"))).Replace(".@", "@"); } } if (!Constants.Rfc2822Regex.IsMatch(validateAttribute)) { success = false; errors |= ErrorType.Format; } if (success) { return(this.GetSuccessResult()); } else { attributeValue = Constants.SMTPRegex.IsMatch(attributeValue) ? attributeValue.Substring(0, attributeValue.IndexOf(":") + 1).Trim() + validateAttribute : validateAttribute; return(this.GetErrorResult(errors, attributeValue)); } }