diff --git a/src/Umbraco.Core/Services/PackagingService.cs b/src/Umbraco.Core/Services/PackagingService.cs
index f98a333ab3..23fd5d5ab1 100644
--- a/src/Umbraco.Core/Services/PackagingService.cs
+++ b/src/Umbraco.Core/Services/PackagingService.cs
@@ -736,6 +736,21 @@ namespace Umbraco.Core.Services
 
         #region DataTypes
 
+        /// <summary>
+        /// Export a list of data types
+        /// </summary>
+        /// <param name="dataTypeDefinitions"></param>
+        /// <returns></returns>
+        internal XElement Export(IEnumerable<IDataTypeDefinition >dataTypeDefinitions)
+        {
+            var container = new XElement("DataTypes");
+            foreach (var d in dataTypeDefinitions)
+            {
+                container.Add(Export(d));
+            }
+            return container;
+        }
+
         internal XElement Export(IDataTypeDefinition dataTypeDefinition)
         {
             var prevalues = new XElement("PreValues");
@@ -848,8 +863,19 @@ namespace Umbraco.Core.Services
                 var dataTypeDefinitionName = dataTypeElement.Attribute("Name").Value;
                 var dataTypeDefinition = dataTypes.First(x => x.Name == dataTypeDefinitionName);
 
-                var values = prevaluesElement.Elements("PreValue").Select(prevalue => prevalue.Attribute("Value").Value).ToList();
-                _dataTypeService.SavePreValues(dataTypeDefinition.Id, values);
+                var valuesWithoutKeys = prevaluesElement.Elements("PreValue")
+                                                        .Where(x => ((string) x.Attribute("Alias")).IsNullOrWhiteSpace())
+                                                        .Select(x => x.Attribute("Value").Value);
+
+                var valuesWithKeys = prevaluesElement.Elements("PreValue")
+                                                     .Where(x => ((string) x.Attribute("Alias")).IsNullOrWhiteSpace() == false)
+                                                     .ToDictionary(key => (string) key.Attribute("Alias"), val => new PreValue((string) val.Attribute("Value")));
+                
+                //save the values with keys
+                _dataTypeService.SavePreValues(dataTypeDefinition.Id, valuesWithKeys);
+
+                //save the values without keys (this is legacy)
+                _dataTypeService.SavePreValues(dataTypeDefinition.Id, valuesWithoutKeys);
             }
         }
 
diff --git a/src/Umbraco.Core/XmlExtensions.cs b/src/Umbraco.Core/XmlExtensions.cs
index d6a93af035..02ebc07490 100644
--- a/src/Umbraco.Core/XmlExtensions.cs
+++ b/src/Umbraco.Core/XmlExtensions.cs
@@ -202,20 +202,20 @@ namespace Umbraco.Core
             }
         }
 
-        /// <summary>
-        /// Converts from an XElement to an XmlElement
-        /// </summary>
-        /// <param name="xElement"></param>
-        /// <returns></returns>
-        public static XmlNode ToXmlElement(this XContainer xElement)
-        {
-            var xmlDocument = new XmlDocument();
-            using (var xmlReader = xElement.CreateReader())
-            {
-                xmlDocument.Load(xmlReader);
-            }
-            return xmlDocument.DocumentElement;
-        }
+        ///// <summary>
+        ///// Converts from an XElement to an XmlElement
+        ///// </summary>
+        ///// <param name="xElement"></param>
+        ///// <returns></returns>
+        //public static XmlNode ToXmlElement(this XContainer xElement)
+        //{
+        //    var xmlDocument = new XmlDocument();
+        //    using (var xmlReader = xElement.CreateReader())
+        //    {
+        //        xmlDocument.Load(xmlReader);
+        //    }
+        //    return xmlDocument.DocumentElement;
+        //}
 
         /// <summary>
         /// Converts from an XmlElement to an XElement
diff --git a/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs b/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs
index 77c8201f75..a94d451e9a 100644
--- a/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs
+++ b/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs
@@ -56,8 +56,8 @@ namespace Umbraco.Web.Models.Mapping
                         var defaultVals = editor.DefaultPreValues;
                         var fields = editor.PreValueEditor.Fields.Select(Mapper.Map<PreValueFieldDisplay>).ToArray();
                         if (defaultVals != null)
-                        {
-                            PreValueDisplayResolver.MapPreValueValuesToPreValueFields(fields, defaultVals, true);
+                        {                           
+                            PreValueDisplayResolver.MapPreValueValuesToPreValueFields(fields, defaultVals);
                         }
                         return fields;
                     });
diff --git a/src/Umbraco.Web/Models/Mapping/PreValueDisplayResolver.cs b/src/Umbraco.Web/Models/Mapping/PreValueDisplayResolver.cs
index a7bf89a1d2..295a5df63d 100644
--- a/src/Umbraco.Web/Models/Mapping/PreValueDisplayResolver.cs
+++ b/src/Umbraco.Web/Models/Mapping/PreValueDisplayResolver.cs
@@ -24,40 +24,21 @@ namespace Umbraco.Web.Models.Mapping
         /// Maps pre-values in the dictionary to the values for the fields
         /// </summary>
         /// <param name="fields"></param>
-        /// <param name="preValues"></param>
-        /// <param name="isDictionaryBased"></param>
-        internal static void MapPreValueValuesToPreValueFields(PreValueFieldDisplay[] fields, IDictionary<string, object> preValues, bool isDictionaryBased)
+        /// <param name="preValues"></param>        
+        internal static void MapPreValueValuesToPreValueFields(PreValueFieldDisplay[] fields, IDictionary<string, object> preValues)
         {
             if (fields == null) throw new ArgumentNullException("fields");
             if (preValues == null) throw new ArgumentNullException("preValues");
-            //now we need to wire up the pre-values values with the actual fields defined
-            var currentIndex = 0; //used if the collection is non-dictionary based.
+            //now we need to wire up the pre-values values with the actual fields defined            
             foreach (var field in fields)
             {
-                if (isDictionaryBased == false)
+                var found = preValues.Any(x => x.Key.InvariantEquals(field.Key));
+                if (found == false)
                 {
-                    //we'll just need to wire up the values based on the order that the pre-values are stored
-                    var found = preValues.Any(x => x.Key.InvariantEquals(currentIndex.ToInvariantString()));
-                    if (found == false)
-                    {
-                        LogHelper.Warn<PreValueDisplayResolver>("Could not find persisted pre-value for index " + currentIndex);
-                        continue;
-                    }
-                    field.Value = preValues.Single(x => x.Key.InvariantEquals(currentIndex.ToInvariantString())).Value.ToString();
-                    currentIndex++;
+                    LogHelper.Warn<PreValueDisplayResolver>("Could not find persisted pre-value for field " + field.Key);
+                    continue;
                 }
-                else
-                {
-                    var found = preValues.Any(x => x.Key.InvariantEquals(field.Key));
-                    if (found == false)
-                    {
-                        LogHelper.Warn<PreValueDisplayResolver>("Could not find persisted pre-value for field " + field.Key);
-                        continue;
-                    }
-                    field.Value = preValues.Single(x => x.Key.InvariantEquals(field.Key)).Value;
-                }
-
-
+                field.Value = preValues.Single(x => x.Key.InvariantEquals(field.Key)).Value;
             }
         }
 
@@ -86,7 +67,7 @@ namespace Umbraco.Web.Models.Mapping
                 dictionaryVals = propEd.PreValueEditor.ConvertDbToEditor(propEd.DefaultPreValues, preVals);
             }
 
-            MapPreValueValuesToPreValueFields(result, dictionaryVals, preVals.IsDictionaryBased);
+            MapPreValueValuesToPreValueFields(result, dictionaryVals);
 
             return result;
         }
diff --git a/src/umbraco.cms/businesslogic/Packager/PackageInstance/CreatedPackage.cs b/src/umbraco.cms/businesslogic/Packager/PackageInstance/CreatedPackage.cs
index 3aff552bf8..9af68b4482 100644
--- a/src/umbraco.cms/businesslogic/Packager/PackageInstance/CreatedPackage.cs
+++ b/src/umbraco.cms/businesslogic/Packager/PackageInstance/CreatedPackage.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
 using System.Xml;
 using System.Web;
@@ -10,57 +11,62 @@ using umbraco.cms.businesslogic.macro;
 using Umbraco.Core.IO;
 
 
-namespace umbraco.cms.businesslogic.packager {
-    public class CreatedPackage {
+namespace umbraco.cms.businesslogic.packager
+{
+    public class CreatedPackage
+    {
 
-        public static CreatedPackage GetById(int id) {
-            CreatedPackage pack = new CreatedPackage(); 
+        public static CreatedPackage GetById(int id)
+        {
+            var pack = new CreatedPackage();
             pack.Data = data.Package(id, IOHelper.MapPath(Settings.CreatedPackagesSettings));
-            return pack;    
-        }
-
-        public static CreatedPackage MakeNew(string name) {
-            CreatedPackage pack = new CreatedPackage();
-            pack.Data = data.MakeNew(name, IOHelper.MapPath(Settings.CreatedPackagesSettings));
-
-            NewEventArgs e = new NewEventArgs();
-            pack.OnNew(e);
-            
             return pack;
         }
 
-        public void Save() {
-            SaveEventArgs e = new SaveEventArgs();
+        public static CreatedPackage MakeNew(string name)
+        {
+            var pack = new CreatedPackage();
+            pack.Data = data.MakeNew(name, IOHelper.MapPath(Settings.CreatedPackagesSettings));
+
+            var e = new NewEventArgs();
+            pack.OnNew(e);
+
+            return pack;
+        }
+
+        public void Save()
+        {
+            var e = new SaveEventArgs();
             FireBeforeSave(e);
 
-            if (!e.Cancel) {
+            if (!e.Cancel)
+            {
                 data.Save(this.Data, IOHelper.MapPath(Settings.CreatedPackagesSettings));
                 FireAfterSave(e);
             }
         }
 
-        public void Delete() {
-            DeleteEventArgs e = new DeleteEventArgs();
+        public void Delete()
+        {
+            var e = new DeleteEventArgs();
             FireBeforeDelete(e);
 
-            if (!e.Cancel) {
+            if (!e.Cancel)
+            {
                 data.Delete(this.Data.Id, IOHelper.MapPath(Settings.CreatedPackagesSettings));
                 FireAfterDelete(e);
             }
         }
 
-        private PackageInstance m_data;
-        public PackageInstance Data {
-            get { return m_data; }
-            set { m_data = value; }
-        }
+        public PackageInstance Data { get; set; }
 
-        public static List<CreatedPackage> GetAllCreatedPackages() {
-            List<CreatedPackage> val = new List<CreatedPackage>();
+        public static List<CreatedPackage> GetAllCreatedPackages()
+        {
+            var val = new List<CreatedPackage>();
 
-            foreach (PackageInstance pack in data.GetAllPackages(IOHelper.MapPath(Settings.CreatedPackagesSettings)))
+            foreach (var pack in data.GetAllPackages(IOHelper.MapPath(Settings.CreatedPackagesSettings)))
             {
-                CreatedPackage crPack = new CreatedPackage();
+                var crPack = new CreatedPackage();
                 crPack.Data = pack;
                 val.Add(crPack);
             }
@@ -69,9 +75,10 @@ namespace umbraco.cms.businesslogic.packager {
         }
 
         private static XmlDocument _packageManifest;
-        private static void createPackageManifest() {
+        private static void CreatePackageManifest()
+        {
             _packageManifest = new XmlDocument();
-            XmlDeclaration xmldecl = _packageManifest.CreateXmlDeclaration("1.0", "UTF-8", "no");
+            var xmldecl = _packageManifest.CreateXmlDeclaration("1.0", "UTF-8", "no");
 
             _packageManifest.AppendChild(xmldecl);
 
@@ -82,222 +89,226 @@ namespace umbraco.cms.businesslogic.packager {
             umbPackage.AppendChild(_packageManifest.CreateElement("files"));
         }
 
-        private static void appendElement(XmlNode node) {
-            XmlNode root = _packageManifest.SelectSingleNode("/umbPackage");
+        private static void AppendElement(XmlNode node)
+        {
+            var root = _packageManifest.SelectSingleNode("/umbPackage");
             root.AppendChild(node);
         }
 
 
-        public void Publish() {
+        public void Publish()
+        {
 
-            CreatedPackage package = this;
-            PackageInstance pack = package.Data;
+            var package = this;
+            var pack = package.Data;
 
-			try
-			{
+            try
+            {
 
-				PublishEventArgs e = new PublishEventArgs();
-				package.FireBeforePublish(e);
+                var e = new PublishEventArgs();
+                package.FireBeforePublish(e);
 
-				if (!e.Cancel)
-				{
-					int outInt = 0;
+                if (e.Cancel == false)
+                {
+                    var outInt = 0;
 
-					//Path checking...
-					string localPath = IOHelper.MapPath(SystemDirectories.Media + "/" + pack.Folder);
+                    //Path checking...
+                    var localPath = IOHelper.MapPath(SystemDirectories.Media + "/" + pack.Folder);
 
-					if (!System.IO.Directory.Exists(localPath))
-						System.IO.Directory.CreateDirectory(localPath);
+                    if (Directory.Exists(localPath) == false)
+                        Directory.CreateDirectory(localPath);
 
-					//Init package file...
-					createPackageManifest();
-					//Info section..
-					appendElement(utill.PackageInfo(pack, _packageManifest));
+                    //Init package file...
+                    CreatePackageManifest();
+                    //Info section..
+                    AppendElement(utill.PackageInfo(pack, _packageManifest));
 
-					//Documents...
-					int _contentNodeID = 0;
-					if (!String.IsNullOrEmpty(pack.ContentNodeId) && int.TryParse(pack.ContentNodeId, out _contentNodeID))
-					{
-						XmlNode documents = _packageManifest.CreateElement("Documents");
+                    //Documents...
+                    var contentNodeId = 0;
+                    if (string.IsNullOrEmpty(pack.ContentNodeId) == false && int.TryParse(pack.ContentNodeId, out contentNodeId))
+                    {
+                        XmlNode documents = _packageManifest.CreateElement("Documents");
 
-						XmlNode documentSet = _packageManifest.CreateElement("DocumentSet");
-						XmlAttribute importMode = _packageManifest.CreateAttribute("importMode", "");
-						importMode.Value = "root";
-						documentSet.Attributes.Append(importMode);
-						documents.AppendChild(documentSet);
+                        XmlNode documentSet = _packageManifest.CreateElement("DocumentSet");
+                        XmlAttribute importMode = _packageManifest.CreateAttribute("importMode", "");
+                        importMode.Value = "root";
+                        documentSet.Attributes.Append(importMode);
+                        documents.AppendChild(documentSet);
 
-						//load content from umbraco.
-						cms.businesslogic.web.Document umbDocument = new Document(_contentNodeID);
-						documentSet.AppendChild(umbDocument.ToXml(_packageManifest, pack.ContentLoadChildNodes));
+                        //load content from umbraco.
+                        var umbDocument = new Document(contentNodeId);
+                        documentSet.AppendChild(umbDocument.ToXml(_packageManifest, pack.ContentLoadChildNodes));
 
-						appendElement(documents);
-					}
+                        AppendElement(documents);
+                    }
 
-					//Document types..
-					List<DocumentType> dtl = new List<DocumentType>();
-					XmlNode docTypes = _packageManifest.CreateElement("DocumentTypes");
-					foreach (string dtId in pack.Documenttypes)
-					{
-						if (int.TryParse(dtId, out outInt))
-						{
-							DocumentType docT = new DocumentType(outInt);
+                    //Document types..
+                    var dtl = new List<DocumentType>();
+                    var docTypes = _packageManifest.CreateElement("DocumentTypes");
+                    foreach (var dtId in pack.Documenttypes)
+                    {
+                        if (int.TryParse(dtId, out outInt))
+                        {
+                            DocumentType docT = new DocumentType(outInt);
 
-							AddDocumentType(docT, ref dtl);
+                            AddDocumentType(docT, ref dtl);
 
-						}
-					}
-					foreach (DocumentType d in dtl)
-					{
-						docTypes.AppendChild(d.ToXml(_packageManifest));
-					}
+                        }
+                    }
+                    foreach (DocumentType d in dtl)
+                    {
+                        docTypes.AppendChild(d.ToXml(_packageManifest));
+                    }
 
-					appendElement(docTypes);
+                    AppendElement(docTypes);
 
-					//Templates
-					XmlNode templates = _packageManifest.CreateElement("Templates");
-					foreach (string templateId in pack.Templates)
-					{
-						if (int.TryParse(templateId, out outInt))
-						{
-							Template t = new Template(outInt);
-							templates.AppendChild(t.ToXml(_packageManifest));
-						}
-					}
-					appendElement(templates);
+                    //Templates
+                    var templates = _packageManifest.CreateElement("Templates");
+                    foreach (var templateId in pack.Templates)
+                    {
+                        if (int.TryParse(templateId, out outInt))
+                        {
+                            var t = new Template(outInt);
+                            templates.AppendChild(t.ToXml(_packageManifest));
+                        }
+                    }
+                    AppendElement(templates);
 
-					//Stylesheets
-					XmlNode stylesheets = _packageManifest.CreateElement("Stylesheets");
-					foreach (string ssId in pack.Stylesheets)
-					{
-						if (int.TryParse(ssId, out outInt))
-						{
-							StyleSheet s = new StyleSheet(outInt);
-							stylesheets.AppendChild(s.ToXml(_packageManifest));
-						}
-					}
-					appendElement(stylesheets);
+                    //Stylesheets
+                    var stylesheets = _packageManifest.CreateElement("Stylesheets");
+                    foreach (var ssId in pack.Stylesheets)
+                    {
+                        if (int.TryParse(ssId, out outInt))
+                        {
+                            var s = new StyleSheet(outInt);
+                            stylesheets.AppendChild(s.ToXml(_packageManifest));
+                        }
+                    }
+                    AppendElement(stylesheets);
 
-					//Macros
-					XmlNode macros = _packageManifest.CreateElement("Macros");
-					foreach (string macroId in pack.Macros)
-					{
-						if (int.TryParse(macroId, out outInt))
-						{
-							macros.AppendChild(utill.Macro(int.Parse(macroId), true, localPath, _packageManifest));
-						}
-					}
-					appendElement(macros);
+                    //Macros
+                    var macros = _packageManifest.CreateElement("Macros");
+                    foreach (var macroId in pack.Macros)
+                    {
+                        if (int.TryParse(macroId, out outInt))
+                        {
+                            macros.AppendChild(utill.Macro(int.Parse(macroId), true, localPath, _packageManifest));
+                        }
+                    }
+                    AppendElement(macros);
 
-					//Dictionary Items
-					XmlNode dictionaryItems = _packageManifest.CreateElement("DictionaryItems");
-					foreach (string dictionaryId in pack.DictionaryItems)
-					{
-						if (int.TryParse(dictionaryId, out outInt))
-						{
-							Dictionary.DictionaryItem di = new Dictionary.DictionaryItem(outInt);
-							dictionaryItems.AppendChild(di.ToXml(_packageManifest));
-						}
-					}
-					appendElement(dictionaryItems);
+                    //Dictionary Items
+                    var dictionaryItems = _packageManifest.CreateElement("DictionaryItems");
+                    foreach (var dictionaryId in pack.DictionaryItems)
+                    {
+                        if (int.TryParse(dictionaryId, out outInt))
+                        {
+                            var di = new Dictionary.DictionaryItem(outInt);
+                            dictionaryItems.AppendChild(di.ToXml(_packageManifest));
+                        }
+                    }
+                    AppendElement(dictionaryItems);
 
-					//Languages
-					XmlNode languages = _packageManifest.CreateElement("Languages");
-					foreach (string langId in pack.Languages)
-					{
-						if (int.TryParse(langId, out outInt))
-						{
-							language.Language lang = new umbraco.cms.businesslogic.language.Language(outInt);
+                    //Languages
+                    var languages = _packageManifest.CreateElement("Languages");
+                    foreach (var langId in pack.Languages)
+                    {
+                        if (int.TryParse(langId, out outInt))
+                        {
+                            var lang = new language.Language(outInt);
 
-							languages.AppendChild(lang.ToXml(_packageManifest));
-						}
-					}
-					appendElement(languages);
+                            languages.AppendChild(lang.ToXml(_packageManifest));
+                        }
+                    }
+                    AppendElement(languages);
 
-					//Datatypes
-					XmlNode dataTypes = _packageManifest.CreateElement("DataTypes");
-					foreach (string dtId in pack.DataTypes)
-					{
-						if (int.TryParse(dtId, out outInt))
-						{
-							cms.businesslogic.datatype.DataTypeDefinition dtd = new umbraco.cms.businesslogic.datatype.DataTypeDefinition(outInt);
-							dataTypes.AppendChild(dtd.ToXml(_packageManifest));
-						}
-					}
-					appendElement(dataTypes);
+                    //Datatypes
+                    var dataTypes = _packageManifest.CreateElement("DataTypes");
+                    foreach (var dtId in pack.DataTypes)
+                    {
+                        if (int.TryParse(dtId, out outInt))
+                        {
+                            datatype.DataTypeDefinition dtd = new datatype.DataTypeDefinition(outInt);
+                            dataTypes.AppendChild(dtd.ToXml(_packageManifest));
+                        }
+                    }
+                    AppendElement(dataTypes);
 
-					//Files
-					foreach (string fileName in pack.Files)
-					{
-						utill.AppendFileToManifest(fileName, localPath, _packageManifest);
-					}
+                    //Files
+                    foreach (var fileName in pack.Files)
+                    {
+                        utill.AppendFileToManifest(fileName, localPath, _packageManifest);
+                    }
 
-					//Load control on install...
-					if (!string.IsNullOrEmpty(pack.LoadControl))
-					{
-						XmlNode control = _packageManifest.CreateElement("control");
-						control.InnerText = pack.LoadControl;
-						utill.AppendFileToManifest(pack.LoadControl, localPath, _packageManifest);
-						appendElement(control);
-					}
+                    //Load control on install...
+                    if (string.IsNullOrEmpty(pack.LoadControl) == false)
+                    {
+                        XmlNode control = _packageManifest.CreateElement("control");
+                        control.InnerText = pack.LoadControl;
+                        utill.AppendFileToManifest(pack.LoadControl, localPath, _packageManifest);
+                        AppendElement(control);
+                    }
 
-					//Actions
-					if (!string.IsNullOrEmpty(pack.Actions))
-					{
-						try
-						{
-							XmlDocument xd_actions = new XmlDocument();
-							xd_actions.LoadXml("<Actions>" + pack.Actions + "</Actions>");
-							XmlNode actions = xd_actions.DocumentElement.SelectSingleNode(".");
+                    //Actions
+                    if (string.IsNullOrEmpty(pack.Actions) == false)
+                    {
+                        try
+                        {
+                            var xdActions = new XmlDocument();
+                            xdActions.LoadXml("<Actions>" + pack.Actions + "</Actions>");
+                            var actions = xdActions.DocumentElement.SelectSingleNode(".");
 
 
-							if (actions != null)
-							{
-								actions = _packageManifest.ImportNode(actions, true).Clone();
-								appendElement(actions);
-							}
-						}
-						catch { }
-					}
+                            if (actions != null)
+                            {
+                                actions = _packageManifest.ImportNode(actions, true).Clone();
+                                AppendElement(actions);
+                            }
+                        }
+                        catch { }
+                    }
 
-					string manifestFileName = localPath + "/package.xml";
+                    var manifestFileName = localPath + "/package.xml";
 
-					if (System.IO.File.Exists(manifestFileName))
-						System.IO.File.Delete(manifestFileName);
+                    if (File.Exists(manifestFileName))
+                        File.Delete(manifestFileName);
 
-					_packageManifest.Save(manifestFileName);
-					_packageManifest = null;
+                    _packageManifest.Save(manifestFileName);
+                    _packageManifest = null;
 
 
-					//string packPath = Settings.PackagerRoot.Replace(System.IO.Path.DirectorySeparatorChar.ToString(), "/") + "/" + pack.Name.Replace(' ', '_') + "_" + pack.Version.Replace(' ', '_') + "." + Settings.PackageFileExtension;
+                    //string packPath = Settings.PackagerRoot.Replace(System.IO.Path.DirectorySeparatorChar.ToString(), "/") + "/" + pack.Name.Replace(' ', '_') + "_" + pack.Version.Replace(' ', '_') + "." + Settings.PackageFileExtension;
 
-					// check if there's a packages directory below media
-					string packagesDirectory = SystemDirectories.Media + "/created-packages";
-					if (!System.IO.Directory.Exists(IOHelper.MapPath(packagesDirectory)))
-						System.IO.Directory.CreateDirectory(IOHelper.MapPath(packagesDirectory));
+                    // check if there's a packages directory below media
+                    var packagesDirectory = SystemDirectories.Media + "/created-packages";
+                    if (Directory.Exists(IOHelper.MapPath(packagesDirectory)) == false)
+                    {
+                        Directory.CreateDirectory(IOHelper.MapPath(packagesDirectory));
+                    }
 
 
-					string packPath = packagesDirectory + "/" + (pack.Name + "_" + pack.Version).Replace(' ', '_') + "." + Settings.PackageFileExtension;
-					utill.ZipPackage(localPath, IOHelper.MapPath(packPath));
+                    var packPath = packagesDirectory + "/" + (pack.Name + "_" + pack.Version).Replace(' ', '_') + "." + Settings.PackageFileExtension;
+                    utill.ZipPackage(localPath, IOHelper.MapPath(packPath));
 
-					pack.PackagePath = packPath;
+                    pack.PackagePath = packPath;
 
-					if (pack.PackageGuid.Trim() == "")
-						pack.PackageGuid = Guid.NewGuid().ToString();
+                    if (pack.PackageGuid.Trim() == "")
+                        pack.PackageGuid = Guid.NewGuid().ToString();
 
-					package.Save();
+                    package.Save();
 
-					//Clean up..
-					System.IO.File.Delete(localPath + "/package.xml");
-					System.IO.Directory.Delete(localPath, true);
+                    //Clean up..
+                    File.Delete(localPath + "/package.xml");
+                    Directory.Delete(localPath, true);
 
-					package.FireAfterPublish(e);
-				}
+                    package.FireAfterPublish(e);
+                }
 
-			}
-			catch (Exception ex)
-			{
-				LogHelper.Error<CreatedPackage>("An error occurred", ex);
-			}
+            }
+            catch (Exception ex)
+            {
+                LogHelper.Error<CreatedPackage>("An error occurred", ex);
+            }
         }
 
         private void AddDocumentType(DocumentType dt, ref List<DocumentType> dtl)
@@ -305,14 +316,16 @@ namespace umbraco.cms.businesslogic.packager {
             if (dt.MasterContentType != 0)
             {
                 //first add masters
-                DocumentType mDocT = new DocumentType(dt.MasterContentType);
+                var mDocT = new DocumentType(dt.MasterContentType);
 
                 AddDocumentType(mDocT, ref dtl);
 
             }
 
-            if (!dtl.Contains(dt))
+            if (dtl.Contains(dt) == false)
+            {
                 dtl.Add(dt);
+            }
         }
 
         //EVENTS
@@ -325,47 +338,54 @@ namespace umbraco.cms.businesslogic.packager {
         /// Occurs when a macro is saved.
         /// </summary>
         public static event SaveEventHandler BeforeSave;
-        protected virtual void FireBeforeSave(SaveEventArgs e) {
+        protected virtual void FireBeforeSave(SaveEventArgs e)
+        {
             if (BeforeSave != null)
                 BeforeSave(this, e);
         }
 
         public static event SaveEventHandler AfterSave;
-        protected virtual void FireAfterSave(SaveEventArgs e) {
+        protected virtual void FireAfterSave(SaveEventArgs e)
+        {
             if (AfterSave != null)
                 AfterSave(this, e);
         }
 
         public static event NewEventHandler New;
-        protected virtual void OnNew(NewEventArgs e) {
+        protected virtual void OnNew(NewEventArgs e)
+        {
             if (New != null)
                 New(this, e);
         }
 
         public static event DeleteEventHandler BeforeDelete;
-        protected virtual void FireBeforeDelete(DeleteEventArgs e) {
+        protected virtual void FireBeforeDelete(DeleteEventArgs e)
+        {
             if (BeforeDelete != null)
                 BeforeDelete(this, e);
         }
 
         public static event DeleteEventHandler AfterDelete;
-        protected virtual void FireAfterDelete(DeleteEventArgs e) {
+        protected virtual void FireAfterDelete(DeleteEventArgs e)
+        {
             if (AfterDelete != null)
                 AfterDelete(this, e);
         }
 
         public static event PublishEventHandler BeforePublish;
-        protected virtual void FireBeforePublish(PublishEventArgs e) {
+        protected virtual void FireBeforePublish(PublishEventArgs e)
+        {
             if (BeforePublish != null)
                 BeforePublish(this, e);
         }
 
         public static event PublishEventHandler AfterPublish;
-        protected virtual void FireAfterPublish(PublishEventArgs e) {
+        protected virtual void FireAfterPublish(PublishEventArgs e)
+        {
             if (AfterPublish != null)
                 AfterPublish(this, e);
         }
 
-        
+
     }
 }
diff --git a/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs b/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs
index a563549bcf..bcb8c91fa3 100644
--- a/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs
+++ b/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.Globalization;
 using System.Linq;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Persistence;
@@ -30,10 +31,9 @@ namespace umbraco.cms.businesslogic.datatype
         #region Private fields
         private string _propertyEditorAlias;
 
-        private static Guid _objectType = new Guid(Constants.ObjectTypes.DataType);
-	    private string _dbType;
+        private static readonly Guid ObjectType = new Guid(Constants.ObjectTypes.DataType);
 
-	    #endregion
+        #endregion
 
         #region Constructors
 
@@ -102,19 +102,18 @@ namespace umbraco.cms.businesslogic.datatype
 
                 _propertyEditorAlias = alias;
             }
-        } 
-	    internal string DbType
-	    {
-            get { return _dbType; }
-        } 
+        }
+
+        internal string DbType { get; private set; }
+
         #endregion
 
         #region Public methods
         public override void delete()
         {
-            DeleteEventArgs e = new DeleteEventArgs();
+            var e = new DeleteEventArgs();
             FireBeforeDelete(e);
-            if (!e.Cancel)
+            if (e.Cancel == false)
             {
                 //first clear the prevalues
                 PreValues.DeleteByDataTypeDefinition(this.Id);
@@ -155,20 +154,21 @@ namespace umbraco.cms.businesslogic.datatype
             //here we need to get the property editor alias from it's id
             var alias = LegacyPropertyEditorIdToAliasConverter.GetAliasFromLegacyId(DataType.Id, true);
 
-            XmlElement dt = xd.CreateElement("DataType");
+            var dt = xd.CreateElement("DataType");
             dt.Attributes.Append(xmlHelper.addAttribute(xd, "Name", Text));
+            //The 'ID' when exporting is actually the property editor alias (in pre v7 it was the IDataType GUID id)
             dt.Attributes.Append(xmlHelper.addAttribute(xd, "Id", alias));
             dt.Attributes.Append(xmlHelper.addAttribute(xd, "Definition", UniqueId.ToString()));
             dt.Attributes.Append(xmlHelper.addAttribute(xd, "DatabaseType", DbType));
 
             // templates
-            XmlElement prevalues = xd.CreateElement("PreValues");
+            var prevalues = xd.CreateElement("PreValues");
             foreach (DictionaryEntry item in PreValues.GetPreValues(Id))
             {
-                XmlElement prevalue = xd.CreateElement("PreValue");
-                prevalue.Attributes.Append(xmlHelper.addAttribute(xd, "Id", ((PreValue)item.Value).Id.ToString()));
+                var prevalue = xd.CreateElement("PreValue");
+                prevalue.Attributes.Append(xmlHelper.addAttribute(xd, "Id", ((PreValue)item.Value).Id.ToString(CultureInfo.InvariantCulture)));
                 prevalue.Attributes.Append(xmlHelper.addAttribute(xd, "Value", ((PreValue)item.Value).Value));
-
+                prevalue.Attributes.Append(xmlHelper.addAttribute(xd, "Alias", ((PreValue)item.Value).Alias));
                 prevalues.AppendChild(prevalue);
             }
 
@@ -226,17 +226,17 @@ namespace umbraco.cms.businesslogic.datatype
         /// <returns>A list of all datatypedefinitions</returns>
         public static DataTypeDefinition[] GetAll()
         {
-            SortedList retvalSort = new SortedList();
-            Guid[] tmp = CMSNode.getAllUniquesFromObjectType(_objectType);
-            DataTypeDefinition[] retval = new DataTypeDefinition[tmp.Length];
-            for (int i = 0; i < tmp.Length; i++)
+            var retvalSort = new SortedList();
+            var tmp = getAllUniquesFromObjectType(ObjectType);
+            var retval = new DataTypeDefinition[tmp.Length];
+            for (var i = 0; i < tmp.Length; i++)
             {
-                DataTypeDefinition dt = DataTypeDefinition.GetDataTypeDefinition(tmp[i]);
-                retvalSort.Add(dt.Text + "|||" + Guid.NewGuid().ToString(), dt);
+                var dt = GetDataTypeDefinition(tmp[i]);
+                retvalSort.Add(dt.Text + "|||" + Guid.NewGuid(), dt);
             }
 
-            IDictionaryEnumerator ide = retvalSort.GetEnumerator();
-            int counter = 0;
+            var ide = retvalSort.GetEnumerator();
+            var counter = 0;
             while (ide.MoveNext())
             {
                 retval[counter] = (DataTypeDefinition)ide.Value;
@@ -266,7 +266,7 @@ namespace umbraco.cms.businesslogic.datatype
         public static DataTypeDefinition MakeNew(BusinessLogic.User u, string Text, Guid UniqueId)
         {
 
-            var newId = MakeNew(-1, _objectType, u.Id, 1, Text, UniqueId).Id;
+            var newId = MakeNew(-1, ObjectType, u.Id, 1, Text, UniqueId).Id;
 
             //insert empty prop ed alias
             SqlHelper.ExecuteNonQuery("Insert into cmsDataType (nodeId, propertyEditorAlias, dbType) values (" + newId + ",'','Ntext')");
@@ -284,19 +284,18 @@ namespace umbraco.cms.businesslogic.datatype
         /// <returns>A list of datatypedefinitions which are based on the IDataType specified</returns>
         public static DataTypeDefinition GetByDataTypeId(Guid DataTypeId)
         {
-            int dfId = 0;
+            var dfId = 0;
             // When creating a datatype and not saving it, it will be null, so we need this check
-            foreach (DataTypeDefinition df in DataTypeDefinition.GetAll().Where(x => x.DataType != null))
+            foreach (var df in GetAll().Where(x => x.DataType != null))
+            {
                 if (df.DataType.Id == DataTypeId)
                 {
                     dfId = df.Id;
                     break;
                 }
+            }
 
-            if (dfId == 0)
-                return null;
-            else
-                return new DataTypeDefinition(dfId);
+            return dfId == 0 ? null : new DataTypeDefinition(dfId);
         }
 
         /// <summary>
@@ -309,7 +308,9 @@ namespace umbraco.cms.businesslogic.datatype
             Type typeOfData = Data.GetType();
 
             while (typeOfData.BaseType != new Object().GetType())
+            {
                 typeOfData = typeOfData.BaseType;
+            }
 
             return (typeOfData.FullName == "umbraco.cms.businesslogic.datatype.DefaultData");
         }
@@ -335,12 +336,12 @@ namespace umbraco.cms.businesslogic.datatype
         {
             base.setupNode();
 
-            using (IRecordsReader dr = SqlHelper.ExecuteReader("select dbType, propertyEditorAlias from cmsDataType where nodeId = '" + this.Id.ToString() + "'"))
+            using (var dr = SqlHelper.ExecuteReader("select dbType, propertyEditorAlias from cmsDataType where nodeId = '" + this.Id.ToString() + "'"))
             {
                 if (dr.Read())
                 {
                     _propertyEditorAlias = dr.GetString("propertyEditorAlias");
-                    _dbType = dr.GetString("dbType");
+                    DbType = dr.GetString("dbType");
                 }
                 else
                     throw new ArgumentException("No dataType with id = " + this.Id.ToString() + " found");
diff --git a/src/umbraco.cms/businesslogic/datatype/PreValue.cs b/src/umbraco.cms/businesslogic/datatype/PreValue.cs
index db65b9ce6f..cefdbb2bae 100644
--- a/src/umbraco.cms/businesslogic/datatype/PreValue.cs
+++ b/src/umbraco.cms/businesslogic/datatype/PreValue.cs
@@ -40,8 +40,16 @@ namespace umbraco.cms.businesslogic.datatype
         public PreValue(int Id, int SortOrder, string Value)
         {
             _id = Id;
-            _sortOrder = SortOrder;
-            _value = Value;
+            this.SortOrder = SortOrder;
+            this.Value = Value;
+        }
+
+        public PreValue(int id, int sortOrder, string value, string alias)
+        {
+            _id = id;
+            SortOrder = sortOrder;
+            Value = value;
+            Alias = alias;
         }
 
         /// <summary>
@@ -51,7 +59,7 @@ namespace umbraco.cms.businesslogic.datatype
         public PreValue(int Id)
         {
             _id = Id;
-            initialize();
+            Initialize();
         }
 
         /// <summary>
@@ -61,14 +69,14 @@ namespace umbraco.cms.businesslogic.datatype
         /// <param name="Value">The value.</param>
         public PreValue(int DataTypeId, string Value)
         {
-            object id = SqlHelper.ExecuteScalar<object>(
+            var id = SqlHelper.ExecuteScalar<object>(
                 "Select id from cmsDataTypePreValues where [Value] = @value and DataTypeNodeId = @dataTypeId",
                 SqlHelper.CreateParameter("@dataTypeId", DataTypeId),
                 SqlHelper.CreateParameter("@value", Value));
             if (id != null)
                 _id = int.Parse(id.ToString());
 
-            initialize();
+            Initialize();
         } 
         #endregion
 
@@ -90,22 +98,18 @@ namespace umbraco.cms.businesslogic.datatype
         }
 
         #region Private members
-        private int _dataTypeId;
+
         private int? _id;
-        private string _value;
-        private int _sortOrder; 
+
         #endregion
 
         #region Public properties
+
         /// <summary>
         /// Gets or sets the data type id.
         /// </summary>
         /// <value>The data type id.</value>
-        public int DataTypeId
-        {
-            get { return _dataTypeId; }
-            set { _dataTypeId = value; }
-        }
+        public int DataTypeId { get; set; }
 
         /// <summary>
         /// Gets or sets the id.
@@ -121,21 +125,20 @@ namespace umbraco.cms.businesslogic.datatype
         /// Gets or sets the value.
         /// </summary>
         /// <value>The value.</value>
-        public string Value
-        {
-            get { return _value; }
-            set { _value = value; }
-        }
+        public string Value { get; set; }
 
         /// <summary>
         /// Gets or sets the sort order.
         /// </summary>
         /// <value>The sort order.</value>
-        public int SortOrder
-        {
-            get { return _sortOrder; }
-            set { _sortOrder = value; }
-        } 
+        public int SortOrder { get; set; }
+
+        /// <summary>
+        /// Gets or sets the sort order.
+        /// </summary>
+        /// <value>The sort order.</value>
+        public string Alias { get; set; }
+
         #endregion
 
         #region Public methods
@@ -164,27 +167,29 @@ namespace umbraco.cms.businesslogic.datatype
             if (Id == 0)
             {
                 // Update sortOrder
-                object tempSortOrder = SqlHelper.ExecuteScalar<object>("select max(sortorder) from cmsDataTypePreValues where datatypenodeid = @dataTypeId", SqlHelper.CreateParameter("@dataTypeId", DataTypeId));
-                int _sortOrder = 0;
+                var tempSortOrder = SqlHelper.ExecuteScalar<object>("select max(sortorder) from cmsDataTypePreValues where datatypenodeid = @dataTypeId", SqlHelper.CreateParameter("@dataTypeId", DataTypeId));
+                var sortOrder = 0;
 
-                if (tempSortOrder != null && int.TryParse(tempSortOrder.ToString(), out _sortOrder))
-                    SortOrder = _sortOrder + 1;
+                if (tempSortOrder != null && int.TryParse(tempSortOrder.ToString(), out sortOrder))
+                    SortOrder = sortOrder + 1;
                 else
                     SortOrder = 1;
 
-                IParameter[] SqlParams = new IParameter[] {
+                var sqlParams = new IParameter[] {
 								SqlHelper.CreateParameter("@value",Value),
-								SqlHelper.CreateParameter("@dtdefid",DataTypeId)};
+								SqlHelper.CreateParameter("@dtdefid",DataTypeId),
+                                SqlHelper.CreateParameter("@alias",Alias)};
                 // The method is synchronized
-                SqlHelper.ExecuteNonQuery("INSERT INTO cmsDataTypePreValues (datatypenodeid,[value],sortorder,alias) VALUES (@dtdefid,@value,0,'')", SqlParams);
+                SqlHelper.ExecuteNonQuery("INSERT INTO cmsDataTypePreValues (datatypenodeid,[value],sortorder,alias) VALUES (@dtdefid,@value,0,'@alias')", sqlParams);
                 _id = SqlHelper.ExecuteScalar<int>("SELECT MAX(id) FROM cmsDataTypePreValues");
             }
 
             SqlHelper.ExecuteNonQuery(
-                "update cmsDataTypePreValues set sortorder = @sortOrder, [value] = @value where id = @id",
+                "update cmsDataTypePreValues set sortorder = @sortOrder, [value] = @value, alias = @alias where id = @id",
                 SqlHelper.CreateParameter("@sortOrder", SortOrder),
                 SqlHelper.CreateParameter("@value", Value),
-                SqlHelper.CreateParameter("@id", Id));
+                SqlHelper.CreateParameter("@id", Id),
+                SqlHelper.CreateParameter("@alias", Alias));
         } 
         
         #endregion
@@ -193,15 +198,16 @@ namespace umbraco.cms.businesslogic.datatype
         /// <summary>
         /// Initializes this instance.
         /// </summary>
-        private void initialize()
+        private void Initialize()
         {
-            IRecordsReader dr = SqlHelper.ExecuteReader(
-                 "Select id, sortorder, [value] from cmsDataTypePreValues where id = @id order by sortorder",
+            var dr = SqlHelper.ExecuteReader(
+                 "Select id, sortorder, [value], alias from cmsDataTypePreValues where id = @id order by sortorder",
                  SqlHelper.CreateParameter("@id", Id));
             if (dr.Read())
             {
-                _sortOrder = dr.GetInt("sortorder");
-                _value = dr.GetString("value");
+                SortOrder = dr.GetInt("sortorder");
+                Value = dr.GetString("value");
+                Alias = dr.GetString("alias");
             }
             dr.Close();
         } 
diff --git a/src/umbraco.cms/businesslogic/datatype/PreValues.cs b/src/umbraco.cms/businesslogic/datatype/PreValues.cs
index 457554e92a..da23f650bd 100644
--- a/src/umbraco.cms/businesslogic/datatype/PreValues.cs
+++ b/src/umbraco.cms/businesslogic/datatype/PreValues.cs
@@ -29,15 +29,15 @@ namespace umbraco.cms.businesslogic.datatype
         /// <returns></returns>
         public static SortedList GetPreValues(int DataTypeId)
         {
-            SortedList retval = new SortedList();
-            IRecordsReader dr = SqlHelper.ExecuteReader(
-                "Select id, sortorder, [value] from cmsDataTypePreValues where DataTypeNodeId = @dataTypeId order by sortorder",
+            var retval = new SortedList();
+            var dr = SqlHelper.ExecuteReader(
+                "Select id, sortorder, [value], alias from cmsDataTypePreValues where DataTypeNodeId = @dataTypeId order by sortorder",
                 SqlHelper.CreateParameter("@dataTypeId", DataTypeId));
 
             int counter = 0;
             while (dr.Read())
             {
-                retval.Add(counter, new PreValue(dr.GetInt("id"), dr.GetInt("sortorder"), dr.GetString("value")));
+                retval.Add(counter, new PreValue(dr.GetInt("id"), dr.GetInt("sortorder"), dr.GetString("value"), dr.GetString("alias")));
                 counter++;
             }
             dr.Close();