protected virtual ADObjectId AutoSelectRequestQueueForPFRequest(OrganizationId orgId)
{
Guid guid = Guid.Empty;
TenantPublicFolderConfigurationCache.Instance.RemoveValue(orgId);
TenantPublicFolderConfiguration value = TenantPublicFolderConfigurationCache.Instance.GetValue(orgId);
PublicFolderInformation hierarchyMailboxInformation = value.GetHierarchyMailboxInformation();
guid = hierarchyMailboxInformation.HierarchyMailboxGuid;
if (guid == Guid.Empty)
{
base.WriteError(new RecipientTaskException(MrsStrings.PublicFolderMailboxesNotProvisionedForMigration), ExchangeErrorCategory.ServerOperation, null);
}
PublicFolderRecipient localMailboxRecipient = value.GetLocalMailboxRecipient(guid);
return(localMailboxRecipient.Database);
}
protected override IConfigurable ConvertDataObjectToPresentationObject(IConfigurable dataObject)
{
IConfigurable configurable = base.ConvertDataObjectToPresentationObject(dataObject);
Mailbox mailbox = configurable as Mailbox;
if (mailbox == null)
{
return(null);
}
TenantPublicFolderConfiguration value = TenantPublicFolderConfigurationCache.Instance.GetValue(mailbox.OrganizationId);
bool flag = mailbox.RecipientTypeDetails == Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.PublicFolderMailbox;
if (!flag)
{
if (mailbox.DefaultPublicFolderMailboxValue == null || mailbox.DefaultPublicFolderMailboxValue.IsDeleted)
{
PublicFolderRecipient publicFolderRecipient = value.GetPublicFolderRecipient(mailbox.ExchangeGuid, null);
if (publicFolderRecipient != null)
{
if (base.NeedSuppressingPiiData)
{
string text;
string text2;
mailbox.DefaultPublicFolderMailbox = SuppressingPiiData.Redact(publicFolderRecipient.ObjectId, out text, out text2);
}
else
{
mailbox.DefaultPublicFolderMailbox = publicFolderRecipient.ObjectId;
}
}
}
else
{
mailbox.DefaultPublicFolderMailbox = mailbox.DefaultPublicFolderMailboxValue;
}
}
mailbox.IsRootPublicFolderMailbox = (flag && value.GetHierarchyMailboxInformation().HierarchyMailboxGuid == mailbox.ExchangeGuid);
if (this.UsnForReconciliationSearch >= 0L)
{
mailbox.ReconciliationId = mailbox.NetID;
}
mailbox.ResetChangeTracking();
return(mailbox);
}
public PublicFolderDataProvider(IConfigurationSession configurationSession, string action, Guid mailboxGuid)
{
using (DisposeGuard disposeGuard = this.Guard())
{
Util.ThrowOnNullArgument(configurationSession, "configurationSession");
Util.ThrowOnNullOrEmptyArgument(action, "action");
this.currentOrganizationId = configurationSession.GetOrgContainer().OrganizationId;
TenantPublicFolderConfiguration value = TenantPublicFolderConfigurationCache.Instance.GetValue(this.currentOrganizationId);
if (mailboxGuid == Guid.Empty)
{
Organization orgContainer = configurationSession.GetOrgContainer();
if (orgContainer.DefaultPublicFolderMailbox.HierarchyMailboxGuid != value.GetHierarchyMailboxInformation().HierarchyMailboxGuid)
{
TenantPublicFolderConfigurationCache.Instance.RemoveValue(this.currentOrganizationId);
}
}
else if (value.GetLocalMailboxRecipient(mailboxGuid) == null)
{
TenantPublicFolderConfigurationCache.Instance.RemoveValue(this.currentOrganizationId);
}
this.publicFolderSessionCache = new PublicFolderSessionCache(configurationSession.SessionSettings.CurrentOrganizationId, null, null, CultureInfo.InvariantCulture, string.Format("Client=Management;Action={0}", action), null, null, true);
this.PublicFolderSession = this.publicFolderSessionCache.GetPublicFolderSession(mailboxGuid);
disposeGuard.Success();
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
try
{
ADUser aduser = this.DataObject as ADUser;
if (aduser == null || aduser.RecipientTypeDetails != RecipientTypeDetails.PublicFolderMailbox)
{
base.WriteError(new ObjectNotFoundException(Strings.PublicFolderMailboxNotFound), ExchangeErrorCategory.Client, aduser);
}
ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromADUser(base.SessionSettings, aduser);
string serverFqdn = exchangePrincipal.MailboxInfo.Location.ServerFqdn;
if (this.InvokeSynchronizer)
{
TenantPublicFolderConfiguration value = TenantPublicFolderConfigurationCache.Instance.GetValue(aduser.OrganizationId);
Organization orgContainer = this.ConfigurationSession.GetOrgContainer();
if (orgContainer.DefaultPublicFolderMailbox.HierarchyMailboxGuid != value.GetHierarchyMailboxInformation().HierarchyMailboxGuid || value.GetLocalMailboxRecipient(aduser.ExchangeGuid) == null)
{
TenantPublicFolderConfigurationCache.Instance.RemoveValue(aduser.OrganizationId);
}
if (aduser.ExchangeGuid == value.GetHierarchyMailboxInformation().HierarchyMailboxGuid)
{
base.WriteError(new TaskArgumentException(Strings.ErrorSecondaryMailboxIdRequired), ExchangeErrorCategory.Client, exchangePrincipal);
}
if (this.FullSync)
{
using (PublicFolderSession publicFolderSession = PublicFolderSession.OpenAsAdmin(this.DataObject.OrganizationId, null, aduser.ExchangeGuid, null, CultureInfo.CurrentCulture, "Client=Management;Action=UpdatePublicFolderMailbox", null))
{
using (Folder folder = Folder.Bind(publicFolderSession, publicFolderSession.GetTombstonesRootFolderId()))
{
using (UserConfiguration configuration = UserConfiguration.GetConfiguration(folder, new UserConfigurationName("PublicFolderSyncInfo", ConfigurationNameKind.Name), UserConfigurationTypes.Dictionary))
{
IDictionary dictionary = configuration.GetDictionary();
dictionary["SyncState"] = null;
configuration.Save();
}
}
}
}
PublicFolderSyncJobState publicFolderSyncJobState = PublicFolderSyncJobRpc.StartSyncHierarchy(exchangePrincipal, this.ReconcileFolders);
if (!this.SuppressStatus)
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageStartUpdatePublicFolderMailbox(this.Identity.ToString())));
int num = 0;
while (publicFolderSyncJobState.JobStatus != PublicFolderSyncJobState.Status.Completed && publicFolderSyncJobState.LastError == null && num++ < UpdatePublicFolderMailbox.timeToWaitInMilliseconds / UpdatePublicFolderMailbox.QueryIntervalInMilliseconds)
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageUpdatePublicFolderMailboxUnderProgress(publicFolderSyncJobState.JobStatus.ToString())));
Thread.Sleep(UpdatePublicFolderMailbox.QueryIntervalInMilliseconds);
publicFolderSyncJobState = PublicFolderSyncJobRpc.QueryStatusSyncHierarchy(exchangePrincipal);
}
if (publicFolderSyncJobState.LastError != null)
{
base.WriteError(publicFolderSyncJobState.LastError, ExchangeErrorCategory.ServerOperation, publicFolderSyncJobState);
}
if (publicFolderSyncJobState.JobStatus == PublicFolderSyncJobState.Status.Completed)
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageUpdatePublicFolderMailboxCompleted));
}
else
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageSynchronizerRunningInBackground));
}
}
}
else if (aduser.ExchangeGuid != Guid.Empty)
{
MailboxDatabase mailboxDatabase = base.GlobalConfigSession.Read <MailboxDatabase>(aduser.Database);
if (mailboxDatabase == null)
{
base.WriteError(new TaskArgumentException(Strings.ElcMdbNotFound(this.Identity.ToString())), ExchangeErrorCategory.Client, null);
}
this.EnsureMailboxExistsOnDatabase(aduser.ExchangeGuid);
AssistantsRpcClient assistantsRpcClient = new AssistantsRpcClient(serverFqdn);
try
{
assistantsRpcClient.Start("PublicFolderAssistant", aduser.ExchangeGuid, mailboxDatabase.Guid);
}
catch (RpcException ex)
{
base.WriteError(new TaskException(RpcUtility.MapRpcErrorCodeToMessage(ex.ErrorCode, serverFqdn)), ExchangeErrorCategory.Client, null);
}
}
}
finally
{
TaskLogger.LogExit();
}
}
