protected override void ValidateRequest(TransactionalRequestJob requestJob)
{
DateTime?timestamp = requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter);
bool flag = RequestTaskHelper.CompareUtcTimeWithLocalTime(timestamp, this.StartAfter);
bool flag2 = base.IsFieldSet("StartAfter") && !flag;
if (flag2)
{
this.CheckJobStatusInQueuedForStartAfterSet(requestJob);
}
DateTime utcNow = DateTime.UtcNow;
if (flag2 && this.StartAfter != null)
{
RequestTaskHelper.ValidateStartAfterTime(this.StartAfter.Value.ToUniversalTime(), new Task.TaskErrorLoggingDelegate(base.WriteError), utcNow);
}
if (base.IsFieldSet("IncrementalSyncInterval"))
{
if (requestJob.IncrementalSyncInterval == TimeSpan.Zero || requestJob.JobType < MRSJobType.RequestJobE15_AutoResume)
{
base.WriteError(new IncrementalSyncIntervalCannotBeSetOnNonIncrementalRequestsException(), ErrorCategory.InvalidArgument, this.Identity);
}
RequestTaskHelper.ValidateIncrementalSyncInterval(this.IncrementalSyncInterval, new Task.TaskErrorLoggingDelegate(base.WriteError));
}
if (base.IsFieldSet("StartAfter") && flag)
{
this.WriteWarning(Strings.WarningScheduledTimeIsUnchanged("StartAfter"));
}
base.ValidateRequest(requestJob);
}
protected override void ValidateMoveRequest(TransactionalRequestJob moveRequest)
{
if (moveRequest.IsFake)
{
return;
}
if (!base.ParameterSetName.Equals("MigrationMoveRequestQueue"))
{
base.ValidateMoveRequestProtectionStatus(moveRequest);
if (moveRequest.ValidationResult == RequestJobBase.ValidationResultEnum.Valid)
{
base.ValidateMoveRequestIsActive(moveRequest);
if (moveRequest.RequestJobState == JobProcessingState.InProgress && RequestJobStateNode.RequestStateIs(moveRequest.StatusDetail, RequestState.Cleanup) && moveRequest.IdleTime < TimeSpan.FromMinutes(60.0))
{
base.WriteError(new CannotModifyCompletingRequestPermanentException(base.LocalADUser.ToString()), ErrorCategory.InvalidArgument, base.Identity);
}
if (moveRequest.CancelRequest)
{
base.WriteVerbose(Strings.MoveAlreadyCanceled);
}
if (moveRequest.Status == RequestStatus.Completed || moveRequest.Status == RequestStatus.CompletedWithWarning)
{
this.mrCondition = RemoveMoveRequest.MoveRequestCondition.MoveCompleted;
return;
}
}
else
{
this.mrCondition = RemoveMoveRequest.MoveRequestCondition.FailedValidation;
}
}
}
protected override void InternalValidate()
{
TaskLogger.LogEnter(new object[]
{
this.DataObject
});
try
{
base.InternalValidate();
TransactionalRequestJob dataObject = this.DataObject;
if (base.IsFieldSet("TargetDatabase"))
{
ServerVersion serverVersion = new ServerVersion(MapiUtils.FindServerForMdb(dataObject.TargetDatabase.ObjectGuid, null, null, FindServerFlags.None).ServerVersion);
if (this.newTargetServerVersion.Major != serverVersion.Major || this.newTargetServerVersion.Minor != serverVersion.Minor)
{
base.WriteError(new RecipientTaskException(Strings.ErrorCannotRetargetToDifferentVersionServerThanOriginal(this.newTargetServerVersion.ToString(), serverVersion.ToString())), ErrorCategory.InvalidArgument, base.Identity);
}
}
if (base.IsFieldSet("ArchiveTargetDatabase"))
{
ServerVersion serverVersion2 = new ServerVersion(MapiUtils.FindServerForMdb(dataObject.TargetArchiveDatabase.ObjectGuid, null, null, FindServerFlags.None).ServerVersion);
if (this.newArchiveTargetServerVersion.Major != serverVersion2.Major || this.newArchiveTargetServerVersion.Minor != serverVersion2.Minor)
{
base.WriteError(new RecipientTaskException(Strings.ErrorCannotRetargetToDifferentVersionArchiveServerThanOriginal(this.newArchiveTargetServerVersion.ToString(), serverVersion2.ToString())), ErrorCategory.InvalidArgument, base.Identity);
}
}
}
finally
{
TaskLogger.LogExit();
}
}
private void CheckMoveStatusInQueuedForStartAfterSet(TransactionalRequestJob moveRequest)
{
if (!RequestJobStateNode.RequestStateIs(moveRequest.StatusDetail, RequestState.Queued))
{
base.WriteError(new ErrorStartAfterCanBeSetOnlyInQueuedException(), ErrorCategory.InvalidArgument, base.Identity);
}
}
protected override void ModifyMoveRequest(TransactionalRequestJob moveRequest)
{
this.mdbGuid = moveRequest.WorkItemQueueMdb.ObjectGuid;
if (base.LocalADUser != null)
{
moveRequest.DomainControllerToUpdate = base.LocalADUser.OriginatingServer;
}
moveRequest.PoisonCount = 0;
if (moveRequest.Suspend)
{
moveRequest.Suspend = false;
moveRequest.Message = LocalizedString.Empty;
DateTime?timestamp = moveRequest.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter);
moveRequest.TimeTracker.SetTimestamp(RequestJobTimestamp.DoNotPickUntil, timestamp);
moveRequest.TotalRetryCount = 0;
LocalizedString msg;
if (this.SuspendWhenReadyToComplete)
{
moveRequest.SuspendWhenReadyToComplete = true;
msg = MrsStrings.ReportRequestResumedWithSuspendWhenReadyToComplete(base.ExecutingUserIdentity);
}
else
{
msg = MrsStrings.ReportMoveRequestResumed(base.ExecutingUserIdentity);
}
ReportData reportData = new ReportData(moveRequest.ExchangeGuid, moveRequest.ReportVersion);
ConnectivityRec connectivityRec = new ConnectivityRec(ServerKind.Cmdlet, VersionInformation.MRS);
reportData.Append(msg, connectivityRec);
reportData.Flush(base.MRProvider.SystemMailbox);
}
}
protected override void ValidateRequest(TransactionalRequestJob requestJob)
{
base.ValidateRequest(requestJob);
base.ValidateRequestIsActive(requestJob);
base.ValidateRequestProtectionStatus(requestJob);
base.ValidateRequestIsRunnable(requestJob);
base.ValidateRequestIsNotCancelled(requestJob);
if (!requestJob.Suspend)
{
base.WriteVerbose(Strings.RequestNotSuspended(requestJob.Name));
}
if (RequestJobStateNode.RequestStateIs(requestJob.StatusDetail, RequestState.Completion) && !RequestJobStateNode.RequestStateIs(requestJob.StatusDetail, RequestState.IncrementalSync))
{
base.WriteError(new SuspendWhenReadyToCompleteCannotBeUsedDuringCompletionException(requestJob.Name), ErrorCategory.InvalidArgument, requestJob.Identity);
}
using (MailboxReplicationServiceClient mailboxReplicationServiceClient = requestJob.CreateMRSClient(base.ConfigSession, requestJob.WorkItemQueueMdb.ObjectGuid, base.UnreachableMrsServers))
{
LocalizedString message = requestJob.Message;
requestJob.Message = LocalizedString.Empty;
try
{
List <ReportEntry> entries = null;
using (mailboxReplicationServiceClient.ValidateAndPopulateRequestJob(requestJob, out entries))
{
RequestTaskHelper.WriteReportEntries(requestJob.Name, entries, requestJob.Identity, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError));
}
}
finally
{
requestJob.Message = message;
}
}
}
protected override void ModifyRequest(TransactionalRequestJob requestJob)
{
this.mdbGuid = requestJob.WorkItemQueueMdb.ObjectGuid;
if (requestJob.TargetUser != null)
{
requestJob.DomainControllerToUpdate = requestJob.TargetUser.OriginatingServer;
}
else if (requestJob.SourceUser != null)
{
requestJob.DomainControllerToUpdate = requestJob.SourceUser.OriginatingServer;
}
requestJob.PoisonCount = 0;
if (requestJob.Suspend)
{
requestJob.Suspend = false;
requestJob.Message = LocalizedString.Empty;
requestJob.TotalRetryCount = 0;
LocalizedString msg;
if (this.SuspendWhenReadyToComplete)
{
requestJob.SuspendWhenReadyToComplete = true;
msg = MrsStrings.ReportRequestResumedWithSuspendWhenReadyToComplete(base.ExecutingUserIdentity);
}
else
{
msg = MrsStrings.ReportRequestResumed(base.ExecutingUserIdentity);
}
ReportData reportData = new ReportData(requestJob.RequestGuid, requestJob.ReportVersion);
ConnectivityRec connectivityRec = new ConnectivityRec(ServerKind.Cmdlet, VersionInformation.MRS);
reportData.Append(msg, connectivityRec);
reportData.Flush(base.RJProvider.SystemMailbox);
}
}
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker)
{
if (base.IsFieldSet("RemoteSourceMailboxServerLegacyDN"))
{
changedValuesTracker.AppendLine(string.Format("RemoteMailboxServerLegacyDN: {0} -> {1}", requestJob.RemoteMailboxServerLegacyDN, this.RemoteSourceMailboxServerLegacyDN));
requestJob.RemoteMailboxServerLegacyDN = this.RemoteSourceMailboxServerLegacyDN;
}
if (base.IsFieldSet("OutlookAnywhereHostName"))
{
changedValuesTracker.AppendLine(string.Format("OutlookAnywhereHostName: {0} -> {1}", requestJob.OutlookAnywhereHostName, this.OutlookAnywhereHostName));
requestJob.OutlookAnywhereHostName = this.OutlookAnywhereHostName;
}
if (base.IsFieldSet("RemoteCredential"))
{
changedValuesTracker.AppendLine("RemoteCredential: <secure> -> <secure>");
requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, requestJob.AuthenticationMethod);
}
if (base.IsFieldSet("IsAdministrativeCredential"))
{
changedValuesTracker.AppendLine(string.Format("IsAdministrativeCredential: {0} -> {1}", requestJob.IsAdministrativeCredential, this.IsAdministrativeCredential));
requestJob.IsAdministrativeCredential = new bool?(this.IsAdministrativeCredential);
}
if (base.IsFieldSet("StartAfter") && !RequestTaskHelper.CompareUtcTimeWithLocalTime(requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter), this.StartAfter))
{
RequestTaskHelper.SetStartAfter(this.StartAfter, requestJob, changedValuesTracker);
}
if (base.IsFieldSet("IncrementalSyncInterval"))
{
changedValuesTracker.AppendLine(string.Format("IncrementalSyncInterval: {0} -> {1}", requestJob.IncrementalSyncInterval, this.IncrementalSyncInterval));
requestJob.IncrementalSyncInterval = this.IncrementalSyncInterval;
}
}
protected void ValidateRequestType(TransactionalRequestJob requestJob)
{
if (requestJob.RequestType != SetRequestBase <TIdentity> .RequestType)
{
base.WriteError(new ManagementObjectNotFoundException(Strings.ErrorNotEnoughInformationToFindRequestOfCorrectType), ErrorCategory.InvalidArgument, this.Identity);
}
}
protected override void ModifyRequest(TransactionalRequestJob requestJob)
{
base.ModifyRequest(requestJob);
if (base.IsFieldSet("SourceDatabase"))
{
PublicFolderDatabase publicFolderDatabase = (PublicFolderDatabase)base.GetDataObject <PublicFolderDatabase>(this.SourceDatabase, base.ConfigSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(this.SourceDatabase.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(this.SourceDatabase.ToString())));
DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(publicFolderDatabase.Id.ObjectGuid, null, null, FindServerFlags.None);
if (!this.IsSupportedDatabaseVersion(databaseInformation.ServerVersion))
{
base.WriteError(new DatabaseVersionUnsupportedPermanentException(publicFolderDatabase.Identity.ToString(), databaseInformation.ServerFqdn, new ServerVersion(databaseInformation.ServerVersion).ToString()), ErrorCategory.InvalidArgument, null);
}
requestJob.SourceDatabase = publicFolderDatabase.Id;
}
if (base.IsFieldSet("RemoteMailboxLegacyDN"))
{
requestJob.RemoteMailboxLegacyDN = this.RemoteMailboxLegacyDN;
}
if (base.IsFieldSet("RemoteMailboxServerLegacyDN"))
{
requestJob.RemoteMailboxServerLegacyDN = this.RemoteMailboxServerLegacyDN;
}
if (base.IsFieldSet("OutlookAnywhereHostName"))
{
requestJob.OutlookAnywhereHostName = this.OutlookAnywhereHostName;
}
if (base.IsFieldSet("AuthenticationMethod"))
{
requestJob.AuthenticationMethod = new AuthenticationMethod?(this.AuthenticationMethod);
}
if (base.IsFieldSet("RemoteCredential"))
{
requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, requestJob.AuthenticationMethod);
}
}
protected override void SetRequestProperties(TransactionalRequestJob dataObject)
{
base.SetRequestProperties(dataObject);
dataObject.JobType = MRSJobType.RequestJobE15_CreatePublicFoldersUnderParentInSecondary;
dataObject.RequestType = MRSRequestType.PublicFolderMailboxMigration;
dataObject.WorkloadType = base.WorkloadType;
if (base.ParameterSetName.Equals("MailboxMigrationOutlookAnywherePublicFolder"))
{
dataObject.AuthenticationMethod = new AuthenticationMethod?(this.AuthenticationMethod);
dataObject.OutlookAnywhereHostName = this.OutlookAnywhereHostName;
dataObject.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, new AuthenticationMethod?(this.AuthenticationMethod));
dataObject.RemoteMailboxLegacyDN = this.RemoteMailboxLegacyDN;
dataObject.RemoteMailboxServerLegacyDN = this.RemoteMailboxServerLegacyDN;
}
else
{
dataObject.SourceDatabase = this.sourceDatabase;
dataObject.SourceExchangeGuid = this.sourceDatabase.ObjectGuid;
}
dataObject.PreserveMailboxSignature = false;
dataObject.PreventCompletion = true;
dataObject.SuspendWhenReadyToComplete = true;
dataObject.AllowedToFinishMove = false;
dataObject.SourceDatabase = this.sourceDatabase;
dataObject.TargetDatabase = base.MdbId;
dataObject.TargetUserId = this.TargetMailboxUser.Id;
dataObject.ExchangeGuid = this.TargetMailboxUser.ExchangeGuid;
dataObject.TargetExchangeGuid = this.TargetMailboxUser.ExchangeGuid;
dataObject.FolderToMailboxMap = this.folderToMailboxMapping;
dataObject.AllowLargeItems = false;
dataObject.SkipFolderPromotedProperties = true;
dataObject.SkipFolderViews = true;
dataObject.SkipFolderRestrictions = true;
dataObject.SkipContentVerification = true;
}
protected override void ValidateRequest(TransactionalRequestJob requestJob)
{
base.ValidateRequest(requestJob);
if (base.IsFieldSet("LargeItemLimit") && requestJob.AllowLargeItems)
{
base.WriteError(new RecipientTaskException(Strings.ErrorIncompatibleParameters("AllowLargeItems", "LargeItemLimit")), ErrorCategory.InvalidArgument, this.Identity);
}
}
protected override void ValidateRequest(TransactionalRequestJob requestJob)
{
if (base.IsFieldSet("IncrementalSyncInterval"))
{
RequestTaskHelper.ValidateIncrementalSyncInterval(this.IncrementalSyncInterval, new Task.TaskErrorLoggingDelegate(base.WriteError));
}
base.ValidateRequest(requestJob);
}
protected override MailboxRelocationRequest ConvertToPresentationObject(TransactionalRequestJob dataObject)
{
if (dataObject.IndexEntries == null || dataObject.IndexEntries.Count < 1)
{
base.WriteError(new RequestIndexEntriesAbsentPermanentException(base.RequestName), ErrorCategory.InvalidArgument, this.Mailbox);
}
return(new MailboxRelocationRequest(dataObject.IndexEntries[0]));
}
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker)
{
if (base.IsFieldSet("SuspendWhenReadyToComplete"))
{
changedValuesTracker.AppendLine(string.Format("SWRTC: {0} -> {1}", requestJob.SuspendWhenReadyToComplete, this.SuspendWhenReadyToComplete));
requestJob.SuspendWhenReadyToComplete = this.SuspendWhenReadyToComplete;
}
}
protected override SyncRequest ConvertToPresentationObject(TransactionalRequestJob dataObject)
{
if (dataObject.IndexEntries != null && dataObject.IndexEntries.Count >= 1)
{
return(new SyncRequest(dataObject.IndexEntries[0]));
}
return(null);
}
internal static void ApplyOrganization(TransactionalRequestJob dataObject, OrganizationId organizationId)
{
dataObject.OrganizationId = organizationId;
if (organizationId != OrganizationId.ForestWideOrgId)
{
dataObject.PartitionHint = TenantPartitionHint.FromOrganizationId(organizationId);
dataObject.ExternalDirectoryOrganizationId = dataObject.PartitionHint.GetExternalDirectoryOrganizationId();
}
}
protected override void ModifyRequest(TransactionalRequestJob requestJob)
{
if (requestJob.Suspend)
{
DateTime?timestamp = requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter);
requestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.DoNotPickUntil, timestamp);
}
base.ModifyRequest(requestJob);
}
protected override MergeRequest ConvertToPresentationObject(TransactionalRequestJob dataObject)
{
if (dataObject.IndexEntries != null && dataObject.IndexEntries.Count >= 1)
{
return(new MergeRequest(dataObject.IndexEntries[0]));
}
base.WriteError(new RequestIndexEntriesAbsentPermanentException(base.RequestName), ErrorCategory.InvalidArgument, this.TargetMailbox);
return(null);
}
protected override FolderMoveRequest ConvertToPresentationObject(TransactionalRequestJob dataObject)
{
if (dataObject.IndexEntries != null && dataObject.IndexEntries.Count >= 1)
{
return(new FolderMoveRequest(dataObject.IndexEntries[0]));
}
base.WriteError(new RequestIndexEntriesAbsentPermanentException(dataObject.ToString()), ErrorCategory.InvalidArgument, null);
return(null);
}
protected override void ModifyRequest(TransactionalRequestJob requestJob)
{
base.ModifyRequest(requestJob);
if (base.IsFieldSet("SuspendWhenReadyToComplete"))
{
requestJob.SuspendWhenReadyToComplete = this.SuspendWhenReadyToComplete;
requestJob.PreventCompletion = this.SuspendWhenReadyToComplete;
requestJob.AllowedToFinishMove = !this.SuspendWhenReadyToComplete;
}
}
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker)
{
base.ModifyRequestInternal(requestJob, changedValuesTracker);
if (base.IsFieldSet("SkipMoving"))
{
RequestJobInternalFlags requestJobInternalFlags = requestJob.RequestJobInternalFlags;
RequestTaskHelper.SetSkipMoving(this.SkipMoving, requestJob, new Task.TaskErrorLoggingDelegate(base.WriteError), true);
changedValuesTracker.AppendLine(string.Format("InternalFlags: {0} -> {1}", requestJobInternalFlags, requestJob.RequestJobInternalFlags));
}
}
protected override void SetRequestProperties(TransactionalRequestJob dataObject)
{
base.SetRequestProperties(dataObject);
dataObject.RequestType = MRSRequestType.MailboxImport;
if (dataObject.WorkloadType == RequestWorkloadType.None)
{
if (string.IsNullOrEmpty(this.RemoteHostName))
{
dataObject.WorkloadType = RequestWorkloadType.Local;
}
else
{
dataObject.WorkloadType = RequestWorkloadType.RemotePstIngestion;
}
}
dataObject.ContentCodePage = this.ContentCodePage;
dataObject.FilePath = this.FilePath.PathName;
if (this.user != null)
{
dataObject.TargetUserId = this.user.Id;
dataObject.TargetUser = this.user;
}
if (base.ParameterSetName.Equals("MailboxImportRequest"))
{
if (!string.IsNullOrEmpty(this.SourceRootFolder))
{
dataObject.SourceRootFolder = this.SourceRootFolder;
}
if (!string.IsNullOrEmpty(this.TargetRootFolder))
{
dataObject.TargetRootFolder = this.TargetRootFolder;
}
if (this.IsArchive)
{
dataObject.TargetIsArchive = true;
dataObject.TargetExchangeGuid = this.user.ArchiveGuid;
dataObject.TargetDatabase = ADObjectIdResolutionHelper.ResolveDN(this.user.ArchiveDatabase);
}
else
{
dataObject.TargetIsArchive = false;
dataObject.TargetExchangeGuid = this.user.ExchangeGuid;
dataObject.TargetDatabase = ADObjectIdResolutionHelper.ResolveDN(this.user.Database);
}
dataObject.TargetAlias = this.user.Alias;
if (this.RemoteCredential != null)
{
dataObject.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, null);
}
if (!string.IsNullOrEmpty(this.RemoteHostName))
{
dataObject.RemoteHostName = this.RemoteHostName;
}
}
}
protected override void ValidateRequest(TransactionalRequestJob requestJob)
{
bool flag = !OrganizationId.ForestWideOrgId.Equals(base.ExecutingUserOrganizationId);
bool flag2 = !string.IsNullOrEmpty(base.IsFieldSet("RemoteHostName") ? this.RemoteHostName : requestJob.RemoteHostName);
if (flag && !flag2)
{
base.WriteError(new RemoteMailboxImportNeedRemoteProxyException(), ErrorCategory.InvalidArgument, this);
}
base.ValidateRequest(requestJob);
}
private void SetSkipMergingAndInternalFlags(TransactionalRequestJob dataObject)
{
RequestTaskHelper.SetSkipMerging(this.SkipMerging, dataObject, new Task.TaskErrorLoggingDelegate(base.WriteError));
RequestTaskHelper.SetInternalFlags(this.InternalFlags, dataObject, new Task.TaskErrorLoggingDelegate(base.WriteError));
if (this.SkipMerging == null)
{
using (SettingsContextBase.ActivateContext(dataObject))
{
dataObject.SkipKnownCorruptions = ConfigBase <MRSConfigSchema> .GetConfig <bool>("SkipKnownCorruptionsDefault");
}
}
}
protected override void ValidateRequest(TransactionalRequestJob requestJob)
{
if (!requestJob.SuspendWhenReadyToComplete && this.SuspendWhenReadyToComplete)
{
base.WriteError(new SuspendWhenReadyToCompleteNotSupportedException(requestJob.Name), ErrorCategory.InvalidArgument, this.Identity);
}
if (requestJob.SuspendWhenReadyToComplete && requestJob.StatusDetail == RequestState.AutoSuspended && !this.SuspendWhenReadyToComplete)
{
base.WriteError(new IncrementalMergesRequireSuspendWhenReadyToCompleteException(requestJob.Name), ErrorCategory.InvalidArgument, this.Identity);
}
base.ValidateRequest(requestJob);
}
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker)
{
if (base.IsFieldSet("RemoteServerName"))
{
changedValuesTracker.AppendLine(string.Format("RemoteServerName: {0} -> {1}", requestJob.RemoteHostName, this.RemoteServerName));
requestJob.RemoteHostName = this.RemoteServerName;
}
if (base.IsFieldSet("RemoteServerPort"))
{
changedValuesTracker.AppendLine(string.Format("RemoteServerPort: {0} -> {1}", requestJob.RemoteHostPort, this.RemoteServerPort));
requestJob.RemoteHostPort = this.RemoteServerPort;
}
if (base.IsFieldSet("SmtpServerName"))
{
changedValuesTracker.AppendLine(string.Format("SmtpServerName: {0} -> {1}", requestJob.SmtpServerName, this.SmtpServerName));
requestJob.SmtpServerName = this.SmtpServerName;
}
if (base.IsFieldSet("SmtpServerPort"))
{
changedValuesTracker.AppendLine(string.Format("SmtpServerPort: {0} -> {1}", requestJob.SmtpServerPort, this.SmtpServerPort));
requestJob.SmtpServerPort = this.SmtpServerPort;
}
if (base.IsFieldSet("Authentication"))
{
changedValuesTracker.AppendLine(string.Format("Authentication: {0} -> {1}", requestJob.AuthenticationMethod, this.Authentication));
requestJob.AuthenticationMethod = new AuthenticationMethod?(this.Authentication);
}
if (base.IsFieldSet("Security"))
{
changedValuesTracker.AppendLine(string.Format("Security: {0} -> {1}", requestJob.SecurityMechanism, this.Security));
requestJob.SecurityMechanism = this.Security;
}
if (base.IsFieldSet("Password"))
{
changedValuesTracker.AppendLine("Password: <secure> -> <secure>");
PSCredential psCred = new PSCredential(requestJob.RemoteCredential.UserName, this.Password);
requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(psCred, requestJob.AuthenticationMethod);
}
if (base.IsFieldSet("IncrementalSyncInterval"))
{
changedValuesTracker.AppendLine(string.Format("IncrementalSyncInterval: {0} -> {1}", requestJob.IncrementalSyncInterval, this.IncrementalSyncInterval));
requestJob.IncrementalSyncInterval = this.IncrementalSyncInterval;
}
if (base.IsFieldSet("StartAfter") && !RequestTaskHelper.CompareUtcTimeWithLocalTime(requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter), this.StartAfter))
{
RequestTaskHelper.SetStartAfter(this.StartAfter, requestJob, changedValuesTracker);
}
if (base.IsFieldSet("CompleteAfter") && !RequestTaskHelper.CompareUtcTimeWithLocalTime(requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.CompleteAfter), this.CompleteAfter))
{
RequestTaskHelper.SetCompleteAfter(this.CompleteAfter, requestJob, changedValuesTracker);
}
}
protected override void ValidateRequest(TransactionalRequestJob requestJob)
{
base.ValidateRequest(requestJob);
if (base.ParameterSetName.Equals("MailboxMigrationLocalPublicFolder") && requestJob.Flags.HasFlag(RequestFlags.CrossOrg))
{
base.WriteError(new RecipientTaskException(Strings.ErrorInvalidParametersForOutlookAnywherePublicFolderMailboxMigration), ExchangeErrorCategory.Client, null);
return;
}
if (base.ParameterSetName.Equals("MailboxMigrationOutlookAnywherePublicFolder") && requestJob.Flags.HasFlag(RequestFlags.IntraOrg))
{
base.WriteError(new RecipientTaskException(Strings.ErrorInvalidParametersForLocalPublicFolderMailboxMigration), ExchangeErrorCategory.Client, null);
}
}
protected override void CreateIndexEntries(TransactionalRequestJob dataObject)
{
RequestIndexEntryProvider.CreateAndPopulateRequestIndexEntries(dataObject, new RequestIndexId(this.mailbox.Id));
if (base.ParameterSetName == "MailboxRelocationSplit")
{
RequestIndexEntryProvider.CreateAndPopulateRequestIndexEntries(dataObject, new RequestIndexId(this.sourceContainer.Id));
return;
}
if (base.ParameterSetName == "MailboxRelocationJoin")
{
RequestIndexEntryProvider.CreateAndPopulateRequestIndexEntries(dataObject, new RequestIndexId(this.targetContainer.Id));
}
}
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker)
{
if (base.IsFieldSet("RemoteCredential"))
{
changedValuesTracker.AppendLine("RemoteCredential: <secure> -> <secure>");
requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, null);
}
if (base.IsFieldSet("RemoteHostName"))
{
changedValuesTracker.AppendLine(string.Format("RemoteHostName: {0} -> {1}", requestJob.RemoteHostName, this.RemoteHostName));
requestJob.RemoteHostName = this.RemoteHostName;
}
base.ModifyRequestInternal(requestJob, changedValuesTracker);
}
