protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
if (this.DataObject.IsModified(ADOabVirtualDirectorySchema.OAuthAuthentication))
{
ExchangeServiceVDirHelper.SetOAuthAuthenticationModule(this.OAuthAuthentication, false, this.DataObject);
}
bool flag = this.DataObject.IsModified(ADOabVirtualDirectorySchema.RequireSSL) | this.DataObject.IsModified(ADOabVirtualDirectorySchema.BasicAuthentication) | this.DataObject.IsModified(ADOabVirtualDirectorySchema.WindowsAuthentication);
base.InternalProcessRecord();
if (flag)
{
try
{
SetOabVirtualDirectory.UpdateMetabase(this.DataObject, new Task.TaskErrorLoggingDelegate(base.WriteError));
}
finally
{
if (base.HasErrors)
{
base.WriteError(new LocalizedException(Strings.ErrorADOperationSucceededButMetabaseOperationFailed), ErrorCategory.WriteError, this.DataObject.Identity);
}
}
}
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
ADOwaVirtualDirectory adowaVirtualDirectory = WebAppVirtualDirectoryHelper.FindWebAppVirtualDirectoryInSameWebSite <ADOwaVirtualDirectory>(this.DataObject, base.DataSession);
if (adowaVirtualDirectory != null)
{
WebAppVirtualDirectoryHelper.CheckTwoWebAppVirtualDirectories(this.DataObject, adowaVirtualDirectory, new Action <string>(base.WriteWarning), Strings.EcpAuthenticationNotMatchOwaWarning, Strings.EcpUrlNotMatchOwaWarning);
}
else
{
this.WriteWarning(Strings.CreateOwaForEcpWarning);
}
if (this.DataObject.IsChanged(ADEcpVirtualDirectorySchema.AdminEnabled) || this.DataObject.IsChanged(ADEcpVirtualDirectorySchema.OwaOptionsEnabled))
{
this.WriteWarning(Strings.NeedIisRestartForChangingECPFeatureWarning);
}
base.InternalProcessRecord();
ADEcpVirtualDirectory dataObject = this.DataObject;
WebAppVirtualDirectoryHelper.UpdateMetabase(dataObject, dataObject.MetabasePath, true);
if (!ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(this.DataObject) && base.Fields.Contains("FormsAuthentication"))
{
ExchangeServiceVDirHelper.UpdateFrontEndHttpModule(this.DataObject, this.FormsAuthentication);
}
if (base.Fields.Contains("AdfsAuthentication"))
{
ExchangeServiceVDirHelper.SetAdfsAuthenticationModule(this.DataObject.AdfsAuthentication, false, this.DataObject);
}
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
base.InternalProcessRecord();
base.InternalEnableLiveIdNegotiateAuxiliaryModule();
ExchangeServiceVDirHelper.ForceAnonymous(this.DataObject.MetabasePath);
ExchangeServiceVDirHelper.EwsAutodiscMWA.OnSetManageWCFEndpoints(this, ExchangeServiceVDirHelper.EwsAutodiscMWA.EndpointProtocol.Autodiscover, this.WSSecurityAuthentication, this.DataObject);
}
protected override void InternalProcessRecord()
{
T dataObject = this.DataObject;
byte major = dataObject.ExchangeVersion.ExchangeBuild.Major;
T dataObject2 = this.DataObject;
if (major != dataObject2.MaximumSupportedExchangeObjectVersion.ExchangeBuild.Major)
{
T dataObject3 = this.DataObject;
base.WriteError(new CannotModifyCrossVersionObjectException(dataObject3.Id.DistinguishedName), ErrorCategory.InvalidOperation, null);
return;
}
base.InternalProcessRecord();
T dataObject4 = this.DataObject;
base.WriteVerbose(Strings.VerboseApplyingAuthenticationSettingForVDir(dataObject4.MetabasePath));
ExchangeServiceVDirHelper.SetIisVirtualDirectoryAuthenticationMethods(this.DataObject, new Task.TaskErrorLoggingDelegate(base.WriteError), this.MetabaseSetPropertiesFailureMessage);
T dataObject5 = this.DataObject;
if (dataObject5.LiveIdBasicAuthentication != null)
{
ExchangeServiceVDirHelper.SetLiveIdBasicAuthModule(this.LiveIdBasicAuthentication, false, this.DataObject);
}
T dataObject6 = this.DataObject;
if (dataObject6.OAuthAuthentication != null)
{
T dataObject7 = this.DataObject;
ExchangeServiceVDirHelper.SetOAuthAuthenticationModule(dataObject7.OAuthAuthentication.Value, false, this.DataObject);
}
ExchangeServiceVDirHelper.CheckAndUpdateWindowsAuthProvidersIfNecessary(this.DataObject, (bool?)base.Fields["WindowsAuthentication"]);
}
protected override void InternalProcessComplete()
{
base.InternalProcessComplete();
if (this.IsBackEnd)
{
ExchangeServiceVDirHelper.ForceAnonymous(this.DataObject.MetabasePath);
}
}
protected override void InternalProcessRecord()
{
base.InternalProcessRecord();
if (ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(this.DataObject))
{
ExchangeServiceVDirHelper.ForceAnonymous(this.DataObject.MetabasePath);
}
}
protected override void ProcessMetabaseProperties(ExchangeVirtualDirectory dataObject)
{
TaskLogger.LogEnter();
base.ProcessMetabaseProperties(dataObject);
ADPowerShellVirtualDirectory adpowerShellVirtualDirectory = (ADPowerShellVirtualDirectory)dataObject;
adpowerShellVirtualDirectory.RequireSSL = ExchangeServiceVDirHelper.IsSSLRequired(adpowerShellVirtualDirectory, new Task.TaskErrorLoggingDelegate(base.WriteError));
TaskLogger.LogExit();
}
protected override void InternalProcessComplete()
{
base.InternalProcessComplete();
this.DataObject.RequireSSL = new bool?(true);
if (base.Fields["RequireSSL"] != null)
{
ExchangeServiceVDirHelper.SetSSLRequired(this.DataObject, new Task.TaskErrorLoggingDelegate(base.WriteError), Strings.ErrorUpdatingVDir(this.DataObject.MetabasePath, string.Empty), (bool)base.Fields["RequireSSL"]);
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
if (!this.Force)
{
foreach (ADPropertyDefinition adpropertyDefinition in NewWebServicesVirtualDirectory.HostProperties)
{
if (!NewWebServicesVirtualDirectory.IsValidHost(this.DataObject, adpropertyDefinition) && !base.ShouldContinue(Strings.ConfirmationMessageHostCannotBeResolved(adpropertyDefinition.Name)))
{
TaskLogger.LogExit();
return;
}
}
}
if (!(this.DataObject.WindowsAuthentication ?? true))
{
if (base.ExchangeRunspaceConfig != null && base.ExchangeRunspaceConfig.ConfigurationSettings != null && (base.ExchangeRunspaceConfig.ConfigurationSettings.ClientApplication == ExchangeRunspaceConfigurationSettings.ExchangeApplication.ECP || base.ExchangeRunspaceConfig.ConfigurationSettings.ClientApplication == ExchangeRunspaceConfigurationSettings.ExchangeApplication.OSP))
{
if (!this.Force && !base.ShouldContinue(new LocalizedString(string.Format("{0} {1}", Strings.WarningMessageSetWebServicesVirtualDirectoryWindowsAuthentication(this.Identity.ToString()), Strings.ConfirmationMessageWebServicesVirtualDirectoryContinue))))
{
TaskLogger.LogExit();
return;
}
}
else
{
this.WriteWarning(Strings.WarningMessageSetWebServicesVirtualDirectoryWindowsAuthentication(this.Identity.ToString()));
if (!this.Force && !base.ShouldContinue(Strings.ConfirmationMessageWebServicesVirtualDirectoryContinue))
{
TaskLogger.LogExit();
return;
}
}
}
this.DataObject.CertificateAuthentication = null;
base.InternalProcessRecord();
base.InternalEnableLiveIdNegotiateAuxiliaryModule();
if (Datacenter.IsMicrosoftHostedOnly(true))
{
string text = string.Format("{0}/{1}", this.DataObject.MetabasePath, "Nego2");
if (!IisUtility.Exists(text))
{
DirectoryEntry directoryEntry = IisUtility.CreateWebDirObject(this.DataObject.MetabasePath, null, "Nego2");
IisUtility.SetProperty(directoryEntry, "AccessFlags", MetabasePropertyTypes.AccessFlags.Read | MetabasePropertyTypes.AccessFlags.Script, true);
directoryEntry.CommitChanges();
}
ExchangeServiceVDirHelper.SetSplitVirtualDirectoryAuthenticationMethods(this.DataObject, text, new Task.TaskErrorLoggingDelegate(base.WriteError), this.MetabaseSetPropertiesFailureMessage);
ExchangeServiceVDirHelper.ForceAnonymous(text);
}
ExchangeServiceVDirHelper.ForceAnonymous(this.DataObject.MetabasePath);
ExchangeServiceVDirHelper.EwsAutodiscMWA.OnSetManageWCFEndpoints(this, ExchangeServiceVDirHelper.EwsAutodiscMWA.EndpointProtocol.Ews, this.WSSecurityAuthentication, this.DataObject);
this.UpdateCompressionSettings();
TaskLogger.LogExit();
}
protected override void InternalProcessComplete()
{
base.InternalProcessComplete();
if (this.CertificateAuthentication)
{
T dataObject = this.DataObject;
dataObject.CertificateAuthentication = new bool?(true);
ADExchangeServiceVirtualDirectory virtualDirectory = this.DataObject;
Task.TaskErrorLoggingDelegate errorHandler = new Task.TaskErrorLoggingDelegate(base.WriteError);
T dataObject2 = this.DataObject;
ExchangeServiceVDirHelper.SetIisVirtualDirectoryAuthenticationMethods(virtualDirectory, errorHandler, Strings.ErrorUpdatingVDir(dataObject2.MetabasePath, string.Empty));
}
}
protected override void InternalValidate()
{
base.InternalValidate();
if (base.HasErrors)
{
return;
}
if (!this.IsInSetup && this.DataObject.ExchangeVersion.IsOlderThan(ADMobileVirtualDirectory.MinimumSupportedExchangeObjectVersion))
{
base.WriteError(new TaskException(Strings.ErrorSetOlderVirtualDirectory(this.DataObject.Identity.ToString(), this.DataObject.ExchangeVersion.ToString(), ADMobileVirtualDirectory.MinimumSupportedExchangeObjectVersion.ToString())), ErrorCategory.InvalidArgument, null);
}
string metabasePath = this.DataObject.MetabasePath;
if (!IisUtility.Exists(metabasePath))
{
base.WriteError(new WebObjectNotFoundException(Strings.ErrorObjectNotFound(metabasePath)), ErrorCategory.ObjectNotFound, metabasePath);
return;
}
if (ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(this.DataObject) && !this.IsInSetup)
{
bool flag = false;
for (int i = 0; i < this.InvalidParametersOnMbxRole.Length; i++)
{
if (base.Fields.Contains(this.InvalidParametersOnMbxRole[i]))
{
this.WriteError(new InvalidArgumentForServerRoleException(this.InvalidParametersOnMbxRole[i], DirectoryStrings.ServerRoleCafe), ErrorCategory.InvalidArgument, this.DataObject, false);
flag = true;
}
}
if (flag)
{
return;
}
}
bool flag2 = IisUtility.SSLEnabled(metabasePath);
if (this.DataObject.BasicAuthEnabled && !flag2)
{
this.WriteWarning(Strings.WarnBasicAuthInClear);
}
if (this.DataObject.ClientCertAuth != ClientCertAuthTypes.Ignore && this.DataObject.ClientCertAuth != ClientCertAuthTypes.Accepted && this.DataObject.ClientCertAuth != ClientCertAuthTypes.Required)
{
base.WriteError(new ArgumentException(Strings.InvalidCertAuthValue, "ClientCertAuth"), ErrorCategory.InvalidArgument, null);
return;
}
if (this.DataObject.ClientCertAuth == ClientCertAuthTypes.Required && !flag2)
{
base.WriteError(new ArgumentException(Strings.CertAuthWithoutSSLError, "ClientCertAuth"), ErrorCategory.InvalidArgument, null);
}
}
protected bool FilterBackendVdir(ExchangeVirtualDirectory vdir)
{
if (this.ShowMailboxVirtualDirectories || this.ShowBackEndVirtualDirectories)
{
return(false);
}
if (ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(vdir))
{
return(true);
}
Server server = (Server)base.GetDataObject <Server>(new ServerIdParameter(vdir.Server), base.DataSession, null, new LocalizedString?(Strings.ErrorServerNotFound(vdir.Server.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(vdir.Server.ToString())));
return(server.IsE15OrLater && !server.IsCafeServer && server.IsMailboxServer);
}
protected override void InternalProcessMetabase()
{
base.InternalProcessMetabase();
if (this.IsBackEnd)
{
ExchangeServiceVDirHelper.CheckAndUpdateLocalhostNetPipeBindingsIfNecessary(this.DataObject);
try
{
ExchangeServiceVDirHelper.RunAppcmd(string.Format("set app \"{0}/{1}\" /enabledProtocols:http,net.pipe", this.WebSiteName, this.VirtualDirectoryName));
}
catch (AppcmdException exception)
{
base.WriteError(exception, ExchangeErrorCategory.ServerOperation, this.DataObject.Identity);
}
}
}
protected override void InternalProcessComplete()
{
base.InternalProcessComplete();
if (Datacenter.IsMicrosoftHostedOnly(true))
{
DirectoryEntry directoryEntry = IisUtility.CreateWebDirObject(this.DataObject.MetabasePath, null, "Nego2");
IisUtility.SetProperty(directoryEntry, "AccessFlags", MetabasePropertyTypes.AccessFlags.Read | MetabasePropertyTypes.AccessFlags.Script, true);
directoryEntry.CommitChanges();
string nego2Path = string.Format("{0}/{1}", this.DataObject.MetabasePath, "Nego2");
ExchangeServiceVDirHelper.SetSplitVirtualDirectoryAuthenticationMethods(this.DataObject, nego2Path, new Task.TaskErrorLoggingDelegate(base.WriteError), this.MetabaseSetPropertiesFailureMessage);
}
else if (base.Role == VirtualDirectoryRole.ClientAccess)
{
ExchangeServiceVDirHelper.CheckAndUpdateLocalhostWebBindingsIfNecessary(this.DataObject);
}
ExchangeServiceVDirHelper.EwsAutodiscMWA.OnNewManageWCFEndpoints(this, ExchangeServiceVDirHelper.EwsAutodiscMWA.EndpointProtocol.Ews, this.DataObject.BasicAuthentication, this.DataObject.WindowsAuthentication, this.DataObject.WSSecurityAuthentication ?? false, this.DataObject.OAuthAuthentication ?? false, this.DataObject, base.Role);
}
protected override void InternalProcessRecord()
{
base.InternalProcessRecord();
base.InternalEnableLiveIdNegotiateAuxiliaryModule();
if (base.Fields["EnableSessionKeyRedirectionModule"] != null)
{
base.SetSessionKeyRedirectionModule(this.EnableSessionKeyRedirectionModule, false);
}
if (base.Fields["EnableDelegatedAuthModule"] != null)
{
base.SetDelegatedAuthenticationModule(this.EnableDelegatedAuthModule, false);
base.SetPowerShellRequestFilterModule(this.EnableDelegatedAuthModule, false);
}
if (base.Fields["RequireSSL"] != null)
{
ExchangeServiceVDirHelper.SetSSLRequired(this.DataObject, new Task.TaskErrorLoggingDelegate(base.WriteError), Strings.ErrorUpdatingVDir(this.DataObject.MetabasePath, string.Empty), (bool)base.Fields["RequireSSL"]);
}
}
protected override void InternalProcessRecord()
{
base.InternalProcessRecord();
base.InternalEnableLiveIdNegotiateAuxiliaryModule();
if (base.Fields["CertificateAuthentication"] != null)
{
T dataObject = this.DataObject;
dataObject.CertificateAuthentication = new bool?((bool)base.Fields["CertificateAuthentication"]);
ADExchangeServiceVirtualDirectory virtualDirectory = this.DataObject;
Task.TaskErrorLoggingDelegate errorHandler = new Task.TaskErrorLoggingDelegate(base.WriteError);
T dataObject2 = this.DataObject;
ExchangeServiceVDirHelper.SetIisVirtualDirectoryAuthenticationMethods(virtualDirectory, errorHandler, Strings.ErrorUpdatingVDir(dataObject2.MetabasePath, string.Empty));
T dataObject3 = this.DataObject;
ExchangeServiceVDirHelper.ConfigureAnonymousAuthentication(dataObject3.MetabasePath, false);
}
if (base.Fields["EnableCertificateHeaderAuthModule"] != null)
{
base.SetCertificateHeaderAuthenticationModule(this.EnableCertificateHeaderAuthModule, false);
}
}
protected override void InternalProcessComplete()
{
ADExchangeServiceVirtualDirectory adexchangeServiceVirtualDirectory = this.DataObject;
base.InternalProcessComplete();
ExchangeServiceVDirHelper.SetIisVirtualDirectoryAuthenticationMethods(adexchangeServiceVirtualDirectory, new Task.TaskErrorLoggingDelegate(base.WriteError), this.MetabaseSetPropertiesFailureMessage);
T dataObject = this.DataObject;
if (dataObject.LiveIdBasicAuthentication != null)
{
T dataObject2 = this.DataObject;
ExchangeServiceVDirHelper.SetLiveIdBasicAuthModule(dataObject2.LiveIdBasicAuthentication.Value, false, adexchangeServiceVirtualDirectory);
}
T dataObject3 = this.DataObject;
if (dataObject3.OAuthAuthentication != null)
{
T dataObject4 = this.DataObject;
ExchangeServiceVDirHelper.SetOAuthAuthenticationModule(dataObject4.OAuthAuthentication.Value, false, adexchangeServiceVirtualDirectory);
}
ExchangeServiceVDirHelper.CheckAndUpdateWindowsAuthProvidersIfNecessary(adexchangeServiceVirtualDirectory, new bool?(true));
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
base.InternalProcessRecord();
ServerIdParameter serverIdParameter = new ServerIdParameter();
Server server = (Server)base.GetDataObject <Server>(serverIdParameter, base.DataSession, null, new LocalizedString?(Strings.ErrorServerNotFound(serverIdParameter.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(serverIdParameter.ToString())));
if (!server.IsClientAccessServer && !server.IsCafeServer)
{
base.ThrowTerminatingError(server.GetServerRoleError(ServerRole.ClientAccess), ErrorCategory.InvalidOperation, server);
}
using (ServerManager serverManager = new ServerManager())
{
ApplicationPool applicationPool = serverManager.ApplicationPools["MSExchangeOWAAppPool"];
if (applicationPool == null)
{
base.ThrowTerminatingError(new ADNoSuchObjectException(Strings.ErrorOWAVdirAppPoolNotExist), ErrorCategory.ObjectNotFound, serverManager.ApplicationPools);
}
applicationPool.ManagedPipelineMode = 0;
serverManager.CommitChanges();
}
QueryFilter filter = new ComparisonFilter(ComparisonOperator.NotEqual, ADOwaVirtualDirectorySchema.OwaVersion, OwaVersions.Exchange2003or2000);
base.WriteVerbose(TaskVerboseStringHelper.GetFindDataObjectsVerboseString(base.DataSession, typeof(ADOwaVirtualDirectory), filter, server.Identity, true));
IConfigDataProvider dataSession = base.DataSession;
IEnumerable <ADOwaVirtualDirectory> enumerable = dataSession.FindPaged <ADOwaVirtualDirectory>(filter, server.Identity, true, null, 0);
foreach (ADOwaVirtualDirectory adowaVirtualDirectory in enumerable)
{
if (adowaVirtualDirectory.WebSite.Equals("Exchange Back End", StringComparison.OrdinalIgnoreCase))
{
string metabasePath = adowaVirtualDirectory.MetabasePath;
try
{
base.WriteVerbose(Strings.VerboseConnectingIISVDir(metabasePath));
using (IisUtility.CreateIISDirectoryEntry(metabasePath))
{
if (!DirectoryEntry.Exists(metabasePath))
{
this.WriteWarning(Strings.OwaAdOrphanFound(adowaVirtualDirectory.Identity.ToString()));
continue;
}
if (!IisUtility.WebDirObjectExists(metabasePath, this.owaVersion))
{
base.WriteVerbose(Strings.VerboseCreatingChildVDir(this.owaVersion, metabasePath));
CreateVirtualDirectory createVirtualDirectory = new CreateVirtualDirectory();
createVirtualDirectory.Name = this.owaVersion;
createVirtualDirectory.Parent = metabasePath;
createVirtualDirectory.CustomizedVDirProperties = OwaVirtualDirectoryHelper.GetVersionVDirProperties();
createVirtualDirectory.LocalPath = (string)IisUtility.GetIisPropertyValue("Path", createVirtualDirectory.CustomizedVDirProperties);
createVirtualDirectory.Initialize();
createVirtualDirectory.Execute();
}
}
OwaVirtualDirectoryHelper.CreateLegacyVDirs(metabasePath, true);
OwaVirtualDirectoryHelper.CreateOwaCalendarVDir(metabasePath, VirtualDirectoryRole.Mailbox);
if (ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(adowaVirtualDirectory))
{
WebAppVirtualDirectoryHelper.UpdateMetabase(adowaVirtualDirectory, metabasePath, true);
}
}
catch (COMException ex)
{
base.WriteError(new IISGeneralCOMException(ex.Message, ex.ErrorCode, ex), ErrorCategory.InvalidOperation, null);
}
if (adowaVirtualDirectory.ExchangeVersion.IsOlderThan(adowaVirtualDirectory.MaximumSupportedExchangeObjectVersion))
{
try
{
adowaVirtualDirectory.SetExchangeVersion(adowaVirtualDirectory.MaximumSupportedExchangeObjectVersion);
base.DataSession.Save(adowaVirtualDirectory);
}
catch (DataSourceTransientException exception)
{
base.WriteError(exception, ErrorCategory.WriteError, null);
}
}
}
}
TaskLogger.LogExit();
}
protected override void InternalProcessComplete()
{
base.InternalProcessComplete();
ExchangeServiceVDirHelper.ForceAnonymous(this.DataObject.MetabasePath);
ExchangeServiceVDirHelper.EwsAutodiscMWA.OnNewManageWCFEndpoints(this, ExchangeServiceVDirHelper.EwsAutodiscMWA.EndpointProtocol.Autodiscover, this.DataObject.BasicAuthentication, this.DataObject.WindowsAuthentication, this.DataObject.WSSecurityAuthentication ?? false, this.DataObject.OAuthAuthentication ?? false, this.DataObject, base.Role);
}
protected void SetSessionKeyRedirectionModule(bool EnableModule, bool isChildVDirApplication)
{
ExchangeServiceVDirHelper.SetAuthModule(EnableModule, isChildVDirApplication, "SessionKeyRedirectionModule", typeof(SessionKeyRedirectionModule).FullName, this.DataObject);
}
protected void SetCertificateHeaderAuthenticationModule(bool EnableModule, bool isChildVDirApplication)
{
ExchangeServiceVDirHelper.SetAuthModule(EnableModule, isChildVDirApplication, "CertificateHeaderAuthModule", "Microsoft.Exchange.Configuration.CertificateAuthentication.CertificateHeaderAuthModule", this.DataObject);
}
protected void SetPowerShellRequestFilterModule(bool EnableModule, bool isChildVDirApplication)
{
ExchangeServiceVDirHelper.SetAuthModule(EnableModule, isChildVDirApplication, "PowerShellRequestFilterModule", "Microsoft.Exchange.Configuration.DelegatedAuthentication.PowerShellRequestFilterModule", this.DataObject);
}
protected void SetLiveIdNegotiateAuxiliaryModule(bool EnableModule, bool isChildVDirApplication)
{
ExchangeServiceVDirHelper.SetAuthModule(EnableModule, isChildVDirApplication, "LiveIdNegotiateAuxiliaryModule", typeof(LiveIdNegotiateAuxiliaryModule).FullName, this.DataObject);
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
base.InternalProcessRecord();
ADMobileVirtualDirectory dataObject = this.DataObject;
MobileSyncVirtualDirectoryHelper.SetToMetabase(dataObject, this);
if (base.Fields.Contains("InstallIsapiFilter") && this.InstallIsapiFilter)
{
try
{
MobileSyncVirtualDirectoryHelper.InstallIsapiFilter(this.DataObject, !ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(this.DataObject));
}
catch (Exception ex)
{
TaskLogger.Trace("Exception occurred in InstallIsapiFilter(): {0}", new object[]
{
ex.Message
});
this.WriteWarning(Strings.ActiveSyncMetabaseIsapiInstallFailure);
throw;
}
}
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
bool flag = false;
ADEcpVirtualDirectory adecpVirtualDirectory = WebAppVirtualDirectoryHelper.FindWebAppVirtualDirectoryInSameWebSite <ADEcpVirtualDirectory>(this.DataObject, base.DataSession);
if (adecpVirtualDirectory != null)
{
if (this.DataObject.IsChanged(ExchangeWebAppVirtualDirectorySchema.DefaultDomain))
{
adecpVirtualDirectory.DefaultDomain = this.DataObject.DefaultDomain;
flag = true;
}
WebAppVirtualDirectoryHelper.CheckTwoWebAppVirtualDirectories(this.DataObject, adecpVirtualDirectory, new Action <string>(base.WriteWarning), Strings.OwaAuthenticationNotMatchEcpWarning, Strings.OwaUrlNotMatchEcpWarning);
}
else
{
this.WriteWarning(Strings.CreateEcpForOwaWarning);
}
if (this.DataObject.IsChanged(ADOwaVirtualDirectorySchema.AnonymousFeaturesEnabled))
{
this.UpdateCalendarMetabase(this.DataObject);
}
if (this.DataObject.IsChanged(ADOwaVirtualDirectorySchema.IntegratedFeaturesEnabled))
{
this.UpdateIntegratedMetabase(this.DataObject);
}
if (this.DataObject.IsChanged(ExchangeWebAppVirtualDirectorySchema.LiveIdAuthentication))
{
this.UpdateOmaMetabase(this.DataObject);
}
base.InternalProcessRecord();
ADOwaVirtualDirectory dataObject = this.DataObject;
bool flag2 = ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(this.DataObject);
if (dataObject.LiveIdAuthentication)
{
WebAppVirtualDirectoryHelper.UpdateMetabase(dataObject, dataObject.MetabasePath, true);
}
else
{
WebAppVirtualDirectoryHelper.UpdateMetabase(dataObject, dataObject.MetabasePath, flag2);
}
if (flag)
{
WebAppVirtualDirectoryHelper.UpdateMetabase(adecpVirtualDirectory, adecpVirtualDirectory.MetabasePath, true);
}
if (flag2)
{
ExchangeServiceVDirHelper.EwsAutodiscMWA.OnSetManageWCFEndpoints(this, ExchangeServiceVDirHelper.EwsAutodiscMWA.EndpointProtocol.OwaEws, false, this.DataObject);
}
else if (base.Fields.Contains("FormsAuthentication"))
{
ExchangeServiceVDirHelper.UpdateFrontEndHttpModule(this.DataObject, this.FormsAuthentication);
}
if (base.Fields.Contains("OAuthAuthentication"))
{
ExchangeServiceVDirHelper.SetOAuthAuthenticationModule(this.DataObject.OAuthAuthentication, false, this.DataObject);
}
if (base.Fields.Contains("AdfsAuthentication"))
{
ExchangeServiceVDirHelper.SetAdfsAuthenticationModule(this.DataObject.AdfsAuthentication, false, this.DataObject);
}
TaskLogger.LogExit();
}
