public override bool Execute(SearchAttributeDetails field, List <Entity> entities)
        {
            foreach (var entity in entities)
            {
                var populated = true;
                if (!entity.Attributes.ContainsKey(field.LogicalName))
                {
                    populated = false;
                }
                else
                {
                    var attrValue = entity[field.LogicalName];
                    if (attrValue == null)
                    {
                        populated = false;
                    }
                }

                if (!populated)
                {
                    field.FailedRecords.Add(new FailedRecord()
                    {
                        Id            = entity.Id,
                        FailureReason = $"Required field not populated",
                        FailedValue   = ""
                    });
                }
            }

            return(field.FailedCount > 0);
        }
Пример #2
0
        public override bool Execute(SearchAttributeDetails field, List <Entity> entities)
        {
            Regex regex;

            switch (RegexType)
            {
            case "Email":
                // Using regex found here: https://www.rhyous.com/2010/06/15/csharp-email-regular-expression/
                var emailPattern = @".+\@.+\..+";
                regex = new Regex(emailPattern, RegexOptions.Compiled);
                break;

            case "UK Telephone":
                var ukPhoneRegex = @"(\s*\(?(0|\+44)(\s*|-)\d{4}\)?(\s*|-)\d{3}(\s*|-)\d{3}\s*)|(\s*\(?(0|\+44)(\s*|-)\d{3}\)?(\s*|-)\d{3}(\s*|-)\d{4}\s*)|(\s*\(?(0|\+44)(\s*|-)\d{2}\)?(\s*|-)\d{4}(\s*|-)\d{4}\s*)|(\s*(7|8)(\d{7}|\d{3}(\-|\s{1})\d{4})\s*)|(\s*\(?(0|\+44)(\s*|-)\d{3}\s\d{2}\)?(\s*|-)\d{4,5}\s*)";
                regex = new Regex(ukPhoneRegex, RegexOptions.Compiled);
                break;

            case "US Telephone":
                var usPhoneRegex = @"^(\([0-9]{3}\) |[0-9]{3}-)[0-9]{3}-[0-9]{4}$";
                regex = new Regex(usPhoneRegex, RegexOptions.Compiled);
                break;

            case "UK Postcode":
                var ukPostcodeRegex = @"^(([A-Z]{1,2}[0-9][A-Z0-9]?|ASCN|STHL|TDCU|BBND|[BFS]IQQ|PCRN|TKCA) ?[0-9][A-Z]{2}|BFPO ?[0-9]{1,4}|(KY[0-9]|MSR|VG|AI)[ -]?[0-9]{4}|[A-Z]{2} ?[0-9]{2}|GE ?CX|GIR ?0A{2}|SAN ?TA1)$";
                regex = new Regex(ukPostcodeRegex, RegexOptions.Compiled);
                break;

            case "US  Zipcode":
                var usZipcodeRegex = @"^[0-9]{5}(?:-[0-9]{4})?$";
                regex = new Regex(usZipcodeRegex, RegexOptions.Compiled);
                break;

            default:
                regex = new Regex("");
                break;
            }

            foreach (var entity in entities)
            {
                var fieldValue = entity.GetAttributeValue <string>(field.LogicalName);
                if (!string.IsNullOrEmpty(fieldValue))
                {
                    var regexMatch = regex.IsMatch(fieldValue);
                    if (!regexMatch)
                    {
                        field.FailedRecords.Add(new FailedRecord()
                        {
                            Id            = entity.Id,
                            FailureReason = $"Failed {RegexType} regex",
                            FailedValue   = fieldValue
                        });
                    }
                }
            }

            return(field.FailedCount > 0);
        }
Пример #3
0
        public TestSelectionForm(List <SearchAttributeDetails> allAttributes, SearchAttributeDetails attributeDetails)
        {
            InitializeComponent();
            this.allAttributes    = allAttributes;
            this.attributeDetails = attributeDetails;

            if (attributeDetails.RequiredLevel != Microsoft.Xrm.Sdk.Metadata.AttributeRequiredLevel.None)
            {
                requiredValidation.Visible = true;
            }
        }
 public virtual bool Execute(SearchAttributeDetails value, List <Entity> entities)
 {
     throw new NotImplementedException();
 }
Пример #5
0
        public override bool Execute(SearchAttributeDetails field, List <Entity> entities)
        {
            if (field.AttrType == SearchAttributeDetails.AttributeType.String)
            {
                field.PopulatedCount += entities.Count(t => !string.IsNullOrEmpty(t.GetAttributeValue <string>(field.LogicalName)));

                var invalidRecords = entities.Where(t => (t.GetAttributeValue <string>(field.LogicalName) ?? "").Length > field.MaxLength).ToList();
                field.FailedRecords.AddRange(invalidRecords.Select(r => new FailedRecord()
                {
                    Id            = r.Id,
                    FailureReason = "Text too long",
                    FailedValue   = r.GetAttributeValue <string>(field.LogicalName)
                }).ToList());
            }

            if (field.AttrType == SearchAttributeDetails.AttributeType.Int)
            {
                if (!field.IntMinValue.HasValue)
                {
                    field.IntMinValue = Int32.MinValue;
                }

                if (!field.IntMaxValue.HasValue)
                {
                    field.IntMaxValue = Int32.MaxValue;
                }

                var invalidRecords = entities.Where(t =>
                                                    t.GetAttributeValue <int?>(field.LogicalName) != null &&
                                                    t.GetAttributeValue <int?>(field.LogicalName).HasValue&&
                                                    (t.GetAttributeValue <int?>(field.LogicalName).Value <field.IntMinValue || t.GetAttributeValue <int?>(field.LogicalName).Value> field.IntMaxValue)).ToList();

                field.FailedRecords.AddRange(invalidRecords.Select(r => new FailedRecord()
                {
                    Id            = r.Id,
                    FailureReason = $"Number out of bounds",
                    FailedValue   = r.GetAttributeValue <string>(field.LogicalName)
                }).ToList());
            }

            if (field.AttrType == SearchAttributeDetails.AttributeType.BigInt)
            {
                if (!field.BigIntMinValue.HasValue)
                {
                    field.BigIntMinValue = long.MinValue;
                }

                if (!field.BigIntMaxValue.HasValue)
                {
                    field.BigIntMaxValue = long.MaxValue;
                }

                var invalidRecords = entities.Where(t =>
                                                    t.GetAttributeValue <long?>(field.LogicalName) != null &&
                                                    t.GetAttributeValue <long?>(field.LogicalName).HasValue&&
                                                    (t.GetAttributeValue <long?>(field.LogicalName).Value <= field.BigIntMinValue || t.GetAttributeValue <long?>(field.LogicalName).Value >= field.BigIntMaxValue)).ToList();

                field.FailedRecords.AddRange(invalidRecords.Select(r => new FailedRecord()
                {
                    Id            = r.Id,
                    FailureReason = $"Number out of bounds",
                    FailedValue   = r.GetAttributeValue <string>(field.LogicalName)
                }).ToList());
            }

            if (field.AttrType == SearchAttributeDetails.AttributeType.Double)
            {
                if (!field.DoubleMinValue.HasValue)
                {
                    field.DoubleMinValue = double.MinValue;
                }

                if (!field.DoubleMaxValue.HasValue)
                {
                    field.DoubleMaxValue = double.MaxValue;
                }

                var invalidRecords = entities.Where(t =>
                                                    t.GetAttributeValue <double?>(field.LogicalName) != null &&
                                                    t.GetAttributeValue <double?>(field.LogicalName).HasValue&&
                                                    (t.GetAttributeValue <double?>(field.LogicalName).Value <= field.DoubleMinValue || t.GetAttributeValue <double?>(field.LogicalName).Value >= field.DoubleMaxValue)).ToList();

                field.FailedRecords.AddRange(invalidRecords.Select(r => new FailedRecord()
                {
                    Id            = r.Id,
                    FailureReason = $"Number out of bounds",
                    FailedValue   = r.GetAttributeValue <string>(field.LogicalName)
                }).ToList());
            }

            if (field.AttrType == SearchAttributeDetails.AttributeType.Decimal)
            {
                if (!field.DecimalMinValue.HasValue)
                {
                    field.DecimalMinValue = decimal.MinValue;
                }

                if (!field.DecimalMaxValue.HasValue)
                {
                    field.DecimalMaxValue = decimal.MaxValue;
                }

                var invalidRecords = entities.Where(t =>
                                                    t.GetAttributeValue <decimal?>(field.LogicalName) != null &&
                                                    t.GetAttributeValue <decimal?>(field.LogicalName).HasValue&&
                                                    (t.GetAttributeValue <decimal?>(field.LogicalName).Value <= field.DecimalMinValue || t.GetAttributeValue <decimal?>(field.LogicalName).Value >= field.DecimalMaxValue)).ToList();
                field.FailedRecords.AddRange(invalidRecords.Select(r => new FailedRecord()
                {
                    Id            = r.Id,
                    FailureReason = $"Number out of bounds",
                    FailedValue   = r.GetAttributeValue <string>(field.LogicalName)
                }).ToList());
            }

            if (field.AttrType == SearchAttributeDetails.AttributeType.Picklist || field.AttrType == SearchAttributeDetails.AttributeType.State)
            {
                var invalidRecords = entities.Where(t =>
                                                    t.GetAttributeValue <OptionSetValue>(field.LogicalName) != null &&
                                                    !field.AllowableValues.Contains(t.GetAttributeValue <OptionSetValue>(field.LogicalName).Value)
                                                    ).ToList();

                field.FailedRecords.AddRange(invalidRecords.Select(r => new FailedRecord()
                {
                    Id            = r.Id,
                    FailureReason = $"Invalid option set value",
                    FailedValue   = r.GetAttributeValue <OptionSetValue>(field.LogicalName).Value.ToString()
                }).ToList());
            }

            if (field.AttrType == SearchAttributeDetails.AttributeType.Status)
            {
                foreach (var record in entities.Where(t => t.GetAttributeValue <OptionSetValue>(field.LogicalName) != null))
                {
                    var state  = record.GetAttributeValue <OptionSetValue>("statecode");
                    var status = record.GetAttributeValue <OptionSetValue>("statuscode");

                    var matchingConfig = field.StatusLookups.SingleOrDefault(s => s.StatusCode == status.Value);
                    if (matchingConfig == null)
                    {
                        field.FailedRecords.Add(new FailedRecord()
                        {
                            Id            = record.Id,
                            FailureReason = "Invalid status code",
                            FailedValue   = record.GetAttributeValue <OptionSetValue>(field.LogicalName).Value.ToString()
                        });
                    }
                    else if (matchingConfig.StateCode != state.Value)
                    {
                        field.FailedRecords.Add(new FailedRecord()
                        {
                            Id            = record.Id,
                            FailureReason = "State code does not correlate with status code"
                        });
                    }
                }
            }

            return(field.FailedRecords.Any());
        }