public static Property FromContentTypeElement(ElementMetadataBase element)
{
if (IsContentTypeSupported(element.Type))
{
return(new Property(element.Codename, ManagementElementTypesDictionary[element.Type], element.Id.ToString()));
}
if (element.Type == ElementMetadataType.Guidelines)
{
throw new UnsupportedTypeException();
}
throw new ArgumentException($"Unknown Content Type {element.Type}", nameof(element));
}
private static void Validate(
ElementMetadataBase element,
IEnumerable <ContentTypeSnippetModel> managementSnippets)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
if (managementSnippets == null)
{
throw new ArgumentNullException(nameof(managementSnippets));
}
}
public static IEnumerable <ElementMetadataBase> GetManagementContentTypeSnippetElements(
ElementMetadataBase element,
IEnumerable <ContentTypeSnippetModel> managementSnippets)
{
Validate(element, managementSnippets);
if (element.Type != ElementMetadataType.ContentTypeSnippet)
{
return(null);
}
var managementSnippet = managementSnippets.FirstOrDefault(s => element.Codename == s.Codename);
if (managementSnippet == null)
{
throw new ArgumentException($"{nameof(managementSnippet)} shouldn't be null.");
}
return(managementSnippet.Elements);
}
private void SetElementProperties(IElement element, ElementMetadataBase elementMetadata)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
if (elementMetadata == null)
{
throw new ArgumentNullException(nameof(elementMetadata));
}
//Parameters
if (elementMetadata.Parameters != null)
{
//Deal with each parameter
foreach (var parameterMetadata in elementMetadata.Parameters)
{
//Find the parameter in question
var parameter = element.Parameters.FirstOrDefault(p => p.Id == parameterMetadata.Id);
if (parameter == null)
{
Console.WriteLine($"Unable to find parameter {parameterMetadata.Id}");
}
else
{
//Set the value of the parameter
parameter.SetValue(parameterMetadata.Value);
if (parameterMetadata.Operator != null)
{
parameter.Operator = (IOperator)(CreateElement(element.Owner, parameterMetadata.Operator));
}
}
}
}
}
/// <summary>
/// Transform the base class to the specific element.
/// </summary>
/// <param name="source">ElementMetadataBase class</param>
/// <returns></returns>
public static T ToElement <T>(this ElementMetadataBase source) where T : ElementMetadataBase
{
if (source == null)
{
return(null);
}
switch (source.Type)
{
case ElementMetadataType.Text:
if (source.Type != ElementMetadataType.Text)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(TextElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.RichText:
if (source.Type != ElementMetadataType.RichText)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(RichTextElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.Number:
if (source.Type != ElementMetadataType.Number)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(NumberElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.MultipleChoice:
if (source.Type != ElementMetadataType.MultipleChoice)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(MultipleChoiceElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.DateTime:
if (source.Type != ElementMetadataType.DateTime)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(DateTimeElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.Asset:
if (source.Type != ElementMetadataType.Asset)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(AssetElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.LinkedItems:
if (source.Type != ElementMetadataType.LinkedItems)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(LinkedItemsElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.Guidelines:
if (source.Type != ElementMetadataType.Guidelines)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(GuidelinesElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.Taxonomy:
if (source.Type != ElementMetadataType.Taxonomy)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(TaxonomyElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.UrlSlug:
if (source.Type != ElementMetadataType.UrlSlug)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(UrlSlugElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.ContentTypeSnippet:
if (source.Type != ElementMetadataType.ContentTypeSnippet)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(ContentTypeSnippetElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.Custom:
if (source.Type != ElementMetadataType.Custom)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(CustomElementMetadataModel)}");
}
return(source as T);
case ElementMetadataType.Subpages:
if (source.Type != ElementMetadataType.Subpages)
{
throw new InvalidOperationException($"Type {source.Type} cannot be converted to {nameof(SubpagesElementMetadataModel)}");
}
return(source as T);
default: throw new InvalidOperationException($"Type {source.Type} cannot be converted to any known element");
}
}
public void FromContentTypeElement_ManagementApiModel_Returns(string expectedTypeName, string expectedCodename, ElementMetadataBase element)
{
var property = Property.FromContentTypeElement(element);
Assert.Equal(expectedCodename, property.Identifier);
Assert.Equal(expectedTypeName, property.TypeName);
Assert.Equal(element.Id.ToString(), property.Id);
}
