//================================================================================================ Public API
public static string ConvertWikilinksToHtml(string articleText, Node parent)
{
if (string.IsNullOrEmpty(articleText))
{
return(articleText);
}
var index = 0;
var regex = new Regex(WIKILINKPATTERN, RegexOptions.Multiline);
while (true)
{
var match = regex.Match(articleText, index);
if (!match.Success)
{
break;
}
var wTitle = match.Groups["WikiTitle"].Value;
var lTitle = match.Groups["LinkTitle"].Value;
if (string.IsNullOrEmpty(lTitle))
{
lTitle = wTitle;
}
Node targetArticle;
using (new SystemAccount())
{
var wikiWs = parent == null ? null : Workspace.GetWorkspaceForNode(parent);
var articleQuery = ContentQuery.CreateQuery("+TypeIs:WikiArticle +DisplayName:@0",
new QuerySettings {
EnableAutofilters = FilterStatus.Disabled, Top = 1
},
wTitle);
if (wikiWs != null)
{
articleQuery.AddClause(string.Format("+InTree:\"{0}\"", wikiWs.Path));
}
targetArticle = articleQuery.Execute().Nodes.FirstOrDefault();
}
var templateValue = targetArticle != null?
GetExistingLinkHtml(targetArticle.Path, lTitle) :
GetAddLinkHtml(parent, wTitle, lTitle);
articleText = articleText.Remove(match.Index, match.Length)
.Insert(match.Index, templateValue);
index = match.Index + templateValue.Length;
if (index >= articleText.Length)
{
break;
}
}
return(articleText);
}
private static object[] SearchContentQuery(string searchStr, string searchRoot, string contentTypes, bool simpleContent = false)
{
var queryStr = CreateContentQueryString(searchStr, searchRoot, contentTypes);
var query = ContentQuery.CreateQuery(queryStr, new QuerySettings
{
Sort = new List <SortInfo> {
new SortInfo("DisplayName")
},
EnableAutofilters = FilterStatus.Disabled,
EnableLifespanFilter = FilterStatus.Disabled
});
if (simpleContent)
{
return((from n in query.Execute().Nodes
where n != null
select new cs.SimpleServiceContent(n)).ToArray());
}
else
{
return((from n in query.Execute().Nodes
where n != null
select new cs.Content(n, true, false, false, false, 0, 0)).ToArray());
}
}
private static Dictionary <string, int> GetAllPortalObjects(ADObjectType objType)
{
var typeText = string.Empty;
if (objType == ADObjectType.AllContainers)
{
typeText = string.Concat(
"(TypeIs:", Common.GetNodeType(ADObjectType.OrgUnit).Name,
" OR TypeIs:", Common.GetNodeType(ADObjectType.Container).Name,
" OR TypeIs:", Common.GetNodeType(ADObjectType.Domain).Name, ")");
}
else
{
typeText = string.Concat("TypeIs:", Common.GetNodeType(objType).Name);
}
var queryText = string.Concat(typeText, " AND InTree:/Root/IMS");
var settings = new QuerySettings {
EnableAutofilters = false, EnableLifespanFilter = false
};
var query = ContentQuery.CreateQuery(queryText, settings);
var result = query.Execute();
var guidIdList = (from node in result.Nodes
where !string.IsNullOrEmpty(node.GetProperty <string>("SyncGuid"))
select new { Guid = node.GetProperty <string>("SyncGuid").ToLower(), ID = node.Id });
return(guidIdList.ToDictionary(a => a.Guid, a => a.ID));
}
private void RefreshIdentityResults()
{
ListEntries.Items.Clear();
// do not allow empty search here
if (SearchText.Text.Length == 0)
{
return;
}
var ws = Workspace.GetWorkspaceForNode(ContextNode);
var permQuery = ContentQuery.CreateQuery("InTree:@0", null, RepositoryStructure.ImsFolderPath);
if (ws != null)
{
permQuery.AddClause(string.Format("InTree:\"{0}/{1}\"", ws.Path, Repository.LocalGroupsFolderName), LogicalOperator.Or);
}
switch (this.Isi.IdentityKind)
{
case SnIdentityKind.User:
permQuery.AddClause("TypeIs:User");
break;
case SnIdentityKind.Group:
permQuery.AddClause("TypeIs:Group");
break;
case SnIdentityKind.OrganizationalUnit:
permQuery.AddClause("TypeIs:OrganizationalUnit");
break;
default:
throw new InvalidOperationException("Unknown identity kind");
}
if (SearchText.Text.Length > 0)
{
var st = SearchText.Text;
if (!st.StartsWith("*"))
{
st = "*" + st;
}
if (!st.EndsWith("*"))
{
st = st + "*";
}
permQuery.AddClause($"Name:{st}");
}
permQuery.Settings.EnableAutofilters = FilterStatus.Disabled;
permQuery.Settings.Top = 500;
permQuery.Settings.Sort = new List <SortInfo> {
new SortInfo("Name")
};
ListEntries.Items.AddRange((from node in permQuery.Execute().Nodes
select GetListItem(node)).ToArray());
}
private ActionResult SearchLucene(string searchStr, string searchRoot, string contentTypes, bool simpleContent = false)
{
var queryStr = CreateLuceneQueryString(searchStr, searchRoot, contentTypes);
var query = ContentQuery.CreateQuery(queryStr, new QuerySettings
{
Sort = new List <SortInfo> {
new SortInfo {
FieldName = "DisplayName"
}
},
EnableAutofilters = FilterStatus.Disabled,
EnableLifespanFilter = FilterStatus.Disabled
});
if (simpleContent)
{
return(Json((from n in query.Execute().Nodes
where n != null
select new SimpleServiceContent(n)).ToArray(),
JsonRequestBehavior.AllowGet));
}
else
{
return(Json((from n in query.Execute().Nodes
where n != null
select new Content(n, true, false, false, false, 0, 0)).ToArray(),
JsonRequestBehavior.AllowGet));
}
}
private static void ExportByFilterText(ExportContext context, string fsRoot, string queryText)
{
var query = ContentQuery.CreateQuery(queryText);
query.AddClause(@"InTree:""" + context.SourceFsPath + @"""", LogicalOperator.And);
var result = query.Execute();
var maxCount = result.Count;
var count = 0;
foreach (var nodeId in result.Identifiers)
{
try
{
var content = Content.Load(nodeId);
var relIndex = RepositoryPath.GetParentPath(context.SourceFsPath).Length + 1;
var relPath = content.Path.Substring(relIndex).Replace("/", "\\");
var fsPath = Path.Combine(fsRoot, relPath);
var fsDir = Path.GetDirectoryName(fsPath);
var dirInfo = new DirectoryInfo(fsDir);
if (!dirInfo.Exists)
{
Directory.CreateDirectory(fsDir);
}
ExportContent(content, context, fsDir, string.Concat(++count, "/", maxCount, ": ", Path.GetDirectoryName(relPath), "\\"));
}
catch (Exception ex)
{
LogException(ex);
}
}
}
public void ContentQuery_AddClause_Comments_01()
{
var queryText1 = @"+TypeIs:WebContentDemo // comment1
/*+TypeIs:Article*/ .SKIP:5
+InTree:""/Root/Sites/Default_Site"" .SORT:abc// comment2
.COUNTONLY
//comment3 .SORT:def
+CreationDate:>'2010.10.10' .TOP:3
/*comment4";
var queryText1Expected = @"+(+TypeIs:WebContentDemo // comment1
/*+TypeIs:Article*/
+InTree:""/Root/Sites/Default_Site"" // comment2
//comment3 .SORT:def
+CreationDate:>'2010.10.10'
/*comment4*/) +(-TypeIs:Car) .SKIP:5 .SORT:abc .COUNTONLY
.TOP:3";
//the query init corrects the unclosed multiline comment at the end!
var q1 = ContentQuery.CreateQuery(queryText1);
//the AddClause moves all the relevant keywords to the end, skipping the comments
q1.AddClause("-TypeIs:Car");
Assert.AreEqual(queryText1Expected, q1.Text, "Query #1: texts does not match");
}
private void ExportByFilterText(Content root, ExportContext context, string fsRoot, string queryText)
{
var query = ContentQuery.CreateQuery(queryText);
var result = query.Execute();
var maxCount = result.Count;
var count = 0;
foreach (var nodeId in result.Identifiers)
{
string fsPath = null;
Content content = null;
try
{
content = Content.Load(nodeId);
var relPath = content.Path.Remove(0, 1).Replace("/", "\\");
fsPath = Path.Combine(fsRoot, relPath);
var fsDir = Path.GetDirectoryName(fsPath);
var dirInfo = new DirectoryInfo(fsDir);
if (!dirInfo.Exists)
{
Directory.CreateDirectory(fsDir);
}
ExportContent(content, context, fsDir, String.Concat(++count, "/", maxCount, ": ", relPath, "\\"));
}
catch (Exception ex)
{
PrintException(ex, content == null ? fsPath : content.Path);
}
}
}
// returns synchronized portal nodes
private IEnumerable <Node> GetAllPortalObjects(ADObjectType objType, SyncTree syncTree)
{
var typeText = string.Empty;
if (objType == ADObjectType.AllContainers)
{
typeText = string.Concat(
"(TypeIs:", Common.GetNodeType(ADObjectType.OrgUnit).Name,
" OR TypeIs:", Common.GetNodeType(ADObjectType.Container).Name,
" OR TypeIs:", Common.GetNodeType(ADObjectType.Domain).Name, ")");
}
else
{
typeText = string.Concat("TypeIs:", Common.GetNodeType(objType).Name);
}
var startPath = string.Concat('"', syncTree.PortalPath.TrimEnd(new char[] { '/' }), '"');
var queryText = string.Concat(typeText, " AND InTree:", startPath);
var settings = new QuerySettings {
EnableAutofilters = false, EnableLifespanFilter = false
};
var query = ContentQuery.CreateQuery(queryText, settings);
var result = query.Execute();
return(result.Nodes);
}
/* ====================================================================================================== Methods */
private void BuildList()
{
// store the selected value for using it after the list is repopulated
// (storing the index is not correct, we have to use the value)
var selVal = this.SelectedIndex > 0 ? this.SelectedValue : null;
// we have to clear the itemlist here to
// refresh the item collection if changed
this.Items.Clear();
if (this.DropdownOptions.CommonType == DropDownCommonType.ContentTypeDropdown)
{
// special use-case, content type list is defined in webconfig
var contentTypeNodes = GetWebContentTypeList();
foreach (var ctContent in contentTypeNodes.Select(Content.Create))
{
this.Items.Add(new ListItem(ctContent.DisplayName, ctContent.Name));
}
}
if (!string.IsNullOrEmpty(this.DropdownOptions.Query))
{
// the list is built up from a query
var sortinfo = new List <SortInfo> {
new SortInfo("Name")
};
var settings = new QuerySettings {
EnableAutofilters = FilterStatus.Disabled, Sort = sortinfo
};
var query = ContentQuery.CreateQuery(this.DropdownOptions.Query, settings);
var result = query.Execute();
if (result.Count == 0)
{
this.Items.Add(new ListItem(SenseNetResourceManager.Current.GetString("PortletFramework", "DropDown-NoItems"), string.Empty));
return;
}
this.Items.Add(new ListItem(SenseNetResourceManager.Current.GetString("PortletFramework", "DropDown-SelectOne"), string.Empty));
foreach (var content in result.Nodes.Select(Content.Create))
{
this.Items.Add(new ListItem(content.DisplayName, content.Name));
}
}
// re-select the original selected value if needed
if (selVal != null)
{
var index = 0;
foreach (ListItem item in this.Items)
{
if (selVal.CompareTo(item.Value) == 0)
{
this.SelectedIndex = index;
break;
}
index++;
}
}
}
/* ========================================================================= TOOLS */
protected static ContentQuery CreateSafeContentQuery(string qtext)
{
var cquery = ContentQuery.CreateQuery(qtext, QuerySettings.AdminSettings);
var cqueryAcc = new ObjectAccessor(cquery);
cqueryAcc.SetFieldOrProperty("IsSafe", true);
return(cquery);
}
protected static ContentQuery CreateSafeContentQuery(string qtext, QuerySettings settings = null)
{
var cquery = ContentQuery.CreateQuery(qtext, settings ?? QuerySettings.AdminSettings);
var cqueryAcc = new PrivateObject(cquery);
cqueryAcc.SetFieldOrProperty("IsSafe", true);
return(cquery);
}
private static void PreloadControls()
{
try
{
QueryResult controlResult;
var cc = 0;
var timer = new Stopwatch();
timer.Start();
using (new SystemAccount())
{
var query = ContentQuery.CreateQuery("+Name:'*.ascx' -InTree:'/Root/Global/celltemplates' -Path:'/Root/Global/renderers/MyDataboundView.ascx' .SORT:Path",
new QuerySettings {
EnableAutofilters = false
});
if (!string.IsNullOrEmpty(Repository.WarmupControlQueryFilter))
{
query.AddClause(Repository.WarmupControlQueryFilter);
}
controlResult = query.Execute();
foreach (var controlId in controlResult.Identifiers)
{
var head = NodeHead.Get(controlId);
try
{
if (head != null)
{
var pct = BuildManager.GetCompiledType(head.Path);
//if (pct != null)
// Trace.WriteLine(">>>>Precompiled control: " + pct.FullName);
}
}
catch (Exception ex)
{
Logger.WriteException(new Exception("Error during control load: " + (head == null ? controlId.ToString() : head.Path), ex));
//Trace.WriteLine(">>>>Precompiled error during control load: " + (head == null ? controlId.ToString() : head.Path) + " ERROR: " + ex);
}
cc++;
}
}
timer.Stop();
Logger.WriteInformation(string.Format("***** Control preload time: {0} ******* Count: {1} ({2})", timer.Elapsed, cc, controlResult.Count));
//Trace.WriteLine(string.Format(">>>>Precompiled preload time: {0} ******* Count: {1} ({2})", timer.Elapsed, cc, controlResult.Count));
}
catch (Exception ex)
{
Logger.WriteException(ex);
}
}
/* ====================================================================================================== Methods */
protected override void OnInit(EventArgs e)
{
if (ShowExecutionTime)
{
Timer.Start();
}
UITools.AddScript("$skin/scripts/sn/SN.KPIViewDropDown.js");
// setup views list
// the source list is built up from a query
var sortinfo = new List <SortInfo>()
{
new SortInfo()
{
FieldName = "Name", Reverse = false
}
};
var settings = new QuerySettings()
{
EnableAutofilters = false, Sort = sortinfo
};
var query = ContentQuery.CreateQuery(string.Format("InFolder:\"{0}\"", kpiSourcePath), settings);
var result = query.Execute();
var viewList = new StringBuilder();
// collect kpi views from under sources
foreach (Node node in result.Nodes)
{
var c = SenseNet.ContentRepository.Content.Create(node);
c.ChildrenQuerySettings = new QuerySettings()
{
EnableAutofilters = false, Sort = sortinfo
};
foreach (var child in c.Children)
{
viewList.Append(string.Concat("{ sourceName: '", node.Name, "', viewName: '", child.Name, "'},"));
}
}
var viewListStr = string.Concat('[', viewList.ToString().TrimEnd(','), ']');
string script = string.Format("SN.KPIViewDropDown.init('{0}','{1}',{2});", masterDropdownCss, slaveDropdownCss, viewListStr);
UITools.RegisterStartupScript("KPIViewDropDownScript", script, this.Page);
if (ShowExecutionTime)
{
Timer.Stop();
}
base.OnInit(e);
}
private static void PreloadControls()
{
try
{
QueryResult controlResult;
var cc = 0;
var timer = new Stopwatch();
timer.Start();
using (new SystemAccount())
{
var query = ContentQuery.CreateQuery(SafeQueries.PreloadControls);
if (!string.IsNullOrEmpty(Repository.WarmupControlQueryFilter))
{
query.AddClause(Repository.WarmupControlQueryFilter);
}
controlResult = query.Execute();
foreach (var controlId in controlResult.Identifiers)
{
var head = NodeHead.Get(controlId);
try
{
if (head != null)
{
var pct = BuildManager.GetCompiledType(head.Path);
//if (pct != null)
// Trace.WriteLine(">>>>Precompiled control: " + pct.FullName);
}
}
catch (Exception ex)
{
Logger.WriteException(new Exception("Error during control load: " + (head == null ? controlId.ToString() : head.Path), ex));
//Trace.WriteLine(">>>>Precompiled error during control load: " + (head == null ? controlId.ToString() : head.Path) + " ERROR: " + ex);
}
cc++;
}
}
timer.Stop();
Logger.WriteInformation(Logger.EventId.NotDefined, string.Format("***** Control preload time: {0} ******* Count: {1} ({2})", timer.Elapsed, cc, controlResult.Count));
//Trace.WriteLine(string.Format(">>>>Precompiled preload time: {0} ******* Count: {1} ({2})", timer.Elapsed, cc, controlResult.Count));
}
catch (Exception ex)
{
Logger.WriteException(ex);
}
}
private ContentQuery ParseQuery(string queryText)
{
if (queryText.StartsWith("<"))
{
SnLog.WriteWarning(
"ReferenceFieldSetting.Query cannot be initialized with a NodeQuery source xml. Use content query text instead.",
properties: new Dictionary <string, object> {
{ "InvalidFilter", queryText }
});
return(null);
}
return(ContentQuery.CreateQuery(queryText));
}
private void DeleteInstances(string[] contentTypeNames)
{
var result = ContentQuery.CreateQuery(
ContentRepository.SafeQueries.TypeIs, QuerySettings.AdminSettings, new object[] { contentTypeNames })
.Execute();
Logger.LogMessage($"Deleting {result.Count} content by matching content type{(contentTypeNames.Length > 1 ? "s" : "")}.");
foreach (var node in result.Nodes)
{
Logger.LogMessage($" {node.Path}");
node.ForceDelete();
}
}
private void DeleteInstances(string contentTypeName)
{
Logger.LogMessage($"Deleting content by content-type: {contentTypeName}");
var nodes = ContentQuery.CreateQuery(
ContentRepository.SafeQueries.TypeIs, QuerySettings.AdminSettings, contentTypeName)
.Execute().Nodes;
foreach (var node in nodes)
{
Logger.LogMessage($" {node.Path}");
node.ForceDelete();
}
}
public Content Search(string searchExpression)
{
var searchString = System.Web.HttpUtility.UrlDecode(searchExpression);
var query = ContentQuery.CreateQuery(searchString, new QuerySettings {
EnableAutofilters = FilterStatus.Disabled, EnableLifespanFilter = FilterStatus.Disabled
});
query.AddClause(string.Format("Name:{0}*", searchString.Replace("\"", "").Replace("*", "")), ChainOperator.Or);
var result = query.Execute().Nodes;
var feed = result.Select(node => new Content(node, false, false, false, false, 0, 0)).ToArray();
return(CreateFakeRootForFeed(feed));
}
public void QueryIsSafe_AddClause()
{
var cq = ContentQuery.CreateQuery(TestSafeQueries.SafeQuery2, null, "value1");
Assert.AreEqual("+Field2:value1", cq.Text);
Assert.IsTrue(cq.IsSafe);
cq.AddClause(TestSafeQueries.SafeQuery3, ChainOperator.And, "value2", "value3");
Assert.AreEqual("+(+Field2:value1) +(+Field3:value2 +Field4:value3)", cq.Text);
Assert.IsTrue(cq.IsSafe);
cq.AddClause("+Field1:Value1");
Assert.AreEqual("+(+(+Field2:value1) +(+Field3:value2 +Field4:value3)) +(+Field1:Value1)", cq.Text);
Assert.IsTrue(cq.IsSafe);
}
private static void PreloadControls()
{
try
{
QueryResult controlResult;
var cc = 0;
var timer = new Stopwatch();
timer.Start();
using (new SystemAccount())
{
var query = ContentQuery.CreateQuery(SafeQueries.PreloadControls);
if (!string.IsNullOrEmpty(SystemStart.WarmupControlQueryFilter))
{
query.AddClause(SystemStart.WarmupControlQueryFilter);
}
controlResult = query.Execute();
foreach (var controlId in controlResult.Identifiers)
{
var head = NodeHead.Get(controlId);
try
{
if (head != null)
{
BuildManager.GetCompiledType(head.Path);
}
}
catch (Exception ex)
{
SnLog.WriteException(ex, "Error during control load: " + (head == null ? controlId.ToString() : head.Path));
}
cc++;
}
}
timer.Stop();
SnLog.WriteInformation($"***** Control preload time: {timer.Elapsed} ******* Count: {cc} ({controlResult.Count})");
}
catch (Exception ex)
{
SnLog.WriteException(ex);
}
}
private ContentQuery GetQuery()
{
var queryString = GetQueryString();
if (string.IsNullOrEmpty(queryString))
{
return(null);
}
try
{
var query = ContentQuery.CreateQuery(queryString);
if (EnableAutofilters != FilterStatus.Default)
{
query.Settings.EnableAutofilters = EnableAutofilters;
}
if (EnableLifespanFilter != FilterStatus.Default)
{
query.Settings.EnableLifespanFilter = EnableLifespanFilter;
}
if (this.CQPParamsExist)
{
query.Settings.Skip = CQPStartIndex + this.SkipFirst;
query.Settings.Top = NodeQuery.UnlimitedPageSize - 1;
//CQPPageSize;
}
else if (this.SkipFirst > 0)
{
query.Settings.Skip = this.SkipFirst;
query.Settings.Top = NodeQuery.UnlimitedPageSize - 1;
}
if (Top > 0)
{
query.Settings.Top = Top;
}
return(query);
}
catch (Exception ex)
{
Logger.WriteException(ex);
return(null);
}
}
/// <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>
/// <param name="queryFilter"></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 pathList = string.Empty;
var typeList = string.Empty;
if (searchPathArray.Any() && contentTypeArray.Any())
{
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)
{
return(new List <int>());
}
ContentQuery query;
if (!string.IsNullOrEmpty(pathList) && !string.IsNullOrEmpty(typeList))
{
query = ContentQuery.CreateQuery($"+Tags:\"{tag.Trim()}\" {pathList} {typeList} {queryFilter}");
}
else
{
query = ContentQuery.CreateQuery($"+Tags:\"{tag.Trim()}\" {queryFilter}");
}
return(query.Execute().Identifiers.ToList());
}
internal ContentTypeDependencies GetDependencies(string[] rootTypeNames)
{
var typeNames = new List <string>();
var inheritedTypeNames = new List <string>();
foreach (var rootTypeName in rootTypeNames)
{
var typeSubtreeQuery = ContentQuery.CreateQuery(ContentRepository.SafeQueries.InTree,
QuerySettings.AdminSettings, ContentType.GetByName(rootTypeName).Path);
var typeSubtreeResult = typeSubtreeQuery.Execute();
typeNames.AddRange(typeSubtreeResult.Nodes.Select(n => n.Name));
inheritedTypeNames.AddRange(typeNames.Except(rootTypeNames));
}
var relatedFolders = GetRelatedFolders(typeNames);
var contentInstancesCount = ContentQuery.CreateQuery(
ContentRepository.SafeQueries.TypeIsCountOnly,
QuerySettings.AdminSettings, new object[] { rootTypeNames }).Execute().Count
-
relatedFolders.ContentTemplates.Select(p => ContentQuery.Query(
ContentRepository.SafeQueries.InTreeAndTypeIsCountOnly,
QuerySettings.AdminSettings, p, typeNames).Count).Sum();
var PDP = Providers.Instance.DataProvider.GetExtension <IPackagingDataProviderExtension>();
var result = new ContentTypeDependencies
{
ContentTypeNames = rootTypeNames,
// +InTree:[currentContentType.Path]
InheritedTypeNames = inheritedTypeNames.ToArray(),
// +TypeIs:[name]
InstanceCount = contentInstancesCount,
// ContentType/AllowedChildTypes: "Folder,File"
PermittingContentTypes = GetContentTypesWhereTheyAreAllowed(typeNames),
// ContentType/Fields/Field/Configuration/AllowedTypes/Type: "Folder"
PermittingFieldSettings = GetContentTypesWhereTheyAreAllowedInReferenceField(typeNames),
// ContentMetaData/Fields/AllowedChildTypes: "Folder File"
PermittingContentCollection = PDP.GetContentPathsWhereTheyAreAllowedChildren(typeNames),
Applications = relatedFolders.Applications,
ContentTemplates = relatedFolders.ContentTemplates,
ContentViews = relatedFolders.ContentViews
};
return(result);
}
public void Indexing_ExecutingUnprocessedDoesNotDuplicate()
{
var contentName = "Indexing_ExecutingUnprocessedDoesNotDuplicate";
var query = ContentQuery.CreateQuery(".COUNTONLY Name:" + contentName, new QuerySettings {
EnableAutofilters = FilterStatus.Disabled, EnableLifespanFilter = FilterStatus.Disabled
});
var count = query.Execute().Count;
if (count > 0)
{
Assert.Inconclusive();
}
var lastActivityId = MissingActivityHandler.MaxActivityId;
var content = Content.CreateNew("Car", TestRoot, contentName);
content.Save();
content.ContentHandler.Index++;
content.Save();
content.ContentHandler.Index++;
content.Save();
count = query.Execute().Count;
Assert.IsTrue(count == 1, String.Format("Before executing unprocessed activities found {0}, expected: 1.", count));
MissingActivityHandler.MaxActivityId -= 3;
// reset indexing history, so that executeunprocessedactivities will actually execute adddocument as it should be tested
ResetIndexingHistory();
LuceneManager.ExecuteUnprocessedIndexingActivities(null, false); // call it with false, so last persisted maxactivityid will not overwrite the one we set above
count = query.Execute().Count;
Assert.IsTrue(count == 1, String.Format("After executing unprocessed activities #1 found {0}, expected: 1.", count));
count = ContentQuery.Query(".COUNTONLY +Index:2 +Name:" + contentName, new QuerySettings {
EnableAutofilters = FilterStatus.Disabled, EnableLifespanFilter = FilterStatus.Disabled
}).Count;
Assert.IsTrue(count == 1, String.Format("After executing unprocessed activities #2 found {0}, expected: 1.", count));
}
public override QueryResult GetChildren(string text, QuerySettings settings, bool getAllChildren)
{
if (!string.IsNullOrEmpty(Query) || !string.IsNullOrEmpty(text))
{
var cq = ContentQuery.CreateQuery(Query);
if (EnableAutofilters != FilterStatus.Default)
{
cq.Settings.EnableAutofilters = (EnableAutofilters == FilterStatus.Enabled);
}
if (EnableLifespanFilter != FilterStatus.Default)
{
cq.Settings.EnableLifespanFilter = (EnableLifespanFilter == FilterStatus.Enabled);
}
if (settings != null)
{
cq.Settings = settings;
}
if ((cq.IsContentQuery || string.IsNullOrEmpty(this.Query)) && !string.IsNullOrEmpty(text))
{
cq.AddClause(text);
}
if (cq.IsContentQuery)
{
//add SmartFolder's own children (with an Or clause)
var excapedPath = this.Path.Replace("(", "\\(").Replace(")", "\\)");
cq.AddClause((getAllChildren ?
string.Format("InTree:\"{0}\"", excapedPath) :
string.Format("InFolder:\"{0}\"", excapedPath)), ChainOperator.Or);
}
else
{
cq.AddClause(new IntExpression(IntAttribute.ParentId, ValueOperator.Equal, this.Id), ChainOperator.Or);
}
var result = cq.Execute();
return(result);
}
return(QueryResult.Empty);
}
public static void RetryAllFailedActions()
{
using (new SystemAccount())
{
var qs = new QuerySettings {
EnableLifespanFilter = false, EnableAutofilters = false
};
var queryText = string.Format("TypeIs:File AND InTree:\"{0}\" .SORT:CreationDate", _actionPath);
var q = ContentQuery.CreateQuery(queryText, qs);
var result = q.Execute();
foreach (Node node in result.Nodes)
{
var failFile = node as File;
if (failFile == null)
{
continue;
}
// restore ADAction object
var stream = failFile.Binary.GetStream();
var serializer = new XmlSerializer(typeof(ADAction));
var adAction = serializer.Deserialize(stream) as ADAction;
if (adAction == null)
{
continue;
}
try
{
adAction.Execute();
failFile.Delete();
}
catch (Exception ex) //TODO: catch block
{
// re-execution failed again, save exception
adAction.LastException = GetExceptionMsg(ex);
SaveAction(adAction, failFile);
}
}
}
}
//===================================================================================== Method
protected override IEnumerable <Node> GetChildren()
{
if (!string.IsNullOrEmpty(Query))
{
var cq = ContentQuery.CreateQuery(Query);
if (EnableAutofilters != FilterStatus.Default)
{
cq.Settings.EnableAutofilters = (EnableAutofilters == FilterStatus.Enabled);
}
if (EnableLifespanFilter != FilterStatus.Default)
{
cq.Settings.EnableLifespanFilter = (EnableLifespanFilter == FilterStatus.Enabled);
}
var result = cq.Execute();
return(result.Nodes);
}
return(base.GetChildren());
}
protected override NodeQueryResult QueryChildrenFromLucene(int thisId)
{
if (string.IsNullOrEmpty(_childrenFilter))
{
return(base.QueryChildrenFromLucene(thisId));
}
else
{
//We need to apply a query filter. Execute a content
//query and create a node query result on-the-fly.
var query = ContentQuery.CreateQuery("+ParentId:@0", null, thisId);
if (!string.IsNullOrEmpty(_childrenFilter))
{
query.AddClause(_childrenFilter);
}
return(new NodeQueryResult(query.ExecuteToIds(ExecutionHint.ForceIndexedEngine)));
}
}
public static void RetryAllFailedActions()
{
using (new SystemAccount())
{
var qs = new QuerySettings {
EnableLifespanFilter = FilterStatus.Disabled, EnableAutofilters = FilterStatus.Disabled
};
var q = ContentQuery.CreateQuery(SafeQueries.FilesInTree, qs, _actionPath);
var result = q.Execute();
foreach (Node node in result.Nodes)
{
var failFile = node as File;
if (failFile == null)
{
continue;
}
// restore ADAction object
var stream = failFile.Binary.GetStream();
var serializer = new XmlSerializer(typeof(ADAction));
var adAction = serializer.Deserialize(stream) as ADAction;
if (adAction == null)
{
continue;
}
try
{
adAction.Execute();
failFile.Delete(true);
}
catch (Exception ex) //TODO: catch block
{
// re-execution failed again, save exception
adAction.LastException = GetExceptionMsg(ex);
SaveAction(adAction, failFile);
}
}
}
}
