private void CreateRoleAssignmentDefinition(RoleAssignmentDefinition roleAssignmentDefinition, ADGroup roleGroup, List <ExchangeRole> precannedRoles)
        {
            List <ExchangeRole> list = precannedRoles.FindAll((ExchangeRole x) => x.RoleType.Equals(roleAssignmentDefinition.RoleType));

            if (roleAssignmentDefinition.UseSafeRole)
            {
                List <ExchangeRole> list2 = new List <ExchangeRole>(list.Count);
                foreach (ExchangeRole cannedRole in list)
                {
                    ExchangeRole exchangeRole = this.TryFindSafeDCRoleOrUseDefault(cannedRole);
                    if (exchangeRole != null)
                    {
                        list2.Add(exchangeRole);
                    }
                }
                list = list2;
            }
            foreach (ExchangeRole role in list)
            {
                if (!this.FindRoleAssignment(role, roleGroup, roleAssignmentDefinition.DelegationType))
                {
                    this.CreateRoleAssignment(role, roleGroup, roleAssignmentDefinition.DelegationType);
                }
            }
        }
        private void RemoveRoleAssignmentDefinition(RoleAssignmentDefinition roleAssignmentDefinition, List <ExchangeRole> precannedRoles)
        {
            List <ExchangeRole> list = precannedRoles.FindAll((ExchangeRole x) => x.RoleType.Equals(roleAssignmentDefinition.RoleType));

            foreach (ExchangeRole exchangeRole in list)
            {
                this.RemoveAllRoleAssignmentsForOneRole(exchangeRole, roleAssignmentDefinition.DelegationType);
                foreach (ExchangeRole role in this.configurationSession.FindPaged <ExchangeRole>(exchangeRole.Id, QueryScope.SubTree, null, null, 0))
                {
                    this.RemoveAllRoleAssignmentsForOneRole(role, roleAssignmentDefinition.DelegationType);
                }
            }
        }
 private void CheckRoleAssignmentDefinition(RoleAssignmentDefinition roleAssignment)
 {
     if (roleAssignment.UseSafeRole)
     {
         if (!Datacenter.IsMicrosoftHostedOnly(false))
         {
             Datacenter.IsDatacenterDedicated(false);
         }
         if (Datacenter.IsMicrosoftHostedOnly(false) || Datacenter.IsDatacenterDedicated(false))
         {
             OrganizationIdParameter organization = this.Organization;
         }
     }
 }
        private void PurgeInvalidAssignmentsFromRoleGroup(RoleGroupRoleMapping rgMapping, ADGroup roleGroup, List <ExchangeRole> topCannedRoles)
        {
            TaskLogger.LogEnter();
            if (!InstallCannedRbacRoleAssignments.MonitoredDCOnlyRoleGroups.Contains(rgMapping.RoleGroup))
            {
                return;
            }
            List <string> list = new List <string>(rgMapping.Assignments.Length * 2);

            RoleAssignmentDefinition[] assignments = rgMapping.Assignments;
            for (int i = 0; i < assignments.Length; i++)
            {
                RoleAssignmentDefinition assignmentDefinition = assignments[i];
                List <ExchangeRole>      list2 = topCannedRoles.FindAll((ExchangeRole x) => x.RoleType.Equals(assignmentDefinition.RoleType));
                if (list2 != null)
                {
                    foreach (ExchangeRole exchangeRole in list2)
                    {
                        list.Add(exchangeRole.DistinguishedName);
                        list.Add(exchangeRole.Id.GetChildId(RoleDefinition.GetDCSafeNameForRole(exchangeRole.Name)).DistinguishedName);
                    }
                }
            }
            ADPagedReader <ExchangeRoleAssignment> adpagedReader = this.configurationSession.FindPaged <ExchangeRoleAssignment>(base.OrgContainerId.GetDescendantId(ExchangeRoleAssignment.RdnContainer), QueryScope.SubTree, new ComparisonFilter(ComparisonOperator.Equal, ExchangeRoleAssignmentSchema.User, roleGroup.Id), null, 0);

            using (IEnumerator <ExchangeRoleAssignment> enumerator2 = adpagedReader.GetEnumerator())
            {
                while (enumerator2.MoveNext())
                {
                    ExchangeRoleAssignment roleAssignment = enumerator2.Current;
                    if (!list.Contains(roleAssignment.Role.DistinguishedName, StringComparer.OrdinalIgnoreCase))
                    {
                        if (topCannedRoles.Find((ExchangeRole x) => x.Name.Equals(roleAssignment.Role.Name, StringComparison.OrdinalIgnoreCase) && x.RoleType.Equals(RoleType.UnScoped)) == null)
                        {
                            ExchangeRole exchangeRole2 = this.configurationSession.Read <ExchangeRole>(roleAssignment.Role);
                            if (exchangeRole2 != null && !exchangeRole2.RoleType.Equals(RoleType.UnScoped))
                            {
                                this.RemoveRoleAssignment(roleAssignment);
                            }
                        }
                    }
                }
            }
            TaskLogger.LogExit();
        }