//public abstract TemplateInfo[] GetTemplates(params ITreeRoot[] rootPaths);
protected virtual IEnumerable <TemplateInfo> ParseTemplates(IItemDataAdapter root)
{
var processQueue = new Queue <IItemDataAdapter>();
processQueue.Enqueue(root);
while (processQueue.Count > 0)
{
var currentTemplate = processQueue.Dequeue();
// if it's a template we parse it and skip adding children (nested templates not really allowed)
if (currentTemplate.TemplateId == TemplateTemplateId)
{
yield return(ParseTemplate(currentTemplate));
continue;
}
// it's not a template (e.g. a template folder) so we want to scan its children for templates to parse
var children = currentTemplate.GetChildren();
foreach (var child in children)
{
processQueue.Enqueue(child);
}
}
}
protected virtual string GetFieldValue(IItemDataAdapter item, Guid fieldId, string defaultValue)
{
foreach (IItemFieldValueAdapter field in item.SharedFields)
{
if (field.FieldId == fieldId)
{
return(field.Value);
}
}
foreach (IItemFieldValueAdapter field in item.UnversionedFields.SelectMany(uf => uf.Fields))
{
if (field.FieldId == fieldId)
{
return(field.Value);
}
}
foreach (IItemFieldValueAdapter field in item.Versions.SelectMany(v => v.Fields))
{
if (field.FieldId == fieldId)
{
return(field.Value);
}
}
return(defaultValue);
}
protected virtual TemplateFieldInfo[] ParseTemplateFields(IItemDataAdapter templateItem)
{
var results = new List <TemplateFieldInfo>();
var sections = templateItem.GetChildren().Where(child => child.TemplateId == TemplateSectionTemplateId);
foreach (var section in sections)
{
var fields = section.GetChildren().Where(child => child.TemplateId == TemplateFieldTemplateId);
foreach (var field in fields)
{
results.Add(new TemplateFieldInfo
{
Id = field.Id,
DisplayName = GetFieldValue(field, TemplateFieldTitleFieldId, null) ?? GetFieldValue(field, DisplayNameFieldId, string.Empty),
HelpText = GetFieldValue(field, HelpTextFieldId, string.Empty),
Name = field.Name,
Path = field.Path,
Section = section.Name,
SortOrder = GetFieldValueAsInt(field, SortOrderFieldId, 100),
Source = GetFieldValue(field, SourceFieldId, string.Empty),
Type = GetFieldValue(field, FieldTypeFieldId, string.Empty),
AllFields = GetAllFields(field)
});
}
}
return(results.ToArray());
}
protected virtual int GetFieldValueAsInt(IItemDataAdapter itemDataAdapter, Guid fieldId, int defaultValue)
{
var value = GetFieldValue(itemDataAdapter, fieldId, string.Empty);
if (int.TryParse(value, out int result))
{
return(result);
}
return(defaultValue);
}
protected virtual IDictionary <Guid, string> GetAllFields(IItemDataAdapter item)
{
var allFields = new Dictionary <Guid, string>();
foreach (IItemFieldValueAdapter field in item.SharedFields)
{
allFields[field.FieldId] = field.Value;
}
foreach (IItemFieldValueAdapter field in item.UnversionedFields.SelectMany(f => f.Fields))
{
allFields[field.FieldId] = field.Value;
}
foreach (IItemFieldValueAdapter field in item.Versions.SelectMany(v => v.Fields))
{
allFields[field.FieldId] = field.Value;
}
return(allFields);
}
protected virtual TemplateInfo ParseTemplate(IItemDataAdapter templateItem)
{
if (templateItem == null)
{
throw new ArgumentException("Template item passed to parse was null", nameof(templateItem));
}
if (templateItem.TemplateId != TemplateTemplateId)
{
throw new ArgumentException("Template item passed to parse was not a Template item", nameof(templateItem));
}
var result = new TemplateInfo
{
Id = templateItem.Id,
BaseTemplateIds = ParseBaseTemplatesAndRejectIgnoredBaseTemplates(GetFieldValue(templateItem, BaseTemplateFieldId, string.Empty)),
HelpText = GetFieldValue(templateItem, HelpTextFieldId, string.Empty),
Name = templateItem.Name,
OwnFields = ParseTemplateFields(templateItem),
Path = templateItem.Path
};
return(result);
}
public IDictionary <Guid, string> Public_GetAllFields(IItemDataAdapter item)
{
return(GetAllFields(item));
}
public TemplateInfo Public_ParseTemplate(IItemDataAdapter templateItem)
{
return(ParseTemplate(templateItem));
}
public void GetAllFields_Includes_AllFields(TestableDataSourceTemplateReader sut, IItemDataAdapter itemData)
{
var allFields = sut.Public_GetAllFields(itemData);
itemData.SharedFields.Select(x => x.FieldId).All(allFields.Keys.Contains).Should().BeTrue();
itemData.UnversionedFields.SelectMany(x => x.Fields.Select(y => y.FieldId)).All(allFields.Keys.Contains).Should().BeTrue();
itemData.Versions.SelectMany(x => x.Fields.Select(y => y.FieldId)).All(allFields.Keys.Contains).Should().BeTrue();
}
public void ParseTemplate_WhenTemplateIsATemplate_ReturnTemplate(TestableDataSourceTemplateReader sut, IItemDataAdapter templateItem)
{
sut.Public_ParseTemplate(templateItem).Id.Should().Be(templateItem.Id);
}
public void ParseTemplate_WhenTemplateIsNotTemplate_ThrowException(TestableDataSourceTemplateReader sut, IItemDataAdapter invalidTemplateItem)
{
Xunit.Assert.Throws <ArgumentException>(() => sut.Public_ParseTemplate(invalidTemplateItem));
}
