// Token: 0x06001D48 RID: 7496 RVA: 0x00079EF8 File Offset: 0x000780F8
        private static void InternalStringValuesSetter(object value, IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, string filterPrefix)
        {
            MultiValuedProperty <string> multiValuedProperty = (MultiValuedProperty <string>)propertyBag[filterMeatadata];

            RecipientFilterHelper.ClearNonExchange12RecipientFilterMetadata(multiValuedProperty);
            int num = multiValuedProperty.Count - 1;

            while (0 <= num)
            {
                if (multiValuedProperty[num].StartsWith(filterPrefix, StringComparison.OrdinalIgnoreCase))
                {
                    multiValuedProperty.RemoveAt(num);
                }
                num--;
            }
            MultiValuedProperty <string> multiValuedProperty2 = (MultiValuedProperty <string>)value;

            if (multiValuedProperty2 != null && multiValuedProperty2.Count != 0)
            {
                foreach (string text in multiValuedProperty2)
                {
                    if (!string.IsNullOrEmpty(text))
                    {
                        multiValuedProperty.Add(filterPrefix + text);
                    }
                }
            }
        }
        // Token: 0x0600196F RID: 6511 RVA: 0x0006BCDC File Offset: 0x00069EDC
        protected override void ValidateWrite(List <ValidationError> errors)
        {
            base.ValidateWrite(errors);
            if (this.ReportToManagerEnabled && this.ManagedBy == null)
            {
                errors.Add(new ObjectValidationError(DirectoryStrings.ErrorReportToManagedEnabledWithoutManager(this.Identity.ToString(), ADDynamicGroupSchema.ReportToManagerEnabled.Name), this.Identity, string.Empty));
            }
            if (this.ReportToManagerEnabled && this.ReportToOriginatorEnabled)
            {
                errors.Add(new ObjectValidationError(DirectoryStrings.ErrorReportToBothManagerAndOriginator(this.Identity.ToString(), ADDynamicGroupSchema.ReportToManagerEnabled.Name, ADDynamicGroupSchema.ReportToOriginatorEnabled.Name), this.Identity, string.Empty));
            }
            if (this.RecipientContainer == null)
            {
                errors.Add(new PropertyValidationError(DirectoryStrings.ErrorRecipientContainerCanNotNull, ADDynamicGroupSchema.RecipientContainer, string.Empty));
            }
            if (string.IsNullOrEmpty(this.RecipientFilter) && (base.IsModified(ADDynamicGroupSchema.RecipientFilter) || base.ObjectState == ObjectState.New))
            {
                errors.Add(new PropertyValidationError(DirectoryStrings.ErrorInvalidOpathFilter(this.RecipientFilter ?? string.Empty), ADDynamicGroupSchema.RecipientFilter, string.Empty));
            }
            ValidationError validationError = RecipientFilterHelper.ValidatePrecannedRecipientFilter(this.propertyBag, ADDynamicGroupSchema.RecipientFilterMetadata, ADDynamicGroupSchema.RecipientFilter, ADDynamicGroupSchema.IncludedRecipients, this.Identity);

            if (validationError != null)
            {
                errors.Add(validationError);
            }
        }
 // Token: 0x06001955 RID: 6485 RVA: 0x0006BA74 File Offset: 0x00069C74
 internal void SetRecipientFilter(QueryFilter filter)
 {
     if (filter == null)
     {
         this[ADDynamicGroupSchema.RecipientFilter]     = string.Empty;
         this[ADDynamicGroupSchema.LdapRecipientFilter] = string.Empty;
     }
     else
     {
         QueryFilter queryFilter = new AndFilter(new QueryFilter[]
         {
             filter,
             RecipientFilterHelper.ExcludingSystemMailboxFilter,
             RecipientFilterHelper.ExcludingCasMailboxFilter,
             RecipientFilterHelper.ExcludingMailboxPlanFilter,
             RecipientFilterHelper.ExcludingDiscoveryMailboxFilter,
             RecipientFilterHelper.ExcludingPublicFolderMailboxFilter,
             RecipientFilterHelper.ExcludingArbitrationMailboxFilter,
             RecipientFilterHelper.ExcludingAuditLogMailboxFilter
         });
         this[ADDynamicGroupSchema.RecipientFilter]     = queryFilter.GenerateInfixString(FilterLanguage.Monad);
         this[ADDynamicGroupSchema.LdapRecipientFilter] = LdapFilterBuilder.LdapFilterFromQueryFilter(queryFilter);
     }
     RecipientFilterHelper.SetRecipientFilterType(WellKnownRecipientFilterType.Custom, this.propertyBag, ADDynamicGroupSchema.RecipientFilterMetadata);
 }
 // Token: 0x06001D44 RID: 7492 RVA: 0x00079D1C File Offset: 0x00077F1C
 internal static ValidationError ValidatePrecannedRecipientFilter(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition includedRecipients, ObjectId id)
 {
     if (!RecipientFilterHelper.IsValidRecipientFilterMetadata(propertyBag, filterMeatadata, filter, includedRecipients))
     {
         return(new ObjectValidationError(DirectoryStrings.ErrorNullRecipientTypeInPrecannedFilter(includedRecipients.Name), id, string.Empty));
     }
     return(null);
 }
        // Token: 0x06001D52 RID: 7506 RVA: 0x0007A160 File Offset: 0x00078360
        internal static void SetRecipientFilterType(WellKnownRecipientFilterType type, IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata)
        {
            if (WellKnownRecipientFilterType.Custom == type)
            {
                MultiValuedProperty <string> multiValuedProperty = (MultiValuedProperty <string>)propertyBag[filterMeatadata];
                if (0 < multiValuedProperty.Count)
                {
                    multiValuedProperty.Clear();
                }
            }
            int num = (int)type;

            RecipientFilterHelper.InternalStringValuesSetter(new MultiValuedProperty <string>(num.ToString()), propertyBag, filterMeatadata, "Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:RecipientFilterType=");
        }
 // Token: 0x06001D42 RID: 7490 RVA: 0x00079CD4 File Offset: 0x00077ED4
 private static bool MergeConditionFilter(MultiValuedProperty <string> conditionVal, ADPropertyDefinition conditionDef, List <QueryFilter> conditions, bool noRecipients, bool validationOnly)
 {
     if (conditionVal != null && conditionVal.Count > 0)
     {
         if (noRecipients)
         {
             return(false);
         }
         if (!validationOnly)
         {
             QueryFilter queryFilter = RecipientFilterHelper.ConstructSimpleComparisionFilters(conditionVal, conditionDef);
             if (queryFilter != null)
             {
                 conditions.Add(queryFilter);
             }
         }
     }
     return(true);
 }
        // Token: 0x06001D40 RID: 7488 RVA: 0x00079A68 File Offset: 0x00077C68
        private static void PersistPrecannedRecipientFilter(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition ldapFilter, bool isDynamicGroup)
        {
            List <QueryFilter> list = new List <QueryFilter>();

            switch (RecipientFilterHelper.GetPrecannedRecipientFilter(propertyBag, filterMeatadata, filter, ldapFilter, false, list))
            {
            case -1:
                break;

            case 0:
                propertyBag[filter]     = string.Empty;
                propertyBag[ldapFilter] = string.Empty;
                return;

            default:
                if (list.Count > 0)
                {
                    QueryFilter queryFilter = (list.Count > 1) ? new AndFilter(list.ToArray()) : list[0];
                    if (isDynamicGroup)
                    {
                        queryFilter = new AndFilter(new QueryFilter[]
                        {
                            queryFilter,
                            RecipientFilterHelper.ExcludingSystemMailboxFilter,
                            RecipientFilterHelper.ExcludingCasMailboxFilter,
                            RecipientFilterHelper.ExcludingMailboxPlanFilter,
                            RecipientFilterHelper.ExcludingDiscoveryMailboxFilter,
                            RecipientFilterHelper.ExcludingPublicFolderMailboxFilter,
                            RecipientFilterHelper.ExcludingArbitrationMailboxFilter,
                            RecipientFilterHelper.ExcludingAuditLogMailboxFilter
                        });
                    }
                    propertyBag[filter]     = queryFilter.GenerateInfixString(FilterLanguage.Monad);
                    propertyBag[ldapFilter] = LdapFilterBuilder.LdapFilterFromQueryFilter(queryFilter);
                }
                break;
            }
        }
        // Token: 0x06001D57 RID: 7511 RVA: 0x0007A2C4 File Offset: 0x000784C4
        internal static bool FixExchange12RecipientFilterMetadata(IPropertyBag propertyBag, ADPropertyDefinition objectVersionProperty, ADPropertyDefinition e2003MetadataProperty, ADPropertyDefinition e12MetadataProperty, string ldapRecipientFilter)
        {
            MultiValuedProperty <string> multiValuedProperty  = (MultiValuedProperty <string>)propertyBag[e2003MetadataProperty];
            MultiValuedProperty <string> multiValuedProperty2 = (MultiValuedProperty <string>)propertyBag[e12MetadataProperty];
            bool flag = false;

            if (ExchangeObjectVersion.Exchange2007.IsSameVersion((ExchangeObjectVersion)propertyBag[objectVersionProperty]))
            {
                if (multiValuedProperty2.Count == 0)
                {
                    foreach (string text in multiValuedProperty)
                    {
                        if (text.StartsWith("Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:", StringComparison.OrdinalIgnoreCase))
                        {
                            multiValuedProperty2.Add(text);
                            flag = true;
                        }
                    }
                }
                flag |= RecipientFilterHelper.StampE2003FilterMetadata(propertyBag, ldapRecipientFilter, e2003MetadataProperty);
            }
            return(flag);
        }
        // Token: 0x06001D41 RID: 7489 RVA: 0x00079B54 File Offset: 0x00077D54
        private static int GetPrecannedRecipientFilter(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition ldapFilter, bool validationOnly, List <QueryFilter> conditions)
        {
            WellKnownRecipientType?wellKnownRecipientType = (WellKnownRecipientType?)RecipientFilterHelper.IncludeRecipientGetter(propertyBag, filterMeatadata, filter);
            bool flag = wellKnownRecipientType == null || wellKnownRecipientType == WellKnownRecipientType.None;

            if (!flag && validationOnly)
            {
                return(1);
            }
            MultiValuedProperty <string> conditionVal = (MultiValuedProperty <string>)RecipientFilterHelper.DepartmentGetter(propertyBag, filterMeatadata, filter, null);

            if (!RecipientFilterHelper.MergeConditionFilter(conditionVal, ADOrgPersonSchema.Department, conditions, flag, validationOnly))
            {
                return(-1);
            }
            MultiValuedProperty <string> conditionVal2 = (MultiValuedProperty <string>)RecipientFilterHelper.CompanyGetter(propertyBag, filterMeatadata, filter, null);

            if (!RecipientFilterHelper.MergeConditionFilter(conditionVal2, ADOrgPersonSchema.Company, conditions, flag, validationOnly))
            {
                return(-1);
            }
            MultiValuedProperty <string> conditionVal3 = (MultiValuedProperty <string>)RecipientFilterHelper.StateOrProvinceGetter(propertyBag, filterMeatadata, filter, null);

            if (!RecipientFilterHelper.MergeConditionFilter(conditionVal3, ADOrgPersonSchema.StateOrProvince, conditions, flag, validationOnly))
            {
                return(-1);
            }
            foreach (ADPropertyDefinition adpropertyDefinition in RecipientFilterHelper.allCustomAttributePropertyDefinition)
            {
                MultiValuedProperty <string> conditionVal4 = (MultiValuedProperty <string>)RecipientFilterHelper.InternalStringValuesGetter(propertyBag, filterMeatadata, filter, null, "Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:" + adpropertyDefinition.Name + "=");
                if (!RecipientFilterHelper.MergeConditionFilter(conditionVal4, adpropertyDefinition, conditions, flag, validationOnly))
                {
                    return(-1);
                }
            }
            if (wellKnownRecipientType == WellKnownRecipientType.None)
            {
                return(0);
            }
            if (validationOnly)
            {
                return(1);
            }
            if (wellKnownRecipientType != null)
            {
                List <QueryFilter> recipientTypeFilter = RecipientFilterHelper.GetRecipientTypeFilter(wellKnownRecipientType);
                if (recipientTypeFilter.Count > 1)
                {
                    conditions.Add(new OrFilter(recipientTypeFilter.ToArray()));
                }
                else
                {
                    if (recipientTypeFilter.Count != 1)
                    {
                        return(-1);
                    }
                    conditions.Add(recipientTypeFilter[0]);
                }
            }
            return(1);
        }
 // Token: 0x06001D46 RID: 7494 RVA: 0x00079DFC File Offset: 0x00077FFC
 internal static void IncludeRecipientSetter(object value, IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition ldapFilter, bool isDynamicGroup)
 {
     RecipientFilterHelper.InternalStringValuesSetter(new MultiValuedProperty <string>(((int)((WellKnownRecipientType?)(value ?? WellKnownRecipientType.None)).Value).ToString()), propertyBag, filterMeatadata, "Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:IncludedRecipients=");
     RecipientFilterHelper.SetRecipientFilterType(WellKnownRecipientFilterType.Precanned, propertyBag, filterMeatadata);
     RecipientFilterHelper.PersistPrecannedRecipientFilter(propertyBag, filterMeatadata, filter, ldapFilter, isDynamicGroup);
 }
 // Token: 0x06001D4F RID: 7503 RVA: 0x0007A068 File Offset: 0x00078268
 internal static object StateOrProvinceGetter(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition filterPropertyDefinition)
 {
     return(RecipientFilterHelper.InternalStringValuesGetter(propertyBag, filterMeatadata, filter, filterPropertyDefinition, "Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:StateOrProvincePrefix="));
 }
 // Token: 0x06001D50 RID: 7504 RVA: 0x0007A078 File Offset: 0x00078278
 internal static void StateOrProvinceSetter(object value, IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition ldapFilter, bool isDynamicGroup)
 {
     RecipientFilterHelper.InternalStringValuesSetter(value, propertyBag, filterMeatadata, "Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:StateOrProvincePrefix=");
     RecipientFilterHelper.SetRecipientFilterType(WellKnownRecipientFilterType.Precanned, propertyBag, filterMeatadata);
     RecipientFilterHelper.PersistPrecannedRecipientFilter(propertyBag, filterMeatadata, filter, ldapFilter, isDynamicGroup);
 }
 // Token: 0x06001D4C RID: 7500 RVA: 0x00079FFC File Offset: 0x000781FC
 internal static void CustomAttributeSetter(object value, IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition filterPropertyDefinition, ADPropertyDefinition ldapFilter, bool isDynamicGroup)
 {
     RecipientFilterHelper.InternalStringValuesSetter(value, propertyBag, filterMeatadata, "Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:" + RecipientFilterHelper.ConditionalToCustomAttributeNameMap[filterPropertyDefinition] + "=");
     RecipientFilterHelper.SetRecipientFilterType(WellKnownRecipientFilterType.Precanned, propertyBag, filterMeatadata);
     RecipientFilterHelper.PersistPrecannedRecipientFilter(propertyBag, filterMeatadata, filter, ldapFilter, isDynamicGroup);
 }
 // Token: 0x06001D4B RID: 7499 RVA: 0x00079FD7 File Offset: 0x000781D7
 internal static object CustomAttributeGetter(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition filterPropertyDefinition)
 {
     return(RecipientFilterHelper.InternalStringValuesGetter(propertyBag, filterMeatadata, filter, filterPropertyDefinition, "Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:" + RecipientFilterHelper.ConditionalToCustomAttributeNameMap[filterPropertyDefinition] + "="));
 }
 // Token: 0x06001D43 RID: 7491 RVA: 0x00079D09 File Offset: 0x00077F09
 private static bool IsValidRecipientFilterMetadata(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition includedRecipients)
 {
     return(0 <= RecipientFilterHelper.GetPrecannedRecipientFilter(propertyBag, filterMeatadata, filter, null, true, null));
 }
        // Token: 0x06001D47 RID: 7495 RVA: 0x00079E50 File Offset: 0x00078050
        private static object InternalStringValuesGetter(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter, ADPropertyDefinition filterPropertyDefinition, string filterPrefix)
        {
            MultiValuedProperty <string> result = null;

            if (WellKnownRecipientFilterType.Precanned == (WellKnownRecipientFilterType)RecipientFilterHelper.RecipientFilterTypeGetter(propertyBag, filterMeatadata, filter))
            {
                MultiValuedProperty <string> multiValuedProperty = (MultiValuedProperty <string>)propertyBag[filterMeatadata];
                Collection <string>          collection          = new Collection <string>();
                foreach (string text in multiValuedProperty)
                {
                    if (text.StartsWith(filterPrefix, StringComparison.OrdinalIgnoreCase) && !text.Equals(filterPrefix, StringComparison.OrdinalIgnoreCase))
                    {
                        collection.Add(text.Substring(filterPrefix.Length));
                    }
                }
                result = new MultiValuedProperty <string>(multiValuedProperty.IsReadOnly, filterPropertyDefinition, collection);
            }
            return(result);
        }
        // Token: 0x06001D45 RID: 7493 RVA: 0x00079D44 File Offset: 0x00077F44
        internal static object IncludeRecipientGetter(IPropertyBag propertyBag, ADPropertyDefinition filterMeatadata, ADPropertyDefinition filter)
        {
            WellKnownRecipientType?wellKnownRecipientType = null;

            if (WellKnownRecipientFilterType.Precanned == (WellKnownRecipientFilterType)RecipientFilterHelper.RecipientFilterTypeGetter(propertyBag, filterMeatadata, filter))
            {
                MultiValuedProperty <string> multiValuedProperty = (MultiValuedProperty <string>)propertyBag[filterMeatadata];
                wellKnownRecipientType = new WellKnownRecipientType?(WellKnownRecipientType.None);
                foreach (string text in multiValuedProperty)
                {
                    if (text.StartsWith("Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:IncludedRecipients=", StringComparison.OrdinalIgnoreCase))
                    {
                        int value;
                        if (int.TryParse(text.Substring("Microsoft.Exchange12.8f91d340bc0c47e4b4058a479602f94c:IncludedRecipients=".Length), out value))
                        {
                            wellKnownRecipientType = new WellKnownRecipientType?((WellKnownRecipientType)value);
                            break;
                        }
                        wellKnownRecipientType = null;
                        break;
                    }
                }
            }
            return(wellKnownRecipientType);
        }