Bump version number

Handle 7.2.6 issue
More formatting
2015-07-08 13:26:06 -04:00 · 2015-07-01 09:25:18 -04:00 · 2015-06-26 14:17:52 +02:00 · 2015-06-26 14:09:12 +02:00 · 2015-06-26 14:08:00 +02:00 · 2015-06-26 11:30:51 +02:00
18 changed files with 396 additions and 184 deletions
@@ -62,7 +62,7 @@ namespace Archetype.Courier.DataResolvers
 					{
 						foreach (var property in config.Fieldsets.SelectMany(x => x.Properties))
 						{
-							item.Dependencies.Add(property.DataTypeGuid.ToString(), ProviderIDCollection.dataTypeItemProviderGuid);
+							item.Dependencies.Add(property.DataTypeGuid.ToString(), ItemProviderIds.dataTypeItemProviderGuid);
 						}

 						item.Prevalues[0].Value = JsonConvert.SerializeObject(config, Formatting.None);
@@ -76,7 +76,7 @@ namespace Archetype.Courier.DataResolvers
 			if (propertyData != null && propertyData.Value != null)
 			{
 				var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(new ItemIdentifier(propertyData.DataType.ToString(),
-					ProviderIDCollection.dataTypeItemProviderGuid));
+					ItemProviderIds.dataTypeItemProviderGuid));

 				//Fetch the Prevalues for the current Property's DataType (if its an 'Archetype config')
 				var prevalue = dataType.Prevalues.FirstOrDefault(x => x.Alias.ToLowerInvariant().Equals("archetypeconfig"));
@@ -94,7 +94,7 @@ namespace Archetype.Courier.DataResolvers
 				if (archetype != null)
 				{
 					// get the `PropertyItemProvider` from the collection.
-					var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ProviderIDCollection.propertyDataItemProviderGuid, ExecutionContext);
+					var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ItemProviderIds.propertyDataItemProviderGuid, ExecutionContext);

 					foreach (var property in archetype.Fieldsets.SelectMany(x => x.Properties))
 					{
@@ -111,7 +111,7 @@ namespace Archetype.Courier.DataResolvers
 								new ContentProperty
 								{
 									Alias = property.Alias,
-									DataType = ExecutionContext.DatabasePersistence.GetUniqueId(property.DataTypeId, NodeObjectTypes.DataType),
+									DataType = ExecutionContext.DatabasePersistence.GetUniqueId(property.DataTypeId, UmbracoNodeObjectTypeIds.DataType),
 									PropertyEditorAlias = property.PropertyEditorAlias,
 									Value = property.Value
 								}
@@ -157,7 +157,7 @@ namespace Archetype.Courier.DataResolvers

 								// (if packaging) add a dependency for the property's data-type
 								if (direction == Direction.Packaging)
-									item.Dependencies.Add(firstDataType.DataType.ToString(), ProviderIDCollection.dataTypeItemProviderGuid);
+									item.Dependencies.Add(firstDataType.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid);
 							}
 						}
 					}
@@ -179,7 +179,7 @@ namespace Archetype.Courier.DataResolvers
 				{
 					var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(
 						new ItemIdentifier(property.DataTypeGuid.ToString(),
-							ProviderIDCollection.dataTypeItemProviderGuid));
+							ItemProviderIds.dataTypeItemProviderGuid));

 					if (dataType == null)
 						continue;
@@ -203,7 +203,7 @@ namespace Archetype.Courier.DataResolvers
 						{
 							propertyInst.DataTypeGuid = property.DataTypeGuid.ToString();
 							propertyInst.DataTypeId = ExecutionContext.DatabasePersistence.GetNodeId(
-								property.DataTypeGuid, NodeObjectTypes.DataType);
+								property.DataTypeGuid, UmbracoNodeObjectTypeIds.DataType);
 							propertyInst.PropertyEditorAlias = property.PropertyEditorAlias;
 						}
 					}
@@ -8,6 +8,9 @@ using Umbraco.Core.Models;
 using Umbraco.Web.Models.ContentEditing;
 using Umbraco.Web.Mvc;
 using Umbraco.Web.Editors;
+using Umbraco.Core.PropertyEditors;
+using Archetype.Extensions;
+using Newtonsoft.Json;

 namespace Archetype.Api
 {
@@ -19,7 +22,7 @@ namespace Archetype.Api
        {
            return
                global::Umbraco.Core.PropertyEditors.PropertyEditorResolver.Current.PropertyEditors
-                    .Select(x => new {defaultPreValues = x.DefaultPreValues, alias = x.Alias, view = x.ValueEditor.View});
+                    .Select(x => new {defaultPreValues = x.DefaultPreValuesForArchetype(), alias = x.Alias, view = x.ValueEditor.View});
        }

        public object GetAll() 
@@ -35,6 +38,7 @@ namespace Archetype.Api
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }
+
            var dataTypeDisplay = Mapper.Map<IDataTypeDefinition, DataTypeDisplay>(dataType);
            return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues };
        }
@@ -234,6 +234,7 @@
    <Compile Include="Extensions\ArchetypeHelper.cs" />
    <Compile Include="Extensions\HtmlHelperExtensions.cs" />
    <Compile Include="Extensions\ArchetypePropertyModelExtensions.cs" />
+    <Compile Include="Extensions\PropertyEditorExtensions.cs" />
    <Compile Include="Extensions\StringExtensions.cs" />
    <Compile Include="Models\ArchetypeModel.cs" />
    <Compile Include="Models\ArchetypePreValue.cs" />
@@ -3,6 +3,7 @@ using System.Linq;
 using Archetype.Models;
 using Newtonsoft.Json;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;

@@ -42,6 +43,7 @@ namespace Archetype.Extensions
                }
                catch (Exception ex)
                {
+                    LogHelper.Error<ArchetypeHelper>("DeserializeJsonToArchetype", ex);
                }

                return archetype;
@@ -66,6 +68,7 @@ namespace Archetype.Extensions
                }
                catch (Exception ex)
                {
+                    LogHelper.Error<ArchetypeHelper>("DeserializeJsonToArchetype", ex);
                }

                return archetype;
@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using Umbraco.Core.PropertyEditors;
+
+namespace Archetype.Extensions
+{
+	public static class PropertyEditorExtensions
+    {
+		/// <summary>
+		/// Formats the default prevalues for a property editor for use within an Archetype clientside context
+		/// </summary>
+		/// <param name="propertyEditor">The property editor</param>
+		/// <returns>The formatted default prevalues</returns>
+		public static IDictionary<string, object> DefaultPreValuesForArchetype(this PropertyEditor propertyEditor)
+        {
+			if (propertyEditor.DefaultPreValues == null || propertyEditor.DefaultPreValues.Any() == false)
+			{
+				return propertyEditor.DefaultPreValues;
+			}
+			var view = propertyEditor.ValueEditor.View.ToLowerInvariant();
+
+			// This is the extension point for default prevalues formatting, in case we need to handle any other
+			// property editors later on. It should be replaced with a switch statement by then, or maybe some fancy 
+			// auto discovery of formatters :)
+			if (view == "imagecropper")
+			{
+				propertyEditor.FormatImageCropperDefaultPreValuesForArchetype();
+			}
+			return propertyEditor.DefaultPreValues;
+        }
+
+		/// <summary>
+		/// Format the default prevalues of the image cropper property editor
+		/// </summary>
+		/// <param name="propertyEditor"></param>
+		/// <remarks>
+		/// In order for the image cropper to work clientside, we need to make sure it's default prevalue "focalpoint" is returned
+		/// as a JSON object and not as the string it's defined as on the image cropper property editor.
+		/// </remarks>
+		private static void FormatImageCropperDefaultPreValuesForArchetype(this PropertyEditor propertyEditor)
+		{
+			const string focalPointKey = "focalPoint";
+
+			if (propertyEditor.DefaultPreValues.ContainsKey(focalPointKey) == false || propertyEditor.DefaultPreValues[focalPointKey] == null)
+			{
+				return;
+			}
+			var focalPoint = propertyEditor.DefaultPreValues[focalPointKey].ToString();
+			if (string.IsNullOrEmpty(focalPoint))
+			{
+				return;
+			}
+			// translate the JSON string to a JSON object
+			propertyEditor.DefaultPreValues[focalPointKey] = JsonConvert.DeserializeObject(focalPoint);
+		}
+    }
+}
@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json;
 using Umbraco.Core;
+using System;

 namespace Archetype.Models
 {
@@ -16,6 +17,9 @@ namespace Archetype.Models
        [JsonProperty("properties")]
        public IEnumerable<ArchetypePropertyModel> Properties;

+        [JsonProperty("id")]
+        public Guid Id { get; set; }
+
        public ArchetypeFieldsetModel()
        {
            Properties = new List<ArchetypePropertyModel>();
@@ -84,4 +88,4 @@ namespace Archetype.Models
        #endregion

    }
-}
+}
@@ -1,7 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;

@@ -30,15 +30,22 @@ namespace Archetype.Models

        public string SerializeForPersistence()
        {
+            // clear the editor state before serializing (it's temporary state data)
+            foreach(var property in Fieldsets.SelectMany(f => f.Properties.Where(p => p.EditorState != null)).ToList())
+            {
+                property.EditorState = null;
+            }
+
            var json = JObject.Parse(JsonConvert.SerializeObject(this, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }));
+
            var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid", "hostContentType" };

            json.Descendants().OfType<JProperty>()
              .Where(p => propertiesToRemove.Contains(p.Name))
              .ToList()
-              .ForEach(x => x.Remove());
-
-            return json.ToString(Formatting.None);
+              .ForEach(x => x.Remove());
+
+            return json.ToString(Formatting.None);
        }
    }
 }
@@ -26,6 +26,10 @@ namespace Archetype.Models
        [JsonProperty("dataTypeGuid")]
        internal string DataTypeGuid { get; set; }

+        // container for temporary editor state from the Umbraco backend
+        [JsonProperty("editorState")]
+        internal UmbracoEditorState EditorState { get; set; }
+
        [JsonProperty("hostContentType")]
        internal PublishedContentType HostContentType { get; set; }

@@ -88,5 +92,12 @@ namespace Archetype.Models

            return Attempt<T>.Fail();
        }
+
+        internal class UmbracoEditorState
+        {
+            // container for the names of any files selected for a property in the Umbraco backend
+            [JsonProperty("fileNames")]
+            public IEnumerable<string> FileNames;
+        }
    }
 }
@@ -1,4 +1,4 @@
 using System.Reflection;

-[assembly: AssemblyVersion("1.8")]
-[assembly: AssemblyFileVersion("1.8")]
+[assembly: AssemblyVersion("1.9")]
+[assembly: AssemblyFileVersion("1.9")]
@@ -1,155 +1,192 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Archetype.Extensions;
-using ClientDependency.Core;
-using Newtonsoft.Json;
-using Umbraco.Core;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Editors;
-using Umbraco.Core.PropertyEditors;
-using Umbraco.Core.Services;
-using Umbraco.Web.PropertyEditors;
-
-namespace Archetype.PropertyEditors
-{
-	[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
-
-		protected override PreValueEditor CreatePreValueEditor()
-		{
-			return new ArchetypePreValueEditor();
-		}
-
-		internal class ArchetypePreValueEditor : PreValueEditor
-		{
-			[PreValueField("archetypeConfig", "Config", "/App_Plugins/Archetype/views/archetype.config.html",
-				Description = "(Required) Describe your Archetype.")]
-			public string Config { get; set; }
-
-			[PreValueField("hideLabel", "Hide Label", "boolean",
-				Description = "Hide the Umbraco property title and description, making the Archetype span the entire page width")]
-			public bool HideLabel { get; set; }
-		}
-
-		#endregion
-
-		#region Value Editor
-
-		protected override PropertyValueEditor CreateValueEditor()
-		{
-			return new ArchetypePropertyValueEditor(base.CreateValueEditor());
-		}
-
-		internal class ArchetypePropertyValueEditor : PropertyValueEditorWrapper
-		{
-			protected JsonSerializerSettings _jsonSettings;
-
-			public ArchetypePropertyValueEditor(PropertyValueEditor wrapped)
-				: base(wrapped) { }
-
-			public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
-			{
-				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;
-
-				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
-
-				foreach (var fieldset in archetype.Fieldsets)
-				{
-                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
-					{
-                        try
-                        {
-                            if(propDef == null || propDef.DataTypeGuid == null) continue;
-                            var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
-						    var propType = new PropertyType(dtd) { Alias = propDef.Alias };
-						    var prop = new Property(propType, propDef.Value);
-						    var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-						    propDef.Value = propEditor.ValueEditor.ConvertDbToString(prop, propType, dataTypeService);
-                        }
-                        catch (Exception ex)
-                        {
-                            LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
-                        }
-					}
-				}
-
-                return archetype.SerializeForPersistence();
-			}
-
-			public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
-			{
-				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;;
-
-				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
-
-				foreach (var fieldset in archetype.Fieldsets)
-				{
-                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
-					{
-                        try
-                        {
-                            var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
-                            var propType = new PropertyType(dtd) { Alias = propDef.Alias };
-                            var prop = new Property(propType, propDef.Value);
-                            var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-                            propDef.Value = propEditor.ValueEditor.ConvertDbToEditor(prop, propType, dataTypeService);
-                        }
-                        catch (Exception ex)
-                        {
-                            LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
-                        }
-					}
-				}
-
-				return archetype;
-			}
-            public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
-			{
-				if (editorValue.Value == null || editorValue.Value.ToString() == "")
-					return string.Empty;
-
-				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
-
-				foreach (var fieldset in archetype.Fieldsets)
-				{    
-                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
-					{
-                        try
-                        {
-                            var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
-						    var preValues = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(dtd.Id);
-						    var propData = new ContentPropertyData(propDef.Value, preValues, new Dictionary<string, object>());
-                            var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-						    propDef.Value = propEditor.ValueEditor.ConvertEditorToDb(propData, propDef.Value);
-                        }
-                        catch (Exception ex)
-                        {
-                            LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
-                        }
-					}
-				}
-
-                return archetype.SerializeForPersistence();
-			}
-
-		    internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd)
-		    {
-		        if (dtd.Id != 0) 
-                    return PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-
-		        return dtd.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias)
-		            ? new ArchetypePropertyEditor()
-                    : (PropertyEditor)new TextboxPropertyEditor();
-		    }
-		}
-
-		#endregion	
-	}
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Archetype.Extensions;
+using ClientDependency.Core;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
+using Umbraco.Core.PropertyEditors;
+using Umbraco.Core.Services;
+using Umbraco.Web.PropertyEditors;
+using Umbraco.Web.Models.ContentEditing;
+
+namespace Archetype.PropertyEditors
+{
+	[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
+
+		protected override PreValueEditor CreatePreValueEditor()
+		{
+			return new ArchetypePreValueEditor();
+		}
+
+		internal class ArchetypePreValueEditor : PreValueEditor
+		{
+			[PreValueField("archetypeConfig", "Config", "/App_Plugins/Archetype/views/archetype.config.html",
+				Description = "(Required) Describe your Archetype.")]
+			public string Config { get; set; }
+
+			[PreValueField("hideLabel", "Hide Label", "boolean",
+				Description = "Hide the Umbraco property title and description, making the Archetype span the entire page width")]
+			public bool HideLabel { get; set; }
+		}
+
+		#endregion
+
+		#region Value Editor
+
+		protected override PropertyValueEditor CreateValueEditor()
+		{
+			return new ArchetypePropertyValueEditor(base.CreateValueEditor());
+		}
+
+		internal class ArchetypePropertyValueEditor : PropertyValueEditorWrapper
+		{
+			protected JsonSerializerSettings _jsonSettings;
+
+			public ArchetypePropertyValueEditor(PropertyValueEditor wrapped)
+				: base(wrapped)
+			{
+			}
+
+			public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
+			{
+				if(property.Value == null || property.Value.ToString() == "")
+					return string.Empty;
+
+				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
+
+				foreach (var fieldset in archetype.Fieldsets)
+				{
+					foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
+					{
+						try
+						{
+							if(propDef == null || propDef.DataTypeGuid == null) continue;
+							var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
+							var propType = new PropertyType(dtd) {Alias = propDef.Alias};
+							var prop = new Property(propType, propDef.Value);
+							var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+							propDef.Value = propEditor.ValueEditor.ConvertDbToString(prop, propType, dataTypeService);
+						}
+						catch (Exception ex)
+						{
+							LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
+						}
+					}
+				}
+
+				return archetype.SerializeForPersistence();
+			}
+
+			public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
+			{
+				if(property.Value == null || property.Value.ToString() == "")
+					return string.Empty;
+
+				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
+
+				foreach (var fieldset in archetype.Fieldsets)
+				{
+					foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
+					{
+						try
+						{
+							var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
+							var propType = new PropertyType(dtd) {Alias = propDef.Alias};
+							var prop = new Property(propType, propDef.Value);
+							var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+							propDef.Value = propEditor.ValueEditor.ConvertDbToEditor(prop, propType, dataTypeService);
+						}
+						catch (Exception ex)
+						{
+							LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
+						}
+					}
+				}
+
+				return archetype;
+			}
+
+			public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
+			{
+				if(editorValue.Value == null || editorValue.Value.ToString() == "")
+					return string.Empty;
+
+				// attempt to deserialize the current property value as an Archetype
+				var currentArchetype = currentValue != null ? ArchetypeHelper.Instance.DeserializeJsonToArchetype(currentValue.ToString(), editorValue.PreValues) : null;
+				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
+
+				// get all files uploaded via the file manager (if any)
+				var uploadedFiles = editorValue.AdditionalData.ContainsKey("files") ? editorValue.AdditionalData["files"] as IEnumerable<ContentItemFile> : null;
+				foreach (var fieldset in archetype.Fieldsets)
+				{
+					// assign an id to the fieldset if it has none (e.g. newly created fieldset)
+					fieldset.Id = fieldset.Id == Guid.Empty ? Guid.NewGuid() : fieldset.Id;
+					// find the corresponding fieldset in the current Archetype value (if any)
+					var currentFieldset = currentArchetype != null ? currentArchetype.Fieldsets.FirstOrDefault(f => f.Id == fieldset.Id) : null;
+					foreach (var propDef in fieldset.Properties)
+					{
+						try
+						{
+							// find the corresponding property in the current Archetype value (if any)
+							var currentProperty = currentFieldset != null ? currentFieldset.Properties.FirstOrDefault(p => p.Alias == propDef.Alias) : null;
+							var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
+							var preValues = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(dtd.Id);
+
+							var additionalData = new Dictionary<string, object>();
+
+							// figure out if we need to pass a files collection in the additional data to the property value editor
+							if(uploadedFiles != null)
+							{
+								if(dtd.PropertyEditorAlias == Constants.PropertyEditorAlias)
+								{
+									// it's a nested Archetype - just pass all uploaded files to the value editor
+									additionalData["files"] = uploadedFiles.ToList();
+								}
+								else if (propDef.EditorState != null && propDef.EditorState.FileNames != null && propDef.EditorState.FileNames.Any())
+								{
+									// pass the uploaded files that belongs to this property (if any) to the value editor
+									var propertyFiles = propDef.EditorState.FileNames.Select(f => uploadedFiles.FirstOrDefault(u => u.FileName == f)).Where(f => f != null).ToList();
+									if(propertyFiles.Any())
+									{
+										additionalData["files"] = propertyFiles;
+									}
+								}
+							}
+							var propData = new ContentPropertyData(propDef.Value, preValues, additionalData);
+							var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+							// make sure to send the current property value (if any) to the PE ValueEditor
+							propDef.Value = propEditor.ValueEditor.ConvertEditorToDb(propData, currentProperty != null ? currentProperty.Value : null);
+						}
+						catch (Exception ex)
+						{
+							LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
+						}
+					}
+				}
+
+				return archetype.SerializeForPersistence();
+			}
+
+			internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd)
+			{
+				if(dtd.Id != 0)
+					return PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+
+				return dtd.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias)
+					? new ArchetypePropertyEditor()
+					: (PropertyEditor) new TextboxPropertyEditor();
+			}
+		}
+
+		#endregion	
+	}
+}
@@ -1,4 +1,4 @@
-angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, entityResource, archetypeService, archetypeLabelService, archetypeCacheService, archetypePropertyEditorResource) {
+angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, fileManager, entityResource, archetypeService, archetypeLabelService, archetypeCacheService, archetypePropertyEditorResource) {

    //$scope.model.value = "";
    $scope.model.hideLabel = $scope.model.config.hideLabel == 1;
@@ -252,11 +252,36 @@ angular.module("umbraco").controller("Imulus.ArchetypeController", function ($sc
    //developerMode helpers
    $scope.model.value.toString = stringify;

+    // issue 114: register handler for file selection
+    $scope.model.value.setFiles = setFiles;
+
    //encapsulate stringify (should be built into browsers, not sure of IE support)
    function stringify() {
        return JSON.stringify(this);
    }

+    // issue 114: handler for file selection
+    function setFiles(files) {
+        // get all currently selected files from file manager
+        var currentFiles = fileManager.getFiles();
+        
+        // get the files already selected for this archetype (by alias)
+        var archetypeFiles = [];
+        _.each(currentFiles, function (item) {
+            if (item.alias === $scope.model.alias) {
+                archetypeFiles.push(item.file);
+            }
+        });
+
+        // add the newly selected files
+        _.each(files, function (file) {
+            archetypeFiles.push(file);
+        });
+
+        // update the selected files for this archetype (by alias)
+        fileManager.setFiles($scope.model.alias, archetypeFiles);
+    }
+
    //watch for changes
    $scope.$watch('model.value', function (v) {
        if ($scope.model.config.developerMode) {
@@ -266,6 +291,11 @@ angular.module("umbraco").controller("Imulus.ArchetypeController", function ($sc
                $scope.model.value.toString = stringify;
            }
        }
+
+        // issue 114: re-register handler for files selection and reset the currently selected files on the file manager
+        $scope.model.value.setFiles = setFiles;
+        fileManager.setFiles($scope.model.alias, []);
+
        // reset submit watcher counter on save
        $scope.activeSubmitWatcher = 0;
    });
@@ -1,4 +1,4 @@
-angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q, editorState, archetypeService, archetypeCacheService) {
+angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q, fileManager, editorState, archetypeService, archetypeCacheService) {

    var linker = function (scope, element, attrs, ngModelCtrl) {
        var configFieldsetModel = archetypeService.getFieldsetByAlias(scope.archetypeConfig.fieldsets, scope.fieldset.alias);
@@ -123,6 +123,9 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                    scope.renderModel = {};
                    scope.model.value = archetypeService.getFieldsetProperty(scope).value;

+                    //init the property editor state
+                    archetypeService.getFieldsetProperty(scope).editorState = {};
+
                    //set the config from the prevalues
                    scope.model.config = config;

@@ -141,8 +144,17 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                        }
                    }

+                    //upload datatype hack
+                    if(view.indexOf('fileupload.html') != -1) {
+                        scope.propertyForm = scope.form;
+                        scope.model.validation = {};
+                        scope.model.validation.mandatory = 0;
+                    }
+
                    //some items need an alias
                    scope.model.alias = "archetype-property-" + propertyAlias;
+                    //some items also need an id (file upload for example)
+                    scope.model.id = propertyAlias;

                    //watch for changes since there is no two-way binding with the local model.value
                    scope.$watch('model.value', function (newValue, oldValue) {
@@ -166,6 +178,23 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                        }
                    });

+                    // issue 114: handle file selection on property editors
+                    scope.$on("filesSelected", function (event, args) {
+                        // populate the fileNames collection on the property editor state
+                        var property = archetypeService.getFieldsetProperty(scope);
+                        property.editorState.fileNames = [];
+                        _.each(args.files, function (item) {
+                            property.editorState.fileNames.push(item.name);
+                        });
+
+                        // remove the files set for this property
+                        // NOTE: we can't use property.alias because the file manager registers the selected files on the assigned Archetype property alias (e.g. "archetype-property-archetype-property-archetype-property-content-0-2-0-1-0-0")
+                        fileManager.setFiles(scope.model.alias, []);
+
+                        // now tell the containing Archetype to pick up the selected files
+                        scope.archetypeRenderModel.setFiles(args.files);
+                    });
+
                    element.html(data).show();
                    $compile(element.contents())(scope);

@@ -3,6 +3,7 @@ angular.module('umbraco.services').factory('archetypeCacheService', function (ar

    var isEntityLookupLoading = false;
    var entityCache = [];
+
    var isDatatypeLookupLoading = false;
    var datatypeCache = [];

@@ -1,11 +1,6 @@
 angular.module('umbraco.services').factory('archetypeLabelService', function (archetypeCacheService) {
    //private

-    var isEntityLookupLoading = false;
-    var entityCache = [];
-    var isDatatypeLookupLoading = false;
-    var datatypeCache = [];
-
    function executeFunctionByName(functionName, context) {
        var args = Array.prototype.slice.call(arguments).splice(2);

@@ -24,6 +19,7 @@ angular.module('umbraco.services').factory('archetypeLabelService', function (ar
    }

    function getNativeLabel(datatype, value, scope) {
+
    	switch (datatype.selectedEditor) {
    		case "Imulus.UrlPicker":
    			return imulusUrlPicker(value, scope, {});
@@ -33,11 +29,27 @@ angular.module('umbraco.services').factory('archetypeLabelService', function (ar
                return coreMntp(value, scope, datatype);
            case "Umbraco.MediaPicker":
                return coreMediaPicker(value, scope, datatype);
+            case "Umbraco.DropDown":
+                return coreDropdown(value, scope, datatype);
    		default:
    			return "";
    	}
    }

+    function coreDropdown(value, scope, args) {
+
+        if(!value)
+            return "";
+
+        var prevalue = args.preValues[0].value[value];
+
+        if(prevalue) {
+            return prevalue.value;
+        }
+
+        return "";
+    }
+
    function coreMntp(value, scope, args) {
        var ids = value.split(',');
        var type = "Document";
@@ -152,14 +164,24 @@ angular.module('umbraco.services').factory('archetypeLabelService', function (ar
            if (template.length < 1)
                return fieldsetConfig.label;

-            var rgx = /{{([^)].*)}}/g;
+            var rgx = /({{(.*?)}})*/g;
            var results;
            var parsedTemplate = template;

-            while ((results = rgx.exec(template)) !== null) {
+            var rawMatches = template.match(rgx);
+            
+            var matches = [];
+
+            _.each(rawMatches, function(match){
+                if(match) {
+                    matches.push(match);
+                }
+            });
+
+            _.each(matches, function (match) {

                // split the template in case it consists of multiple property aliases and/or functions
-                var templates = results[0].replace("{{", '').replace("}}", '').split("|");
+                var templates = match.replace("{{", '').replace("}}", '').split("|");
                var templateLabelValue = "";

                for(var i = 0; i < templates.length; i++) {
@@ -209,7 +231,7 @@ angular.module('umbraco.services').factory('archetypeLabelService', function (ar

                        if(propertyConfig) {
                        	var datatype = archetypeCacheService.getDatatypeByGuid(propertyConfig.dataTypeGuid);
-                        	
+
                        	if(datatype) {

                            	//try to get built-in label
@@ -229,8 +251,13 @@ angular.module('umbraco.services').factory('archetypeLabelService', function (ar

                    }                
                }
-                parsedTemplate = parsedTemplate.replace(results[0], templateLabelValue);
-            }
+
+                if(!templateLabelValue) {
+                    templateLabelValue = "";
+                }
+                
+                parsedTemplate = parsedTemplate.replace(match, templateLabelValue);
+            });

            return parsedTemplate;
        }
@@ -1,6 +1,6 @@
 {
 	"name": "Archetype",
-	"version": "1.8",
+	"version": "1.9",
 	"url": "http://github.com/imulus/archetype/",
 	"author": "Imulus - Kevin Giszewski - Tom Fulton - Lee Kelleher - Matt Brailsford - Kenn Jacobsen - Et. Al.",
 	"authorUrl": "http://imulus.com/",
Author	SHA1	Message	Date
kgiszewski	cfe014ee45	Bump version number	2015-07-08 13:26:06 -04:00
kgiszewski	d62fa05ab5	Handle 7.2.6 issue	2015-07-01 09:25:18 -04:00
kjac	662cf4c3bf	More formatting	2015-06-26 14:17:52 +02:00
kjac	d0b8314134	Formatting issue	2015-06-26 14:09:12 +02:00
kjac	8eb4786976	Revert API method GetByGuid() to its previous state All default prevalue enrichment is now handled by the API method GetAllPropertyEditors()	2015-06-26 14:08:00 +02:00
kjac	20155b5ca6	Move filenames collection to temporary editor state container	2015-06-26 11:30:51 +02:00
kjac	16c310f3c6	Ensure correct default prevalues for imagecropper	2015-06-26 11:27:54 +02:00
kjac	99d570dc97	Handle upload and image cropper clientside	2015-06-25 07:59:16 +02:00
kjac	2ae3e3ade9	Merge with imulus/master	2015-06-23 17:21:26 +02:00
Kevin Giszewski	d4718e358c	Merge pull request #279 from leekelleher/enhancement/helper-log-exception ArchetypeHelper - added exception to Umbraco log	2015-06-18 08:05:10 -04:00
Kevin Giszewski	bb91eb7036	Merge pull request #280 from leekelleher/upgrade/courier-assemblies Upgraded Courier assemblies.	2015-06-18 08:03:58 -04:00
leekelleher	484f2c22a3	Added exception to Umbraco log, as VS was complaining about an unused `ex`.	2015-06-18 12:20:02 +01:00
leekelleher	a2121cd8a7	Upgraded Courier assemblies. Amended references to Courier constants (seems that there was some restructuring within Courier)	2015-06-18 12:17:44 +01:00
kgiszewski	2fb922fd6c	Rework dropdown label to check for a value first	2015-06-15 15:56:45 -04:00
kgiszewski	c2986d39a9	Added coreDropdown to label helpers	2015-06-15 15:46:51 -04:00
kgiszewski	8ee5488261	Merge branch 'master' of github.com:imulus/Archetype	2015-06-15 14:49:19 -04:00
kgiszewski	c60c9e1c5d	Fix #276	2015-06-15 14:48:50 -04:00
kjac	1cbb7b3173	Merge with master	2014-06-16 16:57:51 +02:00
kjac	71be453ada	Move property files collection clean-up Moved the cleaning up of files selected for each property to the SerializeForPersistence() method	2014-06-01 07:48:47 +02:00
kjac	efae05b3ae	Merge branch 'master' into upload-imagecrop-datatypes	2014-05-29 11:17:11 +02:00
kjac	84acd43ccf	Enrich datatypes with default prevalues Datatypes can have default prevalues, that are not saved as part of the config and thus need to be added when loading the datatype - e.g. the "focalPoint" prevalue for the image cropper datatype.	2014-05-29 11:14:45 +02:00
kjac	9fe756bacb	Merge branch 'master' into upload-imagecrop-datatypes	2014-05-21 23:01:44 +02:00
kjac	cd03b5a4f9	Test and fine tune 3rd level nested archetypes	2014-05-20 22:19:21 +02:00
kjac	07a62d7edf	More file upload handling WIP	2014-05-20 21:28:29 +02:00
kjac	a6c166d926	WIP handle file selection Use FileManager to register the files selected for properties contained within an Archetype	2014-05-18 18:19:20 +02:00
kjac	c1bc555443	Merge branch 'master' into current-value-to-value-editor	2014-05-16 13:44:46 +02:00
kjac	d4166f33e8	Correct currentValue for ValueEditor conversion Ensure that the currentValue parameter sent to the fieldset property ValueEditor ConvertEditorToDb() method contains the value that was previously entered (if any) and not the one that was just entered.	2014-05-14 11:32:54 +02:00