private void UpdateHold(Guid id, bool add)
{
try
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(false, ConsistencyMode.PartiallyConsistent, this.RecipientSession.SessionSettings, 418, "UpdateHold", "f:\\15.00.1497\\sources\\dev\\data\\src\\ApplicationLogic\\Compliance\\ExMailboxComplianceItemContainer.cs");
ADRecipient adUser = ExMailboxComplianceItemContainer.GetAdUser(tenantOrRootOrgRecipientSession, this.ExternalDirectoryObjectId, add);
string holdId = ExMailboxComplianceItemContainer.GetHoldId(id);
if (add)
{
MailboxDiscoverySearch.AddInPlaceHold(adUser, holdId, tenantOrRootOrgRecipientSession);
}
else
{
MailboxDiscoverySearch.RemoveInPlaceHold(adUser, holdId, tenantOrRootOrgRecipientSession);
}
}
catch (ComplianceTaskPermanentException)
{
throw;
}
catch (Exception ex)
{
ExTraceGlobals.StorageTracer.TraceError <string, Exception, string>(0L, "Failed to {2} hold on mailbox '{0}'. Exception: {1}", this.ExternalDirectoryObjectId, ex, add ? "place" : "remove");
throw new ComplianceTaskPermanentException(string.Format("Failed to {0} hold on mailbox '{1}'", add ? "place" : "remove", this.ExternalDirectoryObjectId), ex, UnifiedPolicyErrorCode.Unknown);
}
}
private IDictionary <string, QueryFilter> GetSubQueryString(ICollection <QueryFilter> filters)
{
int maxAllowedKeywords = Factory.Current.GetMaxAllowedKeywords(this.RecipientSession);
if (filters.Count > maxAllowedKeywords)
{
throw new TooManyKeywordsException(filters.Count, maxAllowedKeywords);
}
int num = 0;
Dictionary <string, QueryFilter> dictionary = new Dictionary <string, QueryFilter>(filters.Count);
foreach (QueryFilter queryFilter in filters)
{
string keywordPhrase = MailboxDiscoverySearch.GetKeywordPhrase(queryFilter, this.queryString, ref num);
QueryFilter value = queryFilter;
if (this.propertyFilterQuery != null)
{
value = new AndFilter(new QueryFilter[]
{
queryFilter,
this.propertyFilterQuery
});
}
if (!dictionary.ContainsKey(keywordPhrase))
{
dictionary.Add(keywordPhrase, value);
}
}
return(dictionary);
}
public void LogInPlaceHoldSettingsSynchronizedEvent(MailboxDiscoverySearch obj)
{
SearchEventLogger.PropertyLogData propertyLogData = new SearchEventLogger.PropertyLogData();
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.InPlaceHoldEnabled.Name, obj.InPlaceHoldEnabled);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ItemHoldPeriod.Name, obj.ItemHoldPeriod);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.InPlaceHoldErrors.Name, obj.InPlaceHoldErrors);
propertyLogData.AddOrganization(obj.ManagedByOrganization);
this.logger.LogEvent(StorageEventLogConstants.Tuple_InPlaceHoldSettingsSynchronized, null, new object[]
{
propertyLogData
});
if (obj.InPlaceHoldErrors != null && obj.InPlaceHoldErrors.Count > 0)
{
foreach (string stringToEscape in obj.InPlaceHoldErrors)
{
string value = Uri.EscapeDataString(stringToEscape);
SearchEventLogger.PropertyLogData propertyLogData2 = new SearchEventLogger.PropertyLogData();
propertyLogData2.AddOrganization(obj.ManagedByOrganization);
propertyLogData2.AddProperty("Error", value);
this.logger.LogEvent(StorageEventLogConstants.Tuple_SynchronizeInPlaceHoldError, null, new object[]
{
propertyLogData2
});
}
}
}
// Token: 0x06000160 RID: 352 RVA: 0x00009890 File Offset: 0x00007A90
public InPlaceHoldConfiguration(MailboxDiscoverySearch searchObject)
{
this.Name = searchObject.Name;
this.Identity = searchObject.InPlaceHoldIdentity;
this.Enabled = searchObject.InPlaceHoldEnabled;
this.IsValid = searchObject.IsValid;
if (this.IsValid)
{
this.QueryString = searchObject.Query;
this.QueryFilter = searchObject.InternalQueryFilter;
if (!searchObject.ItemHoldPeriod.IsUnlimited)
{
QueryFilter retentionPeriodFilter = MailboxDiscoverySearch.GetRetentionPeriodFilter(searchObject.ItemHoldPeriod.Value);
if (this.QueryFilter == null)
{
this.QueryFilter = retentionPeriodFilter;
return;
}
this.QueryFilter = new AndFilter(new QueryFilter[]
{
retentionPeriodFilter,
this.QueryFilter
});
}
}
}
internal static void CheckSearchRunningStatus(MailboxDiscoverySearch dataObject, Task.TaskErrorLoggingDelegate writeErrorDelegate, LocalizedString errorMessage)
{
if (dataObject.Status == SearchState.Queued || dataObject.Status == SearchState.EstimateInProgress || dataObject.Status == SearchState.InProgress || dataObject.Status == SearchState.EstimateStopping || dataObject.Status == SearchState.Stopping || dataObject.Status == SearchState.DeletionInProgress)
{
writeErrorDelegate(new MailboxSearchTaskException(errorMessage), ErrorCategory.InvalidOperation, dataObject);
}
}
internal void GenerateSubQueryFilters(IRecipientSession recipientSession, IConfigurationSession configurationSession)
{
if (!string.IsNullOrEmpty(this.userQuery))
{
SearchMailboxCriteria.RecipientIdentityResolver recipientResolver = null;
if (recipientSession != null)
{
recipientResolver = new SearchMailboxCriteria.RecipientIdentityResolver(recipientSession);
}
PolicyTagAdProvider policyTagProvider = null;
if (configurationSession != null)
{
policyTagProvider = new PolicyTagAdProvider(configurationSession);
}
QueryFilter queryFilter = KqlParser.ParseAndBuildQuery(this.userQuery, KqlParser.ParseOption.ImplicitOr | KqlParser.ParseOption.UseCiKeywordOnly | KqlParser.ParseOption.DisablePrefixMatch | KqlParser.ParseOption.AllowShortWildcards | KqlParser.ParseOption.EDiscoveryMode, this.QueryCulture, RescopedAll.Default, recipientResolver, policyTagProvider);
if (queryFilter == null)
{
throw new SearchQueryEmptyException();
}
ICollection <QueryFilter> collection = null;
if (queryFilter != null && queryFilter.GetType() == typeof(OrFilter))
{
collection = AqsParser.FlattenQueryFilter(queryFilter);
}
if (collection != null && collection.Count > 1)
{
string text = this.searchQuery.Replace(this.userQuery, "");
QueryFilter queryFilter2 = null;
if (!string.IsNullOrEmpty(text))
{
queryFilter2 = KqlParser.ParseAndBuildQuery(text, KqlParser.ParseOption.ImplicitOr | KqlParser.ParseOption.UseCiKeywordOnly | KqlParser.ParseOption.DisablePrefixMatch | KqlParser.ParseOption.AllowShortWildcards | KqlParser.ParseOption.EDiscoveryMode, this.QueryCulture, RescopedAll.Default, recipientResolver, policyTagProvider);
}
this.subfilters = new Dictionary <string, QueryFilter>(collection.Count);
int num = 0;
foreach (QueryFilter queryFilter3 in collection)
{
string keywordPhrase = MailboxDiscoverySearch.GetKeywordPhrase(queryFilter3, this.userQuery, ref num);
QueryFilter value;
if (queryFilter2 == null)
{
value = queryFilter3;
}
else
{
value = new AndFilter(new QueryFilter[]
{
queryFilter2,
queryFilter3
});
}
if (!this.subfilters.ContainsKey(keywordPhrase))
{
this.subfilters.Add(keywordPhrase, value);
}
}
}
}
}
public void LogDiscoverySearchRemoveRequestedEvent(MailboxDiscoverySearch obj, string rbacContext)
{
SearchEventLogger.PropertyLogData propertyLogData = new SearchEventLogger.PropertyLogData();
propertyLogData.AddProperty("RbacContext", rbacContext);
propertyLogData.AddOrganization(obj.ManagedByOrganization);
this.logger.LogEvent(StorageEventLogConstants.Tuple_DiscoverySearchRemoveRequested, null, new object[]
{
propertyLogData
});
}
public override SearchErrorInfo UpdateStatus(SearchId searchId)
{
MailboxSearchServer.Tracer.TraceFunction <string>((long)this.GetHashCode(), "MailboxSearchServer.UpdateStatus on {0}", searchId.SearchName);
SearchErrorInfo errorInfo = null;
SearchUtils.ExWatsonWrappedCall(delegate()
{
lock (this)
{
if (this.searchWorkItemMap.ContainsKey(searchId) || this.pendingSearchIdMap.ContainsKey(searchId))
{
MailboxSearchServer.Tracer.TraceDebug <string>((long)this.GetHashCode(), "The search {0} is still in the queue. Not updating status", searchId.SearchName);
}
else
{
try
{
ADObjectId discoverySystemMailboxId = new ADObjectId(searchId.MailboxDsName, searchId.MailboxGuid);
IMailboxSearchConfigurationProvider mailboxSearchConfigurationProvider = new MailboxSearchConfigurationProvider(discoverySystemMailboxId, searchId.SearchName);
if (MailboxDiscoverySearch.IsInProgressState(mailboxSearchConfigurationProvider.SearchObject.Status))
{
mailboxSearchConfigurationProvider.SearchObject.UpdateState(SearchStateTransition.Fail);
mailboxSearchConfigurationProvider.UpdateSearchObject("UpdateStatus", 452);
}
else if (MailboxDiscoverySearch.IsInDeletionState(mailboxSearchConfigurationProvider.SearchObject.Status))
{
this.QueueSearchForDeletion(searchId, true, ref errorInfo);
}
}
catch (FormatException exception)
{
errorInfo = new SearchErrorInfo(-2147220990, exception);
}
catch (SearchObjectNotFoundException exception2)
{
errorInfo = new SearchErrorInfo(-2147220990, exception2);
}
catch (DataSourceOperationException exception3)
{
errorInfo = new SearchErrorInfo(-2147220990, exception3);
}
catch (NoInternalEwsAvailableException exception4)
{
errorInfo = new SearchErrorInfo(-2147220990, exception4);
}
}
}
});
if (errorInfo != null && errorInfo.Failed)
{
MailboxSearchServer.LogErrorInfo("Error occured when trying to update the status of the search workitem", searchId, errorInfo);
}
return(errorInfo);
}
private static string[] GetStatusMailRecipients(MailboxDiscoverySearch searchObject, IRecipientSession recipientSession)
{
return((from r in searchObject.StatusMailRecipients.Select(delegate(ADObjectId recipientId)
{
ADRecipient adrecipient = recipientSession.Read(recipientId);
if (adrecipient == null)
{
Util.Tracer.TraceWarning <ADObjectId>((long)searchObject.GetHashCode(), "Unable to find status mail recipient '{0}'", recipientId);
return null;
}
return adrecipient.PrimarySmtpAddress.ToString();
})
where r != null
select r).ToArray <string>());
}
public void LogDiscoverySearchStatusChangedEvent(MailboxDiscoverySearch obj, string parentCallerInfo, [CallerMemberName] string callerMember = null)
{
SearchEventLogger.PropertyLogData propertyLogData = new SearchEventLogger.PropertyLogData();
propertyLogData.AddProperty("CallerInfo", parentCallerInfo + ": " + callerMember);
propertyLogData.AddProperty(EwsStoreObjectSchema.Identity.Name, obj.Identity);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Status.Name, obj.Status);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.StatisticsOnly.Name, obj.StatisticsOnly);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.IncludeUnsearchableItems.Name, obj.IncludeUnsearchableItems);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.IncludeKeywordStatistics.Name, obj.IncludeKeywordStatistics);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Query.Name, (obj.Query != null) ? obj.Query.Length : 0);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Language.Name, obj.Language);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Sources.Name, obj.Sources);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.CreatedTime.Name, obj.CreatedTime);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.LastModifiedTime.Name, obj.LastModifiedTime);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ExcludeDuplicateMessages.Name, obj.ExcludeDuplicateMessages);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.InPlaceHoldEnabled.Name, obj.InPlaceHoldEnabled);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ItemHoldPeriod.Name, obj.ItemHoldPeriod);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.InPlaceHoldIdentity.Name, obj.InPlaceHoldIdentity);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.FailedToHoldMailboxes.Name, obj.FailedToHoldMailboxes);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.KeywordHits.Name, (obj.KeywordHits != null) ? obj.KeywordHits.Count : 0);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ScenarioId.Name, obj.ScenarioId);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Resume.Name, obj.Resume);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.LastStartTime.Name, obj.LastStartTime);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.LastEndTime.Name, obj.LastEndTime);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.PercentComplete.Name, obj.PercentComplete);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.NumberOfMailboxes.Name, obj.NumberOfMailboxes);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ResultItemCountCopied.Name, obj.ResultItemCountCopied);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ResultItemCountEstimate.Name, obj.ResultItemCountEstimate);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ResultSizeCopied.Name, obj.ResultSizeCopied);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ResultSizeEstimate.Name, obj.ResultSizeEstimate);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ResultsPath.Name, obj.ResultsPath);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ResultsLink.Name, obj.ResultsLink);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.CompletedMailboxes.Name, obj.CompletedMailboxes);
propertyLogData.AddOrganization(obj.ManagedByOrganization);
if (obj.Errors != null && obj.Errors.Count > 0)
{
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Errors.Name, string.Join(",", obj.Errors.ToArray()));
}
if (obj.IsFeatureFlighted("SearchStatsFlighted") && obj.SearchStatistics != null && obj.SearchStatistics.Count > 0 && obj.SearchStatistics[0] != null)
{
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.SearchStatistics.Name, obj.SearchStatistics[0].ToString());
}
propertyLogData.AddProperty("Flighted Features", obj.FlightedFeatures);
this.logger.LogEvent(StorageEventLogConstants.Tuple_DiscoverySearchStatusChanged, null, new object[]
{
propertyLogData
});
}
private void InternalCreateOrUpdateSearchLogEmail(MailboxDiscoverySearch searchObject, List <string> successfulMailboxes, List <string> unsuccessfulMailboxes, bool updateIfExists)
{
BaseFolderType baseFolderType = this.CreateRootResultFolderIfNotExist();
if (string.IsNullOrEmpty(this.logItemId))
{
this.logItemId = this.CreateSearchLogEmail(baseFolderType.FolderId, searchObject, successfulMailboxes, unsuccessfulMailboxes);
return;
}
ItemType item = this.ewsClient.GetItem(this.PrimarySmtpAddress, this.logItemId);
if (item == null)
{
this.logItemId = this.CreateSearchLogEmail(baseFolderType.FolderId, searchObject, successfulMailboxes, unsuccessfulMailboxes);
return;
}
this.logItemId = item.ItemId.Id;
if (updateIfExists)
{
ItemChangeType itemChangeType = new ItemChangeType
{
Item = item.ItemId,
Updates = new ItemChangeDescriptionType[]
{
new SetItemFieldType
{
Item = new PathToUnindexedFieldType
{
FieldURI = UnindexedFieldURIType.itemBody
},
Item1 = new MessageType
{
Body = new BodyType
{
BodyType1 = BodyTypeType.HTML,
Value = Util.CreateLogMailBody(searchObject, this.StatusMailRecipients, successfulMailboxes, unsuccessfulMailboxes, this.ExportContext.Sources)
}
}
}
}
};
this.ewsClient.UpdateItems(this.PrimarySmtpAddress, baseFolderType.FolderId, new ItemChangeType[]
{
itemChangeType
});
}
}
private string CreateSearchLogEmail(FolderIdType folderId, MailboxDiscoverySearch searchObject, List <string> successfulMailboxes, List <string> unsuccessfulMailboxes)
{
ItemType itemType = new ItemType
{
Subject = string.Format("{0}-{1}", searchObject.Name, searchObject.LastStartTime.ToString()),
Body = new BodyType
{
BodyType1 = BodyTypeType.HTML,
Value = Util.CreateLogMailBody(searchObject, this.StatusMailRecipients, successfulMailboxes, unsuccessfulMailboxes, this.ExportContext.Sources)
}
};
List <ItemType> list = this.ewsClient.CreateItems(this.PrimarySmtpAddress, folderId, new ItemType[]
{
itemType
});
return(list[0].ItemId.Id);
}
internal static void ResetSearchResults(MailboxDiscoverySearch discoverySearchObject)
{
discoverySearchObject.PercentComplete = 0;
discoverySearchObject.ResultItemCountCopied = 0L;
discoverySearchObject.ResultItemCountEstimate = 0L;
discoverySearchObject.ResultSizeCopied = 0L;
discoverySearchObject.ResultSizeEstimate = 0L;
discoverySearchObject.ResultsPath = null;
discoverySearchObject.ResultsLink = null;
discoverySearchObject.SearchStatistics = null;
if (discoverySearchObject.Errors != null)
{
discoverySearchObject.Errors.Clear();
}
if (discoverySearchObject.CompletedMailboxes != null)
{
discoverySearchObject.CompletedMailboxes.Clear();
}
}
internal MailboxSearchObject(MailboxDiscoverySearch discoverySearch, OrganizationId orgId)
{
if (discoverySearch == null)
{
throw new ArgumentNullException("discoverySearch");
}
this.discoverySearch = discoverySearch;
if (orgId != null)
{
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopes(ADSystemConfigurationSession.GetRootOrgContainerIdForLocalForest(), orgId, null, false);
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(true, ConsistencyMode.PartiallyConsistent, sessionSettings, 791, ".ctor", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\Search\\MailboxSearch\\MailboxSearchObject.cs");
if (this.discoverySearch.Sources != null && this.discoverySearch.Sources.Count > 0)
{
if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled)
{
tenantOrRootOrgRecipientSession.SessionSettings.IncludeInactiveMailbox = true;
}
Result <ADRawEntry>[] array = tenantOrRootOrgRecipientSession.FindByLegacyExchangeDNs(this.discoverySearch.Sources.ToArray(), null);
if (array != null && array.Length > 0)
{
this.sourceMailboxes = new MultiValuedProperty <ADObjectId>();
for (int i = 0; i < array.Length; i++)
{
if (array[i].Data != null)
{
this.sourceMailboxes.Add(array[i].Data.Id);
}
}
}
}
if (!string.IsNullOrEmpty(this.discoverySearch.Target))
{
tenantOrRootOrgRecipientSession.SessionSettings.IncludeInactiveMailbox = false;
ADRawEntry adrawEntry = tenantOrRootOrgRecipientSession.FindByLegacyExchangeDN(this.discoverySearch.Target);
if (adrawEntry != null)
{
this.targetMailbox = adrawEntry.Id;
}
}
}
}
private static void BuildResultNumbersEx(StringBuilder sbLogMailBody, MailboxDiscoverySearch searchObject)
{
DiscoverySearchStats discoverySearchStats = null;
if (searchObject.SearchStatistics != null)
{
if (searchObject.SearchStatistics.Count == 0)
{
searchObject.SearchStatistics.Add(new DiscoverySearchStats());
}
discoverySearchStats = searchObject.SearchStatistics[0];
}
if (discoverySearchStats == null)
{
Util.Tracer.TraceWarning((long)searchObject.GetHashCode(), "searchObject does not contain SearchStatistics");
throw new CorruptDataException(ServerStrings.ErrorCorruptedData("searchObject"));
}
Util.ReplaceLogFieldTags(sbLogMailBody, Globals.LogFields.ResultNumber, string.Empty);
sbLogMailBody = sbLogMailBody.Replace(", " + Globals.LogFields.ResultNumberEstimate.ToLabelTag(), string.Empty);
Util.ReplaceLogFieldTags(sbLogMailBody, Globals.LogFields.ResultNumberEstimate, string.Empty);
Util.ReplaceLogFieldTags(sbLogMailBody, Globals.LogFields.EstimateNotExcludeDuplicates, discoverySearchStats.ToHtmlString());
}
public void LogDiscoveryAndHoldSavedEvent(MailboxDiscoverySearch obj)
{
SearchEventLogger.PropertyLogData propertyLogData = new SearchEventLogger.PropertyLogData();
propertyLogData.AddProperty(EwsStoreObjectSchema.Identity.Name, obj.Identity);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.StatisticsOnly.Name, obj.StatisticsOnly);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.IncludeUnsearchableItems.Name, obj.IncludeUnsearchableItems);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.IncludeKeywordStatistics.Name, obj.IncludeKeywordStatistics);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.LogLevel.Name, obj.LogLevel);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Query.Name, (obj.Query != null) ? obj.Query.Length : 0);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.Language.Name, obj.Language);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.CreatedTime.Name, obj.CreatedTime);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.LastModifiedTime.Name, obj.LastModifiedTime);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ExcludeDuplicateMessages.Name, obj.ExcludeDuplicateMessages);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.InPlaceHoldEnabled.Name, obj.InPlaceHoldEnabled);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.ItemHoldPeriod.Name, obj.ItemHoldPeriod);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.InPlaceHoldIdentity.Name, obj.InPlaceHoldIdentity);
propertyLogData.AddProperty(MailboxDiscoverySearchSchema.KeywordHits.Name, (obj.KeywordHits != null) ? obj.KeywordHits.Count : 0);
propertyLogData.AddOrganization(obj.ManagedByOrganization);
this.logger.LogEvent(StorageEventLogConstants.Tuple_DiscoveryAndHoldSaved, null, new object[]
{
propertyLogData
});
}
// Token: 0x060005CE RID: 1486 RVA: 0x0002BED4 File Offset: 0x0002A0D4
private QueryFilter ConstructSearchFilter()
{
List <QueryFilter> list = new List <QueryFilter>();
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.Equal, ItemSchema.SearchIsPartiallyIndexed, true);
foreach (InPlaceHoldConfiguration inPlaceHoldConfiguration in this.AllInPlaceHoldConfiguration)
{
if (inPlaceHoldConfiguration.QueryFilter != null)
{
list.Add(inPlaceHoldConfiguration.QueryFilter);
}
}
if (this.IsOnLitigationHoldWithDuration())
{
QueryFilter retentionPeriodFilter = MailboxDiscoverySearch.GetRetentionPeriodFilter(base.MailboxDataForTags.LitigationHoldDuration.Value.Value);
list.Add(retentionPeriodFilter);
}
QueryFilter result = null;
if (list.Count > 0)
{
if (list.Count == 1)
{
result = QueryFilter.NotFilter(new OrFilter(new QueryFilter[]
{
list[0],
queryFilter
}));
}
else
{
list.Add(queryFilter);
result = QueryFilter.NotFilter(QueryFilter.OrTogether(list.ToArray()));
}
}
return(result);
}
private static void BuildResultNumbers(StringBuilder sbLogMailBody, MailboxDiscoverySearch searchObject, KeywordHit unsearchableHit)
{
if (searchObject.IsFeatureFlighted("SearchStatsFlighted"))
{
Util.BuildResultNumbersEx(sbLogMailBody, searchObject);
return;
}
Util.ReplaceLogFieldTags(sbLogMailBody, Globals.LogFields.ResultNumberEstimate, searchObject.ResultItemCountEstimate);
if (searchObject.ExcludeDuplicateMessages)
{
Util.ReplaceLogFieldTags(sbLogMailBody, Globals.LogFields.EstimateNotExcludeDuplicates, Strings.LogFieldsEstimateNotExcludeDuplicates);
}
else
{
Util.ReplaceLogFieldTags(sbLogMailBody, Globals.LogFields.EstimateNotExcludeDuplicates, string.Empty);
}
string value = searchObject.ResultItemCountCopied.ToString();
if (unsearchableHit != null)
{
value = string.Format(Strings.MailboxSeachCountIncludeUnsearchable, searchObject.ResultItemCountCopied, unsearchableHit.Count);
}
Util.ReplaceLogFieldTags(sbLogMailBody, Globals.LogFields.ResultNumber, value);
}
public MailboxSearchConfigurationProvider(ADObjectId discoverySystemMailboxId, string searchName, IDiscoverySearchDataProvider searchDataProvider, MailboxDiscoverySearch searchObject)
{
Util.ThrowIfNullOrEmpty(searchName, "searchName");
this.discoverySystemMailboxId = discoverySystemMailboxId;
if (discoverySystemMailboxId != null)
{
OrganizationId organizationId = this.ResolveOrganization(discoverySystemMailboxId);
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId);
if (organizationId.Equals(OrganizationId.ForestWideOrgId))
{
adsessionSettings = ADSessionSettings.RescopeToSubtree(adsessionSettings);
}
if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled)
{
adsessionSettings.IncludeInactiveMailbox = true;
}
this.recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.PartiallyConsistent, adsessionSettings, 146, ".ctor", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\MailboxSearch\\Common\\MailboxSearchConfigurationProvider.cs");
}
this.SearchDataProvider = searchDataProvider;
if (this.SearchDataProvider == null)
{
this.SearchDataProvider = new DiscoverySearchDataProvider(this.DiscoverySystemMailboxUser.OrganizationId);
}
this.SearchObject = searchObject;
if (this.SearchObject == null)
{
this.SearchObject = this.SearchDataProvider.Find <MailboxDiscoverySearch>(searchName);
if (this.SearchObject == null)
{
Util.Tracer.TraceError <string>((long)this.GetHashCode(), "Unable to find SearchObject {0}", searchName);
throw new SearchObjectNotFoundException(Strings.UnableToFindSearchObject(searchName));
}
}
}
internal static ITargetMailbox CreateTargetMailbox(IRecipientSession recipientSession, MailboxDiscoverySearch searchObject, string targetLegacyDn, ITargetLocation targetLocation)
{
Util.ThrowIfNull(recipientSession, "recipientSession");
Util.ThrowIfNull(searchObject, "searchObject");
Util.ThrowIfNullOrEmpty(targetLegacyDn, "targetLegacyDn");
Util.ThrowIfNull(targetLocation, "targetLocation");
ADSessionSettings sessionSettings = recipientSession.SessionSettings;
Util.ThrowIfNull(sessionSettings, "adSessionSettings");
ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromLegacyDN(sessionSettings, targetLegacyDn, RemotingOptions.AllowCrossSite);
if (exchangePrincipal == null || string.IsNullOrEmpty(exchangePrincipal.MailboxInfo.Location.ServerFqdn))
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFoundId(targetLegacyDn));
}
return(new TargetMailbox(exchangePrincipal.MailboxInfo.OrganizationId, exchangePrincipal.MailboxInfo.PrimarySmtpAddress.ToString(), targetLegacyDn, BackEndLocator.GetBackEndWebServicesUrl(exchangePrincipal.MailboxInfo), targetLocation)
{
StatusMailRecipients = Util.GetStatusMailRecipients(searchObject, recipientSession)
});
}
internal static Exception ValidateSourceAndTargetMailboxes(DiscoverySearchDataProvider dataProvider, MailboxDiscoverySearch dataObject)
{
if (dataObject.Sources.Contains(dataProvider.LegacyDistinguishedName))
{
return(new MailboxSearchTaskException(ServerStrings.DiscoveryMailboxCannotBeSourceOrTarget(dataProvider.LegacyDistinguishedName)));
}
if (!string.IsNullOrEmpty(dataObject.Target))
{
if (dataObject.Sources.Contains(dataObject.Target))
{
return(new MailboxSearchTaskException(ServerStrings.SearchTargetInSource));
}
if (dataObject.Target.Equals(dataProvider.LegacyDistinguishedName))
{
return(new MailboxSearchTaskException(ServerStrings.DiscoveryMailboxCannotBeSourceOrTarget(dataProvider.LegacyDistinguishedName)));
}
}
return(null);
}
internal static MailboxDiscoverySearch UpgradeLegacySearchObject(SearchObject searchObject, MailboxDataProvider e14DataProvider, DiscoverySearchDataProvider e15DataProvider, Task.TaskErrorLoggingDelegate writeErrorDelegate, Action <LocalizedString> writeWarningDelegate)
{
MailboxDiscoverySearch mailboxDiscoverySearch = new MailboxDiscoverySearch();
if (e15DataProvider.Find <MailboxDiscoverySearch>(searchObject.Name) != null)
{
mailboxDiscoverySearch.Name = searchObject.Name + Guid.NewGuid().ToString();
}
else
{
mailboxDiscoverySearch.Name = searchObject.Name;
}
mailboxDiscoverySearch.Senders = searchObject.Senders;
mailboxDiscoverySearch.CreatedBy = searchObject.CreatedByEx;
mailboxDiscoverySearch.Description = Strings.UpgradedSearchObjectDescription;
mailboxDiscoverySearch.EndDate = searchObject.EndDate;
mailboxDiscoverySearch.StartDate = searchObject.StartDate;
mailboxDiscoverySearch.ExcludeDuplicateMessages = searchObject.ExcludeDuplicateMessages;
mailboxDiscoverySearch.StatisticsOnly = searchObject.EstimateOnly;
mailboxDiscoverySearch.IncludeUnsearchableItems = searchObject.IncludeUnsearchableItems;
mailboxDiscoverySearch.IncludeKeywordStatistics = searchObject.IncludeKeywordStatistics;
mailboxDiscoverySearch.Language = searchObject.Language.ToString();
mailboxDiscoverySearch.LogLevel = searchObject.LogLevel;
mailboxDiscoverySearch.ManagedBy = searchObject.ManagedBy;
mailboxDiscoverySearch.MessageTypes = searchObject.MessageTypes;
mailboxDiscoverySearch.Query = Utils.ConvertAqsToKql(searchObject.SearchQuery, searchObject.Language);
mailboxDiscoverySearch.Recipients = searchObject.Recipients;
mailboxDiscoverySearch.StatusMailRecipients = searchObject.StatusMailRecipients;
mailboxDiscoverySearch.ManagedByOrganization = e15DataProvider.OrganizationId.ToString();
mailboxDiscoverySearch.LegacySearchObjectIdentity = searchObject.Identity.ToString();
if (searchObject.SourceMailboxes != null && searchObject.SourceMailboxes.Count > 0)
{
MultiValuedProperty <string> multiValuedProperty = new MultiValuedProperty <string>();
Result <ADRawEntry>[] first = e14DataProvider.RecipientSession.ReadMultiple(searchObject.SourceMailboxes.ToArray(), new PropertyDefinition[]
{
ADRecipientSchema.DisplayName,
ADRecipientSchema.LegacyExchangeDN,
ADObjectSchema.ExchangeVersion
});
foreach (ADRawEntry adrawEntry in from x in first
select x.Data)
{
if (adrawEntry != null)
{
if (((ExchangeObjectVersion)adrawEntry[ADObjectSchema.ExchangeVersion]).IsOlderThan(ExchangeObjectVersion.Exchange2012))
{
writeErrorDelegate(new MailboxSearchTaskException(Strings.SourceMailboxMustBeE15OrLater((string)adrawEntry[ADRecipientSchema.DisplayName])), ErrorCategory.InvalidArgument, null);
}
else
{
multiValuedProperty.Add((string)adrawEntry[ADRecipientSchema.LegacyExchangeDN]);
}
}
}
if (multiValuedProperty.Count > 0)
{
mailboxDiscoverySearch.Sources = multiValuedProperty;
}
}
ADUser aduser = null;
if (searchObject.TargetMailbox != null)
{
aduser = (ADUser)e14DataProvider.RecipientSession.Read(searchObject.TargetMailbox);
if (aduser != null)
{
mailboxDiscoverySearch.Target = aduser.LegacyExchangeDN;
}
}
e15DataProvider.CreateOrUpdate <MailboxDiscoverySearch>(mailboxDiscoverySearch);
Exception ex = null;
try
{
if (searchObject.SearchStatus != null)
{
if (!string.IsNullOrEmpty(searchObject.SearchStatus.ResultsPath) && aduser != null)
{
string serverFqdn = ExchangePrincipal.FromADUser(e14DataProvider.RecipientSession.SessionSettings, aduser, RemotingOptions.AllowCrossSite).MailboxInfo.Location.ServerFqdn;
if (!string.IsNullOrEmpty(serverFqdn))
{
goto IL_395;
}
Utils.< > c__DisplayClassc CS$ < > 8__locals1 = new Utils.< > c__DisplayClassc();
CS$ < > 8__locals1.searchId = new SearchId(e14DataProvider.ADUser.Id.DistinguishedName, e14DataProvider.ADUser.Id.ObjectGuid, searchObject.Id.Guid.ToString());
using (MailboxSearchClient client = new MailboxSearchClient(serverFqdn))
{
Utils.RpcCallWithRetry(delegate()
{
client.Remove(CS$ < > 8__locals1.searchId, true);
});
goto IL_395;
}
}
e14DataProvider.Delete(searchObject.SearchStatus);
}
IL_395:
e14DataProvider.Delete(searchObject);
}
catch (RpcConnectionException ex2)
{
ex = ex2;
}
catch (RpcException ex3)
{
ex = ex3;
}
catch (StoragePermanentException ex4)
{
ex = ex4;
}
catch (StorageTransientException ex5)
{
ex = ex5;
}
if (ex != null)
{
writeWarningDelegate(Strings.FailedToDeleteE14SearchObjectWhenUpgrade(searchObject.Name, ex.Message));
}
return(e15DataProvider.FindByAlternativeId <MailboxDiscoverySearch>(searchObject.Name));
}
private static string CreateMailBody(string templateName, MailboxDiscoverySearch searchObject, string[] statusMailRecipients, List <string> successfulMailboxes, List <string> unsuccessfulMailboxes, IList <ISource> srcMailboxes)
{
Util.ThrowIfNullOrEmpty(templateName, "templateName");
Util.ThrowIfNull(searchObject, "searchObject");
StringBuilder stringBuilder = new StringBuilder();
using (StreamReader streamReader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(templateName)))
{
stringBuilder.Append(streamReader.ReadToEnd());
}
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.Identity, searchObject.Identity.ToString());
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.LastStartTime, searchObject.LastStartTime);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.LastEndTime, searchObject.LastEndTime);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.CreatedBy, searchObject.CreatedBy);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.Name, searchObject.Name);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.SearchQuery, searchObject.Query);
string text = searchObject.Senders.AggregateOfDefault((string s, string x) => s + ", " + x);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.Senders, text.ValueOrDefault(Strings.LogMailAll));
text = searchObject.Recipients.AggregateOfDefault((string s, string x) => s + ", " + x);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.Recipients, text.ValueOrDefault(Strings.LogMailAll));
text = ((searchObject.StartDate != null) ? string.Format("{0}, {0:%z}", searchObject.StartDate.Value) : Strings.LogMailBlank);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.StartDate, text);
text = ((searchObject.EndDate != null) ? string.Format("{0}, {0:%z}", searchObject.EndDate.Value) : Strings.LogMailBlank);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.EndDate, text);
text = (from x in searchObject.MessageTypes
select x.ToString()).AggregateOfDefault((string s, string x) => s + ", " + x);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.MessageTypes, text.ValueOrDefault(Strings.LogMailAll));
if (searchObject.StatisticsOnly)
{
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.TargetMailbox, Strings.LogMailNone);
}
else
{
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.TargetMailbox, searchObject.Target);
}
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.LogLevel, searchObject.LogLevel);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.ExcludeDuplicateMessages, searchObject.ExcludeDuplicateMessages);
StringBuilder sb = stringBuilder;
Globals.LogFields logField = Globals.LogFields.SourceRecipients;
object value;
if (srcMailboxes != null)
{
value = string.Join(", ", (from src in srcMailboxes
select src.Id).ToArray <string>());
}
else
{
value = null;
}
Util.ReplaceLogFieldTags(sb, logField, value);
text = statusMailRecipients.AggregateOfDefault((string s, string x) => s + ", " + x);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.StatusMailRecipients, text.ValueOrDefault(Strings.LogMailNone));
text = (from x in searchObject.ManagedBy
select x.ToString()).AggregateOfDefault((string s, string x) => s + ", " + x);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.ManagedBy, text.ValueOrDefault(Strings.LogMailNone));
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.LastRunBy, searchObject.LastModifiedBy);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.NumberMailboxesToSearch, searchObject.NumberOfMailboxes);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.NumberSuccessfulMailboxes, (successfulMailboxes == null) ? 0 : successfulMailboxes.Count);
text = null;
if (successfulMailboxes != null && successfulMailboxes.Count > 0)
{
text = (from x in successfulMailboxes
select x).AggregateOfDefault((string s, string x) => s + ", " + x);
}
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.SuccessfulMailboxes, string.IsNullOrEmpty(text) ? Strings.LogMailNone : text);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.NumberUnsuccessfulMailboxes, (unsuccessfulMailboxes == null) ? 0 : unsuccessfulMailboxes.Count);
text = null;
if (unsuccessfulMailboxes != null && unsuccessfulMailboxes.Count > 0)
{
text = (from x in unsuccessfulMailboxes
select x).AggregateOfDefault((string s, string x) => s + ", " + x);
}
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.UnsuccessfulMailboxes, string.IsNullOrEmpty(text) ? Strings.LogMailNone : text);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.Resume, searchObject.Resume);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.IncludeKeywordStatistics, searchObject.IncludeKeywordStatistics);
if (searchObject.Status == SearchState.Stopped || searchObject.Status == SearchState.EstimateStopped)
{
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.StoppedBy, searchObject.LastModifiedBy);
}
else
{
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.StoppedBy, Strings.LogMailNotApplicable);
}
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.PercentComplete, string.Format("{0}%", searchObject.PercentComplete));
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.ResultSize, new ByteQuantifiedSize((ulong)searchObject.ResultSizeCopied));
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.ResultSizeEstimate, searchObject.ResultSizeEstimate);
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.ResultSizeCopied, new ByteQuantifiedSize((ulong)searchObject.ResultSizeCopied));
if (searchObject.StatisticsOnly)
{
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.ResultsLink, string.Empty);
}
else
{
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.ResultsLink, searchObject.ResultsLink);
}
int num = Math.Min(Util.MaxNumberOfErrorsInStatusMessage, searchObject.Errors.Count);
StringBuilder stringBuilder2 = new StringBuilder();
for (int i = 0; i < num; i++)
{
stringBuilder2.Append(searchObject.Errors[i]);
}
text = stringBuilder2.ToString();
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.Errors, text.ValueOrDefault(Strings.LogMailNone));
KeywordHit unsearchableHit = null;
StringBuilder stringBuilder3 = new StringBuilder();
if (searchObject.KeywordHits != null && searchObject.KeywordHits.Count > 0)
{
stringBuilder3.AppendLine("<table style=\"width: 100%\" cellspacing=\"0\">");
stringBuilder3.AppendFormat("<tr> <td class=\"lefttd\"><strong>{0}</strong> </td><td class=\"lefttd\"><strong>{1}</strong> </td><td class=\"rightttd\"><strong>{2}</strong></td></tr>", Strings.LogFieldsKeywordKeyword, Strings.LogFieldsKeywordHitCount, Strings.LogFieldsKeywordMbxs);
foreach (KeywordHit keywordHit in searchObject.KeywordHits)
{
if (keywordHit.Phrase != "652beee2-75f7-4ca0-8a02-0698a3919cb9")
{
stringBuilder3.AppendFormat("<tr><td class=\"lefttd\">{0} </td><td class=\"lefttd\">{1} </td><td class=\"rightttd\">{2}</td></tr>", keywordHit.Phrase, keywordHit.Count, keywordHit.MailboxCount);
}
else
{
unsearchableHit = keywordHit;
}
}
stringBuilder3.Append("</table>");
}
else if (!searchObject.StatisticsOnly)
{
stringBuilder3.Append(Strings.NoKeywordStatsForCopySearch);
}
else if (string.IsNullOrEmpty(searchObject.Query))
{
stringBuilder3.Append(Strings.KeywordHitEmptyQuery);
}
else
{
stringBuilder3.Append(Strings.KeywordStatsNotRequested);
}
Util.ReplaceLogFieldTags(stringBuilder, Globals.LogFields.KeywordHits, stringBuilder3.ToString());
Util.BuildResultNumbers(stringBuilder, searchObject, unsearchableHit);
stringBuilder = stringBuilder.Replace(Globals.LogFields.LogMailHeader.ToLabelTag(), Strings.LogMailHeader(searchObject.Name, LocalizedDescriptionAttribute.FromEnum(typeof(SearchState), searchObject.Status)));
if (!searchObject.StatisticsOnly)
{
stringBuilder = stringBuilder.Replace(Globals.LogFields.LogMailHeaderInstructions.ToLabelTag(), Strings.LogMailHeaderInstructions(searchObject.Name));
}
else
{
stringBuilder.Replace(Globals.LogFields.LogMailHeaderInstructions.ToLabelTag(), string.Empty);
}
stringBuilder = stringBuilder.Replace(Globals.LogFields.LogMailSeeAttachment.ToLabelTag(), Strings.LogMailSeeAttachment);
stringBuilder = stringBuilder.Replace(Globals.LogFields.LogMailFooter.ToLabelTag(), Strings.LogMailFooter);
return(stringBuilder.ToString());
}
// Token: 0x06000170 RID: 368 RVA: 0x00009C70 File Offset: 0x00007E70
internal void Synchronize(object argument)
{
try
{
ServicePointManager.ServerCertificateValidationCallback = (RemoteCertificateValidationCallback)Delegate.Combine(ServicePointManager.ServerCertificateValidationCallback, new RemoteCertificateValidationCallback(CertificateValidation.CertificateErrorHandler));
Guid b = (Guid)argument;
SearchEventLogger.Instance.LogSyncDiscoveryHoldToExchangeOnlineStartEvent(b.ToString());
DiscoverySearchDataProvider discoverySearchDataProvider = new DiscoverySearchDataProvider(OrganizationId.ForestWideOrgId);
if (discoverySearchDataProvider.ObjectGuid == b)
{
Dictionary <string, MailboxDiscoverySearch> dictionary = new Dictionary <string, MailboxDiscoverySearch>();
SmtpAddress discoveryHolds = DiscoveryHoldSynchronizer.GetDiscoveryHolds(discoverySearchDataProvider, dictionary);
SearchEventLogger.Instance.LogSyncDiscoveryHoldToExchangeOnlineDetailsEvent(dictionary.Count, discoveryHolds.ToString());
if (discoveryHolds != SmtpAddress.Empty)
{
Uri uri = null;
string str = string.Empty;
EndPointDiscoveryInfo endPointDiscoveryInfo;
bool flag = RemoteDiscoveryEndPoint.TryGetDiscoveryEndPoint(OrganizationId.ForestWideOrgId, discoveryHolds.Domain, null, null, null, out uri, out endPointDiscoveryInfo);
if (endPointDiscoveryInfo != null && endPointDiscoveryInfo.Status != EndPointDiscoveryInfo.DiscoveryStatus.Success)
{
str = endPointDiscoveryInfo.Message;
DiscoveryHoldSynchronizer.Tracer.TraceDebug <EndPointDiscoveryInfo.DiscoveryStatus, string>((long)this.GetHashCode(), "Getting autodiscover url encountered problem with status {0}. {1}", endPointDiscoveryInfo.Status, endPointDiscoveryInfo.Message);
}
if (flag && uri != null)
{
uri = EwsWsSecurityUrl.FixForAnonymous(uri);
AutodiscoverService autodiscoverService = new AutodiscoverService(uri, 4);
OAuthCredentials credentials = new OAuthCredentials(OAuthCredentials.GetOAuthCredentialsForAppToken(OrganizationId.ForestWideOrgId, discoveryHolds.Domain));
autodiscoverService.Credentials = credentials;
GetUserSettingsResponse userSettings = autodiscoverService.GetUserSettings(discoveryHolds.ToString(), new UserSettingName[]
{
58
});
if (userSettings != null && userSettings.ErrorCode == null && userSettings.Settings != null && userSettings.Settings.ContainsKey(58))
{
string uriString = userSettings.Settings[58].ToString();
ExchangeService exchangeService = new ExchangeService(4);
exchangeService.Credentials = credentials;
exchangeService.Url = new Uri(uriString);
exchangeService.ManagementRoles = new ManagementRoles(null, "LegalHoldApplication");
GetDiscoverySearchConfigurationResponse discoverySearchConfiguration = exchangeService.GetDiscoverySearchConfiguration(null, false, true);
if (discoverySearchConfiguration.Result == 2)
{
SearchEventLogger.Instance.LogFailedToSyncDiscoveryHoldToExchangeOnlineEvent(string.Format("ErrorCode={0}&ErrorMessage={1}", discoverySearchConfiguration.ErrorCode, discoverySearchConfiguration.ErrorMessage));
goto IL_402;
}
foreach (DiscoverySearchConfiguration discoverySearchConfiguration2 in discoverySearchConfiguration.DiscoverySearchConfigurations)
{
MailboxDiscoverySearch mailboxDiscoverySearch = null;
if (dictionary.TryGetValue(discoverySearchConfiguration2.InPlaceHoldIdentity, out mailboxDiscoverySearch))
{
if (mailboxDiscoverySearch.Name != discoverySearchConfiguration2.SearchId)
{
if (DiscoveryHoldSynchronizer.CallSetHoldOnMailboxes(exchangeService, discoverySearchConfiguration2.SearchId, 2, discoverySearchConfiguration2.SearchQuery, discoverySearchConfiguration2.InPlaceHoldIdentity, null))
{
DiscoveryHoldSynchronizer.CallSetHoldOnMailboxes(exchangeService, mailboxDiscoverySearch.Name, 0, mailboxDiscoverySearch.CalculatedQuery, mailboxDiscoverySearch.InPlaceHoldIdentity, mailboxDiscoverySearch.ItemHoldPeriod.ToString());
}
}
else
{
DiscoveryHoldSynchronizer.CallSetHoldOnMailboxes(exchangeService, mailboxDiscoverySearch.Name, 1, mailboxDiscoverySearch.CalculatedQuery, mailboxDiscoverySearch.InPlaceHoldIdentity, mailboxDiscoverySearch.ItemHoldPeriod.ToString());
}
dictionary.Remove(discoverySearchConfiguration2.InPlaceHoldIdentity);
}
else if (discoverySearchConfiguration2.ManagedByOrganization == "b5d6efcd-1aee-42b9-b168-6fef285fe613")
{
DiscoveryHoldSynchronizer.CallSetHoldOnMailboxes(exchangeService, discoverySearchConfiguration2.SearchId, 2, discoverySearchConfiguration2.SearchQuery, discoverySearchConfiguration2.InPlaceHoldIdentity, null);
}
}
using (Dictionary <string, MailboxDiscoverySearch> .ValueCollection.Enumerator enumerator = dictionary.Values.GetEnumerator())
{
while (enumerator.MoveNext())
{
MailboxDiscoverySearch mailboxDiscoverySearch2 = enumerator.Current;
DiscoveryHoldSynchronizer.CallSetHoldOnMailboxes(exchangeService, mailboxDiscoverySearch2.Name, 0, mailboxDiscoverySearch2.CalculatedQuery, mailboxDiscoverySearch2.InPlaceHoldIdentity, mailboxDiscoverySearch2.ItemHoldPeriod.ToString());
}
goto IL_402;
}
}
string str2 = string.Empty;
if (userSettings != null && userSettings.ErrorCode != null)
{
str2 = string.Format("ErrorCode={0}&ErrorMessage={1}", userSettings.ErrorCode, userSettings.ErrorMessage);
}
SearchEventLogger.Instance.LogFailedToSyncDiscoveryHoldToExchangeOnlineEvent("Failed to get autodiscover settings. " + str2);
}
else
{
SearchEventLogger.Instance.LogFailedToSyncDiscoveryHoldToExchangeOnlineEvent("Failed to get autodiscover URL. " + str);
}
}
}
IL_402 :;
}
finally
{
ServicePointManager.ServerCertificateValidationCallback = (RemoteCertificateValidationCallback)Delegate.Remove(ServicePointManager.ServerCertificateValidationCallback, new RemoteCertificateValidationCallback(CertificateValidation.CertificateErrorHandler));
}
}
internal static string CreateStatusMailBody(MailboxDiscoverySearch searchObject, string[] statusMailRecipients, List <string> successfulMailboxes, List <string> unsuccessfulMailboxes, IList <ISource> srcMailboxes)
{
return(Util.CreateMailBody(Util.StatusMailTemplate, searchObject, statusMailRecipients, successfulMailboxes, unsuccessfulMailboxes, srcMailboxes));
}
public void ApplyConfiguration(ISearchPolicy policy, ref SearchMailboxesInputs inputs)
{
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration Inputs:", inputs);
if (inputs.Sources != null && inputs.Sources.Count > 0 && inputs.Sources[0].SourceType == SourceType.SavedSearchId)
{
inputs.SearchConfigurationId = inputs.Sources[0].ReferenceId;
inputs.Sources.RemoveAt(0);
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration Found In Sources SearchId:", inputs.SearchConfigurationId);
}
if (!string.IsNullOrWhiteSpace(inputs.SearchConfigurationId))
{
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration Found SearchId:", inputs.SearchConfigurationId);
IDiscoverySearchDataProvider discoverySearchDataProvider = new DiscoverySearchDataProvider(policy.RecipientSession.SessionSettings.CurrentOrganizationId);
MailboxDiscoverySearch mailboxDiscoverySearch = discoverySearchDataProvider.Find <MailboxDiscoverySearch>(inputs.SearchConfigurationId);
if (mailboxDiscoverySearch == null)
{
Recorder.Trace(5L, TraceType.ErrorTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration Invalid SearchId:", inputs.SearchConfigurationId);
throw new SearchException(KnownError.ErrorInvalidSearchId);
}
inputs.SearchQuery = mailboxDiscoverySearch.CalculatedQuery;
inputs.Language = mailboxDiscoverySearch.Language;
Recorder.Trace(5L, TraceType.InfoTrace, new object[]
{
"ArbitrationSearchConfigurationProvider.ApplyConfiguration Query:",
inputs.SearchQuery,
"Language:",
inputs.Language
});
if (inputs.Sources == null || inputs.Sources.Count == 0)
{
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration No Sources");
inputs.Sources = new List <SearchSource>();
if (mailboxDiscoverySearch.Sources != null && mailboxDiscoverySearch.Sources.Count > 0)
{
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration Mailboxes:", mailboxDiscoverySearch.Sources.Count);
using (MultiValuedProperty <string> .Enumerator enumerator = mailboxDiscoverySearch.Sources.GetEnumerator())
{
while (enumerator.MoveNext())
{
string referenceId = enumerator.Current;
inputs.Sources.Add(new SearchSource
{
ReferenceId = referenceId,
SourceLocation = SourceLocation.All,
SourceType = SourceType.AutoDetect
});
}
goto IL_234;
}
}
if (mailboxDiscoverySearch.Version == SearchObjectVersion.Original || mailboxDiscoverySearch.AllSourceMailboxes)
{
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration AllMailboxes");
inputs.Sources.Add(new SearchSource
{
SourceLocation = SourceLocation.All,
SourceType = SourceType.AllMailboxes
});
}
IL_234:
if (mailboxDiscoverySearch.PublicFolderSources != null && mailboxDiscoverySearch.PublicFolderSources.Count > 0)
{
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration PublicFoiders:", mailboxDiscoverySearch.PublicFolderSources.Count);
using (MultiValuedProperty <string> .Enumerator enumerator2 = mailboxDiscoverySearch.PublicFolderSources.GetEnumerator())
{
while (enumerator2.MoveNext())
{
string referenceId2 = enumerator2.Current;
inputs.Sources.Add(new SearchSource
{
ReferenceId = referenceId2,
SourceLocation = SourceLocation.All,
SourceType = SourceType.PublicFolder
});
}
return;
}
}
if (mailboxDiscoverySearch.AllPublicFolderSources)
{
Recorder.Trace(5L, TraceType.InfoTrace, "ArbitrationSearchConfigurationProvider.ApplyConfiguration AllPublicFoiders");
inputs.Sources.Add(new SearchSource
{
SourceLocation = SourceLocation.PrimaryOnly,
SourceType = SourceType.AllPublicFolders
});
}
}
}
}
public void WriteExportRecordLog(MailboxDiscoverySearch searchObject, IEnumerable <ExportRecord> records)
{
Util.ThrowIfNull(searchObject, "searchObject");
this.InternalCreateOrUpdateSearchLogEmail(searchObject, null, null, false);
this.InternalWriteExportRecordLog(records);
}
public void CreateOrUpdateSearchLogEmail(MailboxDiscoverySearch searchObject, List <string> successfulMailboxes, List <string> unsuccessfulMailboxes)
{
Util.ThrowIfNull(searchObject, "searchObject");
this.exportRecordLogFileName = Path.ChangeExtension(this.ToSafeFileNameString(searchObject.Name), ".csv");
this.InternalCreateOrUpdateSearchLogEmail(searchObject, successfulMailboxes, unsuccessfulMailboxes, true);
}
public MailboxSearchTask(IEwsClient ewsClient, string keywordStatisticsQuery, MultiValuedProperty <string> userKeywords, IRecipientSession recipientSession, IExportContext exportContext, string executingUserPrimarySmtpAddress, int previewMaxMailboxes, bool isPFSearchFlightingEnabled, MailboxDiscoverySearch searchObject, OrganizationId orgId)
{
Util.ThrowIfNull(ewsClient, "ewsClient");
Util.ThrowIfNull(exportContext, "exportContext");
this.isStatisticsOnlySearch = true;
this.keywordStatisticsQuery = keywordStatisticsQuery;
this.CurrentState = SearchState.NotStarted;
this.Errors = new List <string>(1);
this.executingUserPrimarySmtpAddress = executingUserPrimarySmtpAddress;
this.ewsClient = ewsClient;
this.ExportContext = exportContext;
this.previewMaxMailboxes = previewMaxMailboxes;
this.InitializeUserKeywordsMapping(keywordStatisticsQuery, userKeywords, recipientSession);
this.isPFSearchFlightingEnabled = isPFSearchFlightingEnabled;
this.searchObject = searchObject;
this.orgId = orgId;
}
public override SearchErrorInfo AbortEx(SearchId searchId, string userId)
{
MailboxSearchServer.Tracer.TraceFunction <string>((long)this.GetHashCode(), "MailboxSearchServer.Abort on {0}", searchId.SearchName);
SearchErrorInfo errorInfo = null;
SearchUtils.ExWatsonWrappedCall(delegate()
{
lock (this)
{
if (!this.searchWorkItemMap.ContainsKey(searchId) && !this.pendingSearchIdMap.ContainsKey(searchId))
{
MailboxSearchServer.Tracer.TraceWarning <string>((long)this.GetHashCode(), "The search {0} is not started", searchId.SearchName);
try
{
ADObjectId discoverySystemMailboxId = new ADObjectId(searchId.MailboxDsName, searchId.MailboxGuid);
IMailboxSearchConfigurationProvider mailboxSearchConfigurationProvider = new MailboxSearchConfigurationProvider(discoverySystemMailboxId, searchId.SearchName);
if (MailboxDiscoverySearch.IsInProgressState(mailboxSearchConfigurationProvider.SearchObject.Status))
{
mailboxSearchConfigurationProvider.SearchObject.UpdateState(SearchStateTransition.Fail);
mailboxSearchConfigurationProvider.UpdateSearchObject("AbortEx", 317);
}
errorInfo = new SearchErrorInfo(262658, Strings.SearchNotStarted);
goto IL_3A4;
}
catch (FormatException exception)
{
errorInfo = new SearchErrorInfo(-2147220990, exception);
goto IL_3A4;
}
catch (SearchObjectNotFoundException exception2)
{
errorInfo = new SearchErrorInfo(-2147220990, exception2);
goto IL_3A4;
}
catch (DataSourceOperationException exception3)
{
errorInfo = new SearchErrorInfo(-2147220990, exception3);
goto IL_3A4;
}
}
if (this.searchWorkItemMap.ContainsKey(searchId))
{
MailboxSearchWorkItem searchWorkItem = this.searchWorkItemMap[searchId];
if (searchWorkItem.IsCompleted)
{
goto IL_3A4;
}
try
{
searchWorkItem.Abort(userId);
}
catch (ExportException ex)
{
MailboxSearchServer.Tracer.TraceError <ExportException>((long)this.GetHashCode(), "MailboxSearchServer.Abort error {0}", ex);
errorInfo = new SearchErrorInfo(-2147220991, ex);
}
catch (DataSourceOperationException ex2)
{
MailboxSearchServer.Tracer.TraceError <DataSourceOperationException>((long)this.GetHashCode(), "MailboxSearchServer.Abort error {0}", ex2);
errorInfo = new SearchErrorInfo(-2147220991, ex2);
}
lock (this.workItemQueue)
{
int num = this.workItemQueue.FindIndex((MailboxSearchWorkItem x) => x == searchWorkItem);
if (num != -1)
{
if (num != 0)
{
this.workItemQueue.RemoveAt(num);
this.workItemQueue.Insert(0, searchWorkItem);
}
int num2 = this.workItemSemaphore.Release();
MailboxSearchServer.Tracer.TraceDebug <int, int>((long)this.GetHashCode(), "MailboxSearch is aborted with Queue Length {0} and semaphore {1}", this.workItemQueue.Count, num2 + 1);
SearchEventLogger.Instance.LogDiscoverySearchWorkItemQueueChangedEvent("MovedToFrontOfQueueOnAbort", searchId.SearchName, searchId.MailboxDsName, searchWorkItem.Action.ToString(), searchWorkItem.IsEstimateOnly, this.workItemQueue.Count, this.searchWorkItemMap.Count, this.copySearchesInProgress, num2 + 1);
}
goto IL_3A4;
}
}
if (this.pendingSearchIdMap.ContainsKey(searchId))
{
this.pendingSearchIdMap.Remove(searchId);
SearchEventLogger.Instance.LogDiscoverySearchPendingWorkItemsChangedEvent("RemovedFromPendingWorkItemsOnAbort", searchId.SearchName, searchId.MailboxDsName, this.pendingSearchIdMap.Count);
}
IL_3A4:;
}
});
if (errorInfo != null && errorInfo.Failed)
{
MailboxSearchServer.LogErrorInfo("Error occured when trying to abort the search workitem", searchId, errorInfo);
}
return(errorInfo);
}
