swcs/Archetype
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add missing XML docs.

Browse Source
This commit is contained in:
kgiszewski
2015-11-02 11:35:37 -05:00
parent a2b2567350
commit 6acaf65ec3
21 changed files with 381 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/Umbraco/Archetype.Courier/DataResolvers/ArchetypeDataResolver.cs
+46
View File
@@ -13,6 +13,9 @@ using Umbraco.Courier.ItemProviders;
namespace Archetype.Courier.DataResolvers
{
/// <summary>
/// Lee Kelleher's implementation of Courier's PropertyDataResolverProvider for Archetype.
/// </summary>
public class ArchetypeDataResolver : PropertyDataResolverProvider
{
private enum Direction
@@ -21,6 +24,12 @@ namespace Archetype.Courier.DataResolvers
Packaging
}
/// <summary>
/// Gets the editor alias.
/// </summary>
/// <value>
/// The editor alias.
/// </value>
public override string EditorAlias
{
get
@@ -29,26 +38,48 @@ namespace Archetype.Courier.DataResolvers
}
}
/// <summary>
/// Extractings the type of the data.
/// </summary>
/// <param name="item">The item.</param>
public override void ExtractingDataType(DataType item)
{
// No longer need to extract the DataType (int) Ids as Archetype now references the Guid [LK]
}
/// <summary>
/// Extractings the property.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="propertyData">The property data.</param>
public override void ExtractingProperty(Item item, ContentProperty propertyData)
{
ReplacePropertyDataIds(item, propertyData, Direction.Extracting);
}
/// <summary>
/// Packagings the type of the data.
/// </summary>
/// <param name="item">The item.</param>
public override void PackagingDataType(DataType item)
{
AddDataTypeDependencies(item);
}
/// <summary>
/// Packages the property.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="propertyData">The property data.</param>
public override void PackagingProperty(Item item, ContentProperty propertyData)
{
ReplacePropertyDataIds(item, propertyData, Direction.Packaging);
}
/// <summary>
/// Adds the datatype dependencies.
/// </summary>
/// <param name="item">The item.</param>
private void AddDataTypeDependencies(DataType item)
{
if (item.Prevalues != null && item.Prevalues.Count > 0)
@@ -71,6 +102,12 @@ namespace Archetype.Courier.DataResolvers
}
}
/// <summary>
/// Replaces the property data Ids.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="propertyData">The property data.</param>
/// <param name="direction">The direction.</param>
private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction)
{
if (propertyData != null && propertyData.Value != null)
@@ -168,6 +205,10 @@ namespace Archetype.Courier.DataResolvers
}
}
/// <summary>
/// Retrieves the additional properties.
/// </summary>
/// <param name="preValue">The pre value.</param>
private void RetrieveAdditionalProperties(ref ArchetypePreValue preValue)
{
if (preValue == null)
@@ -189,6 +230,11 @@ namespace Archetype.Courier.DataResolvers
}
}
/// <summary>
/// Retrieves the additional properties.
/// </summary>
/// <param name="archetype">The archetype.</param>
/// <param name="preValue">The pre value.</param>
private void RetrieveAdditionalProperties(ref ArchetypeModel archetype, ArchetypePreValue preValue)
{
foreach (var fieldset in preValue.Fieldsets)
app/Umbraco/Archetype.Tests/Models/FieldsetTests.cs
+6 -2
View File
@@ -5,13 +5,17 @@ using NUnit.Framework;
namespace Archetype.Tests.Models
{
/// <summary>
/// Tests designed for the fieldsets.
/// </summary>
[TestFixture]
public class FieldsetTests
{
private string _sampleJson;
/// <summary>
/// Sets up the test to use sample JSON data.
/// </summary>
[SetUp]
public void SetUp()
{
app/Umbraco/Archetype.Tests/PropertyValueConverter/PropertyValueConverterTests.cs
+7 -8
View File
@@ -1,22 +1,21 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Archetype.PropertyConverters;
using Moq;
using NUnit.Framework;
using Umbraco.Core.Models.PublishedContent;
namespace Archetype.Tests.PropertyValueConverter
{
/// <summary>
/// Tests designed to test the PVC.
/// </summary>
[TestFixture]
public class PropertyValueConverterTests
{
private string _sampleJson;
/// <summary>
/// Sets up the test to use JSON data.
/// </summary>
[SetUp]
public void SetUp()
{
app/Umbraco/DatabaseSizer/Application.cs
+4
View File
@@ -4,6 +4,10 @@ using Umbraco.Core.Logging;
namespace DatabaseSizer
{
/// <summary>
/// A now obsolete project that handled an Umbraco core limitation.
/// </summary>
[Obsolete("This project is now obsolete with 7.2.2+")]
public class Application : ApplicationEventHandler
{
protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
app/Umbraco/Umbraco.Archetype/Api/ArchetypeDataTypeController.cs
+31 -1
View File
@@ -14,10 +14,12 @@ using Archetype.Extensions;
namespace Archetype.Api
{
/// <summary>
/// Controller that handles datatype related interactions.
/// </summary>
[PluginController("ArchetypeApi")]
public class ArchetypeDataTypeController : UmbracoAuthorizedJsonController
{
public IEnumerable<object> GetAllPropertyEditors()
{
return
@@ -25,12 +27,22 @@ namespace Archetype.Api
.Select(x => new {defaultPreValues = x.DefaultPreValuesForArchetype(), alias = x.Alias, view = x.ValueEditor.View});
}
/// <summary>
/// Gets all datatypes.
/// </summary>
/// <returns></returns>
public object GetAll()
{
var dataTypes = Services.DataTypeService.GetAllDataTypeDefinitions();
return dataTypes.Select(t => new { guid = t.Key, name = t.Name });
}
/// <summary>
/// Gets the datatype by GUID.
/// </summary>
/// <param name="guid">The unique identifier.</param>
/// <returns></returns>
/// <exception cref="System.Web.Http.HttpResponseException"></exception>
public object GetByGuid(Guid guid)
{
var dataType = Services.DataTypeService.GetDataTypeDefinitionById(guid);
@@ -43,6 +55,16 @@ namespace Archetype.Api
return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues };
}
/// <summary>
/// Gets the datatype by GUID.
/// </summary>
/// <param name="guid">The unique identifier.</param>
/// <param name="contentTypeAlias">The content type alias.</param>
/// <param name="propertyTypeAlias">The property type alias.</param>
/// <param name="archetypeAlias">The archetype alias.</param>
/// <param name="nodeId">The node identifier.</param>
/// <returns></returns>
/// <exception cref="System.Web.Http.HttpResponseException"></exception>
public object GetByGuid(Guid guid, string contentTypeAlias, string propertyTypeAlias, string archetypeAlias, int nodeId)
{
var dataType = Services.DataTypeService.GetDataTypeDefinitionById(guid);
@@ -54,11 +76,19 @@ namespace Archetype.Api
return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues, contentTypeAlias = contentTypeAlias, propertyTypeAlias = propertyTypeAlias, archetypeAlias = archetypeAlias, nodeId = nodeId };
}
/// <summary>
/// Returns the DLL version from the file.
/// </summary>
/// <returns></returns>
public object GetDllVersion()
{
return new {dllVersion = _version()};
}
/// <summary>
/// Gets the DLL version from the file.
/// </summary>
/// <returns></returns>
private string _version()
{
var asm = Assembly.GetExecutingAssembly();
app/Umbraco/Umbraco.Archetype/Constants.cs
+3
View File
@@ -1,5 +1,8 @@
namespace Archetype
{
/// <summary>
/// Archetype constants.
/// </summary>
public static class Constants
{
public const string PropertyEditorAlias = "Imulus.Archetype";
app/Umbraco/Umbraco.Archetype/Events/ExpireCache.cs
+11 -8
View File
@@ -1,18 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Umbraco.Core;
using Umbraco.Core;
using Umbraco.Core.Models;
using Umbraco.Core.Services;
using Umbraco.Web;
namespace Archetype.Events
{
public class ExpireCache : ApplicationEventHandler
{
/// <summary>
/// Registers our ExpirePreValueCache handler on app starting.
/// </summary>
/// <param name="umbracoApplication"></param>
/// <param name="applicationContext"></param>
protected override void ApplicationStarting(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
{
base.ApplicationStarting(umbracoApplication, applicationContext);
@@ -20,6 +18,11 @@ namespace Archetype.Events
DataTypeService.Saved += ExpirePreValueCache;
}
/// <summary>
/// Expires the pre value cache when a datatype is saved.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="Umbraco.Core.Events.SaveEventArgs{IDataTypeDefinition}"/> instance containing the event data.</param>
void ExpirePreValueCache(IDataTypeService sender, global::Umbraco.Core.Events.SaveEventArgs<IDataTypeDefinition> e)
{
foreach (var dataType in e.SavedEntities)
app/Umbraco/Umbraco.Archetype/Extensions/ArchetypeHelper.cs
+45
View File
@@ -9,6 +9,9 @@ using Umbraco.Core.Models.PublishedContent;
namespace Archetype.Extensions
{
/// <summary>
/// Helper class that handles several Archetype related interactions.
/// </summary>
public class ArchetypeHelper
{
protected JsonSerializerSettings _jsonSettings;
@@ -18,6 +21,9 @@ namespace Archetype.Extensions
internal static ArchetypeHelper Instance { get { return _instance; } }
/// <summary>
/// Initializes a new instance of the <see cref="ArchetypeHelper"/> class.
/// </summary>
internal ArchetypeHelper()
{
var dcr = new Newtonsoft.Json.Serialization.DefaultContractResolver();
@@ -27,8 +33,20 @@ namespace Archetype.Extensions
_app = ApplicationContext.Current;
}
/// <summary>
/// Gets the json serializer settings.
/// </summary>
/// <value>
/// The json serializer settings.
/// </value>
internal JsonSerializerSettings JsonSerializerSettings { get { return _jsonSettings; } }
/// <summary>
/// Deserializes the JSON to archetype.
/// </summary>
/// <param name="sourceJson">The source JSON.</param>
/// <param name="dataTypePreValues">The data type pre values.</param>
/// <returns></returns>
internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues)
{
try
@@ -54,6 +72,13 @@ namespace Archetype.Extensions
}
}
/// <summary>
/// Deserializes the JSON to archetype.
/// </summary>
/// <param name="sourceJson">The source JSON.</param>
/// <param name="dataTypeId">The data type identifier.</param>
/// <param name="hostContentType">Type of the host content.</param>
/// <returns></returns>
internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, int dataTypeId, PublishedContentType hostContentType = null)
{
try
@@ -79,6 +104,11 @@ namespace Archetype.Extensions
}
}
/// <summary>
/// Determines whether datatypeId has had it's PVC overridden.
/// </summary>
/// <param name="dataTypeId">The data type identifier.</param>
/// <returns></returns>
internal bool IsPropertyValueConverterOverridden(int dataTypeId)
{
var prevalues = GetArchetypePreValueFromDataTypeId(dataTypeId);
@@ -88,6 +118,11 @@ namespace Archetype.Extensions
return prevalues.OverrideDefaultPropertyValueConverter;
}
/// <summary>
/// Gets the archetype pre value from data type identifier.
/// </summary>
/// <param name="dataTypeId">The data type identifier.</param>
/// <returns></returns>
private ArchetypePreValue GetArchetypePreValueFromDataTypeId(int dataTypeId)
{
return _app.ApplicationCache.RuntimeCache.GetCacheItem(
@@ -108,6 +143,11 @@ namespace Archetype.Extensions
}) as ArchetypePreValue;
}
/// <summary>
/// Gets the archetype pre value from pre values collection.
/// </summary>
/// <param name="dataTypePreValues">The data type pre values.</param>
/// <returns></returns>
private ArchetypePreValue GetArchetypePreValueFromPreValuesCollection(PreValueCollection dataTypePreValues)
{
var preValueAsString = dataTypePreValues.PreValuesAsDictionary.First().Value.Value;
@@ -115,6 +155,11 @@ namespace Archetype.Extensions
return preValue;
}
/// <summary>
/// Gets the data type by unique identifier.
/// </summary>
/// <param name="guid">The unique identifier.</param>
/// <returns></returns>
internal IDataTypeDefinition GetDataTypeByGuid(Guid guid)
{
return (IDataTypeDefinition)ApplicationContext.Current.ApplicationCache.RuntimeCache.GetCacheItem(
app/Umbraco/Umbraco.Archetype/Extensions/ArchetypePropertyModelExtensions.cs
+13
View File
@@ -5,13 +5,26 @@ using Umbraco.Core.Models.PublishedContent;
namespace Archetype.Extensions
{
/// <summary>
/// ArchetypePropertyModel extensions.
/// </summary>
public static class ArchetypePropertyModelExtensions
{
/// <summary>
/// Determines whether this instance is an archetype.
/// </summary>
/// <param name="prop">The property.</param>
/// <returns></returns>
public static bool IsArchetype(this ArchetypePropertyModel prop)
{
return prop.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditorAlias);
}
/// <summary>
/// Creates dummy property type.
/// </summary>
/// <param name="prop">The property.</param>
/// <returns></returns>
internal static PublishedPropertyType CreateDummyPropertyType(this ArchetypePropertyModel prop)
{
return new PublishedPropertyType(prop.HostContentType, new PropertyType(new DataTypeDefinition(-1, prop.PropertyEditorAlias) { Id = prop.DataTypeId }));
app/Umbraco/Umbraco.Archetype/Extensions/HtmlHelperExtensions.cs
+39
View File
@@ -7,28 +7,67 @@ using Umbraco.Core.Logging;
namespace Archetype.Extensions
{
/// <summary>
/// HtmlHelper extenions used for rendering an Archetype.
/// </summary>
public static class HtmlHelperExtensions
{
/// <summary>
/// Renders the archetype partials.
/// </summary>
/// <param name="htmlHelper">The HTML helper.</param>
/// <param name="archetypeModel">The archetype model.</param>
/// <returns></returns>
public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel)
{
return RenderPartials(htmlHelper, archetypeModel, null, null);
}
/// <summary>
/// Renders the archetype partials.
/// </summary>
/// <param name="htmlHelper">The HTML helper.</param>
/// <param name="archetypeModel">The archetype model.</param>
/// <param name="partialPath">The partial path.</param>
/// <returns></returns>
public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath)
{
return RenderPartials(htmlHelper, archetypeModel, partialPath, null);
}
/// <summary>
/// Renders the archetype partials.
/// </summary>
/// <param name="htmlHelper">The HTML helper.</param>
/// <param name="archetypeModel">The archetype model.</param>
/// <param name="viewDataDictionary">The view data dictionary.</param>
/// <returns></returns>
public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, ViewDataDictionary viewDataDictionary)
{
return RenderPartials(htmlHelper, archetypeModel, null, viewDataDictionary);
}
/// <summary>
/// Renders the archetype partials.
/// </summary>
/// <param name="htmlHelper">The HTML helper.</param>
/// <param name="archetypeModel">The archetype model.</param>
/// <param name="partialPath">The partial path.</param>
/// <param name="viewDataDictionary">The view data dictionary.</param>
/// <returns></returns>
public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
{
return htmlHelper.RenderPartials(archetypeModel, partialPath, viewDataDictionary);
}
/// <summary>
/// Renders the partials based on the model, partial path and given viewdata dictionary.
/// </summary>
/// <param name="htmlHelper">The HTML helper.</param>
/// <param name="archetypeModel">The archetype model.</param>
/// <param name="partialPath">The partial path.</param>
/// <param name="viewDataDictionary">The view data dictionary.</param>
/// <returns></returns>
private static IHtmlString RenderPartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
{
var context = HttpContext.Current;
app/Umbraco/Umbraco.Archetype/Extensions/PropertyEditorExtensions.cs
+3
View File
@@ -5,6 +5,9 @@ using Umbraco.Core.PropertyEditors;
namespace Archetype.Extensions
{
/// <summary>
/// PropertyEditor extensions.
/// </summary>
public static class PropertyEditorExtensions
{
/// <summary>
app/Umbraco/Umbraco.Archetype/Extensions/StringExtensions.cs
+8 -1
View File
@@ -1,8 +1,15 @@
namespace Archetype.Extensions
{
/// <summary>
/// String extensions.
/// </summary>
public static class StringExtensions
{
//lifted from the core as it is marked 'internal'
/// <summary>
/// Detects if the input string is JSON.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static bool DetectIsJson(this string input)
{
input = input.Trim();
app/Umbraco/Umbraco.Archetype/Models/ArchetypeFieldsetModel.cs
+44 -1
View File
@@ -6,6 +6,9 @@ using System;
namespace Archetype.Models
{
/// <summary>
/// Model that represents a fieldset stored as content JSON.
/// </summary>
public class ArchetypeFieldsetModel
{
[JsonProperty("alias")]
@@ -20,6 +23,9 @@ namespace Archetype.Models
[JsonProperty("id")]
public Guid Id { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="ArchetypeFieldsetModel"/> class.
/// </summary>
public ArchetypeFieldsetModel()
{
Properties = new List<ArchetypePropertyModel>();
@@ -27,11 +33,22 @@ namespace Archetype.Models
#region Helper Methods
/// <summary>
/// Gets the value and returns as string.
/// </summary>
/// <param name="propertyAlias">The property alias.</param>
/// <returns></returns>
public string GetValue(string propertyAlias)
{
return GetValue<string>(propertyAlias);
}
/// <summary>
/// Gets the value based on the type passed in as a generic.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="propertyAlias">The property alias.</param>
/// <returns></returns>
public T GetValue<T>(string propertyAlias)
{
var property = GetProperty(propertyAlias);
@@ -49,6 +66,13 @@ namespace Archetype.Models
// however, this would require GetValue<T>(string propertyAlias) to call the common implementation
// with a default(T) value, which could in theory result in a performance hit, if T for some reason
// is costly to instantiate.
/// <summary>
/// Gets the value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="propertyAlias">The property alias.</param>
/// <param name="defaultValue">The default value.</param>
/// <returns></returns>
public T GetValue<T>(string propertyAlias, T defaultValue)
{
var property = GetProperty(propertyAlias);
@@ -61,16 +85,31 @@ namespace Archetype.Models
return property.GetValue<T>();
}
/// <summary>
/// Determines whether the property is empty.
/// </summary>
/// <param name="property">The property.</param>
/// <returns></returns>
private bool IsEmptyProperty(ArchetypePropertyModel property)
{
return (property == null || property.Value == null || string.IsNullOrEmpty(property.Value.ToString()));
}
/// <summary>
/// Determines whether the specified property alias has property.
/// </summary>
/// <param name="propertyAlias">The property alias.</param>
/// <returns></returns>
public bool HasProperty(string propertyAlias)
{
return GetProperty(propertyAlias) != null;
}
/// <summary>
/// Determines whether the specified property alias has value.
/// </summary>
/// <param name="propertyAlias">The property alias.</param>
/// <returns></returns>
public bool HasValue(string propertyAlias)
{
var property = GetProperty(propertyAlias);
@@ -80,12 +119,16 @@ namespace Archetype.Models
return !string.IsNullOrEmpty(property.Value.ToString());
}
/// <summary>
/// Gets the property.
/// </summary>
/// <param name="propertyAlias">The property alias.</param>
/// <returns></returns>
private ArchetypePropertyModel GetProperty(string propertyAlias)
{
return Properties.FirstOrDefault(p => p.Alias.InvariantEquals(propertyAlias));
}
#endregion
}
}
app/Umbraco/Umbraco.Archetype/Models/ArchetypeModel.cs
+17
View File
@@ -7,27 +7,44 @@ using Newtonsoft.Json.Linq;
namespace Archetype.Models
{
/// <summary>
/// Model that represents an entire Archetype.
/// </summary>
[JsonObject]
public class ArchetypeModel : IEnumerable<ArchetypeFieldsetModel>
{
[JsonProperty("fieldsets")]
public IEnumerable<ArchetypeFieldsetModel> Fieldsets { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="ArchetypeModel"/> class.
/// </summary>
public ArchetypeModel()
{
Fieldsets = new List<ArchetypeFieldsetModel>();
}
/// <summary>
/// Returns an enumerator that iterates through the collection of fieldsets.
/// </summary>
/// <returns>
/// An enumerator that can be used to iterate through the collection.
/// </returns>
public IEnumerator<ArchetypeFieldsetModel> GetEnumerator()
{
return this.Fieldsets.Where(f => f.Disabled == false).GetEnumerator();
}
//possibly obsolete?
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
/// <summary>
/// Serializes for persistence. This should be used for serialization as it cleans up the JSON before saving.
/// </summary>
/// <returns></returns>
public string SerializeForPersistence()
{
var json = JObject.Parse(JsonConvert.SerializeObject(this, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }));
app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValue.cs
+3
View File
@@ -4,6 +4,9 @@ using Newtonsoft.Json;
namespace Archetype.Models
{
/// <summary>
/// Model that represents the configured Archetype options.
/// </summary>
public class ArchetypePreValue
{
[JsonProperty("showAdvancedOptions")]
app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValueFieldset.cs
+3
View File
@@ -3,6 +3,9 @@ using Newtonsoft.Json;
namespace Archetype.Models
{
/// <summary>
/// Model that represents configured Archetype fieldsets.
/// </summary>
public class ArchetypePreValueFieldset
{
[JsonProperty("alias")]
app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValueFieldsetGroup.cs
+3
View File
@@ -2,6 +2,9 @@ using Newtonsoft.Json;
namespace Archetype.Models
{
/// <summary>
/// Model that represents configured groupings of Archetype fieldsets.
/// </summary>
public class ArchetypePreValueFieldsetGroup
{
[JsonProperty("name")]
app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValueProperty.cs
+3
View File
@@ -3,6 +3,9 @@ using Newtonsoft.Json;
namespace Archetype.Models
{
/// <summary>
/// Model that represents a configured property on an Archetype fieldset.
/// </summary>
public class ArchetypePreValueProperty
{
[JsonProperty("alias")]
app/Umbraco/Umbraco.Archetype/Models/ArchetypePropertyModel.cs
+18
View File
@@ -9,6 +9,9 @@ using Umbraco.Web;
namespace Archetype.Models
{
/// <summary>
/// Model that represents a stored property in Archetype.
/// </summary>
public class ArchetypePropertyModel
{
[JsonProperty("alias")]
@@ -33,6 +36,11 @@ namespace Archetype.Models
[JsonProperty("hostContentType")]
internal PublishedContentType HostContentType { get; set; }
/// <summary>
/// Gets the value based on the type given.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T GetValue<T>()
{
// Try Umbraco's PropertyValueConverters
@@ -56,6 +64,13 @@ namespace Archetype.Models
return default(T);
}
/// <summary>
/// Tries to convert the value with property value converters.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value">The value.</param>
/// <param name="converters">The converters.</param>
/// <returns></returns>
private Attempt<T> TryConvertWithPropertyValueConverters<T>(object value, IEnumerable<IPropertyValueConverter> converters)
{
var properyType = this.CreateDummyPropertyType();
@@ -92,6 +107,9 @@ namespace Archetype.Models
return Attempt<T>.Fail();
}
/// <summary>
/// Model that represents the current UmbracoEditorState
/// </summary>
internal class UmbracoEditorState
{
// container for the names of any files selected for a property in the Umbraco backend
app/Umbraco/Umbraco.Archetype/PropertyConverters/ArchetypeValueConverter.cs
+21
View File
@@ -8,15 +8,29 @@ using Umbraco.Core.Services;
namespace Archetype.PropertyConverters
{
/// <summary>
/// Default property value converter that models the JSON to a C# object.
/// </summary>
[PropertyValueType(typeof(Models.ArchetypeModel))]
[PropertyValueCache(PropertyCacheValue.All, PropertyCacheLevel.Content)]
public class ArchetypeValueConverter : PropertyValueConverterBase
{
/// <summary>
/// Gets the services.
/// </summary>
/// <value>
/// The services.
/// </value>
public ServiceContext Services
{
get { return ApplicationContext.Current.Services; }
}
/// <summary>
/// Determines whether the specified property type is converter for Archetype.
/// </summary>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public override bool IsConverter(PublishedPropertyType propertyType)
{
var isArcheTypePropertyEditor = !String.IsNullOrEmpty(propertyType.PropertyEditorAlias)
@@ -27,6 +41,13 @@ namespace Archetype.PropertyConverters
return !ArchetypeHelper.Instance.IsPropertyValueConverterOverridden(propertyType.DataTypeId);
}
/// <summary>
/// Converts the data to source.
/// </summary>
/// <param name="propertyType">Type of the property.</param>
/// <param name="source">The source.</param>
/// <param name="preview">if set to <c>true</c> [preview].</param>
/// <returns></returns>
public override object ConvertDataToSource(PublishedPropertyType propertyType, object source, bool preview)
{
var defaultValue = new ArchetypeModel();
app/Umbraco/Umbraco.Archetype/PropertyEditors/ArcheTypePropertyEditor.cs
+53
View File
@@ -15,17 +15,27 @@ using Umbraco.Web.Models.ContentEditing;
namespace Archetype.PropertyEditors
{
/// <summary>
/// C# representation of the property editor. This is often done with package manifest instead.
/// </summary>
[PropertyEditorAsset(ClientDependencyType.Javascript, "../App_Plugins/Archetype/js/archetype.js")]
[PropertyEditor(Constants.PropertyEditorAlias, "Archetype", "../App_Plugins/Archetype/views/archetype.html", ValueType = "JSON")]
public class ArchetypePropertyEditor : PropertyEditor
{
#region Pre Value Editor
/// <summary>
/// Creates a pre value editor instance
/// </summary>
/// <returns></returns>
protected override PreValueEditor CreatePreValueEditor()
{
return new ArchetypePreValueEditor();
}
/// <summary>
/// Class that represents the prevalue editor. This is often done with a package manifest instead.
/// </summary>
internal class ArchetypePreValueEditor : PreValueEditor
{
[PreValueField("archetypeConfig", "Config", "../App_Plugins/Archetype/views/archetype.config.html",
@@ -41,11 +51,18 @@ namespace Archetype.PropertyEditors
#region Value Editor
/// <summary>
/// Creates a value editor instance
/// </summary>
/// <returns></returns>
protected override PropertyValueEditor CreateValueEditor()
{
return new ArchetypePropertyValueEditor(base.CreateValueEditor());
}
/// <summary>
/// Class that represents the actual data editor. This is often done with a package manifest instead.
/// </summary>
internal class ArchetypePropertyValueEditor : PropertyValueEditorWrapper
{
protected JsonSerializerSettings _jsonSettings;
@@ -55,6 +72,13 @@ namespace Archetype.PropertyEditors
{
}
/// <summary>
/// Converts the property value for use in the front-end cache
/// </summary>
/// <param name="property"></param>
/// <param name="propertyType"></param>
/// <param name="dataTypeService"></param>
/// <returns></returns>
public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
{
if(property.Value == null || property.Value.ToString() == "")
@@ -85,6 +109,17 @@ namespace Archetype.PropertyEditors
return archetype.SerializeForPersistence();
}
/// <summary>
/// A method used to format the database value to a value that can be used by the editor
/// </summary>
/// <param name="property"></param>
/// <param name="propertyType"></param>
/// <param name="dataTypeService"></param>
/// <returns></returns>
/// <remarks>
/// The object returned will automatically be serialized into json notation. For most property editors
/// the value returned is probably just a string but in some cases a json structure will be returned.
/// </remarks>
public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
{
if(property.Value == null || property.Value.ToString() == "")
@@ -114,6 +149,19 @@ namespace Archetype.PropertyEditors
return archetype;
}
/// <summary>
/// A method to deserialize the string value that has been saved in the content editor
/// to an object to be stored in the database.
/// </summary>
/// <param name="editorValue"></param>
/// <param name="currentValue">The current value that has been persisted to the database for this editor. This value may be usesful for
/// how the value then get's deserialized again to be re-persisted. In most cases it will probably not be used.</param>
/// <returns></returns>
/// <remarks>
/// By default this will attempt to automatically convert the string value to the value type supplied by ValueType.
/// If overridden then the object returned must match the type supplied in the ValueType, otherwise persisting the
/// value to the DB will fail when it tries to validate the value type.
/// </remarks>
public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
{
if(editorValue.Value == null || editorValue.Value.ToString() == "")
@@ -175,6 +223,11 @@ namespace Archetype.PropertyEditors
return archetype.SerializeForPersistence();
}
/// <summary>
/// Gets the property editor.
/// </summary>
/// <param name="dtd">The DTD.</param>
/// <returns></returns>
internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd)
{
if(dtd.Id != 0)