public override void Parse(ItemParseContext context, ITextNode textNode)
{
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value);
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName);
var templateIdOrPathTextNode = textNode.GetAttribute("Template");
var templateIdOrPath = templateIdOrPathTextNode?.Value ?? string.Empty;
var item = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, guid, databaseName, itemNameTextNode.Value, itemIdOrPath, templateIdOrPath);
item.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
item.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase);
item.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsExtern, context.IsExtern.ToString()), "True", StringComparison.OrdinalIgnoreCase);
if (templateIdOrPathTextNode != null)
{
item.TemplateIdOrPathProperty.AddSourceTextNode(templateIdOrPathTextNode);
if (!item.IsImport)
{
item.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(item, item.TemplateIdOrPathProperty));
}
}
context.ParseContext.PipelineService.Resolve<ItemParserPipeline>().Execute(context, item, textNode);
ParseChildNodes(context, item, textNode);
context.ParseContext.Project.AddOrMerge(item);
}
public override void Parse(ItemParseContext context, ITextNode textNode)
{
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var parentItemPath = textNode.GetAttributeValue("ParentItemPath", context.ParentItemPath);
var itemIdOrPath = PathHelper.CombineItemPath(parentItemPath, itemNameTextNode.Value);
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName);
var templateIdOrPath = textNode.Key.UnescapeXmlElementName();
var item = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, guid, databaseName, itemNameTextNode.Value, itemIdOrPath, templateIdOrPath);
item.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
item.TemplateIdOrPathProperty.AddSourceTextNode(new AttributeNameTextNode(textNode));
item.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase);
item.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsExtern, context.IsExtern.ToString()), "True", StringComparison.OrdinalIgnoreCase);
if (!item.IsImport)
{
item.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(item, item.TemplateIdOrPathProperty));
}
var fieldContext = new LanguageVersionContext();
ParseAttributes(context, item, fieldContext, textNode);
ParseChildNodes(context, item, textNode);
context.ParseContext.Project.AddOrMerge(item);
}
protected virtual void ParseChildNodes([NotNull] ItemParseContext context, [NotNull] Item item, [NotNull] ITextNode textNode)
{
var sortorder = 100;
foreach (var childNode in textNode.ChildNodes)
{
switch (childNode.Key)
{
case "Fields":
case "fields":
ParseFieldsTextNode(context, item, childNode);
break;
case "Layout":
case "layout":
ParseLayoutTextNode(context, item, childNode);
break;
case "Items":
case "items":
ParseItemsTextNode(context, item, childNode, sortorder);
sortorder += 100;
break;
default:
Trace.TraceError(Msg.P1026, "Unexpected text node", childNode, childNode.Key);
break;
}
}
}
protected virtual void ParseFieldTextNode([NotNull] ItemParseContext context, [NotNull] Item item, [NotNull] LanguageVersionContext languageVersionContext, [NotNull] ITextNode fieldTextNode)
{
SchemaService.ValidateTextNodeSchema(fieldTextNode, "Field");
var fieldName = fieldTextNode.Key.UnescapeXmlElementName();
if (fieldName == "Name" || fieldName == "Id" || fieldName == "Database" || fieldName == "TemplateName" || fieldName == "ItemPath" || fieldName == "ParentItemPath" || fieldName == Constants.Fields.IsEmittable || fieldName == Constants.Fields.IsImport)
{
return;
}
var field = Factory.Field(item).With(fieldTextNode);
field.FieldNameProperty.SetValue(new AttributeNameTextNode(fieldTextNode));
field.LanguageProperty.SetValue(languageVersionContext.LanguageProperty);
field.VersionProperty.SetValue(languageVersionContext.VersionProperty);
field.ValueProperty.SetValue(fieldTextNode);
// check if field is already defined
var duplicate = item.Fields.FirstOrDefault(f => string.Equals(f.FieldName, field.FieldName, StringComparison.OrdinalIgnoreCase) && f.Language == field.Language && f.Version == field.Version);
if (duplicate == null)
{
item.Fields.Add(field);
}
else
{
Trace.TraceError(Msg.P1008, Texts.Field_is_already_defined, fieldTextNode, duplicate.FieldName);
}
if (!item.IsImport)
{
item.References.AddRange(ReferenceParser.ParseReferences(field));
}
}
public virtual void ParseChildNodes([NotNull] ItemParseContext context, [NotNull] ITextNode textNode)
{
foreach (var childNode in textNode.ChildNodes)
{
ParseTextNode(context, childNode);
}
}
protected virtual void ParseAttributes([NotNull] ItemParseContext context, [NotNull] Item item, [NotNull] LanguageVersionContext languageVersionContext, [NotNull] ITextNode textNode)
{
foreach (var childNode in textNode.Attributes)
{
ParseFieldTextNode(context, item, languageVersionContext, childNode);
}
}
protected virtual void ParseField([NotNull] ItemParseContext context, [NotNull] Template template, [NotNull] TemplateSection templateSection, [NotNull] ITextNode templateFieldTextNode, ref int nextSortOrder)
{
SchemaService.ValidateTextNodeSchema(templateFieldTextNode, "TemplateField");
GetName(context.ParseContext, templateFieldTextNode, out var fieldName, out var fieldNameTextNode, "Field", "Name");
if (string.IsNullOrEmpty(fieldName))
{
Trace.TraceError(Msg.P1005, Texts._Field__element_must_have_a__Name__attribute, templateFieldTextNode.Snapshot.SourceFile.AbsoluteFileName, templateFieldTextNode.TextSpan);
return;
}
var templateField = templateSection.Fields.FirstOrDefault(f => string.Equals(f.FieldName, fieldName, StringComparison.OrdinalIgnoreCase));
if (templateField == null)
{
var itemIdOrPath = template.ItemIdOrPath + "/" + templateSection.SectionName + "/" + fieldName;
var guid = StringHelper.GetGuid(template.Project, templateFieldTextNode.GetAttributeValue("Id", itemIdOrPath));
templateField = Factory.TemplateField(template, guid).With(templateFieldTextNode);
templateSection.Fields.Add(templateField);
templateField.FieldNameProperty.SetValue(fieldNameTextNode);
templateField.FieldName = fieldName;
}
templateField.TypeProperty.Parse(templateFieldTextNode, "Single-Line Text");
templateField.Shared = string.Equals(templateFieldTextNode.GetAttributeValue("Sharing"), "Shared", StringComparison.OrdinalIgnoreCase);
templateField.Unversioned = string.Equals(templateFieldTextNode.GetAttributeValue("Sharing"), "Unversioned", StringComparison.OrdinalIgnoreCase);
templateField.SourceProperty.Parse(templateFieldTextNode);
templateField.ShortHelpProperty.Parse(templateFieldTextNode);
templateField.LongHelpProperty.Parse(templateFieldTextNode);
templateField.SortorderProperty.Parse(templateFieldTextNode, nextSortOrder);
nextSortOrder = templateField.Sortorder + 100;
// set field standard value
var standardValueTextNode = templateFieldTextNode.GetAttribute("StandardValue");
if (standardValueTextNode != null && !string.IsNullOrEmpty(standardValueTextNode.Value))
{
if (template.StandardValuesItem == null)
{
Trace.TraceError(Msg.P1006, Texts.Template_does_not_a_standard_values_item, standardValueTextNode);
}
else
{
var field = template.StandardValuesItem.Fields.GetField(templateField.FieldName);
if (field == null)
{
field = Factory.Field(template.StandardValuesItem).With(standardValueTextNode);
field.FieldNameProperty.SetValue(fieldNameTextNode);
template.StandardValuesItem.Fields.Add(field);
}
field.ValueProperty.SetValue(standardValueTextNode);
}
}
template.References.AddRange(ReferenceParser.ParseReferences(template, templateField.SourceProperty));
}
protected override void ParseRenderingReferences(ItemParseContext context, ICollection<IReference> references, IProjectItem projectItem, ITextNode renderingTextNode)
{
var childNode = renderingTextNode.ChildNodes.FirstOrDefault();
if (childNode != null)
{
base.ParseRenderingReferences(context, references, projectItem, childNode);
}
}
protected virtual void ParseItemsTextNode([NotNull] ItemParseContext context, [NotNull] Item item, [NotNull] ITextNode itemsTextNode, int sortorder)
{
foreach (var childNode in itemsTextNode.ChildNodes)
{
var newContext = Factory.ItemParseContext(context.ParseContext, context.Parser, item.Database, item.ItemIdOrPath, item.IsImport).With(sortorder);
context.Parser.ParseTextNode(newContext, childNode);
}
}
protected override void ParseUnversionedTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
foreach (var languageChildNode in textNode.ChildNodes)
{
var fieldContext = new LanguageVersionContext();
fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(languageChildNode));
ParseUnversionedOrVersionedTreeNode(context, item, fieldContext, languageChildNode);
}
}
protected override void ParseUnversionedTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
var fieldContext = new LanguageVersionContext();
fieldContext.LanguageProperty.Parse(textNode);
foreach (var unversionedChildNode in textNode.ChildNodes)
{
ParseFieldTextNode(context, item, fieldContext, unversionedChildNode);
}
}
protected override void ParseLayoutTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
var childNode = textNode.ChildNodes.FirstOrDefault();
if (childNode == null)
{
return;
}
var parser = new XmlLayoutTextNodeParser();
parser.Parse(context, childNode, item);
}
protected override void ParseFieldsTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
var fieldContext = new LanguageVersionContext();
foreach (var attribute in textNode.Attributes)
{
ParseFieldTextNode(context, item, fieldContext, attribute);
}
base.ParseFieldsTextNode(context, item, textNode);
}
protected override void ParseFieldTextNode(ItemParseContext context, Item item, LanguageVersionContext languageVersionContext, ITextNode textNode)
{
var fieldNameTextNode = string.IsNullOrEmpty(textNode.Value) ? textNode.GetAttribute("Name") : textNode;
if (fieldNameTextNode == null)
{
context.ParseContext.Trace.TraceError(Msg.P1015, Texts.Expected__Name__attribute, textNode);
return;
}
ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode);
}
protected virtual IEnumerable <IReference> ParseReferences([NotNull] ItemParseContext context, [NotNull] IProjectItem projectItem, [NotNull] ITextNode layoutTextNode)
{
var result = ReferenceParserService.ParseReferences(projectItem, layoutTextNode).ToList();
foreach (var deviceTextNode in layoutTextNode.ChildNodes)
{
ParseDeviceReferences(context, result, projectItem, deviceTextNode);
}
return(result);
}
protected override void ParseUnversionedTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
var firstChildNode = textNode.ChildNodes.First();
var fieldContext = new LanguageVersionContext();
fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(firstChildNode));
foreach (var unversionedChildNode in firstChildNode.ChildNodes)
{
ParseFieldTextNode(context, item, fieldContext, unversionedChildNode);
}
}
public override void Parse(ItemParseContext context, ITextNode textNode)
{
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value);
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName);
var template = context.ParseContext.Factory.Template(context.ParseContext.Project, guid, textNode, databaseName, itemNameTextNode.Value, itemIdOrPath);
template.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
template.BaseTemplatesProperty.Parse(textNode, Constants.Templates.StandardTemplate);
template.IconProperty.Parse(textNode);
template.ShortHelpProperty.Parse(textNode);
template.LongHelpProperty.Parse(textNode);
template.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase);
template.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsExtern, context.IsExtern.ToString()), "True", StringComparison.OrdinalIgnoreCase);
template.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(template, template.BaseTemplatesProperty));
// create standard values item
var standardValuesItemIdOrPath = itemIdOrPath + "/__Standard Values";
var standardValuesGuid = StringHelper.GetGuid(context.ParseContext.Project, standardValuesItemIdOrPath);
var standardValuesItem = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, standardValuesGuid, databaseName, "__Standard Values", standardValuesItemIdOrPath, itemIdOrPath);
standardValuesItem.IsImport = template.IsImport;
// todo: should be Uri
template.StandardValuesItem = standardValuesItem;
// parse fields and sections
var sections = textNode.GetSnapshotLanguageSpecificChildNode("Sections");
if (sections != null)
{
foreach (var sectionTreeNode in sections.ChildNodes)
{
ParseSection(context, template, sectionTreeNode);
}
}
// setup HtmlTemplate
var htmlFileTextNode = textNode.GetAttribute("Layout.HtmlFile");
if (htmlFileTextNode != null && !string.IsNullOrEmpty(htmlFileTextNode.Value))
{
var field = context.ParseContext.Factory.Field(template.StandardValuesItem, htmlFileTextNode);
field.FieldNameProperty.SetValue("__Renderings");
field.ValueProperty.SetValue(htmlFileTextNode.Value);
field.ValueHintProperty.SetValue("HtmlTemplate");
template.StandardValuesItem.Fields.Add(field);
}
context.ParseContext.Project.AddOrMerge(template);
context.ParseContext.Project.AddOrMerge(standardValuesItem);
}
public override void Parse(ItemParseContext context, ITextNode textNode)
{
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value);
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName);
var item = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, guid, databaseName, itemNameTextNode.Value, itemIdOrPath, string.Empty);
item.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
Parse(context, textNode, item);
context.ParseContext.Project.AddOrMerge(item);
}
protected override void ParseChildrenTextNodes(ItemParseContext context, Item item, ITextNode textNode)
{
foreach (var childNode in textNode.ChildNodes)
{
// id child node is blank and first child is "Item", then this is probably an File.Include item
var child = childNode;
if (string.IsNullOrEmpty(child.Key) && !child.Attributes.Any() && child.ChildNodes.Count() == 1 && child.ChildNodes.First().Key == "Item")
{
child = childNode.ChildNodes.First();
}
var newContext = context.ParseContext.Factory.ItemParseContext(context.ParseContext, context.Parser, item.DatabaseName, PathHelper.CombineItemPath(context.ParentItemPath, item.ItemName), item.IsImport);
Parse(newContext, child);
}
}
protected override void ParseVersionedTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
context.ParseContext.SchemaService.ValidateTextNodeSchema(textNode);
foreach (var versionChildNode in textNode.ChildNodes)
{
var fieldContext = new LanguageVersionContext();
fieldContext.LanguageProperty.Parse(textNode);
fieldContext.VersionProperty.Parse(versionChildNode);
foreach (var versionedChildNode in versionChildNode.ChildNodes)
{
ParseFieldTextNode(context, item, fieldContext, versionedChildNode);
}
}
}
public override void Parse(ItemParseContext context, ITextNode textNode)
{
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value);
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.Database.DatabaseName);
var database = context.ParseContext.Project.GetDatabase(databaseName);
var item = Factory.Item(database, guid, itemNameTextNode.Value, itemIdOrPath, string.Empty).With(textNode);
item.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
Parse(context, textNode, item);
context.ParseContext.Project.AddOrMerge(item);
}
protected virtual void ParseDeviceReferences([NotNull] ItemParseContext context, [NotNull, ItemNotNull] ICollection <IReference> references, [NotNull] IProjectItem projectItem, [NotNull] ITextNode deviceTextNode)
{
var deviceNameProperty = new SourceProperty <string>(projectItem, "Name", string.Empty, SourcePropertyFlags.IsShort);
deviceNameProperty.Parse(deviceTextNode);
references.Add(Factory.DeviceReference(projectItem, deviceNameProperty, string.Empty, context.ParseContext.Database.DatabaseName));
var layoutProperty = new SourceProperty <string>(projectItem, "Layout", string.Empty, SourcePropertyFlags.IsShort);
layoutProperty.Parse(deviceTextNode);
references.Add(Factory.LayoutReference(projectItem, layoutProperty, string.Empty, context.ParseContext.Database.DatabaseName));
foreach (var renderingTextNode in deviceTextNode.ChildNodes)
{
ParseRenderingReferences(context, references, projectItem, renderingTextNode);
}
}
protected override void ParseFieldTextNode(ItemParseContext context, Item item, LanguageVersionContext languageVersionContext, ITextNode textNode)
{
var fieldNameTextNode = textNode.Key == "Field" ? textNode.GetAttribute("Name") : new AttributeNameTextNode(textNode);
if (fieldNameTextNode == null)
{
context.ParseContext.Trace.TraceError(Msg.P1014, Texts.Expected__Name__attribute, textNode);
return;
}
if (textNode.Attributes.Any() || textNode.ChildNodes.Any())
{
base.ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode);
return;
}
base.ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode, textNode);
}
public override void Parse(ItemParseContext context, ITextNode textNode)
{
SchemaService.ValidateTextNodeSchema(textNode, "Item");
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var parentItemPath = textNode.GetAttributeValue("ParentItemPath", context.ParentItemPath);
var itemIdOrPath = textNode.GetAttributeValue("ItemPath");
if (string.IsNullOrEmpty(itemIdOrPath))
{
itemIdOrPath = PathHelper.CombineItemPath(parentItemPath, itemNameTextNode.Value);
}
else if (itemNameTextNode.Value != Path.GetFileName(itemIdOrPath))
{
Trace.TraceError(Msg.P1027, "Item name in 'ItemPath' and 'Name' does not match. Using 'Name'");
}
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.Database.DatabaseName);
var database = context.ParseContext.Project.GetDatabase(databaseName);
var templateIdOrPath = textNode.GetAttributeValue("TemplateName", textNode.Key.UnescapeXmlElementName());
var item = Factory.Item(database, guid, itemNameTextNode.Value, itemIdOrPath, templateIdOrPath).With(textNode);
item.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
item.TemplateIdOrPathProperty.AddSourceTextNode(new AttributeNameTextNode(textNode));
item.SortorderProperty.Parse(textNode, context.Sortorder);
item.IsEmittable = textNode.GetAttributeBool(Constants.Fields.IsEmittable, true);
item.IsImport = textNode.GetAttributeBool(Constants.Fields.IsImport, context.IsImport);
if (!item.IsImport)
{
item.References.AddRange(ReferenceParser.ParseReferences(item, item.TemplateIdOrPathProperty));
}
// parse shared fields
var fieldContext = new LanguageVersionContext();
ParseAttributes(context, item, fieldContext, textNode);
// parse Fields, Layout and Items child text nodes
ParseChildNodes(context, item, textNode);
context.ParseContext.Project.AddOrMerge(item);
}
public virtual void Parse([NotNull] ItemParseContext context, [NotNull] ITextNode textNode, [NotNull] Item item)
{
var field = Factory.Field(item, "__Renderings", string.Empty).With(textNode);
// todo: set template field
var innerTextNode = textNode.Inner;
if (innerTextNode != null)
{
// use the inner value but the outer text node
field.ValueProperty.SetValue(innerTextNode.Value);
}
field.ValueProperty.AddSourceTextNode(textNode);
item.Fields.Add(field);
}
protected override void ParseVersionedTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
var firstChildNode = textNode.ChildNodes.First();
context.ParseContext.SchemaService.ValidateTextNodeSchema(firstChildNode);
foreach (var node in firstChildNode.ChildNodes)
{
var fieldContext = new LanguageVersionContext();
fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(firstChildNode));
fieldContext.VersionProperty.SetValue(new AttributeNameTextNode(node));
foreach (var versionedChildNode in node.ChildNodes)
{
ParseFieldTextNode(context, item, fieldContext, versionedChildNode);
}
}
}
public override void Parse(ItemParseContext context, ITextNode textNode)
{
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value);
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName);
var template = context.ParseContext.Factory.Template(context.ParseContext.Project, guid, textNode, databaseName, itemNameTextNode.Value, itemIdOrPath);
template.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
template.BaseTemplatesProperty.Parse(textNode, Constants.Templates.StandardTemplate);
template.IconProperty.Parse(textNode);
template.ShortHelpProperty.Parse(textNode);
template.LongHelpProperty.Parse(textNode);
// todo: yuck
template.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase);
template.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsImport, context.IsImport.ToString()), "True", StringComparison.OrdinalIgnoreCase);
template.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(template, template.BaseTemplatesProperty));
// create standard values item
var standardValuesItemIdOrPath = itemIdOrPath + "/__Standard Values";
var standardValuesGuid = StringHelper.GetGuid(context.ParseContext.Project, standardValuesItemIdOrPath);
var standardValuesItem = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, standardValuesGuid, databaseName, "__Standard Values", standardValuesItemIdOrPath, itemIdOrPath);
standardValuesItem.IsImport = template.IsImport;
// todo: should be Uri
template.StandardValuesItem = standardValuesItem;
// parse fields and sections
var sections = textNode.GetSnapshotLanguageSpecificChildNode("Sections");
if (sections != null)
{
foreach (var sectionTreeNode in sections.ChildNodes)
{
ParseSection(context, template, sectionTreeNode);
}
}
context.ParseContext.PipelineService.Resolve<TemplateParserPipeline>().Execute(context, template, textNode);
context.ParseContext.Project.AddOrMerge(template);
context.ParseContext.Project.AddOrMerge(standardValuesItem);
}
public virtual void ParseTextNode([NotNull] ItemParseContext context, [NotNull] ITextNode textNode)
{
try
{
var parsed = false;
foreach (var textNodeParser in TextNodeParsers.OrderBy(p => p.Priority))
{
if (!textNodeParser.CanParse(context, textNode))
{
continue;
}
parsed = true;
if (textNodeParser.SchemaService == null || textNodeParser.SchemaService.ValidateTextNodeSchema(textNode))
{
textNodeParser.Parse(context, textNode);
}
break;
}
if (!parsed)
{
Trace.TraceError(Msg.P1025, Texts.Unknown_text_node, textNode, textNode.Key);
}
}
catch (Exception ex)
{
var details = ex.Message;
if (Configuration.GetBool(Constants.Configuration.System.ShowStackTrace))
{
details += Environment.NewLine + ex.StackTrace;
}
Trace.TraceError(Msg.P1004, string.Empty, context.ParseContext.Snapshot.SourceFile.AbsoluteFileName, TextSpan.Empty, details);
}
}
protected virtual void ParseSection([NotNull] ItemParseContext context, [NotNull] Template template, [NotNull] ITextNode templateSectionTextNode)
{
if (string.Equals(templateSectionTextNode.Value, "__Standard Values", StringComparison.OrdinalIgnoreCase))
{
return;
}
SchemaService.ValidateTextNodeSchema(templateSectionTextNode, "TemplateSection");
GetName(context.ParseContext, templateSectionTextNode, out var sectionName, out var sectionNameTextNode, "Section", "Name");
if (string.IsNullOrEmpty(sectionName))
{
Trace.TraceError(Msg.P1007, Texts._Section__element_must_have_a__Name__attribute, sectionNameTextNode);
return;
}
var templateSection = template.Sections.FirstOrDefault(s => string.Equals(s.SectionName, sectionName, StringComparison.OrdinalIgnoreCase));
if (templateSection == null)
{
var itemIdOrPath = template.ItemIdOrPath + "/" + sectionName;
var guid = StringHelper.GetGuid(template.Project, templateSectionTextNode.GetAttributeValue("Id", itemIdOrPath));
templateSection = Factory.TemplateSection(template, guid).With(templateSectionTextNode);
templateSection.SectionNameProperty.SetValue(sectionNameTextNode);
templateSection.SectionName = sectionName;
template.Sections.Add(templateSection);
}
templateSection.IconProperty.Parse(templateSectionTextNode);
var nextSortOrder = 0;
foreach (var fieldTextNode in templateSectionTextNode.ChildNodes)
{
ParseField(context, template, templateSection, fieldTextNode, ref nextSortOrder);
}
}
protected virtual void ParseRenderingReferences([NotNull] ItemParseContext context, [NotNull, ItemNotNull] ICollection <IReference> references, [NotNull] IProjectItem projectItem, [NotNull] ITextNode renderingTextNode)
{
if (!string.IsNullOrEmpty(renderingTextNode.Key))
{
var sourceProperty = new SourceProperty <string>(projectItem, renderingTextNode.Key, string.Empty, SourcePropertyFlags.IsShort);
sourceProperty.SetValue(new AttributeNameTextNode(renderingTextNode));
references.Add(Factory.LayoutRenderingReference(projectItem, sourceProperty, string.Empty, context.ParseContext.Database.DatabaseName));
}
// parse references for rendering properties
foreach (var attributeTextNode in renderingTextNode.Attributes)
{
foreach (var reference in ReferenceParserService.ParseReferences(projectItem, attributeTextNode))
{
references.Add(reference);
}
}
foreach (var childTextNode in renderingTextNode.ChildNodes)
{
ParseRenderingReferences(context, references, projectItem, childTextNode);
}
}
protected abstract void ParseFieldsTextNode([NotNull] ItemParseContext context, [NotNull] Item item, [NotNull] ITextNode fieldsTextNode);
public override void Parse(ItemParseContext context, ITextNode textNode)
{
SchemaService.ValidateTextNodeSchema(textNode, "Template");
var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode);
var parentItemPath = textNode.GetAttributeValue("ParentItemPath", context.ParentItemPath);
var itemIdOrPath = textNode.GetAttributeValue("ItemPath");
if (string.IsNullOrEmpty(itemIdOrPath))
{
itemIdOrPath = PathHelper.CombineItemPath(parentItemPath, itemNameTextNode.Value);
}
else if (itemNameTextNode.Value != Path.GetFileName(itemIdOrPath))
{
Trace.TraceError(Msg.P1034, "Item name in 'ItemPath' and 'Name' does not match. Using 'Name'");
}
var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath));
var databaseName = textNode.GetAttributeValue("Database", context.Database.DatabaseName);
var database = context.ParseContext.Project.GetDatabase(databaseName);
var template = Factory.Template(database, guid, itemNameTextNode.Value, itemIdOrPath);
template.ItemNameProperty.AddSourceTextNode(itemNameTextNode);
template.BaseTemplatesProperty.Parse(textNode, Constants.Templates.StandardTemplateId);
template.IconProperty.Parse(textNode);
template.ShortHelpProperty.Parse(textNode);
template.LongHelpProperty.Parse(textNode);
template.IsEmittable = textNode.GetAttributeBool(Constants.Fields.IsEmittable, true);
template.IsImport = textNode.GetAttributeBool(Constants.Fields.IsImport, context.IsImport);
template.References.AddRange(ReferenceParser.ParseReferences(template, template.BaseTemplatesProperty));
Item standardValuesItem;
var standardValuesTextNode = textNode.ChildNodes.FirstOrDefault(n => string.Equals(n.Value, "__Standard Values", StringComparison.OrdinalIgnoreCase));
if (standardValuesTextNode != null)
{
var newContext = Factory.ItemParseContext(context.ParseContext, context.Parser, template.Database, template.ItemIdOrPath, template.IsImport);
context.Parser.ParseTextNode(newContext, standardValuesTextNode);
standardValuesItem = template.Database.GetItem(template.ItemIdOrPath + "/__Standard Values");
if (standardValuesItem == null)
{
Trace.TraceError(Msg.C1137, "'__Standard Values' item not parsed correctly", standardValuesTextNode);
}
}
else
{
// create standard values item
var standardValuesItemIdOrPath = itemIdOrPath + "/__Standard Values";
var standardValuesGuid = StringHelper.GetGuid(context.ParseContext.Project, standardValuesItemIdOrPath);
standardValuesItem = Factory.Item(database, standardValuesGuid, "__Standard Values", standardValuesItemIdOrPath, itemIdOrPath).With(textNode);
context.ParseContext.Project.AddOrMerge(standardValuesItem);
}
if (standardValuesItem != null)
{
// todo: should be Uri
template.StandardValuesItem = standardValuesItem;
standardValuesItem.IsImport = template.IsImport;
}
// parse fields and sections
foreach (var sectionTreeNode in textNode.ChildNodes)
{
ParseSection(context, template, sectionTreeNode);
}
Pipelines.GetPipeline <TemplateParserPipeline>().Execute(context, template, textNode);
context.ParseContext.Project.AddOrMerge(template);
}
protected override void ParseLayoutTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
var parser = new XmlLayoutTextNodeParser();
parser.Parse(context, textNode, item);
}
protected override void ParseFieldsTextNode(ItemParseContext context, Item item, ITextNode fieldsTextNode)
{
context.ParseContext.SchemaService.ValidateTextNodeSchema(fieldsTextNode);
base.ParseFieldsTextNode(context, item, fieldsTextNode);
}
protected override void ParseUnknownTextNode(ItemParseContext context, Item item, LanguageVersionContext languageVersionContext, ITextNode textNode)
{
ParseFieldTextNode(context, item, languageVersionContext, textNode);
}
public override bool CanParse(ItemParseContext context, ITextNode textNode)
{
return textNode.Key == "Template";
}
public abstract void Parse(ItemParseContext context, ITextNode textNode);
public abstract bool CanParse(ItemParseContext context, ITextNode textNode);
public abstract void Parse(ItemParseContext context, ITextNode textNode);
public override bool CanParse(ItemParseContext context, ITextNode textNode)
{
return textNode.Key == "Layout" && textNode.Snapshot is YamlTextSnapshot && textNode.Snapshot.SourceFile.AbsoluteFileName.EndsWith(".layout.yaml", StringComparison.OrdinalIgnoreCase);
}
protected override void ParseVersionedTextNode(ItemParseContext context, Item item, ITextNode textNode)
{
context.ParseContext.SchemaService.ValidateTextNodeSchema(textNode);
foreach (var languageChildNode in textNode.ChildNodes)
{
foreach (var versionChildNode in languageChildNode.ChildNodes)
{
var fieldContext = new LanguageVersionContext();
fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(languageChildNode));
fieldContext.VersionProperty.SetValue(new AttributeNameTextNode(versionChildNode));
ParseUnversionedOrVersionedTreeNode(context, item, fieldContext, versionChildNode);
}
}
}
protected override void ParseUnknownTextNode(ItemParseContext context, Item item, LanguageVersionContext languageVersionContext, ITextNode textNode)
{
var fieldNameTextNode = new AttributeNameTextNode(textNode);
ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode);
}
protected abstract void ParseLayoutTextNode([NotNull] ItemParseContext context, [NotNull] Item item, [NotNull] ITextNode layoutTextNode);
public abstract bool CanParse(ItemParseContext context, ITextNode textNode);
public override bool CanParse(ItemParseContext context, ITextNode textNode)
{
return textNode.Snapshot is YamlTextSnapshot;
}
public override bool CanParse(ItemParseContext context, ITextNode textNode)
{
return textNode.Key == "Item" && textNode.Snapshot is XmlTextSnapshot;
}
