/// <summary>
/// Get all sites that match the passed query. Batching is done in batches of 500 as this is compliant for both Office 365 as SharePoint on-premises
/// </summary>
/// <param name="cc">ClientContext object of an arbitrary site collection accessible by the defined enumeration username and password</param>
/// <param name="keywordQueryValue">Query string</param>
/// <returns>List of found site collections</returns>
private static List <String> SiteSearch(ClientRuntimeContext cc, string keywordQueryValue)
{
List <String> sites = new List <String>();
KeywordQuery keywordQuery = new KeywordQuery(cc);
// Important to avoid trimming "similar" site collections
keywordQuery.TrimDuplicates = false;
if (keywordQueryValue.Length == 0)
{
keywordQueryValue = "contentclass:\"STS_Site\"";
}
int startRow = 0;
int totalRows = 0;
totalRows = ProcessQuery(cc, keywordQueryValue, sites, keywordQuery, startRow);
if (totalRows > 0)
{
while (totalRows >= sites.Count)
{
startRow += 500;
totalRows = ProcessQuery(cc, keywordQueryValue, sites, keywordQuery, startRow);
}
}
return(sites);
}
/// <summary>
/// Executes a keyword query against Office search service.
/// </summary>
/// <param name="keywordQuery">A keyword query instance.</param>
/// <param name="refiners">A list of <see cref="SearchRefiner"/> objects where refinement results are populated.</param>
/// <returns>Results returned from Office search service.</returns>
public static ResultTable ExecuteQuery(KeywordQuery keywordQuery, SearchRefiner[] refiners)
{
CommonHelper.ConfirmNotNull(keywordQuery, "keywordQuery");
LastQueryText = keywordQuery.QueryText;
if (refiners != null)
{
keywordQuery.Refiners = String.Join(",", refiners.Select(v => v.PropertyName).ToArray());
keywordQuery.RefinementFilters.AddRange(refiners.Where(v => v.RefinementToken != null).Select(v => v.RefinementToken).ToArray());
}
SearchExecutor executor = new SearchExecutor();
ResultTableCollection queryResults = executor.ExecuteQuery(keywordQuery);
ResultTable relevantResults = queryResults.Filter("TableType", KnownTableTypes.RelevantResults).FirstOrDefault();
if (relevantResults == null)
{
throw new Exception("Search executor did not return result table of type RelevantResults");
}
if (refiners != null)
{
ResultTable refinementResults = queryResults.Filter("TableType", KnownTableTypes.RefinementResults).FirstOrDefault();
if (refinementResults == null)
{
throw new Exception("Search executor did not return result table of type RefinementResults");
}
foreach (SearchRefiner refiner in refiners)
{
foreach (DataRow row in refinementResults.Table.Rows.OfType <DataRow>().Where(v => refiner.PropertyName.Equals(v["RefinerName"])))
{
refiner.AddRefinement((string)row["RefinementName"], (string)row["RefinementToken"], (int)row["RefinementCount"]);
}
}
}
return(relevantResults);
}
private static string[] GetActorIds(ClientContext clientContext, string[] siteMembersEmails)
{
StringBuilder searchQueryText = new StringBuilder();
foreach (string userEmail in siteMembersEmails) {
if (searchQueryText.Length > 0) {
searchQueryText.Append(" OR ");
}
searchQueryText.AppendFormat("UserName:{0}", userEmail);
}
KeywordQuery searchQuery = new KeywordQuery(clientContext);
searchQuery.QueryText = searchQueryText.ToString();
searchQuery.SelectProperties.Add("DocId");
searchQuery.SourceId = new Guid("b09a7990-05ea-4af9-81ef-edfab16c4e31");
searchQuery.RowLimit = 100;
SearchExecutor searchExecutor = new SearchExecutor(clientContext);
ClientResult<ResultTableCollection> results = searchExecutor.ExecuteQuery(searchQuery);
clientContext.ExecuteQuery();
List<string> actorIds = new List<string>(results.Value[0].ResultRows.Count());
foreach (var row in results.Value[0].ResultRows) {
actorIds.Add(row["DocId"].ToString());
}
return actorIds.ToArray();
}
protected void btnSearch_Click(object sender, EventArgs e)
{
SPSite site = SPContext.Current.Site;
KeywordQuery kq = new KeywordQuery(site);
kq.SourceId = new Guid("8413cd39-2156-4e00-b54d-11efd9abdb89");
kq.QueryText = "* " + searchText.Text;
kq.SelectProperties.Add("Title");
kq.SelectProperties.Add("Path");
kq.RowLimit = 20;
ResultTableCollection resultTables = new SearchExecutor().ExecuteQuery(kq);
DataTable resultDataTable = resultTables.FirstOrDefault().Table;
List <SearchResult> searchResultList = new List <SearchResult>();
foreach (DataRow row in resultDataTable.Rows)
{
SearchResult searchResult = new SearchResult();
searchResult.Title = row["Title"].ToString();
searchResult.Url = row["Path"].ToString();
searchResultList.Add(searchResult);
}
rptSearch.DataSource = searchResultList;
rptSearch.DataBind();
}
private void RunSearch(string searchText)
{
SharePointContext spContext = SharePointContextProvider.Current.GetSharePointContext(Context);
Uri hostWeb = spContext.SPHostUrl;
using (var context = spContext.CreateUserClientContextForSPHost()) {
//Get current user
User currentUser = context.Web.CurrentUser;
context.Load(currentUser);
context.ExecuteQuery();
//Get current user's tasks
KeywordQuery keywordQuery = new KeywordQuery(context);
keywordQuery.QueryText = searchText;
var searchExecutor = new SearchExecutor(context);
ClientResult<ResultTableCollection> resultsCollection = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
//Bind them to the grid
IEnumerable<IDictionary<string, object>> results = resultsCollection.Value[0].ResultRows;
List<SearchResult> tasks = new List<SearchResult>();
foreach (var result in results) {
SearchResult searchResult = new SearchResult();
searchResult.Title = result["Title"].ToString();
searchResult.Path = result["Path"].ToString();
tasks.Add(searchResult);
}
SearchResultsView.DataSource = tasks;
SearchResultsView.DataBind();
}
}
public List <Event> GetEvents()
{
List <Event> events;
using (new SPMonitoredScope("Boxing Events Search Retrieval"))
{
KeywordQuery query = new KeywordQuery(SPContext.Current.Site);
query.SelectProperties.AddRange(new[] { "Title", "EventDate", "Path" });
query.QueryText = "ContentType:\"CT-Event\"";
var searchExecutor = new SearchExecutor();
ResultTableCollection results = searchExecutor.ExecuteQuery(query);
ResultTable resultTable = results.Filter("TableType", KnownTableTypes.RelevantResults).Single();
events = (from DataRow row in resultTable.ResultRows
select new Event(
(string)row["Title"],
(DateTime)row["EventDate"],
(string)row["Path"])
).OrderByDescending(ev => ev.EventDate)
.ThenBy(ev => ev.Title)
.ToList();
}
return(events);
}
public KeywordQueryInstance(ScriptEngine engine, KeywordQuery keywordQuery)
: base(new QueryInstance(engine, keywordQuery), keywordQuery)
{
this.m_keywordQuery = keywordQuery;
this.PopulateFunctions();
}
protected void cmdSearch_Click(object sender, EventArgs e)
{
string contextToken = SPAppToken.Value;
string hostWeb = Page.Request["SPHostUrl"];
ClientContext ctx = TokenHelper.GetClientContextWithContextToken(hostWeb, contextToken, Request.Url.Authority);
KeywordQuery keywordQuery = new KeywordQuery(ctx);
keywordQuery.QueryText = txtSearchText.Text;
SearchExecutor searchExecutor = new SearchExecutor(ctx);
ClientResult <ResultTableCollection> results = searchExecutor.ExecuteQuery(keywordQuery);
ctx.ExecuteQuery();
DataTable dt = new DataTable();
dt.Columns.Add("Title");
dt.Columns.Add("Author");
dt.Columns.Add("Last Update");
dt.Columns.Add("URL");
if (results.Value.Count > 0)
{
foreach (Dictionary <String, Object> resultRow in results.Value[0].ResultRows)
{
dt.Rows.Add(resultRow["Title"], resultRow["Author"], resultRow["Write"], resultRow["Path"]);
}
}
grd.DataSource = dt;
grd.DataBind();
}
private KeywordQuery GetQuery(string cQuery, string cProp, int StartRpw)
{
KeywordQuery kq = new KeywordQuery(ctx);
try
{
kq.QueryText = cQuery;
kq.StartRow = 0;
kq.RowLimit = 500;
kq.RowsPerPage = 500;
kq.Timeout = 60000;
string[] mp = cProp.Split(',');
foreach (string p in mp)
{
kq.SelectProperties.Add(p);
}
kq.TrimDuplicates = false;
} catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
}
return(kq);
}
private void RunSearch(string searchText)
{
SharePointContext spContext = SharePointContextProvider.Current.GetSharePointContext(Context);
Uri hostWeb = spContext.SPHostUrl;
using (var context = spContext.CreateUserClientContextForSPHost()) {
//Get current user
User currentUser = context.Web.CurrentUser;
context.Load(currentUser);
context.ExecuteQuery();
//Get current user's tasks
KeywordQuery keywordQuery = new KeywordQuery(context);
keywordQuery.QueryText = searchText;
var searchExecutor = new SearchExecutor(context);
ClientResult <ResultTableCollection> resultsCollection = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
//Bind them to the grid
IEnumerable <IDictionary <string, object> > results = resultsCollection.Value[0].ResultRows;
List <SearchResult> tasks = new List <SearchResult>();
foreach (var result in results)
{
SearchResult searchResult = new SearchResult();
searchResult.Title = result["Title"].ToString();
searchResult.Path = result["Path"].ToString();
tasks.Add(searchResult);
}
SearchResultsView.DataSource = tasks;
SearchResultsView.DataBind();
}
}
private void SelectSharePointSite_Load( object sender, EventArgs e )
{
if ( _ctx == null )
{
throw new ArgumentException( "You must set the SharePoint RootSite Url before opening this form." );
}
KeywordQuery kwq = new KeywordQuery( _ctx )
{
QueryText = "contentclass =\"STS_Web\" OR contentclass=\"STS_Site\""
};
SearchExecutor seExecute = new SearchExecutor( _ctx );
var results = seExecute.ExecuteQuery( kwq );
_ctx.ExecuteQuery();
lstSharePointSites.DisplayMember = "SiteName";
lstSharePointSites.ValueMember = "Path";
lstSharePointSites.DataSource = ( from r in results.Value[ 0 ].ResultRows
where
!r[ "Author" ].ToString().Equals( "System Account" )
&& !string.IsNullOrEmpty( r[ "Author" ].ToString() )
&& !r[ "Path" ].ToString().Contains( "-my" )
select new
{
SiteName = r[ "Title" ] + " -|- " + r[ "Author" ],
Path = r[ "Path" ]
} ).ToArray();
this.Closed += ( s, args ) =>
{
_ctx.Dispose();
};
}
protected override void ProcessRecord()
{
base.ProcessRecord();
try {
KeywordQuery query = new KeywordQuery(this.Site.Read());
query.QueryText = this.Query;
query.SelectProperties.AddRange(this.Select);
SearchExecutor executor = new SearchExecutor();
ResultTableCollection result = executor.ExecuteQuery(query);
ResultTable resultTable = result.Filter("TableType", KnownTableTypes.RelevantResults).FirstOrDefault();
if (resultTable == null)
{
throw new Exception("Search executor did not return result table of type RelevantResults");
}
DataTable dataTable = new DataTable();
dataTable.Load(resultTable);
foreach (DataRow row in dataTable.Rows)
{
PSObject obj = new PSObject();
foreach (DataColumn column in dataTable.Columns)
{
obj.Members.Add(new PSNoteProperty(column.Caption, row[column]));
}
WriteObject(obj);
}
} catch (Exception ex) {
ThrowTerminatingError(ex, ErrorCategory.NotSpecified);
}
}
private KeywordQuery GetQuery(string sortExpression)
{
var query = new KeywordQuery(SPContext.Current.Site);
query.QueryText = this.dataSource.QueryText;
query.ResultTypes = ResultType.RelevantResults;
if (!string.IsNullOrEmpty(this.dataSource.SelectProperties))
{
query.SelectProperties.Clear();
foreach (var property in this.dataSource.SelectProperties.Split(','))
{
query.SelectProperties.Add(property.Trim());
}
}
if (!string.IsNullOrEmpty(sortExpression))
{
query.SortList.Clear();
foreach (var sort in sortExpression.Split(','))
{
if (sort.EndsWith(" DESC"))
{
query.SortList.Add(sort.Substring(0, sort.IndexOf(" DESC")), SortDirection.Descending);
}
else
{
query.SortList.Add(sort, SortDirection.Ascending);
}
}
}
return(query);
}
/// <summary>
/// Query SharePoint Search and fetch information about each file (URL and name).
/// </summary>
/// <param name="client">Existing SharePoint ClientContext</param>
/// <param name="folderUrl">Full server folder URL</param>
/// <returns>List of files information</returns>
static async Task <IEnumerable <SPFileInfo> > GetFilesFromFolderAsync(ClientContext client, string folderUrl)
{
KeywordQuery query = new KeywordQuery(client)
{
QueryText = $"IsContainer=false Path:\"{folderUrl}\"",
RowLimit = 500
};
SearchExecutor searchExecutor = new SearchExecutor(client);
ClientResult <ResultTableCollection> results = searchExecutor.ExecuteQuery(query);
await client.ExecuteQueryAsync();
var relevantResults = results.Value.Where(x => x.TableType == "RelevantResults").FirstOrDefault();
if (relevantResults == null)
{
return(Array.Empty <SPFileInfo>());
}
var files = new List <SPFileInfo>();
foreach (IDictionary <string, object> item in relevantResults.ResultRows)
{
var fileKey = item.Where(x => x.Key == "Path").FirstOrDefault();
Uri filePath = new Uri(fileKey.Value.ToString());
files.Add(new SPFileInfo()
{
ServerRelativeUrl = filePath.PathAndQuery,
FileName = filePath.PathAndQuery.Substring(filePath.PathAndQuery.LastIndexOf("/") + 1)
});
}
return(files);
}
public static List <SiteEntity> SiteSearch(this Web web, string keywordQueryValue, bool trimDuplicates = false)
{
try
{
//Log.Debug(Constants.LOGGING_SOURCE, "Site search '{0}'", keywordQueryValue);
List <SiteEntity> sites = new List <SiteEntity>();
KeywordQuery keywordQuery = new KeywordQuery(web.Context);
keywordQuery.TrimDuplicates = trimDuplicates;
//int startRow = 0;
int totalRows = 0;
totalRows = web.ProcessQuery(keywordQueryValue, sites, keywordQuery);
if (totalRows > 0)
{
while (totalRows > 0)
{
totalRows = web.ProcessQuery(keywordQueryValue + " AND IndexDocId >" + sites.Last().IndexDocId, sites, keywordQuery);// From the second Query get the next set (rowlimit) of search result based on IndexDocId
}
}
return(sites);
}
catch (Exception ex)
{
//Log.Error(Constants.LOGGING_SOURCE, CoreResources.WebExtensions_SiteSearchUnhandledException, ex.Message);
// rethrow does lose one line of stack trace, but we want to log the error at the component boundary
throw;
}
}
/// <summary>
/// Returns the site collections that comply with the passed keyword query
/// </summary>
/// <param name="web">Site to be processed - can be root web or sub site</param>
/// <param name="keywordQueryValue">Keyword query</param>
/// <returns>All found site collections</returns>
public static List <SiteEntity> SiteSearch(this Web web, string keywordQueryValue)
{
List <SiteEntity> sites = new List <SiteEntity>();
KeywordQuery keywordQuery = new KeywordQuery(web.Context);
keywordQuery.TrimDuplicates = false;
if (keywordQueryValue.Length == 0)
{
keywordQueryValue = "contentclass:\"STS_Site\"";
}
int startRow = 0;
int totalRows = 0;
totalRows = web.ProcessQuery(keywordQueryValue, sites, keywordQuery, startRow);
if (totalRows > 0)
{
while (totalRows >= sites.Count)
{
startRow += 500;
totalRows = web.ProcessQuery(keywordQueryValue, sites, keywordQuery, startRow);
}
}
return(sites);
}
private List <string> GetUserLoginNamesFromSearch()
{
Logger?.Debug($"[O365] Getting user list from search");
try
{
List <string> loginNames = new List <string>();
var ctx = GetSpoClientContextForSite(SpoSite.RootSite);
SearchExecutor searchExecutor = new SearchExecutor(ctx);
int currentPage = 0;
int totalRows = -1;
int startRow = 1;
int rowLimit = 10;
do
{
startRow = (rowLimit * currentPage) + 1;
// http://www.techmikael.com/2015/01/how-to-query-using-result-source-name.html
KeywordQuery qry = new KeywordQuery(ctx);
qry.Properties["SourceName"] = "Local People Results";
qry.Properties["SourceLevel"] = "SSA";
qry.QueryText = "*";
qry.RowLimit = rowLimit;
qry.StartRow = startRow;
ClientResult <ResultTableCollection> results = searchExecutor.ExecuteQuery(qry);
ctx.ExecuteQueryWithIncrementalRetry(SpoRetries, SpoBackoff, Logger);
var resultTable = results.Value[0];
if (currentPage == 0)
{
totalRows = resultTable.TotalRows;
}
foreach (var resultRow in resultTable.ResultRows)
{
loginNames.Add(resultRow["AccountName"].ToString());
}
currentPage++;
} while (startRow + rowLimit < totalRows);
return(loginNames);
}
catch (MaximumRetryAttemptedException ex)
{
// Exception handling for the Maximum Retry Attempted
Logger?.Error($"[O365] Max retries / throttle for SPO reached getting site user list. Message {ex.Message}");
throw new O365Exception($"Max retries / throttle for SPO reached. Message {ex.Message}", ex);
}
catch (Exception ex)
{
Logger?.Error($"[O365] Problem getting root site user list. Message {ex.Message}");
throw new O365Exception($"Problem getting root site user list. Message {ex.Message}", ex);
}
}
private void RunSearch(string searchText)
{
SharePointContext spContext = SharePointContextProvider.Current.GetSharePointContext(Context);
Uri hostWeb = spContext.SPHostUrl;
using (var context = TokenHelper.GetS2SClientContextWithWindowsIdentity(hostWeb, Request.LogonUserIdentity)) {
//Get current user
User currentUser = context.Web.CurrentUser;
context.Load(currentUser);
context.ExecuteQuery();
//Get current user's tasks
KeywordQuery keywordQuery = new KeywordQuery(context);
keywordQuery.QueryText = searchText;
var searchExecutor = new SearchExecutor(context);
ClientResult<ResultTableCollection> resultsCollection = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
//Bind them to the grid
IEnumerable<IDictionary<string, object>> results = resultsCollection.Value[0].ResultRows;
List<Task> tasks = new List<Task>();
foreach (var result in results) {
Task task = new Task();
task.Title = result["Title"].ToString();
task.Path = result["Path"].ToString();
tasks.Add(task);
}
SearchResultsView.DataSource = tasks;
SearchResultsView.DataBind();
}
}
private void RunSearch(string searchText)
{
SharePointContext spContext = SharePointContextProvider.Current.GetSharePointContext(Context);
Uri hostWeb = spContext.SPHostUrl;
using (var context = TokenHelper.GetS2SClientContextWithWindowsIdentity(hostWeb, Request.LogonUserIdentity)) {
//Get current user
User currentUser = context.Web.CurrentUser;
context.Load(currentUser);
context.ExecuteQuery();
//Get current user's tasks
KeywordQuery keywordQuery = new KeywordQuery(context);
keywordQuery.QueryText = searchText;
var searchExecutor = new SearchExecutor(context);
ClientResult <ResultTableCollection> resultsCollection = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
//Bind them to the grid
IEnumerable <IDictionary <string, object> > results = resultsCollection.Value[0].ResultRows;
List <Task> tasks = new List <Task>();
foreach (var result in results)
{
Task task = new Task();
task.Title = result["Title"].ToString();
task.Path = result["Path"].ToString();
tasks.Add(task);
}
SearchResultsView.DataSource = tasks;
SearchResultsView.DataBind();
}
}
public static void GetUnlabeledDocsFromSearch(ICollector <UnlabeledDocument> queueData, TraceWriter log)
{
Stopwatch sw = new Stopwatch();
//var ac = new AuthenticationContext(Constants.AuthorityUri, false);
var cert = Utils.GetCertificate(Constants.AADAppCertificateThumbprint);
ClientAssertionCertificate cac = new ClientAssertionCertificate(Constants.AADAppClientId, cert);
var authResult = ac.AcquireTokenAsync(Constants.ResourceUri, cac).Result;
using (ClientContext cc = new ClientContext(Constants.TenantRootUrl))
{
cc.ExecutingWebRequest += (s, e) =>
{
e.WebRequestExecutor.RequestHeaders["Authorization"] = "Bearer " + authResult.AccessToken;
};
ClientResult <ResultTableCollection> results = new ClientResult <ResultTableCollection>();
KeywordQuery keywordQuery = new KeywordQuery(cc);
int startRow = 0;
var defaultRetentionLabel = Environment.GetEnvironmentVariable("defaultRetentionLabel");
sw.Start();
do
{
keywordQuery.StartRow = startRow;
keywordQuery.QueryText = Constants.KeywordQueryForComplianceTag;
keywordQuery.RowLimit = 500;
keywordQuery.TrimDuplicates = false;
SearchExecutor searchExec = new SearchExecutor(cc);
results = searchExec.ExecuteQuery(keywordQuery);
cc.ExecuteQuery();
if (results != null)
{
if (results.Value[0].RowCount > 0)
{
foreach (var row in results.Value[0].ResultRows)
{
var path = row["Path"].ToString();
var byteEncodedPath = HttpUtility.UrlEncode(row["Path"].ToString());
var byteEncodedWebUrl = HttpUtility.UrlEncode(row["SPWebUrl"].ToString());
log.Info("Unlabeled document at: " + path);
queueData.Add(new UnlabeledDocument(byteEncodedWebUrl, byteEncodedPath, Constants.DefaultRetentionLabel));
}
}
}
startRow += results.Value[0].RowCount;
} while (results.Value[0].TotalRowsIncludingDuplicates > startRow);
sw.Stop();
telemetry.TrackMetric("CSOM-GetUnlabeledDocs", sw.ElapsedMilliseconds);
}
}
private IEnumerable <NavigationNode> GetNavigationNodesBySearch(SPWeb web, NavigationSearchSettings settings, IEnumerable <string> additionalFilters = null)
{
var filters = new List <string>(settings.GlobalFilters);
// Check if find result source
var searchResultSource = this.searchHelper.GetResultSourceByName(web.Site, settings.ResultSourceName, SearchObjectLevel.Ssa);
if (searchResultSource == null)
{
this.logger.Error("searchResultSource is null in GSoft.Dynamite.Navigation.NavigationService.GetNavigationNodeItems");
return(new List <NavigationNode>());
}
var query = new KeywordQuery(web)
{
SourceId = searchResultSource.Id,
TrimDuplicates = false,
RowLimit = 500
};
// Add defined filters
if (additionalFilters != null)
{
filters.AddRange(additionalFilters);
}
if (settings.SelectedProperties != null && settings.SelectedProperties.Any())
{
query.SelectProperties.AddRange(settings.SelectedProperties.ToArray());
}
// TODO: For now, the filters are applied seperated by whitespaces which means "AND" in KQL land.
// TODO: We should figure out a way to make this more flexible to use "OR" if necessary.
query.QueryText = string.Join(" ", filters.Where(filter => !string.IsNullOrEmpty(filter)));
// Execute search query
var tables = new SearchExecutor().ExecuteQuery(query);
if (tables.Exists(KnownTableTypes.RelevantResults))
{
// Build navigation nodes for search results
var results = tables.Filter("TableType", KnownTableTypes.RelevantResults).Single(relevantTable => relevantTable.QueryRuleId == Guid.Empty);
var nodes = results.Table.Rows.Cast <DataRow>().Select(dataRow => new NavigationNode(dataRow, settings.NavigationManagedPropertyName));
this.logger.Info(
"GetNavigationNodeItems: Found {0} items with search query '{1}' from source '{2}'.",
results.Table.Rows.Count,
query.QueryText,
settings.ResultSourceName);
return(nodes);
}
this.logger.Error(
"GetNavigationNodeItems: No relevant results table found with search query '{0}' from source '{1}'.",
query.QueryText,
settings.ResultSourceName);
return(new List <NavigationNode>());
}
private static void PopulateQueryDefaults(KeywordQuery query)
{
query.ProcessBestBets = false;
query.BypassResultTypes = true;
query.Properties["EnableStacking"] = false;
query.EnableStemming = false;
query.EnableQueryRules = false;
}
public KeywordQueryCamlVisitor(KeywordQuery query, Hashtable bindings)
{
CommonHelper.ConfirmNotNull(query, "query");
CommonHelper.ConfirmNotNull(bindings, "bindings");
this.query = query;
this.bindings = bindings;
this.managedPropertyDictionary = SearchServiceHelper.GetManagedPropertyNames(query.Site);
}
private DataTable GetItems()
{
DataTable resultsDataTable = new DataTable();
if (tags.Length > 0)
{
SPSite site = new SPSite(SPContext.Current.Site.Url);
/*
* FullTextSqlQuery query = new FullTextSqlQuery(site);
* query.Hint = QueryHint.OptimizeWithPropertyStore;
* // inserito per prendere tutto. BUG della search
* query.TrimDuplicates = false;
* query.QueryText = "SELECT Path, title, Created, Tags, TipoContenuto, SiteTitle, SiteName FROM scope() WHERE \"scope\"='All Sites' AND (CONTAINS(Tags,'\"" + tags[0] + "\"')";
* if (tags.Length > 1)
* {
* for (int i = 1; i < tags.Length; i++)
* {
* query.QueryText += " OR CONTAINS(Tags,'\"" + tags[i] + "\"')";
* }
* }
* query.QueryText += ") ORDER BY LastModifiedTime Desc";
* query.SiteContext = new Uri(site.Url);
* query.ResultTypes = ResultType.RelevantResults;
* */
SearchServiceApplicationProxy proxy =
(SearchServiceApplicationProxy)SearchServiceApplicationProxy.GetProxy(SPServiceContext.GetContext(SPContext.Current.Site));
KeywordQuery query = new KeywordQuery(proxy);
//query.EnableFQL = true;
query.QueryText = propertyName + ":\"" + tags[0] + "\"";
if (tags.Length > 1)
{
for (int i = 1; i < tags.Length; i++)
{
query.QueryText += " OR " + propertyName + ":\"" + tags[i] + "\"";
}
}
query.ResultsProvider = SearchProvider.Default;
query.ResultTypes = ResultType.RelevantResults;
query.StartRow = 0;
query.RowLimit = 5000;
query.TrimDuplicates = false;
query.SelectProperties.Add("Path");
query.SelectProperties.Add("title");
query.SelectProperties.Add("Descrizione");
query.SelectProperties.Add(propertyName);
query.SelectProperties.Add("TipoContenuto");
query.SelectProperties.Add("Created");
query.SelectProperties.Add("SiteTitle");
query.SelectProperties.Add("SiteName");
query.SortList.Add("Rank", Microsoft.Office.Server.Search.Query.SortDirection.Descending);
//
ResultTableCollection resultTables = query.Execute();
ResultTable relevantResults = resultTables[ResultType.RelevantResults];
resultsDataTable.Load(relevantResults, LoadOption.OverwriteChanges);
}
return(resultsDataTable);
}
public ResultTableCollection ExecuteSearch(ClientContext context, string location, bool searchOnlySiteCollection)
{
SearchExecutor searchExecutor = new SearchExecutor(context);
KeywordQuery keywordQuery = searchOnlySiteCollection ? SharepointCsomProvider.GetKeywordQueryForSiteCollectionOnly(location, context) : SharepointCsomProvider.GetKeywordQuery(location, context);
ClientResult <ResultTableCollection> clientResult = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
return(clientResult.Value);
}
public List <Dictionary <string, string> > Search(Web web, string keywordQueryValue, List <string> propertiesToRetrieve, bool trimDuplicates = false)
{
try
{
List <Dictionary <string, string> > sites = new List <Dictionary <string, string> >();
KeywordQuery keywordQuery = new KeywordQuery(web.Context);
keywordQuery.TrimDuplicates = trimDuplicates;
keywordQuery.SourceId = localSharePointResultsSourceId;
//property IndexDocId is required, so add it if not yet present
if (!propertiesToRetrieve.Contains("IndexDocId"))
{
propertiesToRetrieve.Add("IndexDocId");
}
int totalRows = 0;
Log($"Start search query {keywordQueryValue}");
totalRows = this.ProcessQuery(web, keywordQueryValue, propertiesToRetrieve, sites, keywordQuery);
Log($"Found {totalRows} rows...");
if (totalRows > 0)
{
string previousLastIndexDocId = null;
while (totalRows > 0)
{
string lastIndexDocIdString = "";
double lastIndexDocId = 0;
if (sites.Last().TryGetValue("IndexDocId", out lastIndexDocIdString))
{
// Leave the loop if for some reason we're getting the same lastIndexDocId --> should not happen, this is an
// extra safety to prevent from getting stuck in an infinite loop.
if (previousLastIndexDocId != null && previousLastIndexDocId.Equals(lastIndexDocIdString))
{
Log($"Breaking loop, lastIndexDocId was {previousLastIndexDocId}");
break;
}
lastIndexDocId = double.Parse(lastIndexDocIdString);
Log($"Retrieving a batch of up to 500 search results");
keywordQuery.SourceId = localSharePointResultsSourceId;
totalRows = this.ProcessQuery(web, keywordQueryValue + " AND IndexDocId >" + lastIndexDocId, propertiesToRetrieve, sites, keywordQuery);// From the second Query get the next set (rowlimit) of search result based on IndexDocId
previousLastIndexDocId = lastIndexDocIdString;
}
}
}
return(sites);
}
catch (Exception)
{
// rethrow does lose one line of stack trace, but we want to log the error at the component boundary
throw;
}
}
public ResultTableCollection ExecuteSearch(ClientContext context, Guid webId, Guid siteId)
{
SearchExecutor searchExecutor = new SearchExecutor(context);
KeywordQuery keywordQuery = SharepointCsomProvider.GetKeywordQuery(webId, siteId, context);
ClientResult <ResultTableCollection> clientResult = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
return(clientResult.Value);
}
private static void FillSelectProperties(string select, KeywordQuery query)
{
if (!string.IsNullOrEmpty(select))
{
var properties = select.Split(new[] { ',' }, System.StringSplitOptions.RemoveEmptyEntries);
query.SelectProperties.Clear();
query.SelectProperties.AddRange(properties);
}
}
/// <summary>
/// Get the peer url for a page represents a cross site publishing catalog item
/// </summary>
/// <param name="currentUrl">The current page url</param>
/// <param name="label">The target label to resolve</param>
/// <param name="associationKeyManagedPropertyName">The content association key search managed property name</param>
/// <param name="associationKeyValue">The value of the content association key for the current item</param>
/// <param name="languageManagedPropertyName">The language search managed property name</param>
/// <param name="catalogNavigationTermManagedPropertyName">The navigation search managed property name used for the friendly url generation</param>
/// <returns>The url of the peer page</returns>
public Uri GetPeerCatalogItemUrl(
Uri currentUrl,
VariationLabelInfo label,
string associationKeyManagedPropertyName,
string associationKeyValue,
string languageManagedPropertyName,
string catalogNavigationTermManagedPropertyName)
{
ValidateProperties("GetPeerCatalogItemUrl", associationKeyManagedPropertyName, associationKeyValue, catalogNavigationTermManagedPropertyName);
var url = new Uri(Variations.GetPeerUrl(SPContext.Current.Web, currentUrl.AbsoluteUri, label.Title), UriKind.Relative);
var searchResultSource = this.searchHelper.GetResultSourceByName(SPContext.Current.Site, LocalSharePointResultsSourceName, SearchObjectLevel.Ssa);
// We take the Title of the Label because the Label.Language is always a language from a language pack (supported). Sometimes, we deal with Not implemented language (ie Inuktitut "IU").
// Our workaround is to set the Title as the agnostic language label ("en", "fr", "iu", etc).
// For backward compatibility purpose, we will test the length of the Title. If it's not 2, we will fallback on the Language of the Label.
// This is not 100% robust but it the only way we found to deal with unsupported language.
var labelLocaleAgnosticLanguage = label.Title.Length == 2 ? label.Title : label.Language.Split('-').FirstOrDefault();
var queryText = string.Format(
CultureInfo.InvariantCulture,
"{0}:{1} {2}={3}",
associationKeyManagedPropertyName,
associationKeyValue,
languageManagedPropertyName,
labelLocaleAgnosticLanguage);
var query = new KeywordQuery(SPContext.Current.Web)
{
SourceId = searchResultSource.Id,
QueryText = queryText
};
// Search query must include the following properties for the friendly URL to work
query.SelectProperties.AddRange(new[]
{
catalogNavigationTermManagedPropertyName,
BuiltInManagedProperties.Url,
BuiltInManagedProperties.SiteUrl,
BuiltInManagedProperties.ListId
});
var tables = new SearchExecutor().ExecuteQuery(query);
if (tables.Exists(KnownTableTypes.RelevantResults))
{
var table = tables.Filter("TableType", KnownTableTypes.RelevantResults).Single(relevantTable => relevantTable.QueryRuleId == Guid.Empty);
if (table != null && table.ResultRows.Count == 1 && table.Table.Columns.Contains(BuiltInManagedProperties.Url))
{
url = new Uri(table.Table.Rows[0][BuiltInManagedProperties.Url].ToString());
}
}
return(url);
}
private List <SiteData> GetSites(ClientContext clientContext)
{
List <SiteData> sites = new List <SiteData>();
KeywordQuery keywordQuery = new KeywordQuery(clientContext);
string keywordQueryValue = "contentclass:\"STS_Site\"";
ProcessQuery(keywordQueryValue, sites, clientContext, keywordQuery, 0);
return(sites);
}
/* It includes methods related to SampleEntity */
#endregion
#region Methods
public static List <SearchModel> QuerySearchResults(string siteUrl, string queryText, string contentTypeId, int contentTypeCode, string contentTypeName, string redirectUrl)
{
try
{
List <SearchModel> searchResults = new List <SearchModel>();
System.Net.NetworkCredential credentials = new System.Net.NetworkCredential(Data.DataStatics.UserNameForService, Data.DataStatics.PasswordForService, Data.DataStatics.DomainForService);
ClientContext clientContext = new ClientContext(siteUrl);
clientContext.Credentials = credentials;
KeywordQuery keywordQuery = new KeywordQuery(clientContext);
keywordQuery.QueryText = queryText;
keywordQuery.SortList.Add("Created", SortDirection.Descending);
string filter1 = "contenttypeid:equals(\"{0}\")";
keywordQuery.RefinementFilters.Add(string.Format(filter1, contentTypeId));
keywordQuery.SelectProperties.Add("ContentTypeId");
keywordQuery.SelectProperties.Add("Title");
keywordQuery.SelectProperties.Add("ListItemID");
keywordQuery.RowLimit = 10;
keywordQuery.ClientType = "ContentSearchRegular";
SearchExecutor searchExecutor = new SearchExecutor(clientContext);
ClientResult <ResultTableCollection> results = searchExecutor.ExecuteQuery(keywordQuery);
clientContext.ExecuteQuery();
IEnumerable <IDictionary <string, object> > resultTable = results.Value[0].ResultRows;
if (resultTable != null)
{
foreach (var resultRow in resultTable)
{
SearchModel newSearchItem = new SearchModel();
newSearchItem.Title = resultRow["Title"].ToString();
newSearchItem.ListItemId = resultRow["ListItemID"].ToString();
newSearchItem.ContentTypeId = resultRow["ContentTypeId"].ToString();
newSearchItem.ContentTypeName = contentTypeName;
newSearchItem.ContentTypeCode = contentTypeCode;
newSearchItem.RedirectUrl = redirectUrl;
searchResults.Add(newSearchItem);
}
}
clientContext.Dispose();
return(searchResults);
}
catch (Exception ex)
{
EXP.RedirectToErrorPage(ex.Message);
return(null);
}
}
void oWorker_DoWork(object sender, DoWorkEventArgs e)
{
int StartRow = 0;
try
{
string mp = "Title,Path,SPSiteURL,ListItemID,ListID,UniqueID,Language";
KeywordQuery kq = GetQuery("ContentType:gbBook", mp, 0);
ResultTable firstResults = GetResults(kq);
List <dynamic> items = new List <dynamic>();
items = UpdateItems(items, firstResults, mp);
//if (firstResults.RowCount != firstResults.TotalRows)
//{
// while ((StartRow + 500) < firstResults.TotalRows)
// {
// StartRow += 500;
// ShowProgress("Starting At: " + StartRow);
// KeywordQuery nestedkq = GetQuery("ContentType:gbBook", "Title;Path", StartRow);
// ResultTable nestedResults = GetResults(kq);
// items = UpdateItems(items, nestedResults,mp);
// }
//}
System.Diagnostics.Trace.WriteLine(firstResults.TotalRows);
List lst = ctx.Web.Lists.GetByTitle("BookInfo");
ctx.Load(lst);
ctx.ExecuteQuery();
foreach (IDictionary <string, object> item in firstResults.ResultRows)
{
string id = item["UniqueID"].ToString();
ListItem itm = lst.GetItemByField(id, "ItemUniqueId");
if (itm == null)
{
ListItemCreationInformation lici = new ListItemCreationInformation();
ListItem newItem = lst.AddItem(lici);
newItem["ItemUniqueId"] = id;
}
itm["Title"] = item["Title"].ToString();
itm["Language"] = item["Language"].ToString();
itm.Update();
ctx.ExecuteQuery();
}
}
catch (Exception ex)
{
ShowError(ex, "metadataWorker.oWorker_DoWork", "");
}
}
/// <summary>
/// Returns the Keyword query object with refiners added for sorting
/// </summary>
/// <param name="keywordQuery">Keyword object</param>
/// <param name="sortByProperty">Property by which sort is applied</param>
/// <param name="sortDirection">Direction in which sort is applied (0 --> Ascending order and 1 --> Descending order)</param>
/// <returns>Keyword object with sorting refiners applied</returns>
internal static KeywordQuery AddSortingRefiner(KeywordQuery keywordQuery, string sortByProperty, int sortDirection)
{
if (0 == sortDirection)
{
keywordQuery.SortList.Add(sortByProperty, Microsoft.SharePoint.Client.Search.Query.SortDirection.Ascending);
}
else if (1 == sortDirection)
{
keywordQuery.SortList.Add(sortByProperty, Microsoft.SharePoint.Client.Search.Query.SortDirection.Descending);
}
return keywordQuery;
}
/// <summary>
/// Get the peer url for a page represents a cross site publishing catalog item
/// </summary>
/// <param name="currentUrl">The current page url</param>
/// <param name="label">The target label to resolve</param>
/// <param name="associationKeyManagedPropertyName">The content association key search managed property name</param>
/// <param name="associationKeyValue">The value of the content association key for the current item</param>
/// <param name="languageManagedPropertyName">The language search managed property name</param>
/// <param name="catalogNavigationTermManagedPropertyName">The navigation search managed property name used for the friendly url generation</param>
/// <returns>The url of the peer page</returns>
public Uri GetPeerCatalogItemUrl(
Uri currentUrl,
VariationLabelInfo label,
string associationKeyManagedPropertyName,
string associationKeyValue,
string languageManagedPropertyName,
string catalogNavigationTermManagedPropertyName)
{
ValidateProperties("GetPeerCatalogItemUrl", associationKeyManagedPropertyName, associationKeyValue, catalogNavigationTermManagedPropertyName);
var url = new Uri(Variations.GetPeerUrl(SPContext.Current.Web, currentUrl.AbsolutePath, label.Title), UriKind.Relative);
var searchResultSource = this.searchHelper.GetResultSourceByName(SPContext.Current.Site, LocalSharePointResultsSourceName, SearchObjectLevel.Ssa);
var queryText = string.Format(
CultureInfo.InvariantCulture,
"{0}:{1} {2}:{3}",
associationKeyManagedPropertyName,
associationKeyValue,
languageManagedPropertyName,
label.Locale);
var query = new KeywordQuery(SPContext.Current.Web)
{
SourceId = searchResultSource.Id,
QueryText = queryText
};
// Search query must include the following properties for the friendly URL to work
query.SelectProperties.AddRange(new[]
{
catalogNavigationTermManagedPropertyName,
BuiltInManagedProperties.Url.Name,
BuiltInManagedProperties.SiteUrl.Name,
BuiltInManagedProperties.ListId.Name
});
var tables = new SearchExecutor().ExecuteQuery(query);
if (tables.Exists(KnownTableTypes.RelevantResults))
{
var table = tables.Filter("TableType", KnownTableTypes.RelevantResults).Single(relevantTable => relevantTable.QueryRuleId == Guid.Empty);
if (table != null && table.ResultRows.Count == 1 && table.Table.Columns.Contains(BuiltInManagedProperties.Url.Name))
{
url = new Uri(table.Table.Rows[0][BuiltInManagedProperties.Url.Name].ToString(), UriKind.Absolute);
// Convert the absolute Uri into a relative Uri. This is required for environments using a load balancer,
// because we need to ignore the load balancer's port found in the absolute Uri.
url = new Uri(url.AbsolutePath, UriKind.Relative);
}
}
return(url);
}
public WhereExpressionScope(KeywordQueryCamlVisitor visitor, CamlLogicalOperator currentOperator)
{
if (!visitor.whereExpressionScope)
{
visitor.whereExpressionScope = true;
this.query = visitor.query;
this.queryBuilder = visitor.queryBuilder;
}
this.previousOperator = visitor.currentOperater;
this.visitor = visitor;
visitor.currentOperater = currentOperator == CamlLogicalOperator.Not ? previousOperator : currentOperator;
}
protected override void ExecuteCmdlet()
{
var keywordQuery = new KeywordQuery(ClientContext);
// Construct query to execute
var query = "contentclass:STS_Site";
if(!string.IsNullOrEmpty(Query))
{
query = query + " AND " + Query;
}
keywordQuery.QueryText = query;
keywordQuery.RowLimit = MaxResults;
keywordQuery.StartRow = StartRow;
keywordQuery.SelectProperties.Add("Title");
keywordQuery.SelectProperties.Add("SPSiteUrl");
keywordQuery.SelectProperties.Add("Description");
keywordQuery.SelectProperties.Add("WebTemplate");
keywordQuery.SortList.Add("SPSiteUrl", SortDirection.Ascending);
SearchExecutor searchExec = new SearchExecutor(ClientContext);
// Important to avoid trimming "similar" site collections
keywordQuery.TrimDuplicates = false;
ClientResult<ResultTableCollection> results = searchExec.ExecuteQuery(keywordQuery);
ClientContext.ExecuteQueryRetry();
var dynamicList = new List<dynamic>();
if (results != null)
{
if (results.Value[0].RowCount > 0)
{
foreach (var row in results.Value[0].ResultRows)
{
dynamicList.Add(
new {
Title = row["Title"] != null ? row["Title"].ToString() : "",
Url = row["SPSiteUrl"] != null ? row["SPSiteUrl"].ToString() : "",
Description = row["Description"] != null ? row["Description"].ToString() : "",
WebTemplate = row["WebTemplate"] != null ? row["WebTemplate"].ToString() : ""
});
}
}
}
WriteObject(dynamicList, true);
}
/// <summary>
/// Adds date refinement filter to the keyword query object
/// </summary>
/// <param name="keywordQuery">The keyword query</param>
/// <param name="fromDate">From date</param>
/// <param name="toDate">To date</param>
/// <param name="managedProperty">Managed property name</param>
/// <returns>Returns a keyword query object</returns>
internal static KeywordQuery AddDateRefinementFilter(KeywordQuery keywordQuery, string fromDate, string toDate, string managedProperty)
{
if (!string.IsNullOrWhiteSpace(fromDate) && !string.IsNullOrWhiteSpace(toDate))
{
keywordQuery.RefinementFilters.Add(string.Concat(managedProperty, ConstantStrings.COLON, ConstantStrings.OperatorRange, ConstantStrings.OpeningBracket, fromDate, ConstantStrings.Comma, toDate, ConstantStrings.ClosingBracket));
}
else if (string.IsNullOrWhiteSpace(fromDate) && !string.IsNullOrWhiteSpace(toDate))
{
keywordQuery.RefinementFilters.Add(string.Concat(managedProperty, ConstantStrings.COLON, ConstantStrings.OperatorRange, ConstantStrings.OpeningBracket, ConstantStrings.MinDate, ConstantStrings.Comma, toDate, ConstantStrings.ClosingBracket));
}
else if (!string.IsNullOrWhiteSpace(fromDate) && string.IsNullOrWhiteSpace(toDate))
{
keywordQuery.RefinementFilters.Add(string.Concat(managedProperty, ConstantStrings.COLON, ConstantStrings.OperatorRange, ConstantStrings.OpeningBracket, fromDate, ConstantStrings.Comma, ConstantStrings.MaxDate, ConstantStrings.ClosingBracket));
}
return keywordQuery;
}
public async void LoadResults(string siteUrl, string keywords, string login, string mdp)
{
ObservableCollection<CortanaItem> cortanaResults = new ObservableCollection<CortanaItem>();
keywords = keywords.Trim('.').ToLower();
try
{
using (ClientContext context = new ClientContext(siteUrl))
{
SharePointOnlineCredentials credentials = new SharePointOnlineCredentials(login, mdp);
context.Credentials = credentials;
KeywordQuery keywordQuery = new KeywordQuery(context);
keywordQuery.QueryText = keywords;
keywordQuery.SourceId = new Guid(SettingsValues.SourceId);
keywordQuery.EnablePhonetic = true;
keywordQuery.EnableStemming = true;
keywordQuery.RowLimit = 100;
SearchExecutor searchExecutor = new SearchExecutor(context);
ClientResult<ResultTableCollection> results = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQueryAsync().Wait();
foreach (var item in results.Value[0].ResultRows)
{
CortanaItem ci = new CortanaItem();
ci.Id = item["ID"] != null ? item["ID"].ToString() : string.Empty;
ci.Title = item["Title"] != null ? item["Title"].ToString() : string.Empty;
ci.LastModifiedDate = item["Modified"] != null ? item["Modified"].ToString() : string.Empty;
ci.Url = item["Path"] != null ? item["Path"].ToString() : string.Empty;
cortanaResults.Add(ci);
}
}
LoadDataCompleted(cortanaResults); // Fire event DataLoadCompleted
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Erreur : " + ex.Message);
LoadDataCompleted(null);
}
}
//
static void Main(string[] args) {
//
using (ClientContext context = new ClientContext(global::VS13.Properties.Settings.Default.SharePointServerUrl)) {
//
KeywordQuery query = new KeywordQuery(context);
query.StartRow = 0;
query.RowLimit = 500;
query.EnableStemming = true;
query.TrimDuplicates = false;
//query.QueryText = "tiff";
query.QueryText = "scope:\"All Sites\" AND contentclass:\"STS_ListItem_DocumentLibrary\" AND IsDocument:\"True\" AND Created:2013-08-05";
query.SelectProperties.Add("scope");
query.SelectProperties.Add("contentclass");
query.SelectProperties.Add("IsDocument");
query.SelectProperties.Add("DAV:displayname");
query.SelectProperties.Add("DAV:href");
query.SelectProperties.Add("TBBARCODEOWSTEXT");
query.SelectProperties.Add("BatchDateOWSDATE");
query.SelectProperties.Add("Created");
ClientResult<ResultTableCollection> results = new SearchExecutor(context).ExecuteQuery(query);
context.ExecuteQuery();
foreach (IDictionary result in results.Value[0].ResultRows) {
Console.WriteLine("{0}: {1}","scope",result["scope"]);
Console.WriteLine("{0}: {1}","contentclass",result["contentclass"]);
Console.WriteLine("{0}: {1}","IsDocument",result["IsDocument"]);
Console.WriteLine("{0}: {1}","DAV:displayname",result["DAV:displayname"]);
Console.WriteLine("{0}: {1}","DAV:href",result["DAV:href"]);
Console.WriteLine("{0}: {1}","BOLNumOWSTEXT",result["BOLNumOWSTEXT"]);
Console.WriteLine("{0}: {1}","BatchDateOWSDATE",result["BatchDateOWSDATE"]);
Console.WriteLine("{0}: {1}","Created",result["Created"]);
Console.WriteLine("{0}: {1}","Title",result["Title"]);
Console.WriteLine("{0}: {1}","Path",result["Path"]);
Console.WriteLine("{0}: {1}","Description",result["Description"]);
}
Console.ReadLine();
}
}
/// <summary>
/// Get the peer url for a page represents a cross site publishing catalog item
/// </summary>
/// <param name="currentUrl">The current page url</param>
/// <param name="label">The target label to resolve</param>
/// <param name="associationKeyManagedPropertyName">The content association key search managed property name</param>
/// <param name="associationKeyValue">The value of the content association key for the current item</param>
/// <param name="languageManagedPropertyName">The language search managed property name</param>
/// <param name="catalogNavigationTermManagedPropertyName">The navigation search managed property name used for the friendly url generation</param>
/// <returns>The url of the peer page</returns>
public Uri GetPeerCatalogItemUrl(
Uri currentUrl,
VariationLabelInfo label,
string associationKeyManagedPropertyName,
string associationKeyValue,
string languageManagedPropertyName,
string catalogNavigationTermManagedPropertyName)
{
ValidateProperties("GetPeerCatalogItemUrl", associationKeyManagedPropertyName, associationKeyValue, catalogNavigationTermManagedPropertyName);
var url = new Uri(Variations.GetPeerUrl(SPContext.Current.Web, currentUrl.AbsolutePath, label.Title), UriKind.Relative);
var searchResultSource = this.searchHelper.GetResultSourceByName(SPContext.Current.Site, LocalSharePointResultsSourceName, SearchObjectLevel.Ssa);
var queryText = string.Format(
CultureInfo.InvariantCulture,
"{0}:{1} {2}:{3}",
associationKeyManagedPropertyName,
associationKeyValue,
languageManagedPropertyName,
label.Language);
var query = new KeywordQuery(SPContext.Current.Web)
{
SourceId = searchResultSource.Id,
QueryText = queryText
};
// Search query must include the following properties for the friendly URL to work
query.SelectProperties.AddRange(new[]
{
catalogNavigationTermManagedPropertyName,
BuiltInManagedProperties.Url.Name,
BuiltInManagedProperties.SiteUrl.Name,
BuiltInManagedProperties.ListId.Name
});
var tables = new SearchExecutor().ExecuteQuery(query);
if (tables.Exists(KnownTableTypes.RelevantResults))
{
var table = tables.Filter("TableType", KnownTableTypes.RelevantResults).Single(relevantTable => relevantTable.QueryRuleId == Guid.Empty);
if (table != null && table.ResultRows.Count == 1 && table.Table.Columns.Contains(BuiltInManagedProperties.Url.Name))
{
url = new Uri(table.Table.Rows[0][BuiltInManagedProperties.Url.Name].ToString(), UriKind.Absolute);
// Convert the absolute Uri into a relative Uri. This is required for environments using a load balancer,
// because we need to ignore the load balancer's port found in the absolute Uri.
url = new Uri(url.AbsolutePath, UriKind.Relative);
}
}
return url;
}
public ClientResult<ResultTableCollection> ExecuteSearchQuery(
string query, string sorting = null, string rankModel = null)
{
var keywordQuery = new KeywordQuery(_clientContext){ QueryText = query};
// Ranking model to use
if (!String.IsNullOrEmpty(rankModel))
keywordQuery.RankingModelId = rankModel;
// If sorting parameter provided
if (!String.IsNullOrEmpty(sorting))
keywordQuery.SortList.Add(sorting, SortDirection.Descending);
// Select only this properties for documents
keywordQuery.SelectProperties.Add("Title");
keywordQuery.SelectProperties.Add("Path");
keywordQuery.SelectProperties.Add("ServerRedirectedURL");
keywordQuery.SelectProperties.Add("ModifiedOWSDATE");
keywordQuery.SelectProperties.Add("ModifiedBy");
keywordQuery.SelectProperties.Add("CreatedOWSDATE");
keywordQuery.SelectProperties.Add("CreatedBy");
keywordQuery.SelectProperties.Add("SPWebUrl");
keywordQuery.SelectProperties.Add("Rank");
keywordQuery.SelectProperties.Add("LastModifiedTime");
// Select only this properties for tasks
keywordQuery.SelectProperties.Add("StatusOWSCHCS");
keywordQuery.SelectProperties.Add("PercentCompleteOWSNMBR");
keywordQuery.SelectProperties.Add("AssignedTo");
keywordQuery.SelectProperties.Add("DueDateOWSDATE");
keywordQuery.SelectProperties.Add("StartDateOWSDATE");
// Select only this properties for events
keywordQuery.SelectProperties.Add("EventDateOWSDATE");
keywordQuery.SelectProperties.Add("EndDateOWSDATE");
var searchExecutor = new SearchExecutor(_clientContext);
var results = searchExecutor.ExecuteQuery(keywordQuery);
return results;
}
private List<string> GetMemberSites()
{
var siteUri = new Uri(ConfigurationManager.AppSettings["SiteCollectionRequests_SiteUrl"]);
using (var context = this.contextFactory.GetContext(siteUri.ToString()))
{
var keywordQuery = new KeywordQuery(context);
keywordQuery.QueryText = "rdoyle AND SiteGroup:\"Team\"";
keywordQuery.TrimDuplicates = false;
var searchExecutor = new SearchExecutor(context);
var results = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
}
return new List<string>();
}
/// <summary>
/// Returns the site collections that comply with the passed keyword query
/// </summary>
/// <param name="web">Site to be processed - can be root web or sub site</param>
/// <param name="keywordQueryValue">Keyword query</param>
/// <returns>All found site collections</returns>
public static List<SiteEntity> SiteSearch(this Web web, string keywordQueryValue)
{
try
{
LoggingUtility.Internal.TraceVerbose("Site search '{0}'", keywordQueryValue);
List<SiteEntity> sites = new List<SiteEntity>();
KeywordQuery keywordQuery = new KeywordQuery(web.Context);
keywordQuery.TrimDuplicates = false;
if (keywordQueryValue.Length == 0)
{
keywordQueryValue = "contentclass:\"STS_Site\"";
}
int startRow = 0;
int totalRows = 0;
totalRows = web.ProcessQuery(keywordQueryValue, sites, keywordQuery, startRow);
if (totalRows > 0)
{
while (totalRows >= sites.Count)
{
startRow += 500;
totalRows = web.ProcessQuery(keywordQueryValue, sites, keywordQuery, startRow);
}
}
return sites;
}
catch (Exception ex)
{
LoggingUtility.Internal.TraceError((int)EventId.SiteSearchUnhandledException, ex, "Site search error.");
// rethrow does lose one line of stack trace, but we want to log the error at the component boundary
throw;
}
}
/// <summary>
///
/// </summary>
/// <param name="cc">ClientContext object of an arbitrary site collection accessible by the defined enumeration username and password</param>
/// <param name="keywordQueryValue">Query to execute</param>
/// <param name="sites">List of found site collections</param>
/// <param name="keywordQuery">KeywordQuery instance that will perform the actual queries</param>
/// <param name="startRow">Row as of which we want to see the results</param>
/// <returns>Total result rows of the query</returns>
private static int ProcessQuery(ClientRuntimeContext cc, string keywordQueryValue, List<string> sites, KeywordQuery keywordQuery, int startRow)
{
int totalRows = 0;
keywordQuery.QueryText = keywordQueryValue;
keywordQuery.RowLimit = 500;
keywordQuery.StartRow = startRow;
keywordQuery.SelectProperties.Add("SPSiteUrl");
keywordQuery.SortList.Add("SPSiteUrl", SortDirection.Ascending);
SearchExecutor searchExec = new SearchExecutor(cc);
ClientResult<ResultTableCollection> results = searchExec.ExecuteQuery(keywordQuery);
cc.ExecuteQueryRetry();
if (results != null)
{
if (results.Value[0].RowCount > 0)
{
totalRows = results.Value[0].TotalRows;
foreach (var row in results.Value[0].ResultRows)
{
if (row["SPSiteUrl"] != null)
{
sites.Add(row["SPSiteUrl"].ToString());
}
}
}
}
return totalRows;
}
/// <summary>
/// Defines the sorting property and direction for querying SharePoint Search.
/// </summary>
/// <param name="keywordQuery">Keyword object</param>
/// <param name="searchObject">Search object</param>
/// <param name="isMatterSearch">Boolean flag which determines current search is for matters or documents</param>
/// <returns></returns>
internal static KeywordQuery GetSortByProperty(KeywordQuery keywordQuery, SearchObject searchObject, Boolean isMatterSearch)
{
string matterIDRefiner = string.Empty;
////Sorting by specified property 0 --> Ascending order and 1 --> Descending order
if (!string.IsNullOrWhiteSpace(searchObject.Sort.ByProperty))
{
keywordQuery = AddSortingRefiner(keywordQuery, searchObject.Sort.ByProperty, searchObject.Sort.Direction);
//// Add Matter ID property as second level sort for Client.MatterID column based on Search Matter or Search Document
if (SearchConstants.ManagedPropertyClientID == searchObject.Sort.ByProperty || SearchConstants.ManagedPropertyDocumentClientId == searchObject.Sort.ByProperty)
{
if (isMatterSearch)
{
matterIDRefiner = SearchConstants.ManagedPropertyMatterId;
}
else
{
matterIDRefiner = SearchConstants.ManagedPropertyDocumentMatterId;
}
keywordQuery = AddSortingRefiner(keywordQuery, matterIDRefiner, searchObject.Sort.Direction);
}
}
return keywordQuery;
}
/// <summary>
/// Fires query on SharePoint Search and fills the result data.
/// </summary>
/// <param name="clientContext">The client context.</param>
/// <param name="keywordQuery">The keyword query.</param>
/// <param name="searchObject">The search object.</param>
/// <param name="isMatterSearch">The flag to determine weather call is from Search Matter or Search Document.</param>
/// <param name="managedProperties">List of managed properties</param>
/// <returns>It returns a string object, that contains all the results combined with dollar pipe dollar separator.</returns>
internal static string FillResultData(ClientContext clientContext, KeywordQuery keywordQuery, SearchObject searchObject, Boolean isMatterSearch, List<string> managedProperties)
{
string result = string.Empty;
Boolean isReadOnly;
try
{
if (null != searchObject.Sort)
{
keywordQuery.EnableSorting = true;
keywordQuery = SearchHelperFunctions.GetSortByProperty(keywordQuery, searchObject, isMatterSearch);
}
SearchExecutor searchExecutor = new SearchExecutor(clientContext);
ClientResult<ResultTableCollection> resultsTableCollection = searchExecutor.ExecuteQuery(keywordQuery);
Users currentLoggedInUser = UIUtility.GetLoggedInUserDetails(clientContext);
if (null != resultsTableCollection && null != resultsTableCollection.Value && 0 < resultsTableCollection.Value.Count && null != resultsTableCollection.Value[0].ResultRows)
{
if (isMatterSearch && 0 < resultsTableCollection.Value.Count && null != resultsTableCollection.Value[0].ResultRows && (!string.IsNullOrWhiteSpace(currentLoggedInUser.Name) || !string.IsNullOrWhiteSpace(currentLoggedInUser.Email)))
{
foreach (IDictionary<string, object> matterMetadata in resultsTableCollection.Value[0].ResultRows)
{
isReadOnly = false;
if (null != matterMetadata)
{
// Decode matter properties
DecodeMatterProperties(matterMetadata);
string readOnlyUsers = Convert.ToString(matterMetadata[SearchConstants.ManagedPropertyBlockedUploadUsers], CultureInfo.InvariantCulture);
if (!string.IsNullOrWhiteSpace(readOnlyUsers))
{
isReadOnly = IsUserReadOnlyForMatter(isReadOnly, currentLoggedInUser.Name, currentLoggedInUser.Email, readOnlyUsers);
}
matterMetadata.Add(TextConstants.IsReadOnlyUser, isReadOnly);
}
}
}
else
{
/*Keeping the code to clean the author values*/
foreach (IDictionary<string, object> documentMetadata in resultsTableCollection.Value[0].ResultRows)
{
if (null != documentMetadata)
{
string authorData = Convert.ToString(documentMetadata[SearchConstants.ManagedPropertyAuthor], CultureInfo.InvariantCulture);
int ltIndex = authorData.IndexOf(ConstantStrings.OpeningAngularBracket, StringComparison.Ordinal);
int gtIndex = authorData.IndexOf(ConstantStrings.ClosingAngularBracket, StringComparison.Ordinal);
authorData = (0 <= ltIndex && ltIndex < gtIndex) ? authorData.Remove(ltIndex, (gtIndex - ltIndex) + 1) : authorData;
authorData = authorData.Replace(ServiceConstantStrings.DoubleQuotes, string.Empty);
documentMetadata[SearchConstants.ManagedPropertyAuthor] = authorData.Trim();
}
}
}
if (1 < resultsTableCollection.Value.Count)
{
result = string.Concat(JsonConvert.SerializeObject(resultsTableCollection.Value[0].ResultRows), ConstantStrings.DOLLAR, ConstantStrings.Pipe, ConstantStrings.DOLLAR, resultsTableCollection.Value[0].TotalRows, ConstantStrings.DOLLAR, ConstantStrings.Pipe, ConstantStrings.DOLLAR, JsonConvert.SerializeObject(resultsTableCollection.Value[1].ResultRows));
}
else
{
if (0 == resultsTableCollection.Value[0].TotalRows)
{
result = SearchHelperFunctions.NoDataRow(managedProperties);
}
else
{
result = string.Concat(JsonConvert.SerializeObject(resultsTableCollection.Value[0].ResultRows), ConstantStrings.DOLLAR, ConstantStrings.Pipe, ConstantStrings.DOLLAR, resultsTableCollection.Value[0].TotalRows);
}
}
}
else
{
result = SearchHelperFunctions.NoDataRow(managedProperties);
}
}
catch (Exception exception)
{
result = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
return result;
}
/// <summary>
/// This method executes te search api to get most popular items from the current site
/// </summary>
/// <param name="clientContext"></param>
/// <param name="propListName"></param>
/// <param name="errMSG"></param>
/// <returns></returns>
public static string GetFAQFromSearchAPI(string propListName, string errMSG)
{
string mostPopular = string.Empty;
try
{
Web oWeb = clientContext.Web;
clientContext.Load(oWeb);
clientContext.ExecuteQuery();
KeywordQuery keywordQuery = new KeywordQuery(clientContext);
Uri uri = new Uri(oWeb.Url.ToString());
string urlPath = System.Web.HttpUtility.UrlPathEncode(uri.GetLeftPart(UriPartial.Authority) + GetListUrlByTitle(propListName)[0]);
string actualURL = string.Format(@"path:{0}", urlPath);
StringCollection selectProperties = keywordQuery.SelectProperties;
selectProperties.Add("LastModifiedTime");
selectProperties.Add("ContentTypeId");
selectProperties.Add("Title");
selectProperties.Add("Answer");
keywordQuery.QueryText = actualURL;
SearchExecutor searchExecutor = new SearchExecutor(clientContext);
ClientResult<ResultTableCollection> results = searchExecutor.ExecuteQuery(keywordQuery);
clientContext.ExecuteQuery();
mostPopular = GenerateFAQHTML(results, errMSG);
}
catch (Exception ex)
{
mostPopular = errMSG;
Logger.WriteLog(Logger.Category.Unexpected, string.Format("{0}-{1}", "CommonHelper", "GetFAQFromSearchAPI"), ex.StackTrace);
}
return mostPopular;
}
/// <summary>
/// Prepares and returns the query to filter the documents.
/// </summary>
/// <param name="searchObject">The search object.</param>
/// <param name="keywordQuery">The keyword query.</param>
/// <returns>It returns a Keyword Query object.</returns>
internal static KeywordQuery FilterDocuments(SearchObject searchObject, KeywordQuery keywordQuery)
{
string filterValues = string.Empty;
if (null != searchObject && null != keywordQuery)
{
if (null != searchObject.Filters)
{
keywordQuery = AddDateRefinementFilter(keywordQuery, searchObject.Filters.FromDate, searchObject.Filters.ToDate, SearchConstants.ManagedPropertyCreated);
if (null != searchObject.Filters.DocumentAuthor && !string.IsNullOrWhiteSpace(searchObject.Filters.DocumentAuthor))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertyAuthor, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.DocumentAuthor, ConstantStrings.DoubleQuote));
}
if (0 < searchObject.Filters.ClientsList.Count && !string.IsNullOrWhiteSpace(searchObject.Filters.ClientsList[0]))
{
filterValues = SearchHelperFunctions.FormFilterQuery(SearchConstants.ManagedPropertyDocumentClientName, searchObject.Filters.ClientsList);
keywordQuery.RefinementFilters.Add(filterValues);
}
/* New refinement filters for list view control */
if (!string.IsNullOrWhiteSpace(searchObject.Filters.Name))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertyFileName, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.Name, ConstantStrings.DoubleQuote));
}
if (!string.IsNullOrWhiteSpace(searchObject.Filters.ClientName))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertyDocumentClientName, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.ClientName, ConstantStrings.DoubleQuote));
}
if (null != searchObject.Filters.DocumentCheckoutUsers && !string.IsNullOrWhiteSpace(searchObject.Filters.DocumentCheckoutUsers))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertyDocumentCheckOutUser, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.DocumentCheckoutUsers, ConstantStrings.DoubleQuote));
}
}
keywordQuery = FilterCommonDetails(searchObject, keywordQuery, false);
}
return keywordQuery;
}
/// <summary>
/// Returns the query to filter the matters/ documents for common filters.
/// </summary>
/// <param name="searchObject">The search object.</param>
/// <param name="keywordQuery">The keyword query.</param>
/// <param name="isMatterView">Flag to identify matters/documents view.</param>
/// <returns>It returns a keyword query object.</returns>
internal static KeywordQuery FilterCommonDetails(SearchObject searchObject, KeywordQuery keywordQuery, bool isMatterView)
{
if (null != searchObject && null != keywordQuery)
{
if (null != searchObject.Filters.DateFilters)
{
string lastModifiedTime = SearchConstants.ManagedPropertyLastModifiedTime;
//// Add refiner for Modified date value
if (!isMatterView)
{
lastModifiedTime = SearchConstants.ManagedPropertyDocumentLastModifiedTime;
}
keywordQuery = AddDateRefinementFilter(keywordQuery, searchObject.Filters.DateFilters.ModifiedFromDate, searchObject.Filters.DateFilters.ModifiedToDate, lastModifiedTime);
////// Add refiner for Created date value
keywordQuery = AddDateRefinementFilter(keywordQuery, searchObject.Filters.DateFilters.CreatedFromDate, searchObject.Filters.DateFilters.CreatedToDate, SearchConstants.ManagedPropertyCreated);
}
}
return keywordQuery;
}
/// <summary>
/// Assigns the keyword query values.
/// </summary>
/// <param name="keywordQuery">The keyword query.</param>
/// <param name="managedProperties">The managed properties.</param>
/// <returns>It returns a Keyword Query object.</returns>
internal static KeywordQuery AssignKeywordQueryValues(KeywordQuery keywordQuery, List<string> managedProperties)
{
KeywordQuery result = null;
if (keywordQuery != null)
{
keywordQuery.SelectProperties.Clear();
foreach (string selectProperties in managedProperties)
{
keywordQuery.SelectProperties.Add(selectProperties);
}
result = keywordQuery;
}
else
{
result = null;
}
return result;
}
/// <summary>
/// Returns the query to filter the matters.
/// </summary>
/// <param name="searchObject">The search object.</param>
/// <param name="keywordQuery">The keyword query.</param>
/// <returns>It returns a keyword query object.</returns>
internal static KeywordQuery FilterMatters(SearchObject searchObject, KeywordQuery keywordQuery)
{
string filterValues = string.Empty;
if (null != searchObject && null != keywordQuery)
{
if (null != searchObject.Filters)
{
if (null != searchObject.Filters.AOLList && 0 < searchObject.Filters.AOLList.Count && !string.IsNullOrWhiteSpace(searchObject.Filters.AOLList[0]))
{
filterValues = SearchHelperFunctions.FormFilterQuery(SearchConstants.ManagedPropertyAreaOfLaw, searchObject.Filters.AOLList);
keywordQuery.RefinementFilters.Add(filterValues);
}
if (null != searchObject.Filters.PGList && 0 < searchObject.Filters.PGList.Count && !string.IsNullOrWhiteSpace(searchObject.Filters.PGList[0]))
{
filterValues = SearchHelperFunctions.FormFilterQuery(SearchConstants.ManagedPropertyPracticeGroup, searchObject.Filters.PGList);
keywordQuery.RefinementFilters.Add(filterValues);
}
keywordQuery = AddDateRefinementFilter(keywordQuery, searchObject.Filters.FromDate, searchObject.Filters.ToDate, SearchConstants.ManagedPropertyOpenDate);
if (null != searchObject.Filters.ClientsList && 0 < searchObject.Filters.ClientsList.Count && !string.IsNullOrWhiteSpace(searchObject.Filters.ClientsList[0]))
{
filterValues = SearchHelperFunctions.FormFilterQuery(SearchConstants.ManagedPropertyClientName, searchObject.Filters.ClientsList);
keywordQuery.RefinementFilters.Add(filterValues);
}
}
keywordQuery = FilterMattersUtility(searchObject, keywordQuery);
keywordQuery = SearchHelperFunctions.FilterCommonDetails(searchObject, keywordQuery, true);
}
return keywordQuery;
}
/// <summary>
/// Prepares and returns the keyword query to get data from SharePoint Search based on filtering condition.
/// </summary>
/// <param name="client">The client object</param>
/// <param name="searchObject">The search object.</param>
/// <param name="keywordQuery">The keyword query.</param>
/// <param name="filterCondition">The filter condition.</param>
/// <param name="managedProperty">The managed property.</param>
/// <param name="isMatterView">If the user is pinning a matter, this will be true, else will be false.</param>
/// <returns>It returns a Keyword Query object.</returns>
internal static KeywordQuery KeywordQueryMetrics(Client client, SearchObject searchObject, KeywordQuery keywordQuery, string filterCondition, string managedProperty, bool isMatterView)
{
KeywordQuery result = null;
try
{
if (ServiceConstantStrings.IsTenantDeployment)
{
keywordQuery.QueryText = searchObject.SearchTerm;
}
else
{
keywordQuery.QueryText = "(" + searchObject.SearchTerm + " AND site:" + client.Url + ")";
}
keywordQuery.RefinementFilters.Add(filterCondition);
if (isMatterView)
{
keywordQuery.RefinementFilters.Add(string.Concat(managedProperty, ConstantStrings.COLON, ConstantStrings.DoubleQuote, true, ConstantStrings.DoubleQuote));
}
else
{
string[] invalidExtensions = ServiceConstantStrings.FindDocumentInvalidExtensions.Split(',');
string chunk = string.Empty;
foreach (string extension in invalidExtensions)
{
chunk = chunk + "equals" + ConstantStrings.OpeningBracket + ConstantStrings.DoubleQuote + extension + ConstantStrings.DoubleQuote + ConstantStrings.ClosingBracket + ConstantStrings.Comma;
}
chunk = chunk.Remove(chunk.Length - 1);
keywordQuery.RefinementFilters.Add(string.Concat("not" + ConstantStrings.OpeningBracket + "FileType", ConstantStrings.COLON, ConstantStrings.OperatorOR + ConstantStrings.OpeningBracket +
chunk + ConstantStrings.ClosingBracket + ConstantStrings.ClosingBracket
));
keywordQuery.RefinementFilters.Add(string.Concat(managedProperty, ConstantStrings.COLON, "equals", ConstantStrings.OpeningBracket + ConstantStrings.DoubleQuote +
"1" + ConstantStrings.DoubleQuote + ConstantStrings.ClosingBracket
));
}
keywordQuery.TrimDuplicates = false;
if (0 < searchObject.PageNumber && 0 < searchObject.ItemsPerPage)
{
keywordQuery.StartRow = (searchObject.PageNumber - 1) * searchObject.ItemsPerPage;
keywordQuery.RowLimit = searchObject.ItemsPerPage;
}
result = keywordQuery;
}
catch (Exception exception)
{
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
result = null;
}
return result;
}
// private methods
/// <summary>
/// Runs a query
/// </summary>
/// <param name="web">Site to be processed - can be root web or sub site</param>
/// <param name="keywordQueryValue">keyword query </param>
/// <param name="sites">sites variable that hold the resulting sites</param>
/// <param name="keywordQuery">KeywordQuery object</param>
/// <param name="startRow">Start row of the resultset to be returned</param>
/// <returns>Total number of rows for the query</returns>
private static int ProcessQuery(this Web web, string keywordQueryValue, List<SiteEntity> sites, KeywordQuery keywordQuery, int startRow)
{
int totalRows = 0;
keywordQuery.QueryText = keywordQueryValue;
keywordQuery.RowLimit = 500;
keywordQuery.StartRow = startRow;
keywordQuery.SelectProperties.Add("Title");
keywordQuery.SelectProperties.Add("SPSiteUrl");
keywordQuery.SelectProperties.Add("Description");
keywordQuery.SelectProperties.Add("WebTemplate");
keywordQuery.SortList.Add("SPSiteUrl", SortDirection.Ascending);
SearchExecutor searchExec = new SearchExecutor(web.Context);
// Important to avoid trimming "similar" site collections
keywordQuery.TrimDuplicates = false;
ClientResult<ResultTableCollection> results = searchExec.ExecuteQuery(keywordQuery);
web.Context.ExecuteQueryRetry();
if (results != null)
{
if (results.Value[0].RowCount > 0)
{
totalRows = results.Value[0].TotalRows;
foreach (var row in results.Value[0].ResultRows)
{
sites.Add(new SiteEntity
{
Title = row["Title"] != null ? row["Title"].ToString() : "",
Url = row["SPSiteUrl"] != null ? row["SPSiteUrl"].ToString() : "",
Description = row["Description"] != null ? row["Description"].ToString() : "",
Template = row["WebTemplate"] != null ? row["WebTemplate"].ToString() : "",
});
}
}
}
return totalRows;
}
private DataTable GetItems()
{
DataTable resultsDataTable = new DataTable();
if (tags.Length > 0)
{
SPSite site = new SPSite(SPContext.Current.Site.Url);
/*
FullTextSqlQuery query = new FullTextSqlQuery(site);
query.Hint = QueryHint.OptimizeWithPropertyStore;
// inserito per prendere tutto. BUG della search
query.TrimDuplicates = false;
query.QueryText = "SELECT Path, title, Created, Tags, TipoContenuto, SiteTitle, SiteName FROM scope() WHERE \"scope\"='All Sites' AND (CONTAINS(Tags,'\"" + tags[0] + "\"')";
if (tags.Length > 1)
{
for (int i = 1; i < tags.Length; i++)
{
query.QueryText += " OR CONTAINS(Tags,'\"" + tags[i] + "\"')";
}
}
query.QueryText += ") ORDER BY LastModifiedTime Desc";
query.SiteContext = new Uri(site.Url);
query.ResultTypes = ResultType.RelevantResults;
* */
SearchServiceApplicationProxy proxy =
(SearchServiceApplicationProxy)SearchServiceApplicationProxy.GetProxy(SPServiceContext.GetContext(SPContext.Current.Site));
KeywordQuery query = new KeywordQuery(proxy);
//query.EnableFQL = true;
query.QueryText = propertyName + ":\"" + tags[0] + "\"";
if (tags.Length > 1)
{
for (int i = 1; i < tags.Length; i++)
{
query.QueryText += " OR " + propertyName + ":\"" + tags[i] + "\"";
}
}
query.ResultsProvider = SearchProvider.Default;
query.ResultTypes = ResultType.RelevantResults;
query.StartRow = 0;
query.RowLimit = 5000;
query.TrimDuplicates = false;
query.SelectProperties.Add("Path");
query.SelectProperties.Add("title");
query.SelectProperties.Add("Descrizione");
query.SelectProperties.Add(propertyName);
query.SelectProperties.Add("TipoContenuto");
query.SelectProperties.Add("Created");
query.SelectProperties.Add("SiteTitle");
query.SelectProperties.Add("SiteName");
query.SortList.Add("Rank", Microsoft.Office.Server.Search.Query.SortDirection.Descending);
//
ResultTableCollection resultTables = query.Execute();
ResultTable relevantResults = resultTables[ResultType.RelevantResults];
resultsDataTable.Load(relevantResults, LoadOption.OverwriteChanges);
}
return resultsDataTable;
}
public static List<SiteEntity> SiteSearch(this Web web, string keywordQueryValue, bool trimDublicates = true)
{
try
{
Log.Debug(Constants.LOGGING_SOURCE, "Site search '{0}'", keywordQueryValue);
List<SiteEntity> sites = new List<SiteEntity>();
KeywordQuery keywordQuery = new KeywordQuery(web.Context);
keywordQuery.TrimDuplicates = false;
if (keywordQueryValue.Length == 0)
{
keywordQueryValue = "contentclass:\"STS_Site\"";
}
int startRow = 0;
int totalRows = 0;
totalRows = web.ProcessQuery(keywordQueryValue, sites, keywordQuery, startRow);
if (totalRows > 0)
{
while (totalRows >= sites.Count)
{
startRow += 500;
totalRows = web.ProcessQuery(keywordQueryValue, sites, keywordQuery, startRow);
}
}
return sites;
}
catch (Exception ex)
{
Log.Error(Constants.LOGGING_SOURCE, CoreResources.WebExtensions_SiteSearchUnhandledException, ex.Message);
// rethrow does lose one line of stack trace, but we want to log the error at the component boundary
throw;
}
}
private static ResultTableCollection ExecuteKeywordQuery(SPSite site, string queryText)
{
SearchServiceApplicationProxy proxy = (SearchServiceApplicationProxy)SearchServiceApplicationProxy.GetProxy(SPServiceContext.GetContext(site));
KeywordQuery query = new KeywordQuery(proxy);
query.ResultsProvider = Microsoft.Office.Server.Search.Query.SearchProvider.Default;
query.SelectProperties.Add("ItemID");
query.QueryText = queryText;
query.ResultTypes |= ResultType.RelevantResults;
query.RowLimit = 0;
ResultTableCollection searchResults = query.Execute();
return searchResults;
//if (searchResults.Exists(ResultType.RelevantResults))
//{
// ResultTable searchResult = searchResults[ResultType.RelevantResults];
// DataTable result = new DataTable();
// result.TableName = "Result";
// result.Load(searchResult, LoadOption.OverwriteChanges);
// FillResultsGrid(result);
//}
}
/// <summary>
/// Get all sites that match the passed query. Batching is done in batches of 500 as this is compliant for both Office 365 as SharePoint on-premises
/// </summary>
/// <param name="cc">ClientContext object of an arbitrary site collection accessible by the defined enumeration username and password</param>
/// <param name="keywordQueryValue">Query string</param>
/// <returns>List of found site collections</returns>
private static List<String> SiteSearch(ClientRuntimeContext cc, string keywordQueryValue)
{
List<String> sites = new List<String>();
KeywordQuery keywordQuery = new KeywordQuery(cc);
// Important to avoid trimming "similar" site collections
keywordQuery.TrimDuplicates = false;
if (keywordQueryValue.Length == 0)
{
keywordQueryValue = "contentclass:\"STS_Site\"";
}
int startRow = 0;
int totalRows = 0;
totalRows = ProcessQuery(cc, keywordQueryValue, sites, keywordQuery, startRow);
if (totalRows > 0)
{
while (totalRows >= sites.Count)
{
startRow += 500;
totalRows = ProcessQuery(cc, keywordQueryValue, sites, keywordQuery, startRow);
}
}
return sites;
}
private IEnumerable<NavigationNode> GetNavigationNodesBySearch(SPWeb web, NavigationSearchSettings settings, IEnumerable<string> additionalFilters = null)
{
var filters = new List<string>(settings.GlobalFilters);
// Check if find result source
var searchResultSource = this.searchHelper.GetResultSourceByName(web.Site, settings.ResultSourceName, SearchObjectLevel.Ssa);
if (searchResultSource == null)
{
this.logger.Error("searchResultSource is null in GSoft.Dynamite.Navigation.NavigationService.GetNavigationNodeItems");
return new List<NavigationNode>();
}
var query = new KeywordQuery(web)
{
SourceId = searchResultSource.Id,
TrimDuplicates = false,
RowLimit = 500
};
// Add defined filters
if (additionalFilters != null)
{
filters.AddRange(additionalFilters);
}
if (settings.SelectedProperties != null && settings.SelectedProperties.Any())
{
query.SelectProperties.AddRange(settings.SelectedProperties.ToArray());
}
// TODO: For now, the filters are applied seperated by whitespaces which means "AND" in KQL land.
// TODO: We should figure out a way to make this more flexible to use "OR" if necessary.
query.QueryText = string.Join(" ", filters.Where(filter => !string.IsNullOrEmpty(filter)));
// Execute search query
var tables = new SearchExecutor().ExecuteQuery(query);
if (tables.Exists(KnownTableTypes.RelevantResults))
{
// Build navigation nodes for search results
var results = tables.Filter("TableType", KnownTableTypes.RelevantResults).Single(relevantTable => relevantTable.QueryRuleId == Guid.Empty);
var nodes = results.Table.Rows.Cast<DataRow>().Select(dataRow => new NavigationNode(dataRow, settings.NavigationManagedPropertyName));
this.logger.Info(
"GetNavigationNodeItems: Found {0} items with search query '{1}' from source '{2}'.",
results.Table.Rows.Count,
query.QueryText,
settings.ResultSourceName);
return nodes;
}
this.logger.Error(
"GetNavigationNodeItems: No relevant results table found with search query '{0}' from source '{1}'.",
query.QueryText,
settings.ResultSourceName);
return new List<NavigationNode>();
}
/// <summary>
/// Returns the query to filter the matters.
/// </summary>
/// <param name="searchObject">The search object.</param>
/// <param name="keywordQuery">The keyword query.</param>
/// <returns>It returns a keyword query object.</returns>
internal static KeywordQuery FilterMattersUtility(SearchObject searchObject, KeywordQuery keywordQuery)
{
if (null != searchObject && null != keywordQuery && null != searchObject.Filters)
{
/* New refinement filters for list view control */
if (!string.IsNullOrWhiteSpace(searchObject.Filters.Name))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertyMatterName, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.Name, ConstantStrings.DoubleQuote));
}
if (!string.IsNullOrWhiteSpace(searchObject.Filters.ClientName))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertyClientName, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.ClientName, ConstantStrings.DoubleQuote));
}
if (null != searchObject.Filters.ResponsibleAttorneys && !string.IsNullOrWhiteSpace(searchObject.Filters.ResponsibleAttorneys))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertyResponsibleAttorney, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.ResponsibleAttorneys, ConstantStrings.DoubleQuote));
}
if (!string.IsNullOrWhiteSpace(searchObject.Filters.SubareaOfLaw))
{
keywordQuery.RefinementFilters.Add(string.Concat(SearchConstants.ManagedPropertySubAreaOfLaw, ConstantStrings.COLON, ConstantStrings.DoubleQuote, searchObject.Filters.SubareaOfLaw, ConstantStrings.DoubleQuote));
}
if (null != searchObject.Filters.DateFilters)
{
////// Add refiner for Open date value
keywordQuery = AddDateRefinementFilter(keywordQuery, searchObject.Filters.DateFilters.OpenDateFrom, searchObject.Filters.DateFilters.OpenDateTo, SearchConstants.ManagedPropertyOpenDate);
}
}
return keywordQuery;
}
private List<string> GetHiddenProjectSites()
{
var siteUri = new Uri(ConfigurationManager.AppSettings["SiteCollectionRequests_SiteUrl"]);
var resultsList = new List<string>();
using (var context = this.contextFactory.GetContext(siteUri.ToString()))
{
var keywordQuery = new KeywordQuery(context);
keywordQuery.QueryText = "Project AND HiddenSite AND ContentType=\"Site Collection Metadata\"";
keywordQuery.TrimDuplicates = false;
keywordQuery.SelectProperties.Clear();
keywordQuery.SelectProperties.Add("SiteNumFollowers");
keywordQuery.SelectProperties.Add("SiteTitle");
keywordQuery.SelectProperties.Add("SiteMembers");
var searchExecutor = new SearchExecutor(context);
var results = searchExecutor.ExecuteQuery(keywordQuery);
context.ExecuteQuery();
var result = results.Value[0];
foreach (var res in result.ResultRows)
{
var siteTitle = res["SiteName"];
resultsList.Add(siteTitle.ToString());
}
}
return resultsList;
}
