Use relative paths for API endpoints

Since the backoffice has `<base href="/yourvdir/umbraco">`, we can just use relative links here to support virtual directories

If this does not work, alternatively we can look at `Umbraco.Sys.ServerVariables.umbracoSettings.umbracoPath`

app/Umbraco/Umbraco.Archetype/Api/ArchetypeDataTypeController.cs

@@ -8,9 +8,6 @@ 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
 {
@@ -22,7 +19,7 @@ namespace Archetype.Api
         {
             return
                 global::Umbraco.Core.PropertyEditors.PropertyEditorResolver.Current.PropertyEditors
-                    .Select(x => new {defaultPreValues = x.DefaultPreValuesForArchetype(), alias = x.Alias, view = x.ValueEditor.View});
+                    .Select(x => new {defaultPreValues = x.DefaultPreValues, alias = x.Alias, view = x.ValueEditor.View});
         }
 
         public object GetAll() 
@@ -38,7 +35,6 @@ namespace Archetype.Api
             {
                 throw new HttpResponseException(HttpStatusCode.NotFound);
             }
-
             var dataTypeDisplay = Mapper.Map<IDataTypeDefinition, DataTypeDisplay>(dataType);
             return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues };
         }

app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj

@@ -234,7 +234,6 @@
     <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" />

app/Umbraco/Umbraco.Archetype/Extensions/PropertyEditorExtensions.cs

@@ -1,58 +0,0 @@
-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);
-		}
-    }
-}

app/Umbraco/Umbraco.Archetype/Models/ArchetypeFieldsetModel.cs

@@ -2,7 +2,6 @@ using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json;
 using Umbraco.Core;
-using System;
 
 namespace Archetype.Models
 {
@@ -17,9 +16,6 @@ namespace Archetype.Models
         [JsonProperty("properties")]
         public IEnumerable<ArchetypePropertyModel> Properties;
 
-        [JsonProperty("id")]
-        public Guid Id { get; set; }
-
         public ArchetypeFieldsetModel()
         {
             Properties = new List<ArchetypePropertyModel>();
@@ -88,4 +84,4 @@ namespace Archetype.Models
         #endregion
 
     }
-}
+}

app/Umbraco/Umbraco.Archetype/Models/ArchetypeModel.cs

@@ -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,22 +30,15 @@ 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);
         }
     }
 }

app/Umbraco/Umbraco.Archetype/Models/ArchetypePropertyModel.cs

@@ -26,10 +26,6 @@ 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; }
 
@@ -92,12 +88,5 @@ 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;
-        }
     }
 }

app/Umbraco/Umbraco.Archetype/Properties/VersionInfo.cs

@@ -1,4 +1,4 @@
 using System.Reflection;
 
-[assembly: AssemblyVersion("1.9")]
-[assembly: AssemblyFileVersion("1.9")]
+[assembly: AssemblyVersion("1.8.1")]
+[assembly: AssemblyFileVersion("1.8.1")]

app/Umbraco/Umbraco.Archetype/PropertyEditors/ArcheTypePropertyEditor.cs

@@ -1,192 +1,155 @@
-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	
-	}
-}
+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	
+	}
+}

app/controllers/controller.js

@@ -1,4 +1,4 @@
-angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, fileManager, entityResource, archetypeService, archetypeLabelService, archetypeCacheService, archetypePropertyEditorResource) {
+angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, entityResource, archetypeService, archetypeLabelService, archetypeCacheService, archetypePropertyEditorResource) {
 
     //$scope.model.value = "";
     $scope.model.hideLabel = $scope.model.config.hideLabel == 1;
@@ -252,36 +252,11 @@ 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) {
@@ -291,11 +266,6 @@ 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;
     });

app/directives/archetypeproperty.js

@@ -1,4 +1,4 @@
-angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q, fileManager, editorState, archetypeService, archetypeCacheService) {
+angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q, editorState, archetypeService, archetypeCacheService) {
 
     var linker = function (scope, element, attrs, ngModelCtrl) {
         var configFieldsetModel = archetypeService.getFieldsetByAlias(scope.archetypeConfig.fieldsets, scope.fieldset.alias);
@@ -123,9 +123,6 @@ 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;
 
@@ -144,17 +141,8 @@ 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) {
@@ -178,23 +166,6 @@ 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);
 

app/resources/archetypePropertyEditorResource.js

@@ -3,24 +3,24 @@ angular.module('umbraco.resources').factory('archetypePropertyEditorResource', f
         getAllDataTypes: function() {
             // Hack - grab DataTypes from Tree API, as `dataTypeService.getAll()` isn't implemented yet
             return umbRequestHelper.resourcePromise(
-                $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetAll"), 'Failed to retrieve datatypes from tree service'
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetAll"), 'Failed to retrieve datatypes from tree service'
             );
         },
         getDataType: function (guid, useDeepDatatypeLookup, contentTypeAlias, propertyTypeAlias, archetypeAlias, nodeId) {
             if(useDeepDatatypeLookup) {
             	return umbRequestHelper.resourcePromise(
-            		$http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid + "&contentTypeAlias=" + contentTypeAlias + "&propertyTypeAlias=" + propertyTypeAlias + "&archetypeAlias=" + archetypeAlias + "&nodeId=" + nodeId), 'Failed to retrieve datatype'
+            		$http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid + "&contentTypeAlias=" + contentTypeAlias + "&propertyTypeAlias=" + propertyTypeAlias + "&archetypeAlias=" + archetypeAlias + "&nodeId=" + nodeId), 'Failed to retrieve datatype'
         		);
             }
             else {
                 return umbRequestHelper.resourcePromise(
-                    $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid , { cache: true }), 'Failed to retrieve datatype'
+                    $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid , { cache: true }), 'Failed to retrieve datatype'
                 );
             }
         },
         getPropertyEditorMapping: function(alias) {
             return umbRequestHelper.resourcePromise(
-                $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetAllPropertyEditors", { cache: true }), 'Failed to retrieve datatype mappings'
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetAllPropertyEditors", { cache: true }), 'Failed to retrieve datatype mappings'
             ).then(function (data) {
                 var result = _.find(data, function(d) {
                     return d.alias === alias;

config/meta.json

@@ -1,6 +1,6 @@
 {
 	"name": "Archetype",
-	"version": "1.9",
+	"version": "1.8",
 	"url": "http://github.com/imulus/archetype/",
 	"author": "Imulus - Kevin Giszewski - Tom Fulton - Lee Kelleher - Matt Brailsford - Kenn Jacobsen - Et. Al.",
 	"authorUrl": "http://imulus.com/",