/// <summary>
/// Initializes a new instance of the <see cref="StructuredTree"/> class.
/// </summary>
/// <param name="structuredTreeRootItem">
/// The structured tree root item.
/// </param>
public StructuredTree(Item structuredTreeRootItem)
{
Assert.ArgumentNotNull(structuredTreeRootItem, "structuredTreeRootItem");
Database db = structuredTreeRootItem.Database;
this.FolderMasterItem = db.Templates["Ecommerce/StructuredData/StructuredData StructuredFolder"];
this.StructuredTreeRootItem = structuredTreeRootItem;
string id = this.StructuredTreeRootItem["enumeratorCurrentFolder"];
if (!string.IsNullOrEmpty(id))
{
Item itm = db.GetItem(id);
if (itm != null)
{
this.CurrentFolder = itm;
return;
}
}
if (this.CurrentFolder == null)
{
this.CurrentFolder = this.StructuredTreeRootItem;
}
}
protected override void OnLoad(EventArgs args)
{
base.OnLoad(args);
string currentItemId = GetCurrentContentGuid();
template = masterDb.GetItem(currentItemId);
if(template == null)
{
SheerResponse.Alert("You must select a template to continue.", new string[0]);
}
else
{
if (!Context.ClientPage.IsEvent)
{
CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);
string defaultNamespace = settings.BaseNamespace;
string defaultFilePath = settings.BaseFileOutputPath;
if(!string.IsNullOrEmpty(defaultNamespace))
{
CustomItemNamespace.Value = defaultNamespace;
}
if (!string.IsNullOrEmpty(defaultFilePath))
{
CustomItemFilePath.Value = defaultFilePath;
}
else
{
CustomItemFilePath.Value = "[ENTER CUSTOM ITEM ROOT FILE PATH]";
}
}
}
}
private bool InheritsFromTemplate(TemplateItem templateItem, Sitecore.Data.ID templateId)
{
return templateItem.ID == templateId
|| (templateItem.BaseTemplates != null
&& templateItem.BaseTemplates
.Where(baseTempl => InheritsFromTemplate(baseTempl, templateId)).Count() > 0);
}
public virtual void ChangedTemplate(Item targetItem, TemplateItem oldTemplate)
{
if(oldTemplate != null)
_logger.Debug($"* [T] from {oldTemplate.Name} to {targetItem.TemplateName}");
else
_logger.Debug($"* [T] to {targetItem.TemplateName}");
}
public override void Execute(CommandContext context)
{
var selectedItem = context.Items.FirstOrDefault();
if (selectedItem == null)
return;
string templateId = "{CC80011D-8EAE-4BFC-84F1-67ECD0223E9E}";
TemplateItem newTemplate = new TemplateItem(Sitecore.Context.Database.GetItem(templateId));
if (newTemplate != null)
{
try
{
using (new Sitecore.SecurityModel.SecurityDisabler())
{
selectedItem.Editing.BeginEdit();
selectedItem.ChangeTemplate(newTemplate);
}
}
catch (Exception ex)
{
Log.Error(ex.Message, ex, this);
throw;
}
finally
{
selectedItem.Editing.EndEdit();
}
}
}
protected void AddTemplate(ITemplate template) {
if (template != null) {
TemplateItem i = new TemplateItem();
template.InstantiateIn(i);
Controls.Add(i);
}
}
/// <summary>
/// Determine if an item is based on a given template or if the item's template is based on the given template
/// </summary>
/// <param name="item">The item to test the template of</param>
/// <param name="template">The template which the item's template should be or inherit from</param>
/// <returns>True if the item's template is based on the given template, otherwsie false</returns>
public static bool TemplateIsOrBasedOn(this Item item, TemplateItem template)
{
if (template != null)
return TemplateIsOrBasedOn(item, template.ID);
else
return false;
}
/// <summary>
/// Creates an alphabet folder structure under the passed in parent. This will also inlcude 123 as a folder
/// for handling items that start with numbers.
/// </summary>
/// <param name="parentItem">The parent item.</param>
/// <param name="folderTemplate">The folder template.</param>
/// <param name="upperCase">if set to <c>true</c> make the letter folder name upper case.</param>
public static void CreateAlphabetFolderStructure(Item parentItem, TemplateItem folderTemplate, bool upperCase)
{
if (parentItem == null || folderTemplate == null) return;
Database masterDb = Factory.GetDatabase("master");
using (new SecurityDisabler())
{
foreach (string letter in alphabetFolderNames)
{
//If we are supposed to make the folder name upper case, do so
string folderName = letter;
if (upperCase)
{
folderName = folderName.ToUpper();
}
//Only add the folder if it does not already exist, this way this method can be used to fill
// in missing folders in an already existing partial alpha folder structure.
string letterFolderPath = string.Format("{0}/{1}", parentItem.Paths.Path, folderName);
Item alphaFolder = SitecoreItemFinder.GetItem(masterDb, letterFolderPath);
if (alphaFolder == null)
{
parentItem.Add(letter.ToUpper(), folderTemplate);
}
}
}
}
/// <summary>
/// Cheks if selected templates has "StructuredData StructuredTreeArchive" as one of its base tamplates
/// </summary>
/// <param name="templateItem">The template item. </param>
/// <returns>if selected templates has "StructuredData StructuredTreeArchive".</returns>
private static bool RecursiveCheckBaseTemplatesIfStructuredTree(TemplateItem templateItem)
{
if (templateItem != null
&& !templateItem.Name.Equals("Standard template"))
{
if (templateItem.Name.Equals("StructuredData StructuredTreeArchive"))
{
return true;
}
TemplateItem[] baseTemplates = templateItem.BaseTemplates;
if (baseTemplates != null)
{
foreach (TemplateItem baseTemplateItem in baseTemplates)
{
bool success = RecursiveCheckBaseTemplatesIfStructuredTree(baseTemplateItem);
if (success)
{
return true;
}
}
}
}
return false;
}
/// <summary>Checks the specified output.</summary>
/// <param name="output">The output.</param>
/// <param name="item">The item.</param>
public override void Check(ValidationAnalyzer output, Item item)
{
Assert.ArgumentNotNull(output, "output");
Assert.ArgumentNotNull(item, "item");
var parametersTemplateId = item[ParametersTemplateFieldId];
if (string.IsNullOrEmpty(parametersTemplateId))
{
return;
}
var parameterTemplateItem = item.Database.GetItem(parametersTemplateId);
if (parameterTemplateItem == null)
{
return;
}
var template = new TemplateItem(parameterTemplateItem);
foreach (var templateFieldItem in template.Fields)
{
var templateItem = new TemplateItem(templateFieldItem.InnerItem.Parent.Parent);
if (!templateItem.BaseTemplates.Any())
{
continue;
}
output.MaxMessages++;
if (string.IsNullOrEmpty(templateFieldItem.ToolTip))
{
output.Write(SeverityLevel.Suggestion, "Parameter must have help text", string.Format("The parameter '{0}' in the '{1}' control does not have a short help text. The short help text is part of documentation and is displayed in the Documentation web site", templateFieldItem.Name, item.Name), "Write a help text.", templateFieldItem.InnerItem);
}
}
}
public CustomItemInformation(TemplateItem template, string baseNamespace, string baseFileRoot)
{
CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);
ICustomItemNamespaceProvider namespaceProvider = AssemblyUtil.GetNamespaceProvider(settings.NamespaceProvider);
ICustomItemFolderPathProvider filePathProvider = AssemblyUtil.GetFilePathProvider(settings.FilepathProvider);
GetItemInformation(template, baseNamespace, baseFileRoot, filePathProvider, namespaceProvider);
}
/// <summary>
/// Find items below another based on the specified template or a derived template
/// </summary>
/// <param name="rootItem">The item the item must be below</param>
/// <param name="template">The template to find item based on, or based on derivaties of the template</param>
/// <returns>All items which match</returns>
public static Item[] FindItemsByTemplateOrDerivedTemplate(this Item rootItem, TemplateItem template)
{
if (rootItem == null || template == null)
return new Item[0];
var database = rootItem.Database;
var foundItems = new List<Item>();
var derivedTemplates = new List<TemplateItem>();
var references = Sitecore.Globals.LinkDatabase.GetReferrers(template);
foreach (var reference in references)
{
var source = reference.GetSourceItem();
if (source.Template.Key == "template")
derivedTemplates.Add((TemplateItem)source);
else
{
if(source.Axes.IsDescendantOf(rootItem))
foundItems.Add(source);
}
}
foreach(var derivedTemplate in derivedTemplates)
{
foundItems.AddRange(FindItemsByTemplateOrDerivedTemplate(rootItem, derivedTemplate));
}
return foundItems.ToArray();
}
public void TestFixtureSetUp()
{
// Create test content
var templateHome = Sitecore.Context.Database.GetItem("/sitecore/templates/user defined");
var home = Sitecore.Context.Database.GetItem("/sitecore/content/home");
using (new SecurityDisabler())
{
templateHome.Paste(File.ReadAllText(HttpContext.Current.Server.MapPath(@"~\test data\templates.xml")), false, PasteMode.Overwrite);
home.Paste(File.ReadAllText(HttpContext.Current.Server.MapPath(@"~\test data\template content.xml")), false, PasteMode.Overwrite);
}
// Retrieve created templates
m_testTemplateRoot = templateHome.Axes.GetChild("Test Templates");
m_baseTemplate = Sitecore.Context.Database.GetTemplate("user defined/test templates/base");
m_d1Template = Sitecore.Context.Database.GetTemplate("user defined/test templates/d1");
m_d2Template = Sitecore.Context.Database.GetTemplate("user defined/test templates/d2");
// Retrieve created content items
m_testRoot = home.Axes.GetChild("Test Root");
m_base1 = m_testRoot.Axes.GetChild("Base1");
m_base2 = m_testRoot.Axes.GetChild("Base2");
m_d11 = m_testRoot.Axes.GetChild("D1-1");
m_d12 = m_testRoot.Axes.GetChild("D1-2");
m_d2 = m_testRoot.Axes.GetChild("D2");
}
public override string Render(TemplateItem item)
{
return Template.Resolve().Render(new TemplateItem {
Parent = item,
Data = new ExpressionEvaluator(item).Evaluate(Data).Value,
Options = new ExpressionEvaluator(item).Evaluate(Options).Value,
});
}
public void Init()
{
Sitecore.Context.IsUnitTesting = true;
Sitecore.Context.SkipSecurityInUnitTests = true;
InitContent();
_template = _context.CurrentDatabase.Templates[Constants.Paths.DocTemplate];
}
/// <summary>
/// Initializes a new instance of the <see cref="Folder"/> class.
/// </summary>
/// <param name="templateItem">The template item.</param>
/// <param name="format">The format.</param>
public Folder(TemplateItem templateItem, string format)
{
Sitecore.Diagnostics.Assert.IsNotNull(templateItem, "templateItem");
Sitecore.Diagnostics.Assert.IsNotNullOrEmpty(format, "format");
Template = templateItem;
FormatString = format;
}
public void GetAllTemplates(TemplateItem baseTemplate, List<string> list)
{
var str = IdHelper.NormalizeGuid(baseTemplate.ID);
list.Add(str);
if (baseTemplate.ID == TemplateIDs.StandardTemplate)
return;
foreach (var item in baseTemplate.BaseTemplates)
GetAllTemplates(item, list);
}
protected virtual bool TemplateAndBaseCheck(TemplateItem template, ID templateId)
{
if (template.ID == templateId)
{
return true;
}
return template.BaseTemplates.Any(baseTemplate => TemplateAndBaseCheck(baseTemplate, templateId));
}
private static void RecurseTemplates(ICollection<string> list, TemplateItem template)
{
foreach (var baseTemplateItem in template.BaseTemplates)
{
list.Add(IdHelper.NormalizeGuid(baseTemplateItem.ID));
if (baseTemplateItem.ID != TemplateIDs.StandardTemplate)
RecurseTemplates(list, baseTemplateItem);
}
}
public void TestFixtureSetUp()
{
Sitecore.Context.IsUnitTesting = true;
Sitecore.Context.SkipSecurityInUnitTests = true;
_context.CurrentDatabase = Sitecore.Configuration.Factory.GetDatabase("master");
InitContent(_context.CurrentDatabase);
_template = _context.CurrentDatabase.Templates[Constants.Paths.DocTemplate];
}
public static IEnumerable<Item> GetItemsByTemplate(TemplateItem template, Item root)
{
var usages = template.GetUsageIDs();
foreach (var usage in usages)
{
var item = template.Database.GetItem(usage);
if (item != null && (root == null || root.Axes.IsAncestorOf(item)))
yield return item;
}
}
public TemplateInSetBase(Item item, string[] databases, string setNamespace)
{
TemplateItem = new TemplateItem(item);
TemplateId = item.ID.ToString();
TemplateName = item.Name;
ClassName = DomUtil.ConvertCaseString(item.Name);
FullClassName = string.Format("{0}.{1}", setNamespace, ClassName);
Databases = databases;
TemplateSectionItem[] sectionItems = TemplateItem.GetSections();
Sections = sectionItems != null ? sectionItems.Select(sectionItem => new TemplateSection(sectionItem, false)) : null;
}
public string GetNamespace(TemplateItem template, string baseNamespace)
{
string relativePath = TemplateUtil.GetRelativeTemplatePath(template);
if(string.IsNullOrEmpty(relativePath)) return baseNamespace;
relativePath = relativePath.Replace("/", ".");
relativePath = CodeUtil.CleanStringOfIllegalCharacters(relativePath);
return baseNamespace + "." + relativePath;
}
private static void GetBaseTemplates(TemplateItem template, IDictionary<string, TemplateItem> templates)
{
if (template != null && !templates.ContainsKey(template.FullName))
{
templates.Add(template.FullName, template);
foreach (var baseTemplate in template.BaseTemplates)
{
GetBaseTemplates(baseTemplate, templates);
}
}
}
protected virtual bool ShouldMigrate(TemplateItem template)
{
foreach (TemplateItem baseTemplate in template.BaseTemplates)
{
if (string.Equals(baseTemplate.ID.ToString(), sharedBaseTemplateID) || ShouldMigrate(baseTemplate))
{
return true;
}
}
return false;
}
public void TestFixtureSetUp()
{
// Set DB to master so notification provider exists
_context.CurrentDatabase = Sitecore.Configuration.Factory.GetDatabase("master");
using (new SecurityDisabler())
{
InitContent(_context.CurrentDatabase);
}
_template = _context.CurrentDatabase.Templates[Constants.Paths.DocTemplate];
}
public void GetAllTemplates(TemplateItem baseTemplate, List<string> list)
{
if (baseTemplate.ID != Sitecore.TemplateIDs.StandardTemplate)
{
string str = IdHelper.NormalizeGuid(baseTemplate.ID);
list.Add(str);
foreach (TemplateItem item in baseTemplate.BaseTemplates)
{
this.GetAllTemplates(item, list);
}
}
}
public static bool InheritsFrom(this Item item, TemplateItem templateItem)
{
bool returnValue = false;
if (templateItem != null)
{
Template template = TemplateManager.GetTemplate(item);
returnValue = template != null &&
(template.ID == templateItem.ID || template.DescendsFrom(templateItem.ID));
}
return returnValue;
}
public string GetFolderPath(TemplateItem template,string baseFilePath)
{
string relativeTemplatePath = TemplateUtil.GetRelativeTemplatePath(template).Replace("/", "\\");
relativeTemplatePath = CodeUtil.CleanStringOfIllegalCharacters(relativeTemplatePath);
if(!baseFilePath.EndsWith("\\"))
{
baseFilePath += "\\";
}
return baseFilePath + relativeTemplatePath;
}
public void Init()
{
m_context = new Context();
Item home = m_context.CurrentDatabase.GetItem(Constants.Paths.Home);
m_template = m_context.CurrentDatabase.Templates[Constants.Paths.DocTemplate];
using (new SecurityDisabler())
{
m_testRoot = home.Add("testroot", m_template);
}
}
public void Add(TemplateItem templateItem)
{
tree.Add(templateItem);
}
public static void ImportPosts(Item bh, List <WPPost> listWordpressPosts, string blogName, Item userBlogPostTemplate)
{
Database master = Database.GetDatabase("master");
foreach (WPPost post in listWordpressPosts)
{
try
{
using (new SecurityDisabler())
{
if (string.IsNullOrEmpty(post.Content) || string.IsNullOrEmpty(post.Title))
{
continue;
}
TemplateItem blogPostTemplate = master.GetItem(userBlogPostTemplate.ID);
string validItemName = ItemUtil.ProposeValidItemName(post.Title);
if (string.IsNullOrEmpty(validItemName))
{
continue;
}
BlogPost bp = ItemManager.CreateItem(validItemName, bh, userBlogPostTemplate.ID).CreateAs <BlogPost>();
if (bp == null)
{
continue;
}
using (new EditContext(bp.InnerItem))
{
bp.InnerItem.SetString(BlogPost.BlogPostTitleFieldId, post.Title.Replace("-", " "));
bp.InnerItem.SetString(BlogPost.BlogPostBodyFieldId, post.Content);
bp.PublishDate.Value = DateUtil.ToIsoDate(post.PublishDate);
if (!string.IsNullOrEmpty(post.WPAuthor))
{
if (post.Tags.Any())
{
foreach (string tag in post.Tags)
{
Item t = master.SelectItems("fast://sitecore/content/Data/" + blogName + "/Tags/*[@Tag Name= '" + tag + "']").FirstOrDefault();
if (t == null)
{
continue;
}
bp.InnerItem.SetValue(BlogPost.BlogPostTagsFieldId, t.ID);
}
}
if (post.Categories.Any())
{
foreach (string cat in post.Categories)
{
Item c = master.SelectItems("fast://sitecore/content/Data/" + blogName + "/Categories/*[@Category Name= '" + cat + "']").FirstOrDefault();
if (c == null)
{
continue;
}
bp.InnerItem.SetValue(BlogPost.BlogPostCategoryFieldId, c.ID);
}
}
Item auth = master.SelectItems("fast://sitecore/content/Data/" + blogName + "/Authors/*[@Creator= '" + post.WPAuthor + "']").FirstOrDefault();
if (auth != null)
{
bp.InnerItem.SetValue(BlogPost.BlogPostAuthorFieldId, auth.ID);
}
}
}
}
}
catch (Exception ex)
{
Log.Error("Cannot create entry for: " + post.Title + " " + ex.Message, "WPImporter");
}
}
}
public ITemplateItem BuildTemplateItem(TemplateItem templateItem)
{
return(new TemplateItemWrapper(templateItem));
}
