private void InitializeFolderAndNotifyApps() { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(this.mailboxPrincipal, CultureInfo.InvariantCulture, "Client=Management;Action=NewConnectSubscription")) { this.providerImpl.InitializeFolderAndNotifyApps(mailboxSession, this.DataObject); } }
private void GetProtocolLogs(ADUser user) { ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromADUser(user, RemotingOptions.AllowCrossSite); if (exchangePrincipal == null) { base.WriteVerbose(Strings.ExchangePrincipalNotFoundException(user.ToString())); return; } try { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(exchangePrincipal, CultureInfo.InvariantCulture, "Client=Management;Action=Get-CasMailbox")) { if (this.GetPopProtocolLog) { this.GetProtocolLogs(mailboxSession, "POP3"); } if (this.GetImapProtocolLog) { this.GetProtocolLogs(mailboxSession, "IMAP4"); } } } catch (LocalizedException ex) { this.WriteWarning(Strings.FailedToGetLogs(user.ToString(), ex.LocalizedString)); } }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); try { ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(this.DataObject, null); using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=Management;Action=Set-MailboxAssociationReplicationState")) { if (this.Instance.NextReplicationTime != null) { LocalAssociationStore.SaveMailboxSyncStatus(mailboxSession, this.Instance.NextReplicationTime, null); } } } catch (StorageTransientException exception) { base.WriteError(exception, ErrorCategory.ReadError, this.Identity); } catch (StoragePermanentException exception2) { base.WriteError(exception2, ErrorCategory.ReadError, this.Identity); } finally { TaskLogger.LogExit(); } }
public void Save(TenantInfo tenantInfo) { try { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(this.SyncMailboxPrincipal, CultureInfo.InvariantCulture, "Client=UnifiedPolicy;Action=CommitChanges;Interactive=False")) { using (UserConfiguration mailboxConfiguration = UserConfigurationHelper.GetMailboxConfiguration(mailboxSession, "TenantInfoConfigurations", UserConfigurationTypes.Stream, true)) { using (Stream stream = mailboxConfiguration.GetStream()) { BinaryFormatter binaryFormatter = ExchangeBinaryFormatterFactory.CreateBinaryFormatter(null); binaryFormatter.Serialize(stream, tenantInfo); } mailboxConfiguration.Save(); } } } catch (StoragePermanentException innerException) { throw new SyncAgentPermanentException("TenantInfoProvider.Save failed with StoragePermanentException", innerException); } catch (StorageTransientException innerException2) { throw new SyncAgentTransientException("TenantInfoProvider.Save failed with StorageTransientException", innerException2); } catch (IOException innerException3) { throw new SyncAgentTransientException("TenantInfoProvider.Save failed with IOException", innerException3); } }
private void OpenMailboxSession() { if (this.mailboxSession == null) { this.mailboxSession = MailboxSession.OpenAsAdmin(this.principal, CultureInfo.InvariantCulture, "Client=Management;Action=Remove-ActiveSyncDevice"); } }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); CmdletProxy.ThrowExceptionIfProxyIsNeeded(base.CurrentTaskContext, base.DataObject, false, this.ConfirmationMessage, null); try { ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromADUser(base.DataObject, null); using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(exchangePrincipal, CultureInfo.InvariantCulture, "Client=Management;Action=Remove-UserPhoto")) { new PhotoRemovalPipeline(RemoveUserPhoto.PhotosConfiguration, mailboxSession, (IRecipientSession)base.DataSession, this.tracer).Upload(this.CreateRemovePhotoRequest(exchangePrincipal), Stream.Null); } } catch (WrongServerException ex) { this.LogFailedToRemovePhotoEvent(ex); this.WriteError(new CannotModifyPhotoBecauseMailboxIsInTransitException(ex), ExchangeErrorCategory.ServerTransient, base.DataObject, true); } catch (Exception e) { this.LogFailedToRemovePhotoEvent(e); throw; } finally { this.tracer.Dump(new PhotoRequestLogWriter(RemoveUserPhoto.RequestLog, RemoveUserPhoto.GenerateRequestId())); } TaskLogger.LogExit(); }
internal static MailboxSession OpenMailboxSession(ADUser adUser, string clientString, Task.TaskErrorLoggingDelegate writeError) { LocalizedString?localizedString = null; try { ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromADUser(adUser.OrganizationId.ToADSessionSettings(), adUser); if (exchangePrincipal == null) { return(null); } return(MailboxSession.OpenAsAdmin(exchangePrincipal, CultureInfo.InvariantCulture, clientString)); } catch (StorageTransientException ex) { localizedString = new LocalizedString?(Strings.ExceptionStorageOther(ex.ErrorCode, ex.Message)); } catch (StoragePermanentException ex2) { if (ex2 is AccessDeniedException) { localizedString = new LocalizedString?(Strings.ExceptionStorageAccessDenied(ex2.ErrorCode, ex2.Message)); } else { localizedString = new LocalizedString?(Strings.ExceptionStorageOther(ex2.ErrorCode, ex2.Message)); } } if (localizedString != null) { writeError(new TaskException(localizedString.Value), ErrorCategory.ReadError, null); } return(null); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); try { ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromADUser(this.DataObject, null); using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(exchangePrincipal, CultureInfo.InvariantCulture, "Client=Management;Action=Set-UserPhoto")) { PhotoRequest request = this.CreateRequest(exchangePrincipal); PhotoUploadPipeline photoUploadPipeline = new PhotoUploadPipeline(SetUserPhoto.PhotosConfiguration, mailboxSession, (IRecipientSession)base.DataSession, this.tracer); photoUploadPipeline.Upload(request, Stream.Null); if (!this.Save && !this.Cancel && !this.Preview) { photoUploadPipeline.Upload(this.CreateSavePreviewRequest(exchangePrincipal), Stream.Null); } } } catch (WrongServerException ex) { this.LogFailedToUploadPhotoEvent(ex); this.WriteError(new CannotModifyPhotoBecauseMailboxIsInTransitException(ex), ExchangeErrorCategory.ServerTransient, this.DataObject, true); } catch (Exception e) { this.LogFailedToUploadPhotoEvent(e); throw; } finally { this.tracer.Dump(new PhotoRequestLogWriter(SetUserPhoto.RequestLog, SetUserPhoto.GenerateRequestId())); } TaskLogger.LogExit(); }
public static MailboxSession CreateMailboxSessionForConfiguration(ExchangePrincipal groupPrincipal, string domainController) { MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(groupPrincipal, CultureInfo.InvariantCulture, "Client=WebServices;Action=ConfigureGroupMailbox"); mailboxSession.SetADRecipientSessionFactory((bool isReadonly, ConsistencyMode consistencyMode) => DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(domainController, isReadonly, consistencyMode, null, groupPrincipal.MailboxInfo.OrganizationId.ToADSessionSettings(), 127, "CreateMailboxSessionForConfiguration", "f:\\15.00.1497\\sources\\dev\\UnifiedGroups\\src\\UnifiedGroups\\GroupMailboxAccessLayer\\Commands\\ConfigureGroupMailbox.cs")); return(mailboxSession); }
public void SetProperties(DefaultFolderContext context, Folder folder) { MatchAdminFolderFlags.< > c__DisplayClass2 CS$ < > 8__locals1 = new MatchAdminFolderFlags.< > c__DisplayClass2(); CS$ < > 8__locals1.folder = folder; CS$ < > 8__locals1.< > 4__this = this; ExTraceGlobals.DefaultFoldersTracer.TraceDebug <ELCFolderFlags, Folder>((long)this.GetHashCode(), "MatchAdminFolderFlags::SetPropertiesInternal. Setting AdminFolderFlags to {0} for folder {1} on the admin session.", this.adminFolderFlags, CS$ < > 8__locals1.folder); if (context.Session.LogonType == LogonType.Admin || (context.Session != null && context.Session.IsMoveUser)) { CS$ < > 8__locals1.folder[InternalSchema.AdminFolderFlags] = this.adminFolderFlags; return; } using (MailboxSession adminSession = MailboxSession.OpenAsAdmin(context.Session.MailboxOwner, CultureInfo.InvariantCulture, context.Session.ClientInfoString + ";COW=DumpsterFolderFlag")) { adminSession.BypassAuditing(delegate { adminSession.BypassAuditsFolderAccessChecking(delegate { using (Folder folder2 = Folder.Bind(adminSession, CS$ < > 8__locals1.folder.Id, new PropertyDefinition[] { FolderSchema.AdminFolderFlags })) { folder2[InternalSchema.AdminFolderFlags] = CS$ < > 8__locals1.< > 4__this.adminFolderFlags; folder2.Save(); } });
private bool IsGroupMemberInMailboxAssociation() { IExtensibleLogger logger = MailboxAssociationDiagnosticsFrameFactory.Default.CreateLogger(this.groupMailboxToLogon.MailboxInfo.MailboxGuid, this.organizationId); IMailboxAssociationPerformanceTracker performanceTracker = MailboxAssociationDiagnosticsFrameFactory.Default.CreatePerformanceTracker(null); bool result; using (MailboxAssociationDiagnosticsFrameFactory.Default.CreateDiagnosticsFrame("XSO", "CheckMembership", logger, performanceTracker)) { try { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(this.groupMailboxToLogon, CultureInfo.InvariantCulture, this.clientInfoString)) { using (IAssociationStore associationStore = this.GetAssociationStore(mailboxSession, performanceTracker)) { using (IMailboxAssociationUser memberAssociationInformation = this.GetMemberAssociationInformation(associationStore)) { result = (memberAssociationInformation != null && (bool)memberAssociationInformation[MailboxAssociationBaseSchema.IsMember]); } } } } catch (AssociationNotFoundException) { GroupMailboxAuthorizationHandler.Tracer.TraceDebug <string, string>((long)this.GetHashCode(), "MemberRetrieval: Unable to make IsMember() check for the user {0} on the mailbox {1}", this.accessingUserInfo.Identity, this.groupMailboxToLogon.MailboxInfo.DisplayName); result = false; } catch (LocalizedException) { GroupMailboxAuthorizationHandler.Tracer.TraceDebug <string, string>((long)this.GetHashCode(), "MemberRetrieval: Unable to make IsMember() check for the user {0} on the mailbox {1}", this.accessingUserInfo.Identity, this.groupMailboxToLogon.MailboxInfo.DisplayName); result = false; } } return(result); }
internal MailboxSession ConnectToEDiscoveryMailbox(string clientString) { ADUser dataObject = this.DataObject; ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(dataObject, RemotingOptions.AllowCrossSite); return(MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, clientString)); }
internal static MailboxSession OpenMailboxSessionForSubmission(ADUser adUser, bool catchStorageException) { try { ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(adUser.OrganizationId.ToADSessionSettings(), adUser, RemotingOptions.AllowCrossSite); return(MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=EDiscoverySearch;Action=Search;Interactive=False", null, true)); } catch (StoragePermanentException arg) { SearchUtils.Tracer.TraceError <StoragePermanentException>(0L, "SearchUtils.OpenMailboxSession error {0}", arg); if (!catchStorageException) { throw; } } catch (StorageTransientException arg2) { SearchUtils.Tracer.TraceError <StorageTransientException>(0L, "SearchUtils.OpenMailboxSession error {0}", arg2); if (!catchStorageException) { throw; } } return(null); }
// Token: 0x06000503 RID: 1283 RVA: 0x00025B70 File Offset: 0x00023D70 private void InitializeArchiveMailboxSession() { if (this.primaryMailboxSession != null) { IMailboxInfo archiveMailbox = this.primaryMailboxSession.MailboxOwner.GetArchiveMailbox(); if (archiveMailbox != null) { try { ExchangePrincipal mailboxOwner = ExchangePrincipal.FromMailboxGuid(this.primaryMailboxSession.GetADSessionSettings(), archiveMailbox.MailboxGuid, RemotingOptions.AllowCrossSite | RemotingOptions.AllowCrossPremise, null); this.archiveMailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.CurrentCulture, "Client=TBA;Action=MoveToArchive;Interactive=False", null, true); } catch (ObjectNotFoundException arg) { LocalArchiveProcessor.Tracer.TraceDebug <IExchangePrincipal, ObjectNotFoundException>((long)this.primaryMailboxSession.GetHashCode(), "{0}: Problems opening the archive.{1}", this.primaryMailboxSession.MailboxOwner, arg); } catch (StorageTransientException arg2) { LocalArchiveProcessor.Tracer.TraceWarning <IExchangePrincipal, MailboxSession, StorageTransientException>((long)this.primaryMailboxSession.GetHashCode(), "{0}: Failed to connect to the the archive mailbox : {1}.\nError:\n{2}", this.primaryMailboxSession.MailboxOwner, this.primaryMailboxSession, arg2); } catch (StoragePermanentException arg3) { LocalArchiveProcessor.Tracer.TraceError <IExchangePrincipal, MailboxSession, StoragePermanentException>((long)this.primaryMailboxSession.GetHashCode(), "{0}: Failed to connect to the the archive mailbox : {1}.\nError:\n{2}", this.primaryMailboxSession.MailboxOwner, this.primaryMailboxSession, arg3); } } } }
public override MRSRequestMailboxEntry Read(RequestIndexEntryProvider requestIndexEntryProvider, RequestIndexEntryObjectId identity) { this.ValidateRequestIndexId(identity.IndexId); ADUser aduser = requestIndexEntryProvider.ReadADUser(identity.IndexId.Mailbox, Guid.Empty); if (aduser == null) { return(null); } ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(aduser, RemotingOptions.AllowCrossSite); MRSRequestMailboxEntry result; using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=MSExchangeMigration")) { MailboxStoreTypeProvider session = new MailboxStoreTypeProvider(aduser) { MailboxSession = mailboxSession }; MRSRequestMailboxEntry mrsrequestMailboxEntry = MRSRequest.Read <MRSRequestMailboxEntry>(session, identity.RequestGuid); mrsrequestMailboxEntry.RequestIndexId = identity.IndexId; mrsrequestMailboxEntry.OrganizationId = identity.OrganizationId; result = mrsrequestMailboxEntry; } return(result); }
public void Save(IConfigurable instance) { this.mailMessage = (MailMessage)instance; CultureInfo currentCulture = CultureInfo.CurrentCulture; using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(ExchangePrincipal.FromDirectoryObjectId(this.adSession, this.mailbox.Id, RemotingOptions.LocalConnectionsOnly), currentCulture, "Client=Management;Action=New-MailMessage")) { StoreObjectId defaultFolderId = mailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts); using (MessageItem messageItem = MessageItem.Create(mailboxSession, defaultFolderId)) { if (!string.IsNullOrEmpty(this.mailMessage.Subject)) { messageItem.Subject = this.mailMessage.Subject; } if (!string.IsNullOrEmpty(this.mailMessage.Body)) { using (TextWriter textWriter = messageItem.Body.OpenTextWriter((BodyFormat)this.mailMessage.BodyFormat)) { textWriter.WriteLine(this.mailMessage.Body); } } messageItem.Save(SaveMode.NoConflictResolution); messageItem.Load(); this.mailMessage.SetIdentity(messageItem.Id.ObjectId); } } }
private void NotifyApps() { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(this.mailboxPrincipal, CultureInfo.InvariantCulture, "Client=Management;Action=SetConnectSubscription")) { this.providerImpl.NotifyApps(mailboxSession); } }
protected override void WriteResult(IConfigurable dataObject) { TaskLogger.LogEnter(); try { if (dataObject != null) { ADUser user = (ADUser)dataObject; ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(user, null); using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=Management;Action=Get-MailboxActivityLog")) { IActivityLog activityLog = ActivityLogFactory.Current.Bind(mailboxSession); foreach (Activity activity in activityLog.Query()) { base.WriteResult(new ActivityLogEntryPresentationObject(activity)); } } } } catch (StorageTransientException exception) { base.WriteError(exception, ErrorCategory.ReadError, null); } catch (StoragePermanentException exception2) { base.WriteError(exception2, ErrorCategory.ReadError, null); } finally { TaskLogger.LogExit(); } }
public static void InitExtendedRuleSizeLimitIfNeeded(MailboxSession originalSession) { if (originalSession.LogonType != LogonType.BestAccess && originalSession.LogonType != LogonType.Delegated && originalSession.LogonType != LogonType.Owner) { return; } int?num = originalSession.Mailbox.TryGetProperty(MailboxSchema.ExtendedRuleSizeLimit) as int?; if (num == null || num > 522240) { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(originalSession.MailboxOwner, originalSession.InternalCulture, "Client=Management;Action=InitExtendedRuleSizeLimit")) { mailboxSession.Mailbox.SetProperties(new PropertyDefinition[] { MailboxSchema.ExtendedRuleSizeLimit }, new object[] { 522240 }); CoreObject.GetPersistablePropertyBag((CoreMailboxObject)mailboxSession.Mailbox.CoreObject).FlushChanges(); } originalSession.Mailbox.ForceReload(new PropertyDefinition[] { MailboxSchema.ExtendedRuleSizeLimit }); } }
internal static MailboxSession OpenMailboxSession(ExchangePrincipal principal, string taskName, bool allowAdminLocalization) { TaskLogger.LogEnter(); MailboxSession result = MailboxSession.OpenAsAdmin(principal, CultureInfo.InvariantCulture, string.Format("Client=Management;Action={0};Privilege:ActAsAdmin", taskName), false, false, null, allowAdminLocalization); TaskLogger.LogExit(); return(result); }
internal static MailboxSession OpenMailboxSession(ExchangePrincipal principal, GenericIdentity actualExecutingIdentity) { if (actualExecutingIdentity == null) { throw new ArgumentNullException("actualExecutingIdentity"); } return(MailboxSession.OpenAsAdmin(principal, CultureInfo.InvariantCulture, "Client=EDiscoverySearch;Action=Search;Interactive=False", actualExecutingIdentity, true)); }
private static MailboxSession OpenMailboxSession(ADUser adUser) { if (adUser == null) { throw new ArgumentNullException("adUser"); } ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(adUser.OrganizationId.ToADSessionSettings(), adUser, RemotingOptions.AllowCrossSite); return(MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=ELC;Action=Manage-SearchObject;Interactive=false", null, true)); }
public XsoMailboxDataProviderBase(ExchangePrincipal mailboxOwner, string action) { using (DisposeGuard disposeGuard = this.Guard()) { Util.ThrowOnNullArgument(mailboxOwner, "mailboxOwner"); Util.ThrowOnNullOrEmptyArgument(action, "action"); this.MailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, string.Format("Client=Management;Action={0};Privilege:ActAsAdmin", action)); disposeGuard.Success(); } }
private static SessionManager.SessionData OpenSession(ExchangePrincipal principal, ExTimeZone timeZone, string clientInfoString) { MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(principal, CultureInfo.InvariantCulture, clientInfoString); if (timeZone != null) { mailboxSession.ExTimeZone = timeZone; } return(new SessionManager.SessionData(mailboxSession)); }
protected override IConfigurable ConvertDataObjectToPresentationObject(IConfigurable dataObject) { if (dataObject == null) { return(null); } ADUser aduser = (ADUser)dataObject; UserPhotoConfiguration userPhotoConfiguration = new UserPhotoConfiguration(dataObject.Identity, Stream.Null, null); if (CmdletProxy.TryToProxyOutputObject(userPhotoConfiguration, base.CurrentTaskContext, aduser, this.Identity == null, this.ConfirmationMessage, CmdletProxy.AppendIdentityToProxyCmdlet(aduser))) { return(userPhotoConfiguration); } IConfigurable result; try { ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromADUser(aduser, null); using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(exchangePrincipal, CultureInfo.InvariantCulture, "Client=Management;Action=Get-UserPhoto")) { using (MemoryStream memoryStream = new MemoryStream()) { PhotoManagementRetrievalPipeline photoManagementRetrievalPipeline = new PhotoManagementRetrievalPipeline(GetUserPhoto.PhotosConfiguration, mailboxSession, (IRecipientSession)base.DataSession, this.tracer); PhotoResponse photoResponse = photoManagementRetrievalPipeline.Retrieve(this.CreateRetrievePhotoRequest(exchangePrincipal), memoryStream); HttpStatusCode status = photoResponse.Status; if (status != HttpStatusCode.OK && status == HttpStatusCode.NotFound) { this.WriteError(new UserPhotoNotFoundException(this.Preview), ExchangeErrorCategory.Client, this.Identity, true); throw new InvalidOperationException(); } memoryStream.Seek(0L, SeekOrigin.Begin); result = new UserPhotoConfiguration(dataObject.Identity, memoryStream, photoResponse.Thumbprint); } } } catch (UserPhotoNotFoundException) { throw; } catch (Exception ex) { ExManagementApplicationLogger.LogEvent(ManagementEventLogConstants.Tuple_FailedToRetrievePhoto, new string[] { dataObject.ToString(), ((ADUser)dataObject).UserPrincipalName, ex.ToString() }); throw; } finally { this.tracer.Dump(new PhotoRequestLogWriter(GetUserPhoto.RequestLog, GetUserPhoto.GenerateRequestId())); } return(result); }
private static IEnumerable <MRSRequestMailboxEntry> GetRequestIndexEntries(ADUser user, RequestIndexEntryQueryFilter requestIndexEntryQueryFilter) { ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(user, RemotingOptions.AllowCrossSite); IEnumerable <MRSRequestMailboxEntry> result; using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=MSExchangeMigration")) { result = MRSRequestMailboxEntry.Read(mailboxSession, requestIndexEntryQueryFilter); } return(result); }
protected override TeamMailboxSyncInfo CreateOnCacheMiss(TeamMailboxSyncId key, ref bool shouldAdd) { IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(key.DomainController, true, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(key.OrgId), 105, "CreateOnCacheMiss", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\LinkedFolder\\TeamMailboxSyncInfoCache.cs"); ADRecipient adrecipient = tenantOrRootOrgRecipientSession.FindByExchangeGuid(key.MailboxGuid); ADUser aduser = adrecipient as ADUser; if (aduser == null) { return(null); } TeamMailboxLifecycleState teamMailboxLifecycleState = TeamMailboxLifecycleState.Active; if (TeamMailbox.IsPendingDeleteSiteMailbox(aduser)) { teamMailboxLifecycleState = TeamMailboxLifecycleState.PendingDelete; } else if (aduser.SharePointUrl == null) { teamMailboxLifecycleState = TeamMailboxLifecycleState.Unlinked; } ExchangePrincipal exchangePrincipal = null; try { exchangePrincipal = ExchangePrincipal.FromMailboxGuid(ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(key.OrgId), key.MailboxGuid, key.DomainController); } catch (ObjectNotFoundException) { return(null); } TeamMailboxSyncInfo result; using (DisposeGuard disposeGuard = default(DisposeGuard)) { MailboxSession mailboxSession = null; UserConfiguration userConfiguration = null; if (teamMailboxLifecycleState == TeamMailboxLifecycleState.Active) { mailboxSession = MailboxSession.OpenAsAdmin(exchangePrincipal, CultureInfo.InvariantCulture, "Client=TeamMailbox;Action=CommitChanges;Interactive=False"); disposeGuard.Add <MailboxSession>(mailboxSession); if (!string.Equals(mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn, TeamMailboxSyncInfoCache.LocalServerFqdn, StringComparison.OrdinalIgnoreCase)) { throw new WrongServerException(new LocalizedString(string.Format("Non-local XSO MailboxSession not allowed for TeamMailboxSync. TeamMailbox Name: {0}, MailboxGuid {1}, ServerFqdn {2}", mailboxSession.MailboxOwner.MailboxInfo.DisplayName, mailboxSession.MailboxOwner.MailboxInfo.MailboxGuid, mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn))); } userConfiguration = UserConfigurationHelper.GetMailboxConfiguration(mailboxSession, this.syncLogConfigurationName, UserConfigurationTypes.Stream, true); disposeGuard.Add <UserConfiguration>(userConfiguration); } TeamMailbox teamMailbox = TeamMailbox.FromDataObject(aduser); TeamMailboxSyncInfo teamMailboxSyncInfo = new TeamMailboxSyncInfo(key.MailboxGuid, teamMailboxLifecycleState, mailboxSession, exchangePrincipal, teamMailbox.DisplayName, teamMailbox.WebCollectionUrl, teamMailbox.WebId, (aduser.SharePointUrl != null) ? aduser.SharePointUrl.AbsoluteUri : null, (teamMailboxLifecycleState == TeamMailboxLifecycleState.Active) ? this.resourceMonitorFactory.Create(exchangePrincipal.MailboxInfo.MailboxDatabase.ObjectGuid) : null, userConfiguration); disposeGuard.Success(); result = teamMailboxSyncInfo; } return(result); }
public List<Exception> SendNotification(IList<ADObjectId> recipients, string subject, string body, RemotingOptions remotingOptons = RemotingOptions.LocalConnectionsOnly) { if (recipients == null) { throw new ArgumentNullException("recipients"); } if (subject == null) { throw new ArgumentNullException("subject"); } if (body == null) { throw new ArgumentNullException("body"); } List<Exception> list = new List<Exception>(); if (recipients.Count > 0) { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(ExchangePrincipal.FromADUser((ADUser)this.tm.DataObject, remotingOptons), CultureInfo.InvariantCulture, "Client=TeamMailbox;Action=Send_Notification")) { using (MessageItem messageItem = MessageItem.Create(mailboxSession, mailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts))) { foreach (ADObjectId adobjectId in recipients) { Exception ex = null; ADUser aduser = TeamMailboxADUserResolver.Resolve(this.dataSession, adobjectId, out ex); if (ex != null) { list.Add(new Exception(string.Format("When resolving recipient {0}, got an excetion: {1}", adobjectId, ex))); } else if (aduser == null) { list.Add(new Exception("Cannot find recipient: " + adobjectId)); } else { messageItem.Recipients.Add(new Participant(aduser.DisplayName, aduser.PrimarySmtpAddress.ToString(), "SMTP")); } } messageItem.Subject = subject; using (Stream stream = messageItem.Body.OpenWriteStream(new BodyWriteConfiguration(BodyFormat.TextHtml, Charset.Unicode))) { using (StreamWriter streamWriter = new StreamWriter(stream, Encoding.Unicode)) { streamWriter.WriteLine(body); } } messageItem.AutoResponseSuppress = AutoResponseSuppress.All; messageItem.SendWithoutSavingMessage(); } } } return list; }
internal static StoreSession OpenSession(ExchangePrincipal principal, GenericIdentity actualExecutingIdentity, bool publicFolderSession = false) { if (actualExecutingIdentity == null) { throw new ArgumentNullException("actualExecutingIdentity"); } if (!publicFolderSession) { return(MailboxSession.OpenAsAdmin(principal, CultureInfo.InvariantCulture, "Client=EDiscoverySearch;Action=Search;Interactive=False", actualExecutingIdentity, true)); } return(PublicFolderSession.OpenAsAdmin(principal.MailboxInfo.OrganizationId, null, principal.MailboxInfo.MailboxGuid, null, CultureInfo.InvariantCulture, "Client=EDiscoverySearch;Action=Search;Interactive=False", null)); }
public override void Save(RequestIndexEntryProvider requestIndexEntryProvider, T instance) { ArgumentValidator.ThrowIfNull("instance", instance); ArgumentValidator.ThrowIfNull("instance.TargetUser", instance.TargetUser); ArgumentValidator.ThrowIfNull("instance.TargetExchangeGuid", instance.TargetExchangeGuid); instance.SetExchangePrincipal(); using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(instance.GetExchangePrincipal(), CultureInfo.InvariantCulture, "Client=MSExchangeMigration")) { instance.Save(new MailboxStoreTypeProvider(instance.TargetUser) { MailboxSession = mailboxSession }); } }