public static void ClearOutputForOlderVersion(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
HybridConfiguration hybridConfiguration = store.GetDataObject("HybridConfiguration") as HybridConfiguration;
IntraOrganizationConfiguration intraOrganizationConfiguration = store.GetDataObject("IntraOrganizationConfiguration") as IntraOrganizationConfiguration;
bool flag = hybridConfiguration != null && DDIHelper.IsLegacyObject(hybridConfiguration);
if (flag)
{
dataTable.Rows.Clear();
store.UpdateDataObject("HybridConfiguration", null);
DataRow row = dataTable.NewRow();
dataTable.Rows.Add(row);
}
dataTable.Rows[0]["NeedUpgrade"] = flag;
if (object.Equals(dataTable.Rows[0]["IncomingServiceInstance"], "1"))
{
inputRow["IsGallatin"] = (dataTable.Rows[0]["IsGallatin"] = true);
if (OrganizationCache.RestrictIOCToSP1OrGreaterGallatin && intraOrganizationConfiguration.DeploymentIsCompleteIOCReady == false)
{
dataTable.Rows[0]["GallatinBlock"] = true;
return;
}
}
else if (!OrganizationCache.RestrictIOCToSP1OrGreaterWorldWide || intraOrganizationConfiguration.DeploymentIsCompleteIOCReady == true)
{
dataTable.Rows[0]["WWoAuth"] = true;
}
}
public override bool CheckPrereqs(ITaskContext taskContext)
{
if (!base.CheckPrereqs(taskContext))
{
base.Logger.LogInformation(HybridStrings.HybridInfoTaskLogTemplate(base.Name, HybridStrings.HybridInfoBasePrereqsFailed));
return(false);
}
HybridConfiguration hybridConfigurationObject = taskContext.HybridConfigurationObject;
this.onPremOrgRel = taskContext.Parameters.Get <OrganizationRelationship>("_onPremOrgRel");
if (this.onPremOrgRel == null)
{
throw new LocalizedException(HybridStrings.ErrorOrgRelNotFoundOnPrem);
}
this.tenantOrgRel = taskContext.Parameters.Get <OrganizationRelationship>("_tenantOrgRel");
if (this.tenantOrgRel == null)
{
throw new LocalizedException(HybridStrings.ErrorOrgRelNotFoundOnTenant);
}
if (this.RequiresFederationTrust())
{
this.fedOrgId = base.TenantSession.GetFederatedOrganizationIdentifier();
if (this.fedOrgId == null)
{
throw new LocalizedException(HybridStrings.ErrorFederationIDNotProvisioned);
}
if (!this.fedOrgId.Enabled || string.IsNullOrEmpty(this.fedOrgId.AccountNamespace.Domain) || this.fedOrgId.Domains.Count == 0)
{
throw new LocalizedException(HybridStrings.ErrorFederationIDNotProvisioned);
}
}
return(true);
}
public static void Validate(HybridConfiguration dataObject, bool hasErrors, Task.TaskErrorLoggingDelegate writeErrorFunc)
{
if (hasErrors)
{
return;
}
if (dataObject.MaximumSupportedExchangeObjectVersion.ExchangeBuild < dataObject.ExchangeVersion.ExchangeBuild)
{
writeErrorFunc(new InvalidObjectOperationException(HybridStrings.ErrorHybridConfigurationTooNew(dataObject.ExchangeVersion.ToString(), dataObject.MaximumSupportedExchangeObjectVersion.ToString())), ErrorCategory.InvalidArgument, null);
}
}
public static void SetHybridConfigurationEnabled(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
HybridConfiguration hybridConfiguration = store.GetDataObject("HybridConfiguration") as HybridConfiguration;
bool flag = hybridConfiguration != null && !DDIHelper.IsLegacyObject(hybridConfiguration);
dataTable.Rows[0]["HybridConfigurationEnabled"] = flag;
if (flag)
{
dataTable.Rows[0]["IsHostedOnGallatin"] = (hybridConfiguration.ServiceInstance == 1);
}
}
public TaskContext(IUserInterface ui, ILogger logger, HybridConfiguration hybridConfigurationObject, IOnPremisesSession onPremisesSession, ITenantSession tenantSession)
{
this.UI = ui;
this.Logger = logger;
this.HybridConfigurationObject = hybridConfigurationObject;
this.OnPremisesSession = onPremisesSession;
this.TenantSession = tenantSession;
this.Parameters = new ContextParameters();
this.Errors = new List <LocalizedString>();
this.Warnings = new List <LocalizedString>();
}
public StandardWorkflow(ILogger logger, IUserInterface ui, HybridConfiguration hybridConfigurationObject, Func <IOnPremisesSession> createOnPremisesSession, Func <ITenantSession> createTenantSession)
{
base.AddOverhead(1);
base.AddOverhead(1);
base.AddTask(new TenantDetectionTask());
base.AddTask(new UpgradeConfigurationFrom14Task(ExchangeObjectVersion.Exchange2012));
base.AddTask(new GlobalPrereqTask());
base.AddTask(new RecipientTask());
base.AddTask(new OrganizationRelationshipTask());
base.AddTask(new OnOffSettingsTask());
base.AddTask(new MailFlowTask());
base.AddTask(new MRSProxyTask());
base.AddTask(new IOCConfigurationTask());
LocalizedString hybridActivityEstablish = HybridStrings.HybridActivityEstablish;
LocalizedString localizedString = HybridStrings.HybridConnectingToOnPrem;
ui.WriteVerbose(localizedString);
ui.WriteProgessIndicator(hybridActivityEstablish, localizedString, base.PercentCompleted);
try
{
this.onPremisesSession = createOnPremisesSession();
}
catch (Exception ex)
{
if (ex is CouldNotResolveServerException || ex is CouldNotOpenRunspaceException)
{
throw new CouldNotCreateOnPremisesSessionException(ex, ex);
}
throw ex;
}
base.UpdateProgress(1);
logger.LogInformation(HybridStrings.HybridInfoConnectedToOnPrem);
localizedString = HybridStrings.HybridConnectingToTenant;
ui.WriteVerbose(localizedString);
ui.WriteProgessIndicator(hybridActivityEstablish, localizedString, base.PercentCompleted);
try
{
this.tenantSession = createTenantSession();
}
catch (Exception ex2)
{
if (ex2 is CouldNotResolveServerException || ex2 is CouldNotOpenRunspaceException)
{
throw new CouldNotCreateTenantSessionException(ex2, ex2);
}
throw ex2;
}
base.UpdateProgress(1);
logger.LogInformation(HybridStrings.HybridInfoConnectedToTenant);
this.TaskContext = new TaskContext(ui, logger, hybridConfigurationObject, this.onPremisesSession, this.tenantSession);
this.TaskContext.Parameters.Set <List <Uri> >("_onPremAcceptedTokenIssuerUris", Configuration.OnPremiseAcceptedTokenIssuerUriList);
this.TaskContext.Parameters.Set <List <Uri> >("_tenantAcceptedTokenIssuerUris", Configuration.TenantAcceptedTokenIssuerUriList);
}
private bool CheckOrVerifyConfiguration(ITaskContext taskContext, bool fVerifyOnly)
{
bool result = false;
HybridConfiguration hybridConfigurationObject = taskContext.HybridConfigurationObject;
if (hybridConfigurationObject.MoveMailboxEnabled != this.onPremOrgRel.MailboxMoveEnabled)
{
result = true;
}
if (hybridConfigurationObject.FreeBusySharingEnabled != this.onPremOrgRel.FreeBusyAccessEnabled || hybridConfigurationObject.FreeBusySharingEnabled != this.tenantOrgRel.FreeBusyAccessEnabled)
{
result = true;
}
else if (hybridConfigurationObject.FreeBusySharingEnabled && (this.onPremOrgRel.FreeBusyAccessLevel != FreeBusyAccessLevel.LimitedDetails || this.tenantOrgRel.FreeBusyAccessLevel != FreeBusyAccessLevel.LimitedDetails))
{
result = true;
}
if (hybridConfigurationObject.OnlineArchiveEnabled != this.onPremOrgRel.ArchiveAccessEnabled)
{
result = true;
}
if (hybridConfigurationObject.MailtipsEnabled != this.onPremOrgRel.MailTipsAccessEnabled || hybridConfigurationObject.MailtipsEnabled != this.tenantOrgRel.MailTipsAccessEnabled)
{
result = true;
}
else if (hybridConfigurationObject.MailtipsEnabled && (this.onPremOrgRel.MailTipsAccessLevel != MailTipsAccessLevel.All || this.tenantOrgRel.MailTipsAccessLevel != MailTipsAccessLevel.All))
{
result = true;
}
if (hybridConfigurationObject.MessageTrackingEnabled != this.onPremOrgRel.DeliveryReportEnabled || hybridConfigurationObject.MessageTrackingEnabled != this.tenantOrgRel.DeliveryReportEnabled)
{
result = true;
}
if (hybridConfigurationObject.PhotosEnabled != this.onPremOrgRel.PhotosEnabled || hybridConfigurationObject.PhotosEnabled != this.tenantOrgRel.PhotosEnabled)
{
result = true;
}
string value = (this.onPremOrgRel.TargetOwaURL != null) ? this.onPremOrgRel.TargetOwaURL.ToString() : string.Empty;
if (fVerifyOnly)
{
if (hybridConfigurationObject.OwaRedirectionEnabled == string.IsNullOrEmpty(value))
{
result = true;
}
}
else if (hybridConfigurationObject.OwaRedirectionEnabled || !string.IsNullOrEmpty(value))
{
result = true;
}
return(result);
}
public override bool Configure(ITaskContext taskContext)
{
if (!base.Configure(taskContext))
{
return(false);
}
HybridConfiguration hybridConfigurationObject = taskContext.HybridConfigurationObject;
if (this.configureRemoteDomain)
{
string name = string.Format("Hybrid Domain - {0}", this.tenantRoutingDomain);
base.OnPremisesSession.NewRemoteDomain(this.tenantRoutingDomain, name);
}
if (this.configureRemoteDomain || this.configureTargetDeliveryDomain)
{
string identity = string.Format("Hybrid Domain - {0}", this.targetDeliveryDomain);
SessionParameters sessionParameters = new SessionParameters();
sessionParameters.Set("TargetDeliveryDomain", true);
base.OnPremisesSession.SetRemoteDomain(identity, sessionParameters);
}
if (this.configureAcceptedDomain)
{
base.OnPremisesSession.NewAcceptedDomain(this.tenantRoutingDomain, this.tenantRoutingDomain);
IEnumerable <IAcceptedDomain> acceptedDomain = base.OnPremisesSession.GetAcceptedDomain();
if (acceptedDomain.Count <IAcceptedDomain>() == 0)
{
throw new LocalizedException(HybridStrings.ErrorNoOnPremAcceptedDomains);
}
taskContext.Parameters.Set <IEnumerable <IAcceptedDomain> >("_onPremAcceptedDomains", acceptedDomain);
}
if (this.upgradeLegacyDefaultPolicy)
{
base.OnPremisesSession.SetEmailAddressPolicy("default policy", "AllRecipients", null);
}
if (this.policiesToUpdate != null)
{
foreach (EmailAddressPolicy policy in this.policiesToUpdate)
{
this.AddTenantRoutingAddressToPolicy(policy);
}
foreach (EmailAddressPolicy emailAddressPolicy in this.policiesToUpdate)
{
base.OnPremisesSession.UpdateEmailAddressPolicy(emailAddressPolicy.DistinguishedName);
}
}
return(true);
}
public static void ProcessRecord(ILogger logger, IUserInterface ui, HybridConfiguration hybridConfigurationObject, Func <IOnPremisesSession> createOnPremisesSessionFunc, Func <ITenantSession> createTenantSessionFunc, Action <Exception, ErrorCategory, object> writeErrorFunc, bool forceUpgrade, bool suppressOAuthWarning)
{
try
{
using (StandardWorkflow standardWorkflow = new StandardWorkflow(logger, ui, hybridConfigurationObject, createOnPremisesSessionFunc, createTenantSessionFunc))
{
standardWorkflow.TaskContext.Parameters.Set <bool>("_forceUpgrade", forceUpgrade);
standardWorkflow.TaskContext.Parameters.Set <bool>("_suppressOAuthWarning", suppressOAuthWarning);
Engine.Execute(standardWorkflow.TaskContext, standardWorkflow);
}
}
catch (Exception ex)
{
LocalizedString localizedString = HybridStrings.ExceptionUpdateHybridConfigurationFailedWithLog(ex.ToString(), Environment.MachineName, logger.ToString());
writeErrorFunc(new LocalizedException(localizedString), ErrorCategory.WriteError, null);
}
}
private bool CheckOrVerifyConfiguration(ITaskContext taskContext, bool verifyOnly)
{
this.configureRemoteDomain = false;
this.configureTargetDeliveryDomain = false;
HybridConfiguration hybridConfigurationObject = taskContext.HybridConfigurationObject;
this.targetDeliveryDomain = this.tenantRoutingDomain;
IEnumerable <DomainContentConfig> remoteDomain = base.OnPremisesSession.GetRemoteDomain();
if (remoteDomain.Count <DomainContentConfig>() == 0)
{
this.configureRemoteDomain = true;
}
else
{
this.configureRemoteDomain = true;
foreach (DomainContentConfig domainContentConfig in remoteDomain)
{
if (domainContentConfig.DomainName.Domain.Equals(this.tenantRoutingDomain, StringComparison.InvariantCultureIgnoreCase))
{
if (!domainContentConfig.TargetDeliveryDomain)
{
this.targetDeliveryDomain = domainContentConfig.DomainName.Domain;
this.configureTargetDeliveryDomain = true;
}
this.configureRemoteDomain = false;
break;
}
}
}
IEnumerable <IAcceptedDomain> source = taskContext.Parameters.Get <IEnumerable <IAcceptedDomain> >("_onPremAcceptedDomains");
this.configureAcceptedDomain = !source.Any((IAcceptedDomain d) => d.DomainNameDomain.Equals(this.tenantRoutingDomain, StringComparison.InvariantCultureIgnoreCase));
IEnumerable <string> source2 = from domain in hybridConfigurationObject.Domains
select domain.Domain;
this.policiesToUpdate = this.GetEmailAddressPoliciesToUpdate(taskContext, verifyOnly, source2.ToArray <string>(), out this.upgradeLegacyDefaultPolicy);
return(this.configureRemoteDomain || this.configureTargetDeliveryDomain || this.configureAcceptedDomain || this.policiesToUpdate.Count <EmailAddressPolicy>() > 0 || this.upgradeLegacyDefaultPolicy);
}
// Token: 0x060008F1 RID: 2289 RVA: 0x0001F41E File Offset: 0x0001D61E
public HybridConfigurationIdParameter(HybridConfiguration hybridRelationship) : base(hybridRelationship.Id)
{
}
public static IConfigurable PrepareDataObject(PropertyBag fields, HybridConfiguration dataObject, IConfigDataProvider dataSession, HybridConfigurationTaskUtility.GetUniqueObject getDataObjectFunc, Task.TaskErrorLoggingDelegate writeErrorFunc)
{
MultiValuedProperty <ADObjectId> clientAccessServers = dataObject.ClientAccessServers;
if (fields.IsModified("ClientAccessServers"))
{
ADPropertyDefinition clientAccessServers2 = HybridConfigurationSchema.ClientAccessServers;
HybridConfigurationTaskUtility.ServerCriterion[] array = new HybridConfigurationTaskUtility.ServerCriterion[2];
array[0] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsClientAccessServer, new Func <string, LocalizedString>(HybridStrings.HybridErrorServerNotCAS));
array[1] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsE14OrLater, new Func <string, LocalizedString>(HybridStrings.HybridErrorServerNotE14CAS));
dataObject.ClientAccessServers = HybridConfigurationTaskUtility.ValidateServers(clientAccessServers2, dataSession, fields, getDataObjectFunc, writeErrorFunc, array);
}
if (fields.IsModified("SendingTransportServers"))
{
ADPropertyDefinition sendingTransportServers = HybridConfigurationSchema.SendingTransportServers;
HybridConfigurationTaskUtility.ServerCriterion[] array2 = new HybridConfigurationTaskUtility.ServerCriterion[2];
array2[0] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsHubTransportServer, new Func <string, LocalizedString>(HybridStrings.HybridErrorSendingTransportServerNotHub));
array2[1] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsE15OrLater, new Func <string, LocalizedString>(HybridStrings.HybridErrorSendingTransportServerNotE15Hub));
dataObject.SendingTransportServers = HybridConfigurationTaskUtility.ValidateServers(sendingTransportServers, dataSession, fields, getDataObjectFunc, writeErrorFunc, array2);
}
if (fields.IsModified("ReceivingTransportServers"))
{
ADPropertyDefinition receivingTransportServers = HybridConfigurationSchema.ReceivingTransportServers;
HybridConfigurationTaskUtility.ServerCriterion[] array3 = new HybridConfigurationTaskUtility.ServerCriterion[2];
array3[0] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsFrontendTransportServer, new Func <string, LocalizedString>(HybridStrings.HybridErrorReceivingTransportServerNotFrontEnd));
array3[1] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsE15OrLater, new Func <string, LocalizedString>(HybridStrings.HybridErrorReceivingTransportServerNotE15FrontEnd));
dataObject.ReceivingTransportServers = HybridConfigurationTaskUtility.ValidateServers(receivingTransportServers, dataSession, fields, getDataObjectFunc, writeErrorFunc, array3);
}
if (fields.IsModified("EdgeTransportServers"))
{
ADPropertyDefinition edgeTransportServers = HybridConfigurationSchema.EdgeTransportServers;
HybridConfigurationTaskUtility.ServerCriterion[] array4 = new HybridConfigurationTaskUtility.ServerCriterion[2];
array4[0] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsEdgeServer, new Func <string, LocalizedString>(HybridStrings.HybridErrorServerNotEdge));
array4[1] = new HybridConfigurationTaskUtility.ServerCriterion((Server s) => s.IsE14Sp1OrLater, new Func <string, LocalizedString>(HybridStrings.HybridErrorServerNotE14Edge));
dataObject.EdgeTransportServers = HybridConfigurationTaskUtility.ValidateServers(edgeTransportServers, dataSession, fields, getDataObjectFunc, writeErrorFunc, array4);
}
if (fields.IsModified("TlsCertificateName"))
{
string text = fields["TlsCertificateName"] as string;
dataObject.TlsCertificateName = ((text == null) ? null : SmtpX509Identifier.Parse(text));
}
if (fields.IsModified("OnPremisesSmartHost"))
{
dataObject.OnPremisesSmartHost = (SmtpDomain)fields["OnPremisesSmartHost"];
}
if (fields.IsModified("Domains"))
{
dataObject.Domains = (MultiValuedProperty <AutoDiscoverSmtpDomain>)fields["Domains"];
}
if (fields.IsModified("Features"))
{
dataObject.Features = (MultiValuedProperty <HybridFeature>)fields["Features"];
}
if (fields.IsModified("ExternalIPAddresses"))
{
dataObject.ExternalIPAddresses = HybridConfigurationTaskUtility.ValidateExternalIPAddresses((MultiValuedProperty <IPRange>)fields["ExternalIPAddresses"], writeErrorFunc);
}
if (fields.IsModified("ServiceInstance"))
{
dataObject.ServiceInstance = (int)fields["ServiceInstance"];
}
return(dataObject);
}
public override bool Configure(ITaskContext taskContext)
{
if (!base.Configure(taskContext))
{
return(false);
}
HybridConfiguration hybridConfigurationObject = taskContext.HybridConfigurationObject;
SessionParameters sessionParameters = new SessionParameters();
SessionParameters sessionParameters2 = new SessionParameters();
if (hybridConfigurationObject.MoveMailboxEnabled != this.onPremOrgRel.MailboxMoveEnabled)
{
sessionParameters.Set("MailboxMoveEnabled", hybridConfigurationObject.MoveMailboxEnabled);
}
if (hybridConfigurationObject.FreeBusySharingEnabled != this.onPremOrgRel.FreeBusyAccessEnabled || hybridConfigurationObject.FreeBusySharingEnabled != this.tenantOrgRel.FreeBusyAccessEnabled)
{
sessionParameters.Set("FreeBusyAccessEnabled", hybridConfigurationObject.FreeBusySharingEnabled);
sessionParameters2.Set("FreeBusyAccessEnabled", hybridConfigurationObject.FreeBusySharingEnabled);
}
if (hybridConfigurationObject.FreeBusySharingEnabled && (this.onPremOrgRel.FreeBusyAccessLevel != FreeBusyAccessLevel.LimitedDetails || this.tenantOrgRel.FreeBusyAccessLevel != FreeBusyAccessLevel.LimitedDetails))
{
sessionParameters.Set("FreeBusyAccessLevel", FreeBusyAccessLevel.LimitedDetails);
sessionParameters2.Set("FreeBusyAccessLevel", FreeBusyAccessLevel.LimitedDetails);
}
if (hybridConfigurationObject.OnlineArchiveEnabled != this.onPremOrgRel.ArchiveAccessEnabled)
{
sessionParameters.Set("ArchiveAccessEnabled", hybridConfigurationObject.OnlineArchiveEnabled);
}
if (hybridConfigurationObject.MailtipsEnabled != this.onPremOrgRel.MailTipsAccessEnabled || hybridConfigurationObject.MailtipsEnabled != this.tenantOrgRel.MailTipsAccessEnabled)
{
sessionParameters.Set("MailTipsAccessEnabled", hybridConfigurationObject.MailtipsEnabled);
sessionParameters2.Set("MailTipsAccessEnabled", hybridConfigurationObject.MailtipsEnabled);
}
if (hybridConfigurationObject.MailtipsEnabled && (this.onPremOrgRel.MailTipsAccessLevel != MailTipsAccessLevel.All || this.tenantOrgRel.MailTipsAccessLevel != MailTipsAccessLevel.All))
{
sessionParameters.Set("MailTipsAccessLevel", MailTipsAccessLevel.All);
sessionParameters2.Set("MailTipsAccessLevel", MailTipsAccessLevel.All);
}
if (hybridConfigurationObject.MessageTrackingEnabled != this.onPremOrgRel.DeliveryReportEnabled || hybridConfigurationObject.MessageTrackingEnabled != this.tenantOrgRel.DeliveryReportEnabled)
{
sessionParameters.Set("DeliveryReportEnabled", hybridConfigurationObject.MessageTrackingEnabled);
sessionParameters2.Set("DeliveryReportEnabled", hybridConfigurationObject.MessageTrackingEnabled);
}
if (hybridConfigurationObject.PhotosEnabled != this.onPremOrgRel.PhotosEnabled || hybridConfigurationObject.PhotosEnabled != this.tenantOrgRel.PhotosEnabled)
{
sessionParameters.Set("PhotosEnabled", hybridConfigurationObject.PhotosEnabled);
sessionParameters2.Set("PhotosEnabled", hybridConfigurationObject.PhotosEnabled);
}
string text = (this.onPremOrgRel.TargetOwaURL != null) ? this.onPremOrgRel.TargetOwaURL.ToString() : string.Empty;
if (hybridConfigurationObject.OwaRedirectionEnabled || !string.IsNullOrEmpty(text))
{
if (hybridConfigurationObject.OwaRedirectionEnabled)
{
IEnumerable <IAcceptedDomain> acceptedDomains = taskContext.Parameters.Get <IEnumerable <IAcceptedDomain> >("_tenantAcceptedDomains");
if (!string.IsNullOrEmpty(text))
{
if (!this.ValidateOwaUri(text, acceptedDomains))
{
sessionParameters.Set("TargetOwaURL", this.GetDefaultOwaUri(acceptedDomains, this.fedOrgId));
}
}
else
{
sessionParameters.Set("TargetOwaURL", this.GetDefaultOwaUri(acceptedDomains, this.fedOrgId));
}
}
else
{
sessionParameters.SetNull <string>("TargetOwaURL");
}
}
if (sessionParameters.Count > 0)
{
OrganizationRelationship organizationRelationship = taskContext.Parameters.Get <OrganizationRelationship>("_onPremOrgRel");
base.OnPremisesSession.SetOrganizationRelationship(organizationRelationship.Identity, sessionParameters);
List <string> list = new List <string>();
string item = taskContext.Parameters.Get <string>("_hybridDomain");
list.Add(item);
this.onPremOrgRel = TaskCommon.GetOrganizationRelationship(taskContext.OnPremisesSession, TaskCommon.GetOnPremOrgRelationshipName(this.OnPremOrgConfig), list);
taskContext.Parameters.Set <OrganizationRelationship>("_onPremOrgRel", this.onPremOrgRel);
}
if (sessionParameters2.Count > 0)
{
OrganizationRelationship organizationRelationship2 = taskContext.Parameters.Get <OrganizationRelationship>("_tenantOrgRel");
base.TenantSession.SetOrganizationRelationship(organizationRelationship2.Identity, sessionParameters2);
IEnumerable <string> domains = taskContext.Parameters.Get <IEnumerable <string> >("_hybridDomainList");
this.tenantOrgRel = TaskCommon.GetOrganizationRelationship(taskContext.TenantSession, TaskCommon.GetTenantOrgRelationshipName(this.OnPremOrgConfig), domains);
taskContext.Parameters.Set <OrganizationRelationship>("_onPremOrgRel", this.tenantOrgRel);
}
this.ConfigureAvailabilityAddressSpace(taskContext);
return(true);
}
