protected override void InternalValidate()
{
base.InternalValidate();
IRMConfiguration dataObject = this.DataObject;
try
{
this.ValidateCommon();
this.datacenter = (Datacenter.IsMicrosoftHostedOnly(true) || Datacenter.IsPartnerHostedOnly(true));
if (this.datacenter)
{
this.ValidateForDC(dataObject);
}
else
{
this.ValidateForEnterprise(dataObject);
}
}
catch (CannotDetermineExchangeModeException exception)
{
base.WriteError(SetIRMConfiguration.GetExceptionInfo(exception), ErrorCategory.InvalidOperation, base.Identity);
}
catch (ExchangeConfigurationException exception2)
{
base.WriteError(SetIRMConfiguration.GetExceptionInfo(exception2), ErrorCategory.InvalidOperation, base.Identity);
}
catch (RightsManagementException exception3)
{
base.WriteError(SetIRMConfiguration.GetExceptionInfo(exception3), ErrorCategory.InvalidOperation, base.Identity);
}
}
private RoleGroupCollection GetInvalidRoleGroups()
{
bool flag = Datacenter.IsPartnerHostedOnly(false);
RoleGroupCollection roleGroupCollection = new RoleGroupCollection();
List <string> enabledRoleGroupRoleAssignmentFeatures = this.ServicePlanSettings.Organization.GetEnabledRoleGroupRoleAssignmentFeatures();
using (List <RoleGroupDefinition> .Enumerator enumerator = RoleGroupDefinitions.RoleGroups.GetEnumerator())
{
while (enumerator.MoveNext())
{
RoleGroupDefinition roleGroupDefinition = enumerator.Current;
RoleGroupRoleMapping roleGroupRoleMapping;
if (flag)
{
roleGroupRoleMapping = HostedTenant_RoleGroupDefinition.Definition.FirstOrDefault((RoleGroupRoleMapping x) => x.RoleGroup.Equals(roleGroupDefinition.Name, StringComparison.OrdinalIgnoreCase));
}
else
{
roleGroupRoleMapping = Tenant_RoleGroupDefinition.Definition.FirstOrDefault((RoleGroupRoleMapping x) => x.RoleGroup.Equals(roleGroupDefinition.Name, StringComparison.OrdinalIgnoreCase));
}
if (roleGroupRoleMapping != null && roleGroupRoleMapping.GetRolesAssignments(enabledRoleGroupRoleAssignmentFeatures).Count == 0)
{
roleGroupCollection.Add(new RoleGroupDefinition(roleGroupDefinition));
}
}
}
return(roleGroupCollection);
}
private RoleGroupRoleMapping[] GetRoleGroupAssignmentsDefinition()
{
if (this.Organization == null)
{
if (Datacenter.IsMicrosoftHostedOnly(false))
{
return(Datacenter_RoleGroupDefinition.Definition);
}
if (Datacenter.IsPartnerHostedOnly(false))
{
return(Hosting_RoleGroupDefinition.Definition);
}
if (Datacenter.IsDatacenterDedicated(false))
{
return(Dedicated_RoleGroupDefinition.Definition);
}
return(Enterprise_RoleGroupDefinition.Definition);
}
else
{
if (Datacenter.IsPartnerHostedOnly(false))
{
return(HostedTenant_RoleGroupDefinition.Definition);
}
return(Tenant_RoleGroupDefinition.Definition);
}
}
static ServicePlanConfiguration()
{
ServicePlanConfiguration.servicePlansFolder = Path.Combine(ConfigurationContext.Setup.InstallPath, "ClientAccess\\ServicePlans");
if (Datacenter.IsPartnerHostedOnly(false))
{
ServicePlanConfiguration.remapFile = Path.Combine(ServicePlanConfiguration.servicePlansFolder, "ServicePlanHostingRemap.csv");
return;
}
ServicePlanConfiguration.remapFile = Path.Combine(ServicePlanConfiguration.servicePlansFolder, "ServicePlanRemap.csv");
}
public ManageOrganizationTaskBase()
{
base.ImplementsResume = false;
base.IsTenantOrganization = true;
base.IsDatacenter = Datacenter.IsMicrosoftHostedOnly(false);
base.IsPartnerHosted = Datacenter.IsPartnerHostedOnly(false);
base.ComponentInfoFileNames = new List <string>();
base.ShouldLoadDatacenterConfigFile = false;
this.InitializeComponentInfoFileNames();
}
private List <string> GetCannedRoleNames()
{
RoleDefinition[] array;
if (InstallCannedRbacRoleAssignments.isFfoEnvironment)
{
array = InstallCannedRbacRoles.MergeRoleDefinitions(CannedEOPRoles_Datacenter.Definition, CannedUCCRoles_Datacenter.Definition);
}
else if (this.Organization == null)
{
if (Datacenter.IsMicrosoftHostedOnly(false))
{
array = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Datacenter.Definition, CannedWebServiceRoles_Datacenter.Definition);
}
else if (Datacenter.IsPartnerHostedOnly(false))
{
array = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Hosting.Definition, CannedWebServiceRoles_Hosting.Definition);
}
else if (Datacenter.IsDatacenterDedicated(false))
{
array = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Dedicated.Definition, CannedWebServiceRoles_Hosting.Definition);
}
else
{
array = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Enterprise.Definition, CannedWebServiceRoles_Enterprise.Definition);
}
}
else if (Datacenter.IsPartnerHostedOnly(false))
{
array = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_HostedTenant.Definition, CannedWebServiceRoles_HostedTenant.Definition);
}
else
{
array = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Tenant.Definition, CannedWebServiceRoles_Tenant.Definition);
}
List <string> list = new List <string>(array.Length);
foreach (RoleDefinition roleDefinition in array)
{
list.Add(roleDefinition.RoleName);
if (base.ServicePlanSettings != null && Array.BinarySearch <RoleType>(ExchangeRole.EndUserRoleTypes, roleDefinition.RoleType) >= 0)
{
foreach (ServicePlan.MailboxPlan mailboxPlan in base.ServicePlanSettings.MailboxPlans)
{
list.Add(string.Format("{0}_{1}", roleDefinition.RoleName, mailboxPlan.Name));
}
}
}
list.Sort();
return(list);
}
private bool TryIsDatacenter()
{
this.result.SetTask(Strings.InfoCheckMode);
try
{
this.datacenter = (Datacenter.IsMicrosoftHostedOnly(true) || Datacenter.IsPartnerHostedOnly(true));
this.result.SetSuccessResult(this.datacenter ? Strings.InfoDatacenterMode : Strings.InfoEnterpriseMode);
}
catch (CannotDetermineExchangeModeException ex)
{
this.result.SetFailureResult(Strings.ErrorFailedToCheckMode, ex, true);
return(false);
}
return(true);
}
// Token: 0x06000AC1 RID: 2753 RVA: 0x000469EC File Offset: 0x00044BEC
private Hashtable GetUMEnabledUsersFromAD()
{
MailboxDatabase database = this.rootOrgConfigSession.Read <MailboxDatabase>(new ADObjectId(base.DatabaseInfo.Guid));
if (VariantConfiguration.InvariantNoFlightingSnapshot.MailboxAssistants.MwiAssistantGetUMEnabledUsersFromDatacenter.Enabled)
{
ExTraceGlobals.MWITracer.TraceDebug((long)this.GetHashCode(), "GetUMEnabledUsersFromAD() - Microsoft Hosted Topology.");
return(this.GetUMEnabledUsersDatacenter(database));
}
if (Datacenter.IsPartnerHostedOnly(true))
{
ExTraceGlobals.MWITracer.TraceDebug((long)this.GetHashCode(), "GetUMEnabledUsersFromAD() - Partner Hosted Topology.");
return(new Hashtable());
}
ExTraceGlobals.MWITracer.TraceDebug((long)this.GetHashCode(), "GetUMEnabledUsersFromAD() - Enterprise Topology.");
return(this.GetUMEnabledUsersEnterprise(database));
}
internal static RoleGroupCollection RoleGroupsToCreate()
{
RoleGroupCollection roleGroupCollection = new RoleGroupCollection();
Datacenter.ExchangeSku exchangeSku = Datacenter.GetExchangeSku();
RoleGroupRoleMapping[] definition;
if (Datacenter.IsMicrosoftHostedOnly(false))
{
definition = Datacenter_RoleGroupDefinition.Definition;
}
else if (Datacenter.IsPartnerHostedOnly(false))
{
definition = Hosting_RoleGroupDefinition.Definition;
}
else if (Datacenter.IsDatacenterDedicated(false))
{
definition = Dedicated_RoleGroupDefinition.Definition;
}
else
{
definition = Enterprise_RoleGroupDefinition.Definition;
}
using (List <RoleGroupDefinition> .Enumerator enumerator = RoleGroupDefinitions.RoleGroups.GetEnumerator())
{
while (enumerator.MoveNext())
{
RoleGroupDefinition roleGroup = enumerator.Current;
if (roleGroup.AlwaysCreateOnSku != null && roleGroup.AlwaysCreateOnSku.Contains(exchangeSku))
{
roleGroupCollection.Add(new RoleGroupDefinition(roleGroup));
}
else
{
RoleGroupRoleMapping roleGroupRoleMapping = definition.FirstOrDefault((RoleGroupRoleMapping x) => x.RoleGroup.Equals(roleGroup.Name, StringComparison.OrdinalIgnoreCase));
if (roleGroupRoleMapping != null)
{
roleGroupCollection.Add(new RoleGroupDefinition(roleGroup));
}
}
}
}
return(roleGroupCollection);
}
static Util()
{
try
{
Util.isMicrosoftHostedOnly = Datacenter.IsMicrosoftHostedOnly(true);
}
catch (CannotDetermineExchangeModeException)
{
Util.isMicrosoftHostedOnly = false;
}
try
{
Util.isPartnerHostedOnly = Datacenter.IsPartnerHostedOnly(true);
}
catch (CannotDetermineExchangeModeException)
{
Util.isPartnerHostedOnly = false;
}
Util.isDataCenter = Datacenter.IsMultiTenancyEnabled();
}
internal List <ValidationError> ValidateFeaturesAllowedForSKU()
{
List <ValidationError> list = new List <ValidationError>();
ServicePlanSkus servicePlanSkus;
if (Datacenter.IsPartnerHostedOnly(false))
{
servicePlanSkus = ServicePlanSkus.Hosted;
}
else
{
servicePlanSkus = ServicePlanSkus.Datacenter;
}
foreach (object obj in this.propertyBag.Keys)
{
FeatureDefinition featureDefinition = (FeatureDefinition)obj;
if ((byte)(featureDefinition.ServicePlanSkus & servicePlanSkus) == 0)
{
list.Add(new ServicePlanFeaturesValidationError(featureDefinition.Name, servicePlanSkus.ToString()));
}
}
return(list);
}
protected override IConfigurable PrepareDataObject()
{
TaskLogger.LogEnter();
ExchangeConfigurationUnit exchangeConfigurationUnit = (ExchangeConfigurationUnit)base.PrepareDataObject();
if (base.Fields.IsModified(OrganizationSchema.DefaultMovePriority))
{
exchangeConfigurationUnit.DefaultMovePriority = this.DefaultMovePriority;
}
if (base.Fields.IsModified("TenantSKUCapability"))
{
CapabilityHelper.SetTenantSKUCapabilities(this.PersistedCapabilities, exchangeConfigurationUnit.PersistedCapabilities);
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeMessage))
{
exchangeConfigurationUnit.UpgradeMessage = this.UpgradeMessage;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeDetails))
{
exchangeConfigurationUnit.UpgradeDetails = this.UpgradeDetails;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeConstraints))
{
exchangeConfigurationUnit.UpgradeConstraints = this.UpgradeConstraints;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeStage))
{
exchangeConfigurationUnit.UpgradeStage = this.UpgradeStage;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeStageTimeStamp))
{
exchangeConfigurationUnit.UpgradeStageTimeStamp = this.UpgradeStageTimeStamp;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeE14RequestCountForCurrentStage))
{
exchangeConfigurationUnit.UpgradeE14RequestCountForCurrentStage = this.UpgradeE14RequestCountForCurrentStage;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeE14MbxCountForCurrentStage))
{
exchangeConfigurationUnit.UpgradeE14MbxCountForCurrentStage = this.UpgradeE14MbxCountForCurrentStage;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeLastE14CountsUpdateTime))
{
exchangeConfigurationUnit.UpgradeLastE14CountsUpdateTime = this.UpgradeLastE14CountsUpdateTime;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeConstraintsDisabled))
{
exchangeConfigurationUnit.UpgradeConstraintsDisabled = this.UpgradeConstraintsDisabled;
}
if (base.Fields.IsModified(OrganizationSchema.UpgradeUnitsOverride))
{
exchangeConfigurationUnit.UpgradeUnitsOverride = this.UpgradeUnitsOverride;
}
if (base.Fields.IsModified(OrganizationSchema.MaxAddressBookPolicies))
{
exchangeConfigurationUnit.MaxAddressBookPolicies = new int?(this.MaxAddressBookPolicies);
}
if (base.Fields.IsModified(OrganizationSchema.MaxOfflineAddressBooks))
{
exchangeConfigurationUnit.MaxOfflineAddressBooks = new int?(this.MaxOfflineAddressBooks);
}
if (this.RemoveSharedConfigurations)
{
exchangeConfigurationUnit.SupportedSharedConfigurations.Clear();
}
if (base.Fields.IsModified(OrganizationSchema.SupportedSharedConfigurations))
{
if (this.ClearPreviousSharedConfigurations)
{
exchangeConfigurationUnit.SupportedSharedConfigurations.Clear();
}
foreach (ExchangeConfigurationUnit exchangeConfigurationUnit2 in this.SharedConfigurationUnits)
{
if (!exchangeConfigurationUnit.SupportedSharedConfigurations.Contains(exchangeConfigurationUnit2.OrganizationId.ConfigurationUnit))
{
exchangeConfigurationUnit.SupportedSharedConfigurations.Add(exchangeConfigurationUnit2.Identity);
}
}
}
if (base.Fields.IsModified(OrganizationSchema.EnableAsSharedConfiguration))
{
exchangeConfigurationUnit.EnableAsSharedConfiguration = this.EnableAsSharedConfiguration;
}
if (base.Fields.IsModified(OrganizationSchema.ImmutableConfiguration))
{
exchangeConfigurationUnit.ImmutableConfiguration = this.ImmutableConfiguration;
}
if (base.Fields.IsModified(OrganizationSchema.IsDehydrated))
{
exchangeConfigurationUnit.IsDehydrated = this.IsDehydrated;
}
if (base.Fields.IsModified(OrganizationSchema.IsStaticConfigurationShared))
{
exchangeConfigurationUnit.IsStaticConfigurationShared = this.IsStaticConfigurationShared;
}
if (base.Fields.IsModified(OrganizationSchema.IsUpdatingServicePlan))
{
exchangeConfigurationUnit.IsUpdatingServicePlan = this.IsUpdatingServicePlan;
}
if (base.Fields.IsModified(ExchangeConfigurationUnitSchema.ProgramId))
{
exchangeConfigurationUnit.ProgramId = this.ProgramId;
}
if (base.Fields.IsModified(ExchangeConfigurationUnitSchema.OfferId))
{
exchangeConfigurationUnit.OfferId = this.OfferId;
}
if (base.Fields.IsModified(ExchangeConfigurationUnitSchema.ServicePlan))
{
exchangeConfigurationUnit.ServicePlan = this.ServicePlan;
}
if (base.Fields.IsModified(ExchangeConfigurationUnitSchema.TargetServicePlan))
{
exchangeConfigurationUnit.TargetServicePlan = this.TargetServicePlan;
}
if (!exchangeConfigurationUnit.HostingDeploymentEnabled && Datacenter.IsPartnerHostedOnly(false))
{
exchangeConfigurationUnit.HostingDeploymentEnabled = true;
}
if (base.Fields.IsModified(OrganizationSchema.ExcludedFromBackSync))
{
exchangeConfigurationUnit.ExcludedFromBackSync = this.ExcludedFromBackSync;
}
if (base.Fields.IsModified(OrganizationSchema.ExcludedFromForwardSyncEDU2BPOS))
{
exchangeConfigurationUnit.ExcludedFromForwardSyncEDU2BPOS = this.ExcludedFromForwardSyncEDU2BPOS;
}
if (base.Fields.IsModified(ExchangeConfigurationUnitSchema.ExchangeUpgradeBucket))
{
if (this.ExchangeUpgradeBucket != null)
{
ExchangeUpgradeBucket exchangeUpgradeBucket = (ExchangeUpgradeBucket)base.GetDataObject <ExchangeUpgradeBucket>(this.ExchangeUpgradeBucket, base.GlobalConfigSession, null, new LocalizedString?(Strings.ErrorExchangeUpgradeBucketNotFound(this.ExchangeUpgradeBucket.ToString())), new LocalizedString?(Strings.ErrorExchangeUpgradeBucketNotUnique(this.ExchangeUpgradeBucket.ToString())));
UpgradeBucketTaskHelper.ValidateOrganizationVersion(exchangeConfigurationUnit, exchangeUpgradeBucket, new Task.ErrorLoggerDelegate(base.WriteError));
UpgradeBucketTaskHelper.ValidateOrganizationAddition(base.GlobalConfigSession, exchangeConfigurationUnit.OrganizationId, exchangeUpgradeBucket, new Task.ErrorLoggerDelegate(base.WriteError));
exchangeConfigurationUnit.ExchangeUpgradeBucket = (ADObjectId)exchangeUpgradeBucket.Identity;
}
else
{
exchangeConfigurationUnit.ExchangeUpgradeBucket = null;
}
}
if (base.Fields.IsModified(OrganizationSchema.MailboxRelease))
{
exchangeConfigurationUnit.MailboxRelease = this.MailboxRelease;
}
if (base.Fields.IsModified(OrganizationSchema.PreviousMailboxRelease))
{
exchangeConfigurationUnit.PreviousMailboxRelease = this.PreviousMailboxRelease;
}
if (base.Fields.IsModified(OrganizationSchema.PilotMailboxRelease))
{
exchangeConfigurationUnit.PilotMailboxRelease = this.PilotMailboxRelease;
}
if (base.Fields.IsModified("AddRelocationConstraint"))
{
RelocationConstraint constraintToAdd = new RelocationConstraint((RelocationConstraintType)this.RelocationConstraintType, DateTime.UtcNow.AddDays((double)this.RelocationConstraintExpirationInDays));
RelocationConstraintArray persistedRelocationConstraints = SetOrganization.PopulateRelocationConstraintsList(exchangeConfigurationUnit.PersistedRelocationConstraints, this.RelocationConstraintType, constraintToAdd);
exchangeConfigurationUnit.PersistedRelocationConstraints = persistedRelocationConstraints;
}
else if (base.Fields.IsModified("RemoveRelocationConstraint"))
{
RelocationConstraintArray persistedRelocationConstraints2 = SetOrganization.PopulateRelocationConstraintsList(exchangeConfigurationUnit.PersistedRelocationConstraints, this.RelocationConstraintType, null);
exchangeConfigurationUnit.PersistedRelocationConstraints = persistedRelocationConstraints2;
}
OrganizationStatus organizationStatus;
if (exchangeConfigurationUnit.IsModified(ExchangeConfigurationUnitSchema.OrganizationStatus) && exchangeConfigurationUnit.TryGetOriginalValue <OrganizationStatus>(ExchangeConfigurationUnitSchema.OrganizationStatus, out organizationStatus))
{
if (OrganizationStatus.Active == exchangeConfigurationUnit.OrganizationStatus && (OrganizationStatus.Suspended == organizationStatus || OrganizationStatus.LockedOut == organizationStatus))
{
exchangeConfigurationUnit.IsTenantAccessBlocked = false;
}
else if ((OrganizationStatus.Suspended == exchangeConfigurationUnit.OrganizationStatus || OrganizationStatus.LockedOut == exchangeConfigurationUnit.OrganizationStatus) && OrganizationStatus.Active == organizationStatus)
{
exchangeConfigurationUnit.IsTenantAccessBlocked = true;
}
}
if (base.Fields.IsModified(OrganizationSchema.IsLicensingEnforced))
{
exchangeConfigurationUnit.IsLicensingEnforced = this.IsLicensingEnforced;
}
TaskLogger.LogExit();
return(exchangeConfigurationUnit);
}
// Token: 0x06000C0F RID: 3087 RVA: 0x0004E5DC File Offset: 0x0004C7DC
public bool IsEventInteresting(MapiEvent mapiEvent)
{
if (mapiEvent.ItemType != ObjectType.MAPI_STORE && mapiEvent.ItemType != ObjectType.MAPI_MESSAGE)
{
return(false);
}
if (this.IsApprovalStatusModified(mapiEvent) || this.IsRequestExpired(mapiEvent))
{
return(true);
}
bool flag = false;
try
{
flag = (VariantConfiguration.InvariantNoFlightingSnapshot.MailboxAssistants.ApprovalAssistantCheckRateLimit.Enabled || Datacenter.IsPartnerHostedOnly(true));
}
catch (CannotDetermineExchangeModeException)
{
}
return(flag && this.IsNewInitiationMessageCreated(mapiEvent) && this.IncrementAndCheckRateLimit(mapiEvent));
}
private static bool IsMultiTenantEnvironment()
{
bool result = false;
try
{
result = (VariantConfiguration.InvariantNoFlightingSnapshot.DataStorage.FindOrgMailboxInMultiTenantEnvironment.Enabled || Datacenter.IsPartnerHostedOnly(true));
}
catch (CannotDetermineExchangeModeException)
{
ExTraceGlobals.StorageTracer.TraceWarning(0L, "Could not determine Exchange mode in IsMultiTenantEnvironment");
}
return(result);
}
// Token: 0x060010E8 RID: 4328 RVA: 0x00062F58 File Offset: 0x00061158
public static string GetTenantIdentifiableDN(OrganizationId orgId)
{
string result;
if (VariantConfiguration.InvariantNoFlightingSnapshot.MailboxAssistants.DirectoryProcessorTenantLogging.Enabled || Datacenter.IsPartnerHostedOnly(true))
{
ExAssert.RetailAssert(null != orgId && null != orgId.OrganizationalUnit, "orgId and orgId.OrganizationalUnit should be non-null in Datacenter");
result = orgId.OrganizationalUnit.ToDNString();
}
else
{
ExAssert.RetailAssert(orgId.OrganizationalUnit == null, "orgId.OrganizationalUnit should be null for Enterprise");
result = "Enterprise";
}
return(result);
}
// Token: 0x06000031 RID: 49 RVA: 0x000037D4 File Offset: 0x000019D4
internal override bool OnExpire(MessageItem messageItem, out bool sendUpdate)
{
sendUpdate = false;
string valueOrDefault = messageItem.GetValueOrDefault <string>(ItemSchema.InternetReferences, string.Empty);
string valueOrDefault2 = messageItem.GetValueOrDefault <string>(MessageItemSchema.ApprovalRequestor);
if ((!VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && !Datacenter.IsPartnerHostedOnly(true)) || ModeratedDLApplication.ExpiryNotificationCounterWrapper.Instance.IncrementCountAndCheckLimit())
{
sendUpdate = true;
this.SendExpiryNdrOofNotification(messageItem, ApprovalInformation.ApprovalNotificationType.ExpiryNotification);
this.SendModeratorExpiryNotification(messageItem, ApprovalInformation.ApprovalNotificationType.ModeratorExpiryNotification);
}
MessageTrackingLog.TrackModeratorExpired(MessageTrackingSource.APPROVAL, messageItem.InternetMessageId, valueOrDefault, valueOrDefault2, this.GetModeratedRecipients(messageItem, true), ModeratedDLApplication.GetOrganizationIdFromMessage(messageItem), sendUpdate);
return(true);
}
internal static void CalculateRoleConfigurationForCurrentSKU(OrganizationIdParameter organization, ServicePlan servicePlanSettings, out RoleDefinition[] roles, out RoleNameMappingCollection nameMapping, out string[] rolesToRemove, out RoleEntry[] allAllowedRoleEntriesForSKU)
{
if (InstallCannedRbacRoles.isFfoEnvironment)
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedEOPRoles_Datacenter.Definition, CannedWebServiceRoles_Datacenter.Definition);
roles = InstallCannedRbacRoles.MergeRoleDefinitions(roles, CannedUCCRoles_Datacenter.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingDatacenterR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesDatacenter;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableEOPRoleEntries_Datacenter.RoleEntries, AvailableWebServiceRoleEntries_Datacenter.RoleEntries, AvailableUCCRoleEntries_Datacenter.RoleEntries);
return;
}
if (organization == null)
{
if (Datacenter.IsMicrosoftHostedOnly(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Datacenter.Definition, CannedWebServiceRoles_Datacenter.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingDatacenterR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesDatacenter;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Datacenter.RoleEntries, AvailableWebServiceRoleEntries_Datacenter.RoleEntries, null);
return;
}
if (Datacenter.IsPartnerHostedOnly(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Hosting.Definition, CannedWebServiceRoles_Hosting.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingHostingR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesHosting;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Hosting.RoleEntries, AvailableWebServiceRoleEntries_Hosting.RoleEntries, null);
return;
}
if (Datacenter.IsDatacenterDedicated(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Dedicated.Definition, CannedWebServiceRoles_Dedicated.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingEnterpriseR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesEnterprise;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Dedicated.RoleEntries, AvailableWebServiceRoleEntries_Dedicated.RoleEntries, null);
return;
}
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Enterprise.Definition, CannedWebServiceRoles_Enterprise.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingEnterpriseR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesEnterprise;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Enterprise.RoleEntries, AvailableWebServiceRoleEntries_Enterprise.RoleEntries, null);
return;
}
else
{
if (Datacenter.IsPartnerHostedOnly(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_HostedTenant.Definition, CannedWebServiceRoles_HostedTenant.Definition);
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesHostedTenant;
if (servicePlanSettings != null)
{
List <string> enabledRoleGroupRoleAssignmentFeatures = servicePlanSettings.Organization.GetEnabledRoleGroupRoleAssignmentFeatures();
RoleGroupRoleMapping[] definition = HostedTenant_RoleGroupDefinition.Definition;
List <string> a;
roles = InstallCannedRbacRoles.FilterOrgRolesByRoleGroupFilters(roles, enabledRoleGroupRoleAssignmentFeatures, definition, out a);
rolesToRemove = InstallCannedRbacRoles.AppendIListToarray <string>(rolesToRemove, a);
}
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingHostedTenantR4;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_HostedTenant.RoleEntries, AvailableWebServiceRoleEntries_HostedTenant.RoleEntries, null);
return;
}
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Tenant.Definition, CannedWebServiceRoles_Tenant.Definition);
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesTenant;
if (servicePlanSettings != null)
{
List <string> enabledRoleGroupRoleAssignmentFeatures2 = servicePlanSettings.Organization.GetEnabledRoleGroupRoleAssignmentFeatures();
RoleGroupRoleMapping[] definition2 = Tenant_RoleGroupDefinition.Definition;
List <string> a2;
roles = InstallCannedRbacRoles.FilterOrgRolesByRoleGroupFilters(roles, enabledRoleGroupRoleAssignmentFeatures2, definition2, out a2);
rolesToRemove = InstallCannedRbacRoles.AppendIListToarray <string>(rolesToRemove, a2);
}
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingTenantR4;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Tenant.RoleEntries, AvailableWebServiceRoleEntries_Tenant.RoleEntries, null);
return;
}
}
