/// <summary> /// Replaces the given tag to the given new tag on every content in reppository. /// Also used for deleting tags, by calling with newtag = String.Empty parameter. /// </summary> /// <param name="tag">Tag to replace.</param> /// <param name="newtag">Tag to replace with.</param> /// <param name="pathList">The path list.</param> public static void ReplaceTag(string tag, string newtag, List <string> pathList) { tag = tag.ToLower(); newtag = newtag.ToLower(); if (tag == string.Empty) { return; } var query = String.Format("Tags:\"{0}\"", tag); if (pathList != null && pathList.Count > 0) { query = string.Concat(query, String.Format("+InTree:({0})", pathList.Aggregate(String.Empty, (current, path) => String.Concat(current, path, " ")).TrimEnd(' '))); } var lq = LucQuery.Parse(query); var result = lq.Execute(); foreach (var tmp in result.Select(item => Node.LoadNode(item.NodeId))) { if (tmp["Tags"] != null) { tmp["Tags"] = (tmp["Tags"].ToString().ToLower().Replace(tag, newtag)).Trim(); } tmp.Save(); } }
public void Security_ContentQuery_FieldLevel_Parsing() { Assert.AreEqual(QueryFieldLevel.HeadOnly, LucQuery.Parse("+Name:a* +InTree:/Root/MyFolder -InFolder:/Root/MyFolder/x +Index:0").FieldLevel); Assert.AreEqual(QueryFieldLevel.NoBinaryOrFullText, LucQuery.Parse("+Name:a* +InTree:/Root/MyFolder +Description:value1").FieldLevel); Assert.AreEqual(QueryFieldLevel.BinaryOrFullText, LucQuery.Parse("+InTree:/Root/MyFolder searchword").FieldLevel); Assert.AreEqual(QueryFieldLevel.BinaryOrFullText, LucQuery.Parse("searchword").FieldLevel); }
/// <summary> /// Determines if the tag given as parameter is presented in content repository or not. /// </summary> /// <param name="tag">Tag to search.</param> /// <param name="tagPath">The tag path.</param> /// <returns>True is present, false if not.</returns> public static bool IsInRepository(string tag, string tagPath) { var query = LucQuery.Parse(String.Concat("+Type:tag +DisplayName:\"", tag.ToLower(), "\"")); var result = query.Execute(); return(result.Count() > 0); }
private ScoreDoc[] GetDocsUnderTree(string path, bool recurse) { var field = recurse ? "InTree" : "Path"; var lq = LucQuery.Parse(String.Format("{0}:'{1}'", path, path.ToLower())); var idxReader = GetIndexReader(); var searcher = new IndexSearcher(idxReader); var numDocs = idxReader.NumDocs(); try { var collector = TopScoreDocCollector.Create(numDocs, false); searcher.Search(lq.Query, collector); var topDocs = collector.TopDocs(0, numDocs); return(topDocs.ScoreDocs); } finally { if (searcher != null) { searcher.Close(); } searcher = null; } }
private void CheckQueryToString(string text, string expected) { //var visitor = new ToStringVisitor(); //visitor.Visit(LucQuery.Parse(text).Query); //Assert.AreEqual(expected, visitor.ToString()); Assert.AreEqual(expected, LucQuery.Parse(text).QueryText); }
/// <summary> /// Implements syncing between Lucene Index and Content Repository. /// - Cleans up not referenced tag Nodes (not used on any content) /// - Imports new tags which are not stored as Tag node in repository. /// - Optimizes Lucene Index for accurate search results. /// </summary> /// <param name="tagPath">Repository path where to import new tags.</param> /// <param name="searchPaths">The search paths.</param> public static void SynchronizeTags(string tagPath, List <string> searchPaths) { //1. adding new tags to repositry var usedTags = GetAllTags(null, searchPaths); if (tagPath != string.Empty) { foreach (var tag in usedTags) { if (!IsInRepository(tag, tagPath.ToLower())) { AddToRepository(tag.ToLower(), tagPath); } } } //2. deleting unused tag nodes var query = LucQuery.Parse("+Type:tag"); var result = query.Execute(); var nodes = result.Select(o => Node.LoadNode(o.NodeId)).ToList(); foreach (var node in nodes) { if (!usedTags.Contains(node.DisplayName) && string.IsNullOrWhiteSpace(node.GetProperty <string>("BlackListPath"))) { node.Delete(); } } }
/// <summary> /// Determines if the given tag is blacklisted or not. /// </summary> /// <param name="tag">Tag to search on blacklist.</param> /// <param name="blacklistPaths">The blacklist paths.</param> /// <returns>True if blacklisted, false if not.</returns> public static bool IsBlacklisted(string tag, List <string> blacklistPaths) { LucQuery query; // escaping if (!string.IsNullOrEmpty(tag)) { tag = tag.Replace("\"", "\\\""); } using (var readerFrame = LuceneManager.GetIndexReaderFrame()) { var reader = readerFrame.IndexReader; var terms = reader.Terms(new Term("BlackListPath", "*")); string queryString; if (blacklistPaths != null && blacklistPaths.Count > 0) { var usedPaths = new List <string>(); do { if (terms.Term().Field() == "BlackListPath") { if (blacklistPaths.Any(path => path.ToLower().StartsWith(terms.Term().Text()))) { usedPaths.Add(terms.Term().Text()); } } } while (terms.Next()); var pathString = usedPaths.Aggregate(string.Empty, (current, usedPath) => String.Concat(current, usedPath, " ")); pathString = pathString.TrimEnd(' '); queryString = String.Format("+Type:tag +DisplayName:\"{0}\"", tag.ToLower()); queryString = String.Concat(queryString, String.IsNullOrEmpty(pathString) ? " +BlackListPath:/root" : String.Format(" +BlackListPath:({0})", pathString)); } else { queryString = String.Concat("+Type:tag +DisplayName:\"", tag.ToLower(), "\" +BlackListPath:/root"); } try { query = LucQuery.Parse(queryString); } catch (ParserException) { // wrong query: return no Logger.WriteWarning(1, "TagAdmin query parse error: " + queryString); return(false); } var result = query.Execute(); return(result.Count() > 0); } }
public void ContentQuery_CountOnly() { var expectedCount = ContentType.GetContentTypeNames().Length; var query = LucQuery.Parse("Type:ContentType .COUNTONLY .AUTOFILTERS:OFF .LIFESPAN:OFF"); var result = query.Execute().ToArray(); var totalCount = query.TotalCount; Assert.IsTrue(result.Length == 0, String.Format("Result length is: {0}, expected: 0.", result.Length)); Assert.IsTrue(expectedCount == totalCount, String.Format("TotalCount is: {0}, expected: {1}.", totalCount, expectedCount)); }
/// <summary> /// Determines if the given tag is blacklisted or not. /// - Uses Lucene query for fast searching /// </summary> /// <param name="tag">Tag to check</param> /// <returns>True if the tag is on blacklist, false if it isn't.</returns> private static bool IsBlacklisted(string tag) { //if (_blackList != null) // return _blackList.Contains(tag); var query = LucQuery.Parse("+TypePath:genericcontent/tag +IsBlacklisted:true +DisplayName:" + tag.ToLower()); var result = query.Execute(); return(result.Count() > 0); }
public void ContentQuery_LucQueryAddDoubleOrClause() { var inputText = ".SKIP:10 Name:My* .TOP:5 Meta:'.TOP:6' Type:Folder"; var extensionText = ".AUTOFILTERS:OFF InTree:/Root/JohnSmith .TOP:100 InTree:/Root/System"; var inputQuery = LucQuery.Parse(inputText); var extensionQuery = LucQuery.Parse(extensionText); inputQuery.AddOrClause(extensionQuery); var combinedAndText = inputQuery.ToString(); var expectedAndText = "(Name:my* Meta:.TOP:6 Type:folder) (InTree:/root/johnsmith InTree:/root/system) .TOP:5 .SKIP:10"; Assert.AreEqual(expectedAndText, combinedAndText); }
public void ContentQuery_LucQueryAddSimpleAndClause() { var inputText = ".SKIP:10 Name:My* .TOP:5 Meta:'.TOP:6' Type:Folder"; var extensionText = "InTree:/Root/JohnSmith"; var inputQuery = LucQuery.Parse(inputText); var extensionQuery = LucQuery.Parse(extensionText); inputQuery.AddAndClause(extensionQuery); var combinedAndText = inputQuery.ToString(); var expectedAndText = "+(Name:my* Meta:.TOP:6 Type:folder) +InTree:/root/johnsmith .TOP:5 .SKIP:10"; Assert.AreEqual(expectedAndText, combinedAndText); }
public void Querying_Analyzers() { var query = LucQuery.Parse("'Mr.John Smith'"); var s = query.ToString(); var pq = query.Query as Lucene.Net.Search.PhraseQuery; Assert.IsNotNull(pq, String.Concat("Parsed query is: ", pq.GetType().Name, ". Expected: PhraseQuery")); var terms = pq.GetTerms(); Assert.IsTrue(terms.Length == 2, String.Concat("Count of terms is: ", terms.Length, ". Expected: 2")); Assert.IsTrue(terms[0].Text() == "mr.john", String.Concat("First term is ", terms[0].Text(), ". Expected: 'mr.john'")); Assert.IsTrue(terms[1].Text() == "smith", String.Concat("Second term is ", terms[1].Text(), ". Expected: 'smith'")); var qtext = "\"Mr.John Smith\""; //var qtext = "(InTree:/Root/Site1/Folder1/Folder2/Folder3 OR InTree:/Root/Site2/Folder1/Folder2/Folder3/Folder5/Folder6) AND Type:Folder AND _Text:\"Mr.John Smith\""; Lucene.Net.Search.Query q; var k = 0; var stopper = Stopwatch.StartNew(); for (int i = 0; i < 10000000; i++) { k++; } var t0 = stopper.ElapsedMilliseconds; stopper.Stop(); stopper = Stopwatch.StartNew(); for (int i = 0; i < 1000; i++) { q = LucQuery.Parse(qtext).Query; } var t1 = stopper.ElapsedMilliseconds; stopper.Stop(); stopper = Stopwatch.StartNew(); for (int i = 0; i < 1000; i++) { q = new Lucene.Net.QueryParsers.QueryParser(LuceneManager.LuceneVersion, "_Text", IndexManager.GetAnalyzer()).Parse(qtext); } var t2 = stopper.ElapsedMilliseconds; stopper.Stop(); }
public void QueryExecutor_ForceTopByConfig_CheckUsage() { var lq = LucQuery.Parse("Type:ContentType .TOP:500 .AUTOFILTERS:OFF"); var result = lq.Execute(); Assert.IsTrue(lq.TraceInfo.Searches == 1, String.Format("Searches is {0}, expected: 1.", lq.TraceInfo.Searches)); StorageContext.Search.DefaultTopAndGrowth = new[] { 10, 30, 50, 0 }; lq = LucQuery.Parse("Type:ContentType .AUTOFILTERS:OFF"); result = lq.Execute(); Assert.IsTrue(lq.TraceInfo.Searches == 4, String.Format("Searches is {0}, expected: 4.", lq.TraceInfo.Searches)); StorageContext.Search.DefaultTopAndGrowth = new[] { 10, 100, 1000, 10000, 0 }; lq = LucQuery.Parse("Type:ContentType .AUTOFILTERS:OFF"); result = lq.Execute(); Assert.IsTrue(lq.TraceInfo.Searches == 3, String.Format("Searches is {0}, expected: 3.", lq.TraceInfo.Searches)); }
/// <summary> /// Returns the ID-s of Nodes, that contains the tag given as parameter. /// </summary> /// <param name="tag">Searched tag as String.</param> /// <param name="searchPathArray">Paths to search in.</param> /// <param name="contentTypeArray">Types to search.</param> /// <returns>Node Id list.</returns> public static List <int> GetNodeIds(string tag, string[] searchPathArray, string[] contentTypeArray, string queryFilter = "") { if (String.IsNullOrEmpty(tag)) { return(new List <int>()); } tag = tag.ToLower(); var ids = new List <int>(); var pathList = string.Empty; var typeList = string.Empty; if (searchPathArray.Count() > 0 && contentTypeArray.Count() > 0) { pathList = "+Path:("; foreach (var path in searchPathArray) { pathList = String.Concat(pathList, path, "* "); } pathList = String.Concat(pathList, ")"); typeList = "+Type:("; foreach (var path in contentTypeArray) { typeList = String.Concat(typeList, path, " "); } typeList = String.Concat(typeList, ")"); } if (tag != string.Empty) { LucQuery query; if (!String.IsNullOrEmpty(pathList) && !String.IsNullOrEmpty(typeList)) { query = LucQuery.Parse(string.Format("+Tags:\"{0}\" {1} {2} {3}", tag.Trim(), pathList, typeList, queryFilter)); } else { query = LucQuery.Parse(string.Format("+Tags:\"{0}\" {1}", tag.Trim(), queryFilter)); } var results = query.Execute(); ids.AddRange(results.Select(o => o.NodeId)); } return(ids); }
/// <summary> /// Determines if the given tag is blacklisted or not. /// </summary> /// <param name="tag">Tag to search on blacklist.</param> /// <param name="blacklistPaths">The blacklist paths.</param> /// <returns>True if blacklisted, false if not.</returns> public static bool IsBlacklisted(string tag, List <string> blacklistPaths) { LucQuery query; using (var readerFrame = LuceneManager.GetIndexReaderFrame()) { var reader = readerFrame.IndexReader; var terms = reader.Terms(new Term("BlackListPath", "*")); if (blacklistPaths != null && blacklistPaths.Count > 0) { var usedPaths = new List <string>(); do { if (terms.Term().Field() == "BlackListPath") { if (blacklistPaths.Any(path => path.ToLower().StartsWith(terms.Term().Text()))) { usedPaths.Add(terms.Term().Text()); } } } while (terms.Next()); var pathString = usedPaths.Aggregate(string.Empty, (current, usedPath) => String.Concat(current, usedPath, " ")); pathString = pathString.TrimEnd(' '); var queryString = String.Format("+Type:tag +DisplayName:\"{0}\"", tag.ToLower()); queryString = String.Concat(queryString, String.IsNullOrEmpty(pathString) ? " +BlackListPath:/root" : String.Format(" +BlackListPath:({0})", pathString)); query = LucQuery.Parse(queryString); } else { query = LucQuery.Parse(String.Concat("+Type:tag +DisplayName:\"", tag.ToLower(), "\" +BlackListPath:/root")); } var result = query.Execute(); return(result.Count() > 0); } }
/// <summary> /// Get the search result. /// </summary> /// <param name="from">value of searching from</param> /// <param name="to">value of searching to</param> /// <returns>List of nodes which matches the search.</returns> private IEnumerable GetResult(string from, string to) { if (from == string.Empty || to == string.Empty) { return(null); } decimal fromD = 0; decimal toD = 5; Decimal.TryParse(from, out fromD); Decimal.TryParse(to, out toD); fromD -= (decimal)0.01; toD += (decimal)0.01; var contentsId = new List <int>(); var query = LucQuery.Parse("Rate:{" + string.Format("{0} TO {1}", fromD.ToString("F2"), toD.ToString("F2")) + "}"); var results = query.Execute(); foreach (var o in results) { contentsId.Add(o.NodeId); } var result = new NodeList <Node>(contentsId); return(result); //Demo query!!! //var queryString = "civic"; //var contentsId = TagManager.GetNodeIds(queryString); //var result = new NodeList<Node>(contentsId); //return result; }
private static LucQuery BuildLucQuery(System.Linq.Expressions.Expression expression, Type sourceCollectionItemType, string contextPath, ChildrenDefinition childrenDef) { Query q0 = null; CQVisitor v = null; // #1 compiling linq expression if (expression != null) { var v1 = new SetExecVisitor(); var expr1 = v1.Visit(expression); var expr2 = expr1; if (v1.HasParameter) { var v2 = new ExecutorVisitor(v1.GetExpressions()); expr2 = v2.Visit(expr1); } v = new CQVisitor(); v.Visit(expr2); q0 = v.GetQuery(sourceCollectionItemType, childrenDef); } // #2 combining with additional query clause LucQuery lq = null; if (!string.IsNullOrEmpty(childrenDef.ContentQuery)) { lq = LucQuery.Parse(childrenDef.ContentQuery); if (q0 == null) { q0 = lq.Query; } else { q0 = CombineQueries(q0, lq.Query); } } // #3 combining with context path if (q0 == null) { if (childrenDef != null && childrenDef.PathUsage != PathUsageMode.NotUsed && contextPath != null) { q0 = GetPathQuery(contextPath, childrenDef.PathUsage == PathUsageMode.InTreeAnd || childrenDef.PathUsage == PathUsageMode.InTreeOr); } } else { if (childrenDef != null && childrenDef.PathUsage != PathUsageMode.NotUsed && contextPath != null) { q0 = CombinePathQuery(q0, contextPath, childrenDef.PathUsage); } } // #4 empty query is invalid in this place if (q0 == null) { throw new NotSupportedException("Cannot execute empty query. Expression: " + expression); } var q1 = OptimizeBooleans(q0); // #5 configuring query by linq expression (the smallest priority) var query = LucQuery.Create(q1); if (v != null) { query.Skip = v.Skip; query.Top = v.Top; query.CountOnly = v.CountOnly; query.SortFields = v.SortFields.ToArray(); query.ThrowIfEmpty = v.ThrowIfEmpty; query.ExistenceOnly = v.ExistenceOnly; } // #6 configuring query by children definition if (childrenDef != null) { if (childrenDef.Skip > 0) { query.Skip = childrenDef.Skip; } if (childrenDef.Top > 0) { query.Top = childrenDef.Top; } if (childrenDef.Sort != null) { query.SetSort(childrenDef.Sort); } if (childrenDef.CountAllPages != null) { query.CountAllPages = childrenDef.CountAllPages.Value; } if (childrenDef.EnableAutofilters != FilterStatus.Default) { query.EnableAutofilters = childrenDef.EnableAutofilters; } if (childrenDef.EnableLifespanFilter != FilterStatus.Default) { query.EnableLifespanFilter = childrenDef.EnableLifespanFilter; } if (childrenDef.QueryExecutionMode != QueryExecutionMode.Default) { query.QueryExecutionMode = childrenDef.QueryExecutionMode; } } // #7 configuring query by additional query clause (the biggest priority) if (lq != null) { if (lq.Skip > 0) { query.Skip = lq.Skip; } if (lq.Top > 0) { query.Top = lq.Top; } if (lq.SortFields != null && lq.SortFields.Length > 0) { query.SortFields = lq.SortFields; } if (lq.EnableAutofilters != FilterStatus.Default) { query.EnableAutofilters = lq.EnableAutofilters; } if (lq.EnableLifespanFilter != FilterStatus.Default) { query.EnableLifespanFilter = lq.EnableLifespanFilter; } if (lq.QueryExecutionMode != QueryExecutionMode.Default) { query.QueryExecutionMode = lq.QueryExecutionMode; } } return(query); }
public void IndexingHistory_FixAddUpdateOverlap() { // add overlaps with update var fieldvalue1 = "IndexingHistoryFixAddUpdateOverlapFirst"; var fieldvalue2 = "IndexingHistoryFixAddUpdateOverlapSecond"; var history = LuceneManager._history; var car = new GenericContent(TestRoot, "Car"); car.Name = Guid.NewGuid().ToString(); car.Save(); var id = car.Id; // init 1 var node1 = Node.LoadNode(id); node1["Description"] = fieldvalue1; node1.Save(); // delete changes from index DataRowTimestampTest.DeleteVersionFromIndex(node1.VersionId); DataRowTimestampTest.DeleteVersionIdFromIndexingHistory(node1.VersionId); var docInfo1 = IndexDocumentInfo.Create(node1, false); var docData1 = DataBackingStore.CreateIndexDocumentData(node1, docInfo1, null, null); var document1 = IndexDocumentInfo.CreateDocument(docInfo1, docData1); // init 2 var node2 = Node.LoadNode(id); node2["Description"] = fieldvalue2; node2.Save(); // delete changes from index DataRowTimestampTest.DeleteVersionFromIndex(node2.VersionId); DataRowTimestampTest.DeleteVersionIdFromIndexingHistory(node2.VersionId); var docInfo2 = IndexDocumentInfo.Create(node2, false); var docData2 = DataBackingStore.CreateIndexDocumentData(node2, docInfo2, null, null); var document2 = IndexDocumentInfo.CreateDocument(docInfo2, docData2); // 1 check indexing history var versionId1 = history.GetVersionId(document1); var timestamp1 = history.GetTimestamp(document1); var historyOk = LuceneManager._history.CheckForAdd(versionId1, timestamp1); // timestamp in indexing history should be the newest var actTimestamp1 = history.Get(versionId1); Assert.AreEqual(timestamp1, actTimestamp1, "Timestamp in indexing history did not change."); Assert.IsTrue(historyOk, "History indicates indexing should not be executed, but this is not true."); // 2 check indexing history var versionId2 = history.GetVersionId(document2); var timestamp2 = history.GetTimestamp(document2); historyOk = LuceneManager._history.CheckForUpdate(versionId2, timestamp2); // timestamp in indexing history should change var actTimestamp2 = history.Get(versionId2); Assert.AreEqual(timestamp2, actTimestamp2, "Timestamp in indexing history did not change."); Assert.IsTrue(historyOk, "History indicates indexing should not be executed, but this is not true."); // 2 index var document = document2; var updateTerm = UpdateDocumentActivity.GetIdTerm(document); LuceneManager.SetFlagsForUpdate(document); LuceneManager._writer.UpdateDocument(updateTerm, document); var firstfound = ContentQuery.Query("Description:" + fieldvalue1, new QuerySettings { EnableAutofilters = FilterStatus.Disabled }).Count; var secondfound = ContentQuery.Query("Description:" + fieldvalue2, new QuerySettings { EnableAutofilters = FilterStatus.Disabled }).Count; // check indexing occured correctly // thread 2 writes values in index Assert.AreEqual(0, firstfound); Assert.AreEqual(1, secondfound); // 1 index document = document1; LuceneManager._writer.AddDocument(document); firstfound = ContentQuery.Query("Description:" + fieldvalue1, new QuerySettings { EnableAutofilters = FilterStatus.Disabled }).Count; secondfound = ContentQuery.Query("Description:" + fieldvalue2, new QuerySettings { EnableAutofilters = FilterStatus.Disabled }).Count; // check indexing occured correctly // thread 1 adds values to index, duplication occurs Assert.AreEqual(1, firstfound); Assert.AreEqual(1, secondfound); // 1 detects problem var detectChange1 = history.CheckHistoryChange(versionId1, timestamp1); Assert.IsTrue(detectChange1, "Thread 1 did not detect indexing overlapping although it should have."); // 2 detects no problem var detectChange2 = history.CheckHistoryChange(versionId2, timestamp2); Assert.IsFalse(detectChange2, "Thread 2 detected indexing overlapping although it should not have."); // 1 fixes index LuceneManager.RefreshDocument(versionId1, false); firstfound = ContentQuery.Query("Description:" + fieldvalue1, new QuerySettings { EnableAutofilters = FilterStatus.Disabled }).Count; //secondfound = ContentQuery.Query("Description:" + fieldvalue2, new QuerySettings { EnableAutofilters = FilterStatus.Disabled }).Count; var q = LucQuery.Parse("Description:" + fieldvalue2); q.EnableAutofilters = FilterStatus.Disabled; secondfound = q.Execute(true).Count(); Assert.AreEqual(0, firstfound); Assert.AreEqual(1, secondfound); var node = Node.LoadNode(id); node.ForceDelete(); }
/// <summary> /// Add or edit a saved content query. /// </summary> /// <param name="content">A query content to modify, a user, or any content under a workspace.</param> /// <param name="query">Query text.</param> /// <param name="displayName">Display name for the saved query.</param> /// <param name="queryType">Type of the query.</param> /// <returns></returns> public static object SaveQuery(Content content, string query, string displayName, QueryType queryType) { if (content == null) { throw new ArgumentNullException("content"); } if (query == null) { throw new ArgumentNullException("query"); } try { // We need to validate the query to avoid saving unknown texts. LucQuery.Parse(query); } catch (Exception ex) { Logger.WriteWarning(EventId.Query.ParseError, "Content query parse error during query save.", properties: new Dictionary <string, object> { { "User", User.Current.Name }, { "Query text", query }, { "Error", ex.Message } }); return(string.Empty); } ContentList queryContainer = null; Content queryContent = null; switch (queryType) { case QueryType.Private: //load the user and his profile var user = content.ContentHandler as User ?? (User)User.Current; if (!user.IsProfileExist()) { user.CreateProfile(); } var profile = user.Profile; if (profile == null) { throw new InvalidOperationException("User profile could not be created."); } queryContainer = GetQueryContainer(profile); break; case QueryType.Public: //store the query under the current workspace queryContainer = GetQueryContainer(((GenericContent)content.ContentHandler).Workspace); if (queryContainer == null) { throw new InvalidOperationException("Query container could not be created for a public query. Content: " + content.Path); } break; case QueryType.NonDefined: if (!content.ContentType.IsInstaceOfOrDerivedFrom(QueryTypeName)) { throw new InvalidOperationException("If the query type is nondefined, the content must be a query to save."); } queryContent = content; break; default: throw new InvalidOperationException("Unknown query type: " + queryType); } if (queryContainer != null) { //create a new query under the previously found container queryContent = Content.CreateNew(QueryTypeName, queryContainer, null); } if (queryContent == null) { throw new InvalidOperationException("No query content to save."); } // Elevation: a simple user does not necessarily have // 'Add' permission for the public queries folder. using (new SystemAccount()) { if (!string.IsNullOrEmpty(displayName)) { queryContent.DisplayName = displayName; } queryContent["Query"] = query; queryContent.Save(); } return(queryContent); }
public void Indexing_RecoverStoredField() { var ctdTemplate = @"<?xml version='1.0' encoding='utf-8'?> <ContentType name='{0}' parentType='GenericContent' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'> <Fields> <Field name='BodyColorIndexingTests' type='Color'> <Indexing> {2} <IndexHandler>{1}</IndexHandler> </Indexing> </Field> </Fields> </ContentType>"; var ctdCleanTemplate = @"<?xml version='1.0' encoding='utf-8'?> <ContentType name='{0}' parentType='GenericContent' handler='SenseNet.ContentRepository.GenericContent' xmlns='http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition'> </ContentType>"; var typeName = "TypeForIndexingTest"; var fieldHandlerName = typeof(ColorWithNameIndexHandler).FullName; Content content = null; ContentTypeInstaller.InstallContentType(String.Format(ctdTemplate, typeName, fieldHandlerName, "<Store>No</Store>")); var contentType = ContentType.GetByName(typeName); //-- typesystem load back var query = LucQuery.Parse("BodyColorIndexingTests:Red"); try { //-- without storing: there is query result but there is not value to recover content = Content.CreateNew(typeName, TestRoot, "car"); content["BodyColorIndexingTests"] = Color.Red; content.Save(); var doc = query.Execute().FirstOrDefault(); Assert.IsNotNull(doc, "Query result document is null"); Assert.IsTrue(!doc.Names.Contains("BodyColorIndexingTests"), "Document has BodyColorIndexingTests field."); //-- clean content.ForceDelete(); ContentTypeInstaller.InstallContentType(String.Format(ctdCleanTemplate, typeName)); contentType = ContentType.GetByName(typeName); //-- typesystem load back //-- with storing: there are query result and value to recover ContentTypeInstaller.InstallContentType(String.Format(ctdTemplate, typeName, fieldHandlerName, "<Store>Yes</Store>")); content = Content.CreateNew(typeName, TestRoot, "car"); content["BodyColorIndexingTests"] = Color.Red; content.Save(); doc = query.Execute().FirstOrDefault(); Assert.IsNotNull(doc, "Query result document is null"); var fieldValueColor = doc.Get <Color>("BodyColorIndexingTests"); var fieldValueObject = doc.Get("BodyColorIndexingTests"); Assert.IsTrue(SenseNet.ContentRepository.Fields.ColorField.ColorToString(fieldValueColor) == SenseNet.ContentRepository.Fields.ColorField.ColorToString(Color.Red), "Colors are not equal."); } finally { if (content != null) { content.ForceDelete(); } ContentTypeInstaller.RemoveContentType(typeName); } }
private string CheckQueryObject(string src, string qstring, string qqstring, FilterStatus autofilters, FilterStatus lifespan, int?top, int?skip, bool?countOnly, params string[] sortnames) { var query = LucQuery.Parse(src); var realqstring = query.ToString(); var realqqstring = query.Query.ToString(); var realtop = query.Top; var realskip = query.Skip; var realCountOnly = query.CountOnly; var sortcount = query.HasSort ? query.SortFields.Length : 0; var realsortnames = new string[sortcount]; var realautofilters = query.EnableAutofilters; var reallifespan = query.EnableLifespanFilter; for (int i = 0; i < sortcount; i++) { if (i + 1 <= sortcount) { var name = query.SortFields[i].GetField(); var reverse = query.SortFields[i].GetReverse(); realsortnames[i] = (reverse ? "-" : "+") + name; } } var msg = new StringBuilder(); if (qstring != null) { if (qstring != realqstring) { msg.Append("qstring='").Append(realqstring).Append("' expected='").Append(qstring).AppendLine("'"); } } if (qqstring != null) { if (qqstring != realqqstring) { msg.Append("qqstring='").Append(realqqstring).Append("' expected='").Append(qqstring).AppendLine("'"); } } if (top != null) { if (top.Value != realtop) { msg.Append("top=").Append(realtop).Append(" expected=").Append(top).AppendLine(); } } if (skip != null) { if (skip.Value != realskip) { msg.Append("skip=").Append(realskip).Append(" expected=").Append(skip).AppendLine(); } } if (countOnly != null) { if (countOnly.Value != realCountOnly) { msg.Append("countOnly=").Append(realCountOnly).Append(" expected=").Append(countOnly).AppendLine(); } } var s = String.Join(", ", sortnames); var ss = String.Join(", ", realsortnames); if (s != ss) { msg.Append("sortnames='").Append(ss).Append("' expected='").Append(s).AppendLine("'"); } if (realautofilters != autofilters) { msg.Append("Autofilters='").Append(realautofilters).Append("' expected='").Append(autofilters).AppendLine("'"); } if (reallifespan != lifespan) { msg.Append("Lifespan='").Append(reallifespan).Append("' expected='").Append(lifespan).AppendLine("'"); } return(msg.Length == 0 ? null : msg.ToString()); }