internal static string GenerateUniqueAliasForSiteMailbox(IRecipientSession recipientSession, OrganizationId organizationId, string preferredAlias, string prefix, bool isMicrosoftHostedOnlyDatacenter, Task.TaskVerboseLoggingDelegate logHandler, Task.ErrorLoggerDelegate writeError)
{
string text = WindowsLiveIDLocalPartConstraint.RemoveInvalidPartOfWindowsLiveID(preferredAlias);
if (!string.IsNullOrEmpty(text) && text.Length > 3)
{
logHandler(Strings.VerboseGenerateAliasBySiteDisplayName(preferredAlias));
text = RecipientTaskHelper.GenerateUniqueAlias(recipientSession, organizationId, (!string.IsNullOrEmpty(prefix)) ? (prefix + text) : text, logHandler, 63);
}
else
{
int num = 1000;
if (string.IsNullOrEmpty(prefix))
{
prefix = (isMicrosoftHostedOnlyDatacenter ? "SMO-" : "SM-");
}
do
{
text = TeamMailboxHelper.GenerateRandomString();
text = prefix + text;
logHandler(Strings.VerboseGenerateAliasByRandomString(preferredAlias, text));
if (RecipientTaskHelper.IsAliasUnique(recipientSession, organizationId, null, text, logHandler, writeError, ExchangeErrorCategory.Client))
{
break;
}
text = string.Empty;
}while (num-- > 0);
}
if (string.IsNullOrEmpty(text))
{
writeError(new ErrorCannotGenerateSiteMailboxAliasException(), ExchangeErrorCategory.Client, null);
}
return(text);
}
protected override IConfigDataProvider CreateSession()
{
if (this.AccountPartition == null && this.Identity == null)
{
base.WriteError(new NotSupportedException(Strings.ErrorUnknownPartition), ErrorCategory.InvalidData, null);
}
PartitionId partitionId;
if (this.Identity != null)
{
if (this.Identity.RawIdentity.Contains("*"))
{
base.WriteError(new ArgumentException(Strings.ErrorWildcardNotSupportedInRelocationIdentity(this.Identity.RawIdentity)), ErrorCategory.InvalidOperation, this.Identity);
}
OrganizationId organizationId = this.Identity.ResolveOrganizationId();
partitionId = organizationId.PartitionId;
}
else
{
partitionId = RecipientTaskHelper.ResolvePartitionId(this.AccountPartition, new Task.TaskErrorLoggingDelegate(base.WriteError));
}
this.sourceForestRIDMaster = ForestTenantRelocationsCache.GetRidMasterName(partitionId);
ITenantConfigurationSession tenantConfigurationSession = DirectorySessionFactory.Default.CreateTenantConfigurationSession(base.DomainController, true, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromAllTenantsPartitionId(partitionId), 223, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Relocation\\GetTenantRelocationRequest.cs");
if (base.DomainController != null && !this.sourceForestRIDMaster.StartsWith(base.DomainController, StringComparison.OrdinalIgnoreCase))
{
ForestTenantRelocationsCache.Reset();
}
tenantConfigurationSession.SessionSettings.TenantConsistencyMode = TenantConsistencyMode.IncludeRetiredTenants;
return(tenantConfigurationSession);
}
private void FindOrganizationalUnit()
{
if (this.OrganizationalUnit == null)
{
return;
}
bool useConfigNC = this.ConfigurationSession.UseConfigNC;
bool useGlobalCatalog = this.ConfigurationSession.UseGlobalCatalog;
this.ConfigurationSession.UseConfigNC = false;
if (string.IsNullOrEmpty(this.ConfigurationSession.DomainController))
{
this.ConfigurationSession.UseGlobalCatalog = true;
}
try
{
this.organizationalUnit = (ExchangeOrganizationalUnit)base.GetDataObject <ExchangeOrganizationalUnit>(this.OrganizationalUnit, this.ConfigurationSession, (base.CurrentOrganizationId != null) ? base.CurrentOrganizationId.OrganizationalUnit : null, new LocalizedString?(Strings.ErrorOrganizationalUnitNotFound(this.OrganizationalUnit.ToString())), new LocalizedString?(Strings.ErrorOrganizationalUnitNotUnique(this.OrganizationalUnit.ToString())));
RecipientTaskHelper.IsOrgnizationalUnitInOrganization(this.ConfigurationSession, base.CurrentOrganizationId, this.organizationalUnit, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError));
}
finally
{
this.ConfigurationSession.UseConfigNC = useConfigNC;
this.ConfigurationSession.UseGlobalCatalog = useGlobalCatalog;
}
}
protected virtual void PrepareRecipientObject(ref TDataObject dataObject)
{
ADUser aduser = dataObject as ADUser;
if (aduser != null)
{
if (base.Fields.IsModified("SKUCapability"))
{
aduser.SKUCapability = new Capability?(this.SKUCapability);
}
if (base.Fields.IsModified("AddOnSKUCapability"))
{
CapabilityHelper.SetAddOnSKUCapabilities(this.AddOnSKUCapability, aduser.PersistedCapabilities);
RecipientTaskHelper.UpgradeArchiveQuotaOnArchiveAddOnSKU(aduser, aduser.PersistedCapabilities);
}
if (base.Fields.IsModified(ADRecipientSchema.SKUAssigned))
{
aduser.SKUAssigned = new bool?(this.SKUAssigned);
}
if (base.Fields.IsModified(ADRecipientSchema.UsageLocation))
{
aduser.UsageLocation = this.UsageLocation;
}
}
}
protected override void InternalValidate()
{
this.latencyContext = ProvisioningPerformanceHelper.StartLatencyDetection(this);
base.InternalValidate();
base.VerifyIsWithinScopes((IRecipientSession)base.DataSession, this.DataObject, true, new DataAccessTask <ADUser> .ADObjectOutOfScopeString(Strings.ErrorCannotChangeMailboxOutOfWriteScope));
if (this.DataObject.IsModified(ADMailboxRecipientSchema.ExchangeGuid) && this.DataObject.ExchangeGuid != Guid.Empty && this.DataObject.IsModified(ADUserSchema.ArchiveGuid) && this.DataObject.ArchiveGuid != Guid.Empty && this.DataObject.ExchangeGuid == this.DataObject.ArchiveGuid)
{
base.WriteError(new RecipientTaskException(Strings.ErrorInvalidParameterValue("ExchangeGuid", this.DataObject.ExchangeGuid.ToString())), ExchangeErrorCategory.Client, this.DataObject.Identity);
}
if (this.DataObject.IsModified(ADMailboxRecipientSchema.ExchangeGuid) && this.DataObject.ExchangeGuid != Guid.Empty && !this.DataObject.IsSoftDeleted)
{
RecipientTaskHelper.IsExchangeGuidOrArchiveGuidUnique(this.DataObject, ADMailboxRecipientSchema.ExchangeGuid, this.DataObject.ExchangeGuid, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client);
}
if (this.DataObject.IsModified(ADUserSchema.ArchiveGuid) && this.DataObject.ArchiveGuid != Guid.Empty)
{
RecipientTaskHelper.IsExchangeGuidOrArchiveGuidUnique(this.DataObject, ADUserSchema.ArchiveGuid, this.DataObject.ArchiveGuid, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client);
}
if (ComplianceConfigImpl.JournalArchivingHardeningEnabled && this.DataObject.IsModified(ADRecipientSchema.EmailAddresses))
{
bool flag = false;
foreach (ProxyAddress proxyAddress in this.DataObject.EmailAddresses)
{
if (proxyAddress.Prefix == ProxyAddressPrefix.JRNL)
{
if (flag)
{
base.WriteError(new RecipientTaskException(Strings.ErrorMultipleJournalArchiveAddress), ExchangeErrorCategory.Client, this.DataObject.Identity);
}
flag = true;
}
}
}
}
internal static ADUser SplitArchiveFromPrimary(ADUser primaryUser, IRecipientSession recipientSession = null)
{
ADUser aduser = null;
if (!primaryUser.ArchiveGuid.Equals(Guid.Empty))
{
aduser = new ADUser();
aduser.StampPersistableDefaultValues();
aduser.StampDefaultValues(RecipientType.UserMailbox);
aduser.ResetChangeTracking();
AuxMailboxTaskHelper.AuxMailboxStampDefaultValues(aduser);
aduser.AddressListMembership = primaryUser.AddressListMembership;
aduser.DisplayName = string.Format("{0} {1}", Strings.ArchiveNamePrefix, primaryUser.DisplayName);
aduser.OrganizationId = primaryUser.OrganizationId;
aduser.ExchangeGuid = primaryUser.ArchiveGuid;
aduser.Database = primaryUser.ArchiveDatabase;
aduser.Alias = RecipientTaskHelper.GenerateAlias(string.Format("{0}{1}", Strings.ArchiveNamePrefix, aduser.ExchangeGuid));
aduser.Name = string.Format("{0}{1}", Strings.ArchiveNamePrefix, primaryUser.ExchangeGuid);
if (recipientSession == null)
{
recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(primaryUser.OrganizationId), 74, "SplitArchiveFromPrimary", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Common\\recipient\\AuxMailboxTaskHelper.cs");
}
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(primaryUser.OrganizationId), 80, "SplitArchiveFromPrimary", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Common\\recipient\\AuxMailboxTaskHelper.cs");
aduser.UserPrincipalName = RecipientTaskHelper.GenerateUniqueUserPrincipalName(recipientSession, aduser.Alias, tenantOrTopologyConfigurationSession.GetDefaultAcceptedDomain().DomainName.Domain, null);
aduser.EmailAddresses.Add(new SmtpProxyAddress(aduser.UserPrincipalName, false));
DatabaseLocationInfo serverForDatabase = ActiveManager.GetActiveManagerInstance().GetServerForDatabase(primaryUser.ArchiveDatabase.ObjectGuid);
aduser.ServerLegacyDN = serverForDatabase.ServerLegacyDN;
aduser.SetId(primaryUser.Id.Parent.GetChildId(aduser.Name));
}
return(aduser);
}
// Token: 0x06000576 RID: 1398 RVA: 0x00014F54 File Offset: 0x00013154
protected override void SaveSoftDeletedObject()
{
TDataObject dataObject = base.DataObject;
RecipientTaskHelper.CreateSoftDeletedObjectsContainerIfNecessary(dataObject.Id.Parent, base.DomainController);
base.DataSession.Save(base.DataObject);
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
ADForest localForest = ADForest.GetLocalForest();
if (base.Fields.IsModified("Domain"))
{
this.adDomain = localForest.FindDomainByFqdn(this.Domain);
if (this.adDomain == null)
{
base.WriteError(new DomainNotFoundException(this.Domain), ErrorCategory.InvalidArgument, null);
}
}
else
{
this.adDomain = localForest.FindLocalDomain();
}
string defaultOUForRecipient = RecipientTaskHelper.GetDefaultOUForRecipient(this.adDomain.Id);
if (string.IsNullOrEmpty(defaultOUForRecipient))
{
base.WriteError(new ArgumentException(Strings.UsersContainerNotFound(this.adDomain.Fqdn, WellKnownGuid.UsersWkGuid)), ErrorCategory.InvalidArgument, null);
}
this.containerId = new ADObjectId(NativeHelpers.DistinguishedNameFromCanonicalName(defaultOUForRecipient));
base.InternalValidate();
TaskLogger.LogExit();
}
protected override IConfigDataProvider CreateSession()
{
ADSessionSettings adsessionSettings;
if (this.AccountPartition != null)
{
PartitionId partitionId = RecipientTaskHelper.ResolvePartitionId(this.AccountPartition, new Task.TaskErrorLoggingDelegate(base.WriteError));
adsessionSettings = ADSessionSettings.FromAllTenantsPartitionId(partitionId);
}
else
{
adsessionSettings = ADSessionSettings.FromCustomScopeSet(base.ScopeSet, base.RootOrgContainerId, base.CurrentOrganizationId, base.ExecutingUserOrganizationId, true);
}
if (MapiTaskHelper.IsDatacenter || MapiTaskHelper.IsDatacenterDedicated)
{
adsessionSettings.IncludeSoftDeletedObjects = true;
adsessionSettings.IncludeInactiveMailbox = true;
}
this.CurrentOrgConfigSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(this.DomainController, true, ConsistencyMode.PartiallyConsistent, null, adsessionSettings, 479, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequest.cs");
if (this.AccountPartition == null)
{
adsessionSettings = ADSessionSettings.RescopeToSubtree(adsessionSettings);
}
this.GCSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(this.DomainController, true, ConsistencyMode.PartiallyConsistent, adsessionSettings, 493, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequest.cs");
this.RecipSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(this.DomainController, true, ConsistencyMode.PartiallyConsistent, adsessionSettings, 500, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequest.cs");
this.ConfigSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(null, true, ConsistencyMode.PartiallyConsistent, null, ADSessionSettings.FromRootOrgScopeSet(), 506, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequest.cs");
if (this.indexProvider != null)
{
this.indexProvider = null;
}
this.indexProvider = new RequestIndexEntryProvider(this.GCSession, this.CurrentOrgConfigSession);
return(this.indexProvider);
}
protected override void PrepareUserObject(ADUser user)
{
TaskLogger.LogEnter();
if (base.WindowsLiveID == null && base.SoftDeletedObject == null && VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Global.WindowsLiveID.Enabled&& !RecipientTaskHelper.SMTPAddressCheckWithAcceptedDomain(this.ConfigurationSession, user.OrganizationId, new Task.ErrorLoggerDelegate(base.WriteError), base.ProvisioningCache))
{
base.WriteError(new RecipientTaskException(Strings.ErrorWindowsLiveIdRequired(user.Name)), ExchangeErrorCategory.Client, null);
}
if (base.WindowsLiveID != null && base.WindowsLiveID.SmtpAddress != SmtpAddress.Empty)
{
if (this.ExternalEmailAddress == null)
{
user.ExternalEmailAddress = ProxyAddress.Parse(base.WindowsLiveID.SmtpAddress.ToString());
}
user.UserPrincipalName = base.WindowsLiveID.SmtpAddress.ToString();
base.IsSetRandomPassword = (base.SoftDeletedObject == null || base.IsSetRandomPassword);
}
if (string.IsNullOrEmpty(user.UserPrincipalName))
{
user.UserPrincipalName = RecipientTaskHelper.GenerateUniqueUserPrincipalName(base.TenantGlobalCatalogSession, user.Name, this.ConfigurationSession.GetDefaultAcceptedDomain().DomainName.Domain, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose));
}
if (base.SoftDeletedObject == null)
{
if (base.Fields.IsModified(MailUserSchema.RemotePowerShellEnabled))
{
user.RemotePowerShellEnabled = this.RemotePowerShellEnabled;
}
else
{
user.RemotePowerShellEnabled = true;
}
MailUserTaskHelper.ValidateExternalEmailAddress(user, this.ConfigurationSession, new Task.ErrorLoggerDelegate(base.WriteError), base.ProvisioningCache);
}
if (base.Fields.IsChanged(ADRecipientSchema.MailboxProvisioningConstraint))
{
user.MailboxProvisioningConstraint = this.MailboxProvisioningConstraint;
}
if (base.Fields.IsChanged(ADRecipientSchema.MailboxProvisioningPreferences))
{
user.MailboxProvisioningPreferences = this.MailboxProvisioningPreferences;
}
if (user.MailboxProvisioningConstraint != null)
{
MailboxTaskHelper.ValidateMailboxProvisioningConstraintEntries(new MailboxProvisioningConstraint[]
{
user.MailboxProvisioningConstraint
}, base.DomainController, delegate(string message)
{
base.WriteVerbose(new LocalizedString(message));
}, new Task.ErrorLoggerDelegate(base.WriteError));
}
if (user.MailboxProvisioningPreferences != null)
{
MailboxTaskHelper.ValidateMailboxProvisioningConstraintEntries(user.MailboxProvisioningPreferences, base.DomainController, delegate(string message)
{
base.WriteVerbose(new LocalizedString(message));
}, new Task.ErrorLoggerDelegate(base.WriteError));
}
base.PrepareUserObject(user);
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
if (this.FederatedIdentity != null && this.Password != null)
{
base.WriteError(new RecipientTaskException(Strings.ErrorFederatedIdentityandPasswordTogether), ExchangeErrorCategory.Client, this.DataObject.Identity);
}
if (this.DataObject.IsChanged(MailUserSchema.WindowsLiveID))
{
MailboxTaskHelper.IsMemberExists((IRecipientSession)base.DataSession, this.DataObject.WindowsLiveID, new Task.ErrorLoggerDelegate(base.WriteError));
}
if (this.DataObject.IsModified(MailUserSchema.UserPrincipalName))
{
if (VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).CmdletInfra.ValidateExternalEmailAddressInAcceptedDomain.Enabled&& this.ShouldCheckAcceptedDomains())
{
RecipientTaskHelper.ValidateInAcceptedDomain(this.ConfigurationSession, this.DataObject.OrganizationId, RecipientTaskHelper.GetDomainPartOfUserPrincalName(this.DataObject.UserPrincipalName), new Task.ErrorLoggerDelegate(base.WriteError), base.ProvisioningCache);
}
RecipientTaskHelper.IsUserPrincipalNameUnique(base.TenantGlobalCatalogSession, this.DataObject, this.DataObject.UserPrincipalName, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client);
}
if (this.DataObject.IsChanged(MailboxSchema.JournalArchiveAddress) && this.DataObject.JournalArchiveAddress != SmtpAddress.NullReversePath && this.DataObject.JournalArchiveAddress != SmtpAddress.Empty)
{
RecipientTaskHelper.IsJournalArchiveAddressUnique(base.TenantGlobalCatalogSession, this.DataObject.OrganizationId, this.DataObject, this.DataObject.JournalArchiveAddress, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client);
}
if (this.DataObject.IsModified(MailUserSchema.SamAccountName))
{
RecipientTaskHelper.IsSamAccountNameUnique(this.DataObject, this.DataObject.SamAccountName, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client);
}
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter(new object[]
{
this.DataObject
});
this.IsSetRandomPassword = false;
if (this.DataObject.IsChanged(MailboxSchema.WindowsLiveID))
{
this.IsSetRandomPassword = true;
if (this.DataObject.IsChanged(MailboxSchema.NetID))
{
MailboxTaskHelper.IsLiveIdExists((IRecipientSession)base.DataSession, this.DataObject.WindowsLiveID, this.DataObject.NetID, new Task.ErrorLoggerDelegate(base.WriteError));
}
}
if (base.Fields.IsModified("SKUCapability"))
{
this.DataObject.SKUCapability = new Capability?(this.SKUCapability);
}
if (base.Fields.IsModified("AddOnSKUCapability"))
{
CapabilityHelper.SetAddOnSKUCapabilities(this.AddOnSKUCapability, this.DataObject.PersistedCapabilities);
RecipientTaskHelper.UpgradeArchiveQuotaOnArchiveAddOnSKU(this.DataObject, this.DataObject.PersistedCapabilities);
}
if (this.IsChangingOnPassword && this.HasSetPasswordPermission)
{
((IRecipientSession)base.DataSession).SetPassword(this.DataObject, this.Password);
}
base.InternalProcessRecord();
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
SetADUserBase <TIdentity, TPublicObject> .ValidateUserParameters(this.DataObject, this.ConfigurationSession, RecipientTaskHelper.CreatePartitionOrRootOrgScopedGcSession(base.DomainController, this.DataObject.Id), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client, this.ShouldCheckAcceptedDomains(), base.ProvisioningCache);
if (this.DataObject.IsChanged(UserSchema.WindowsLiveID) && this.DataObject.WindowsLiveID != SmtpAddress.Empty)
{
if (this.ShouldCheckAcceptedDomains())
{
RecipientTaskHelper.ValidateInAcceptedDomain(this.ConfigurationSession, this.DataObject.OrganizationId, this.DataObject.WindowsLiveID.Domain, new Task.ErrorLoggerDelegate(base.WriteError), base.ProvisioningCache);
MailboxTaskHelper.IsLiveIdExists((IRecipientSession)base.DataSession, this.DataObject.WindowsLiveID, this.DataObject.NetID, new Task.ErrorLoggerDelegate(base.WriteError));
}
this.DataObject.UserPrincipalName = this.DataObject.WindowsLiveID.ToString();
}
if (this.DataObject.IsModified(UserSchema.CertificateSubject))
{
NewLinkedUser.ValidateCertificateSubject(this.DataObject.CertificateSubject, OrganizationId.ForestWideOrgId.Equals(this.DataObject.OrganizationId) ? null : this.DataObject.OrganizationId.PartitionId, this.DataObject.Id, new Task.TaskErrorLoggingDelegate(base.WriteError));
}
if (this.IsDisablingRemotePowerShell() && this.orgAdminHelper.ShouldPreventLastAdminRemoval(this, this.DataObject.OrganizationId) && this.orgAdminHelper.IsLastAdmin(this.DataObject))
{
TIdentity identity = this.Identity;
base.WriteError(new RecipientTaskException(Strings.ErrorCannotDisableRemotePowershelForLastDelegatingOrgAdmin(identity.ToString())), ErrorCategory.InvalidOperation, this.Identity);
}
TaskLogger.LogExit();
}
protected virtual void PrepareUserObject(ADUser user)
{
TaskLogger.LogEnter();
if (this.WindowsLiveID != null && this.WindowsLiveID.SmtpAddress != SmtpAddress.Empty)
{
if (base.IsDebugOn)
{
base.WriteDebug(Strings.DebugStartInAcceptedDomainCheck);
}
if (this.ShouldCheckAcceptedDomains())
{
RecipientTaskHelper.ValidateInAcceptedDomain(this.ConfigurationSession, base.CurrentOrganizationId, this.WindowsLiveID.SmtpAddress.Domain, new Task.ErrorLoggerDelegate(base.WriteError), base.ProvisioningCache);
}
if (base.IsDebugOn)
{
base.WriteDebug(Strings.DebugEndInAcceptedDomainCheck);
}
this.IsSetRandomPassword = true;
user.WindowsLiveID = this.WindowsLiveID.SmtpAddress;
user.UserPrincipalName = this.WindowsLiveID.SmtpAddress.ToString();
}
else if (VariantConfiguration.InvariantNoFlightingSnapshot.CmdletInfra.ValidateExternalEmailAddressInAcceptedDomain.Enabled && this.ShouldCheckAcceptedDomains())
{
RecipientTaskHelper.ValidateInAcceptedDomain(this.ConfigurationSession, user.OrganizationId, RecipientTaskHelper.GetDomainPartOfUserPrincalName(user.UserPrincipalName), new Task.ErrorLoggerDelegate(base.WriteError), base.ProvisioningCache);
}
TaskLogger.LogExit();
}
private void RemoveMailUser()
{
if (this.mailUser == null)
{
this.WriteWarning(Strings.WarningJournalArchiveMailboxHasNoMailUser);
return;
}
if (DisableJournalArchiving.ShouldSoftDeleteUser(this.mailUser))
{
SoftDeletedTaskHelper.UpdateRecipientForSoftDelete(base.DataSession as IRecipientSession, this.mailUser, false);
SoftDeletedTaskHelper.UpdateExchangeGuidForMailEnabledUser(this.mailUser);
this.mailUser.JournalArchiveAddress = SmtpAddress.NullReversePath;
base.WriteVerbose(TaskVerboseStringHelper.GetDeleteObjectVerboseString(this.mailUser.Identity, base.DataSession, typeof(ADUser)));
try
{
try
{
RecipientTaskHelper.CreateSoftDeletedObjectsContainerIfNecessary(this.mailUser.Id.Parent, base.DomainController);
base.DataSession.Save(this.mailUser);
}
catch (DataSourceTransientException exception)
{
base.WriteError(exception, ExchangeErrorCategory.ServerTransient, null);
}
return;
}
finally
{
base.WriteVerbose(TaskVerboseStringHelper.GetSourceVerboseString(base.DataSession));
}
}
base.WriteError(new RecipientTaskException(Strings.ErrorDisableJournalArchiveMailuserNotSoftDeleted), ExchangeErrorCategory.Client, this.mailUser.Identity);
}
public static void ValidateExternalEmailAddress(ADContact contact, IConfigurationSession configurationSession, Task.ErrorLoggerDelegate writeError, ProvisioningCache provisioningCache)
{
if (VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).CmdletInfra.ValidateExternalEmailAddressInAcceptedDomain.Enabled)
{
SmtpProxyAddress smtpProxyAddress = contact.ExternalEmailAddress as SmtpProxyAddress;
if (smtpProxyAddress == null)
{
writeError(new RecipientTaskException(Strings.ErrorExternalEmailAddressNotSmtpAddress((contact.ExternalEmailAddress == null) ? "$null" : contact.ExternalEmailAddress.ToString())), ExchangeErrorCategory.Client, contact.Identity);
return;
}
if (RecipientTaskHelper.SMTPAddressCheckWithAcceptedDomain(configurationSession, contact.OrganizationId, writeError, provisioningCache))
{
string domain = new SmtpAddress(smtpProxyAddress.SmtpAddress).Domain;
if (RecipientTaskHelper.IsAcceptedDomain(configurationSession, contact.OrganizationId, domain, provisioningCache))
{
writeError(new RecipientTaskException(Strings.ErrorIsAcceptedDomain(domain)), ExchangeErrorCategory.Client, null);
}
}
contact.EmailAddressPolicyEnabled = false;
if (contact.PrimarySmtpAddress == SmtpAddress.Empty)
{
contact.PrimarySmtpAddress = new SmtpAddress(smtpProxyAddress.SmtpAddress);
}
}
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
if (this.manager != null)
{
RecipientTaskHelper.CheckRecipientInSameOrganizationWithDataObject(this.DataObject, this.manager, new Task.ErrorLoggerDelegate(base.WriteError));
}
if (this.grantSendOnBehalfTo != null)
{
foreach (ADRecipient recipient in this.grantSendOnBehalfTo)
{
RecipientTaskHelper.CheckRecipientInSameOrganizationWithDataObject(this.DataObject, recipient, new Task.ErrorLoggerDelegate(base.WriteError));
}
}
if (this.bypassModerationFromRecipient != null)
{
foreach (ADRecipient recipient2 in this.bypassModerationFromRecipient)
{
RecipientTaskHelper.CheckRecipientInSameOrganizationWithDataObject(this.DataObject, recipient2, new Task.ErrorLoggerDelegate(base.WriteError));
}
}
if (this.bypassModerationFromDLMembersRecipient != null)
{
foreach (ADRecipient recipient3 in this.bypassModerationFromDLMembersRecipient)
{
RecipientTaskHelper.CheckRecipientInSameOrganizationWithDataObject(this.DataObject, recipient3, new Task.ErrorLoggerDelegate(base.WriteError));
}
}
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
MailboxTaskHelper.ValidateGroupManagedBy(base.TenantGlobalCatalogSession, this.DataObject, this.managedByRecipients, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>), new Task.ErrorLoggerDelegate(base.WriteError));
if (this.DataObject.IsModified(ADMailboxRecipientSchema.SamAccountName))
{
RecipientTaskHelper.IsSamAccountNameUnique(this.DataObject, this.DataObject.SamAccountName, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client);
}
if (base.ParameterSetName == "Universal")
{
if ((this.DataObject.GroupType & GroupTypeFlags.Universal) == GroupTypeFlags.Universal)
{
base.WriteError(new RecipientTaskException(Strings.ErrorIsUniversalGroupAlready(this.DataObject.Name)), ErrorCategory.InvalidArgument, this.DataObject.Identity);
}
else
{
if ((this.DataObject.GroupType & GroupTypeFlags.BuiltinLocal) == GroupTypeFlags.BuiltinLocal || SetGroup.IsBuiltInObject(this.DataObject))
{
base.WriteError(new RecipientTaskException(Strings.ErrorCannotConvertBuiltInGroup(this.DataObject.Name)), ErrorCategory.InvalidArgument, this.DataObject.Identity);
}
GroupTypeFlags groupTypeFlags = (GroupTypeFlags)7;
this.DataObject.GroupType = ((this.DataObject.GroupType & ~groupTypeFlags) | GroupTypeFlags.Universal);
base.DesiredRecipientType = this.DataObject.RecipientType;
}
}
if (this.DataObject.IsChanged(ADGroupSchema.Members) || base.ParameterSetName == "Universal")
{
MailboxTaskHelper.ValidateAddedMembers(base.TenantGlobalCatalogSession, this.DataObject, new Task.ErrorLoggerDelegate(base.WriteError), new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>));
}
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
ADUser aduser = null;
if (this.IsDefault)
{
aduser = RecipientTaskHelper.ResetOldDefaultPlan((IRecipientSession)base.DataSession, this.DataObject.Id, this.DataObject.OrganizationalUnitRoot, new Task.ErrorLoggerDelegate(base.WriteError));
}
bool flag = false;
try
{
base.InternalProcessRecord();
flag = true;
}
finally
{
if (!flag && aduser != null)
{
aduser.IsDefault = true;
try
{
base.DataSession.Save(aduser);
}
catch (DataSourceTransientException exception)
{
this.WriteError(exception, ExchangeErrorCategory.ServerTransient, null, false);
}
}
}
}
protected override void PrepareUserObject(ADUser user)
{
TaskLogger.LogEnter();
base.PrepareUserObject(user);
if (this.WindowsLiveID != null && this.WindowsLiveID.SmtpAddress != SmtpAddress.Empty)
{
user.EmailAddressPolicyEnabled = false;
SmtpProxyAddress item = new SmtpProxyAddress(this.WindowsLiveID.SmtpAddress.ToString(), false);
if (!user.EmailAddresses.Contains(item))
{
user.EmailAddresses.Add(item);
}
}
if (user.ExchangeGuid == SoftDeletedTaskHelper.PredefinedExchangeGuid)
{
user.ExchangeGuid = user.PreviousExchangeGuid;
if (!RecipientTaskHelper.IsExchangeGuidOrArchiveGuidUnique(user, ADMailboxRecipientSchema.ExchangeGuid, user.ExchangeGuid, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client))
{
user.ExchangeGuid = Guid.Empty;
}
user.PreviousExchangeGuid = Guid.Empty;
}
SoftDeletedTaskHelper.UpdateShadowWhenSoftDeletedProperty((IRecipientSession)base.DataSession, this.ConfigurationSession, base.CurrentOrganizationId, this.DataObject);
this.DataObject.RecipientSoftDeletedStatus = 0;
this.DataObject.WhenSoftDeleted = null;
this.DataObject.InternalOnly = false;
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
ADUser aduser = null;
if (this.DataObject.IsDefault)
{
aduser = RecipientTaskHelper.ResetOldDefaultPlan((IRecipientSession)base.DataSession, this.DataObject.Id, this.DataObject.OrganizationalUnitRoot, new Task.ErrorLoggerDelegate(base.WriteError));
}
bool flag = false;
try
{
this.DataObject[MailboxPlanSchema.MailboxPlanRelease] = (base.Fields.IsModified("MailboxPlanRelease") ? this.MailboxPlanRelease : MailboxPlanRelease.AllReleases);
base.InternalProcessRecord();
flag = true;
}
finally
{
if (!flag && aduser != null)
{
aduser.IsDefault = true;
try
{
base.DataSession.Save(aduser);
}
catch (DataSourceTransientException exception)
{
base.WriteError(exception, ExchangeErrorCategory.Client, null);
}
}
}
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
if (base.HasErrors)
{
return;
}
ExchangeOrganizationalUnit exchangeOrganizationalUnit = null;
if (base.Fields.IsModified("DefaultDistributionListOU"))
{
this.DataObject.DefaultDistributionListOU = ((this.defaultOU == null) ? null : this.defaultOU.Id);
exchangeOrganizationalUnit = this.defaultOU;
}
else if (this.DataObject.IsChanged(RecipientTemplateProvisioningPolicySchema.DefaultDistributionListOU) && this.DataObject.DefaultDistributionListOU != null)
{
exchangeOrganizationalUnit = RecipientTaskHelper.ResolveOrganizationalUnitInOrganization(new OrganizationalUnitIdParameter(this.DataObject.DefaultDistributionListOU), this.ConfigurationSession, null, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ExchangeOrganizationalUnit>), ExchangeErrorCategory.Client, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError));
}
if (exchangeOrganizationalUnit != null)
{
OrganizationId organizationId = OrganizationId.ForestWideOrgId;
if (this.ConfigurationSession is ITenantConfigurationSession)
{
organizationId = TaskHelper.ResolveOrganizationId(this.DataObject.Id, ADProvisioningPolicy.RdnContainer, (ITenantConfigurationSession)this.ConfigurationSession);
}
RecipientTaskHelper.IsOrgnizationalUnitInOrganization(this.ConfigurationSession, organizationId, exchangeOrganizationalUnit, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError));
}
TaskLogger.LogExit();
}
protected override void PrepareRecipientObject(ADDynamicGroup group)
{
TaskLogger.LogEnter();
base.PrepareRecipientObject(group);
if (base.OrganizationalUnit == null && group[ADRecipientSchema.DefaultDistributionListOU] != null)
{
ADObjectId adobjectId = (ADObjectId)group[ADRecipientSchema.DefaultDistributionListOU];
RecipientTaskHelper.ResolveOrganizationalUnitInOrganization(new OrganizationalUnitIdParameter(adobjectId), this.ConfigurationSession, base.CurrentOrganizationId, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ExchangeOrganizationalUnit>), ExchangeErrorCategory.ServerOperation, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError));
group.SetId(adobjectId.GetChildId(base.Name));
}
if (this.RecipientContainer == null)
{
if (!base.Fields.IsModified(ADDynamicGroupSchema.RecipientContainer))
{
group.RecipientContainer = group.Id.Parent;
}
}
else
{
bool useConfigNC = this.ConfigurationSession.UseConfigNC;
bool useGlobalCatalog = this.ConfigurationSession.UseGlobalCatalog;
this.ConfigurationSession.UseConfigNC = false;
if (string.IsNullOrEmpty(this.ConfigurationSession.DomainController))
{
this.ConfigurationSession.UseGlobalCatalog = true;
}
ExchangeOrganizationalUnit exchangeOrganizationalUnit = (ExchangeOrganizationalUnit)base.GetDataObject <ExchangeOrganizationalUnit>(this.RecipientContainer, this.ConfigurationSession, (base.CurrentOrganizationId != null) ? base.CurrentOrganizationId.OrganizationalUnit : null, null, new LocalizedString?(Strings.ErrorOrganizationalUnitNotFound(this.RecipientContainer.ToString())), new LocalizedString?(Strings.ErrorOrganizationalUnitNotUnique(this.RecipientContainer.ToString())), ExchangeErrorCategory.Client);
RecipientTaskHelper.IsOrgnizationalUnitInOrganization(this.ConfigurationSession, group.OrganizationId, exchangeOrganizationalUnit, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError));
this.ConfigurationSession.UseConfigNC = useConfigNC;
this.ConfigurationSession.UseGlobalCatalog = useGlobalCatalog;
group.RecipientContainer = (ADObjectId)exchangeOrganizationalUnit.Identity;
}
group.RecipientDisplayType = new RecipientDisplayType?(RecipientDisplayType.DynamicDistributionGroup);
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
base.InternalValidate();
if (this.AccountPartition != null)
{
this.accountPartitionId = RecipientTaskHelper.ResolvePartitionId(this.AccountPartition, new Task.TaskErrorLoggingDelegate(base.WriteError));
}
}
protected override IConfigurable ConvertDataObjectToPresentationObject(IConfigurable dataObject)
{
if (dataObject == null)
{
return(null);
}
return(RecipientTaskHelper.ConvertRecipientToPresentationObject((ADRecipient)dataObject));
}
protected override void InternalValidate()
{
base.InternalValidate();
if (this.DataObject.IsModified(ADUserSchema.ArchiveGuid) && this.ArchiveGuid != Guid.Empty)
{
RecipientTaskHelper.IsExchangeGuidOrArchiveGuidUnique(this.DataObject, ADUserSchema.ArchiveGuid, this.ArchiveGuid, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), ExchangeErrorCategory.Client);
}
}
protected override void ResolveLocalSecondaryIdentities()
{
base.ResolveLocalSecondaryIdentities();
if (this.DefaultDistributionListOU != null)
{
this.defaultOU = RecipientTaskHelper.ResolveOrganizationalUnitInOrganization(this.DefaultDistributionListOU, this.ConfigurationSession, null, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ExchangeOrganizationalUnit>), ExchangeErrorCategory.Client, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.ThrowTerminatingError));
}
}
protected QueryFilter ConstructQueryFilterWithCustomFilter(QueryFilter customFilter)
{
List <QueryFilter> list = new List <QueryFilter>();
RecipientType[] recipientTypes = this.RecipientTypes;
List <RecipientTypeDetails> list2 = new List <RecipientTypeDetails>();
if (this.InternalRecipientTypeDetails != null && this.InternalRecipientTypeDetails.Length > 0)
{
foreach (RecipientTypeDetails recipientTypeDetails in this.InternalRecipientTypeDetails)
{
RecipientType recipientType = RecipientTaskHelper.RecipientTypeDetailsToRecipientType(recipientTypeDetails);
if (recipientType != RecipientType.Invalid && Array.IndexOf <RecipientType>(this.RecipientTypes, recipientType) != -1)
{
list2.Add(recipientTypeDetails);
}
else if (base.IsVerboseOn)
{
base.WriteVerbose(Strings.VerboseRecipientTypeDetailsIgnored(recipientTypeDetails.ToString()));
}
}
if (list2.Count == 0)
{
base.WriteError(new ArgumentException(Strings.ErrorRecipientTypeDetailsConflictWithRecipientType), ErrorCategory.InvalidArgument, null);
}
}
QueryFilter internalFilter = base.InternalFilter;
if (internalFilter != null)
{
list.Add(internalFilter);
}
QueryFilter recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(list2.ToArray());
if (recipientTypeDetailsFilter != null)
{
list.Add(recipientTypeDetailsFilter);
}
else
{
list.Add(RecipientIdParameter.GetRecipientTypeFilter(recipientTypes));
}
if (this.Organization != null)
{
QueryFilter item = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.OrganizationalUnitRoot, base.CurrentOrganizationId.OrganizationalUnit);
list.Add(item);
}
if (customFilter != null)
{
list.Add(customFilter);
}
if (list.Count != 1)
{
return(new AndFilter(list.ToArray()));
}
return(list[0]);
}
protected override void PrepareRecipientAlias(ADGroup dataObject)
{
if (!string.IsNullOrEmpty(base.Alias))
{
dataObject.Alias = base.Alias;
return;
}
dataObject.Alias = RecipientTaskHelper.GenerateUniqueAlias(base.TenantGlobalCatalogSession, dataObject.OrganizationId, dataObject.SamAccountName, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose));
}
protected virtual void PrepareRecipientAlias(TDataObject dataObject)
{
if (string.IsNullOrEmpty(this.Alias))
{
dataObject.Alias = RecipientTaskHelper.GenerateUniqueAlias(base.TenantGlobalCatalogSession, dataObject.OrganizationId, dataObject.Name, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose));
return;
}
dataObject.Alias = this.Alias;
}
