diff --git a/src/Umbraco.Core/ApplicationContext.cs b/src/Umbraco.Core/ApplicationContext.cs
index 964e771850..776714b839 100644
--- a/src/Umbraco.Core/ApplicationContext.cs
+++ b/src/Umbraco.Core/ApplicationContext.cs
@@ -4,7 +4,6 @@ using System.Web;
 using System.Web.Caching;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
-using Umbraco.Core.Persistence;
 using Umbraco.Core.Services;
 
 
diff --git a/src/Umbraco.Core/Models/Content.cs b/src/Umbraco.Core/Models/Content.cs
index 2410c1c995..2e5e7f8383 100644
--- a/src/Umbraco.Core/Models/Content.cs
+++ b/src/Umbraco.Core/Models/Content.cs
@@ -102,10 +102,10 @@ namespace Umbraco.Core.Models
                 if(Trashed)
                     return ContentStatus.Trashed;
 
-                if(ExpireDate.HasValue && DateTime.UtcNow > ExpireDate.Value)
+                if(ExpireDate.HasValue && ExpireDate.Value > DateTime.MinValue && DateTime.UtcNow > ExpireDate.Value)
                     return ContentStatus.Expired;
 
-                if(ReleaseDate.HasValue && ReleaseDate.Value > DateTime.UtcNow)
+                if(ReleaseDate.HasValue && ReleaseDate.Value > DateTime.MinValue && ReleaseDate.Value > DateTime.UtcNow)
                     return ContentStatus.AwaitingRelease;
 
                 if(Published)
@@ -156,11 +156,12 @@ namespace Umbraco.Core.Models
             get { return _releaseDate; }
             set
             {
-                if(value.HasValue && value.Value > DateTime.UtcNow && Published)
+                //Thought this type of check would be clever, but it only seems to cause problems
+                /*if(value.HasValue && value.Value > DateTime.UtcNow && Published)
                     _published = false;
 
                 if (value.HasValue && value.Value < DateTime.UtcNow && !Published)
-                    _published = true;
+                    _published = true;*/
 
                 _releaseDate = value;
                 OnPropertyChanged(ReleaseDateSelector);
@@ -176,8 +177,9 @@ namespace Umbraco.Core.Models
             get { return _expireDate; }
             set
             {
-                if(value.HasValue && DateTime.UtcNow > value.Value && Published)
-                    _published = false;
+                //Thought this type of check would be clever, but it only seems to cause problems
+                /*if(value.HasValue && DateTime.UtcNow > value.Value && Published)
+                    _published = false;*/
 
                 _expireDate = value;
                 OnPropertyChanged(ExpireDateSelector);
@@ -311,10 +313,10 @@ namespace Umbraco.Core.Models
         public override bool IsPropertyDirty(string propertyName)
         {
             bool existsInEntity = base.IsPropertyDirty(propertyName);
+            if (existsInEntity)
+                return true;
 
-            bool anyDirtyProperties = Properties.Any(x => x.IsPropertyDirty(propertyName));
-
-            return existsInEntity || anyDirtyProperties;
+            return Properties.Any(x => x.IsPropertyDirty(propertyName));
         }
 
         /// <summary>
diff --git a/src/Umbraco.Core/Models/ContentExtensions.cs b/src/Umbraco.Core/Models/ContentExtensions.cs
index 23fb4694e2..10151455e7 100644
--- a/src/Umbraco.Core/Models/ContentExtensions.cs
+++ b/src/Umbraco.Core/Models/ContentExtensions.cs
@@ -12,6 +12,7 @@ using Umbraco.Core.IO;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.UnitOfWork;
+using Umbraco.Core.Services;
 
 namespace Umbraco.Core.Models
 {
@@ -369,6 +370,18 @@ namespace Umbraco.Core.Models
 			}
         }
 
+        /// <summary>
+        /// Checks whether an <see cref="IContent"/> item has any published versions
+        /// </summary>
+        /// <param name="content"></param>
+        /// <returns>True if the content has any published versiom otherwise False</returns>
+        public static bool HasPublishedVersion(this IContent content)
+        {
+            if (content.HasIdentity == false)
+                return false;
+
+            return ApplicationContext.Current.Services.ContentService.HasPublishedVersion(content.Id);
+        }
 
         /// <summary>
         /// Creates the xml representation for the <see cref="IContent"/> object
diff --git a/src/Umbraco.Core/Models/ContentType.cs b/src/Umbraco.Core/Models/ContentType.cs
index 13bd19cec6..9d747e4c55 100644
--- a/src/Umbraco.Core/Models/ContentType.cs
+++ b/src/Umbraco.Core/Models/ContentType.cs
@@ -7,7 +7,7 @@ using System.Runtime.Serialization;
 namespace Umbraco.Core.Models
 {
     /// <summary>
-    /// Represents the contnet type that a <see cref="Content"/> object is based on
+    /// Represents the content type that a <see cref="Content"/> object is based on
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
@@ -81,6 +81,24 @@ namespace Umbraco.Core.Models
             }
         }
 
+        /// <summary>
+        /// Removes a template from the list of allowed templates
+        /// </summary>
+        /// <param name="template"><see cref="ITemplate"/> to remove</param>
+        /// <returns>True if template was removed, otherwise False</returns>
+        public bool RemoveTemplate(ITemplate template)
+        {
+            if (DefaultTemplateId == template.Id)
+                DefaultTemplateId = default(int);
+
+            var templates = AllowedTemplates.ToList();
+            var remove = templates.FirstOrDefault(x => x.Id == template.Id);
+            var result = templates.Remove(remove);
+            AllowedTemplates = templates;
+
+            return result;
+        }
+
         /// <summary>
         /// Indicates whether a specific property on the current <see cref="IContent"/> entity is dirty.
         /// </summary>
diff --git a/src/Umbraco.Core/Models/ContentTypeBase.cs b/src/Umbraco.Core/Models/ContentTypeBase.cs
index d44b132832..6b01f5b27a 100644
--- a/src/Umbraco.Core/Models/ContentTypeBase.cs
+++ b/src/Umbraco.Core/Models/ContentTypeBase.cs
@@ -149,7 +149,7 @@ namespace Umbraco.Core.Models
             get { return _alias; }
             set
             {
-                _alias = value;
+                _alias = value.ToUmbracoAlias(StringAliasCaseType.CamelCase, true);
                 OnPropertyChanged(AliasSelector);
             }
         }
diff --git a/src/Umbraco.Core/Models/IContent.cs b/src/Umbraco.Core/Models/IContent.cs
index 2d88a56cc0..6583184d76 100644
--- a/src/Umbraco.Core/Models/IContent.cs
+++ b/src/Umbraco.Core/Models/IContent.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Models
 {
diff --git a/src/Umbraco.Core/Models/IContentType.cs b/src/Umbraco.Core/Models/IContentType.cs
index 5e89279755..3e61b98510 100644
--- a/src/Umbraco.Core/Models/IContentType.cs
+++ b/src/Umbraco.Core/Models/IContentType.cs
@@ -22,5 +22,12 @@ namespace Umbraco.Core.Models
         /// </summary>
         /// <param name="template">Default <see cref="ITemplate"/></param>
         void SetDefaultTemplate(ITemplate template);
+
+        /// <summary>
+        /// Removes a template from the list of allowed templates
+        /// </summary>
+        /// <param name="template"><see cref="ITemplate"/> to remove</param>
+        /// <returns>True if template was removed, otherwise False</returns>
+        bool RemoveTemplate(ITemplate template);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Models/Rdbms/PropertyDataDto.cs b/src/Umbraco.Core/Models/Rdbms/PropertyDataDto.cs
index f125c6eaf3..4b50d835fe 100644
--- a/src/Umbraco.Core/Models/Rdbms/PropertyDataDto.cs
+++ b/src/Umbraco.Core/Models/Rdbms/PropertyDataDto.cs
@@ -75,7 +75,7 @@ namespace Umbraco.Core.Models.Rdbms
                     return Text;
                 }
 
-                return null;
+                return string.Empty;
             }
         }
     }
diff --git a/src/Umbraco.Core/Persistence/Factories/PropertyFactory.cs b/src/Umbraco.Core/Persistence/Factories/PropertyFactory.cs
index 93d137d1b1..789646df2d 100644
--- a/src/Umbraco.Core/Persistence/Factories/PropertyFactory.cs
+++ b/src/Umbraco.Core/Persistence/Factories/PropertyFactory.cs
@@ -54,11 +54,11 @@ namespace Umbraco.Core.Persistence.Factories
                 if (property.HasIdentity)
                     dto.Id = property.Id;
 
-                if (property.DataTypeDatabaseType == DataTypeDatabaseType.Integer && property.Value != null)
+                if (property.DataTypeDatabaseType == DataTypeDatabaseType.Integer && property.Value != null && string.IsNullOrWhiteSpace(property.Value.ToString()) == false)
                 {
                     dto.Integer = int.Parse(property.Value.ToString());
                 }
-                else if (property.DataTypeDatabaseType == DataTypeDatabaseType.Date && property.Value != null)
+                else if (property.DataTypeDatabaseType == DataTypeDatabaseType.Date && property.Value != null && string.IsNullOrWhiteSpace(property.Value.ToString()) == false)
                 {
                     dto.Date = DateTime.Parse(property.Value.ToString());
                 }
diff --git a/src/Umbraco.Core/Persistence/Mappers/ModelDtoMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ModelDtoMapper.cs
index c44512a6fb..acfffc8971 100644
--- a/src/Umbraco.Core/Persistence/Mappers/ModelDtoMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/ModelDtoMapper.cs
@@ -2,6 +2,8 @@
 using System.Reflection;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Mappers
 {
@@ -15,6 +17,21 @@ namespace Umbraco.Core.Persistence.Mappers
 
         public bool MapPropertyToColumn(Type t, PropertyInfo pi, ref string columnName, ref bool resultColumn)
         {
+            if (t == typeof (PropertyDataDto))
+            {
+                var tableNameAttribute = t.FirstAttribute<TableNameAttribute>();
+                var columnAttribute = pi.FirstAttribute<ColumnAttribute>();
+
+                if (tableNameAttribute != null && columnAttribute != null && string.IsNullOrEmpty(columnAttribute.Name) == false)
+                {
+                    columnName = string.Format("{0}.{1}",
+                                               SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(
+                                                   tableNameAttribute.Value),
+                                               SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(columnAttribute.Name));
+                }
+                return true;
+            }
+
             if (t == typeof(Content) || t == typeof(IContent))
             {
                 var mappedName = ContentMapper.Instance.Map(pi.Name);
@@ -125,6 +142,16 @@ namespace Umbraco.Core.Persistence.Mappers
                 return true;
             }
 
+            if (t == typeof(Property))
+            {
+                var mappedName = PropertyMapper.Instance.Map(pi.Name);
+                if (!string.IsNullOrEmpty(mappedName))
+                {
+                    columnName = mappedName;
+                }
+                return true;
+            }
+
             if (t == typeof(PropertyType))
             {
                 var mappedName = PropertyTypeMapper.Instance.Map(pi.Name);
@@ -155,6 +182,19 @@ namespace Umbraco.Core.Persistence.Mappers
 
         public Func<object, object> GetToDbConverter(Type sourceType)
         {
+            //We need this check to ensure that PetaPoco doesn't try to insert an invalid date from a nullable DateTime property
+            if (sourceType == typeof (DateTime))
+            {
+                return datetimeVal =>
+                           {
+                               var datetime = datetimeVal as DateTime?;
+                               if(datetime.HasValue && datetime.Value > DateTime.MinValue)
+                                   return datetime.Value;
+
+                               return null;
+                           };
+            }
+
             return null;
         }
     }
diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs
new file mode 100644
index 0000000000..795e5a9216
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    internal sealed class PropertyMapper : BaseMapper
+    {
+        private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCache = new ConcurrentDictionary<string, DtoMapModel>();
+
+        internal static PropertyMapper Instance = new PropertyMapper();
+
+        private PropertyMapper()
+        {
+            BuildMap();
+        }
+
+        #region Overrides of BaseMapper
+
+        internal override void BuildMap()
+        {
+            CacheMap<Property, PropertyDataDto>(src => src.Id, dto => dto.Id);
+            CacheMap<Property, PropertyDataDto>(src => src.Version, dto => dto.VersionId);
+            CacheMap<Property, PropertyDataDto>(src => src.PropertyTypeId, dto => dto.PropertyTypeId);
+        }
+
+        internal override string Map(string propertyName)
+        {
+            if (!PropertyInfoCache.ContainsKey(propertyName))
+                return string.Empty;
+
+            var dtoTypeProperty = PropertyInfoCache[propertyName];
+
+            return base.GetColumnName(dtoTypeProperty.Type, dtoTypeProperty.PropertyInfo);
+        }
+
+        internal override void CacheMap<TSource, TDestination>(Expression<Func<TSource, object>> sourceMember, Expression<Func<TDestination, object>> destinationMember)
+        {
+            var property = base.ResolveMapping(sourceMember, destinationMember);
+            PropertyInfoCache.AddOrUpdate(property.SourcePropertyName, property, (x, y) => property);
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/PetaPoco.cs b/src/Umbraco.Core/Persistence/PetaPoco.cs
index e825bf78a9..ae0eb39ec9 100644
--- a/src/Umbraco.Core/Persistence/PetaPoco.cs
+++ b/src/Umbraco.Core/Persistence/PetaPoco.cs
@@ -13,6 +13,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security;
+using System.Security.Permissions;
 using System.Text;
 using System.Configuration;
 using System.Data.Common;
@@ -936,7 +938,7 @@ namespace Umbraco.Core.Persistence
 
 
 		// Instance data used by the Multipoco factory delegate - essentially a list of the nested poco factories to call
-		class MultiPocoFactory
+		public class MultiPocoFactory
 		{
 
 			public MultiPocoFactory(IEnumerable<Delegate> dels)
@@ -2324,6 +2326,7 @@ namespace Umbraco.Core.Persistence
 
 		public SqlJoinClause InnerJoin(string table) { return Join("INNER JOIN ", table); }
 		public SqlJoinClause LeftJoin(string table) { return Join("LEFT JOIN ", table); }
+        public SqlJoinClause LeftOuterJoin(string table) { return Join("LEFT OUTER JOIN ", table); }
         public SqlJoinClause RightJoin(string table) { return Join("RIGHT JOIN ", table); }
 
 		public class SqlJoinClause
diff --git a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs
index 8243e47de5..3e8d562d07 100644
--- a/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs
+++ b/src/Umbraco.Core/Persistence/PetaPocoExtensions.cs
@@ -129,6 +129,11 @@ namespace Umbraco.Core.Persistence
             return SyntaxConfig.SqlSyntaxProvider.DoesTableExist(db, tableName);
         }
 
+        public static bool TableExist(this UmbracoDatabase db, string tableName)
+        {
+            return SyntaxConfig.SqlSyntaxProvider.DoesTableExist(db, tableName);
+        }
+
         public static void CreateDatabaseSchema(this Database db)
         {
             NewTable += PetaPocoExtensions_NewTable;
diff --git a/src/Umbraco.Core/Persistence/PetaPocoSqlExtensions.cs b/src/Umbraco.Core/Persistence/PetaPocoSqlExtensions.cs
index 71e6d0c1bd..f38392fcc4 100644
--- a/src/Umbraco.Core/Persistence/PetaPocoSqlExtensions.cs
+++ b/src/Umbraco.Core/Persistence/PetaPocoSqlExtensions.cs
@@ -86,6 +86,15 @@ namespace Umbraco.Core.Persistence
             return sql.LeftJoin(SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName));
         }
 
+        public static Sql.SqlJoinClause LeftOuterJoin<T>(this Sql sql)
+        {
+            var type = typeof(T);
+            var tableNameAttribute = type.FirstAttribute<TableNameAttribute>();
+            string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
+
+            return sql.LeftOuterJoin(SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName));
+        }
+
         public static Sql.SqlJoinClause RightJoin<T>(this Sql sql)
         {
             var type = typeof (T);
diff --git a/src/Umbraco.Core/Persistence/Querying/ExpressionHelper.cs b/src/Umbraco.Core/Persistence/Querying/ExpressionHelper.cs
index 72e785e8b3..48d9731149 100644
--- a/src/Umbraco.Core/Persistence/Querying/ExpressionHelper.cs
+++ b/src/Umbraco.Core/Persistence/Querying/ExpressionHelper.cs
@@ -21,7 +21,7 @@ namespace Umbraco.Core.Persistence.Querying
         IList<string> updateFields = new List<string>();
         IList<string> insertFields = new List<string>();
 
-        private string sep = string.Empty;
+        private string sep = " ";
         private bool useFieldName = false;
         private Database.PocoData pd;
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
index 90c80f2f63..84bf8cb115 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
@@ -260,7 +260,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override void PersistUpdatedItem(IContent entity)
         {
-            //A new version should only be created if published state has changed
+            //A new version should only be created if published state (or language) has changed
             bool shouldCreateNewVersion = ((ICanBeDirty)entity).IsPropertyDirty("Published") || ((ICanBeDirty)entity).IsPropertyDirty("Language");
             if (shouldCreateNewVersion)
             {
@@ -298,7 +298,7 @@ namespace Umbraco.Core.Persistence.Repositories
             }
 
             //If Published state has changed then previous versions should have their publish state reset
-            if (shouldCreateNewVersion && entity.Published)
+            if (((ICanBeDirty)entity).IsPropertyDirty("Published") && entity.Published)
             {
                 var publishedDocs = Database.Fetch<DocumentDto>("WHERE nodeId = @Id AND published = @IsPublished", new { Id = entity.Id, IsPublished = true });
                 foreach (var doc in publishedDocs)
@@ -374,7 +374,7 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();
             var uploadFieldId = new Guid("5032a6e6-69e3-491d-bb28-cd31cd11086c");
-            //Loop through properties to check if the content contains media that should be deleted
+            //Loop through properties to check if the content contains images/files that should be deleted
             foreach (var property in entity.Properties)
             {
                 if (property.PropertyType.DataTypeControlId == uploadFieldId &&
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
index bb73c7c7d3..299b2e2e0a 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
@@ -91,11 +91,11 @@ namespace Umbraco.Core.Persistence.Repositories
             var translator = new SqlTranslator<IContentType>(sqlClause, query);
             var sql = translator.Translate();
 
-            var documentTypeDtos = Database.Fetch<DocumentTypeDto, ContentTypeDto, NodeDto>(sql);
+            var dtos = Database.Fetch<DocumentTypeDto, ContentTypeDto, NodeDto>(sql);
 
-            foreach (var dto in documentTypeDtos)
+            foreach (var dto in dtos.DistinctBy(x => x.ContentTypeDto.NodeId))
             {
-                yield return Get(dto.ContentTypeNodeId);
+                yield return Get(dto.ContentTypeDto.NodeId);
             }
         }
 
@@ -138,6 +138,7 @@ namespace Umbraco.Core.Persistence.Repositories
                                string.Format("DELETE FROM umbracoUser2NodePermission WHERE nodeId = @Id"),
                                string.Format("DELETE FROM cmsTagRelationship WHERE nodeId = @Id"),
                                string.Format("DELETE FROM cmsContentTypeAllowedContentType WHERE Id = @Id"),
+                               string.Format("DELETE FROM cmsContentTypeAllowedContentType WHERE AllowedId = @Id"),
                                string.Format("DELETE FROM cmsContentType2ContentType WHERE parentContentTypeId = @Id"),
                                string.Format("DELETE FROM cmsContentType2ContentType WHERE childContentTypeId = @Id"),
                                string.Format("DELETE FROM cmsPropertyType WHERE contentTypeId = @Id"),
@@ -185,6 +186,13 @@ namespace Umbraco.Core.Persistence.Repositories
             //Updates Modified date
             ((ContentType)entity).UpdatingEntity();
 
+            //Look up parent to get and set the correct Path if ParentId has changed
+            if (((ICanBeDirty)entity).IsPropertyDirty("ParentId"))
+            {
+                var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
+                entity.Path = string.Concat(parent.Path, ",", entity.Id);
+            }
+
             var factory = new ContentTypeFactory(NodeObjectTypeId);
             var dto = factory.BuildDto(entity);
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
index ff42b191a7..83e57db965 100644
--- a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
@@ -153,6 +153,13 @@ namespace Umbraco.Core.Persistence.Repositories
             //Updates Modified date and Version Guid
             ((DataTypeDefinition)entity).UpdatingEntity();
 
+            //Look up parent to get and set the correct Path if ParentId has changed
+            if (((ICanBeDirty)entity).IsPropertyDirty("ParentId"))
+            {
+                var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
+                entity.Path = string.Concat(parent.Path, ",", entity.Id);
+            }
+
             var factory = new DataTypeDefinitionFactory(NodeObjectTypeId);
             //Look up DataTypeDefinition entry to get Primary for updating the DTO
             var dataTypeDto = Database.SingleOrDefault<DataTypeDto>("WHERE nodeId = @Id", new { Id = entity.Id });
diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs
index 70726b7671..d63360031d 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.IO;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Rdbms;
@@ -234,6 +236,13 @@ namespace Umbraco.Core.Persistence.Repositories
             //Updates Modified date
             ((Models.Media)entity).UpdatingEntity();
 
+            //Look up parent to get and set the correct Path if ParentId has changed
+            if (((ICanBeDirty)entity).IsPropertyDirty("ParentId"))
+            {
+                var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
+                entity.Path = string.Concat(parent.Path, ",", entity.Id);
+            }
+
             var factory = new MediaFactory(NodeObjectTypeId, entity.Id);
             //Look up Content entry to get Primary for updating the DTO
             var contentDto = Database.SingleOrDefault<ContentDto>("WHERE nodeId = @Id", new { Id = entity.Id });
@@ -287,6 +296,36 @@ namespace Umbraco.Core.Persistence.Repositories
             ((ICanBeDirty)entity).ResetDirtyProperties();
         }
 
+        protected override void PersistDeletedItem(IMedia entity)
+        {
+            var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();
+            var uploadFieldId = new Guid("5032a6e6-69e3-491d-bb28-cd31cd11086c");
+            //Loop through properties to check if the media item contains images/file that should be deleted
+            foreach (var property in entity.Properties)
+            {
+                if (property.PropertyType.DataTypeControlId == uploadFieldId &&
+                    string.IsNullOrEmpty(property.Value.ToString()) == false
+                    && fs.FileExists(IOHelper.MapPath(property.Value.ToString())))
+                {
+                    var relativeFilePath = fs.GetRelativePath(property.Value.ToString());
+                    var parentDirectory = System.IO.Path.GetDirectoryName(relativeFilePath);
+
+                    // don't want to delete the media folder if not using directories.
+                    if (UmbracoSettings.UploadAllowDirectories && parentDirectory != fs.GetRelativePath("/"))
+                    {
+                        //issue U4-771: if there is a parent directory the recursive parameter should be true
+                        fs.DeleteDirectory(parentDirectory, String.IsNullOrEmpty(parentDirectory) == false);
+                    }
+                    else
+                    {
+                        fs.DeleteFile(relativeFilePath, true);
+                    }
+                }
+            }
+
+            base.PersistDeletedItem(entity);
+        }
+
         #endregion
 
         private PropertyCollection GetPropertyCollection(int id, Guid versionId, IMediaType contentType)
diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
index 51705e1adf..17035d725d 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
@@ -124,6 +124,7 @@ namespace Umbraco.Core.Persistence.Repositories
                                string.Format("DELETE FROM umbracoUser2NodePermission WHERE nodeId = @Id"),
                                string.Format("DELETE FROM cmsTagRelationship WHERE nodeId = @Id"),
                                string.Format("DELETE FROM cmsContentTypeAllowedContentType WHERE Id = @Id"),
+                               string.Format("DELETE FROM cmsContentTypeAllowedContentType WHERE AllowedId = @Id"),
                                string.Format("DELETE FROM cmsContentType2ContentType WHERE parentContentTypeId = @Id"),
                                string.Format("DELETE FROM cmsContentType2ContentType WHERE childContentTypeId = @Id"),
                                string.Format("DELETE FROM cmsPropertyType WHERE contentTypeId = @Id"),
@@ -160,6 +161,13 @@ namespace Umbraco.Core.Persistence.Repositories
             //Updates Modified date
             ((MediaType)entity).UpdatingEntity();
 
+            //Look up parent to get and set the correct Path if ParentId has changed
+            if (((ICanBeDirty)entity).IsPropertyDirty("ParentId"))
+            {
+                var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
+                entity.Path = string.Concat(parent.Path, ",", entity.Id);
+            }
+
             var factory = new MediaTypeFactory(NodeObjectTypeId);
             var dto = factory.BuildDto(entity);
             
diff --git a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs
index ec42e6dee2..3b2d8e753f 100644
--- a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs
@@ -125,7 +125,7 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             entity.AddingEntity();
 
-            var factory = new RelationFactory(null);
+            var factory = new RelationFactory(entity.RelationType);
             var dto = factory.BuildDto(entity);
 
             var id = Convert.ToInt32(Database.Insert(dto));
@@ -138,7 +138,7 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             entity.UpdatingEntity();
 
-            var factory = new RelationFactory(null);
+            var factory = new RelationFactory(entity.RelationType);
             var dto = factory.BuildDto(entity);
             Database.Update(dto);
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
index 47d2b60c95..88565f29e9 100644
--- a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
@@ -226,6 +226,13 @@ namespace Umbraco.Core.Persistence.Repositories
                 }
             }
 
+            //Look up parent to get and set the correct Path if ParentId has changed
+            if (((ICanBeDirty)entity).IsPropertyDirty("ParentId"))
+            {
+                var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = ((Template)entity).ParentId });
+                entity.Path = string.Concat(parent.Path, ",", entity.Id);
+            }
+
             //Get TemplateDto from db to get the Primary key of the entity
             var templateDto = Database.SingleOrDefault<TemplateDto>("WHERE nodeId = @Id", new { Id = entity.Id });
             //Save updated entity to db
diff --git a/src/Umbraco.Core/Properties/AssemblyInfo.cs b/src/Umbraco.Core/Properties/AssemblyInfo.cs
index c05f9e4a60..2c428fab52 100644
--- a/src/Umbraco.Core/Properties/AssemblyInfo.cs
+++ b/src/Umbraco.Core/Properties/AssemblyInfo.cs
@@ -1,6 +1,8 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.Permissions;
 
 // General Information about an assembly is controlled through the following 
 // set of attributes. Change these attribute values to modify the information
@@ -18,7 +20,9 @@ using System.Runtime.InteropServices;
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("130a6b5c-50e7-4df3-a0dd-e9e7eb0b7c5c")]
 
-//[assembly: System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]
+//[assembly: SecurityRules(SecurityRuleSet.Level2, SkipVerificationInFullTrust = true)]
+//[assembly: AllowPartiallyTrustedCallers]
+//[assembly: SecurityTransparent]
 
 [assembly: InternalsVisibleTo("umbraco")]
 [assembly: InternalsVisibleTo("Umbraco.Tests")]
diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs
index af61a4891f..61cdd4bf45 100644
--- a/src/Umbraco.Core/Services/ContentService.cs
+++ b/src/Umbraco.Core/Services/ContentService.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
@@ -354,6 +353,24 @@ namespace Umbraco.Core.Services
             }
         }
 
+        /// <summary>
+        /// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
+        /// <returns>True if the Content can be published, otherwise False</returns>
+        public bool IsPublishable(IContent content)
+        {
+            //If the passed in content has yet to be saved we "fallback" to checking the Parent
+            //because if the Parent is publishable then the current content can be Saved and Published
+            if (content.HasIdentity == false)
+            {
+                IContent parent = GetById(content.ParentId);
+                return IsPublishable(parent, true);
+            }
+
+            return IsPublishable(content, false);
+        }
+
 	    /// <summary>
 	    /// Re-Publishes all Content
 	    /// </summary>
@@ -442,11 +459,11 @@ namespace Umbraco.Core.Services
             //TODO Refactor this so omitCacheRefresh isn't exposed in the public method, but only in an internal one as its purely there for legacy reasons.
 
 	        //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-	        if (content.ParentId != -1 && content.ParentId != -20 && HasPublishedVersion(content.ParentId) == false)
+	        if (content.ParentId != -1 && content.ParentId != -20 && IsPublishable(content) == false)
 	        {
 	            LogHelper.Info<ContentService>(
 	                string.Format(
-	                    "Content '{0}' with Id '{1}' could not be published because its parent is not published.",
+	                    "Content '{0}' with Id '{1}' could not be published because its parent or one of its ancestors is not published.",
 	                    content.Name, content.Id));
 	            return false;
 	        }
@@ -518,17 +535,7 @@ namespace Umbraco.Core.Services
 	    {
             //TODO Refactor this so omitCacheRefresh isn't exposed in the public method, but only in an internal one as its purely there for legacy reasons.
 
-	        //Look for children and unpublish them if any exists, otherwise just unpublish the passed in Content.
-	        var children = GetChildrenDeep(content.Id);
-	        var hasChildren = children.Any();
-
-	        if (hasChildren)
-	            children.Add(content);
-
-	        var unpublished = hasChildren
-	                              ? _publishingStrategy.UnPublish(children, userId)
-	                              : _publishingStrategy.UnPublish(content, userId);
-
+	        var unpublished = _publishingStrategy.UnPublish(content, userId);
 	        if (unpublished)
 	        {
 	            var uow = _uowProvider.GetUnitOfWork();
@@ -536,24 +543,8 @@ namespace Umbraco.Core.Services
 	            {
 	                repository.AddOrUpdate(content);
 
-	                if (hasChildren)
-	                {
-	                    foreach (var child in children)
-	                    {
-	                        SetWriter(child, userId);
-	                        repository.AddOrUpdate(child);
-	                    }
-	                }
-
-	                //Remove 'published' xml from the cmsContentXml table for the unpublished content and its (possible) children
+	                //Remove 'published' xml from the cmsContentXml table for the unpublished content
 	                uow.Database.Delete<ContentXmlDto>("WHERE nodeId = @Id", new {Id = content.Id});
-	                if (hasChildren)
-	                {
-	                    foreach (var child in children)
-	                    {
-	                        uow.Database.Delete<ContentXmlDto>("WHERE nodeId = @Id", new {Id = child.Id});
-	                    }
-	                }
 
                     uow.Commit();
 	            }
@@ -581,7 +572,7 @@ namespace Umbraco.Core.Services
 				return false;
 
 			//Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-			if (content.ParentId != -1 && content.ParentId != -20 && HasPublishedVersion(content.ParentId) == false)
+            if (content.ParentId != -1 && content.ParentId != -20 && IsPublishable(content) == false)
 			{
 				LogHelper.Info<ContentService>(
 					string.Format(
@@ -616,22 +607,30 @@ namespace Umbraco.Core.Services
 				{
 					var xml = content.ToXml();
 					var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToString(SaveOptions.None) };
-					var exists =
-						uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = content.Id }) !=
-						null;
+				    var exists = uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new {Id = content.Id}) != null;
 					int result = exists
 									 ? uow.Database.Update(poco)
 									 : Convert.ToInt32(uow.Database.Insert(poco));
 				}
 			}
 
+            Saved.RaiseEvent(new SaveEventArgs<IContent>(content, false), this);
+
 			//Save xml to db and call following method to fire event through PublishingStrategy to update cache
 			if (omitCacheRefresh == false)
 				_publishingStrategy.PublishingFinalized(content);
+            
+            //We need to check if children and their publish state to ensure that we republish content that was previously published
+	        if (HasChildren(content.Id))
+	        {
+	            var children = GetChildrenDeep(content.Id);
+	            var shouldBeRepublished = children.Where(child => HasPublishedVersion(child.Id));
 
-			Saved.RaiseEvent(new SaveEventArgs<IContent>(content, false), this);
+	            if (omitCacheRefresh == false)
+	                _publishingStrategy.PublishingFinalized(shouldBeRepublished, false);
+	        }
 
-			Audit.Add(AuditTypes.Publish, "Save and Publish performed by user", userId == -1 ? 0 : userId, content.Id);
+	        Audit.Add(AuditTypes.Publish, "Save and Publish performed by user", userId == -1 ? 0 : userId, content.Id);
 
 			return published;
 	    }
@@ -687,7 +686,6 @@ namespace Umbraco.Core.Services
 				{
 					foreach (var content in contents)
 					{
-
 						SetWriter(content, userId);
 
 						//Only change the publish state if the "previous" version was actually published
@@ -978,10 +976,13 @@ namespace Umbraco.Core.Services
         /// <param name="userId">Optional Id of the User copying the Content</param>
         /// <returns>The newly created <see cref="IContent"/> object</returns>
         public IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = -1)
-		{
+        {
 			var copy = ((Content)content).Clone();
 			copy.ParentId = parentId;
-			copy.Name = copy.Name + " (1)";
+
+            // A copy should never be set to published
+            // automatically even if the original was
+            this.UnPublish(copy);
 
 			if (Copying.IsRaisedEventCancelled(new CopyEventArgs<IContent>(content, copy, parentId), this))
 				return null;
@@ -990,7 +991,7 @@ namespace Umbraco.Core.Services
 			using (var repository = _repositoryFactory.CreateContentRepository(uow))
 			{
 				SetWriter(content, userId);
-
+			    
 				repository.AddOrUpdate(copy);
 				uow.Commit();
 
@@ -1101,7 +1102,6 @@ namespace Umbraco.Core.Services
 	    /// <returns>The newly created <see cref="IContent"/> object</returns>
 	    public IContent Rollback(int id, Guid versionId, int userId = -1)
 	    {
-	        
 	        var content = GetByVersion(versionId);
 
 			if (RollingBack.IsRaisedEventCancelled(new RollbackEventArgs<IContent>(content), this))
@@ -1148,7 +1148,7 @@ namespace Umbraco.Core.Services
         /// </remarks>
         /// <param name="parentId">Id of the parent to retrieve children from</param>
         /// <returns>A list of valid <see cref="IContent"/> that can be published</returns>
-        private List<IContent> GetChildrenDeep(int parentId)
+        private IEnumerable<IContent> GetChildrenDeep(int parentId)
         {
             var list = new List<IContent>();
             var children = GetChildren(parentId);
@@ -1163,6 +1163,40 @@ namespace Umbraco.Core.Services
             return list;
         }
 
+        /// <summary>
+        /// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
+        /// </summary>
+        /// <remarks>
+        /// Check current is only used when falling back to checking the Parent of non-saved content, as
+        /// non-saved content doesn't have a valid path yet.
+        /// </remarks>
+        /// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
+        /// <param name="checkCurrent">Boolean indicating whether the passed in content should also be checked for published versions</param>
+        /// <returns>True if the Content can be published, otherwise False</returns>
+        private bool IsPublishable(IContent content, bool checkCurrent)
+        {
+            var ids = content.Path.Split(',').Select(int.Parse).ToList();
+            foreach (var id in ids)
+            {
+                //If Id equals that of the recycle bin we return false because nothing in the bin can be published
+                if (id == -20)
+                    return false;
+
+                //We don't check the System Root, so just continue
+                if (id == -1) continue;
+
+                //If the current id equals that of the passed in content and if current shouldn't be checked we skip it.
+                if (checkCurrent == false && id == content.Id) continue;
+
+                //Check if the content for the current id is published - escape the loop if we encounter content that isn't published
+                var hasPublishedVersion = ApplicationContext.Current.Services.ContentService.GetById(id).Published;
+                if (hasPublishedVersion == false)
+                    return false;
+            }
+
+            return true;
+        }
+
 		/// <summary>
 		/// Updates a content object with the User (id), who created the content.
 		/// </summary>
diff --git a/src/Umbraco.Core/Services/ContentTypeService.cs b/src/Umbraco.Core/Services/ContentTypeService.cs
index 5ecf8b05f8..bae66f95a5 100644
--- a/src/Umbraco.Core/Services/ContentTypeService.cs
+++ b/src/Umbraco.Core/Services/ContentTypeService.cs
@@ -109,6 +109,21 @@ namespace Umbraco.Core.Services
             }
         }
 
+        /// <summary>
+        /// Checks whether an <see cref="IContentType"/> item has any children
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContentType"/></param>
+        /// <returns>True if the content type has any children otherwise False</returns>
+        public bool HasChildren(int id)
+        {
+            using (var repository = _repositoryFactory.CreateContentTypeRepository(_uowProvider.GetUnitOfWork()))
+            {
+                var query = Query<IContentType>.Builder.Where(x => x.ParentId == id);
+                int count = repository.Count(query);
+                return count > 0;
+            }
+        }
+
         /// <summary>
         /// Saves a single <see cref="IContentType"/> object
         /// </summary>
@@ -278,6 +293,21 @@ namespace Umbraco.Core.Services
             }
         }
 
+        /// <summary>
+        /// Checks whether an <see cref="IMediaType"/> item has any children
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IMediaType"/></param>
+        /// <returns>True if the media type has any children otherwise False</returns>
+        public bool MediaTypeHasChildren(int id)
+        {
+            using (var repository = _repositoryFactory.CreateMediaTypeRepository(_uowProvider.GetUnitOfWork()))
+            {
+                var query = Query<IMediaType>.Builder.Where(x => x.ParentId == id);
+                int count = repository.Count(query);
+                return count > 0;
+            }
+        }
+
         /// <summary>
         /// Saves a single <see cref="IMediaType"/> object
         /// </summary>
diff --git a/src/Umbraco.Core/Services/FileService.cs b/src/Umbraco.Core/Services/FileService.cs
index 11d21dbd9f..4130da307a 100644
--- a/src/Umbraco.Core/Services/FileService.cs
+++ b/src/Umbraco.Core/Services/FileService.cs
@@ -213,7 +213,7 @@ namespace Umbraco.Core.Services
         /// </summary>
         /// <param name="alias">Alias of the template</param>
         /// <returns>A <see cref="Template"/> object</returns>
-        public ITemplate GetTemplateByAlias(string alias)
+        public ITemplate GetTemplate(string alias)
         {
             using (var repository = _repositoryFactory.CreateTemplateRepository(_dataUowProvider.GetUnitOfWork()))
             {
@@ -221,6 +221,19 @@ namespace Umbraco.Core.Services
             }
         }
 
+        /// <summary>
+        /// Gets a <see cref="ITemplate"/> object by its alias
+        /// </summary>
+        /// <param name="id">Id of the template</param>
+        /// <returns>A <see cref="ITemplate"/> object</returns>
+        public ITemplate GetTemplate(int id)
+        {
+            using (var repository = _repositoryFactory.CreateTemplateRepository(_dataUowProvider.GetUnitOfWork()))
+            {
+                return repository.Get(id);
+            }
+        }
+
         /// <summary>
         /// Saves a <see cref="Template"/>
         /// </summary>
diff --git a/src/Umbraco.Core/Services/IContentService.cs b/src/Umbraco.Core/Services/IContentService.cs
index 4836f25736..4e4a400b51 100644
--- a/src/Umbraco.Core/Services/IContentService.cs
+++ b/src/Umbraco.Core/Services/IContentService.cs
@@ -270,5 +270,12 @@ namespace Umbraco.Core.Services
         /// <param name="userId">Optional Id of the User copying the Content</param>
         /// <returns>The newly created <see cref="IContent"/> object</returns>
         IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = -1);
+
+        /// <summary>
+        /// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
+        /// <returns>True if the Content can be published, otherwise False</returns>
+        bool IsPublishable(IContent content);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Services/IContentTypeService.cs b/src/Umbraco.Core/Services/IContentTypeService.cs
index d51eb3a784..f9ee765c9b 100644
--- a/src/Umbraco.Core/Services/IContentTypeService.cs
+++ b/src/Umbraco.Core/Services/IContentTypeService.cs
@@ -136,5 +136,19 @@ namespace Umbraco.Core.Services
         /// </summary>
         /// <returns>The DTD as a string</returns>
         string GetContentTypesDtd();
+
+        /// <summary>
+        /// Checks whether an <see cref="IContentType"/> item has any children
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContentType"/></param>
+        /// <returns>True if the content type has any children otherwise False</returns>
+        bool HasChildren(int id);
+
+        /// <summary>
+        /// Checks whether an <see cref="IMediaType"/> item has any children
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IMediaType"/></param>
+        /// <returns>True if the media type has any children otherwise False</returns>
+        bool MediaTypeHasChildren(int id);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Services/IFileService.cs b/src/Umbraco.Core/Services/IFileService.cs
index 58839f7673..8793987ca6 100644
--- a/src/Umbraco.Core/Services/IFileService.cs
+++ b/src/Umbraco.Core/Services/IFileService.cs
@@ -87,7 +87,14 @@ namespace Umbraco.Core.Services
         /// </summary>
         /// <param name="alias">Alias of the template</param>
         /// <returns>A <see cref="ITemplate"/> object</returns>
-        ITemplate GetTemplateByAlias(string alias);
+        ITemplate GetTemplate(string alias);
+
+        /// <summary>
+        /// Gets a <see cref="ITemplate"/> object by its alias
+        /// </summary>
+        /// <param name="id">Id of the template</param>
+        /// <returns>A <see cref="ITemplate"/> object</returns>
+        ITemplate GetTemplate(int id);
 
         /// <summary>
         /// Saves a <see cref="ITemplate"/>
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 81351de603..e1b8fbb05c 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -247,6 +247,7 @@
     <Compile Include="Persistence\Mappers\MediaMapper.cs" />
     <Compile Include="Persistence\Mappers\ModelDtoMapper.cs" />
     <Compile Include="Persistence\Mappers\PropertyGroupMapper.cs" />
+    <Compile Include="Persistence\Mappers\PropertyMapper.cs" />
     <Compile Include="Persistence\Mappers\PropertyTypeMapper.cs" />
     <Compile Include="Persistence\Mappers\RelationMapper.cs" />
     <Compile Include="Persistence\Mappers\RelationTypeMapper.cs" />
diff --git a/src/Umbraco.Tests/CodeFirst/Definitions/ContentTypeDefinitionFactory.cs b/src/Umbraco.Tests/CodeFirst/Definitions/ContentTypeDefinitionFactory.cs
index 4b1a00d7ca..eb1d9ee8fd 100644
--- a/src/Umbraco.Tests/CodeFirst/Definitions/ContentTypeDefinitionFactory.cs
+++ b/src/Umbraco.Tests/CodeFirst/Definitions/ContentTypeDefinitionFactory.cs
@@ -318,7 +318,7 @@ namespace Umbraco.Tests.CodeFirst.Definitions
                                ? templateName.Replace(".cshtml", "").Replace(".vbhtml", "")
                                : templateName.Replace(".masterpage", "");
 
-				var template = ApplicationContext.Current.Services.FileService.GetTemplateByAlias(@alias);
+				var template = ApplicationContext.Current.Services.FileService.GetTemplate(@alias);
                 if(template == null)
                 {
                     var name = engine == RenderingEngine.Mvc
diff --git a/src/Umbraco.Tests/Persistence/Querying/ContentRepositorySqlClausesTest.cs b/src/Umbraco.Tests/Persistence/Querying/ContentRepositorySqlClausesTest.cs
index f5a7cf11ca..37a57a6bf6 100644
--- a/src/Umbraco.Tests/Persistence/Querying/ContentRepositorySqlClausesTest.cs
+++ b/src/Umbraco.Tests/Persistence/Querying/ContentRepositorySqlClausesTest.cs
@@ -20,7 +20,7 @@ namespace Umbraco.Tests.Persistence.Querying
                 .InnerJoin("[cmsContentVersion]").On("[cmsDocument].[versionId] = [cmsContentVersion].[VersionId]")
                 .InnerJoin("[cmsContent]").On("[cmsContentVersion].[ContentId] = [cmsContent].[nodeId]")
                 .InnerJoin("[umbracoNode]").On("[cmsContent].[nodeId] = [umbracoNode].[id]")
-                .Where("nodeObjectType='c66ba18e-eaf3-4cff-8a22-41b16d66a972'");
+                .Where("nodeObjectType = 'c66ba18e-eaf3-4cff-8a22-41b16d66a972'");
 
             var sql = new Sql();
             sql.Select("*")
@@ -49,8 +49,8 @@ namespace Umbraco.Tests.Persistence.Querying
                 .InnerJoin("[cmsContentVersion]").On("[cmsDocument].[versionId] = [cmsContentVersion].[VersionId]")
                 .InnerJoin("[cmsContent]").On("[cmsContentVersion].[ContentId] = [cmsContent].[nodeId]")
                 .InnerJoin("[umbracoNode]").On("[cmsContent].[nodeId] = [umbracoNode].[id]")
-                .Where("nodeObjectType='c66ba18e-eaf3-4cff-8a22-41b16d66a972'")
-                .Where("id=1050");
+                .Where("nodeObjectType = 'c66ba18e-eaf3-4cff-8a22-41b16d66a972'")
+                .Where("id = 1050");
 
             var sql = new Sql();
             sql.Select("*")
@@ -81,9 +81,9 @@ namespace Umbraco.Tests.Persistence.Querying
                 .InnerJoin("[cmsContentVersion]").On("[cmsDocument].[versionId] = [cmsContentVersion].[VersionId]")
                 .InnerJoin("[cmsContent]").On("[cmsContentVersion].[ContentId] = [cmsContent].[nodeId]")
                 .InnerJoin("[umbracoNode]").On("[cmsContent].[nodeId] = [umbracoNode].[id]")
-                .Where("nodeObjectType='c66ba18e-eaf3-4cff-8a22-41b16d66a972'")
-                .Where("id=1050")
-                .Where("VersionId='2b543516-a944-4ee6-88c6-8813da7aaa07'")
+                .Where("nodeObjectType = 'c66ba18e-eaf3-4cff-8a22-41b16d66a972'")
+                .Where("id = 1050")
+                .Where("VersionId = '2b543516-a944-4ee6-88c6-8813da7aaa07'")
                 .OrderBy("[cmsContentVersion].[VersionDate] DESC");
 
             var sql = new Sql();
diff --git a/src/Umbraco.Tests/Persistence/Querying/ContentTypeRepositorySqlClausesTest.cs b/src/Umbraco.Tests/Persistence/Querying/ContentTypeRepositorySqlClausesTest.cs
index d9fca798e7..6a72713323 100644
--- a/src/Umbraco.Tests/Persistence/Querying/ContentTypeRepositorySqlClausesTest.cs
+++ b/src/Umbraco.Tests/Persistence/Querying/ContentTypeRepositorySqlClausesTest.cs
@@ -21,8 +21,8 @@ namespace Umbraco.Tests.Persistence.Querying
                 .On("[cmsContentType].[nodeId] = [cmsDocumentType].[contentTypeNodeId]")
                 .InnerJoin("[umbracoNode]")
                 .On("[cmsContentType].[nodeId] = [umbracoNode].[id]")
-                .Where("nodeObjectType='a2cb7800-f571-4787-9638-bc48539a0efb'")
-                .Where("IsDefault='True'");
+                .Where("nodeObjectType = 'a2cb7800-f571-4787-9638-bc48539a0efb'")
+                .Where("IsDefault = 'True'");
 
             var sql = new Sql();
             sql.Select("*")
@@ -51,9 +51,9 @@ namespace Umbraco.Tests.Persistence.Querying
                 .On("[cmsContentType].[nodeId] = [cmsDocumentType].[contentTypeNodeId]")
                 .InnerJoin("[umbracoNode]")
                 .On("[cmsContentType].[nodeId] = [umbracoNode].[id]")
-                .Where("nodeObjectType='a2cb7800-f571-4787-9638-bc48539a0efb'")
-                .Where("IsDefault='True'")
-                .Where("id=1050");
+                .Where("nodeObjectType = 'a2cb7800-f571-4787-9638-bc48539a0efb'")
+                .Where("IsDefault = 'True'")
+                .Where("id = 1050");
 
             var sql = new Sql();
             sql.Select("*")
diff --git a/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs b/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs
index 0e57c019bb..8037e347aa 100644
--- a/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs
+++ b/src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs
@@ -74,7 +74,7 @@ namespace Umbraco.Tests.Persistence.Querying
         public void Can_Use_Where_Predicate()
         {
             var expected = new Sql();
-            expected.Select("*").From("[cmsContent]").Where("nodeId=1045");
+            expected.Select("*").From("[cmsContent]").Where("nodeId = 1045");
 
             var sql = new Sql();
             sql.Select("*").From<ContentDto>().Where<ContentDto>(x => x.NodeId == 1045);
@@ -90,8 +90,8 @@ namespace Umbraco.Tests.Persistence.Querying
             var expected = new Sql();
             expected.Select("*")
                 .From("[cmsContent]")
-                .Where("nodeId=1045")
-                .Where("contentType=1050");
+                .Where("nodeId = 1045")
+                .Where("contentType = 1050");
 
             var sql = new Sql();
             sql.Select("*")
diff --git a/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs b/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs
index 2fc46144c1..46bc9099ac 100644
--- a/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs
+++ b/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs
@@ -48,7 +48,7 @@ namespace Umbraco.Tests.Persistence.Querying
             var result = translator.Translate();
             var strResult = result.SQL;
 
-            string expectedResult = "SELECT *\nFROM umbracoNode\nWHERE ([umbracoNode].[parentID]=-1)";
+            string expectedResult = "SELECT *\nFROM umbracoNode\nWHERE ([umbracoNode].[parentID] = -1)";
 
             // Assert
             Assert.That(strResult, Is.Not.Empty);
@@ -71,7 +71,7 @@ namespace Umbraco.Tests.Persistence.Querying
             var result = translator.Translate();
             var strResult = result.SQL;
 
-            string expectedResult = "SELECT *\nFROM umbracoNode\nWHERE ([cmsContentType].[alias]='umbTextpage')";
+            string expectedResult = "SELECT *\nFROM umbracoNode\nWHERE ([cmsContentType].[alias] = 'umbTextpage')";
 
             // Assert
             Assert.That(strResult, Is.Not.Empty);
diff --git a/src/Umbraco.Tests/Services/ContentServiceTests.cs b/src/Umbraco.Tests/Services/ContentServiceTests.cs
index 39befcf58a..49e29d2324 100644
--- a/src/Umbraco.Tests/Services/ContentServiceTests.cs
+++ b/src/Umbraco.Tests/Services/ContentServiceTests.cs
@@ -308,7 +308,15 @@ namespace Umbraco.Tests.Services
             Assert.That(content.Published, Is.False);
         }
 
-        [Test]
+        /// <summary>
+        /// This test is ignored because the way children are handled when
+        /// parent is unpublished is treated differently now then from when this test
+        /// was written.
+        /// The correct case is now that Root is UnPublished removing the children
+        /// from cache, but still having them "Published" in the "background".
+        /// Once the Parent is Published the Children should re-appear as published.
+        /// </summary>
+        [Test, NUnit.Framework.Ignore]
         public void Can_UnPublish_Root_Content_And_Verify_Children_Is_UnPublished()
         {
             // Arrange
@@ -707,7 +715,27 @@ namespace Umbraco.Tests.Services
             Assert.That(c2.Value.ParentId > 0, Is.True);
         }
 
-		private IEnumerable<IContent> CreateContentHierarchy()
+        [Test]
+        public void Can_Verify_Content_Has_Published_Version()
+        {
+            // Arrange
+            var contentService = ServiceContext.ContentService;
+            var content = contentService.GetById(1046);
+            bool published = contentService.PublishWithChildren(content, 0);
+            var homepage = contentService.GetById(1046);
+            homepage.Name = "Homepage";
+            ServiceContext.ContentService.Save(homepage);
+
+            // Act
+            bool hasPublishedVersion = ServiceContext.ContentService.HasPublishedVersion(1046);
+
+            // Assert
+            Assert.That(published, Is.True);
+            Assert.That(homepage.Published, Is.False);
+            Assert.That(hasPublishedVersion, Is.True);
+        }
+
+        private IEnumerable<IContent> CreateContentHierarchy()
         {
             var contentType = ServiceContext.ContentTypeService.GetContentType("umbTextpage");
             var root = ServiceContext.ContentService.GetById(1046);
diff --git a/src/Umbraco.Web.UI/config/ClientDependency.config b/src/Umbraco.Web.UI/config/ClientDependency.config
index f7fdad504a..d6edcff895 100644
--- a/src/Umbraco.Web.UI/config/ClientDependency.config
+++ b/src/Umbraco.Web.UI/config/ClientDependency.config
@@ -10,14 +10,14 @@ NOTES:
 * Compression/Combination/Minification is not enabled unless debug="false" is specified on the 'compiliation' element in the web.config
 * A new version will invalidate both client and server cache and create new persisted files
 -->
-<clientDependency version="40" fileDependencyExtensions=".js,.css">
+<clientDependency version="41" fileDependencyExtensions=".js,.css">
 
 	<fileRegistration defaultProvider="LoaderControlProvider">
 		<providers>
-			<add name="PageHeaderProvider" type="ClientDependency.Core.FileRegistration.Providers.PageHeaderProvider, ClientDependency.Core"/>
-			<add name="LazyLoadProvider" type="ClientDependency.Core.FileRegistration.Providers.LazyLoadProvider, ClientDependency.Core"/>
-			<add name="LoaderControlProvider" type="ClientDependency.Core.FileRegistration.Providers.LoaderControlProvider, ClientDependency.Core"/>
-			<add name="PlaceHolderProvider" type="ClientDependency.Core.FileRegistration.Providers.PlaceHolderProvider, ClientDependency.Core" enableCompositeFiles="true" javascriptPlaceHolderId="JavaScriptPlaceHolder" cssPlaceHolderId="CssPlaceHolder"/>
+			<add name="PageHeaderProvider" type="ClientDependency.Core.FileRegistration.Providers.PageHeaderProvider, ClientDependency.Core" />
+			<add name="LazyLoadProvider" type="ClientDependency.Core.FileRegistration.Providers.LazyLoadProvider, ClientDependency.Core" />
+			<add name="LoaderControlProvider" type="ClientDependency.Core.FileRegistration.Providers.LoaderControlProvider, ClientDependency.Core" />
+			<add name="PlaceHolderProvider" type="ClientDependency.Core.FileRegistration.Providers.PlaceHolderProvider, ClientDependency.Core" enableCompositeFiles="true" javascriptPlaceHolderId="JavaScriptPlaceHolder" cssPlaceHolderId="CssPlaceHolder" />
 			<!-- Used for loading dependencies in Canvas mode -->
 			<add name="CanvasProvider" type="umbraco.presentation.LiveEditing.CanvasClientDependencyProvider, umbraco" />
 		</providers>
@@ -26,8 +26,8 @@ NOTES:
 	<!-- This section is used for MVC only -->
 	<mvc defaultRenderer="StandardRenderer">
 		<renderers>
-			<add name="StandardRenderer" type="ClientDependency.Core.FileRegistration.Providers.StandardRenderer, ClientDependency.Core"/>
-			<add name="LazyLoadRenderer" type="ClientDependency.Core.FileRegistration.Providers.LazyLoadRenderer, ClientDependency.Core"/>
+			<add name="StandardRenderer" type="ClientDependency.Core.FileRegistration.Providers.StandardRenderer, ClientDependency.Core" />
+			<add name="LazyLoadRenderer" type="ClientDependency.Core.FileRegistration.Providers.LazyLoadRenderer, ClientDependency.Core" />
 		</renderers>
 	</mvc>
 
@@ -41,20 +41,12 @@ NOTES:
     -->
 	<compositeFiles defaultProvider="defaultFileProcessingProvider" compositeFileHandlerPath="~/DependencyHandler.axd">
 		<fileProcessingProviders>
-			<add name="CompositeFileProcessor"
-           type="ClientDependency.Core.CompositeFiles.Providers.CompositeFileProcessingProvider, ClientDependency.Core"
-           enableCssMinify="true"
-           enableJsMinify="true"
-           persistFiles="true"
-           compositeFilePath="~/App_Data/TEMP/ClientDependency"
-           urlType="Base64QueryStrings" />
+			<add name="CompositeFileProcessor" type="ClientDependency.Core.CompositeFiles.Providers.CompositeFileProcessingProvider, ClientDependency.Core" enableCssMinify="true" enableJsMinify="true" persistFiles="true" compositeFilePath="~/App_Data/TEMP/ClientDependency" urlType="Base64QueryStrings" />
 		</fileProcessingProviders>
 
 		<!-- A file map provider stores references to dependency files by an id to be used in the handler URL when using the MappedId Url type -->
 		<fileMapProviders>
-			<add name="XmlFileMap"
-					 type="ClientDependency.Core.CompositeFiles.Providers.XmlFileMapper, ClientDependency.Core"
-					 mapPath="~/App_Data/TEMP/ClientDependency"/>
+			<add name="XmlFileMap" type="ClientDependency.Core.CompositeFiles.Providers.XmlFileMapper, ClientDependency.Core" mapPath="~/App_Data/TEMP/ClientDependency" />
 		</fileMapProviders>
 
 		<!-- 
diff --git a/src/Umbraco.Web.UI/web.Template.Debug.config b/src/Umbraco.Web.UI/web.Template.Debug.config
index 2f4295ef68..b78ea24ed3 100644
--- a/src/Umbraco.Web.UI/web.Template.Debug.config
+++ b/src/Umbraco.Web.UI/web.Template.Debug.config
@@ -19,7 +19,7 @@
   <system.web>
     <compilation debug="true" xdt:Transform="SetAttributes(debug)" />
     <trust level="Medium" xdt:Transform="Remove" />
-    <trust level="Medium" originUrl=".*"  xdt:Transform="Insert" />
+    <trust level="Full" originUrl=".*"  xdt:Transform="Insert" />
   </system.web>
 
   <runtime>
diff --git a/src/Umbraco.Web.UI/web.Template.config b/src/Umbraco.Web.UI/web.Template.config
index 57bbb4ae7c..b845c4f682 100644
--- a/src/Umbraco.Web.UI/web.Template.config
+++ b/src/Umbraco.Web.UI/web.Template.config
@@ -264,7 +264,10 @@
         <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" />
         <bindingRedirect oldVersion="1.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
       </dependentAssembly>
-
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.WebPages.Razor" publicKeyToken="31bf3856ad364e35"/>
+        <bindingRedirect oldVersion="1.0.0.0-2.0.0.0" newVersion="2.0.0.0"/>
+      </dependentAssembly>
     </assemblyBinding>
   </runtime>
 
diff --git a/src/Umbraco.Web/Strategies/UpdateCacheAfterPublish.cs b/src/Umbraco.Web/Strategies/UpdateCacheAfterPublish.cs
new file mode 100644
index 0000000000..c7c91f87eb
--- /dev/null
+++ b/src/Umbraco.Web/Strategies/UpdateCacheAfterPublish.cs
@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Events;
+using Umbraco.Core.Models;
+using Umbraco.Core.Publishing;
+using umbraco;
+using umbraco.cms.businesslogic.web;
+using umbraco.interfaces;
+using umbraco.presentation.cache;
+
+namespace Umbraco.Web.Strategies
+{
+    /// <summary>
+    /// Represents the UpdateCacheAfterPublish class, which subscribes to the Published event
+    /// of the <see cref="PublishingStrategy"/> class and is responsible for doing the actual
+    /// cache refresh after a content item has been published.
+    /// </summary>
+    /// <remarks>
+    /// This implementation is meant as a seperation of the cache refresh from the ContentService
+    /// and PublishingStrategy.
+    /// </remarks>
+    public class UpdateCacheAfterPublish : IApplicationStartupHandler
+    {
+        public UpdateCacheAfterPublish()
+        {
+            PublishingStrategy.Published += PublishingStrategy_Published;
+        }
+
+        void PublishingStrategy_Published(object sender, PublishingEventArgs e)
+        {
+            if (sender is IContent)
+            {
+                var content = sender as IContent;
+                UpdateSingleContentCache(content);
+            }
+            else if (sender is IEnumerable<IContent>)
+            {
+                if (e.IsAllRepublished)
+                {
+                    var content = sender as IEnumerable<IContent>;
+                    UpdateMultipleContentCache(content);
+                }
+                else
+                {
+                    UpdateEntireCache();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Refreshes the xml cache for all nodes
+        /// </summary>
+        private void UpdateEntireCache()
+        {
+            if (UmbracoSettings.UseDistributedCalls)
+            {
+                dispatcher.RefreshAll(new Guid("27ab3022-3dfa-47b6-9119-5945bc88fd66"));
+            }
+            else
+            {
+                content.Instance.RefreshContentFromDatabaseAsync();
+            }
+        }
+
+        /// <summary>
+        /// Refreshes the xml cache for nodes in list
+        /// </summary>
+        private void UpdateMultipleContentCache(IEnumerable<IContent> content)
+        {
+            if (UmbracoSettings.UseDistributedCalls)
+            {
+                foreach (var c in content)
+                {
+                    dispatcher.Refresh(new Guid("27ab3022-3dfa-47b6-9119-5945bc88fd66"), c.Id);
+                }
+            }
+            else
+            {
+                var documents = content.Select(x => new Document(x)).ToList();
+                global::umbraco.content.Instance.UpdateDocumentCache(documents);
+            }
+        }
+
+        /// <summary>
+        /// Refreshes the xml cache for a single node
+        /// </summary>
+        private void UpdateSingleContentCache(IContent content)
+        {
+            if (UmbracoSettings.UseDistributedCalls)
+            {
+                dispatcher.Refresh(new Guid("27ab3022-3dfa-47b6-9119-5945bc88fd66"), content.Id);
+            }
+            else
+            {
+                var doc = new Document(content);
+                global::umbraco.content.Instance.UpdateDocumentCache(doc);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Strategies/UpdateCacheAfterUnPublish.cs b/src/Umbraco.Web/Strategies/UpdateCacheAfterUnPublish.cs
new file mode 100644
index 0000000000..be9bd22839
--- /dev/null
+++ b/src/Umbraco.Web/Strategies/UpdateCacheAfterUnPublish.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Events;
+using Umbraco.Core.Models;
+using Umbraco.Core.Publishing;
+using umbraco;
+using umbraco.interfaces;
+using umbraco.presentation.cache;
+
+namespace Umbraco.Web.Strategies
+{
+    /// <summary>
+    /// Represents the UpdateCacheAfterUnPublish class, which subscribes to the UnPublished event
+    /// of the <see cref="PublishingStrategy"/> class and is responsible for doing the actual
+    /// cache refresh after a content item has been unpublished.
+    /// </summary>
+    /// <remarks>
+    /// This implementation is meant as a seperation of the cache refresh from the ContentService
+    /// and PublishingStrategy.
+    /// </remarks>
+    public class UpdateCacheAfterUnPublish : IApplicationStartupHandler
+    {
+        public UpdateCacheAfterUnPublish()
+        {
+            PublishingStrategy.UnPublished += PublishingStrategy_UnPublished;
+        }
+
+        void PublishingStrategy_UnPublished(object sender, PublishingEventArgs e)
+        {
+            if (sender is IContent)
+            {
+                var content = sender as IContent;
+                UnPublishSingle(content);
+            }
+            else if (sender is IEnumerable<IContent>)
+            {
+                var content = sender as IEnumerable<IContent>;
+                foreach (var c in content)
+                {
+                    UnPublishSingle(c);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Refreshes the xml cache for a single node by removing it
+        /// </summary>
+        private void UnPublishSingle(IContent content)
+        {
+            if (UmbracoSettings.UseDistributedCalls)
+            {
+                dispatcher.Remove(new Guid("27ab3022-3dfa-47b6-9119-5945bc88fd66"), content.Id);
+            }
+            else
+            {
+                global::umbraco.content.Instance.ClearDocumentCache(content.Id);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 39c6467825..dfc4d8334a 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -326,7 +326,9 @@
     <Compile Include="RouteCollectionExtensions.cs" />
     <Compile Include="Routing\LookupByPageIdQuery.cs" />
     <Compile Include="Mvc\SurfaceControllerResolver.cs" />
-    <Compile Include="Strategies\EnsureAppsTreesUpdatedOnUpgrade.cs" />
+    <Compile Include="Strategies\UpdateCacheAfterPublish.cs" />
+    <Compile Include="Strategies\UpdateCacheAfterUnPublish.cs" />
+    <Compile Include="Strategies\EnsureAppsTreesUpdatedOnUpgrade.cs" />    
     <Compile Include="Templates\TemplateRenderer.cs" />
     <Compile Include="Templates\TemplateUtilities.cs" />
     <Compile Include="umbraco.presentation\Default.aspx.cs">
@@ -2182,7 +2184,9 @@
       <CachedSettingsPropName>umbraco_org_umbraco_update_CheckForUpgrade</CachedSettingsPropName>
     </WebReferenceUrl>
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Folder Include="Strategies\" />
+  </ItemGroup>
   <PropertyGroup>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
diff --git a/src/Umbraco.Web/umbraco.presentation/install/steps/Definitions/Database.cs b/src/Umbraco.Web/umbraco.presentation/install/steps/Definitions/Database.cs
index 9293d0e84b..a11e3be5da 100644
--- a/src/Umbraco.Web/umbraco.presentation/install/steps/Definitions/Database.cs
+++ b/src/Umbraco.Web/umbraco.presentation/install/steps/Definitions/Database.cs
@@ -1,11 +1,7 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Web;
+using Umbraco.Core.Configuration;
 using umbraco.cms.businesslogic.installer;
 using umbraco.IO;
-using umbraco.DataLayer.Utility.Installer;
-using umbraco.DataLayer;
 
 namespace umbraco.presentation.install.steps.Definitions
 {
@@ -41,9 +37,11 @@ namespace umbraco.presentation.install.steps.Definitions
             bool retval = false;
             try
             {
-                IInstallerUtility m_Installer = BusinessLogic.Application.SqlHelper.Utility.CreateInstaller();
-                retval = m_Installer.IsLatestVersion;
-                m_Installer = null;
+                var configuredVersion = new Version(Umbraco.Core.Configuration.GlobalSettings.ConfigurationStatus);
+                var targetVersion = UmbracoVersion.Current;
+
+                retval = targetVersion > configuredVersion;
+
             } catch {
                 // this step might fail due to missing connectionstring
                 return false;
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/BaseMediaTree.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/BaseMediaTree.cs
index f9a440f219..b9d51f90c0 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/BaseMediaTree.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/BaseMediaTree.cs
@@ -137,7 +137,7 @@ function openMedia(id) {
 		/// <returns></returns>
         public virtual string GetLinkValue(Media dd, string nodeLink)
         {
-            var props = dd.getProperties;
+            var props = dd.GenericProperties;
 			foreach (Property p in props)
 			{				
 				Guid currId = p.PropertyType.DataTypeDefinition.DataType.Id;
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/MediaRecycleBin.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/MediaRecycleBin.cs
index ec5c8eb436..e9243745df 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/MediaRecycleBin.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/MediaRecycleBin.cs
@@ -32,11 +32,7 @@ namespace umbraco.cms.presentation.Trees
     [Tree("media", "mediaRecycleBin", "Recycle Bin", "folder.gif", "folder_o.gif", initialize : false)]
 	public class MediaRecycleBin : BaseMediaTree
 	{
-		public MediaRecycleBin(string application)
-			: base(application)
-		{
-						
-		}
+		public MediaRecycleBin(string application) : base(application) { }
 
 		protected override void CreateRootNodeActions(ref List<IAction> actions)
 		{
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadMediaTypes.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadMediaTypes.cs
index f5af115068..670f180228 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadMediaTypes.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadMediaTypes.cs
@@ -1,27 +1,7 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Data;
-using System.IO;
 using System.Text;
-using System.Web;
-using System.Xml;
-using System.Configuration;
-using umbraco.BasePages;
-using umbraco.BusinessLogic;
 using umbraco.businesslogic;
-using umbraco.cms.businesslogic;
-using umbraco.cms.businesslogic.cache;
-using umbraco.cms.businesslogic.contentitem;
-using umbraco.cms.businesslogic.datatype;
-using umbraco.cms.businesslogic.language;
 using umbraco.cms.businesslogic.media;
-using umbraco.cms.businesslogic.member;
-using umbraco.cms.businesslogic.property;
-using umbraco.cms.businesslogic.web;
-using umbraco.interfaces;
-using umbraco.DataLayer;
-using umbraco.BusinessLogic.Utils;
 using umbraco.cms.presentation.Trees;
 
 namespace umbraco
@@ -49,7 +29,7 @@ function openMediaType(id) {
 
         public override void Render(ref XmlTree tree)
         {
-            foreach (MediaType dt in MediaType.GetAll)
+            foreach (var dt in MediaType.GetAllAsList())
             {
                 XmlTreeNode xNode = XmlTreeNode.Create(this);
                 xNode.NodeID = dt.Id.ToString();
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentControl.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentControl.cs
index 2b8df31950..bd24324bcf 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentControl.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentControl.cs
@@ -2,21 +2,18 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.IO;
 using System.Linq;
 using System.Web;
 using System.Web.UI;
 using System.Web.UI.WebControls;
 using umbraco.BasePages;
 using umbraco.cms.businesslogic;
-using umbraco.cms.businesslogic.datatype.controls;
 using umbraco.cms.businesslogic.media;
 using umbraco.cms.businesslogic.property;
 using umbraco.cms.businesslogic.propertytype;
 using umbraco.cms.businesslogic.web;
 using umbraco.interfaces;
 using umbraco.uicontrols;
-using Umbraco.Core.IO;
 using Content = umbraco.cms.businesslogic.Content;
 using SystemDirectories = umbraco.IO.SystemDirectories;
 
@@ -30,7 +27,7 @@ namespace umbraco.controls
     public class ContentControl : TabView
     {
         private Content _content;
-        private ArrayList _dataFields = new ArrayList();
+        internal Dictionary<string, IDataType> DataTypes = new Dictionary<string, IDataType>();
         private UmbracoEnsuredPage prntpage;
         public event EventHandler SaveAndPublish;
         public event EventHandler SaveToPublish;
@@ -135,7 +132,6 @@ namespace umbraco.controls
                 // ge : had a bit of a corrupt db and got weird NRE errors so rewrote this to catch the error and rethrow with detail
                 foreach (PropertyType propertyType in tab.GetPropertyTypes(_content.ContentType.Id))
                 {
-                    // table.Rows.Add(addControl(_content.getProperty(editPropertyType.Alias), tp));
                     var property = _content.getProperty(propertyType);
                     if (property != null && tabPage != null)
                     {
@@ -248,9 +244,10 @@ namespace umbraco.controls
                     return;
                 }
             }
-            foreach (IDataEditor df in _dataFields)
+
+            foreach (var property in DataTypes)
             {
-                df.Save();
+                property.Value.DataEditor.Save();
             }
 
             if (!string.IsNullOrEmpty(NameTxt.Text))
@@ -308,15 +305,14 @@ namespace umbraco.controls
             dt.DataEditor.Editor.ID = string.Format("prop_{0}", p.PropertyType.Alias);
             dt.Data.PropertyId = p.Id;
 
+            //Add the DataType to an internal dictionary, which will be used to call the save method on the IDataEditor
+            //and to retrieve the value from IData in editContent.aspx.cs, so that it can be set on the legacy Document class.
+            DataTypes.Add(p.PropertyType.Alias, dt);
+
             // check for buttons
             IDataFieldWithButtons df1 = dt.DataEditor.Editor as IDataFieldWithButtons;
             if (df1 != null)
             {
-                // df1.Alias = p.PropertyType.Alias;
-                /*
-				// df1.Version = _content.Version;
-				editDataType.Data.PropertyId = p.Id;
-				*/
                 ((Control)df1).ID = p.PropertyType.Alias;
 
 
@@ -389,14 +385,6 @@ namespace umbraco.controls
                                    menuElement.ElementClass, menuElement.ExtraMenuWidth);
             }
 
-
-            // fieldData.Alias = p.PropertyType.Alias;
-            // ((Control) fieldData).ID = p.PropertyType.Alias;
-            // fieldData.Text = p.Value.ToString();
-
-            _dataFields.Add(dt.DataEditor.Editor);
-
-
             Pane pp = new Pane();
             Control holder = new Control();
             holder.Controls.Add(dt.DataEditor.Editor);
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/controls/Images/UploadMediaImage.ascx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/controls/Images/UploadMediaImage.ascx.cs
index 1bbc5d0ea8..6f3c67609d 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/controls/Images/UploadMediaImage.ascx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/controls/Images/UploadMediaImage.ascx.cs
@@ -71,7 +71,7 @@ namespace umbraco.controls.Images
                 parent = BusinessLogic.User.GetCurrent().StartNodeId;
 
             Media m = Media.MakeNew(TextBoxTitle.Text, cms.businesslogic.media.MediaType.GetByAlias("image"), BasePage.Current.getUser(), int.Parse(MediaPickerControl.Value));
-            var props = m.getProperties;
+            var props = m.GenericProperties;
             foreach (cms.businesslogic.property.Property p in props)
             {
                 if (p.PropertyType.DataTypeDefinition.DataType.Id == UploadField.Id)
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/create/media.ascx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/create/media.ascx.cs
index 2ae91676a5..d6b615316a 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/create/media.ascx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/create/media.ascx.cs
@@ -1,12 +1,7 @@
 namespace umbraco.cms.presentation.create.controls
 {
 	using System;
-	using System.Data;
-	using System.Drawing;
-	using System.Web;
 	using System.Web.UI.WebControls;
-	using System.Web.UI.HtmlControls;
-	using umbraco.cms.helpers;
 	using umbraco.BasePages;
 
 	/// <summary>
@@ -28,7 +23,7 @@ namespace umbraco.cms.presentation.create.controls
 				allowedIds = c.ContentType.AllowedChildContentTypeIDs;
 			}
 
-			foreach(cms.businesslogic.ContentType dt in cms.businesslogic.media.MediaType.GetAll) 
+            foreach (var dt in cms.businesslogic.media.MediaType.GetAllAsList())
 			{
 				ListItem li = new ListItem();
 				li.Text = dt.Text;
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/create/nodetypeTasks.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/create/nodetypeTasks.cs
index 4655bdf11e..d355c8b1c0 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/create/nodetypeTasks.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/create/nodetypeTasks.cs
@@ -59,6 +59,8 @@ namespace umbraco
                 dt.MasterContentType = TypeID;
             }
 
+            dt.Save();
+
             m_returnUrl = "settings/editNodeTypeNew.aspx?id=" + dt.Id.ToString();
 
             return true;
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/moveOrCopy.aspx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/moveOrCopy.aspx.cs
index b4e966021c..afbd497d4d 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/moveOrCopy.aspx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/moveOrCopy.aspx.cs
@@ -1,78 +1,63 @@
 using System;
 using System.Collections;
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
-using System.Web;
-using System.Web.SessionState;
 using System.Web.UI;
 using System.Web.UI.WebControls;
-using System.Web.UI.HtmlControls;
 using System.Xml;
-using umbraco.cms.helpers;
 using umbraco.BasePages;
+using umbraco.cms.businesslogic.web;
 using umbraco.presentation;
 using umbraco.cms.businesslogic.media;
-using umbraco.IO;
+using Umbraco.Core.IO;
 using System.Linq;
 using umbraco.cms.businesslogic;
 using umbraco.cms.presentation.user;
 using umbraco.interfaces;
-using System.Collections.Generic;
 
 namespace umbraco.dialogs
 {
-	/// <summary>
-	/// Summary description for moveOrCopy.
-	/// </summary>
-	public partial class moveOrCopy : UmbracoEnsuredPage
-	{
+    /// <summary>
+    /// Summary description for moveOrCopy.
+    /// </summary>
+    public partial class moveOrCopy : UmbracoEnsuredPage
+    {
 
-		protected void Page_Load(object sender, System.EventArgs e)
-		{
+        protected void Page_Load(object sender, EventArgs e)
+        {
             JTree.DataBind();
 
-			// Put user code to initialize the page here
-            if (!IsPostBack)
+            // Put user code to initialize the page here
+            if (IsPostBack == false)
             {
                 pp_relate.Text = ui.Text("moveOrCopy", "relateToOriginal");
 
                 //Document Type copy Hack...
-                string app = helper.Request("app");
+                var app = helper.Request("app");
 
-                if (app == "settings") {
+                if (app == "settings")
+                {
                     pane_form.Visible = false;
                     pane_form_notice.Visible = false;
-
-
-                   
-
                     pane_settings.Visible = true;
 
                     ok.Text = ui.Text("general", "ok", this.getUser());
                     ok.Attributes.Add("style", "width: 60px");
 
-                    cms.businesslogic.web.DocumentType dt = new umbraco.cms.businesslogic.web.DocumentType(int.Parse(helper.Request("id")));
+                    var documentType = new DocumentType(int.Parse(helper.Request("id")));
 
                     //Load master types... 
                     masterType.Attributes.Add("style", "width: 350px;");
                     masterType.Items.Add(new ListItem(ui.Text("none") + "...", "0"));
-                    foreach (cms.businesslogic.web.DocumentType docT in cms.businesslogic.web.DocumentType.GetAllAsList()) {
+                    foreach (var docT in DocumentType.GetAllAsList())
                         masterType.Items.Add(new ListItem(docT.Text, docT.Id.ToString()));
-                    }
 
-                    masterType.SelectedValue = dt.MasterContentType.ToString();
+                    masterType.SelectedValue = documentType.MasterContentType.ToString();
 
                     //hack to close window if not a doctype...
-                    if (dt == null) {
-                        Response.Write("<script type=\"text/javascript\">javascript:parent.window.close()</script>");
-                    } else {
-                        rename.Text = dt.Text + " (copy)";
-                        pane_settings.Text = "Make a copy of the document type '" + dt.Text + "' and save it under a new name";
-                    }
-
-                } else {
-
+                    rename.Text = string.Format("{0} (copy)", documentType.Text);
+                    pane_settings.Text = "Make a copy of the document type '" + documentType.Text + "' and save it under a new name";
+                }
+                else
+                {
                     pane_form.Visible = true;
                     pane_form_notice.Visible = true;
 
@@ -83,280 +68,264 @@ namespace umbraco.dialogs
                     ok.Attributes.Add("style", "width: 60px");
                     ok.Attributes.Add("disabled", "true");
 
-                   
-                    string currentPath = "";
-                    CMSNode d  = new CMSNode(int.Parse(helper.Request("id")));
-                    foreach (string s in d.Path.Split(',')) {
-                        if (int.Parse(s) > 0)
-                            currentPath += "/" + new CMSNode(int.Parse(s)).Text;
-                    }
+                    var cmsNode = new CMSNode(int.Parse(helper.Request("id")));
 
-                    //
-
-                    bool validAction = true;
-                    // only validate permissions in content
-                    if (app == "content" && d.HasChildren)
-                    {
+                    var validAction = true;
+                    if (app == "content" && cmsNode.HasChildren)
                         validAction = ValidAction(helper.Request("mode") == "cut" ? 'M' : 'O');
-                    }
 
 
-                    if (helper.Request("mode") == "cut") {
-                        pane_form.Text = ui.Text("moveOrCopy", "moveTo", d.Text, base.getUser());
+                    if (helper.Request("mode") == "cut")
+                    {
+                        pane_form.Text = ui.Text("moveOrCopy", "moveTo", cmsNode.Text, base.getUser());
                         pp_relate.Visible = false;
-                    } else {
-                        pane_form.Text = ui.Text("moveOrCopy", "copyTo", d.Text, base.getUser());
+                    }
+                    else
+                    {
+                        pane_form.Text = ui.Text("moveOrCopy", "copyTo", cmsNode.Text, base.getUser());
                         pp_relate.Visible = true;
                     }
 
-                    if (!validAction)
+                    if (validAction == false)
                     {
                         ScriptManager.RegisterStartupScript(this, this.GetType(), "notvalid", "notValid();", true);
-
                     }
                 }
             }
-			
-		}
+
+        }
 
         private bool ValidAction(char actionLetter)
         {
-            CMSNode d = new CMSNode(int.Parse(helper.Request("id")));
-            IAction currentAction = umbraco.BusinessLogic.Actions.Action.GetPermissionAssignable().Where(a => a.Letter == actionLetter).First();
-            return CheckPermissions(d, currentAction,actionLetter);
-           
+            var cmsNode = new CMSNode(int.Parse(helper.Request("id")));
+            var currentAction = BusinessLogic.Actions.Action.GetPermissionAssignable().First(a => a.Letter == actionLetter);
+            return CheckPermissions(cmsNode, currentAction);
         }
 
-        private bool CheckPermissions(CMSNode node, IAction currentAction, char actionLetter)
+        private bool CheckPermissions(CMSNode node, IAction currentAction)
         {
-                       
-            UserPermissions currUserPermissions = new UserPermissions(UmbracoEnsuredPage.CurrentUser);
-            List<IAction> lstCurrUserActions = currUserPermissions.GetExistingNodePermission(node.Id);
+            var currUserPermissions = new UserPermissions(CurrentUser);
+            var lstCurrUserActions = currUserPermissions.GetExistingNodePermission(node.Id);
 
-            if (!lstCurrUserActions.Contains(currentAction))
+            if (lstCurrUserActions.Contains(currentAction) == false)
                 return false;
+
             if (node.HasChildren)
             {
-                foreach (CMSNode c in node.Children)
-                    if (!CheckPermissions(c,currentAction,actionLetter))
+                foreach (CMSNode child in node.Children)
+                    if (CheckPermissions(child, currentAction) == false)
                         return false;
             }
             return true;
         }
         //PPH moving multiple nodes and publishing them aswell.
-        private void handleChildNodes(cms.businesslogic.web.Document d) {
+        private void handleChildNodes(cms.businesslogic.web.Document document)
+        {
             //store children array here because iterating over an Array object is very inneficient.
-            var c = d.Children;
-            foreach (cms.businesslogic.web.Document cd in c) 
+            var children = document.Children;
+            foreach (Document child in children.Where(child => child.Published))
             {
-                if (cd.Published) {
-                    cd.Publish(new umbraco.BusinessLogic.User(0));
-                    //using library.publish to support load balancing.
-                    umbraco.library.UpdateDocumentCache(cd.Id);
+                child.Publish(new BusinessLogic.User(0));
 
-
-                    if (cd.HasChildren) {
-                        handleChildNodes(cd);
-                    }
-                }
+                //using library.publish to support load balancing.
+                library.UpdateDocumentCache(child.Id);
+                if (child.HasChildren)
+                    handleChildNodes(child);
             }
         }
 
         //PPH Handle doctype copies..
-        private void HandleDocumentTypeCopy() {
+        private void HandleDocumentTypeCopy()
+        {
+            var documentType = new DocumentType(int.Parse(helper.Request("id")));
 
-            cms.businesslogic.web.DocumentType eDt = new umbraco.cms.businesslogic.web.DocumentType(int.Parse(helper.Request("id")));
-                
             //Documentype exists.. create new doc type... 
-            if (eDt != null) {
-                        string Alias = rename.Text;
-                        cms.businesslogic.web.DocumentType dt = cms.businesslogic.web.DocumentType.MakeNew(base.getUser(), Alias.Replace("'", "''"));
+            var alias = rename.Text;
+            var newDocumentType = DocumentType.MakeNew(base.getUser(), alias.Replace("'", "''"));
 
-                        dt.IconUrl = eDt.IconUrl;
-                        dt.Thumbnail = eDt.Thumbnail;
-                        dt.Description = eDt.Description;
-                        dt.allowedTemplates = eDt.allowedTemplates;
-                        dt.DefaultTemplate = eDt.DefaultTemplate;
-                        dt.AllowedChildContentTypeIDs = eDt.AllowedChildContentTypeIDs;
+            newDocumentType.IconUrl = documentType.IconUrl;
+            newDocumentType.Thumbnail = documentType.Thumbnail;
+            newDocumentType.Description = documentType.Description;
+            newDocumentType.allowedTemplates = documentType.allowedTemplates;
+            newDocumentType.DefaultTemplate = documentType.DefaultTemplate;
+            newDocumentType.AllowedChildContentTypeIDs = documentType.AllowedChildContentTypeIDs;
 
-                        dt.MasterContentType = int.Parse(masterType.SelectedValue);
+            newDocumentType.MasterContentType = int.Parse(masterType.SelectedValue);
 
-                        Hashtable oldNewTabIds = new Hashtable();
-                        foreach (cms.businesslogic.web.DocumentType.TabI tab in eDt.getVirtualTabs.ToList())
-                        {
-                            if (tab.ContentType == eDt.Id)
-                            {
-                                int tId = dt.AddVirtualTab(tab.Caption);
-                                oldNewTabIds.Add(tab.Id, tId);
-                            }
-                        }
+            var oldNewTabIds = new Hashtable();
+            foreach (var tab in documentType.getVirtualTabs.Where(t => t.ContentType == documentType.Id))
+            {
+                int tabId = newDocumentType.AddVirtualTab(tab.Caption);
+                oldNewTabIds.Add(tab.Id, tabId);
+            }
 
-                        foreach (cms.businesslogic.propertytype.PropertyType pt in eDt.PropertyTypes) {
+            foreach (var propertyType in documentType.PropertyTypes.Where(p => p.ContentTypeId == documentType.Id))
+            {
+                var newPropertyType = cms.businesslogic.propertytype.PropertyType.MakeNew(propertyType.DataTypeDefinition, newDocumentType, propertyType.Name, propertyType.Alias);
+                newPropertyType.ValidationRegExp = propertyType.ValidationRegExp;
+                newPropertyType.SortOrder = propertyType.SortOrder;
+                newPropertyType.Mandatory = propertyType.Mandatory;
+                newPropertyType.Description = propertyType.Description;
 
-                            if (pt.ContentTypeId == eDt.Id)
-                            {
-                                cms.businesslogic.propertytype.PropertyType nPt = umbraco.cms.businesslogic.propertytype.PropertyType.MakeNew(pt.DataTypeDefinition, dt, pt.Name, pt.Alias);
-                                nPt.ValidationRegExp = pt.ValidationRegExp;
-                                nPt.SortOrder = pt.SortOrder;
-                                nPt.Mandatory = pt.Mandatory;
-                                nPt.Description = pt.Description;
+                if (propertyType.TabId > 0 && oldNewTabIds[propertyType.TabId] != null)
+                {
+                    var newTabId = (int)oldNewTabIds[propertyType.TabId];
+                    newPropertyType.TabId = newTabId;
+                }
+            }
 
-                                if (pt.TabId > 0 && oldNewTabIds[pt.TabId] != null)
-                                {
-                                    int newTabId = (int)oldNewTabIds[pt.TabId];
-                                    nPt.TabId = newTabId;
-                                }
-                            }
-                        }
+            var returnUrl = string.Format("{0}/settings/editNodeTypeNew.aspx?id={1}", SystemDirectories.Umbraco, newDocumentType.Id);
 
-                        string returnUrl = SystemDirectories.Umbraco + "/settings/editNodeTypeNew.aspx?id=" + dt.Id.ToString();
-                
-                dt.Save();
+            newDocumentType.Save();
 
+            pane_settings.Visible = false;
+            panel_buttons.Visible = false;
 
-                pane_settings.Visible = false;
-                panel_buttons.Visible = false;
+            feedback.Text = "Document type copied";
+            feedback.type = uicontrols.Feedback.feedbacktype.success;
 
-                feedback.Text = "Document type copied";
-                feedback.type = umbraco.uicontrols.Feedback.feedbacktype.success;
+            ClientTools.ChangeContentFrameUrl(returnUrl);
+        }
 
-				ClientTools.ChangeContentFrameUrl(returnUrl);
-                
-                }                
-           }
-        
-        public void HandleMoveOrCopy(object sender, EventArgs e) {
+        public void HandleMoveOrCopy(object sender, EventArgs e)
+        {
             if (UmbracoContext.Current.Request["app"] == "settings")
                 HandleDocumentTypeCopy();
             else
-                HandleDocumentMoveOrCopy(); 
+                HandleDocumentMoveOrCopy();
         }
 
-        protected override void OnPreRender(EventArgs e) {
+        protected override void OnPreRender(EventArgs e)
+        {
             base.OnPreRender(e);
 
             ScriptManager.GetCurrent(Page).Services.Add(new ServiceReference("../webservices/cmsnode.asmx"));
             ScriptManager.GetCurrent(Page).Services.Add(new ServiceReference("../webservices/legacyAjaxCalls.asmx"));
         }
 
-        private void HandleDocumentMoveOrCopy() 
-		{
-			if (helper.Request("copyTo") != "" && helper.Request("id") != "") 
-			{
-				// Check if the current node is allowed at new position
-				bool nodeAllowed = false;
+        private void HandleDocumentMoveOrCopy()
+        {
+            if (helper.Request("copyTo") != "" && helper.Request("id") != "")
+            {
+                // Check if the current node is allowed at new position
+                var nodeAllowed = false;
 
-				cms.businesslogic.Content currentNode = new cms.businesslogic.Content(int.Parse(helper.Request("id")));
-                int oldParent = -1;
-                if (currentNode.Level > 1)
-                   oldParent = currentNode.Parent.Id;
-				cms.businesslogic.Content newNode = new cms.businesslogic.Content(int.Parse(helper.Request("copyTo")));
+                var currentNode = new cms.businesslogic.Content(int.Parse(helper.Request("id")));
 
-				// Check on contenttypes
-				if (int.Parse(helper.Request("copyTo")) == -1)
-					nodeAllowed = true;
-				else 
-				{
-					foreach (int i in newNode.ContentType.AllowedChildContentTypeIDs.ToList())
-						if (i == currentNode.ContentType.Id) 
-						{
-							nodeAllowed = true;
-							break;
-						}
-                    if (!nodeAllowed) {
+                cms.businesslogic.Content newNode = new cms.businesslogic.Content(int.Parse(helper.Request("copyTo")));
+
+                // Check on contenttypes
+                if (int.Parse(helper.Request("copyTo")) == -1)
+                {
+                    nodeAllowed = true;
+                }
+                else
+                {
+                    if (newNode.ContentType.AllowedChildContentTypeIDs.Where(c => c == currentNode.ContentType.Id).Any())
+                    {
+                        nodeAllowed = true;
+                    }
+
+                    if (nodeAllowed == false)
+                    {
                         feedback.Text = ui.Text("moveOrCopy", "notAllowedByContentType", base.getUser());
-                        feedback.type = umbraco.uicontrols.Feedback.feedbacktype.error;
-                    } else {
+                        feedback.type = uicontrols.Feedback.feedbacktype.error;
+                    }
+                    else
+                    {
                         // Check on paths
-                        if (((string)("," + newNode.Path + ",")).IndexOf("," + currentNode.Id + ",") > -1) {
+                        if ((string.Format(",{0},", newNode.Path)).IndexOf(string.Format(",{0},", currentNode.Id)) > -1)
+                        {
                             nodeAllowed = false;
                             feedback.Text = ui.Text("moveOrCopy", "notAllowedByPath", base.getUser());
-                            feedback.type = umbraco.uicontrols.Feedback.feedbacktype.error;
+                            feedback.type = uicontrols.Feedback.feedbacktype.error;
                         }
                     }
-				}
+                }
 
-
-				if (nodeAllowed) 
-				{
+                if (nodeAllowed)
+                {
                     pane_form.Visible = false;
                     pane_form_notice.Visible = false;
                     panel_buttons.Visible = false;
 
-                    string newNodeCaption = newNode.Id == -1 ? ui.Text(helper.Request("app")) : newNode.Text;
+                    var newNodeCaption = newNode.Id == -1 ? ui.Text(helper.Request("app")) : newNode.Text;
 
-                    string[] nodes = {currentNode.Text, newNodeCaption };
+                    string[] nodes = { currentNode.Text, newNodeCaption };
 
                     if (UmbracoContext.Current.Request["mode"] == "cut")
                     {
                         if (UmbracoContext.Current.Request["app"] == "content")
                         {
                             //PPH changed this to document instead of cmsNode to handle republishing.
-                            cms.businesslogic.web.Document d = new umbraco.cms.businesslogic.web.Document(int.Parse(helper.Request("id")));
-                            d.Move(int.Parse(helper.Request("copyTo")));
-                            if (d.Published)
+                            var documentId = int.Parse(helper.Request("id"));
+                            var document = new Document(documentId);
+                            document.Move(int.Parse(helper.Request("copyTo")));
+                            if (document.Published)
                             {
-                                d.Publish(new umbraco.BusinessLogic.User(0));
+                                //TODO HACK - Have to get the Document again, to get the new path from the database..
+                                document = new Document(documentId);
+
+                                document.Publish(new umbraco.BusinessLogic.User(0));
                                 //using library.publish to support load balancing.
                                 //umbraco.library.PublishSingleNode(d.Id);
-                                umbraco.library.UpdateDocumentCache(d.Id);
+                                umbraco.library.UpdateDocumentCache(document.Id);
 
                                 //PPH added handling of load balanced moving of multiple nodes...
-                                if (d.HasChildren)
-                                {
-                                    handleChildNodes(d);
-                                }
+                                if (document.HasChildren)
+                                    handleChildNodes(document);
 
                                 //Using the general Refresh content method instead as it supports load balancing. 
                                 //we only need to do this if the node is actually published.
                                 library.RefreshContent();
                             }
-                            d.Save(); //stub to save stuff to the db.
+
+                            document.Save(); //stub to save stuff to the db.
                         }
                         else
                         {
-                            Media m = new Media(int.Parse(UmbracoContext.Current.Request["id"]));
-                            m.Move(int.Parse(UmbracoContext.Current.Request["copyTo"]));
-                            m.XmlGenerate(new XmlDocument());
-                            library.ClearLibraryCacheForMedia(m.Id);
-                        }                                 
+                            var media = new Media(int.Parse(UmbracoContext.Current.Request["id"]));
+                            media.Move(int.Parse(UmbracoContext.Current.Request["copyTo"]));
+                            media = new Media(int.Parse(UmbracoContext.Current.Request["id"]));
+                            media.XmlGenerate(new XmlDocument());
+                            library.ClearLibraryCacheForMedia(media.Id);
+                        }
 
                         feedback.Text = ui.Text("moveOrCopy", "moveDone", nodes, base.getUser()) + "</p><p><a href='#' onclick='" + ClientTools.Scripts.CloseModalWindow() + "'>" + ui.Text("closeThisWindow") + "</a>";
-                        feedback.type = umbraco.uicontrols.Feedback.feedbacktype.success;
+                        feedback.type = uicontrols.Feedback.feedbacktype.success;
 
                         // refresh tree
-						ClientTools.MoveNode(currentNode.Id.ToString(), newNode.Path);
-
-                    } 
-					else 
-					{
-						cms.businesslogic.web.Document d = new cms.businesslogic.web.Document(int.Parse(helper.Request("id")));
-						d.Copy(int.Parse(helper.Request("copyTo")), this.getUser(), RelateDocuments.Checked);
-						feedback.Text = ui.Text("moveOrCopy", "copyDone", nodes, base.getUser()) + "</p><p><a href='#' onclick='" + ClientTools.Scripts.CloseModalWindow() + "'>" + ui.Text("closeThisWindow") + "</a>";
-                        feedback.type = umbraco.uicontrols.Feedback.feedbacktype.success;
-						ClientTools.CopyNode(currentNode.Id.ToString(), newNode.Path);
+                        ClientTools.MoveNode(currentNode.Id.ToString(), newNode.Path);
                     }
-				} 
-			}
-		}
+                    else
+                    {
+                        var document = new Document(int.Parse(helper.Request("id")));
+                        document.Copy(int.Parse(helper.Request("copyTo")), this.getUser(), RelateDocuments.Checked);
+                        feedback.Text = ui.Text("moveOrCopy", "copyDone", nodes, base.getUser()) + "</p><p><a href='#' onclick='" + ClientTools.Scripts.CloseModalWindow() + "'>" + ui.Text("closeThisWindow") + "</a>";
+                        feedback.type = uicontrols.Feedback.feedbacktype.success;
+                        ClientTools.CopyNode(currentNode.Id.ToString(), newNode.Path);
+                    }
+                }
+            }
+        }
 
-		#region Web Form Designer generated code
-		override protected void OnInit(EventArgs e)
-		{
-			//
-			// CODEGEN: This call is required by the ASP.NET Web Form Designer.
-			//
-			InitializeComponent();
-			base.OnInit(e);
-		}
-		
-		/// <summary>
-		/// Required method for Designer support - do not modify
-		/// the contents of this method with the code editor.
-		/// </summary>
-		private void InitializeComponent()
-		{    
-		}
-		#endregion
-	}
+        #region Web Form Designer generated code
+        override protected void OnInit(EventArgs e)
+        {
+            //
+            // CODEGEN: This call is required by the ASP.NET Web Form Designer.
+            //
+            InitializeComponent();
+            base.OnInit(e);
+        }
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+        }
+        #endregion
+    }
 }
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/publish.aspx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/publish.aspx.cs
index 51b943c413..d8b99c6bba 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/publish.aspx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/publish.aspx.cs
@@ -33,7 +33,7 @@ namespace umbraco.dialogs
             cms.businesslogic.web.Document d = new cms.businesslogic.web.Document(nodeId);
             pageName = d.Text;
 
-			if (d.Level > 1 && !(new cms.businesslogic.web.Document(d.ParentId).PathPublished))
+			if (d.Level > 1 && d.PathPublished == false)
 			{
 				TheForm.Visible = false;
 				theEnd.Visible = true;
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/rollBack.aspx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/rollBack.aspx.cs
index 83bd442486..88e9933945 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/rollBack.aspx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/rollBack.aspx.cs
@@ -41,7 +41,7 @@ namespace umbraco.presentation.dialogs
                     lt_notice.Text = ui.Text("rollback", "htmlHelp");
 
 
-                var props = rollback.getProperties;
+                var props = rollback.GenericProperties;
                 foreach (Property p in props) {
                     try {
 
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/editContent.aspx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/editContent.aspx.cs
index 82a3b98935..d3b9b7d4a2 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/editContent.aspx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/editContent.aspx.cs
@@ -1,27 +1,13 @@
 using System;
-using System.Collections;
-using System.Collections.Specialized;
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
-using System.Web;
-using System.Web.SessionState;
 using System.Web.UI;
 using System.Web.UI.WebControls;
-using System.Web.UI.HtmlControls;
-using System.Reflection;
+using Umbraco.Core.Persistence.Caching;
 using umbraco.BusinessLogic.Actions;
-using umbraco.cms.businesslogic.language;
-using umbraco.cms.helpers;
 using umbraco.IO;
-using umbraco.uicontrols;
 using umbraco.uicontrols.DatePicker;
 using umbraco.BusinessLogic;
-using umbraco.presentation.preview;
 using umbraco.cms.businesslogic.web;
 using umbraco.presentation;
-using umbraco.cms.businesslogic.skinning;
-using System.Collections.Generic;
 using System.Linq;
 using Image = System.Web.UI.WebControls.Image;
 
@@ -291,8 +277,14 @@ namespace umbraco.cms.presentation
                 }
             }
 
-
-
+            //The value of the properties has been set on IData through IDataEditor in the ContentControl
+            //so we need to 'retrieve' that value and set it on the property of the new IContent object.
+            //NOTE This is a workaround for the legacy approach to saving values through the DataType instead of the Property 
+            //- (The DataType shouldn't be responsible for saving the value - especically directly to the db).
+            foreach (var item in cControl.DataTypes)
+            {
+                _document.getProperty(item.Key).Value = item.Value.Data.Value;
+            }
 
             // Run Handler				
             BusinessLogic.Actions.Action.RunActionHandlers(_document, ActionUpdate.Instance);
@@ -320,7 +312,7 @@ namespace umbraco.cms.presentation
         {
             if (Page.IsValid)
             {
-                if (_document.Level == 1 || new cms.businesslogic.web.Document(_document.Parent.Id).PathPublished)
+                if (_document.Level == 1 || _document.PathPublished)
                 {
                     Trace.Warn("before d.publish");
 
@@ -328,7 +320,6 @@ namespace umbraco.cms.presentation
                     {
 
                         ClientTools.ShowSpeechBubble(speechBubbleIcon.save, ui.Text("speechBubbles", "editContentPublishedHeader", null), ui.Text("speechBubbles", "editContentPublishedText", null));
-                        library.UpdateDocumentCache(_document);
 
                         littPublishStatus.Text = ui.Text("content", "lastPublished", base.getUser()) + ": " + _document.VersionDate.ToString() + "<br/>";
 
@@ -388,7 +379,7 @@ namespace umbraco.cms.presentation
 
         void UpdateNiceUrls()
         {
-            if (!_documentHasPublishedVersion)
+            if (!_documentHasPublishedVersion || _document.Published == false)
             {
                 UpdateNiceUrlProperties("<i>" + ui.Text("content", "itemNotPublished", base.getUser()) + "</i>", null);
                 return;
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/editMedia.aspx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/editMedia.aspx.cs
index 27e5d38e54..aadd17841b 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/editMedia.aspx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/editMedia.aspx.cs
@@ -1,16 +1,7 @@
 using System;
-using System.Collections;
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
-using System.Web;
-using System.Web.SessionState;
 using System.Web.UI;
 using System.Web.UI.WebControls;
-using System.Web.UI.HtmlControls;
-
 using System.Xml;
-using umbraco.cms.helpers;
 using umbraco.cms.businesslogic.datatype.controls;
 using System.Collections.Generic;
 using System.Linq;
@@ -120,6 +111,16 @@ namespace umbraco.cms.presentation
                     tp.ErrorControl.Visible = false;
                 }
             }
+
+            //The value of the properties has been set on IData through IDataEditor in the ContentControl
+            //so we need to 'retrieve' that value and set it on the property of the new IContent object.
+            //NOTE This is a workaround for the legacy approach to saving values through the DataType instead of the Property 
+            //- (The DataType shouldn't be responsible for saving the value - especically directly to the db).
+            foreach (var item in tmp.DataTypes)
+            {
+                _media.getProperty(item.Key).Value = item.Value.Data.Value;
+            }
+
             _media.Save();
 
             this.updateDateLiteral.Text = _media.VersionDate.ToShortDateString() + " " + _media.VersionDate.ToShortTimeString();
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/members/EditMember.aspx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/members/EditMember.aspx.cs
index fc02bd5c9d..fbe3d49c8e 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/members/EditMember.aspx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/members/EditMember.aspx.cs
@@ -157,6 +157,7 @@ namespace umbraco.cms.presentation.members
 
                     // Groups
                     foreach (ListItem li in _memberGroups.Items)
+                    {
                         if (("," + _memberGroups.Value + ",").IndexOf("," + li.Value + ",") > -1)
                         {
                             if (!Roles.IsUserInRole(_document.LoginName, li.Value))
@@ -166,6 +167,17 @@ namespace umbraco.cms.presentation.members
                         {
                             Roles.RemoveUserFromRole(_document.LoginName, li.Value);
                         }
+                    }
+
+                    //The value of the properties has been set on IData through IDataEditor in the ContentControl
+                    //so we need to 'retrieve' that value and set it on the property of the new IContent object.
+                    //NOTE This is a workaround for the legacy approach to saving values through the DataType instead of the Property 
+                    //- (The DataType shouldn't be responsible for saving the value - especically directly to the db).
+                    foreach (var item in tmp.DataTypes)
+                    {
+                        _document.getProperty(item.Key).Value = item.Value.Data.Value;
+                    }
+
                     // refresh cache
                     _document.XmlGenerate(new System.Xml.XmlDocument());
                     _document.Save();
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/nodeSorter.asmx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/nodeSorter.asmx.cs
index 81095f530e..7f37b9bd44 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/nodeSorter.asmx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/nodeSorter.asmx.cs
@@ -3,7 +3,9 @@ using System.Collections;
 using System.ComponentModel;
 using System.Web.Script.Services;
 using System.Web.Services;
+using System.Xml;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.Caching;
 using umbraco.BasePages;
 using umbraco.BusinessLogic.Actions;
 using umbraco.cms.businesslogic.web;
@@ -24,11 +26,10 @@ namespace umbraco.presentation.webservices
         {
             if (BasePage.ValidateUserContextID(BasePage.umbracoUserContextID))
             {
-                SortNode parent = new SortNode();
-                parent.Id = ParentId;
+                var parent = new SortNode { Id = ParentId };
 
-                ArrayList _nodes = new ArrayList();
-                cms.businesslogic.CMSNode n = new cms.businesslogic.CMSNode(ParentId);
+                var nodes = new ArrayList();
+                var cmsNode = new cms.businesslogic.CMSNode(ParentId);
 
                 // Root nodes?
                 if (ParentId == -1)
@@ -36,34 +37,32 @@ namespace umbraco.presentation.webservices
                     if (App == "media")
                     {
                         foreach (cms.businesslogic.media.Media child in cms.businesslogic.media.Media.GetRootMedias())
-                            _nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
+                            nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
                     }
                     else
-                        foreach (cms.businesslogic.web.Document child in cms.businesslogic.web.Document.GetRootDocuments())
-                            _nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
+                        foreach (Document child in Document.GetRootDocuments())
+                            nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
                 }
                 else
                 {
                     // "hack for stylesheet"
                     if (App == "settings")
                     {
-                        StyleSheet ss = new StyleSheet(n.Id);
-                        foreach (cms.businesslogic.web.StylesheetProperty child in ss.Properties)
-                            _nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
+                        var styleSheet = new StyleSheet(cmsNode.Id);
+                        foreach (var child in styleSheet.Properties)
+                            nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
 
                     }
                     else
                     {
                         //store children array here because iterating over an Array property object is very inneficient.
-                        var children = n.Children;
+                        var children = cmsNode.Children;
                         foreach (cms.businesslogic.CMSNode child in children)
-                        {
-                            _nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
-                        }
+                            nodes.Add(new SortNode(child.Id, child.sortOrder, child.Text, child.CreateDateTime));
                     }
                 }
 
-                parent.SortNodes = (SortNode[])_nodes.ToArray(typeof(SortNode));
+                parent.SortNodes = (SortNode[])nodes.ToArray(typeof(SortNode));
 
                 return parent;
             }
@@ -74,29 +73,18 @@ namespace umbraco.presentation.webservices
         [WebMethod]
         public void UpdateSortOrder(int ParentId, string SortOrder)
         {
-
             try
             {
                 if (BasePage.ValidateUserContextID(BasePage.umbracoUserContextID))
                 {
-
                     if (SortOrder.Trim().Length > 0)
                     {
-                        string[] tmp = SortOrder.Split(',');
+                        var tmp = SortOrder.Split(',');
 
-                        bool isContent = false;
-                        if (helper.Request("app") == "content" | helper.Request("app") == "")
-                            isContent = true;
+                        var isContent = helper.Request("app") == "content" | helper.Request("app") == "";
+                        var isMedia = helper.Request("app") == "media";
 
-                        //CHANGE:Allan Stegelmann Laustsen, we need to know if the node is in media.
-                        bool isMedia = false;
-                        if (helper.Request("app") == "media")
-                        {
-                            isMedia = true;
-                        }
-                        //CHANGE:End
-
-                        for (int i = 0; i < tmp.Length; i++)
+                        for (var i = 0; i < tmp.Length; i++)
                         {
                             if (tmp[i] != "" && tmp[i].Trim() != "")
                             {
@@ -104,32 +92,26 @@ namespace umbraco.presentation.webservices
 
                                 if (isContent)
                                 {
-                                    Document d = new Document(int.Parse(tmp[i]));
+                                    var document = new Document(int.Parse(tmp[i]));
                                     // refresh the xml for the sorting to work
-                                    if (d.Published)
+                                    if (document.Published)
                                     {
-                                        d.refreshXmlSortOrder();
+                                        document.refreshXmlSortOrder();
                                         library.UpdateDocumentCache(int.Parse(tmp[i]));
                                     }
                                 }
-                                //CHANGE:Allan Laustsen, to update the sortorder of the media node in the XML, re-save the node....
+                                // to update the sortorder of the media node in the XML, re-save the node....
                                 else if (isMedia)
                                 {
                                     new cms.businesslogic.media.Media(int.Parse(tmp[i])).Save();
                                 }
-                                //CHANGE:End
                             }
                         }
 
                         // Refresh sort order on cached xml
                         if (isContent)
                         {
-                            System.Xml.XmlNode parentNode;
-
-                            if (ParentId == -1)
-                                parentNode = content.Instance.XmlContent.DocumentElement;
-                            else
-                                parentNode = content.Instance.XmlContent.GetElementById(ParentId.ToString());
+                            XmlNode parentNode = ParentId == -1 ? content.Instance.XmlContent.DocumentElement : content.Instance.XmlContent.GetElementById(ParentId.ToString());
 
                             //only try to do the content sort if the the parent node is available... 
                             if (parentNode != null)
@@ -140,24 +122,25 @@ namespace umbraco.presentation.webservices
                             if (UmbracoSettings.UseDistributedCalls)
                                 library.RefreshContent();
                         }
-                       
+
+                        //TODO: Properly refactor this, we're just clearing the cache so the new sortorder will also be visible in the backoffice
+                        InMemoryCacheProvider.Current.Clear();
 
                         // fire actionhandler, check for content
                         if ((helper.Request("app") == "content" | helper.Request("app") == "") && ParentId > 0)
-                            global::umbraco.BusinessLogic.Actions.Action.RunActionHandlers(new Document(ParentId), ActionSort.Instance);                        
+                            global::umbraco.BusinessLogic.Actions.Action.RunActionHandlers(new Document(ParentId), ActionSort.Instance);
                     }
                 }
 
             }
             catch (Exception ex)
             {
-				LogHelper.Error<nodeSorter>("An error occurred", ex);
+                LogHelper.Error<nodeSorter>("An error occurred", ex);
             }
 
         }
     }
 
-
     [Serializable]
     public class SortNode
     {
@@ -178,8 +161,7 @@ namespace umbraco.presentation.webservices
             get { return _sortNodes != null ? _sortNodes.Length : 0; }
             set { int test = value; }
         }
-
-
+        
         public SortNode(int Id, int SortOrder, string Name, DateTime CreateDate)
         {
             _id = Id;
@@ -195,8 +177,7 @@ namespace umbraco.presentation.webservices
             get { return _createDate; }
             set { _createDate = value; }
         }
-
-
+        
         private string _name;
 
         public string Name
@@ -204,8 +185,7 @@ namespace umbraco.presentation.webservices
             get { return _name; }
             set { _name = value; }
         }
-
-
+        
         private int _sortOrder;
 
         public int SortOrder
@@ -214,7 +194,6 @@ namespace umbraco.presentation.webservices
             set { _sortOrder = value; }
         }
 
-
         private int _id;
 
         public int Id
diff --git a/src/umbraco.businesslogic/Application.cs b/src/umbraco.businesslogic/Application.cs
index 89a0d1ed1e..e452771fcc 100644
--- a/src/umbraco.businesslogic/Application.cs
+++ b/src/umbraco.businesslogic/Application.cs
@@ -1,8 +1,5 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Data;
-using System.Data.SqlClient;
 using System.IO;
 using System.Linq;
 using System.Web;
@@ -195,15 +192,6 @@ namespace umbraco.BusinessLogic
 
             if (!exist)
             {
-                //                SqlHelper.ExecuteNonQuery(@"
-                //				insert into umbracoApp 
-                //				(appAlias,appIcon,appName, sortOrder) 
-                //				values (@alias,@icon,@name,@sortOrder)",
-                //                SqlHelper.CreateParameter("@alias", alias),
-                //                SqlHelper.CreateParameter("@icon", icon),
-                //                SqlHelper.CreateParameter("@name", name),
-                //                SqlHelper.CreateParameter("@sortOrder", sortOrder));
-
                 LoadXml(doc =>
                 {
                     doc.Root.Add(new XElement("add",
@@ -215,16 +203,6 @@ namespace umbraco.BusinessLogic
             }
         }
 
-        //public static void MakeNew(IApplication Iapp, bool installAppTrees) {
-
-        //    MakeNew(Iapp.Name, Iapp.Alias, Iapp.Icon);
-
-        //    if (installAppTrees) {
-
-        //    }
-        //}
-
-
         /// <summary>
         /// Gets the application by its alias.
         /// </summary>
@@ -250,9 +228,6 @@ namespace umbraco.BusinessLogic
                 t.Delete();
             }
 
-            //SqlHelper.ExecuteNonQuery("delete from umbracoApp where appAlias = @appAlias",
-            //    SqlHelper.CreateParameter("@appAlias", this._alias));
-
             LoadXml(doc =>
             {
                 doc.Root.Elements("add").Where(x => x.Attribute("alias") != null && x.Attribute("alias").Value == this.alias).Remove();
@@ -299,15 +274,6 @@ namespace umbraco.BusinessLogic
             {
                 var tmp = new List<Application>();
 
-                //using (IRecordsReader dr =
-                //    SqlHelper.ExecuteReader("Select appAlias, appIcon, appName from umbracoApp"))
-                //{
-                //    while (dr.Read())
-                //    {
-                //        tmp.Add(new Application(dr.GetString("appName"), dr.GetString("appAlias"), dr.GetString("appIcon")));
-                //    }
-                //}
-
                 LoadXml(doc =>
                 {
 
diff --git a/src/umbraco.businesslogic/ApplicationRegistrar.cs b/src/umbraco.businesslogic/ApplicationRegistrar.cs
index 2432ad783c..12e53a38eb 100644
--- a/src/umbraco.businesslogic/ApplicationRegistrar.cs
+++ b/src/umbraco.businesslogic/ApplicationRegistrar.cs
@@ -3,6 +3,7 @@ using System.Data.SqlClient;
 using System.Linq;
 using System.Xml.Linq;
 using Umbraco.Core;
+using Umbraco.Core.Persistence;
 using umbraco.BusinessLogic.Utils;
 using umbraco.DataLayer;
 using umbraco.businesslogic;
@@ -58,20 +59,25 @@ namespace umbraco.BusinessLogic
                                                   new XAttribute("icon", attr.Icon),
                                                   new XAttribute("sortOrder", attr.SortOrder)));
                     }
-					
-					var dbApps = SqlHelper.ExecuteReader("SELECT * FROM umbracoApp WHERE appAlias NOT IN (" + inString + ")");
-					while (dbApps.Read())
-					{
-						doc.Root.Add(new XElement("add",
-													new XAttribute("alias", dbApps.GetString("appAlias")),
-													new XAttribute("name", dbApps.GetString("appName")),
-													new XAttribute("icon", dbApps.GetString("appIcon")),
-													new XAttribute("sortOrder", dbApps.GetByte("sortOrder"))));
-					}
-					
+                    
+                    var db = ApplicationContext.Current.DatabaseContext.Database;
+                    var exist = db.TableExist("umbracoApp");
+                    if (exist)
+                    {
+                        var dbApps = SqlHelper.ExecuteReader("SELECT * FROM umbracoApp WHERE appAlias NOT IN (" + inString + ")");
+                        while (dbApps.Read())
+                        {
+                            doc.Root.Add(new XElement("add",
+                                                      new XAttribute("alias", dbApps.GetString("appAlias")),
+                                                      new XAttribute("name", dbApps.GetString("appName")),
+                                                      new XAttribute("icon", dbApps.GetString("appIcon")),
+                                                      new XAttribute("sortOrder", dbApps.GetByte("sortOrder"))));
+                        }
+                    }
 
                 }, true);
-
+            
+            //TODO Shouldn't this be enabled and then delete the whole table?
             //SqlHelper.ExecuteNonQuery("DELETE FROM umbracoApp");
         }
     }
diff --git a/src/umbraco.businesslogic/ApplicationTree.cs b/src/umbraco.businesslogic/ApplicationTree.cs
index 67faf9b7ec..65dbb34d21 100644
--- a/src/umbraco.businesslogic/ApplicationTree.cs
+++ b/src/umbraco.businesslogic/ApplicationTree.cs
@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Web;
 using System.Xml.Linq;
 using umbraco.DataLayer;
@@ -240,24 +239,6 @@ namespace umbraco.BusinessLogic
         /// <param name="action">The action.</param>
         public static void MakeNew(bool silent, bool initialize, byte sortOrder, string applicationAlias, string alias, string title, string iconClosed, string iconOpened, string assemblyName, string type, string action)
         {
-
-            //            SqlHelper.ExecuteNonQuery(@"insert into umbracoAppTree(treeSilent, treeInitialize, treeSortOrder, appAlias, treeAlias, treeTitle, 
-            //                                        treeIconClosed, treeIconOpen, treeHandlerAssembly, treeHandlerType, action) 
-            //                                        values(@treeSilent, @treeInitialize, @treeSortOrder, @appAlias, @treeAlias, @treeTitle, @treeIconClosed, @treeIconOpen, @treeHandlerAssembly, @treeHandlerType, @action)"
-            //                                        ,
-            //                SqlHelper.CreateParameter("@treeSilent", silent),
-            //                SqlHelper.CreateParameter("@treeInitialize", initialize),
-            //                SqlHelper.CreateParameter("@treeSortOrder", sortOrder),
-            //                SqlHelper.CreateParameter("@treeAlias", alias),
-            //                SqlHelper.CreateParameter("@appAlias", applicationAlias),
-            //                SqlHelper.CreateParameter("@treeTitle", title),
-            //                SqlHelper.CreateParameter("@treeIconClosed", iconClosed),
-            //                SqlHelper.CreateParameter("@treeIconOpen", iconOpened),
-            //                SqlHelper.CreateParameter("@treeHandlerAssembly", assemblyName),
-            //                SqlHelper.CreateParameter("@treeHandlerType", type),
-            //                SqlHelper.CreateParameter("@action", action)
-            //                );
-
             LoadXml(doc =>
             {
                 var el = doc.Root.Elements("add").SingleOrDefault(x => x.Attribute("alias").Value == alias && x.Attribute("application").Value == applicationAlias);
@@ -285,22 +266,6 @@ namespace umbraco.BusinessLogic
         /// </summary>
         public void Save()
         {
-            //            SqlHelper.ExecuteNonQuery(@"Update umbracoAppTree set treeSilent = @treeSilent, treeInitialize = @treeInitialize, treeSortOrder = @treeSortOrder, treeTitle = @treeTitle, 
-            //                                        treeIconClosed = @treeIconClosed, treeIconOpen = @treeIconOpen, treeHandlerAssembly = @treeHandlerAssembly, treeHandlerType = @treeHandlerType, action = @action 
-            //                                        where treeAlias = @treeAlias AND appAlias = @appAlias",
-            //                SqlHelper.CreateParameter("@treeSilent", this.Silent),
-            //                SqlHelper.CreateParameter("@treeInitialize", this.Initialize),
-            //                SqlHelper.CreateParameter("@treeSortOrder", this.SortOrder),
-            //                SqlHelper.CreateParameter("@treeTitle", this.Title),
-            //                SqlHelper.CreateParameter("@treeIconClosed", this.IconClosed),
-            //                SqlHelper.CreateParameter("@treeIconOpen", this.IconOpened),
-            //                SqlHelper.CreateParameter("@treeHandlerAssembly", this.AssemblyName),
-            //                SqlHelper.CreateParameter("@treeHandlerType", this.Type),
-            //                SqlHelper.CreateParameter("@treeAlias", this.Alias),
-            //                SqlHelper.CreateParameter("@appAlias", this.ApplicationAlias),
-            //                SqlHelper.CreateParameter("@action", this.Action)
-            //                );
-
             LoadXml(doc =>
             {
                 var el = doc.Root.Elements("add").SingleOrDefault(x => x.Attribute("alias").Value == this.Alias && x.Attribute("application").Value == this.ApplicationAlias);
@@ -422,28 +387,6 @@ namespace umbraco.BusinessLogic
                 {
                     var list = new List<ApplicationTree>();
 
-                    //                        using (IRecordsReader dr = SqlHelper.ExecuteReader(@"Select treeSilent, treeInitialize, treeSortOrder, appAlias, treeAlias, treeTitle, treeIconClosed, 
-                    //                                                                treeIconOpen, treeHandlerAssembly, treeHandlerType, action from umbracoAppTree order by treeSortOrder"))
-                    //                        {
-                    //                            while (dr.Read())
-                    //                            {
-
-                    //                                list.Add(new ApplicationTree(
-                    //                                    dr.GetBoolean("treeSilent"),
-                    //                                    dr.GetBoolean("treeInitialize"),
-                    //                                    dr.GetByte("treeSortOrder"),
-                    //                                    dr.GetString("appAlias"),
-                    //                                    dr.GetString("treeAlias"),
-                    //                                    dr.GetString("treeTitle"),
-                    //                                    dr.GetString("treeIconClosed"),
-                    //                                    dr.GetString("treeIconOpen"),
-                    //                                    dr.GetString("treeHandlerAssembly"),
-                    //                                    dr.GetString("treeHandlerType"),
-                    //                                    dr.GetString("action")));
-
-                    //                            }
-                    //                        }
-
                     LoadXml(doc =>
                     {
                         foreach (var addElement in doc.Root.Elements("add").OrderBy(x =>
diff --git a/src/umbraco.businesslogic/ApplicationTreeRegistrar.cs b/src/umbraco.businesslogic/ApplicationTreeRegistrar.cs
index 07175dcc96..16e98ba493 100644
--- a/src/umbraco.businesslogic/ApplicationTreeRegistrar.cs
+++ b/src/umbraco.businesslogic/ApplicationTreeRegistrar.cs
@@ -2,8 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using Umbraco.Core;
-using umbraco.BusinessLogic.Utils;
-using umbraco.DataLayer;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence;
 using umbraco.businesslogic;
 using umbraco.interfaces;
 
@@ -11,23 +11,6 @@ namespace umbraco.BusinessLogic
 {
     public class ApplicationTreeRegistrar : IApplicationStartupHandler
     {
-        private ISqlHelper _sqlHelper;
-        protected ISqlHelper SqlHelper
-        {
-            get
-            {
-                if (_sqlHelper == null)
-                {
-                    try
-                    {
-                        _sqlHelper = DataLayerHelper.CreateSqlHelper(GlobalSettings.DbDSN);
-                    }
-                    catch { }
-                }
-                return _sqlHelper;
-            }
-        }
-
         public ApplicationTreeRegistrar()
         {
 			//don't do anything if the application is not configured!
@@ -70,28 +53,31 @@ namespace umbraco.BusinessLogic
                                               new XAttribute("action", attr.Action)));
                 }
 
-                var dbTrees = SqlHelper.ExecuteReader("SELECT * FROM umbracoAppTree WHERE treeAlias NOT IN (" + inString + ")");
-                while (dbTrees.Read())
+                var db = ApplicationContext.Current.DatabaseContext.Database;
+                var exist = db.TableExist("umbracoAppTree");
+                if (exist)
                 {
-                    var action = dbTrees.GetString("action");
+                    var appTrees = db.Fetch<AppTreeDto>("WHERE treeAlias NOT IN (" + inString + ")");
+                    foreach (var appTree in appTrees)
+                    {
+                        var action = appTree.Action;
 
-                    doc.Root.Add(new XElement("add",
-                                              new XAttribute("silent", dbTrees.GetBoolean("treeSilent")),
-                                              new XAttribute("initialize", dbTrees.GetBoolean("treeInitialize")),
-                                              new XAttribute("sortOrder", dbTrees.GetByte("treeSortOrder")),
-                                              new XAttribute("alias", dbTrees.GetString("treeAlias")),
-                                              new XAttribute("application", dbTrees.GetString("appAlias")),
-                                              new XAttribute("title", dbTrees.GetString("treeTitle")),
-                                              new XAttribute("iconClosed", dbTrees.GetString("treeIconClosed")),
-                                              new XAttribute("iconOpen", dbTrees.GetString("treeIconOpen")),
-                                              new XAttribute("assembly", dbTrees.GetString("treeHandlerAssembly")),
-                                              new XAttribute("type", dbTrees.GetString("treeHandlerType")),
-                                              new XAttribute("action", string.IsNullOrEmpty(action) ? "" : action)));
+                        doc.Root.Add(new XElement("add",
+                                                  new XAttribute("silent", appTree.Silent),
+                                                  new XAttribute("initialize", appTree.Initialize),
+                                                  new XAttribute("sortOrder", appTree.SortOrder),
+                                                  new XAttribute("alias", appTree.Alias),
+                                                  new XAttribute("application", appTree.AppAlias),
+                                                  new XAttribute("title", appTree.Title),
+                                                  new XAttribute("iconClosed", appTree.IconClosed),
+                                                  new XAttribute("iconOpen", appTree.IconOpen),
+                                                  new XAttribute("assembly", appTree.HandlerAssembly),
+                                                  new XAttribute("type", appTree.HandlerType),
+                                                  new XAttribute("action", string.IsNullOrEmpty(action) ? "" : action)));
+                    }
                 }
 
             }, true);
-
-            //SqlHelper.ExecuteNonQuery("DELETE FROM umbracoAppTree");
         }
     }
 }
\ No newline at end of file
diff --git a/src/umbraco.cms/businesslogic/CMSNode.cs b/src/umbraco.cms/businesslogic/CMSNode.cs
index a18a4bc91b..761d11fbdd 100644
--- a/src/umbraco.cms/businesslogic/CMSNode.cs
+++ b/src/umbraco.cms/businesslogic/CMSNode.cs
@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
-using System.Data;
-
 using System.Xml;
-
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Persistence.Caching;
 using umbraco.cms.businesslogic.web;
 using umbraco.DataLayer;
 using umbraco.BusinessLogic;
@@ -11,11 +11,13 @@ using System.IO;
 using System.Text.RegularExpressions;
 using System.ComponentModel;
 using umbraco.IO;
-using umbraco.cms.businesslogic.media;
 using System.Collections;
 using umbraco.cms.businesslogic.task;
 using umbraco.cms.businesslogic.workflow;
 using umbraco.cms.businesslogic.Tags;
+using File = System.IO.File;
+using Media = umbraco.cms.businesslogic.media.Media;
+using Task = umbraco.cms.businesslogic.task.Task;
 
 namespace umbraco.cms.businesslogic
 {
@@ -27,6 +29,7 @@ namespace umbraco.cms.businesslogic
     /// The child classes are required to implement an identifier (Guid) which is used as the objecttype identifier, for 
     /// distinguishing the different types of CMSNodes (ex. Documents/Medias/Stylesheets/documenttypes and so forth).
     /// </summary>
+    [Obsolete("Deprecated, This class will eventually be phased out", false)]
     public class CMSNode : BusinessLogic.console.IconI
     {
         #region Private Members
@@ -397,6 +400,11 @@ namespace umbraco.cms.businesslogic
             PopulateCMSNodeFromReader(reader);
         }
 
+        protected internal CMSNode(IEntity entity)
+        {
+            _id = entity.Id;
+        }
+
         #endregion
 
         #region Public Methods
@@ -541,9 +549,14 @@ order by level,sortOrder";
                 //make sure the node type is a document/media, if it is a recycle bin then this will not be equal
                 if (!IsTrashed && newParent.nodeObjectType == Document._objectType)
                 {
+                    // regenerate the xml of the current document
+                    var movedDocument = new Document(this.Id);
+                    movedDocument.XmlGenerate(new XmlDocument());
+
                     //regenerate the xml for the newParent node
-                    var d = new Document(newParent.Id);
-                    d.XmlGenerate(new XmlDocument());
+                    var parentDocument = new Document(newParent.Id);
+                    parentDocument.XmlGenerate(new XmlDocument());
+                    
                 }
                 else if (!IsTrashed && newParent.nodeObjectType == Media._objectType)
                 {
@@ -558,6 +571,9 @@ order by level,sortOrder";
                     c.Move(this);
                 }
 
+                //TODO: Properly refactor this, we're just clearing the cache so the changes will also be visible in the backoffice
+                InMemoryCacheProvider.Current.Clear();
+
                 FireAfterMove(e);
             }
         }
@@ -1064,6 +1080,34 @@ order by level,sortOrder";
             _isTrashed = dr.GetBoolean("trashed");
         }
 
+        internal protected void PopulateCMSNodeFromContentBase(IContentBase content, Guid objectType)
+        {
+            _uniqueID = content.Key;
+            _nodeObjectType = objectType;
+            _level = content.Level;
+            _path = content.Path;
+            _parentid = content.ParentId;
+            _text = content.Name;
+            _sortOrder = content.SortOrder;
+            _userId = content.CreatorId;
+            _createDate = content.CreateDate;
+            _isTrashed = content.Trashed;
+        }
+
+        internal protected void PopulateCMSNodeFromContentTypeBase(IContentTypeBase contentType, Guid objectType)
+        {
+            _uniqueID = contentType.Key;
+            _nodeObjectType = objectType;
+            _level = contentType.Level;
+            _path = contentType.Path;
+            _parentid = contentType.ParentId;
+            _text = contentType.Name;
+            _sortOrder = contentType.SortOrder;
+            _userId = contentType.CreatorId;
+            _createDate = contentType.CreateDate;
+            _isTrashed = false;
+        }
+
         #endregion
 
         #region Private Methods
diff --git a/src/umbraco.cms/businesslogic/Content.cs b/src/umbraco.cms/businesslogic/Content.cs
index 0a10eb48c5..ab641eba4e 100644
--- a/src/umbraco.cms/businesslogic/Content.cs
+++ b/src/umbraco.cms/businesslogic/Content.cs
@@ -1,21 +1,18 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-
-using System.Data;
 using System.Xml;
+using Umbraco.Core;
 using Umbraco.Core.IO;
+using Umbraco.Core.Models;
 using umbraco.cms.businesslogic.property;
-using umbraco.cms.businesslogic.propertytype;
 using umbraco.DataLayer;
 using System.Runtime.CompilerServices;
 using umbraco.cms.helpers;
-using umbraco.BusinessLogic;
-using umbraco.interfaces;
-using System.IO;
-using umbraco.IO;
 using umbraco.cms.businesslogic.datatype.controls;
-using Umbraco.Core;
+using File = System.IO.File;
+using Property = umbraco.cms.businesslogic.property.Property;
+using PropertyType = umbraco.cms.businesslogic.propertytype.PropertyType;
 
 namespace umbraco.cms.businesslogic
 {
@@ -29,6 +26,7 @@ namespace umbraco.cms.businesslogic
     /// Note that Content data in umbraco is *not* tablular but in a treestructure.
     /// 
     /// </summary>
+    [Obsolete("Deprecated, Use Umbraco.Core.Models.Content or Umbraco.Core.Models.Media", false)]
     public class Content : CMSNode
     {
         #region Private Members
@@ -40,10 +38,11 @@ namespace umbraco.cms.businesslogic
         private string _contentTypeIcon;
         private ContentType _contentType;
         private Properties m_LoadedProperties = null;
+        private IContentBase _contentBase;
 
         #endregion
 
-        #region Constructors        
+        #region Constructors
       
         public Content(int id) : base(id) { }
 
@@ -53,6 +52,15 @@ namespace umbraco.cms.businesslogic
 
         protected Content(Guid id, bool noSetup) : base(id, noSetup) { }
 
+        protected internal Content(IContentBase contentBase)
+            : base(contentBase)
+        {
+            _contentBase = contentBase;
+            _version = _contentBase.Version;
+            _versionDate = _contentBase.UpdateDate;
+            _versionDateInitialized = true;
+        }
+
         #endregion
 
         #region Static Methods
@@ -62,18 +70,17 @@ namespace umbraco.cms.businesslogic
         /// </summary>
         /// <param name="ct">The ContentType</param>
         /// <returns>A list of Content objects sharing the ContentType defined.</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetContentOfContentType() or Umbraco.Core.Services.MediaService.GetMediaOfMediaType()", false)]
         public static Content[] getContentOfContentType(ContentType ct)
         {
-            IRecordsReader dr = SqlHelper.ExecuteReader("Select nodeId from  cmsContent INNER JOIN umbracoNode ON cmsContent.nodeId = umbracoNode.id where ContentType = " + ct.Id + " ORDER BY umbracoNode.text ");
-            System.Collections.ArrayList tmp = new System.Collections.ArrayList();
+            var list = new List<Content>();
+            var content = ApplicationContext.Current.Services.ContentService.GetContentOfContentType(ct.Id);
+            list.AddRange(content.OrderBy(x => x.Name).Select(x => new Content(x)));
 
-            while (dr.Read()) tmp.Add(dr.GetInt("nodeId"));
-            dr.Close();
+            var media = ApplicationContext.Current.Services.MediaService.GetMediaOfMediaType(ct.Id);
+            list.AddRange(media.OrderBy(x => x.Name).Select(x => new Content(x)));
 
-            Content[] retval = new Content[tmp.Count];
-            for (int i = 0; i < tmp.Count; i++) retval[i] = new Content((int)tmp[i]);
-
-            return retval;
+            return list.ToArray();
         }
 
         /// <summary>
@@ -81,10 +88,17 @@ namespace umbraco.cms.businesslogic
         /// </summary>
         /// <param name="version">The version identifier</param>
         /// <returns>The Content object from the given version</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetByIdVersion() or Umbraco.Core.Services.MediaService.GetByIdVersion()", false)]
         public static Content GetContentFromVersion(Guid version)
         {
-            int tmpContentId = SqlHelper.ExecuteScalar<int>("Select ContentId from cmsContentVersion where versionId = '" + version.ToString() + "'");
-            return new Content(tmpContentId);
+            var content = ApplicationContext.Current.Services.ContentService.GetByVersion(version);
+            if (content != null)
+            {
+                return new Content(content);
+            }
+
+            var media = ApplicationContext.Current.Services.MediaService.GetByVersion(version);
+            return new Content(media);
         }
 
         #endregion
@@ -219,22 +233,6 @@ namespace umbraco.cms.businesslogic
             {
                 EnsureProperties();
                 return m_LoadedProperties.ToArray();
-
-                //if (this.ContentType == null)
-                //    return new Property[0];
-
-                //List<Property> result = new List<Property>();
-                //foreach (PropertyType prop in this.ContentType.PropertyTypes)
-                //{
-                //    if (prop == null)
-                //        continue;
-                //    Property p = getProperty(prop);
-                //    if (p == null)
-                //        continue;
-                //    result.Add(p);
-                //}
-
-                //return result.ToArray();
             }
         }
 
@@ -282,15 +280,12 @@ namespace umbraco.cms.businesslogic
         /// </summary>
         /// <param name="alias">Propertyalias (defined in the documenttype)</param>
         /// <returns>The property with the given alias</returns>
-        public Property getProperty(string alias)
+        public virtual Property getProperty(string alias)
         {
-            ContentType ct = this.ContentType;
-            if (ct == null)
-                return null;
-            propertytype.PropertyType pt = ct.getPropertyType(alias);
-            if (pt == null)
-                return null;
-            return getProperty(pt);
+            EnsureProperties();
+
+            var prop = m_LoadedProperties.SingleOrDefault(x => x.PropertyType.Alias == alias);
+            return prop;
         }
 
         /// <summary>
@@ -298,7 +293,7 @@ namespace umbraco.cms.businesslogic
         /// </summary>
         /// <param name="pt">PropertyType</param>
         /// <returns>The property with the given propertytype</returns>
-        public Property getProperty(PropertyType pt)
+        public virtual Property getProperty(PropertyType pt)
         {
             EnsureProperties();
 
@@ -314,7 +309,7 @@ namespace umbraco.cms.businesslogic
         /// <param name="pt">The PropertyType of the Property</param>
         /// <param name="versionId">The version of the document on which the property should be add'ed</param>
         /// <returns>The new Property</returns>
-        public Property addProperty(PropertyType pt, Guid versionId)
+        public virtual Property addProperty(PropertyType pt, Guid versionId)
         {
             ClearLoadedProperties();
             
@@ -401,7 +396,7 @@ namespace umbraco.cms.businesslogic
 
         public virtual void XmlPopulate(XmlDocument xd, ref XmlNode x, bool Deep)
         {
-            var props = this.getProperties;
+            var props = this.GenericProperties;
             foreach (property.Property p in props)
                 if (p != null)
                     x.AppendChild(p.ToXml(xd));
@@ -482,6 +477,7 @@ namespace umbraco.cms.businesslogic
 
             if (_contentType == null)
                 _contentType = ContentType.GetContentType(InitContentType);
+
             _version = InitVersion;
             _versionDate = InitVersionDate;
             _contentTypeIcon = InitContentTypeIcon;
@@ -491,17 +487,14 @@ namespace umbraco.cms.businesslogic
         /// Creates a new Content object from the ContentType.
         /// </summary>
         /// <param name="ct"></param>
-        protected void CreateContent(ContentType ct)
+        protected virtual void CreateContent(ContentType ct)
         {
             SqlHelper.ExecuteNonQuery("insert into cmsContent (nodeId,ContentType) values (" + this.Id + "," + ct.Id + ")");
             createNewVersion(DateTime.Now);
         }
-
-
-
+        
         /// <summary>
-        /// Method for creating a new version of the data associated to the Content.
-        /// 
+        /// Method for creating a new version of the data associated to the Content. 
         /// </summary>
         /// <returns>The new version Id</returns>
 		protected Guid createNewVersion(DateTime versionDate = default(DateTime))
@@ -653,6 +646,12 @@ namespace umbraco.cms.businesslogic
         {
             m_LoadedProperties = new Properties();
 
+            if (_contentBase != null)
+            {
+                m_LoadedProperties.AddRange(_contentBase.Properties.Select(x => new Property(x)));
+                return;
+            }
+
             if (this.ContentType == null)
                 return;
 
@@ -678,9 +677,7 @@ namespace umbraco.cms.businesslogic
                     continue;
 
                 //get the propertyId
-                var property = propData
-                    .Where(x => x.PropertyTypeId == pt.Id)
-                    .SingleOrDefault();
+                var property = propData.LastOrDefault(x => x.PropertyTypeId == pt.Id);
                 if (property == null)
                     continue;
                 var propertyId = property.Id;
diff --git a/src/umbraco.cms/businesslogic/ContentType.cs b/src/umbraco.cms/businesslogic/ContentType.cs
index 797184218c..55f224c783 100644
--- a/src/umbraco.cms/businesslogic/ContentType.cs
+++ b/src/umbraco.cms/businesslogic/ContentType.cs
@@ -1,17 +1,18 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using System.Runtime.CompilerServices;
 using System.Linq;
+using Umbraco.Core;
+using Umbraco.Core.Models;
 using umbraco.cms.businesslogic.cache;
-using umbraco.cms.businesslogic.datatype;
-using umbraco.cms.businesslogic.language;
 using umbraco.cms.businesslogic.propertytype;
 using umbraco.cms.businesslogic.web;
 using umbraco.DataLayer;
-using umbraco.BusinessLogic;
+using DataTypeDefinition = umbraco.cms.businesslogic.datatype.DataTypeDefinition;
+using Language = umbraco.cms.businesslogic.language.Language;
+using PropertyType = umbraco.cms.businesslogic.propertytype.PropertyType;
 
 namespace umbraco.cms.businesslogic
 {
@@ -24,9 +25,9 @@ namespace umbraco.cms.businesslogic
     /// Besides data definition, the ContentType also defines the sorting and grouping (in tabs) of Properties/Datafields
     /// on the Content and which Content (by ContentType) can be created as child to the Content of the ContentType.
     /// </summary>
+    [Obsolete("Deprecated, Use Umbraco.Core.Models.ContentType or Umbraco.Core.Models.MediaType", false)]
     public class ContentType : CMSNode
     {
-
         #region Constructors
 
         /// <summary>
@@ -45,24 +46,6 @@ namespace umbraco.cms.businesslogic
 
         public ContentType(Guid id, bool noSetup) : base(id, noSetup) { }
 
-        ///// <summary>
-        ///// Initializes a new instance of the <see cref="ContentType"/> class.
-        ///// </summary>
-        ///// <param name="id">The id.</param>
-        ///// <param name="UseOptimizedMode">if set to <c>true</c> [use optimized mode] which loads in the data from the 
-        ///// database in an optimized manner (less queries)
-        ///// </param>
-        //public ContentType(bool optimizedMode, int id)
-        //    : base(id, optimizedMode)
-        //{
-        //    this._optimizedMode = optimizedMode;
-
-        //    if (optimizedMode)
-        //    {
-
-        //    }
-        //}
-
         /// <summary>
         /// Creates a new content type object manually.
         /// </summary>
@@ -82,12 +65,19 @@ namespace umbraco.cms.businesslogic
             _alias = alias;
             _iconurl = icon;
             _thumbnail = thumbnail;
+            
             if (masterContentType.HasValue)
                 MasterContentType = masterContentType.Value;
+
             if (isContainer.HasValue)
                 _isContainerContentType = isContainer.Value;
         }
 
+        internal ContentType(IContentTypeComposition contentType) : base(contentType)
+        {
+            _contentType = contentType;
+        }
+
         #endregion
 
         #region Constants and static members
@@ -289,10 +279,74 @@ namespace umbraco.cms.businesslogic
 
         private static readonly object propertyTypesCacheSyncLock = new object();
 
+        private IContentTypeComposition _contentType;
+
         #endregion
 
         #region Public Properties
 
+        /// <summary>
+        /// The Alias of the ContentType, is used for import/export and more human readable initialization see: GetByAlias 
+        /// method.
+        /// </summary>
+        public string Alias
+        {
+            get { return _alias; }
+            set
+            {
+                _alias = helpers.Casing.SafeAliasWithForcingCheck(value);
+
+                // validate if alias is empty
+                if (String.IsNullOrEmpty(_alias))
+                {
+                    throw new ArgumentOutOfRangeException("An Alias cannot be empty");
+                }
+
+                //This switches between using new vs. legacy api.
+                //Note that this is currently only done to support both DocumentType and MediaType, which use the new api and MemberType that doesn't.
+                if (_contentType == null)
+                {
+                    SqlHelper.ExecuteNonQuery("update cmsContentType set alias = @alias where nodeId = @id",
+                                              SqlHelper.CreateParameter("@alias", _alias),
+                                              SqlHelper.CreateParameter("@id", Id));
+                }
+                else
+                {
+                    _contentType.Alias = _alias;
+                }
+
+                // Remove from cache
+                FlushFromCache(Id);
+            }
+        }
+
+        /// <summary>
+        /// A Content object is often (always) represented in the treeview in the Umbraco console, the ContentType defines
+        /// which Icon the Content of this type is representated with.
+        /// </summary>
+        public string IconUrl
+        {
+            get { return _iconurl; }
+            set
+            {
+                _iconurl = value;
+
+                //This switches between using new vs. legacy api.
+                //Note that this is currently only done to support both DocumentType and MediaType, which use the new api and MemberType that doesn't.
+                if (_contentType == null)
+                {
+                    SqlHelper.ExecuteNonQuery("update cmsContentType set icon='" + value + "' where nodeid = " + Id);
+                }
+                else
+                {
+                    _contentType.Icon = _iconurl;
+                }
+
+                // Remove from cache
+                FlushFromCache(Id);
+            }
+        }
+
         /// <summary>
         /// Get or Sets the Container status of the Content Type. A Container Content Type doesn't show its children in the tree,
         /// but instead adds a tab when edited showing its children in a grid
@@ -303,25 +357,49 @@ namespace umbraco.cms.businesslogic
             set
             {
                 _isContainerContentType = value;
-                SqlHelper.ExecuteNonQuery(
+
+                //This switches between using new vs. legacy api.
+                //Note that this is currently only done to support both DocumentType and MediaType, which use the new api and MemberType that doesn't.
+                if (_contentType == null)
+                {
+                    SqlHelper.ExecuteNonQuery(
                                           "update cmsContentType set isContainer = @isContainer where nodeId = @id",
                                           SqlHelper.CreateParameter("@isContainer", value),
                                           SqlHelper.CreateParameter("@id", Id));
+                }
+                else
+                {
+                    _contentType.IsContainer = _isContainerContentType;
+                }
             }
         }
 
+        /// <summary>
+        /// Gets or sets the 'allow at root' boolean
+        /// </summary>
         public bool AllowAtRoot
         {
             get { return _allowAtRoot; }
             set
             {
                 _allowAtRoot = value;
-                SqlHelper.ExecuteNonQuery(
+
+                //This switches between using new vs. legacy api. 
+                //Note that this is currently only done to support both DocumentType and MediaType, which use the new api and MemberType that doesn't.
+                if (_contentType == null)
+                {
+                    SqlHelper.ExecuteNonQuery(
                                           "update cmsContentType set allowAtRoot = @allowAtRoot where nodeId = @id",
                                           SqlHelper.CreateParameter("@allowAtRoot", value),
                                           SqlHelper.CreateParameter("@id", Id));
+                }
+                else
+                {
+                    _contentType.AllowedAsRoot = _allowAtRoot;
+                }
             }
         }
+        
         /// <summary>
         /// Gets or sets the description.
         /// </summary>
@@ -356,10 +434,20 @@ namespace umbraco.cms.businesslogic
             set
             {
                 _description = value;
-                SqlHelper.ExecuteNonQuery(
+
+                //This switches between using new vs. legacy api. 
+                //Note that this is currently only done to support both DocumentType and MediaType, which use the new api and MemberType that doesn't.
+                if (_contentType == null)
+                {
+                    SqlHelper.ExecuteNonQuery(
                                           "update cmsContentType set description = @description where nodeId = @id",
                                           SqlHelper.CreateParameter("@description", value),
                                           SqlHelper.CreateParameter("@id", Id));
+                }
+                else
+                {
+                    _contentType.Description = _description;
+                }
 
                 FlushFromCache(Id);
             }
@@ -375,25 +463,25 @@ namespace umbraco.cms.businesslogic
             set
             {
                 _thumbnail = value;
-                SqlHelper.ExecuteNonQuery(
+
+                //This switches between using new vs. legacy api. 
+                //Note that this is currently only done to support both DocumentType and MediaType, which use the new api and MemberType that doesn't.
+                if (_contentType == null)
+                {
+                    SqlHelper.ExecuteNonQuery(
                                           "update cmsContentType set thumbnail = @thumbnail where nodeId = @id",
                                           SqlHelper.CreateParameter("@thumbnail", value),
                                           SqlHelper.CreateParameter("@id", Id));
+                }
+                else
+                {
+                    _contentType.Thumbnail = _thumbnail;
+                }
 
                 FlushFromCache(Id);
             }
         }
 
-        ///// <summary>
-        ///// Gets or sets a value indicating whether [optimized mode].
-        ///// </summary>
-        ///// <value><c>true</c> if [optimized mode]; otherwise, <c>false</c>.</value>
-        //public bool OptimizedMode
-        //{
-        //    get { return _optimizedMode; }
-        //    set { _optimizedMode = value; }
-        //}
-
         /// <summary>
         /// Human readable name/label
         /// </summary>
@@ -426,6 +514,11 @@ namespace umbraco.cms.businesslogic
             {
                 base.Text = value;
 
+                if (_contentType != null)
+                {
+                    _contentType.Name = value;
+                }
+
                 // Remove from cache
                 FlushFromCache(Id);
             }
@@ -482,50 +575,6 @@ namespace umbraco.cms.businesslogic
             }
         }
 
-        /// <summary>
-        /// The Alias of the ContentType, is used for import/export and more human readable initialization see: GetByAlias 
-        /// method.
-        /// </summary>
-        public string Alias
-        {
-            get { return _alias; }
-            set
-            {
-                _alias = helpers.Casing.SafeAliasWithForcingCheck(value);
-
-                // validate if alias is empty
-                if (String.IsNullOrEmpty(_alias))
-                {
-                    throw new ArgumentOutOfRangeException("An Alias cannot be empty");
-                }
-
-                SqlHelper.ExecuteNonQuery(
-                                          "update cmsContentType set alias = @alias where nodeId = @id",
-                                          SqlHelper.CreateParameter("@alias", _alias),
-                                          SqlHelper.CreateParameter("@id", Id));
-
-                // Remove from cache
-                FlushFromCache(Id);
-            }
-        }
-
-        /// <summary>
-        /// A Content object is often (always) represented in the treeview in the Umbraco console, the ContentType defines
-        /// which Icon the Content of this type is representated with.
-        /// </summary>
-        public string IconUrl
-        {
-            get { return _iconurl; }
-            set
-            {
-                _iconurl = value;
-                SqlHelper.ExecuteNonQuery("update cmsContentType set icon='" + value + "' where nodeid = " + Id);
-                // Remove from cache
-                FlushFromCache(Id);
-            }
-        }
-
-
         public List<int> MasterContentTypes
         {
             get
@@ -587,6 +636,8 @@ namespace umbraco.cms.businesslogic
                     SqlHelper.CreateParameter("@parentContentTypeId", parentContentTypeId),
                     SqlHelper.CreateParameter("@childContentTypeId", Id));
                 MasterContentTypes.Add(parentContentTypeId);
+
+
             }
         }
 
@@ -719,13 +770,31 @@ namespace umbraco.cms.businesslogic
             {
                 m_AllowedChildContentTypeIDs = value.ToList();
 
-                SqlHelper.ExecuteNonQuery(
-                                          "delete from cmsContentTypeAllowedContentType where id=" + Id);
-                foreach (int i in value)
+                //This switches between using new vs. legacy api.
+                //Note that this is currently only done to support both DocumentType and MediaType, which use the new api and MemberType that doesn't.
+                if (_contentType == null)
                 {
                     SqlHelper.ExecuteNonQuery(
-                                              "insert into cmsContentTypeAllowedContentType (id,AllowedId) values (" +
-                                              Id + "," + i + ")");
+                        "delete from cmsContentTypeAllowedContentType where id=" + Id);
+                    foreach (int i in value)
+                    {
+                        SqlHelper.ExecuteNonQuery(
+                            "insert into cmsContentTypeAllowedContentType (id,AllowedId) values (" +
+                            Id + "," + i + ")");
+                    }
+                }
+                else
+                {
+                    var list = new List<ContentTypeSort>();
+                    int sort = 0;
+                    foreach (var i in value)
+                    {
+                        int id = i;
+                        list.Add(new ContentTypeSort{Id = new Lazy<int>(() => id), SortOrder = sort});
+                        sort++;
+                    }
+
+                    _contentType.AllowedContentTypes = list;
                 }
             }
         }
@@ -910,11 +979,6 @@ namespace umbraco.cms.businesslogic
             // NH 22-08-08, Get from the property type stack to ensure support of master document types
             object o = this.PropertyTypes.Find(pt => pt.Alias == alias);
 
-            //object o = SqlHelper.ExecuteScalar<object>(
-            //    "Select id from cmsPropertyType where contentTypeId=@contentTypeId And Alias=@alias",
-            //    SqlHelper.CreateParameter("@contentTypeId", this.Id),
-            //    SqlHelper.CreateParameter("@alias", alias));
-
             if (o == null)
             {
                 return null;
@@ -923,12 +987,6 @@ namespace umbraco.cms.businesslogic
             {
                 return (PropertyType)o;
             }
-
-            //int propertyTypeId;
-            //if (!int.TryParse(o.ToString(), out propertyTypeId))
-            //    return null;
-
-            //return PropertyType.GetPropertyType(propertyTypeId);
         }
 
         /// <summary>
@@ -973,6 +1031,19 @@ namespace umbraco.cms.businesslogic
 
         #region Protected Methods
 
+        internal protected void PopulateContentTypeFromContentTypeBase(IContentTypeComposition contentType)
+        {
+            _alias = contentType.Alias;
+            _iconurl = contentType.Icon;
+            _isContainerContentType = contentType.IsContainer;
+            _allowAtRoot = contentType.AllowedAsRoot;
+            _thumbnail = contentType.Thumbnail;
+            _description = contentType.Description;
+
+            if (_contentType == null)
+                _contentType = contentType;
+        }
+
         protected void PopulateContentTypeNodeFromReader(IRecordsReader dr)
         {
             _alias = dr.GetString("Alias");
@@ -993,6 +1064,26 @@ namespace umbraco.cms.businesslogic
         {
             base.setupNode();
 
+            //Try to load the ContentType/MediaType through the new public api
+            if (nodeObjectType == new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB"))
+            {
+                var contentType = ApplicationContext.Current.Services.ContentTypeService.GetContentType(Id);
+                if (contentType != null)
+                {
+                    PopulateContentTypeFromContentTypeBase(contentType);
+                    return;
+                }
+            }
+            else if (nodeObjectType == new Guid("4EA4382B-2F5A-4C2B-9587-AE9B3CF3602E"))
+            {
+                var mediaType = ApplicationContext.Current.Services.ContentTypeService.GetMediaType(Id);
+                if (mediaType != null)
+                {
+                    PopulateContentTypeFromContentTypeBase(mediaType);
+                    return;
+                }
+            }
+
             // TODO: Load master content types
             using (IRecordsReader dr =
                 SqlHelper.ExecuteReader("Select allowAtRoot, isContainer, Alias,icon,thumbnail,description from cmsContentType where nodeid=" + Id)
@@ -1009,15 +1100,6 @@ namespace umbraco.cms.businesslogic
             }
         }
 
-        /// <summary>
-        /// Set up the internal data of the ContentType
-        /// </summary>
-        [Obsolete("Use the overriden setupNode method instead. This method now calls that method")]
-        protected void setupContentType()
-        {
-            setupNode();
-        }
-
         /// <summary>
         /// Flushes the cache.
         /// </summary>
@@ -1057,7 +1139,6 @@ namespace umbraco.cms.businesslogic
         #endregion
 
         #region Private Methods
-
         /// <summary>
         /// The cache key used to cache the properties for the content type
         /// </summary>
@@ -1507,43 +1588,5 @@ namespace umbraco.cms.businesslogic
         }
         #endregion
 
-
-        ///// <summary>
-        ///// Analyzes the content types.
-        ///// </summary>
-        ///// <param name="ObjectType">Type of the object.</param>
-        ///// <param name="ForceUpdate">if set to <c>true</c> [force update].</param>
-        //protected void AnalyzeContentTypes(Guid ObjectType, bool ForceUpdate)
-        //{
-        //    if (!_analyzedContentTypes.ContainsKey(ObjectType) || ForceUpdate)
-        //    {
-        //        using (IRecordsReader dr = SqlHelper.ExecuteReader(
-        //                                                          "select id from umbracoNode where nodeObjectType = @objectType",
-        //                                                          SqlHelper.CreateParameter("@objectType", ObjectType)))
-        //        {
-        //            while (dr.Read())
-        //            {
-        //                ContentType ct = new ContentType(dr.GetInt("id"));
-        //                if (!_optimizedContentTypes.ContainsKey(ct.UniqueId))
-        //                    _optimizedContentTypes.Add(ct.UniqueId, false);
-
-        //                _optimizedContentTypes[ct.UniqueId] = usesUmbracoDataOnly(ct);
-        //            }
-        //        }
-        //    }
-        //}
-
-        ///// <summary>
-        ///// Determines whether this instance is optimized.
-        ///// </summary>
-        ///// <returns>
-        ///// 	<c>true</c> if this instance is optimized; otherwise, <c>false</c>.
-        ///// </returns>
-        //protected bool IsOptimized()
-        //{
-        //    return (bool) _optimizedContentTypes[UniqueId];
-        //}
-
-
     }
 }
diff --git a/src/umbraco.cms/businesslogic/Packager/Installer.cs b/src/umbraco.cms/businesslogic/Packager/Installer.cs
index f5a0b26563..4c18d9cb5a 100644
--- a/src/umbraco.cms/businesslogic/Packager/Installer.cs
+++ b/src/umbraco.cms/businesslogic/Packager/Installer.cs
@@ -856,6 +856,7 @@ namespace umbraco.cms.businesslogic.packager
             foreach (DocumentType.TabI t in dt.getVirtualTabs.ToList())
                 DocumentType.FlushTabCache(t.Id, dt.Id);
 
+            dt.Save();
         }
 
         /// <summary>
diff --git a/src/umbraco.cms/businesslogic/Property/Property.cs b/src/umbraco.cms/businesslogic/Property/Property.cs
index aec8ab3f83..8404081677 100644
--- a/src/umbraco.cms/businesslogic/Property/Property.cs
+++ b/src/umbraco.cms/businesslogic/Property/Property.cs
@@ -1,11 +1,12 @@
 using System;
-using System.Collections.Generic;
-using System.Data;
 using System.Runtime.CompilerServices;
 using System.Xml;
-
+using Umbraco.Core;
+using Umbraco.Core.Persistence;
 using umbraco.DataLayer;
 using umbraco.BusinessLogic;
+using umbraco.cms.businesslogic.datatype;
+using umbraco.cms.businesslogic.propertytype;
 
 namespace umbraco.cms.businesslogic.property
 {
@@ -15,9 +16,10 @@ namespace umbraco.cms.businesslogic.property
     /// </summary>
     public class Property
     {
-        private static string _connstring = GlobalSettings.DbDSN;
-        propertytype.PropertyType _pt;
-        interfaces.IData _data;
+        private Umbraco.Core.Models.PropertyType _propertyType;
+        private Umbraco.Core.Models.Property _property;
+        private PropertyType _pt;
+        private interfaces.IData _data;
         private int _id;
 
         protected static ISqlHelper SqlHelper
@@ -25,6 +27,11 @@ namespace umbraco.cms.businesslogic.property
             get { return Application.SqlHelper; }
         }
 
+        internal static Database Database
+        {
+            get { return ApplicationContext.Current.DatabaseContext.Database; }
+        }
+
         public Property(int Id, propertytype.PropertyType pt)
         {
 
@@ -37,8 +44,21 @@ namespace umbraco.cms.businesslogic.property
         public Property(int Id)
         {
             _id = Id;
-            _pt = umbraco.cms.businesslogic.propertytype.PropertyType.GetPropertyType(
-                SqlHelper.ExecuteScalar<int>("select propertytypeid from cmsPropertyData where id = @id", SqlHelper.CreateParameter("@id", Id)));
+            _pt = PropertyType.GetPropertyType(
+                SqlHelper.ExecuteScalar<int>("select propertytypeid from cmsPropertyData where id = @id",
+                                             SqlHelper.CreateParameter("@id", Id)));
+            _data = _pt.DataTypeDefinition.DataType.Data;
+            _data.PropertyId = Id;
+        }
+
+        internal Property(Umbraco.Core.Models.Property property)
+        {
+            _id = property.Id;
+            _property = property;
+            _propertyType = property.PropertyType;
+
+            //Just to ensure that there is a PropertyType available
+            _pt = PropertyType.GetPropertyType(property.PropertyTypeId);
             _data = _pt.DataTypeDefinition.DataType.Data;
             _data.PropertyId = Id;
         }
@@ -60,7 +80,13 @@ namespace umbraco.cms.businesslogic.property
         }
         public propertytype.PropertyType PropertyType
         {
-            get { return _pt; }
+            get
+            {
+                /*if (_propertyType != null)
+                    return new PropertyType(_propertyType);*/
+
+                return _pt;
+            }
         }
 
         public object Value
diff --git a/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs b/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs
index 9081532ce6..a782e61a7f 100644
--- a/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs
+++ b/src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs
@@ -22,8 +22,10 @@ namespace umbraco.cms.businesslogic.datatype
         #region Private fields
         private Guid _controlId;
 
-        private static Guid _objectType = new Guid("30a2a501-1978-4ddb-a57b-f7efed43ba3c"); 
-        #endregion
+        private static Guid _objectType = new Guid("30a2a501-1978-4ddb-a57b-f7efed43ba3c");
+	    private string _dbType;
+
+	    #endregion
 
         #region Constructors
 
@@ -74,6 +76,10 @@ namespace umbraco.cms.businesslogic.datatype
                 _controlId = value.Id;
             }
         } 
+	    internal string DbType
+	    {
+            get { return _dbType; }
+	    }
         #endregion
 
         #region Public methods
@@ -330,6 +336,7 @@ namespace umbraco.cms.businesslogic.datatype
                 if (dr.Read())
                 {
                     _controlId = dr.GetGuid("controlId");
+                    _dbType = dr.GetString("dbType");
                 }
                 else
                     throw new ArgumentException("No dataType with id = " + this.Id.ToString() + " found");
diff --git a/src/umbraco.cms/businesslogic/datatype/DefaultData.cs b/src/umbraco.cms/businesslogic/datatype/DefaultData.cs
index 8eaa3760f7..ece234542e 100644
--- a/src/umbraco.cms/businesslogic/datatype/DefaultData.cs
+++ b/src/umbraco.cms/businesslogic/datatype/DefaultData.cs
@@ -1,6 +1,9 @@
 using System;
-using System.Data;
+using System.Linq;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence;
 using umbraco.DataLayer;
 using umbraco.BusinessLogic;
 using umbraco.interfaces;
@@ -19,11 +22,19 @@ namespace umbraco.cms.businesslogic.datatype
         private bool m_PreviewMode;
         private bool m_ValueLoaded = false;
 
+        [Obsolete("Deprecated, For querying the database use the new UmbracoDatabase object ApplicationContext.Current.DatabaseContext.Database", false)]
         protected static ISqlHelper SqlHelper
         {
             get { return Application.SqlHelper; }
         }
 
+        //TODO Refactor this class to use the Database object instead of the SqlHelper
+        //NOTE DatabaseContext.Current.Database should eventually be replaced with that from the Repository-Resolver refactor branch. 
+        internal static Database Database
+        {
+            get { return ApplicationContext.Current.DatabaseContext.Database; }
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="DefaultData"/> class.
         /// </summary>
@@ -49,33 +60,29 @@ namespace umbraco.cms.businesslogic.datatype
         /// </summary>
         protected virtual void LoadValueFromDatabase()
         {
+            var sql = new Sql();
+            sql.Select("*")
+               .From<PropertyDataDto>()
+               .InnerJoin<PropertyTypeDto>()
+               .On<PropertyTypeDto, PropertyDataDto>(x => x.Id, y => y.PropertyTypeId)
+               .InnerJoin<DataTypeDto>()
+               .On<DataTypeDto, PropertyTypeDto>(x => x.DataTypeId, y => y.DataTypeId)
+               .Where("cmsPropertyData.id = @Id", new {Id = m_PropertyId});
+            var dto = Database.Fetch<PropertyDataDto, PropertyTypeDto, DataTypeDto>(sql).FirstOrDefault();
 
-            //this is an optimized version of this query. In one call it will return the data type
-            //and the values, this will then set the underlying db type and value of the BaseDataType object
-            //instead of having it query the database itself.
-            var sql = @"
-                SELECT dataInt, dataDate, dataNvarchar, dataNtext, dbType FROM cmsPropertyData 
-                INNER JOIN cmsPropertyType ON cmsPropertyType.id = cmsPropertyData.propertytypeid
-                INNER JOIN cmsDataType ON cmsDataType.nodeId = cmsPropertyType.dataTypeId
-                WHERE cmsPropertyData.id = " + m_PropertyId;
-
-            using (var r = SqlHelper.ExecuteReader(sql))
+            if (dto != null)
             {
-                if (r.Read())
-                {
-                    //the type stored in the cmsDataType table
-                    var strDbType = r.GetString("dbType"); 
-                    //get the enum of the data type
-                    var dbType = BaseDataType.GetDBType(strDbType); 
-                    //get the column name in the cmsPropertyData table that stores the correct information for the data type
-                    var fieldName = BaseDataType.GetDataFieldName(dbType);
-                    //get the value for the data type, if null, set it to an empty string
-                    m_Value = r.GetObject(fieldName) ?? string.Empty;
-
-                    //now that we've set our value, we can update our BaseDataType object with the correct values from the db
-                    //instead of making it query for itself. This is a peformance optimization enhancement.
-                    _dataType.SetDataTypeProperties(fieldName, dbType);
-                }                
+                //the type stored in the cmsDataType table
+                var strDbType = dto.PropertyTypeDto.DataTypeDto.DbType;
+                //get the enum of the data type
+                var dbType = BaseDataType.GetDBType(strDbType);
+                //get the column name in the cmsPropertyData table that stores the correct information for the data type
+                var fieldName = BaseDataType.GetDataFieldName(dbType);
+                //get the value for the data type, if null, set it to an empty string
+                m_Value = dto.GetValue;
+                //now that we've set our value, we can update our BaseDataType object with the correct values from the db
+                //instead of making it query for itself. This is a peformance optimization enhancement.
+                _dataType.SetDataTypeProperties(fieldName, dbType);
             }
         }
 
@@ -83,7 +90,7 @@ namespace umbraco.cms.businesslogic.datatype
         {
             get
             {
-                return this._dataType.DBType;
+                return _dataType.DBType;
             }
         }
 
@@ -95,7 +102,6 @@ namespace umbraco.cms.businesslogic.datatype
             }
         }
 
-
 		#region IData Members
 
         /// <summary>
@@ -106,7 +112,7 @@ namespace umbraco.cms.businesslogic.datatype
 		public virtual XmlNode ToXMl(XmlDocument data)
 		{
             string sValue = Value!=null ? Value.ToString() : String.Empty;
-			if (this._dataType.DBType == DBTypes.Ntext)
+			if (_dataType.DBType == DBTypes.Ntext)
                 return data.CreateCDataSection(sValue);
             return data.CreateTextNode(sValue);
 		}
@@ -129,38 +135,8 @@ namespace umbraco.cms.businesslogic.datatype
 			}
 			set 
 			{
-                if (!PreviewMode)
-                {
-                    // Try to set null values if possible
-                    try
-                    {
-                        //CHANGE:by Allan Laustsen to fix copy nodes
-                        //if (value == null)
-                        if (value == null ||
-                            (string.IsNullOrEmpty(value.ToString()) &&
-                             (this._dataType.DBType == DBTypes.Integer || this._dataType.DBType == DBTypes.Date)))
-                            SqlHelper.ExecuteNonQuery("update cmsPropertyData set " + _dataType.DataFieldName +
-                                                      " = NULL where id = " + m_PropertyId);
-                        else
-                        {
-                            // we need to be sure that the value doesn't contain malformatted xml
-                            if (_dataType.DBType == DBTypes.Ntext || _dataType.DBType == DBTypes.Nvarchar)
-                            {
-                                value = cms.helpers.xhtml.RemoveIllegalXmlCharacters(value.ToString());
-                            }
-                            SqlHelper.ExecuteNonQuery(
-                                "update cmsPropertyData set " + _dataType.DataFieldName + " = @value where id = " +
-                                m_PropertyId, SqlHelper.CreateParameter("@value", value));
-                        }
-                    }
-                    catch (Exception e)
-                    {
-						LogHelper.Error<DefaultData>("Error updating item", e);
-                        if (value == null) value = "";
-                        SqlHelper.ExecuteNonQuery("update cmsPropertyData set " + _dataType.DataFieldName + " = @value where id = " + m_PropertyId, SqlHelper.CreateParameter("@value", value));
-                    }
-                }
                 m_Value = value;
+                m_ValueLoaded = true;
 			}
 		}
 
@@ -206,12 +182,9 @@ namespace umbraco.cms.businesslogic.datatype
         public virtual Guid Version
         {
 			get
-            {
-                using (IRecordsReader dr = SqlHelper.ExecuteReader("SELECT versionId FROM cmsPropertyData WHERE id = " + PropertyId))
-                {
-                    dr.Read();
-                    return dr.GetGuid("versionId");
-                }
+			{
+			    var dto = Database.FirstOrDefault<PropertyDataDto>("WHERE id = @Id", new {Id = PropertyId});
+			    return dto.VersionId.HasValue ? dto.VersionId.Value : Guid.Empty;
 			}
 		}
 
@@ -222,8 +195,8 @@ namespace umbraco.cms.businesslogic.datatype
         public virtual int NodeId
         {
 			get
-            {
-				return SqlHelper.ExecuteScalar<int>("Select contentNodeid from cmsPropertyData where id = " + PropertyId);
+			{
+			    return Database.ExecuteScalar<int>("Select contentNodeid from cmsPropertyData where id = @Id", new {Id = PropertyId});
 			}
 		}
 
diff --git a/src/umbraco.cms/businesslogic/media/Media.cs b/src/umbraco.cms/businesslogic/media/Media.cs
index 5086077faf..2235eac510 100644
--- a/src/umbraco.cms/businesslogic/media/Media.cs
+++ b/src/umbraco.cms/businesslogic/media/Media.cs
@@ -1,14 +1,12 @@
 using System;
-using System.IO;
-using umbraco.BusinessLogic.Actions;
+using Umbraco.Core;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
 using umbraco.DataLayer;
 using System.Collections;
 using System.Collections.Generic;
-using umbraco.IO;
 using System.Xml;
 using System.Linq;
-using umbraco.interfaces;
-using umbraco.cms.businesslogic.datatype.controls;
 
 namespace umbraco.cms.businesslogic.media
 {
@@ -17,9 +15,12 @@ namespace umbraco.cms.businesslogic.media
 	///  
 	/// By inheriting the Content class it has a generic datafields which enables custumization
 	/// </summary>
-	public class Media : Content
+    [Obsolete("Deprecated, Use Umbraco.Core.Models.Media", false)]
+    public class Media : Content
 	{
         #region Constants and static members
+
+	    private IMedia _media;
         private const string m_SQLOptimizedMany = @"
 			select 
 				count(children.id) as children, cmsContentType.isContainer, umbracoNode.id, umbracoNode.uniqueId, umbracoNode.level, umbracoNode.parentId, umbracoNode.path, umbracoNode.sortOrder, umbracoNode.createDate, umbracoNode.nodeUser, umbracoNode.text, 
@@ -51,6 +52,11 @@ namespace umbraco.cms.businesslogic.media
         public Media(int id, bool noSetup) : base(id, noSetup) { }
 
         public Media(Guid id, bool noSetup) : base(id, noSetup) { }
+
+        internal Media(IMedia media) : base(media)
+        {
+            SetupNode(media);
+        }
         
         #endregion
 
@@ -68,16 +74,22 @@ namespace umbraco.cms.businesslogic.media
         /// <param name="u">The user creating the media</param>
         /// <param name="ParentId">The id of the folder under which the media is created</param>
         /// <returns></returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.CreateMedia()", false)]
         public static Media MakeNew(string Name, MediaType dct, BusinessLogic.User u, int ParentId)
         {
-            Guid newId = Guid.NewGuid();
+            var media = ApplicationContext.Current.Services.MediaService.CreateMedia(ParentId, dct.Alias, u.Id);
+            media.Name = Name;
+            ApplicationContext.Current.Services.MediaService.Save(media);
+            var tmp = new Media(media);
+
+            /*Guid newId = Guid.NewGuid();
             // Updated to match level from base node
             CMSNode n = new CMSNode(ParentId);
             int newLevel = n.Level;
             newLevel++;
             CMSNode.MakeNew(ParentId, _objectType, u.Id, newLevel, Name, newId);
             Media tmp = new Media(newId);
-            tmp.CreateContent(dct);
+            tmp.CreateContent(dct);*/
 
             NewEventArgs e = new NewEventArgs();
             tmp.OnNew(e);
@@ -89,9 +101,13 @@ namespace umbraco.cms.businesslogic.media
         /// Retrieve a list of all toplevel medias and folders
         /// </summary>
         /// <returns></returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.GetRootMedia()", false)]
         public static Media[] GetRootMedias()
         {
-            Guid[] topNodeIds = CMSNode.TopMostNodeIds(_objectType);
+            var children = ApplicationContext.Current.Services.MediaService.GetRootMedia();
+            return children.Select(x => new Media(x)).ToArray();
+
+            /*Guid[] topNodeIds = CMSNode.TopMostNodeIds(_objectType);
 
             Media[] retval = new Media[topNodeIds.Length];
             for (int i = 0; i < topNodeIds.Length; i++)
@@ -99,13 +115,16 @@ namespace umbraco.cms.businesslogic.media
                 Media d = new Media(topNodeIds[i]);
                 retval[i] = d;
             }
-            return retval;
+            return retval;*/
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.GetChildren()", false)]
         public static List<Media> GetChildrenForTree(int nodeId)
         {
+            var children = ApplicationContext.Current.Services.MediaService.GetChildren(nodeId);
+            return children.Select(x => new Media(x)).ToList();
 
-            List<Media> tmp = new List<Media>();
+            /*List<Media> tmp = new List<Media>();
             using (IRecordsReader dr =
                 SqlHelper.ExecuteReader(
                     string.Format(m_SQLOptimizedMany.Trim()
@@ -123,12 +142,16 @@ namespace umbraco.cms.businesslogic.media
                 }
 
             }
-            return tmp;
+            return tmp;*/
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.GetMediaOfMediaType()", false)]
         public static IEnumerable<Media> GetMediaOfMediaType(int mediaTypeId)
         {
-            var tmp = new List<Media>();
+            var children = ApplicationContext.Current.Services.MediaService.GetMediaOfMediaType(mediaTypeId);
+            return children.Select(x => new Media(x)).ToList();
+
+            /*var tmp = new List<Media>();
             using (IRecordsReader dr =
                 SqlHelper.ExecuteReader(
                                         string.Format(m_SQLOptimizedMany.Trim(), "cmsContent.contentType = @contentTypeId", "umbracoNode.sortOrder"),
@@ -143,7 +166,7 @@ namespace umbraco.cms.businesslogic.media
                 }
             }
 
-            return tmp.ToArray();
+            return tmp.ToArray();*/
         }
 
         /// <summary>
@@ -152,10 +175,13 @@ namespace umbraco.cms.businesslogic.media
         /// Use with care.
         /// </summary>
         /// <param name="dt"></param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.DeleteMediaOfType()", false)]
         public static void DeleteFromType(MediaType dt)
         {
+            ApplicationContext.Current.Services.MediaService.DeleteMediaOfType(dt.Id);
+
             //get all document for the document type and order by level (top level first)
-            var medias = Media.GetMediaOfMediaType(dt.Id)
+            /*var medias = Media.GetMediaOfMediaType(dt.Id)
                 .OrderByDescending(x => x.Level);
 
             foreach (Media media in medias)
@@ -171,7 +197,7 @@ namespace umbraco.cms.businesslogic.media
                 }
 
                 media.DeletePermanently();
-            }
+            }*/
         }
         
         #endregion
@@ -180,12 +206,16 @@ namespace umbraco.cms.businesslogic.media
         /// <summary>
         /// Retrieve a list of all medias underneath the current
         /// </summary>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.GetChildren()", false)]
         public new Media[] Children
         {
             get
-            {                
+            {
                 //return refactored optimized method
-                return Media.GetChildrenForTree(this.Id).ToArray();
+                //return Media.GetChildrenForTree(this.Id).ToArray();
+
+                var children = ApplicationContext.Current.Services.MediaService.GetChildren(Id).OrderBy(c => c.SortOrder);
+                return children.Select(x => new Media(x)).ToArray();
             }
         } 
         #endregion
@@ -195,6 +225,7 @@ namespace umbraco.cms.businesslogic.media
         /// <summary>
         /// Used to persist object changes to the database. In Version3.0 it's just a stub for future compatibility
         /// </summary>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.Save()", false)]
         public override void Save()
         {
             SaveEventArgs e = new SaveEventArgs();
@@ -202,7 +233,12 @@ namespace umbraco.cms.businesslogic.media
 
             if (!e.Cancel)
             {
-                this.VersionDate = DateTime.Now;
+                foreach (var property in GenericProperties)
+                {
+                    _media.SetValue(property.PropertyType.Alias, property.Value);
+                }
+
+                ApplicationContext.Current.Services.MediaService.Save(_media);
 
                 base.Save();
 
@@ -223,6 +259,7 @@ namespace umbraco.cms.businesslogic.media
         /// <summary>
         /// Moves the media to the trash
         /// </summary>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.MoveToRecycleBin()", false)]
         public override void delete()
         {
             MoveToTrash();
@@ -232,6 +269,7 @@ namespace umbraco.cms.businesslogic.media
         /// With either move the media to the trash or permanently remove it from the database.
         /// </summary>
         /// <param name="deletePermanently">flag to set whether or not to completely remove it from the database or just send to trash</param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.Delete() or Umbraco.Core.Services.MediaService.MoveToRecycleBin()", false)]
         public void delete(bool deletePermanently)
         {
             if (!deletePermanently)
@@ -244,9 +282,13 @@ namespace umbraco.cms.businesslogic.media
             }
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.GetDescendants()", false)]
         public override IEnumerable GetDescendants()
         {
-            var tmp = new List<Media>();
+            var descendants = ApplicationContext.Current.Services.MediaService.GetDescendants(Id);
+            return descendants.Select(x => new Media(x));
+
+            /*var tmp = new List<Media>();
             using (IRecordsReader dr = SqlHelper.ExecuteReader(
                                         string.Format(m_SQLOptimizedMany.Trim(), "umbracoNode.path LIKE '%," + this.Id + ",%'", "umbracoNode.level"),
                                             SqlHelper.CreateParameter("@nodeObjectType", Media._objectType)))
@@ -259,12 +301,31 @@ namespace umbraco.cms.businesslogic.media
                 }
             }
 
-            return tmp.ToArray();
+            return tmp.ToArray();*/
         }
 
         #endregion
 
         #region Protected methods
+        protected override void setupNode()
+        {
+            if (Id == -1)
+            {
+                base.setupNode();
+                return;
+            }
+
+            var media = Version == Guid.Empty
+                           ? ApplicationContext.Current.Services.MediaService.GetById(Id)
+                           : ApplicationContext.Current.Services.MediaService.GetByVersion(Version);
+
+            if (media == null)
+                throw new ArgumentException(string.Format("No Media exists with id '{0}'", Id));
+
+            SetupNode(media);
+        }
+        
+        [Obsolete("Deprecated, This method is no longer used")]
         protected void PopulateMediaFromReader(IRecordsReader dr)
         {
             var hc = dr.GetInt("children") > 0;
@@ -288,6 +349,19 @@ namespace umbraco.cms.businesslogic.media
         #endregion
 
         #region Private methods
+        private void SetupNode(IMedia media)
+        {
+            _media = media;
+
+            //Setting private properties from IContentBase replacing CMSNode.setupNode() / CMSNode.PopulateCMSNodeFromReader()
+            base.PopulateCMSNodeFromContentBase(_media, _objectType);
+
+            //If the version is empty we update with the latest version from the current IContent.
+            if (Version == Guid.Empty)
+                Version = _media.Version;
+        }
+
+        [Obsolete("Deprecated, This method is no longer needed", false)]
         private void SetupMediaForTree(Guid uniqueId, int level, int parentId, int user, string path,
                                           string text, DateTime createDate, string icon, bool hasChildren, string contentTypeAlias, string contentTypeThumb,
                                             string contentTypeDesc, int? masterContentType, int contentTypeId, bool isContainer)
@@ -301,6 +375,7 @@ namespace umbraco.cms.businesslogic.media
         /// Used internally to permanently delete the data from the database
         /// </summary>      
         /// <returns>returns true if deletion isn't cancelled</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.Delete()", false)]
         private bool DeletePermanently()
         {
             DeleteEventArgs e = new DeleteEventArgs();
@@ -309,13 +384,23 @@ namespace umbraco.cms.businesslogic.media
 
             if (!e.Cancel)
             {
-                foreach (Media m in Children.ToList())
+                /*foreach (Media m in Children.ToList())
                 {
                     m.DeletePermanently();
-                }               
+                } */              
 
                 // Remove all files
-                DeleteAssociatedMediaFiles();
+                //DeleteAssociatedMediaFiles();
+
+                if (_media != null)
+                {
+                    ApplicationContext.Current.Services.MediaService.Delete(_media);
+                }
+                else
+                {
+                    var media = ApplicationContext.Current.Services.MediaService.GetById(Id);
+                    ApplicationContext.Current.Services.MediaService.Delete(media);
+                }
 
                 base.delete();
 
@@ -328,6 +413,7 @@ namespace umbraco.cms.businesslogic.media
         /// Used internally to move the node to the recyle bin
         /// </summary>
         /// <returns>Returns true if the move was not cancelled</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.MediaService.MoveToRecycleBin()", false)]
         private bool MoveToTrash()
         {
             MoveToTrashEventArgs e = new MoveToTrashEventArgs();
@@ -335,7 +421,17 @@ namespace umbraco.cms.businesslogic.media
 
             if (!e.Cancel)
             {
-                Move((int)RecycleBin.RecycleBinType.Media);
+                if (_media != null)
+                {
+                    ApplicationContext.Current.Services.MediaService.MoveToRecycleBin(_media);
+                }
+                else
+                {
+                    var media = ApplicationContext.Current.Services.MediaService.GetById(Id);
+                    ApplicationContext.Current.Services.MediaService.MoveToRecycleBin(media);
+                }
+
+                //Move((int)RecycleBin.RecycleBinType.Media);
 
                 //TODO: Now that we've moved it to trash, we need to move the actual files so they are no longer accessible
                 //from the original URL.
diff --git a/src/umbraco.cms/businesslogic/media/MediaType.cs b/src/umbraco.cms/businesslogic/media/MediaType.cs
index 18365af868..5225972e79 100644
--- a/src/umbraco.cms/businesslogic/media/MediaType.cs
+++ b/src/umbraco.cms/businesslogic/media/MediaType.cs
@@ -1,11 +1,10 @@
 using System;
-using System.Data;
-using System.Runtime.CompilerServices;
 using System.Collections.Generic;
-using umbraco.DataLayer;
+using Umbraco.Core;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence.Caching;
 using System.Linq;
 
-
 namespace umbraco.cms.businesslogic.media
 {
     /// <summary>
@@ -13,9 +12,9 @@ namespace umbraco.cms.businesslogic.media
     /// 
     /// Due to the inheritance of the ContentType class,it enables definition of generic datafields on a Media.
     /// </summary>
+    [Obsolete("Deprecated, Use Umbraco.Core.Models.MediaType", false)]
     public class MediaType : ContentType
     {
-
         #region Constructors
 
         /// <summary>
@@ -32,6 +31,12 @@ namespace umbraco.cms.businesslogic.media
 
         public MediaType(int id, bool noSetup) : base(id, noSetup) { }
 
+        internal MediaType(IMediaType mediaType)
+            : base(mediaType)
+        {
+            SetupNode(mediaType);
+        }
+
         #endregion
 
         #region Constants and static members
@@ -40,23 +45,23 @@ namespace umbraco.cms.businesslogic.media
 
         #endregion
 
+        #region Private Members
+
+        private IMediaType _mediaType;
+
+        #endregion
+
         #region Static Methods
         /// <summary>
         /// Retrieve a MediaType by it's alias
         /// </summary>
         /// <param name="Alias">The alias of the MediaType</param>
         /// <returns>The MediaType with the alias</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.GetMediaType()", false)]
         public static new MediaType GetByAlias(string Alias)
         {
-            using (IRecordsReader dr = SqlHelper.ExecuteReader(@"SELECT nodeid from cmsContentType INNER JOIN umbracoNode on cmsContentType.nodeId = umbracoNode.id WHERE nodeObjectType=@nodeObjectType AND alias=@alias",
-                               SqlHelper.CreateParameter("@nodeObjectType", MediaType._objectType),
-                               SqlHelper.CreateParameter("@alias", Alias)))
-            {
-                if(dr.Read())
-                    return new MediaType(dr.GetInt("nodeid"));
-                else
-                    return null;
-            }
+            var mediaType = ApplicationContext.Current.Services.ContentTypeService.GetMediaType(Alias);
+            return new MediaType(mediaType);
         }
 
         /// <summary>
@@ -71,38 +76,11 @@ namespace umbraco.cms.businesslogic.media
             }
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.GetMediaType()", false)]
         public static IEnumerable<MediaType> GetAllAsList()
         {
-
-            var mediaTypes = new List<MediaType>();
-
-            using (IRecordsReader dr =
-                SqlHelper.ExecuteReader(m_SQLOptimizedGetAll.Trim(), SqlHelper.CreateParameter("@nodeObjectType", MediaType._objectType)))
-            {
-                while (dr.Read())
-                {
-                    //check if the document id has already been added
-                    if (mediaTypes.Where(x => x.Id == dr.Get<int>("id")).Count() == 0)
-                    {
-                        //create the DocumentType object without setting up
-                        MediaType dt = new MediaType(dr.Get<int>("id"), true);
-                        //populate it's CMSNode properties
-                        dt.PopulateCMSNodeFromReader(dr);
-                        //populate it's ContentType properties
-                        dt.PopulateContentTypeNodeFromReader(dr);
-
-                        mediaTypes.Add(dt);
-                    }
-                    else
-                    {
-                        //we've already created the document type with this id, so we'll add the rest of it's templates to itself
-                        var dt = mediaTypes.Where(x => x.Id == dr.Get<int>("id")).Single();
-                    }
-                }
-            }
-
-            return mediaTypes.OrderBy(x => x.Text).ToList();
-
+            var mediaTypes = ApplicationContext.Current.Services.ContentTypeService.GetAllMediaTypes();
+            return mediaTypes.OrderBy(x => x.Name).Select(x => new MediaType(x));
         }
 
         /// <summary>
@@ -111,17 +89,13 @@ namespace umbraco.cms.businesslogic.media
         /// <param name="u">The Umbraco user context</param>
         /// <param name="Text">The name of the MediaType</param>
         /// <returns>The new MediaType</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Models.MediaType and Umbraco.Core.Services.ContentTypeService.Save()", false)]
         public static MediaType MakeNew(BusinessLogic.User u, string Text)
         {
+            var mediaType = new Umbraco.Core.Models.MediaType(-1) { Name = Text, Alias = Text, CreatorId = u.Id, Thumbnail = "folder.png", Icon = "folder.gif" };
+            ApplicationContext.Current.Services.ContentTypeService.Save(mediaType, u.Id);
+            var mt = new MediaType(mediaType.Id);
 
-            int ParentId = -1;
-            int level = 1;
-            Guid uniqueId = Guid.NewGuid();
-            CMSNode n = CMSNode.MakeNew(ParentId, _objectType, u.Id, level, Text, uniqueId);
-
-            ContentType.Create(n.Id, Text, "");
-
-            MediaType mt = new MediaType(n.Id);
             NewEventArgs e = new NewEventArgs();
             mt.OnNew(e);
 
@@ -140,6 +114,11 @@ namespace umbraco.cms.businesslogic.media
 
             if (!e.Cancel)
             {
+                ApplicationContext.Current.Services.ContentTypeService.Save(_mediaType);
+
+                //Ensure that MediaTypes are reloaded from db by clearing cache
+                InMemoryCacheProvider.Current.Clear();
+
                 base.Save();
 
                 FireBeforeSave(e);
@@ -166,6 +145,26 @@ namespace umbraco.cms.businesslogic.media
         }
         #endregion
 
+        #region Protected Methods
+
+        protected override void setupNode()
+        {
+            var mediaType = ApplicationContext.Current.Services.ContentTypeService.GetMediaType(Id);
+            SetupNode(mediaType);
+        }
+
+        #endregion
+
+        #region Private Methods
+        private void SetupNode(IMediaType mediaType)
+        {
+            _mediaType = mediaType;
+
+            base.PopulateContentTypeFromContentTypeBase(_mediaType);
+            base.PopulateCMSNodeFromContentTypeBase(_mediaType, _objectType);
+        }
+        #endregion
+
         #region Events
 
         /// <summary>
diff --git a/src/umbraco.cms/businesslogic/member/Member.cs b/src/umbraco.cms/businesslogic/member/Member.cs
index e94ee3e642..f9ca2f18df 100644
--- a/src/umbraco.cms/businesslogic/member/Member.cs
+++ b/src/umbraco.cms/businesslogic/member/Member.cs
@@ -6,6 +6,8 @@ using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Web;
 using System.Xml;
+using Umbraco.Core;
+using Umbraco.Core.Models.Rdbms;
 using umbraco.cms.businesslogic.cache;
 using umbraco.BusinessLogic;
 using umbraco.DataLayer;
@@ -571,6 +573,55 @@ namespace umbraco.cms.businesslogic.member
 
             if (!e.Cancel)
             {
+                var db = ApplicationContext.Current.DatabaseContext.Database;
+                using (var transaction = db.GetTransaction())
+                {
+                    foreach (var property in GenericProperties)
+                    {
+                        var poco = new PropertyDataDto
+                                       {
+                                           Id = property.Id,
+                                           PropertyTypeId = property.PropertyType.Id,
+                                           NodeId = Id,
+                                           VersionId = property.VersionId
+                                       };
+                        if (property.Value != null)
+                        {
+                            string dbType = property.PropertyType.DataTypeDefinition.DbType;
+                            if (dbType.Equals("dataInt"))
+                            {
+                                int value = 0;
+                                if (int.TryParse(property.Value.ToString(), out value))
+                                {
+                                    poco.Integer = value;
+                                }
+                            }
+                            else if (dbType.Equals("dataDate"))
+                            {
+                                poco.Date = DateTime.Parse(property.Value.ToString());
+                            }
+                            else if (dbType.Equals("dataNvarchar"))
+                            {
+                                poco.VarChar = property.Value.ToString();
+                            }
+                            else
+                            {
+                                poco.Text = property.Value.ToString();
+                            }
+                        }
+                        bool isNew = db.IsNew(poco);
+                        if (isNew)
+                        {
+                            db.Insert(poco);
+                        }
+                        else
+                        {
+                            db.Update(poco);
+                        }
+                    }
+                    transaction.Complete();
+                }
+
                 // re-generate xml
                 XmlDocument xd = new XmlDocument();
                 XmlGenerate(xd);
diff --git a/src/umbraco.cms/businesslogic/member/MemberType.cs b/src/umbraco.cms/businesslogic/member/MemberType.cs
index 30b04b5b23..c6ba370986 100644
--- a/src/umbraco.cms/businesslogic/member/MemberType.cs
+++ b/src/umbraco.cms/businesslogic/member/MemberType.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Data;
 using System.Xml;
 using umbraco.cms.businesslogic.propertytype;
 using System.Linq;
@@ -12,10 +11,16 @@ namespace umbraco.cms.businesslogic.member
 	/// Due to the inheritance of the ContentType class, it enables definition of generic datafields on a Members.
 	/// 
 	public class MemberType : ContentType
-	{
-		private static Guid _objectType = new Guid("9b5416fb-e72f-45a9-a07b-5a9a2709ce43");
+    {
+        #region Private Members
+        
+        private static Guid _objectType = new Guid("9b5416fb-e72f-45a9-a07b-5a9a2709ce43");
+        
+        #endregion
 
-		/// <summary>
+        #region Constructors
+
+        /// <summary>
 		/// Initializes a new instance of the MemberType class.
 		/// </summary>
 		/// <param name="id">MemberType id</param>
@@ -27,56 +32,11 @@ namespace umbraco.cms.businesslogic.member
 		/// <param name="id">MemberType id</param>
         public MemberType(Guid id) : base(id) { }
 
-        /// <summary>
-        /// Used to persist object changes to the database. In Version3.0 it's just a stub for future compatibility
-        /// </summary>
-        public override void Save()
-        {
-            SaveEventArgs e = new SaveEventArgs();
-            FireBeforeSave(e);
+        #endregion
 
-            if(!e.Cancel){
-                FireAfterSave(e);
-            }
-        }
+        #region Public Methods
         
-		/// <summary>
-		/// Create a new MemberType
-		/// </summary>
-		/// <param name="Text">The name of the MemberType</param>
-		/// <param name="u">Creator of the MemberType</param>
-		public static MemberType MakeNew(User u,string Text) 
-		{		
-			int ParentId= -1;
-			int level = 1;
-			Guid uniqueId = Guid.NewGuid();
-			CMSNode n = CMSNode.MakeNew(ParentId, _objectType, u.Id, level,Text, uniqueId);
-
-			ContentType.Create(n.Id, Text,"");
-	        MemberType mt = new MemberType(n.Id);
-		    mt.IconUrl = "member.gif";
-            NewEventArgs e = new NewEventArgs();
-            mt.OnNew(e);
-
-            return mt; 
-		}
-
-		/// <summary>
-		/// Retrieve a list of all MemberTypes
-		/// </summary>
-        public new static MemberType[] GetAll
-        {
-            get
-            {
-                Guid[] Ids = CMSNode.getAllUniquesFromObjectType(_objectType);
-
-                MemberType[] retVal = new MemberType[Ids.Length];
-                for (int i = 0; i < Ids.Length; i++) retVal[i] = new MemberType(Ids[i]);
-                return retVal;
-            }
-        }
-
-		/// <summary>
+        /// <summary>
 		/// Get an true/false if the Member can edit the given data defined in the propertytype
 		/// </summary>
 		/// <param name="pt">Propertytype to edit</param>
@@ -90,29 +50,7 @@ namespace umbraco.cms.businesslogic.member
             }
             return false;
         }
-
-		/// <summary>
-		/// Get a MemberType by it's alias
-		/// </summary>
-		/// <param name="Alias">The alias of the MemberType</param>
-		/// <returns>The MemberType with the given Alias</returns>
-        public new static MemberType GetByAlias(string Alias)
-        {            
-            try
-            {
-                return
-                    new MemberType(
-                            SqlHelper.ExecuteScalar<int>(@"SELECT nodeid from cmsContentType INNER JOIN umbracoNode on cmsContentType.nodeId = umbracoNode.id WHERE nodeObjectType=@nodeObjectType AND alias=@alias",
-                                SqlHelper.CreateParameter("@nodeObjectType", MemberType._objectType),
-                                SqlHelper.CreateParameter("@alias", Alias)));
-            }
-            catch
-            {
-                return null;
-            }
-        }
-
-
+        
 		/// <summary>
 		/// Get an true/false if the given data defined in the propertytype, should be visible on the members profile page
 		/// </summary>
@@ -142,13 +80,7 @@ namespace umbraco.cms.businesslogic.member
                 SqlHelper.ExecuteNonQuery("insert into cmsMemberType (NodeId, propertytypeid, memberCanEdit,viewOnProfile) values (" + this.Id + "," + pt.Id + ", " + tmpval + ",0)");
 
         }
-
-        private bool propertyTypeRegistered(PropertyType pt)
-        {
-            return (SqlHelper.ExecuteScalar<int>("Select count(pk) as tmp from cmsMemberType where NodeId = " + this.Id + " And propertytypeId = " + pt.Id) > 0);
-        }
-
-
+        
 		/// <summary>
 		/// Set if the data should be displayed on members of this type's profilepage
 		/// </summary>
@@ -190,6 +122,20 @@ namespace umbraco.cms.businesslogic.member
                 FireAfterDelete(e);
             }
         }
+
+        /// <summary>
+        /// Used to persist object changes to the database. In Version3.0 it's just a stub for future compatibility
+        /// </summary>
+        public override void Save()
+        {
+            SaveEventArgs e = new SaveEventArgs();
+            FireBeforeSave(e);
+
+            if (!e.Cancel)
+            {
+                FireAfterSave(e);
+            }
+        }
         
         public XmlElement ToXml(XmlDocument xd)
         {
@@ -235,6 +181,76 @@ namespace umbraco.cms.businesslogic.member
             return root;
         }
 
+        #endregion
+
+        #region Public Static Methods
+        /// <summary>
+        /// Get a MemberType by it's alias
+        /// </summary>
+        /// <param name="Alias">The alias of the MemberType</param>
+        /// <returns>The MemberType with the given Alias</returns>
+        public new static MemberType GetByAlias(string Alias)
+        {
+            try
+            {
+                return
+                    new MemberType(
+                            SqlHelper.ExecuteScalar<int>(@"SELECT nodeid from cmsContentType INNER JOIN umbracoNode on cmsContentType.nodeId = umbracoNode.id WHERE nodeObjectType=@nodeObjectType AND alias=@alias",
+                                SqlHelper.CreateParameter("@nodeObjectType", MemberType._objectType),
+                                SqlHelper.CreateParameter("@alias", Alias)));
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Create a new MemberType
+        /// </summary>
+        /// <param name="Text">The name of the MemberType</param>
+        /// <param name="u">Creator of the MemberType</param>
+        public static MemberType MakeNew(User u, string Text)
+        {
+            int ParentId = -1;
+            int level = 1;
+            Guid uniqueId = Guid.NewGuid();
+            CMSNode n = CMSNode.MakeNew(ParentId, _objectType, u.Id, level, Text, uniqueId);
+
+            ContentType.Create(n.Id, Text, "");
+            MemberType mt = new MemberType(n.Id);
+            mt.IconUrl = "member.gif";
+            NewEventArgs e = new NewEventArgs();
+            mt.OnNew(e);
+
+            return mt;
+        }
+
+        /// <summary>
+        /// Retrieve a list of all MemberTypes
+        /// </summary>
+        public new static MemberType[] GetAll
+        {
+            get
+            {
+                Guid[] Ids = CMSNode.getAllUniquesFromObjectType(_objectType);
+
+                MemberType[] retVal = new MemberType[Ids.Length];
+                for (int i = 0; i < Ids.Length; i++) retVal[i] = new MemberType(Ids[i]);
+                return retVal;
+            }
+        }
+        #endregion
+
+        #region Private Methods
+
+        private bool propertyTypeRegistered(PropertyType pt)
+        {
+            return (SqlHelper.ExecuteScalar<int>("Select count(pk) as tmp from cmsMemberType where NodeId = " + this.Id + " And propertytypeId = " + pt.Id) > 0);
+        }
+
+        #endregion
+
         #region Events
 
         /// <summary>
diff --git a/src/umbraco.cms/businesslogic/propertytype/propertytype.cs b/src/umbraco.cms/businesslogic/propertytype/propertytype.cs
index 29d17b5759..2de760e13a 100644
--- a/src/umbraco.cms/businesslogic/propertytype/propertytype.cs
+++ b/src/umbraco.cms/businesslogic/propertytype/propertytype.cs
@@ -22,8 +22,6 @@ namespace umbraco.cms.businesslogic.propertytype
     {
         #region Declarations
 
-        private static string _connstring = GlobalSettings.DbDSN;
-
         private static readonly object propertyTypeCacheSyncLock = new object();
         private static readonly string UmbracoPropertyTypeCacheKey = "UmbracoPropertyTypeCache";
         private readonly int _contenttypeid;
@@ -112,6 +110,7 @@ namespace umbraco.cms.businesslogic.propertytype
                 InvalidateCache();
             }
         }
+
         public int PropertyTypeGroup
         {
             get { return _propertyTypeGroup; }
diff --git a/src/umbraco.cms/businesslogic/template/Template.cs b/src/umbraco.cms/businesslogic/template/Template.cs
index 6dd45b2296..c9c30d1622 100644
--- a/src/umbraco.cms/businesslogic/template/Template.cs
+++ b/src/umbraco.cms/businesslogic/template/Template.cs
@@ -18,10 +18,10 @@ namespace umbraco.cms.businesslogic.template
     /// <summary>
     /// Summary description for Template.
     /// </summary>
+    //[Obsolete("Deprecated, This class will eventually be phased out - Use Umbraco.Core.Models.Template", false)]
     public class Template : CMSNode
     {
-
-
+        
         #region Private members
 
         private string _OutputContentType;
@@ -388,8 +388,7 @@ namespace umbraco.cms.businesslogic.template
         {
             return MakeNew(Name, u, master, null);
         }
-
-
+        
         private static Template MakeNew(string name, BusinessLogic.User u, string design)
         {
             return MakeNew(name, u, null, design);
diff --git a/src/umbraco.cms/businesslogic/translation/Translation.cs b/src/umbraco.cms/businesslogic/translation/Translation.cs
index cbea78c37c..ab0d0d9482 100644
--- a/src/umbraco.cms/businesslogic/translation/Translation.cs
+++ b/src/umbraco.cms/businesslogic/translation/Translation.cs
@@ -92,7 +92,7 @@ namespace umbraco.cms.businesslogic.translation
             Document d = new Document(DocumentId);
 
             int words = CountWordsInString(d.Text);
-            var props = d.getProperties;
+            var props = d.GenericProperties;
             foreach (Property p in props)
             {
                 if (p.Value.GetType() == "".GetType())
diff --git a/src/umbraco.cms/businesslogic/web/Document.cs b/src/umbraco.cms/businesslogic/web/Document.cs
index df9ee4b0a4..4f7699f9fb 100644
--- a/src/umbraco.cms/businesslogic/web/Document.cs
+++ b/src/umbraco.cms/businesslogic/web/Document.cs
@@ -2,22 +2,16 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Web;
 using System.Xml;
-using Umbraco.Core.IO;
+using Umbraco.Core;
+using Umbraco.Core.Models;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.Caching;
 using umbraco.BusinessLogic;
 using umbraco.BusinessLogic.Actions;
-using umbraco.cms.businesslogic.property;
-using umbraco.cms.businesslogic.relation;
 using umbraco.cms.helpers;
 using umbraco.DataLayer;
-using umbraco.IO;
-using umbraco.interfaces;
-using umbraco.cms.businesslogic.datatype.controls;
-using System.IO;
-using System.Diagnostics;
-using Umbraco.Core;
+using Property = umbraco.cms.businesslogic.property.Property;
 
 namespace umbraco.cms.businesslogic.web
 {
@@ -27,6 +21,7 @@ namespace umbraco.cms.businesslogic.web
     /// 
     /// Pubished Documents are exposed to the runtime/the public website in a cached xml document.
     /// </summary>
+    [Obsolete("Deprecated, Use Umbraco.Core.Models.Content", false)]
     public class Document : Content
     {
         #region Constructors
@@ -80,70 +75,37 @@ namespace umbraco.cms.businesslogic.web
             : base(id, optimizedMode)
         {
             this._optimizedMode = optimizedMode;
-
             if (optimizedMode)
             {
+                Content = ApplicationContext.Current.Services.ContentService.GetById(id);
+                bool hasChildren = ApplicationContext.Current.Services.ContentService.HasChildren(id);
+                int templateId = Content.Template == null ? 0 : Content.Template.Id;
 
-                using (IRecordsReader dr =
-                        SqlHelper.ExecuteReader(string.Format(m_SQLOptimizedSingle.Trim(), "umbracoNode.id = @id", "cmsContentVersion.id desc"),
-                            SqlHelper.CreateParameter("@nodeObjectType", Document._objectType),
-                            SqlHelper.CreateParameter("@id", id)))
-                {
-                    if (dr.Read())
-                    {
-                        // Initialize node and basic document properties
-                        bool _hc = false;
-                        if (dr.GetInt("children") > 0)
-                            _hc = true;
-                        SetupDocumentForTree(dr.GetGuid("uniqueId")
-                            , dr.GetShort("level")
-                            , dr.GetInt("parentId")
-                            , dr.GetInt("nodeUser")
-                            , dr.GetInt("documentUser")
-                            , dr.GetBoolean("published")
-                            , dr.GetString("path")
-                            , dr.GetString("text")
-                            , dr.GetDateTime("createDate")
-                            , dr.GetDateTime("updateDate")
-                            , dr.GetDateTime("versionDate")
-                            , dr.GetString("icon")
-                            , _hc
-                            , dr.GetString("alias")
-                            , dr.GetString("thumbnail")
-                            , dr.GetString("description")
-                            , null
-                            , dr.GetInt("contentTypeId")
-                            , dr.GetInt("templateId")
-                            , dr.GetBoolean("isContainer")
-                            );
+                SetupDocumentForTree(Content.Key, Content.Level, Content.ParentId, Content.CreatorId,
+                                     Content.WriterId,
+                                     Content.Published, Content.Path, Content.Name, Content.CreateDate,
+                                     Content.UpdateDate, Content.UpdateDate, Content.ContentType.Icon, hasChildren,
+                                     Content.ContentType.Alias, Content.ContentType.Thumbnail,
+                                     Content.ContentType.Description, null, Content.ContentType.Id,
+                                     templateId, Content.ContentType.IsContainer);
 
-                        // initialize content object
-                        InitializeContent(dr.GetInt("ContentType"), dr.GetGuid("versionId"),
-                                          dr.GetDateTime("versionDate"), dr.GetString("icon"));
+                var tmpReleaseDate = Content.ReleaseDate.HasValue ? Content.ReleaseDate.Value : new DateTime();
+                var tmpExpireDate = Content.ExpireDate.HasValue ? Content.ExpireDate.Value : new DateTime();
+                var creator = new User(Content.CreatorId, true);
+                var writer = new User(Content.WriterId, true);
 
-                        // initialize final document properties
-                        DateTime tmpReleaseDate = new DateTime();
-                        DateTime tmpExpireDate = new DateTime();
-                        if (!dr.IsNull("releaseDate"))
-                            tmpReleaseDate = dr.GetDateTime("releaseDate");
-                        if (!dr.IsNull("expireDate"))
-                            tmpExpireDate = dr.GetDateTime("expireDate");
-
-                        InitializeDocument(
-                            new User(dr.GetInt("nodeUser"), true),
-                            new User(dr.GetInt("documentUser"), true),
-                            dr.GetString("documentText"),
-                            dr.GetInt("templateId"),
-                            tmpReleaseDate,
-                            tmpExpireDate,
-                            dr.GetDateTime("updateDate"),
-                            dr.GetBoolean("published")
-                            );
-                    }
-                }
+                InitializeContent(Content.ContentType.Id, Content.Version, Content.UpdateDate,
+                                  Content.ContentType.Icon);
+                InitializeDocument(creator, writer, Content.Name, templateId, tmpReleaseDate, tmpExpireDate,
+                                   Content.UpdateDate, Content.Published);
             }
         }
 
+        internal Document(IContent content) : base(content)
+        {
+            SetupNode(content);
+        }
+
         #endregion
 
         #region Constants and Static members
@@ -230,6 +192,7 @@ namespace umbraco.cms.businesslogic.web
         private User _writer;
         private int? _writerId;
         private bool _optimizedMode;
+        protected internal IContent Content;
 
         /// <summary>
         /// This is used to cache the child documents of Document when the children property
@@ -237,14 +200,9 @@ namespace umbraco.cms.businesslogic.web
         /// </summary>
         private IEnumerable<Document> _children = null;
 
-        // special for passing httpcontext object
-        //private HttpContext _httpContext;
-
         // special for tree performance
         private int _userId = -1;
 
-        //private Dictionary<Property, object> _knownProperties = new Dictionary<Property, object>();
-        //private Func<KeyValuePair<Property, object>, string, bool> propertyTypeByAlias = (pt, alias) => pt.Key.PropertyType.Alias == alias; 
         #endregion
 
         #region Static Methods
@@ -367,50 +325,30 @@ namespace umbraco.cms.businesslogic.web
         /// <param name="u">The usercontext under which the action are performed</param>
         /// <param name="ParentId">The id of the parent to the document</param>
         /// <returns>The newly created document</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.CreateContent()", false)]
         public static Document MakeNew(string Name, DocumentType dct, User u, int ParentId)
         {
             //allows you to cancel a document before anything goes to the DB
             var newingArgs = new DocumentNewingEventArgs()
-            {
-                Text = Name,
-                DocumentType = dct,
-                User = u,
-                ParentId = ParentId
-            };
+                                 {
+                                     Text = Name,
+                                     DocumentType = dct,
+                                     User = u,
+                                     ParentId = ParentId
+                                 };
             Document.OnNewing(newingArgs);
             if (newingArgs.Cancel)
             {
                 return null;
             }
 
-
-            Guid newId = Guid.NewGuid();
-
-            // Updated to match level from base node
-            CMSNode n = new CMSNode(ParentId);
-            int newLevel = n.Level;
-            newLevel++;
-
-            //create the cms node first
-            CMSNode newNode = MakeNew(ParentId, _objectType, u.Id, newLevel, Name, newId);
-
-            //we need to create an empty document and set the underlying text property
-            Document tmp = new Document(newId, true);
-            tmp.SetText(Name);
-
-            //create the content data for the new document
-            tmp.CreateContent(dct);
-
-            //now create the document data
-            SqlHelper.ExecuteNonQuery("insert into cmsDocument (newest, nodeId, published, documentUser, versionId, updateDate, Text) values (1, " +
-                                      tmp.Id + ", 0, " +
-                                      u.Id + ", @versionId, @updateDate, @text)",
-                SqlHelper.CreateParameter("@versionId", tmp.Version),
-                SqlHelper.CreateParameter("@updateDate", DateTime.Now),
-                SqlHelper.CreateParameter("@text", tmp.Text));
+            //Create a new IContent object based on the passed in DocumentType's alias, set the name and save it
+            IContent content = ApplicationContext.Current.Services.ContentService.CreateContent(ParentId, dct.Alias, u.Id);
+            content.Name = Name;
+            ApplicationContext.Current.Services.ContentService.Save(content);
 
             //read the whole object from the db
-            Document d = new Document(newId);
+            Document d = new Document(content);
 
             //event
             NewEventArgs e = new NewEventArgs();
@@ -433,43 +371,26 @@ namespace umbraco.cms.businesslogic.web
         /// </summary>
         /// <param name="nodeId"></param>
         /// <returns></returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetById()", false)]
         public static bool IsDocument(int nodeId)
         {
             bool isDoc = false;
-            using (IRecordsReader dr =
-            SqlHelper.ExecuteReader(string.Format("select nodeId from cmsDocument where nodeId = @id"),
-                SqlHelper.CreateParameter("@id", nodeId)))
-            {
 
-                if (dr.Read())
-                {
-                    isDoc = true;
-                }
-            }
+            var content = ApplicationContext.Current.Services.ContentService.GetById(nodeId);
+            isDoc = content != null;
 
             return isDoc;
         }
 
+        /// <summary>
         /// Used to get the firstlevel/root documents of the hierachy
         /// </summary>
         /// <returns>Root documents</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetRootContent()", false)]
         public static Document[] GetRootDocuments()
         {
-            Guid[] topNodeIds = TopMostNodeIds(_objectType);
-
-            var docs = new List<Document>();
-            for (int i = 0; i < topNodeIds.Length; i++)
-            {
-                try
-                {
-                    docs.Add(new Document(topNodeIds[i]));
-                }
-                catch (Exception ee)
-                {
-					LogHelper.Error<Document>("GetRootDocuments", ee);
-                }
-            }
-            return docs.ToArray();
+            var content = ApplicationContext.Current.Services.ContentService.GetRootContent();
+            return content.Select(c => new Document(c)).ToArray();
         }
 
         public static int CountSubs(int parentId, bool publishedOnly)
@@ -478,10 +399,10 @@ namespace umbraco.cms.businesslogic.web
             {
                 return CountSubs(parentId);
             }
-            else
-            {
-                return SqlHelper.ExecuteScalar<int>("SELECT COUNT(*) FROM (select distinct umbracoNode.id from umbracoNode INNER JOIN cmsDocument ON cmsDocument.published = 1 and cmsDocument.nodeId = umbracoNode.id WHERE ','+path+',' LIKE '%," + parentId.ToString() + ",%') t");
-            }
+
+            return ApplicationContext.Current.DatabaseContext.Database.ExecuteScalar<int>(
+                "SELECT COUNT(*) FROM (select distinct umbracoNode.id from umbracoNode INNER JOIN cmsDocument ON cmsDocument.published = 1 and cmsDocument.nodeId = umbracoNode.id WHERE ','+path+',' LIKE '%," +
+                parentId.ToString() + ",%') t");
         }
 
         /// <summary>
@@ -490,52 +411,23 @@ namespace umbraco.cms.businesslogic.web
         /// Note: use with care: this method can result in wast amount of data being deleted.
         /// </summary>
         /// <param name="dt">The type of which documents should be deleted</param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.DeleteContentOfType()", false)]
         public static void DeleteFromType(DocumentType dt)
         {
-            //get all document for the document type and order by level (top level first)
-            var docs = Document.GetDocumentsOfDocumentType(dt.Id)
-                .OrderByDescending(x => x.Level);
-
-            foreach (Document doc in docs)
-            {
-                //before we delete this document, we need to make sure we don't end up deleting other documents that 
-                //are not of this document type that are children. So we'll move all of it's children to the trash first.
-                foreach (Document c in doc.GetDescendants())
-                {
-                    if (c.ContentType.Id != dt.Id)
-                    {
-                        c.MoveToTrash();
-                    }
-                }
-
-                doc.DeletePermanently();
-            }
+            ApplicationContext.Current.Services.ContentService.DeleteContentOfType(dt.Id);
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetContentOfContentType()", false)]
         public static IEnumerable<Document> GetDocumentsOfDocumentType(int docTypeId)
         {
-            var tmp = new List<Document>();
-            using (IRecordsReader dr =
-                SqlHelper.ExecuteReader(
-                                        string.Format(m_SQLOptimizedMany.Trim(), "cmsContent.contentType = @contentTypeId", "umbracoNode.sortOrder"),
-                                        SqlHelper.CreateParameter("@nodeObjectType", Document._objectType),
-                                        SqlHelper.CreateParameter("@contentTypeId", docTypeId)))
-            {
-                while (dr.Read())
-                {
-                    Document d = new Document(dr.GetInt("id"), true);
-                    d.PopulateDocumentFromReader(dr);
-                    tmp.Add(d);
-                }
-            }
-
-            return tmp.ToArray();
+            var contents = ApplicationContext.Current.Services.ContentService.GetContentOfContentType(docTypeId);
+            return contents.Select(x => new Document(x)).ToArray();
         }
 
         public static void RemoveTemplateFromDocument(int templateId)
         {
-            SqlHelper.ExecuteNonQuery("update cmsDocument set templateId = NULL where templateId = @templateId",
-                                        SqlHelper.CreateParameter("@templateId", templateId));
+            ApplicationContext.Current.DatabaseContext.Database.Execute(
+                "update cmsDocument set templateId = NULL where templateId = @TemplateId", new {TemplateId = templateId});
         }
 
         /// <summary>
@@ -543,48 +435,22 @@ namespace umbraco.cms.businesslogic.web
         /// </summary>
         /// <param name="NodeId">The parentdocuments id</param>
         /// <returns></returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetChildren()", false)]
         public static Document[] GetChildrenForTree(int NodeId)
         {
-            var tmp = new List<Document>();
-            using (IRecordsReader dr =
-                SqlHelper.ExecuteReader(
-                                        string.Format(m_SQLOptimizedMany.Trim(), "umbracoNode.parentID = @parentId", "umbracoNode.sortOrder"),
-                                        SqlHelper.CreateParameter("@nodeObjectType", Document._objectType),
-                                        SqlHelper.CreateParameter("@parentId", NodeId)))
-            {
-                while (dr.Read())
-                {
-                    Document d = new Document(dr.GetInt("id"), true);
-                    d.PopulateDocumentFromReader(dr);
-                    tmp.Add(d);
-                }
-            }
-
-            return tmp.ToArray();
+            var children = ApplicationContext.Current.Services.ContentService.GetChildren(NodeId).OrderBy(c => c.SortOrder);
+            var list = children.Select(x => new Document(x));
+            return list.ToArray();
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetChildrenByName()", false)]
         public static List<Document> GetChildrenBySearch(int NodeId, string searchString)
         {
-            var tmp = new List<Document>();
-            using (IRecordsReader dr =
-                SqlHelper.ExecuteReader(
-                                        string.Format(m_SQLOptimizedMany.Trim(), "umbracoNode.parentID = @parentId and umbracoNode.text like @search", "umbracoNode.sortOrder"),
-                                        SqlHelper.CreateParameter("@nodeObjectType", Document._objectType),
-                                        SqlHelper.CreateParameter("@search", searchString),
-                                        SqlHelper.CreateParameter("@parentId", NodeId)))
-            {
-                while (dr.Read())
-                {
-                    Document d = new Document(dr.GetInt("id"), true);
-                    d.PopulateDocumentFromReader(dr);
-                    tmp.Add(d);
-                }
-            }
-
-            return tmp;
+            var children = ApplicationContext.Current.Services.ContentService.GetChildrenByName(NodeId, searchString);
+            return children.Select(x => new Document(x)).ToList();
         }
 
-
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.RePublishAll()", false)]
         public static void RePublishAll()
         {
             XmlDocument xd = new XmlDocument();
@@ -636,39 +502,22 @@ namespace umbraco.cms.businesslogic.web
         /// Retrieve a list of documents with an expirationdate greater than today
         /// </summary>
         /// <returns>A list of documents with expirationdates than today</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetContentForExpiration()", false)]
         public static Document[] GetDocumentsForExpiration()
         {
-            ArrayList docs = new ArrayList();
-            IRecordsReader dr =
-                SqlHelper.ExecuteReader("select distinct nodeId from cmsDocument where published = 1 and not expireDate is null and expireDate <= @today",
-                                        SqlHelper.CreateParameter("@today", DateTime.Now));
-            while (dr.Read())
-                docs.Add(dr.GetInt("nodeId"));
-            dr.Close();
-
-            Document[] retval = new Document[docs.Count];
-            for (int i = 0; i < docs.Count; i++) retval[i] = new Document((int)docs[i]);
-            return retval;
+            var contents = ApplicationContext.Current.Services.ContentService.GetContentForExpiration();
+            return contents.Select(x => new Document(x)).ToArray();
         }
 
         /// <summary>
         /// Retrieve a list of documents with with releasedate greater than today
         /// </summary>
         /// <returns>Retrieve a list of documents with with releasedate greater than today</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetContentForRelease()", false)]
         public static Document[] GetDocumentsForRelease()
         {
-            ArrayList docs = new ArrayList();
-            IRecordsReader dr = SqlHelper.ExecuteReader("select distinct nodeId, level, sortOrder from cmsDocument inner join umbracoNode on umbracoNode.id = cmsDocument.nodeId where newest = 1 and not releaseDate is null and releaseDate <= @today order by [level], sortOrder",
-                                        SqlHelper.CreateParameter("@today", DateTime.Now));
-            while (dr.Read())
-                docs.Add(dr.GetInt("nodeId"));
-            dr.Close();
-
-
-            Document[] retval = new Document[docs.Count];
-            for (int i = 0; i < docs.Count; i++) retval[i] = new Document((int)docs[i]);
-
-            return retval;
+            var contents = ApplicationContext.Current.Services.ContentService.GetContentForRelease();
+            return contents.Select(x => new Document(x)).ToArray();
         }
 
         #endregion
@@ -737,28 +586,13 @@ namespace umbraco.cms.businesslogic.web
             }
         }
 
-        /// <summary>
-        /// The current HTTPContext
-        /// </summary>
-        [Obsolete("DO NOT USE THIS! Get the HttpContext via regular ASP.Net methods instead")]
-        public HttpContext HttpContext
-        {
-            set { /*THERE IS NO REASON TO DO THIS. _httpContext = value; */}
-            get
-            {
-                //if (_httpContext == null)
-                //    _httpContext = HttpContext.Current;
-                //return _httpContext;
-                return System.Web.HttpContext.Current;
-            }
-        }
-
         /// <summary>
         /// Gets or sets a value indicating whether the document is published.
         /// </summary>
 		/// <remarks>A document can be published yet not visible, because of one or more of its
 		/// parents being unpublished. Use <c>PathPublished</c> to get a value indicating whether
 		/// the node and all its parents are published, and therefore whether the node is visible.</remarks>
+        [Obsolete("Deprecated, Use Published property on Umbraco.Core.Models.Content", false)]
         public bool Published
         {
             get { return _published; }
@@ -766,100 +600,86 @@ namespace umbraco.cms.businesslogic.web
             set
             {
                 _published = value;
-                SqlHelper.ExecuteNonQuery(
-                    string.Format("update cmsDocument set published = {0} where nodeId = {1}", Id, value ? 1 : 0));
+                Content.ChangePublishedState(value);
+                /*SqlHelper.ExecuteNonQuery(
+                    string.Format("update cmsDocument set published = {0} where nodeId = {1}", Id, value ? 1 : 0));*/
             }
         }
 
 		/// <summary>
 		/// Gets a value indicating whether the document and all its parents are published.
 		/// </summary>
-		public bool PathPublished
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.IsPublishable()", false)]
+        public bool PathPublished
 		{
 			get
 			{
-				// get all nodes in the path to the document, and get all matching published documents
-				// the difference should be zero if everything is published
-				// test nodeObjectType to make sure we only count _content_ nodes
-				int x = SqlHelper.ExecuteScalar<int>(@"select count(node.id) - count(doc.nodeid)
-from umbracoNode as node 
-left join cmsDocument as doc on (node.id=doc.nodeId and doc.published=1)
-where '" + Path + ",' like " + SqlHelper.Concat("node.path", "',%'") + @"
-and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
-				return (x == 0);
+				return ApplicationContext.Current.Services.ContentService.IsPublishable(Content);
 			}
 		}
 
+        [Obsolete("Deprecated, Use Name property on Umbraco.Core.Models.Content", false)]
         public override string Text
         {
             get
             {
-                return base.Text;
+                return Content.Name;
+                //return base.Text;
             }
             set
             {
                 value = value.Trim();
                 base.Text = value;
-                SqlHelper.ExecuteNonQuery("update cmsDocument set text = @text where versionId = @versionId",
+                Content.Name = value;
+
+                /*SqlHelper.ExecuteNonQuery("update cmsDocument set text = @text where versionId = @versionId",
                                           SqlHelper.CreateParameter("@text", value),
-                                          SqlHelper.CreateParameter("@versionId", Version));
-                //CMSNode c = new CMSNode(Id);
-                //c.Text = value;
+                                          SqlHelper.CreateParameter("@versionId", Version));*/
             }
         }
 
         /// <summary>
         /// The date of the last update of the document
         /// </summary>
+        [Obsolete("Deprecated, Use UpdateDate property on Umbraco.Core.Models.Content", false)]
         public DateTime UpdateDate
         {
             get { return _updated; }
             set
             {
                 _updated = value;
-                SqlHelper.ExecuteNonQuery("update cmsDocument set updateDate = @value where versionId = @versionId",
+                Content.UpdateDate = value;
+                /*SqlHelper.ExecuteNonQuery("update cmsDocument set updateDate = @value where versionId = @versionId",
                                           SqlHelper.CreateParameter("@value", value),
-                                          SqlHelper.CreateParameter("@versionId", Version));
+                                          SqlHelper.CreateParameter("@versionId", Version));*/
             }
         }
 
         /// <summary>
         /// A datestamp which indicates when a document should be published, used in automated publish/unpublish scenarios
         /// </summary>
+        [Obsolete("Deprecated, Use ReleaseDate property on Umbraco.Core.Models.Content", false)]
         public DateTime ReleaseDate
         {
             get { return _release; }
             set
             {
                 _release = value;
-
-                if (_release.Year != 1 || _release.Month != 1 || _release.Day != 1)
-                    SqlHelper.ExecuteNonQuery("update cmsDocument set releaseDate = @value where versionId = @versionId",
-                                              SqlHelper.CreateParameter("@value", value),
-                                              SqlHelper.CreateParameter("@versionId", Version));
-                else
-                    SqlHelper.ExecuteNonQuery("update cmsDocument set releaseDate = NULL where versionId = @versionId",
-                                              SqlHelper.CreateParameter("@versionId", Version));
+                Content.ReleaseDate = value;
             }
         }
 
         /// <summary>
         /// A datestamp which indicates when a document should be unpublished, used in automated publish/unpublish scenarios
         /// </summary>
+        [Obsolete("Deprecated, Use ExpireDate property on Umbraco.Core.Models.Content", false)]
         public DateTime ExpireDate
         {
             get { return _expire; }
             set
             {
                 _expire = value;
-
-                if (_expire.Year != 1 || _expire.Month != 1 || _expire.Day != 1)
-                    SqlHelper.ExecuteNonQuery("update cmsDocument set expireDate = @value where versionId=@versionId",
-                                              SqlHelper.CreateParameter("@value", value),
-                                              SqlHelper.CreateParameter("@versionId", Version));
-                else
-                    SqlHelper.ExecuteNonQuery("update cmsDocument set expireDate = NULL where versionId=@versionId",
-                                              SqlHelper.CreateParameter("@versionId", Version));
+                Content.ExpireDate = value;
             }
         }
 
@@ -873,6 +693,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// 
         /// ?altTemplate=[templatealias]
         /// </summary>
+        [Obsolete("Deprecated, Use Template property on Umbraco.Core.Models.Content", false)]
         public int Template
         {
             get { return _template; }
@@ -881,15 +702,12 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
                 _template = value;
                 if (value == 0)
                 {
-                    SqlHelper.ExecuteNonQuery("update cmsDocument set templateId = @value where versionId = @versionId",
-                                              SqlHelper.CreateParameter("@value", DBNull.Value),
-                                              SqlHelper.CreateParameter("@versionId", Version));
+                    Content.Template = null;
                 }
                 else
                 {
-                    SqlHelper.ExecuteNonQuery("update cmsDocument set templateId = @value where versionId = @versionId",
-                                              SqlHelper.CreateParameter("@value", _template),
-                                              SqlHelper.CreateParameter("@versionId", Version));
+                    var template = ApplicationContext.Current.Services.FileService.GetTemplate(value);
+                    Content.Template = template;
                 }
             }
         }
@@ -897,60 +715,19 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// <summary>
         /// A collection of documents imidiately underneath this document ie. the childdocuments
         /// </summary>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetChildren()", false)]
         public new Document[] Children
         {
             get
             {
                 //cache the documents children so that this db call doesn't have to occur again
-                if (this._children == null)
-                    this._children = Document.GetChildrenForTree(this.Id);
+                if (_children == null)
+                    _children = GetChildrenForTree(Id);
 
-                return this._children.ToArray();
+                return _children.ToArray();
             }
         }
 
-
-        /// <summary>
-        /// Indexed property to return the property value by name
-        /// </summary>
-        /// <param name="alias"></param>
-        /// <returns></returns>
-        //public object this[string alias]
-        //{
-        //    get
-        //    {
-        //        if (this._optimizedMode)
-        //        {
-        //            return this._knownProperties.Single(p => propertyTypeByAlias(p, alias)).Value;
-        //        }
-        //        else
-        //        {
-        //            return this.getProperty(alias).Value;
-        //        }
-        //    }
-        //    set
-        //    {
-        //        if (this._optimizedMode)
-        //        {
-        //            if (this._knownProperties.SingleOrDefault(p => propertyTypeByAlias(p, alias)).Key == null)
-        //            {
-        //                var pt = this.getProperty(alias);
-
-        //                this._knownProperties.Add(pt, pt.Value);
-        //            }
-        //            else
-        //            {
-        //                var pt = this._knownProperties.Single(p => propertyTypeByAlias(p, alias)).Key;
-        //                this._knownProperties[pt] = value;
-        //            }
-        //        }
-        //        else
-        //        {
-        //            this.getProperty(alias).Value = value;
-        //        }
-        //    }
-        //}
-
         #endregion
 
         #region Public Methods
@@ -985,9 +762,10 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// the data.
         /// </summary>
         /// <param name="u">The usercontext under which the action are performed</param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Publish()", false)]
         public void Publish(User u)
         {
-            PublishWithResult(u);
+            ApplicationContext.Current.Services.ContentService.Publish(Content, u.Id, true);
         }
 
         /// <summary>
@@ -999,56 +777,20 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// </summary>
         /// <param name="u">The usercontext under which the action are performed</param>
         /// <returns>True if the publishing succeed. Possible causes for not publishing is if an event aborts the publishing</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Publish()", false)]
         public bool PublishWithResult(User u)
         {
-            PublishEventArgs e = new PublishEventArgs();
+            var e = new PublishEventArgs();
             FireBeforePublish(e);
 
             if (!e.Cancel)
             {
-
-                // make a lookup to see if template is 0 as the template is not initialized in the optimized
-                // Document.Children method which is used in PublishWithChildrenWithResult methhod
-                if (_template == 0)
-                {
-                    _template = new DocumentType(this.ContentType.Id).DefaultTemplate;
-                }
-
-                _published = true;
-                DateTime versionDate = DateTime.Now;
-                string tempVersion = Version.ToString();
-                Guid newVersion = createNewVersion(versionDate);
-                
-                Log.Add(LogTypes.Publish, u, Id, "");
-
-                //PPH make sure that there is only 1 newest node, this is important in regard to schedueled publishing...
-                SqlHelper.ExecuteNonQuery("update cmsDocument set newest = 0 where nodeId = " + Id);
-
-                SqlHelper.ExecuteNonQuery("insert into cmsDocument (newest, nodeId, published, documentUser, versionId, updateDate, Text, TemplateId) values (1,@id, 0, @userId, @versionId, @updateDate, @text, @template)",
-                    SqlHelper.CreateParameter("@id", Id),
-                    SqlHelper.CreateParameter("@template", _template > 0 ? (object)_template : (object)DBNull.Value), //pass null in if the template doesn't have a valid id
-                    SqlHelper.CreateParameter("@userId", u.Id),
-                    SqlHelper.CreateParameter("@versionId", newVersion),
-                    SqlHelper.CreateParameter("@updateDate", versionDate),
-                    SqlHelper.CreateParameter("@text", Text));
-
-                SqlHelper.ExecuteNonQuery("update cmsDocument set published = 0 where nodeId = " + Id);
-                SqlHelper.ExecuteNonQuery("update cmsDocument set published = 1, newest = 0 where versionId = @versionId",
-                                            SqlHelper.CreateParameter("@versionId", tempVersion));
-
-                // update release and expire dates
-                Document newDoc = new Document(Id, newVersion);
-                if (ReleaseDate != new DateTime())
-                    newDoc.ReleaseDate = ReleaseDate;
-                if (ExpireDate != new DateTime())
-                    newDoc.ExpireDate = ExpireDate;
-
-                // Update xml in db using the new document (has correct version date)
-                newDoc.XmlGenerate(new XmlDocument());
+                var result = ApplicationContext.Current.Services.ContentService.Publish(Content, u.Id);
+                _published = result;
 
                 FireAfterPublish(e);
 
-                return true;
+                return result;
             }
             else
             {
@@ -1056,21 +798,10 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
             }
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.PublishWithChildren()", false)]
         public bool PublishWithChildrenWithResult(User u)
         {
-            if (PublishWithResult(u))
-            {
-                foreach (cms.businesslogic.web.Document dc in Children.ToList())
-                {
-                    dc.PublishWithChildrenWithResult(u);
-                }
-            }
-            else
-            {
-                return false;
-            }
-
-            return true;
+            return ApplicationContext.Current.Services.ContentService.PublishWithChildren(Content, u.Id, true);
         }
 
         /// <summary>
@@ -1079,56 +810,15 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// </summary>
         /// <param name="u">The usercontext under which the action are performed</param>
         /// <param name="VersionId">The unique Id of the version to roll back to</param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Rollback()", false)]
         public void RollBack(Guid VersionId, User u)
         {
-            RollBackEventArgs e = new RollBackEventArgs();
+            var e = new RollBackEventArgs();
             FireBeforeRollBack(e);
 
             if (!e.Cancel)
             {
-                DateTime versionDate = DateTime.Now;
-                Guid newVersion = createNewVersion(versionDate);
- 
-                if (_template != 0)
-                {
-                    SqlHelper.ExecuteNonQuery("insert into cmsDocument (nodeId, published, documentUser, versionId, updateDate, Text, TemplateId) values (" +
-                                              Id +
-                                              ", 0, " + u.Id + ", @versionId, @text, " +
-                                              _template + ")",
-                                              SqlHelper.CreateParameter("@versionId", newVersion),
-                                              SqlHelper.CreateParameter("@updateDate", versionDate),
-                                              SqlHelper.CreateParameter("@text", Text));
-                }
-                else
-                {
-                    SqlHelper.ExecuteNonQuery("insert into cmsDocument (nodeId, published, documentUser, versionId, updateDate, Text) values (" +
-                                             Id +
-                                             ", 0, " + u.Id + ", @versionId, @text )",
-                                             SqlHelper.CreateParameter("@versionId", newVersion),
-                                              SqlHelper.CreateParameter("@updateDate", versionDate),
-                                             SqlHelper.CreateParameter("@text", Text));
-                }
-
-                // Get new version
-                Document dNew = new Document(Id, newVersion);
-
-                // Old version
-                Document dOld = new Document(Id, VersionId);
-
-                // Revert title
-                dNew.Text = dOld.Text;
-
-                // Revert all properties
-                var props = dOld.getProperties;
-                foreach (Property p in props)
-                    try
-                    {
-                        dNew.getProperty(p.PropertyType).Value = p.Value;
-                    }
-                    catch
-                    {
-                        // property doesn't exists
-                    }
+                Content = ApplicationContext.Current.Services.ContentService.Rollback(Id, VersionId, u.Id);
 
                 FireAfterRollBack(e);
             }
@@ -1140,41 +830,21 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// Envoking this method will publish the documents and all children recursive.
         /// </summary>
         /// <param name="u">The usercontext under which the action are performed</param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.PublishWithChildren()", false)]
         public void PublishWithSubs(User u)
         {
-
             PublishEventArgs e = new PublishEventArgs();
             FireBeforePublish(e);
 
             if (!e.Cancel)
             {
-                _published = true;
-                string tempVersion = Version.ToString();
-                DateTime versionDate = DateTime.Now;
-                Guid newVersion = createNewVersion(versionDate);
-
-                SqlHelper.ExecuteNonQuery("insert into cmsDocument (nodeId, published, documentUser, versionId, updateDate, Text) values (" +
-                                          Id + ", 0, " + u.Id +
-                                          ", @versionId, @text)",
-                    SqlHelper.CreateParameter("@versionId", newVersion),
-                    SqlHelper.CreateParameter("@updateDate", versionDate),
-                    SqlHelper.CreateParameter("@text", Text));
-
-                SqlHelper.ExecuteNonQuery("update cmsDocument set published = 0 where nodeId = " + Id);
-                SqlHelper.ExecuteNonQuery("update cmsDocument set published = 1 where versionId = @versionId", SqlHelper.CreateParameter("@versionId", tempVersion));
-
-				LogHelper.Debug<Document>("PublishWithSubs: " + newVersion.ToString() + " - " + Id.ToString());
-
-                // Update xml in db
-                XmlGenerate(new XmlDocument());
-
-                foreach (Document dc in Children.ToList())
-                    dc.PublishWithSubs(u);
+                var published = ApplicationContext.Current.Services.ContentService.PublishWithChildren(Content, u.Id, true);
 
                 FireAfterPublish(e);
             }
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.UnPublish()", false)]
         public void UnPublish()
         {
             UnPublishEventArgs e = new UnPublishEventArgs();
@@ -1183,10 +853,8 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
 
             if (!e.Cancel)
             {
-                SqlHelper.ExecuteNonQuery(string.Format("update cmsDocument set published = 0 where nodeId = {0}", Id));
-
-                _published = false;
-
+                _published = ApplicationContext.Current.Services.ContentService.UnPublish(Content, 0, true);
+                
                 FireAfterUnPublish(e);
             }
         }
@@ -1194,24 +862,20 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// <summary>
         /// Used to persist object changes to the database. 
         /// </summary>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Save()", false)]
         public override void Save()
         {
-            SaveEventArgs e = new SaveEventArgs();
+            var e = new SaveEventArgs();
             FireBeforeSave(e);
 
             if (!e.Cancel)
             {
+                foreach (var property in GenericProperties)
+                {
+                    Content.SetValue(property.PropertyType.Alias, property.Value);
+                }
 
-                //if (this._optimizedMode)
-                //{
-                //    foreach (var property in this._knownProperties)
-                //    {
-                //        var pt = property.Key;
-                //        pt.Value = property.Value;
-                //    }
-                //}
-
-                UpdateDate = DateTime.Now; //set the updated date to now
+                ApplicationContext.Current.Services.ContentService.Save(Content);
 
                 base.Save();
                 // update preview xml
@@ -1221,9 +885,10 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
             }
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.HasPublishedVersion()", false)]
         public bool HasPublishedVersion()
         {
-            return (SqlHelper.ExecuteScalar<int>("select Count(published) as tmp from cmsDocument where published = 1 And nodeId =" + Id) > 0);
+            return Content.HasPublishedVersion();
         }
 
         /// <summary>
@@ -1232,70 +897,44 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// then this is considered a change.
         /// </summary>
         /// <returns></returns>
+        [Obsolete("Deprecated, Instead of calling this just check if the latest version of the content is published", false)]
         public bool HasPendingChanges()
         {
-            double timeDiff = new TimeSpan(UpdateDate.Ticks - VersionDate.Ticks).TotalMilliseconds;
-            return timeDiff > 2000;
+            return Content.Published == false;
         }
 
         /// <summary>
         /// Used for rolling back documents to a previous version
         /// </summary>
         /// <returns> Previous published versions of the document</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetVersions()", false)]
         public DocumentVersionList[] GetVersions()
         {
-            ArrayList versions = new ArrayList();
-            using (IRecordsReader dr =
-                SqlHelper.ExecuteReader("select documentUser, versionId, updateDate, text from cmsDocument where nodeId = @nodeId order by updateDate",
-                                        SqlHelper.CreateParameter("@nodeId", Id)))
-            {
-                while (dr.Read())
-                {
-                    DocumentVersionList dv =
-                        new DocumentVersionList(dr.GetGuid("versionId"),
-                                                dr.GetDateTime("updateDate"),
-                                                dr.GetString("text"),
-                                                User.GetUser(dr.GetInt("documentUser")));
-                    versions.Add(dv);
-                }
-            }
-
-            DocumentVersionList[] retVal = new DocumentVersionList[versions.Count];
-            int i = 0;
-            foreach (DocumentVersionList dv in versions)
-            {
-                retVal[i] = dv;
-                i++;
-            }
-            return retVal;
+            var versions = ApplicationContext.Current.Services.ContentService.GetVersions(Id);
+            return
+                versions.Select(x => new DocumentVersionList(x.Version, x.UpdateDate, x.Name, User.GetUser(x.CreatorId)))
+                        .ToArray();
         }
 
         /// <summary>
         /// Returns the published version of this document
         /// </summary>
         /// <returns>The published version of this document</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetPublishedVersion()", false)]
         public DocumentVersionList GetPublishedVersion()
         {
-            using (IRecordsReader dr =
-                SqlHelper.ExecuteReader("select top 1 documentUser, versionId, updateDate, text from cmsDocument where nodeId = @nodeId and published = 1 order by updateDate desc",
-                                        SqlHelper.CreateParameter("@nodeId", Id)))
-            {
-                if (dr.Read())
-                {
-                    return new DocumentVersionList(dr.GetGuid("versionId"),
-                                                dr.GetDateTime("updateDate"),
-                                                dr.GetString("text"),
-                                                User.GetUser(dr.GetInt("documentUser")));
-                }
-            }
+            var version = ApplicationContext.Current.Services.ContentService.GetPublishedVersion(Id);
+            if (version == null)
+                return null;
 
-            return null;
+            return new DocumentVersionList(version.Version, version.UpdateDate, version.Name, User.GetUser(version.CreatorId));
         }
 
         /// <summary>
         /// 
         /// </summary>
         /// <returns>Returns a breadcrumlike path for the document like: /ancestorname/ancestorname</returns>
+        [Obsolete("Method is not used anywhere, so its marked for deletion")]
         public string GetTextPath()
         {
             string tempPath = "";
@@ -1315,6 +954,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// </summary>
         /// <param name="CopyTo">The parentid where the document should be copied to</param>
         /// <param name="u">The usercontext under which the action are performed</param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Copy()", false)]
         public Document Copy(int CopyTo, User u)
         {
             return Copy(CopyTo, u, false);
@@ -1327,11 +967,10 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// <param name="CopyTo"></param>
         /// <param name="u"></param>
         /// <param name="RelateToOrignal"></param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Copy()", false)]
         public Document Copy(int CopyTo, User u, bool RelateToOrignal)
         {
-            var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();
-
-            CopyEventArgs e = new CopyEventArgs();
+            var e = new CopyEventArgs();
             e.CopyTo = CopyTo;
             FireBeforeCopy(e);
             Document newDoc = null;
@@ -1339,74 +978,16 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
             if (!e.Cancel)
             {
                 // Make the new document
-                newDoc = MakeNew(Text, new DocumentType(ContentType.Id), u, CopyTo);
-
-                if (newDoc != null)
-                {
-                    // update template if a template is set
-                    if (this.Template > 0)
-                        newDoc.Template = Template;
-
-                    //update the trashed property as it could be copied inside the recycle bin
-                    newDoc.IsTrashed = this.IsTrashed;
-
-                    // Copy the properties of the current document
-                    var props = GenericProperties;
-                    foreach (Property p in props)
-                    {
-                        //copy file if it's an upload property (so it doesn't get removed when original doc get's deleted)
-
-                        IDataType uploadField = new Factory().GetNewObject(new Guid("5032a6e6-69e3-491d-bb28-cd31cd11086c"));
-
-                        if (p.PropertyType.DataTypeDefinition.DataType.Id == uploadField.Id
-                        && p.Value.ToString() != ""
-                        && fs.FileExists(fs.GetRelativePath(p.Value.ToString())))
-                        {
-                            var currentPath = fs.GetRelativePath(p.Value.ToString());
-
-                            var propId = newDoc.getProperty(p.PropertyType.Alias).Id;
-                            var newPath = fs.GetRelativePath(propId, System.IO.Path.GetFileName(currentPath));
-
-                            fs.CopyFile(currentPath, newPath);
-
-                            newDoc.getProperty(p.PropertyType.Alias).Value = fs.GetUrl(newPath);
-
-                            //copy thumbs
-                            foreach (var thumbPath in fs.GetThumbnails(currentPath))
-                            {
-                                var newThumbPath = fs.GetRelativePath(propId, System.IO.Path.GetFileName(thumbPath));
-                                fs.CopyFile(thumbPath, newThumbPath);
-                            }
-
-                        }
-                        else
-                        {
-                            newDoc.getProperty(p.PropertyType.Alias).Value = p.Value;
-                        }
-
-                    }
-
-                    // Relate?
-                    if (RelateToOrignal)
-                    {
-                        Relation.MakeNew(Id, newDoc.Id, RelationType.GetByAlias("relateDocumentOnCopy"), "");
-
-                        // Add to audit trail
-                        Log.Add(LogTypes.Copy, u, newDoc.Id, "Copied and related from " + Text + " (id: " + Id.ToString() + ")");
-                    }
-
-
-                    // Copy the children
-                    //store children array here because iterating over an Array object is very inneficient.
-                    var c = Children;
-                    foreach (Document d in c)
-                        d.Copy(newDoc.Id, u, RelateToOrignal);
-
-                    e.NewDocument = newDoc;
-                }
+                var content = ApplicationContext.Current.Services.ContentService.Copy(Content, CopyTo, RelateToOrignal, u.Id);
+                newDoc = new Document(content);
+                
+                // Have to run the ActionNew handler to do umbEnsureUniqueName (for example)
+                BusinessLogic.Actions.Action.RunActionHandlers(newDoc, ActionNew.Instance);
+                // Then save to preserve any changes made by action handlers
+                newDoc.Save();
 
+                e.NewDocument = newDoc;
                 FireAfterCopy(e);
-
             }
 
             return newDoc;
@@ -1415,6 +996,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// <summary>
         /// Puts the current document in the trash
         /// </summary>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.MoveToRecycleBin()", false)]
         public override void delete()
         {
             MoveToTrash();
@@ -1424,6 +1006,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// With either move the document to the trash or permanently remove it from the database.
         /// </summary>
         /// <param name="deletePermanently">flag to set whether or not to completely remove it from the database or just send to trash</param>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Delete() or Umbraco.Core.Services.ContentService.MoveToRecycleBin()", false)]
         public void delete(bool deletePermanently)
         {
             if (!deletePermanently)
@@ -1440,22 +1023,14 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// Returns all decendants of the current document
         /// </summary>
         /// <returns></returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.GetDescendants()", false)]
         public override IEnumerable GetDescendants()
         {
-            var tmp = new List<Document>();
-            using (IRecordsReader dr = SqlHelper.ExecuteReader(
-                                        string.Format(m_SQLOptimizedMany.Trim(), "umbracoNode.path LIKE '%," + this.Id + ",%'", "umbracoNode.level"),
-                                        SqlHelper.CreateParameter("@nodeObjectType", Document._objectType)))
-            {
-                while (dr.Read())
-                {
-                    Document d = new Document(dr.GetInt("id"), true);
-                    d.PopulateDocumentFromReader(dr);
-                    tmp.Add(d);
-                }
-            }
+            var descendants = Content == null
+                                  ? ApplicationContext.Current.Services.ContentService.GetDescendants(Id)
+                                  : ApplicationContext.Current.Services.ContentService.GetDescendants(Content);
 
-            return tmp.ToArray();
+            return descendants.Select(x => new Document(x.Id, true));
         }
 
         /// <summary>
@@ -1463,6 +1038,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// </summary>
         /// <param name="xd">The source xmldocument</param>
         /// <param name="x">The previous xmlrepresentation of the document</param>
+        [Obsolete("Deprecated, Doesn't appear to be used anywhere", false)]
         public void XmlNodeRefresh(XmlDocument xd, ref XmlNode x)
         {
             x.Attributes.RemoveAll();
@@ -1479,18 +1055,6 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         public override void XmlGenerate(XmlDocument xd)
         {
             XmlNode x = generateXmlWithoutSaving(xd);
-            /*
-                        if (!UmbracoSettings.UseFriendlyXmlSchema)
-                        {
-                        } else
-                        {
-                            XmlNode childNodes = xmlHelper.addTextNode(xd, "data", "");
-                            x.AppendChild(childNodes);
-                            XmlPopulate(xd, ref childNodes, false);
-                        }
-            */
-
-
             // Save to db
             saveXml(x);
         }
@@ -1631,7 +1195,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
 
         public override List<CMSPreviewNode> GetNodesForPreview(bool childrenOnly)
         {
-            List<CMSPreviewNode> nodes = new List<CMSPreviewNode>();
+            var nodes = new List<CMSPreviewNode>();
 
             string pathExp = childrenOnly ? Path + ",%" : Path;
 
@@ -1663,37 +1227,47 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         #endregion
 
         #region Protected Methods
+        [Obsolete("Deprecated", false)]
         protected override void setupNode()
         {
-            base.setupNode();
+            var content = Version == Guid.Empty
+                           ? ApplicationContext.Current.Services.ContentService.GetById(Id)
+                           : ApplicationContext.Current.Services.ContentService.GetByVersion(Version);
 
-            using (var dr =
-                SqlHelper.ExecuteReader("select published, documentUser, coalesce(templateId, cmsDocumentType.templateNodeId) as templateId, text, releaseDate, expireDate, updateDate from cmsDocument inner join cmsContent on cmsDocument.nodeId = cmsContent.Nodeid left join cmsDocumentType on cmsDocumentType.contentTypeNodeId = cmsContent.contentType and cmsDocumentType.IsDefault = 1 where versionId = @versionId",
-                                        SqlHelper.CreateParameter("@versionId", Version)))
-            {
-                if (dr.Read())
-                {
-                    _creator = User;
-                    _writer = User.GetUser(dr.GetInt("documentUser"));
+            if(content == null)
+                throw new ArgumentException(string.Format("No Document exists with id '{0}'", Id));
 
-                    if (!dr.IsNull("templateId"))
-                        _template = dr.GetInt("templateId");
-                    if (!dr.IsNull("releaseDate"))
-                        _release = dr.GetDateTime("releaseDate");
-                    if (!dr.IsNull("expireDate"))
-                        _expire = dr.GetDateTime("expireDate");
-                    if (!dr.IsNull("updateDate"))
-                        _updated = dr.GetDateTime("updateDate");
-                }
-                else
-                {
-                    throw new ArgumentException(string.Format("No Document exists with Version '{0}'", Version));
-                }
-            }
-
-            _published = HasPublishedVersion();
+            SetupNode(content);
         }
 
+        private void SetupNode(IContent content)
+        {
+            Content = content;
+            //Setting private properties from IContentBase replacing CMSNode.setupNode() / CMSNode.PopulateCMSNodeFromReader()
+            base.PopulateCMSNodeFromContentBase(Content, _objectType);
+
+            //If the version is empty we update with the latest version from the current IContent.
+            if (Version == Guid.Empty)
+                Version = Content.Version;
+
+            //Setting private properties from IContent replacing Document.setupNode()
+            _creator = User.GetUser(Content.CreatorId);
+            _writer = User.GetUser(Content.WriterId);
+            _updated = Content.UpdateDate;
+
+            if (Content.Template != null)
+                _template = Content.Template.Id;
+
+            if (Content.ExpireDate.HasValue)
+                _expire = Content.ExpireDate.Value;
+
+            if (Content.ReleaseDate.HasValue)
+                _release = Content.ReleaseDate.Value;
+
+            _published = Content.Published;
+        }
+
+        [Obsolete("Deprecated", false)]
         protected void InitializeDocument(User InitUser, User InitWriter, string InitText, int InitTemplate,
                                           DateTime InitReleaseDate, DateTime InitExpireDate, DateTime InitUpdateDate,
                                           bool InitPublished)
@@ -1716,6 +1290,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
             _published = InitPublished;
         }
 
+        [Obsolete("Deprecated", false)]
         protected void PopulateDocumentFromReader(IRecordsReader dr)
         {
             bool _hc = false;
@@ -1758,6 +1333,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         #endregion
 
         #region Private Methods
+        [Obsolete("Deprecated", false)]
         private void SetupDocumentForTree(Guid uniqueId, int level, int parentId, int creator, int writer, bool publish, string path,
                                          string text, DateTime createDate, DateTime updateDate,
                                          DateTime versionDate, string icon, bool hasChildren, string contentTypeAlias, string contentTypeThumb,
@@ -1806,6 +1382,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// Used internally to permanently delete the data from the database
         /// </summary>
         /// <returns>returns true if deletion isn't cancelled</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.Delete()", false)]
         private bool DeletePermanently()
         {
             DeleteEventArgs e = new DeleteEventArgs();
@@ -1814,21 +1391,18 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
 
             if (!e.Cancel)
             {
-                foreach (Document d in Children.ToList())
+                umbraco.BusinessLogic.Actions.Action.RunActionHandlers(this, ActionDelete.Instance);
+                if (Content != null)
                 {
-                    d.DeletePermanently();
+                    ApplicationContext.Current.Services.ContentService.Delete(Content);
+                }
+                else
+                {
+                    Content = ApplicationContext.Current.Services.ContentService.GetById(Id);
+                    ApplicationContext.Current.Services.ContentService.Delete(Content);
                 }
 
-                umbraco.BusinessLogic.Actions.Action.RunActionHandlers(this, ActionDelete.Instance);
-
-                // Remove all files
-                DeleteAssociatedMediaFiles();
-
-                //remove any domains associated
-                var domains = Domain.GetDomainsById(this.Id).ToList();
-                domains.ForEach(x => x.Delete());
-
-                SqlHelper.ExecuteNonQuery("delete from cmsDocument where NodeId = " + Id);
+                //Keeping the base.delete() as it looks to be clear 'private/internal cache'
                 base.delete();
 
                 FireAfterDelete(e);
@@ -1840,6 +1414,7 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
         /// Used internally to move the node to the recyle bin
         /// </summary>
         /// <returns>Returns true if the move was not cancelled</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentService.MoveToRecycleBin()", false)]
         private bool MoveToTrash()
         {
             MoveToTrashEventArgs e = new MoveToTrashEventArgs();
@@ -1849,7 +1424,15 @@ and node.nodeObjectType='C66BA18E-EAF3-4CFF-8A22-41B16D66A972'");
             {
                 umbraco.BusinessLogic.Actions.Action.RunActionHandlers(this, ActionDelete.Instance);
                 UnPublish();
-                Move((int)RecycleBin.RecycleBinType.Content);
+                if (Content != null)
+                {
+                    ApplicationContext.Current.Services.ContentService.MoveToRecycleBin(Content);
+                }
+                else
+                {
+                    Content = ApplicationContext.Current.Services.ContentService.GetById(Id);
+                    ApplicationContext.Current.Services.ContentService.MoveToRecycleBin(Content);
+                }
                 FireAfterMoveToTrash(e);
             }
             return !e.Cancel;
diff --git a/src/umbraco.cms/businesslogic/web/DocumentType.cs b/src/umbraco.cms/businesslogic/web/DocumentType.cs
index 6c7ab170ec..02bd51b4ba 100644
--- a/src/umbraco.cms/businesslogic/web/DocumentType.cs
+++ b/src/umbraco.cms/businesslogic/web/DocumentType.cs
@@ -4,17 +4,21 @@ using System.Text;
 using System.Xml;
 using System.Linq;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence.Caching;
 using umbraco.BusinessLogic;
 using umbraco.cms.businesslogic.propertytype;
 using umbraco.DataLayer;
 using System.Collections.Generic;
 using Umbraco.Core;
+using PropertyType = umbraco.cms.businesslogic.propertytype.PropertyType;
 
 namespace umbraco.cms.businesslogic.web
 {
     /// <summary>
     /// Summary description for DocumentType.
     /// </summary>
+    [Obsolete("Deprecated, Use Umbraco.Core.Models.ContentType", false)]
     public class DocumentType : ContentType
     {
         #region Constructors
@@ -25,6 +29,12 @@ namespace umbraco.cms.businesslogic.web
 
         public DocumentType(int id, bool noSetup) : base(id, noSetup) { }
 
+        internal DocumentType(IContentType contentType)
+            : base(contentType)
+        {
+            SetupNode(contentType);
+        }
+
         #endregion
 
         #region Constants and Static members
@@ -48,6 +58,7 @@ namespace umbraco.cms.businesslogic.web
         private int _defaultTemplate;
         private bool _hasChildrenInitialized = false;
         private bool _hasChildren;
+        private IContentType _contentType;
 
         #endregion
 
@@ -57,6 +68,7 @@ namespace umbraco.cms.businesslogic.web
         /// Generates the complete (simplified) XML DTD 
         /// </summary>
         /// <returns>The DTD as a string</returns>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.GetDtd()", false)]
         public static string GenerateDtd()
         {
             StringBuilder dtd = new StringBuilder();
@@ -71,6 +83,7 @@ namespace umbraco.cms.businesslogic.web
             return dtd.ToString();
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.GetContentTypesDtd()", false)]
         public static string GenerateXmlDocumentType()
         {
             StringBuilder dtd = new StringBuilder();
@@ -111,15 +124,13 @@ namespace umbraco.cms.businesslogic.web
 
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.GetContentType()", false)]
         public new static DocumentType GetByAlias(string Alias)
         {
             try
             {
-                return
-                    new DocumentType(
-                            SqlHelper.ExecuteScalar<int>(@"SELECT nodeid from cmsContentType INNER JOIN umbracoNode on cmsContentType.nodeId = umbracoNode.id WHERE nodeObjectType=@nodeObjectType AND alias=@alias",
-                                SqlHelper.CreateParameter("@nodeObjectType", DocumentType._objectType),
-                                SqlHelper.CreateParameter("@alias", Alias)));
+                var contentType = ApplicationContext.Current.Services.ContentTypeService.GetContentType(Alias);
+                return new DocumentType(contentType.Id);
             }
             catch
             {
@@ -127,15 +138,12 @@ namespace umbraco.cms.businesslogic.web
             }
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Models.ContentType and Umbraco.Core.Services.ContentTypeService.Save()", false)]
         public static DocumentType MakeNew(User u, string Text)
         {
-            int ParentId = -1;
-            int level = 1;
-            Guid uniqueId = Guid.NewGuid();
-            CMSNode n = MakeNew(ParentId, _objectType, u.Id, level, Text, uniqueId);
-
-            Create(n.Id, Text, "");
-            DocumentType newDt = new DocumentType(n.Id);
+            var contentType = new Umbraco.Core.Models.ContentType(-1) { Name = Text, Alias = Text, CreatorId = u.Id, Thumbnail = "folder.png", Icon = "folder.gif" };
+            ApplicationContext.Current.Services.ContentTypeService.Save(contentType, u.Id);
+            var newDt = new DocumentType(contentType);
 
             //event
             NewEventArgs e = new NewEventArgs();
@@ -153,53 +161,26 @@ namespace umbraco.cms.businesslogic.web
             }
         }
 
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.GetAllContentTypes()", false)]
         public static List<DocumentType> GetAllAsList()
         {
-
-            var documentTypes = new List<DocumentType>();
-
-            using (IRecordsReader dr =
-                SqlHelper.ExecuteReader(m_SQLOptimizedGetAll.Trim(), SqlHelper.CreateParameter("@nodeObjectType", DocumentType._objectType)))
-            {
-                while (dr.Read())
-                {
-                    //check if the document id has already been added
-                    if (documentTypes.Where(x => x.Id == dr.Get<int>("id")).Count() == 0)
-                    {
-                        //create the DocumentType object without setting up
-                        DocumentType dt = new DocumentType(dr.Get<int>("id"), true);
-                        //populate it's CMSNode properties
-                        dt.PopulateCMSNodeFromReader(dr);
-                        //populate it's ContentType properties
-                        dt.PopulateContentTypeNodeFromReader(dr);
-                        //populate from it's DocumentType properties
-                        dt.PopulateDocumentTypeNodeFromReader(dr);
-
-                        documentTypes.Add(dt);
-                    }
-                    else
-                    {
-                        //we've already created the document type with this id, so we'll add the rest of it's templates to itself
-                        var dt = documentTypes.Where(x => x.Id == dr.Get<int>("id")).Single();
-                        dt.PopulateDocumentTypeNodeFromReader(dr);
-                    }
-                }
-            }
+            var contentTypes = ApplicationContext.Current.Services.ContentTypeService.GetAllContentTypes();
+            var documentTypes = contentTypes.Select(x => new DocumentType(x.Id));
 
             return documentTypes.OrderBy(x => x.Text).ToList();
-
         }
 
         #endregion
 
         #region Public Properties
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.HasChildren()", false)]
         public override bool HasChildren
         {
             get
             {
-                if (!_hasChildrenInitialized)
+                if (_hasChildrenInitialized == false)
                 {
-                    HasChildren = SqlHelper.ExecuteScalar<int>("select count(childContentTypeId) as tmp from cmsContentType2ContentType where parentContentTypeId = @id", SqlHelper.CreateParameter("@id", Id)) > 0;
+                    HasChildren = ApplicationContext.Current.Services.ContentTypeService.HasChildren(Id);
                 }
                 return _hasChildren;
             }
@@ -210,6 +191,7 @@ namespace umbraco.cms.businesslogic.web
             }
         }
 
+        [Obsolete("Deprecated, Use SetDefaultTemplate() on Umbraco.Core.Models.ContentType", false)]
         public int DefaultTemplate
         {
             get { return _defaultTemplate; }
@@ -217,15 +199,19 @@ namespace umbraco.cms.businesslogic.web
             {
                 RemoveDefaultTemplate();
                 _defaultTemplate = value;
+
                 if (_defaultTemplate != 0)
-                    SqlHelper.ExecuteNonQuery("update cmsDocumentType set IsDefault = 1 where contentTypeNodeId = " +
-                                              Id.ToString() + " and TemplateNodeId = " + value.ToString());
+                {
+                    var template = ApplicationContext.Current.Services.FileService.GetTemplate(_defaultTemplate);
+                    _contentType.SetDefaultTemplate(template);
+                }
             }
         }
 
         /// <summary>
         /// Gets/sets the allowed templates for this document type.
         /// </summary>
+        [Obsolete("Deprecated, Use AllowedTemplates property on Umbraco.Core.Models.ContentType", false)]
         public template.Template[] allowedTemplates
         {
             get
@@ -244,12 +230,15 @@ namespace umbraco.cms.businesslogic.web
             set
             {
                 clearTemplates();
+                var templates = new List<ITemplate>();
                 foreach (template.Template t in value)
                 {
-                    SqlHelper.ExecuteNonQuery("Insert into cmsDocumentType (contentTypeNodeId, templateNodeId) values (" +
-                                              Id + "," + t.Id + ")");
+                    var template = ApplicationContext.Current.Services.FileService.GetTemplate(t.Id);
+                    templates.Add(template);
+
                     _templateIds.Add(t.Id);
                 }
+                _contentType.AllowedTemplates = templates;
             }
         }
 
@@ -292,6 +281,7 @@ namespace umbraco.cms.businesslogic.web
 
         #region Public Methods
 
+        [Obsolete("Deprecated, Use RemoveTemplate() on Umbraco.Core.Models.ContentType", false)]
         public void RemoveTemplate(int templateId)
         {
             // remove if default template
@@ -303,9 +293,10 @@ namespace umbraco.cms.businesslogic.web
             // remove from list of document type templates
             if (_templateIds.Contains(templateId))
             {
-                SqlHelper.ExecuteNonQuery("delete from cmsDocumentType where contentTypeNodeId = @id and templateNodeId = @templateId",
-                    SqlHelper.CreateParameter("@id", this.Id), SqlHelper.CreateParameter("@templateId", templateId)
-                    );
+                var template = _contentType.AllowedTemplates.FirstOrDefault(x => x.Id == templateId);
+                if (template != null)
+                    _contentType.RemoveTemplate(template);
+
                 _templateIds.Remove(templateId);
             }
         }
@@ -314,6 +305,7 @@ namespace umbraco.cms.businesslogic.web
         /// 
         /// </summary>
         /// <exception cref="ArgumentException">Throws an exception if trying to delete a document type that is assigned as a master document type</exception>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.Delete()", false)]
         public override void delete()
         {
             DeleteEventArgs e = new DeleteEventArgs();
@@ -327,21 +319,20 @@ namespace umbraco.cms.businesslogic.web
                     throw new ArgumentException("Can't delete a Document Type used as a Master Content Type. Please remove all references first!");
                 }
 
-                // delete all documents of this type
-                Document.DeleteFromType(this);
+                // Remove from cache
+                FlushFromCache(Id);
+
+                ApplicationContext.Current.Services.ContentTypeService.Delete(_contentType);
 
                 clearTemplates();
 
-                // Delete contentType
-                base.delete();
-
                 FireAfterDelete(e);
             }
         }
 
         public void clearTemplates()
         {
-            SqlHelper.ExecuteNonQuery("Delete from cmsDocumentType where contentTypeNodeId =" + Id);
+            _contentType.AllowedTemplates = new List<ITemplate>();
             _templateIds.Clear();
         }
 
@@ -429,10 +420,14 @@ namespace umbraco.cms.businesslogic.web
             return doc;
         }
 
+        [Obsolete("Deprecated, Use RemoveTemplate() on Umbraco.Core.Models.ContentType", false)]
         public void RemoveDefaultTemplate()
         {
             _defaultTemplate = 0;
-            SqlHelper.ExecuteNonQuery("update cmsDocumentType set IsDefault = 0 where contentTypeNodeId = " + Id.ToString());
+
+            var template = _contentType.DefaultTemplate;
+            if(template != null)
+                _contentType.RemoveTemplate(template);
         }
 
         public bool HasTemplate()
@@ -443,6 +438,7 @@ namespace umbraco.cms.businesslogic.web
         /// <summary>
         /// Used to persist object changes to the database. In Version3.0 it's just a stub for future compatibility
         /// </summary>
+        [Obsolete("Deprecated, Use Umbraco.Core.Services.ContentTypeService.Save()", false)]
         public override void Save()
         {
             SaveEventArgs e = new SaveEventArgs();
@@ -450,6 +446,20 @@ namespace umbraco.cms.businesslogic.web
 
             if (!e.Cancel)
             {
+                if (MasterContentType != 0)
+                    _contentType.ParentId = MasterContentType;
+
+                foreach (var masterContentType in MasterContentTypes)
+                {
+                    var contentType = ApplicationContext.Current.Services.ContentTypeService.GetContentType(masterContentType);
+                    _contentType.AddContentType(contentType);
+                }
+
+                ApplicationContext.Current.Services.ContentTypeService.Save(_contentType);
+
+                //Ensure that DocumentTypes are reloaded from db by clearing cache
+                InMemoryCacheProvider.Current.Clear();
+
                 base.Save();
                 FireAfterSave(e);
             }
@@ -459,6 +469,7 @@ namespace umbraco.cms.businesslogic.web
 
         #region Protected Methods
 
+        [Obsolete("Depreated, No longer needed nor used")]
         protected void PopulateDocumentTypeNodeFromReader(IRecordsReader dr)
         {
             if (!dr.IsNull("templateNodeId"))
@@ -476,29 +487,27 @@ namespace umbraco.cms.businesslogic.web
 
         protected override void setupNode()
         {
-            base.setupNode();
-
-            using (IRecordsReader dr = SqlHelper.ExecuteReader("Select templateNodeId, IsDefault from cmsDocumentType where contentTypeNodeId = @id",
-                SqlHelper.CreateParameter("@id", Id)))
-            {
-                while (dr.Read())
-                {
-                    PopulateDocumentTypeNodeFromReader(dr);
-                }
-            }
-
+            var contentType = ApplicationContext.Current.Services.ContentTypeService.GetContentType(Id);
+            SetupNode(contentType);
         }
 
         #endregion
 
         #region Private Methods
-
-        [Obsolete("Use the overridden setupNode instead. This method now calls the setupNode method")]
-        private void setupDocumentType()
+        private void SetupNode(IContentType contentType)
         {
-            setupNode();
-        }
+            _contentType = contentType;
+            foreach (var template in _contentType.AllowedTemplates.Where(t => t != null))
+            {
+                _templateIds.Add(template.Id);
+            }
 
+            if (_contentType.DefaultTemplate != null)
+                _defaultTemplate = _contentType.DefaultTemplate.Id;
+
+            base.PopulateContentTypeFromContentTypeBase(_contentType);
+            base.PopulateCMSNodeFromContentTypeBase(_contentType, _objectType);
+        }
         #endregion
 
         #region Events
diff --git a/src/umbraco.cms/businesslogic/workflow/Notification.cs b/src/umbraco.cms/businesslogic/workflow/Notification.cs
index 69fb4cd150..4f8fc52111 100644
--- a/src/umbraco.cms/businesslogic/workflow/Notification.cs
+++ b/src/umbraco.cms/businesslogic/workflow/Notification.cs
@@ -78,7 +78,7 @@ namespace umbraco.cms.businesslogic.workflow
 
             // build summary
             var summary = new StringBuilder();
-            Property[] props = documentObject.getProperties;
+            var props = documentObject.GenericProperties;
             foreach (Property p in props)
             {
                 // check if something was changed and display the changes otherwise display the fields
diff --git a/src/umbraco.controls/umbraco.controls.csproj b/src/umbraco.controls/umbraco.controls.csproj
index e88a9def9a..4ae38fb1ea 100644
--- a/src/umbraco.controls/umbraco.controls.csproj
+++ b/src/umbraco.controls/umbraco.controls.csproj
@@ -124,6 +124,10 @@
       <Project>{ccd75ec3-63db-4184-b49d-51c1dd337230}</Project>
       <Name>umbraco.cms</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Umbraco.Core\Umbraco.Core.csproj">
+      <Project>{31785bc3-256c-4613-b2f5-a1b0bdded8c1}</Project>
+      <Name>Umbraco.Core</Name>
+    </ProjectReference>
     <ProjectReference Include="..\umbraco.datalayer\umbraco.datalayer.csproj">
       <Project>{C7CB79F0-1C97-4B33-BFA7-00731B579AE2}</Project>
       <Name>umbraco.datalayer</Name>
diff --git a/src/umbraco.webservices/documents/documentService.cs b/src/umbraco.webservices/documents/documentService.cs
index caea93c368..6292c02d6b 100644
--- a/src/umbraco.webservices/documents/documentService.cs
+++ b/src/umbraco.webservices/documents/documentService.cs
@@ -293,7 +293,7 @@ namespace umbraco.webservices.documents
 
             carrier.Published = doc.Published;
             carrier.HasChildren = doc.HasChildren;
-            var props = doc.getProperties;
+            var props = doc.GenericProperties;
             foreach (umbraco.cms.businesslogic.property.Property prop in props)
             {
                 documentProperty carrierprop = new documentProperty();
diff --git a/src/umbraco.webservices/media/mediaService.cs b/src/umbraco.webservices/media/mediaService.cs
index 1d62141bf5..e4ca16996c 100644
--- a/src/umbraco.webservices/media/mediaService.cs
+++ b/src/umbraco.webservices/media/mediaService.cs
@@ -278,7 +278,7 @@ namespace umbraco.webservices.media
                 carrier.ParentId = -1;
             }
 
-            foreach (Property p in m.getProperties)
+            foreach (Property p in m.GenericProperties)
             {
 
                 mediaProperty carrierprop = new mediaProperty();
diff --git a/src/umbraco.webservices/members/memberService.cs b/src/umbraco.webservices/members/memberService.cs
index 48fd0748d9..269cf8a4dc 100644
--- a/src/umbraco.webservices/members/memberService.cs
+++ b/src/umbraco.webservices/members/memberService.cs
@@ -216,7 +216,7 @@ namespace umbraco.webservices.members
             }
 
             // Loading properties to carrier
-            var props = member.getProperties;
+            var props = member.GenericProperties;
             foreach (umbraco.cms.businesslogic.property.Property prop in props)
             {
                 memberProperty carrierprop = new memberProperty();