// Token: 0x0600167E RID: 5758 RVA: 0x00066D2E File Offset: 0x00064F2E internal ADMailboxRecipient(IRecipientSession session, PropertyBag propertyBag) : base(session, propertyBag) { }
internal MailTipsPermission Lookup(RecipientData recipientData) { if (this.ExternalClientContext == null) { this.tracer.TraceDebug <object, EmailAddress>((long)this.traceId, "{0}: InternalMailTipsPermission used for {1} because requester is not external", TraceContext.Get(), recipientData.EmailAddress); return(MailTipsPermission.AllAccess); } if (recipientData.IsEmpty) { this.tracer.TraceDebug <object, EmailAddress>((long)this.traceId, "{0}: InternalMailTipsPermission used for {1} because recipient did not resolve in AD", TraceContext.Get(), recipientData.EmailAddress); return(MailTipsPermission.AllAccess); } MailTipsPermission mailTipsPermission; if (this.permissionMap.TryGetValue(recipientData.OrganizationId, out mailTipsPermission)) { return(mailTipsPermission); } OrganizationRelationship organizationRelationship = FreeBusyPermission.GetOrganizationRelationship(recipientData.OrganizationId, this.ExternalClientContext.EmailAddress.Domain); if (organizationRelationship == null || !organizationRelationship.Enabled) { this.tracer.TraceDebug <object, OrganizationId, string>((long)this.traceId, "{0}: No organization relationship found in organization {1} for domain {2}", TraceContext.Get(), recipientData.OrganizationId, this.ExternalClientContext.EmailAddress.Domain); return(MailTipsPermission.NoAccess); } bool requesterInAccessScope = false; if (organizationRelationship.MailTipsAccessScope == null) { requesterInAccessScope = true; } else if (organizationRelationship.MailTipsAccessEnabled && organizationRelationship.MailTipsAccessLevel != MailTipsAccessLevel.None) { IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(recipientData.OrganizationId), 127, "Lookup", "f:\\15.00.1497\\sources\\dev\\infoworker\\src\\common\\MailTips\\MailTipsPerRequesterPermissionMap.cs"); ADGroup adgroup = tenantOrRootOrgRecipientSession.Read(organizationRelationship.MailTipsAccessScope) as ADGroup; if (adgroup == null) { this.tracer.TraceError <object, OrganizationId, ADObjectId>((long)this.traceId, "{0}: OrganizationRelationship for organization {1} has invalid MailTipsAccessScope {2} which cannot be resolved in ad as an ADGroup", TraceContext.Get(), recipientData.OrganizationId, organizationRelationship.MailTipsAccessScope); } else if (adgroup.ContainsMember(recipientData.Id, false)) { this.tracer.TraceDebug((long)this.traceId, "{0}: {1} is a member of MailTipsAccessScope {2} for OrganizationRelationship of organization {3}", new object[] { TraceContext.Get(), recipientData.EmailAddress, organizationRelationship.MailTipsAccessScope, recipientData.OrganizationId }); requesterInAccessScope = true; } else { this.tracer.TraceDebug((long)this.traceId, "{0}: {1} is not a member of MailTipsAccessScope {2} for OrganizationRelationship of organization {3}", new object[] { TraceContext.Get(), recipientData.EmailAddress, organizationRelationship.MailTipsAccessScope, recipientData.OrganizationId }); } } mailTipsPermission = new MailTipsPermission(organizationRelationship.MailTipsAccessEnabled, organizationRelationship.MailTipsAccessLevel, requesterInAccessScope); this.permissionMap[recipientData.OrganizationId] = mailTipsPermission; return(mailTipsPermission); }
// Token: 0x060019D7 RID: 6615 RVA: 0x0006CEF6 File Offset: 0x0006B0F6 internal ADMicrosoftExchangeRecipient(IRecipientSession session, string commonName, ADObjectId containerId) { this.m_Session = session; base.SetId(containerId.GetChildId("CN", commonName)); base.SetObjectClass(this.MostDerivedObjectClass); }
// Token: 0x060010A2 RID: 4258 RVA: 0x00044314 File Offset: 0x00042514 public static void UpdateAndSaveTextMessgaingStateOnAdUser(TextMessagingAccount account, ADRecipient adRecipient, IRecipientSession adSession) { if (account == null) { throw new ArgumentNullException("account"); } if (adRecipient == null) { throw new ArgumentNullException("adRecipient"); } if (adSession == null) { throw new ArgumentNullException("adSession"); } if (TextMessagingHelper.UpdateTextMessagingState(adRecipient.TextMessagingState, account.TextMessagingSettings.DeliveryPoints)) { adSession.Save(adRecipient); } }
public static void SendWelcomeMessageIfNeeded(MailboxSession originalSession) { if (!string.IsNullOrEmpty(originalSession.ClientInfoString) && (originalSession.ClientInfoString.Equals("Client=TeamMailbox;Action=SendWelcomeMessageToSiteMailbox;Interactive=False", StringComparison.OrdinalIgnoreCase) || originalSession.ClientInfoString.Equals("Client=TeamMailbox;Action=GetDiagnostics;Interactive=False", StringComparison.OrdinalIgnoreCase) || originalSession.ClientInfoString.Equals("Client=TeamMailbox;Action=Send_Notification", StringComparison.OrdinalIgnoreCase))) { return; } originalSession.Mailbox.Load(new PropertyDefinition[] { MailboxSchema.SiteMailboxInternalState }); int? siteMailboxInternalState = originalSession.Mailbox.TryGetProperty(InternalSchema.SiteMailboxInternalState) as int?; if (siteMailboxInternalState != null) { if ((siteMailboxInternalState.Value & 1) == 1) { return; } } try { using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(originalSession.MailboxOwner, originalSession.InternalCulture, "Client=TeamMailbox;Action=SendWelcomeMessageToSiteMailbox;Interactive=False")) { string internetMessageId = "ed590c4ca1674effa0067475ab2b93b2_" + mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress; using (MessageItem messageItem = MessageItem.CreateForDelivery(mailboxSession, mailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox), internetMessageId, new ExDateTime?(ExDateTime.MinValue))) { messageItem.Recipients.Add(new Participant(mailboxSession.MailboxOwner.MailboxInfo.DisplayName, mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(), "SMTP")); messageItem.From = new Participant(mailboxSession.MailboxOwner); IRecipientSession recipientSession = null; TeamMailbox teamMailbox = TeamMailboxNotificationHelper.GetTeamMailbox(mailboxSession, out recipientSession); TeamMailboxNotificationHelper teamMailboxNotificationHelper = new TeamMailboxNotificationHelper(teamMailbox, recipientSession); messageItem.Subject = teamMailboxNotificationHelper.GetSubject(TeamMailboxNotificationType.Welcome); using (Stream stream = messageItem.Body.OpenWriteStream(new BodyWriteConfiguration(BodyFormat.TextHtml, Charset.Unicode))) { using (StreamWriter streamWriter = new StreamWriter(stream, Encoding.Unicode)) { streamWriter.WriteLine(teamMailboxNotificationHelper.GetBody(TeamMailboxNotificationType.Welcome)); } } messageItem.AutoResponseSuppress = AutoResponseSuppress.All; messageItem.InternetMessageId = internetMessageId; messageItem.PropertyBag[InternalSchema.SentTime] = ExDateTime.UtcNow; mailboxSession.Deliver(messageItem, ProxyAddress.Parse(ProxyAddressPrefix.Smtp.PrimaryPrefix, mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString()), RecipientItemType.To); } TeamMailboxNotificationHelper.UpdateWelcomeMessageSentState(siteMailboxInternalState, mailboxSession); } } catch (StoragePermanentException ex) { if (ex.InnerException != null && ex.InnerException is MapiExceptionDuplicateDelivery) { using (MailboxSession mailboxSession2 = MailboxSession.OpenAsAdmin(originalSession.MailboxOwner, originalSession.Culture, "Client=TeamMailbox;Action=SendWelcomeMessageToSiteMailbox;Interactive=False")) { TeamMailboxNotificationHelper.UpdateWelcomeMessageSentState(siteMailboxInternalState, mailboxSession2); goto IL_27D; } goto IL_27B; IL_27D: return; } IL_27B: throw; } }
public bool IsMemberOf(Guid adUserObjectGuid, RoutingAddress group) { IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.organizationId), 120, "IsMemberOf", "f:\\15.00.1497\\sources\\dev\\infoworker\\src\\common\\OrganizationConfiguration\\GroupsConfiguration.cs"); return(this.IsMemberOf(tenantOrRootOrgRecipientSession, adUserObjectGuid, group)); }
// Token: 0x060011E6 RID: 4582 RVA: 0x0004B294 File Offset: 0x00049494 public MailboxPhotoHandler(PhotosConfiguration configuration, string clientInfo, IMailboxPhotoReader reader, IRecipientSession recipientSession, ITracer upstreamTracer, IXSOFactory xsoFactory) { ArgumentValidator.ThrowIfNull("configuration", configuration); ArgumentValidator.ThrowIfNullOrEmpty("clientInfo", clientInfo); ArgumentValidator.ThrowIfNull("reader", reader); ArgumentValidator.ThrowIfNull("recipientSession", recipientSession); ArgumentValidator.ThrowIfNull("upstreamTracer", upstreamTracer); ArgumentValidator.ThrowIfNull("xsoFactory", xsoFactory); this.tracer = ExTraceGlobals.UserPhotosTracer.Compose(upstreamTracer); this.configuration = configuration; this.xsoFactory = xsoFactory; this.reader = reader; this.clientInfo = clientInfo; this.recipientSession = recipientSession; }
// Token: 0x06001405 RID: 5125 RVA: 0x00060029 File Offset: 0x0005E229 internal StorageMiniRecipient(IRecipientSession session, PropertyBag propertyBag) : base(session, propertyBag) { }
private Stream GetADPictureStream(string email, string routingType) { IRecipientSession recipientSession = Utilities.CreateADRecipientSession(ConsistencyMode.IgnoreInvalid, base.UserContext); byte[] array = null; bool flag = string.Equals(email, base.UserContext.ExchangePrincipal.LegacyDn, StringComparison.OrdinalIgnoreCase); string stringHash = Utilities.GetStringHash(email); bool flag2 = DisplayPictureUtility.IsInRecipientsNegativeCache(stringHash); if (!flag2 || flag) { ProxyAddress proxyAddress = null; try { if (string.Equals(routingType, "EX", StringComparison.Ordinal)) { proxyAddress = new CustomProxyAddress((CustomProxyAddressPrefix)ProxyAddressPrefix.LegacyDN, email, true); } else if (string.Equals(routingType, "SMTP", StringComparison.Ordinal)) { proxyAddress = new SmtpProxyAddress(email, true); } if (proxyAddress != null) { if (Globals.ArePerfCountersEnabled) { OwaSingleCounters.SenderPhotosTotalLDAPCalls.Increment(); } ADRawEntry adrawEntry = recipientSession.FindByProxyAddress(proxyAddress, new PropertyDefinition[] { ADRecipientSchema.ThumbnailPhoto }); if (adrawEntry != null) { array = (adrawEntry[ADRecipientSchema.ThumbnailPhoto] as byte[]); } } goto IL_10F; } catch (NonUniqueRecipientException ex) { ExTraceGlobals.CoreTracer.TraceDebug <string>(0L, "GetADPictureStream: NonUniqueRecipientException was thrown by FindByProxyAddress: {0}", ex.Message); throw new OwaEventHandlerException("Unable to retrieve recipient data.", LocalizedStrings.GetNonEncoded(-1953304495)); } } if (Globals.ArePerfCountersEnabled) { OwaSingleCounters.SenderPhotosDataFromNegativeCacheCount.Increment(); } IL_10F: bool flag3 = array != null && array.Length > 0; if (flag) { base.UserContext.HasPicture = new bool?(flag3); } if (flag3) { if (Globals.ArePerfCountersEnabled) { OwaSingleCounters.SenderPhotosTotalLDAPCallsWithPicture.Increment(); } if (flag2) { DisplayPictureUtility.RecipientsNegativeCache.Remove(stringHash); } return(new MemoryStream(array)); } if (!flag2) { int num = DisplayPictureUtility.RecipientsNegativeCache.AddAndCount(stringHash, DateTime.UtcNow); if (Globals.ArePerfCountersEnabled) { OwaSingleCounters.SenderPhotosNegativeCacheCount.RawValue = (long)num; } } return(new MemoryStream()); }
// Token: 0x0600108A RID: 4234 RVA: 0x00060890 File Offset: 0x0005EA90 internal void GetMetricsForSingleGroup(IRecipientSession session, string groupDN, TypedHashSet calculatedGroups, Dictionary <string, object> parentGroupDictionary, IList <string> parentGroupList) { ADObjectId id = new ADObjectId(groupDN); ADRawEntry group = null; ADOperationResult adoperationResult = this.TryRunPerGroupADOperation(delegate { group = session.ReadADRawEntry(id, GroupMetricsGenerator.groupProperties); }, groupDN); if (!adoperationResult.Succeeded || group == null) { return; } ulong hash = GroupMetricsUtility.GetHash(group.Id.ObjectGuid); if (calculatedGroups.Contains(hash)) { return; } int externalMemberCount = 0; HashSet <ulong> allMemberHashes = new HashSet <ulong>(2000); ADRecipientExpansion expander = new ADRecipientExpansion(session, false); adoperationResult = this.TryRunPerGroupADOperation(delegate { if (GroupMetricsUtility.Fault == GroupMetricsFault.TransientExceptionInExpansion) { throw new ADTransientException(new LocalizedString("Fault Injection")); } if (GroupMetricsUtility.Fault == GroupMetricsFault.InvalidCredentialExceptionInExpansion) { throw new ADInvalidCredentialException(new LocalizedString("Fault Injection")); } if (GroupMetricsUtility.Fault == GroupMetricsFault.PermanentExceptionInExpansion) { throw new DataSourceOperationException(new LocalizedString("Fault Injection")); } expander.Expand(group, delegate(ADRawEntry member, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType) { this.RunData.ThrowIfShuttingDown(); if (recipientExpansionType == ExpansionType.GroupMembership) { return(ExpansionControl.Continue); } ulong hash2 = GroupMetricsUtility.GetHash(member.Id.ObjectGuid); if (allMemberHashes.TryAdd(hash2) && this.IsExternal(member)) { externalMemberCount++; } if (allMemberHashes.Count >= 1000) { return(ExpansionControl.Terminate); } if (recipientExpansionType != ExpansionType.None) { return(ExpansionControl.Skip); } return(ExpansionControl.Continue); }, (ExpansionFailure failure, ADRawEntry member, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType) => ExpansionControl.Continue); }, groupDN); if (!adoperationResult.Succeeded) { return; } MultiValuedProperty <ADObjectId> multiValuedProperty = group[ADRecipientSchema.MemberOfGroup] as MultiValuedProperty <ADObjectId>; foreach (ADObjectId adobjectId in multiValuedProperty) { string distinguishedName = adobjectId.DistinguishedName; if (!parentGroupDictionary.ContainsKey(distinguishedName)) { parentGroupDictionary.Add(distinguishedName, null); parentGroupList.Add(distinguishedName); } } int count = allMemberHashes.Count; calculatedGroups.Add(hash); this.groupsExpanded++; int oldValue = (int)group[ADGroupSchema.GroupMemberCount]; int oldValue2 = (int)group[ADGroupSchema.GroupExternalMemberCount]; if (this.ShouldSaveToAD(oldValue, count) || this.ShouldSaveToAD(oldValue2, externalMemberCount)) { this.SaveGroupMetricsToAD(session, group, count, externalMemberCount); } }
// Token: 0x06001094 RID: 4244 RVA: 0x000611B4 File Offset: 0x0005F3B4 private bool GetMetricsForChangedGroups(GroupMetricsGeneratorTaskContext context) { string text = this.changedGroupListPath; TypedHashSet calculatedGroups = new TypedHashSet(20000); try { if (GroupMetricsUtility.Fault == GroupMetricsFault.UnreadableChangedGroupFile) { text = this.tenantDirectory; } List <string> list = new List <string>(); Dictionary <string, object> parentGroupDictionary = new Dictionary <string, object>(); IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(base.OrgId), 1316, "GetMetricsForChangedGroups", "f:\\15.00.1497\\sources\\dev\\MailboxAssistants\\src\\assistants\\DirectoryProcessor\\GroupMetricsGenerator\\GroupMetricsGenerator.cs"); using (StreamReader streamReader = new StreamReader(text)) { string text2; if (context.LastProcessedGroupDistinguishedName != null) { while ((text2 = streamReader.ReadLine()) != null && text2 != context.LastProcessedGroupDistinguishedName) { } } DateTime utcNow = DateTime.UtcNow; while ((text2 = streamReader.ReadLine()) != null) { this.GetMetricsForSingleGroup(tenantOrRootOrgRecipientSession, text2, calculatedGroups, parentGroupDictionary, list); context.LastProcessedGroupDistinguishedName = text2; if ((Utilities.TestForceYieldChunk && this.groupsExpanded > 2) || DateTime.UtcNow - utcNow > this.OneChunkTimeLimit) { break; } base.RunData.ThrowIfShuttingDown(); } if (text2 == null) { context.AllChunksFinished = true; } } for (int i = 0; i < list.Count; i++) { string text2 = list[i]; this.GetMetricsForSingleGroup(tenantOrRootOrgRecipientSession, text2, calculatedGroups, parentGroupDictionary, list); } return(true); } catch (FileNotFoundException) { context.AllChunksFinished = true; return(true); } catch (IOException ex) { GroupMetricsGenerator.EventLogger.LogEvent(InfoWorkerEventLogConstants.Tuple_UnableToReadChangedGroupList, null, new object[] { this.GetOrganizationIdString(), text, ex.GetType().FullName, ex.Message }); } catch (UnauthorizedAccessException ex2) { GroupMetricsGenerator.EventLogger.LogEvent(InfoWorkerEventLogConstants.Tuple_UnableToReadChangedGroupList, null, new object[] { this.GetOrganizationIdString(), text, ex2.GetType().FullName, ex2.Message }); } catch (SecurityException ex3) { GroupMetricsGenerator.EventLogger.LogEvent(InfoWorkerEventLogConstants.Tuple_UnableToReadChangedGroupList, null, new object[] { this.GetOrganizationIdString(), text, ex3.GetType().FullName, ex3.Message }); } return(false); }
private static RpcAssociationReplicatorRunNowParameters Instantiate(List <MailboxLocatorType> locators, IRecipientSession adSession) { ArgumentValidator.ThrowIfNull("adSession", adSession); if (locators != null && locators.Count > 0) { List <IMailboxLocator> list = new List <IMailboxLocator>(locators.Count); for (int i = 0; i < locators.Count; i++) { list.Add(EwsAssociationDataConverter.Convert(locators[i], adSession)); } return(new RpcAssociationReplicatorRunNowParameters { SlaveMailboxes = list }); } return(new RpcAssociationReplicatorRunNowParameters()); }
public UnseenCountBrokerHandler(string subscriptionId, SubscriptionParameters parameters, IMailboxContext userContext, IRecipientSession adSession) : base(subscriptionId, parameters, userContext) { using (DisposeGuard disposeGuard = this.Guard()) { this.adSession = adSession; this.unseenItemNotifier = new UnseenItemNotifier(subscriptionId, userContext, null, null); this.unseenItemNotifier.RegisterWithPendingRequestNotifier(); disposeGuard.Success(); } }
// Token: 0x06000B4A RID: 2890 RVA: 0x00048AC0 File Offset: 0x00046CC0 private void UpdateSafeLists(MailboxSession mailboxSession) { ADObjectId adobjectId = (mailboxSession.MailboxOwner != null) ? mailboxSession.MailboxOwner.ObjectId : null; if (adobjectId == null) { JunkEmailOptionsCommiterAssistant.Tracer.TraceError <MailboxSession>((long)this.GetHashCode(), "can't determine owner of mailbox {0}", mailboxSession); return; } if (TemplateTenantConfiguration.IsTemplateTenant(mailboxSession.MailboxOwner.MailboxInfo.OrganizationId)) { JunkEmailOptionsCommiterAssistant.Tracer.TraceDebug <string, Guid>((long)this.GetHashCode(), "Skipping mailbox {0} (GUID: {1}) because it belongs to a consumer tenant.", mailboxSession.MailboxOwner.MailboxInfo.DisplayName, mailboxSession.MailboxOwner.MailboxInfo.MailboxGuid); return; } IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(false, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(mailboxSession.MailboxOwner.MailboxInfo.OrganizationId), 318, "UpdateSafeLists", "f:\\15.00.1497\\sources\\dev\\MailboxAssistants\\src\\assistants\\JunkEmailOptions\\JunkEmailOptionsCommiterAssistant.cs"); ADUser aduser = tenantOrRootOrgRecipientSession.Read(adobjectId) as ADUser; if (aduser == null) { JunkEmailOptionsCommiterAssistant.Tracer.TraceError <ADObjectId>((long)this.GetHashCode(), "can't read user object {0} from AD.", adobjectId); return; } JunkEmailRule filteredJunkEmailRule = mailboxSession.FilteredJunkEmailRule; bool flag = false; bool flag2 = false; bool flag3 = false; byte[] array = filteredJunkEmailRule.IsEnabled ? this.GetSafeSendersHash(filteredJunkEmailRule, out flag) : null; byte[] array2 = filteredJunkEmailRule.IsEnabled ? this.GetSafeRecipientsHash(filteredJunkEmailRule, out flag2) : null; byte[] array3 = filteredJunkEmailRule.IsEnabled ? this.GetBlockedSendersHash(filteredJunkEmailRule, out flag3) : null; bool flag4 = false; if (!ArrayComparer <byte> .Comparer.Equals(array, aduser.SafeSendersHash)) { aduser.SafeSendersHash = array; flag4 = true; } if (!ArrayComparer <byte> .Comparer.Equals(array2, aduser.SafeRecipientsHash)) { aduser.SafeRecipientsHash = array2; flag4 = true; } if (!ArrayComparer <byte> .Comparer.Equals(array3, aduser.BlockedSendersHash)) { aduser.BlockedSendersHash = array3; flag4 = true; } if (flag4) { JunkEmailOptionsCommiterAssistant.Tracer.TraceDebug <ADObjectId>((long)this.GetHashCode(), "Saving updated recipient object {0} to AD...", adobjectId); tenantOrRootOrgRecipientSession.Save(aduser); JunkEmailOptionsPerfCounters.TotalRecipientsUpdated.Increment(); JunkEmailOptionsCommiterAssistant.Tracer.TraceDebug <ADObjectId>((long)this.GetHashCode(), "Recipient object {0} was successfully saved", adobjectId); if (flag || flag2 || flag3) { JunkEmailOptionsPerfCounters.TotalPartialUpdates.Increment(); } } Exception ex = null; try { if (flag4 || !filteredJunkEmailRule.AllRestrictionsLoaded) { filteredJunkEmailRule.Save(); } } catch (StoragePermanentException ex2) { ex = ex2; } catch (StorageTransientException ex3) { ex = ex3; } finally { if (ex != null) { JunkEmailOptionsCommiterAssistant.EventLogger.LogEvent(InfoWorkerEventLogConstants.Tuple_FailedToUpdateMailbox, null, new object[] { mailboxSession.MailboxGuid, ex }); } } }
public GroupConfiguration GetGroupInformation(IRecipientSession session, Guid group) { return(GroupsConfiguration.groupsResolver.Value.GetGroupInfo(session, group)); }
public DeleteUnifiedGroupTask(ADUser accessingUser, ExchangePrincipal accessingPrincipal, IRecipientSession adSession) : base(accessingUser, adSession) { this.accessingPrincipal = accessingPrincipal; }
public bool IsMemberOf(IRecipientSession session, ADObjectId user, string group) { return(GroupsConfiguration.groupsResolver.Value.IsMemberOf(session, user, (RoutingAddress)group)); }
protected override void InternalValidate() { TaskLogger.LogEnter(); try { base.ValidateRootFolders(this.SourceRootFolder, this.TargetRootFolder); bool wildcardedSearch = false; if (!string.IsNullOrEmpty(base.Name)) { base.ValidateName(); base.RequestName = base.Name; } else { wildcardedSearch = true; base.RequestName = "MailboxRestore"; } this.targetUser = RequestTaskHelper.ResolveADUser(base.RecipSession, base.GCSession, base.ServerSettings, this.TargetMailbox, base.OptionalIdentityData, base.DomainController, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), true); this.CheckForInvalidPublicFolderRestoreParameters(); if (this.targetUser.HasLocalArchive && this.targetUser.RecipientType == RecipientType.MailUser && this.targetUser.Database == null && !this.TargetIsArchive) { base.WriteError(new MissingArchiveParameterForRestorePermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox); } if (this.targetUser.RecipientType != RecipientType.UserMailbox && (!this.TargetIsArchive || this.targetUser.RecipientType != RecipientType.MailUser)) { base.WriteError(new InvalidRecipientTypePermanentException(this.targetUser.ToString(), this.targetUser.RecipientType.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox); } if (this.TargetIsArchive && (this.targetUser.ArchiveGuid == Guid.Empty || this.targetUser.ArchiveDatabase == null)) { base.WriteError(new MailboxLacksArchivePermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetIsArchive); } if (!this.TargetIsArchive && this.targetUser.Database == null) { base.WriteError(new MailboxLacksDatabasePermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox); } if (base.ParameterSetName.Equals("RemoteMailboxRestore")) { if (!Guid.TryParse(this.SourceStoreMailbox.RawIdentity, out this.sourceMailboxGuid)) { base.WriteError(new RecipientTaskException(Strings.ErrorParameterValueNotAllowed("SourceStoreMailbox")), ErrorCategory.InvalidArgument, this.SourceStoreMailbox); } if (!base.Fields.IsModified("AllowLegacyDNMismatch") || !this.AllowLegacyDNMismatch) { base.WriteError(new RecipientTaskException(Strings.ErrorParameterValueNotAllowed("AllowLegacyDNMismatch")), ErrorCategory.InvalidArgument, this.AllowLegacyDNMismatch); } base.Flags = (RequestFlags.CrossOrg | RequestFlags.Pull); switch (this.RemoteRestoreType) { case RemoteRestoreType.RecoveryDatabase: this.restoreFlags |= MailboxRestoreType.Recovery; this.restoreFlags |= MailboxRestoreType.SoftDeleted; break; case RemoteRestoreType.DisconnectedMailbox: this.restoreFlags |= MailboxRestoreType.SoftDeleted; break; case RemoteRestoreType.SoftDeletedRecipient: this.restoreFlags |= MailboxRestoreType.SoftDeletedRecipient; break; default: base.WriteError(new RecipientTaskException(Strings.ErrorParameterValueNotAllowed("RemoteRestoreType")), ErrorCategory.InvalidArgument, this.RemoteRestoreType); break; } } else { base.Flags = (RequestFlags.IntraOrg | RequestFlags.Pull); string fqdn; string serverExchangeLegacyDn; ADObjectId adobjectId; int num; MailboxDatabase mailboxDatabase = base.CheckDatabase <MailboxDatabase>(this.SourceDatabase, NewRequest <MailboxRestoreRequest> .DatabaseSide.Source, this.SourceDatabase, out fqdn, out serverExchangeLegacyDn, out adobjectId, out num); if (mailboxDatabase.Recovery) { this.restoreFlags |= MailboxRestoreType.Recovery; } this.sourceDatabase = mailboxDatabase.Id; this.SourceStoreMailbox.Flags |= 1UL; using (MapiSession mapiSession = new MapiAdministrationSession(serverExchangeLegacyDn, Fqdn.Parse(fqdn))) { using (MailboxStatistics mailboxStatistics = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(this.SourceStoreMailbox, mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(mailboxDatabase), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString())))) { MailboxState?disconnectReason = mailboxStatistics.DisconnectReason; if (mailboxStatistics.MailboxType == StoreMailboxType.PublicFolderPrimary || mailboxStatistics.MailboxType == StoreMailboxType.PublicFolderSecondary) { this.restoreFlags |= MailboxRestoreType.PublicFolderMailbox; } bool flag = false; if (disconnectReason == null && !mailboxDatabase.Recovery) { mapiSession.Administration.SyncMailboxWithDS(mailboxDatabase.Guid, mailboxStatistics.MailboxGuid); using (MailboxStatistics mailboxStatistics2 = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(this.SourceStoreMailbox, mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(mailboxDatabase), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString())))) { disconnectReason = mailboxStatistics2.DisconnectReason; if (disconnectReason == null) { if (this.targetUser.OrganizationId != null && this.targetUser.OrganizationId.OrganizationalUnit != null && VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Global.MultiTenancy.Enabled) { IRecipientSession recipientSession = CommonUtils.CreateRecipientSession(mailboxStatistics.ExternalDirectoryOrganizationId, null, null); ADRecipient adrecipient = this.TargetIsArchive ? recipientSession.FindByExchangeGuidIncludingArchive(mailboxStatistics.MailboxGuid) : recipientSession.FindByExchangeGuid(mailboxStatistics.MailboxGuid); flag = (adrecipient != null && adrecipient.RecipientSoftDeletedStatus != 0); } if (!this.IsPublicFolderMailboxRestore && !flag) { base.WriteError(new CannotRestoreConnectedMailboxPermanentException(this.SourceStoreMailbox.ToString()), ErrorCategory.InvalidArgument, this.SourceStoreMailbox); } } } } if (flag) { this.restoreFlags |= MailboxRestoreType.SoftDeletedRecipient; } else if (disconnectReason != null) { if (disconnectReason != MailboxState.SoftDeleted) { this.restoreFlags |= MailboxRestoreType.Disabled; } else { this.restoreFlags |= MailboxRestoreType.SoftDeleted; } } this.sourceMailboxGuid = mailboxStatistics.MailboxGuid; this.sourceMailboxDN = mailboxStatistics.LegacyDN; } } if ((this.TargetIsArchive && this.sourceMailboxGuid == this.targetUser.ArchiveGuid && this.sourceDatabase.Equals(this.targetUser.ArchiveDatabase)) || (!this.TargetIsArchive && this.sourceMailboxGuid == this.targetUser.ExchangeGuid && this.sourceDatabase.Equals(this.targetUser.Database))) { base.WriteError(new CannotRestoreIntoSelfPermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox); } } if (this.restoreFlags.HasFlag(MailboxRestoreType.PublicFolderMailbox)) { if (this.targetUser.RecipientTypeDetails != RecipientTypeDetails.PublicFolderMailbox) { base.WriteError(new RecipientTaskException(Strings.ErrorCannotRestoreFromPublicToPrivateMailbox), ErrorCategory.InvalidArgument, this.SourceStoreMailbox); } } else if (this.targetUser.RecipientTypeDetails == RecipientTypeDetails.PublicFolderMailbox) { base.WriteError(new RecipientTaskException(Strings.ErrorCannotRestoreFromPrivateToPublicMailbox), ErrorCategory.InvalidArgument, this.SourceStoreMailbox); } base.RescopeToOrgId(this.targetUser.OrganizationId); if (base.ParameterSetName.Equals("RemoteMailboxRestore")) { base.PerRecordReportEntries.Add(new ReportEntry(MrsStrings.ReportRequestAllowedMismatch(base.ExecutingUserIdentity))); } else { base.ValidateLegacyDNMatch(this.sourceMailboxDN, this.targetUser, this.TargetMailbox); } ADObjectId mdbId = null; ADObjectId mdbServerSite = null; this.LocateAndChooseMdb(null, this.TargetIsArchive ? this.targetUser.ArchiveDatabase : this.targetUser.Database, null, this.TargetMailbox, this.TargetMailbox, out mdbId, out mdbServerSite); base.MdbId = mdbId; base.MdbServerSite = mdbServerSite; base.RequestName = this.CheckRequestNameAvailability(base.RequestName, this.targetUser.Id, true, MRSRequestType.MailboxRestore, this.TargetMailbox, wildcardedSearch); base.InternalValidate(); } finally { TaskLogger.LogExit(); } }
public bool IsMemberOf(IRecipientSession session, Guid adUserObjectGuid, RoutingAddress group) { return(GroupsConfiguration.groupsResolver.Value.IsMemberOf(session, adUserObjectGuid, group)); }
// Token: 0x0600096D RID: 2413 RVA: 0x00037346 File Offset: 0x00035546 internal void SetRecipientSessionForTesting(IRecipientSession recipientSession) { this.recipientSession = recipientSession; }
// Token: 0x060010A1 RID: 4257 RVA: 0x0004423C File Offset: 0x0004243C public static void SaveTextMessagingAccount(TextMessagingAccount account, VersionedXmlDataProvider storeDataProvider, ADRecipient adRecipient, IRecipientSession adSession) { if (account == null) { throw new ArgumentNullException("account"); } if (storeDataProvider == null) { throw new ArgumentNullException("storeDataProvider"); } if (adRecipient == null) { throw new ArgumentNullException("adRecipient"); } if (adSession == null) { throw new ArgumentNullException("adSession"); } bool notificationPhoneNumberVerified = account.NotificationPhoneNumberVerified; bool dupIdentitiesExist = false; account.TextMessagingSettings.DeliveryPoints.Sort(delegate(DeliveryPoint x, DeliveryPoint y) { if (x.Identity == y.Identity) { dupIdentitiesExist = true; } return(x.Identity.CompareTo(y.Identity)); }); if (dupIdentitiesExist) { int num = 0; while (account.TextMessagingSettings.DeliveryPoints.Count > num) { account.TextMessagingSettings.DeliveryPoints[num].Identity = (byte)num; num++; } } TextMessagingHelper.UpdateTextMessagingState(adRecipient.TextMessagingState, account.TextMessagingSettings.DeliveryPoints); storeDataProvider.Save(account); adSession.Save(adRecipient); }
protected override void InternalValidate() { TaskLogger.LogEnter(); try { base.InternalValidate(); if (!base.HasErrors) { if (MobileDeviceTaskHelper.IsRunningUnderMyOptionsRole(this, base.TenantGlobalCatalogSession, base.SessionSettings)) { ADObjectId id; if (!base.TryGetExecutingUserId(out id)) { throw new ExecutingUserPropertyNotFoundException("executingUserid"); } if (!this.DataObject.Id.Parent.Parent.Equals(id)) { base.WriteError(new LocalizedException(Strings.ErrorObjectNotFound(this.Identity.ToString())), ErrorCategory.InvalidArgument, null); } } IRecipientSession recipientSession = this.CreateTenantGlobalCatalogSession(base.SessionSettings); Exception ex = null; MailboxIdParameter mailboxId = this.Identity.GetMailboxId(); if (mailboxId == null && this.DataObject != null) { this.Identity = new MobileDeviceIdParameter(this.DataObject); mailboxId = this.Identity.GetMailboxId(); } if (mailboxId == null) { base.WriteError(new LocalizedException(Strings.ErrorObjectNotFound(this.Identity.ToString())), ErrorCategory.InvalidArgument, null); } ADUser adObject = null; this.principal = MobileDeviceTaskHelper.GetExchangePrincipal(base.SessionSettings, recipientSession, mailboxId, "Clear-MobileDevice", out ex, out adObject); if (ex != null) { base.WriteError(ex, ErrorCategory.InvalidArgument, null); } IList <LocalizedString> list = null; ADObjectId adobjectId = null; base.TryGetExecutingUserId(out adobjectId); this.validatedAddresses = MobileDeviceTaskHelper.ValidateAddresses(recipientSession, adobjectId, this.NotificationEmailAddresses, out list); if (list != null) { foreach (LocalizedString text in list) { this.WriteWarning(text); } } base.VerifyIsWithinScopes((IDirectorySession)base.DataSession, adObject, true, new DataAccessTask <MobileDevice> .ADObjectOutOfScopeString(Strings.ErrorCannotChangeMailboxOutOfWriteScope)); if (adobjectId != null) { ExchangePrincipal exchangePrincipal = MobileDeviceTaskHelper.GetExchangePrincipal(base.SessionSettings, recipientSession, new MailboxIdParameter(adobjectId), "Clear-MobileDevice", out ex); if (ex != null) { base.WriteWarning(ex.ToString()); } if (exchangePrincipal != null) { this.wipeRequestorSMTP = exchangePrincipal.MailboxInfo.PrimarySmtpAddress.ToString(); } else { this.wipeRequestorSMTP = null; } } } } finally { TaskLogger.LogExit(); } }
public void AddAttachment(Attachment attachment, IRecipientSession adRecipientSession) { bool flag = false; MimePart mimePart = attachment.MimePart; Header header = null; if (mimePart != null) { header = mimePart.Headers.FindFirst("X-MS-Exchange-Organization-Approval-AttachToApprovalRequest"); } string text; if (header != null && header.TryGetValue(out text)) { if (text.Equals("Never")) { return; } if (text.Equals("AsMessage")) { flag = true; } } if (flag) { using (Stream contentReadStream = attachment.GetContentReadStream()) { using (ItemAttachment itemAttachment = (ItemAttachment)this.messageItem.AttachmentCollection.Create(AttachmentType.EmbeddedMessage)) { using (Item item = itemAttachment.GetItem()) { ItemConversion.ConvertAnyMimeToItem(item, contentReadStream, new InboundConversionOptions(Components.Configuration.FirstOrgAcceptedDomainTable.DefaultDomainName) { UserADSession = adRecipientSession }); item[MessageItemSchema.Flags] = MessageFlags.None; item.Save(SaveMode.NoConflictResolution); string valueOrDefault = item.GetValueOrDefault <string>(ItemSchema.Subject); if (!string.IsNullOrEmpty(valueOrDefault)) { itemAttachment[AttachmentSchema.DisplayName] = valueOrDefault; } itemAttachment.Save(); } } return; } } using (StreamAttachment streamAttachment = (StreamAttachment)this.messageItem.AttachmentCollection.Create(AttachmentType.Stream)) { streamAttachment.FileName = attachment.FileName; using (Stream contentStream = streamAttachment.GetContentStream()) { using (Stream contentReadStream2 = attachment.GetContentReadStream()) { ApprovalProcessor.CopyStream(contentReadStream2, contentStream, this.Buffer); } contentStream.Flush(); } streamAttachment.Save(); } }
internal static void SetPreferredCulture(IExchangePrincipal exchangePrincipal, IEnumerable <CultureInfo> preferredCultures, IRecipientSession recipientSession) { ADUser aduser = recipientSession.Read(exchangePrincipal.ObjectId) as ADUser; if (aduser != null) { aduser.Languages.Clear(); foreach (CultureInfo item in preferredCultures) { aduser.Languages.Add(item); } recipientSession.Save(aduser); } }
internal static MultiValuedProperty <string> ConvertSourceMailboxesCollection(IEnumerable <RecipientIdParameter> recipientIds, bool inplaceHoldEnabled, Func <RecipientIdParameter, ADRecipient> recipientGetter, IRecipientSession recipientSession, Task.TaskErrorLoggingDelegate writeErrorDelegate, Action <LocalizedString> writeWarningDelegate, Func <LocalizedString, bool> shouldContinueDelegate) { MultiValuedProperty <string> results = null; if (recipientIds != null) { RecipientType[] source = new RecipientType[] { RecipientType.UserMailbox, RecipientType.Group, RecipientType.MailUniversalDistributionGroup, RecipientType.MailUniversalSecurityGroup, RecipientType.MailNonUniversalGroup, RecipientType.DynamicDistributionGroup }; bool flag = false; foreach (RecipientIdParameter arg in recipientIds) { if (results == null) { results = new MultiValuedProperty <string>(); } ADRecipient adrecipient = recipientGetter(arg); string text = null; ADSessionSettings sessionSettings = adrecipient.OrganizationId.ToADSessionSettings(); if (Utils.IsPublicFolderMailbox(adrecipient)) { writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorInvalidRecipientTypeDetails(adrecipient.ToString())), ErrorCategory.InvalidArgument, null); } else if (Utils.IsValidMailboxType(adrecipient)) { if (adrecipient.ExchangeVersion.IsOlderThan(ExchangeObjectVersion.Exchange2012) && !RemoteMailbox.IsRemoteMailbox(adrecipient.RecipientTypeDetails) && ExchangePrincipal.FromADUser(sessionSettings, (ADUser)adrecipient, RemotingOptions.AllowCrossSite).MailboxInfo.Location.ServerVersion < Server.E15MinVersion) { writeErrorDelegate(new MailboxSearchTaskException(Strings.SourceMailboxMustBeE15OrLater(adrecipient.DisplayName)), ErrorCategory.InvalidArgument, null); } text = adrecipient.LegacyExchangeDN; } else if (source.Contains(adrecipient.RecipientType)) { if (inplaceHoldEnabled) { if (!flag) { if (shouldContinueDelegate(Strings.ShouldContinueToExpandGroupsForHold)) { flag = true; } else { writeErrorDelegate(new MailboxSearchTaskException(Strings.GroupsIsNotAllowedForHold(adrecipient.DisplayName)), ErrorCategory.InvalidArgument, null); } } bool invalidTypeSkipped = false; bool oldVersionMailboxSkipped = false; ADRecipientExpansion adrecipientExpansion = new ADRecipientExpansion(new PropertyDefinition[] { ADRecipientSchema.LegacyExchangeDN, ADRecipientSchema.RecipientTypeDetailsValue, ADObjectSchema.ExchangeVersion }, adrecipient.OrganizationId); adrecipientExpansion.Expand(adrecipient, delegate(ADRawEntry expandedRecipient, ExpansionType expansionType, ADRawEntry parent, ExpansionType parentType) { if (expansionType == ExpansionType.GroupMembership) { return(ExpansionControl.Continue); } if (Utils.IsValidMailboxType(expandedRecipient)) { ExchangeObjectVersion exchangeObjectVersion = (ExchangeObjectVersion)expandedRecipient[ADObjectSchema.ExchangeVersion]; string text2 = (string)expandedRecipient[ADRecipientSchema.LegacyExchangeDN]; if (!oldVersionMailboxSkipped && exchangeObjectVersion.IsOlderThan(ExchangeObjectVersion.Exchange2012) && !RemoteMailbox.IsRemoteMailbox((RecipientTypeDetails)expandedRecipient[ADRecipientSchema.RecipientTypeDetails]) && ExchangePrincipal.FromLegacyDN(sessionSettings, text2).MailboxInfo.Location.ServerVersion < Server.E15MinVersion) { oldVersionMailboxSkipped = true; writeWarningDelegate(Strings.OldVersionMailboxSkipped); } if (!results.Contains(text2)) { results.Add(text2); } } else if (!invalidTypeSkipped) { invalidTypeSkipped = true; writeWarningDelegate(Strings.SkippingInvalidTypeInGroupExpansion); } return(ExpansionControl.Skip); }, delegate(ExpansionFailure failure, ADRawEntry expandedRecipient, ExpansionType expansionType, ADRawEntry parent, ExpansionType parentType) { TaskLogger.Trace("Skipping invalid AD entry {0} because of failure: {1}", new object[] { expandedRecipient, failure }); return(ExpansionControl.Skip); }); } else { text = adrecipient.LegacyExchangeDN; } } else { writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorInvalidRecipientType(adrecipient.ToString(), adrecipient.RecipientType.ToString())), ErrorCategory.InvalidArgument, null); } if (text != null && !results.Contains(text)) { results.Add(text); } if (results.Count > Utils.MaxNumberOfMailboxesInSingleHold) { writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorTooManyMailboxesInSingleHold(Utils.MaxNumberOfMailboxesInSingleHold)), ErrorCategory.InvalidArgument, null); } } if (results != null) { uint discoveryMaxMailboxes = SearchUtils.GetDiscoveryMaxMailboxes(recipientSession); if ((long)results.Count > (long)((ulong)discoveryMaxMailboxes) && !shouldContinueDelegate(Strings.ShouldContinueMoreMailboxesThanMaxSearch(results.Count, discoveryMaxMailboxes))) { writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorTaskCancelledBecauseMoreMailboxesThanSearchSupported), ErrorCategory.InvalidArgument, null); } } } return(results); }
public GroupConfiguration GetGroupInformation(string group) { IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.organizationId), 58, "GetGroupInformation", "f:\\15.00.1497\\sources\\dev\\infoworker\\src\\common\\OrganizationConfiguration\\GroupsConfiguration.cs"); return(this.GetGroupInformation(tenantOrRootOrgRecipientSession, group)); }
// Token: 0x060019D6 RID: 6614 RVA: 0x0006CEEC File Offset: 0x0006B0EC internal ADMicrosoftExchangeRecipient(IRecipientSession session, PropertyBag propertyBag) : base(session, propertyBag) { }
public GroupConfiguration GetGroupInformation(IRecipientSession session, string group) { return(GroupsConfiguration.groupsResolver.Value.GetGroupInfo(session, (RoutingAddress)group)); }
internal static void FillDisplayNames(List <MessageTrackingSearchResult> results, IRecipientSession recipSession) { BulkRecipientLookupCache bulkRecipientLookupCache = new BulkRecipientLookupCache(100); foreach (MessageTrackingSearchResult messageTrackingSearchResult in results) { IEnumerable <string> addresses = from address in messageTrackingSearchResult.RecipientAddresses select address.ToString(); messageTrackingSearchResult.RecipientDisplayNames = bulkRecipientLookupCache.Resolve(addresses, recipSession).ToArray <string>(); } }
public AggregationSubscriptionDataProvider CreateSubscriptionDataProvider(AggregationType aggregationType, AggregationTaskType taskType, IRecipientSession session, ADUser adUser) { if (aggregationType <= AggregationType.Migration) { if (aggregationType != AggregationType.Aggregation && aggregationType != AggregationType.Migration) { goto IL_33; } } else { if (aggregationType == AggregationType.PeopleConnection) { return(new ConnectSubscriptionDataProvider(taskType, session, adUser)); } if (aggregationType != AggregationType.All) { goto IL_33; } } return(new AggregationSubscriptionDataProvider(taskType, session, adUser)); IL_33: throw new InvalidOperationException("Invalid Aggregation Type:" + aggregationType); }