diff --git a/src/Umbraco.Core/Models/TemplateNode.cs b/src/Umbraco.Core/Models/TemplateNode.cs
new file mode 100644
index 0000000000..1fc51f8498
--- /dev/null
+++ b/src/Umbraco.Core/Models/TemplateNode.cs
@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a template in a template tree
+    /// </summary>
+    public class TemplateNode
+    {
+        public TemplateNode(ITemplate template)
+        {
+            Template = template;
+            Children = new List<TemplateNode>();
+        }
+
+        /// <summary>
+        /// The current template
+        /// </summary>
+        public ITemplate Template { get; set; }
+
+        /// <summary>
+        /// The children of the current template
+        /// </summary>
+        public IEnumerable<TemplateNode> Children { get; set; }
+
+        /// <summary>
+        /// The parent template to the current template
+        /// </summary>
+        /// <remarks>
+        /// Will be null if there is no parent
+        /// </remarks>
+        public TemplateNode Parent { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/ITemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/ITemplateRepository.cs
index 90d6f68adc..318b840819 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/ITemplateRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/ITemplateRepository.cs
@@ -7,5 +7,20 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         ITemplate Get(string alias);
         IEnumerable<ITemplate> GetAll(params string[] aliases);
+
+        /// <summary>
+        /// Returns a template as a template node which can be traversed (parent, children)
+        /// </summary>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        TemplateNode GetTemplateNode(string alias);
+
+        /// <summary>
+        /// Given a template node in a tree, this will find the template node with the given alias if it is found in the hierarchy, otherwise null
+        /// </summary>
+        /// <param name="anyNode"></param>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        TemplateNode FindTemplateInTree(TemplateNode anyNode, string alias);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
index 5cc827680b..e3b69a786e 100644
--- a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
@@ -273,6 +273,32 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override void PersistDeletedItem(ITemplate entity)
         {
+
+            //TODO: This isn't the most ideal way to delete a template tree, because below it will actually end up 
+            // recursing back to this method for each descendant and re-looking up the template list causing an extrac
+            // SQL call - not ideal but there shouldn't ever be a heaping list of descendant templates.
+            //The easiest way to overcome this is to expose the underlying cache upwards so that the repository has access
+            // to it, then in the PersistDeletedTemplate we wouldn't recurse the underlying function, we'd just call 
+            // PersistDeletedItem with a Template object and clear it's cache.
+
+            var sql = new Sql();
+            sql.Select("*").From<TemplateDto>().Where<TemplateDto>(dto => dto.Master != null || dto.NodeId == entity.Id);
+            var dtos = Database.Fetch<TemplateDto>(sql);
+            var self = dtos.Single(x => x.NodeId == entity.Id);
+            var allChildren = dtos.Except(new[] { self });
+            var hierarchy = GenerateTemplateHierarchy(self, allChildren);
+            //remove ourselves
+            hierarchy.Remove(self);
+            //change the order so it goes bottom up!
+            hierarchy.Reverse();
+
+            //delete the hierarchy
+            foreach (var descendant in hierarchy)
+            {
+                PersistDeletedTemplate(descendant);
+            }
+
+            //now we can delete this one
             base.PersistDeletedItem(entity);
 
             //Check for file under the Masterpages filesystem
@@ -298,6 +324,34 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #endregion
 
+        private void PersistDeletedTemplate(TemplateDto dto)
+        {
+            //we need to get the real template for this item unfortunately to remove it
+            var template = Get(dto.NodeId);
+            if (template != null)
+            {
+                //NOTE: We must cast here so that it goes to the outter method to
+                // ensure the cache is updated.
+                PersistDeletedItem((IEntity)template);
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of templates in order of descendants from the parent
+        /// </summary>
+        /// <param name="template"></param>
+        /// <param name="allChildTemplates"></param>
+        /// <returns></returns>
+        private static List<TemplateDto> GenerateTemplateHierarchy(TemplateDto template, IEnumerable<TemplateDto> allChildTemplates)
+        {
+            var hierarchy = new List<TemplateDto> { template };
+            foreach (var t in allChildTemplates.Where(x => x.Master == template.NodeId))
+            {
+                hierarchy.AddRange(GenerateTemplateHierarchy(t, allChildTemplates));
+            }
+            return hierarchy;
+        }
+
         private void PopulateViewTemplate(ITemplate template, string fileName)
         {
             string content = string.Empty;
@@ -379,6 +433,103 @@ namespace Umbraco.Core.Persistence.Repositories
 
         }
 
+        /// <summary>
+        /// Returns a template as a template node which can be traversed (parent, children)
+        /// </summary>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        public TemplateNode GetTemplateNode(string alias)
+        {
+            //in order to do this we need to get all of the templates and then organize, unfortunately 
+            // our db structure does not use the path correctly for templates so we cannot just look
+            // up a template tree easily.
+
+            //first get all template objects
+            var allTemplates = GetAll().ToArray();
+
+            var selfTemplate = allTemplates.SingleOrDefault(x => x.Alias == alias);
+            if (selfTemplate == null)
+            {
+                return null;
+            }
+
+            //then we need to get all template Dto's because those contain the master property
+            var sql = new Sql();
+            sql.Select("*").From<TemplateDto>();
+            var allDtos = Database.Fetch<TemplateDto>(sql).ToArray();
+            var selfDto = allDtos.Single(x => x.NodeId == selfTemplate.Id);
+
+            //need to get the top-most node of the current tree
+            var top = selfDto;
+            while (top.Master.HasValue)
+            {
+                top = allDtos.Single(x => x.NodeId == top.Master.Value);
+            }
+
+            var topNode = new TemplateNode(allTemplates.Single(x => x.Id == top.NodeId));
+            var childIds = allDtos.Where(x => x.Master == top.NodeId).Select(x => x.NodeId);
+            //This now creates the hierarchy recursively
+            topNode.Children = CreateChildren(topNode, childIds, allTemplates, allDtos);
+
+            //now we'll return the TemplateNode requested
+            return FindTemplateInTree(topNode, alias);
+        }
+
+        private static TemplateNode WalkTree(TemplateNode current, string alias)
+        {
+            //now walk the tree to find the node
+            if (current.Template.Alias == alias)
+            {
+                return current;
+            }
+            foreach (var c in current.Children)
+            {
+                var found = WalkTree(c, alias);
+                if (found != null) return found;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Given a template node in a tree, this will find the template node with the given alias if it is found in the hierarchy, otherwise null
+        /// </summary>
+        /// <param name="anyNode"></param>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        public TemplateNode FindTemplateInTree(TemplateNode anyNode, string alias)
+        {
+            //first get the root
+            var top = anyNode;
+            while (top.Parent != null)
+            {
+                top = top.Parent;
+            }
+            return WalkTree(top, alias);
+        }
+
+        private static IEnumerable<TemplateNode> CreateChildren(TemplateNode parent, IEnumerable<int> childIds, ITemplate[] allTemplates, TemplateDto[] allDtos)
+        {
+            var children = new List<TemplateNode>();
+            foreach (var i in childIds)
+            {
+                var template = allTemplates.Single(x => x.Id == i);
+                var child = new TemplateNode(template)
+                {
+                    Parent = parent
+                };
+
+                //add to our list
+                children.Add(child);
+
+                //get this node's children
+                var kids = allDtos.Where(x => x.Master == i).Select(x => x.NodeId).ToArray();
+
+                //recurse
+                child.Children = CreateChildren(child, kids, allTemplates, allDtos);
+            }
+            return children;
+        }
+
         #endregion
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Services/FileService.cs b/src/Umbraco.Core/Services/FileService.cs
index c912793e05..5d4f2b1da8 100644
--- a/src/Umbraco.Core/Services/FileService.cs
+++ b/src/Umbraco.Core/Services/FileService.cs
@@ -13,24 +13,24 @@ namespace Umbraco.Core.Services
     /// </summary>
     public class FileService : IFileService
     {
-	    private readonly RepositoryFactory _repositoryFactory;
+        private readonly RepositoryFactory _repositoryFactory;
         private readonly IUnitOfWorkProvider _fileUowProvider;
         private readonly IDatabaseUnitOfWorkProvider _dataUowProvider;
 
         public FileService()
             : this(new RepositoryFactory())
-        {}
+        { }
 
         public FileService(RepositoryFactory repositoryFactory)
-			: this(new FileUnitOfWorkProvider(), new PetaPocoUnitOfWorkProvider(), repositoryFactory)
+            : this(new FileUnitOfWorkProvider(), new PetaPocoUnitOfWorkProvider(), repositoryFactory)
         {
         }
 
-		public FileService(IUnitOfWorkProvider fileProvider, IDatabaseUnitOfWorkProvider dataProvider, RepositoryFactory repositoryFactory)
+        public FileService(IUnitOfWorkProvider fileProvider, IDatabaseUnitOfWorkProvider dataProvider, RepositoryFactory repositoryFactory)
         {
-			_repositoryFactory = repositoryFactory;
-		    _fileUowProvider = fileProvider;
-		    _dataUowProvider = dataProvider;
+            _repositoryFactory = repositoryFactory;
+            _fileUowProvider = fileProvider;
+            _dataUowProvider = dataProvider;
         }
 
         /// <summary>
@@ -65,19 +65,19 @@ namespace Umbraco.Core.Services
         /// <param name="userId"></param>
         public void SaveStylesheet(Stylesheet stylesheet, int userId = 0)
         {
-	        if (SavingStylesheet.IsRaisedEventCancelled(new SaveEventArgs<Stylesheet>(stylesheet), this)) 
-				return;
-	        
-			var uow = _fileUowProvider.GetUnitOfWork();
+            if (SavingStylesheet.IsRaisedEventCancelled(new SaveEventArgs<Stylesheet>(stylesheet), this))
+                return;
+
+            var uow = _fileUowProvider.GetUnitOfWork();
             using (var repository = _repositoryFactory.CreateStylesheetRepository(uow, _dataUowProvider.GetUnitOfWork()))
-	        {
-		        repository.AddOrUpdate(stylesheet);
-		        uow.Commit();
+            {
+                repository.AddOrUpdate(stylesheet);
+                uow.Commit();
 
-		        SavedStylesheet.RaiseEvent(new SaveEventArgs<Stylesheet>(stylesheet, false), this);
-	        }
+                SavedStylesheet.RaiseEvent(new SaveEventArgs<Stylesheet>(stylesheet, false), this);
+            }
 
-	        Audit.Add(AuditTypes.Save, string.Format("Save Stylesheet performed by user"), userId, -1);
+            Audit.Add(AuditTypes.Save, string.Format("Save Stylesheet performed by user"), userId, -1);
         }
 
         /// <summary>
@@ -92,15 +92,15 @@ namespace Umbraco.Core.Services
             {
                 var stylesheet = repository.Get(name);
 
-				if (DeletingStylesheet.IsRaisedEventCancelled(new DeleteEventArgs<Stylesheet>(stylesheet), this))
-					return;
+                if (DeletingStylesheet.IsRaisedEventCancelled(new DeleteEventArgs<Stylesheet>(stylesheet), this))
+                    return;
 
-				repository.Delete(stylesheet);
-				uow.Commit();
+                repository.Delete(stylesheet);
+                uow.Commit();
 
-				DeletedStylesheet.RaiseEvent(new DeleteEventArgs<Stylesheet>(stylesheet, false), this);
+                DeletedStylesheet.RaiseEvent(new DeleteEventArgs<Stylesheet>(stylesheet, false), this);
 
-				Audit.Add(AuditTypes.Delete, string.Format("Delete Stylesheet performed by user"), userId, -1);
+                Audit.Add(AuditTypes.Delete, string.Format("Delete Stylesheet performed by user"), userId, -1);
             }
         }
 
@@ -146,19 +146,19 @@ namespace Umbraco.Core.Services
         /// <param name="userId"></param>
         public void SaveScript(Script script, int userId = 0)
         {
-	        if (SavingScript.IsRaisedEventCancelled(new SaveEventArgs<Script>(script), this)) 
-				return;
-	        
-			var uow = _fileUowProvider.GetUnitOfWork();
-	        using (var repository = _repositoryFactory.CreateScriptRepository(uow))
-	        {
-		        repository.AddOrUpdate(script);
-		        uow.Commit();
+            if (SavingScript.IsRaisedEventCancelled(new SaveEventArgs<Script>(script), this))
+                return;
 
-		        SavedScript.RaiseEvent(new SaveEventArgs<Script>(script, false), this);
-	        }
+            var uow = _fileUowProvider.GetUnitOfWork();
+            using (var repository = _repositoryFactory.CreateScriptRepository(uow))
+            {
+                repository.AddOrUpdate(script);
+                uow.Commit();
 
-	        Audit.Add(AuditTypes.Save, string.Format("Save Script performed by user"), userId, -1);
+                SavedScript.RaiseEvent(new SaveEventArgs<Script>(script, false), this);
+            }
+
+            Audit.Add(AuditTypes.Save, string.Format("Save Script performed by user"), userId, -1);
         }
 
         /// <summary>
@@ -173,15 +173,15 @@ namespace Umbraco.Core.Services
             {
                 var script = repository.Get(name);
 
-				if (DeletingScript.IsRaisedEventCancelled(new DeleteEventArgs<Script>(script), this))
-					return; ;
-				
-				repository.Delete(script);
-				uow.Commit();
+                if (DeletingScript.IsRaisedEventCancelled(new DeleteEventArgs<Script>(script), this))
+                    return; ;
 
-				DeletedScript.RaiseEvent(new DeleteEventArgs<Script>(script, false), this);
+                repository.Delete(script);
+                uow.Commit();
 
-				Audit.Add(AuditTypes.Delete, string.Format("Delete Script performed by user"), userId, -1);
+                DeletedScript.RaiseEvent(new DeleteEventArgs<Script>(script, false), this);
+
+                Audit.Add(AuditTypes.Delete, string.Format("Delete Script performed by user"), userId, -1);
             }
         }
 
@@ -233,6 +233,33 @@ namespace Umbraco.Core.Services
             }
         }
 
+        /// <summary>
+        /// Returns a template as a template node which can be traversed (parent, children)
+        /// </summary>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        public TemplateNode GetTemplateNode(string alias)
+        {
+            using (var repository = _repositoryFactory.CreateTemplateRepository(_dataUowProvider.GetUnitOfWork()))
+            {
+                return repository.GetTemplateNode(alias);
+            }
+        }
+
+        /// <summary>
+        /// Given a template node in a tree, this will find the template node with the given alias if it is found in the hierarchy, otherwise null
+        /// </summary>
+        /// <param name="anyNode"></param>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        public TemplateNode FindTemplateInTree(TemplateNode anyNode, string alias)
+        {
+            using (var repository = _repositoryFactory.CreateTemplateRepository(_dataUowProvider.GetUnitOfWork()))
+            {
+                return repository.FindTemplateInTree(anyNode, alias);
+            }
+        }
+
         /// <summary>
         /// Saves a <see cref="Template"/>
         /// </summary>
@@ -240,19 +267,19 @@ namespace Umbraco.Core.Services
         /// <param name="userId"></param>
         public void SaveTemplate(ITemplate template, int userId = 0)
         {
-	        if (SavingTemplate.IsRaisedEventCancelled(new SaveEventArgs<ITemplate>(template), this)) 
-				return;
-	        
-			var uow = _dataUowProvider.GetUnitOfWork();
-	        using (var repository = _repositoryFactory.CreateTemplateRepository(uow))
-	        {
-		        repository.AddOrUpdate(template);
-		        uow.Commit();
+            if (SavingTemplate.IsRaisedEventCancelled(new SaveEventArgs<ITemplate>(template), this))
+                return;
 
-		        SavedTemplate.RaiseEvent(new SaveEventArgs<ITemplate>(template, false), this);
-	        }
+            var uow = _dataUowProvider.GetUnitOfWork();
+            using (var repository = _repositoryFactory.CreateTemplateRepository(uow))
+            {
+                repository.AddOrUpdate(template);
+                uow.Commit();
 
-	        Audit.Add(AuditTypes.Save, string.Format("Save Template performed by user"), userId, template.Id);
+                SavedTemplate.RaiseEvent(new SaveEventArgs<ITemplate>(template, false), this);
+            }
+
+            Audit.Add(AuditTypes.Save, string.Format("Save Template performed by user"), userId, template.Id);
         }
 
         /// <summary>
@@ -292,15 +319,15 @@ namespace Umbraco.Core.Services
             {
                 var template = repository.Get(alias);
 
-				if (DeletingTemplate.IsRaisedEventCancelled(new DeleteEventArgs<ITemplate>(template), this))
-					return;
+                if (DeletingTemplate.IsRaisedEventCancelled(new DeleteEventArgs<ITemplate>(template), this))
+                    return;
 
-				repository.Delete(template);
-				uow.Commit();
+                repository.Delete(template);
+                uow.Commit();
 
-				DeletedTemplate.RaiseEvent(new DeleteEventArgs<ITemplate>(template, false), this);
+                DeletedTemplate.RaiseEvent(new DeleteEventArgs<ITemplate>(template, false), this);
 
-				Audit.Add(AuditTypes.Delete, string.Format("Delete Template performed by user"), userId, template.Id);
+                Audit.Add(AuditTypes.Delete, string.Format("Delete Template performed by user"), userId, template.Id);
             }
         }
 
@@ -320,62 +347,62 @@ namespace Umbraco.Core.Services
         /// <summary>
         /// Occurs before Delete
         /// </summary>        
-		public static event TypedEventHandler<IFileService, DeleteEventArgs<ITemplate>> DeletingTemplate;
+        public static event TypedEventHandler<IFileService, DeleteEventArgs<ITemplate>> DeletingTemplate;
 
         /// <summary>
         /// Occurs after Delete
         /// </summary>
-		public static event TypedEventHandler<IFileService, DeleteEventArgs<ITemplate>> DeletedTemplate;
+        public static event TypedEventHandler<IFileService, DeleteEventArgs<ITemplate>> DeletedTemplate;
 
-		/// <summary>
-		/// Occurs before Delete
-		/// </summary>        
-		public static event TypedEventHandler<IFileService, DeleteEventArgs<Script>> DeletingScript;
+        /// <summary>
+        /// Occurs before Delete
+        /// </summary>        
+        public static event TypedEventHandler<IFileService, DeleteEventArgs<Script>> DeletingScript;
 
-		/// <summary>
-		/// Occurs after Delete
-		/// </summary>
-		public static event TypedEventHandler<IFileService, DeleteEventArgs<Script>> DeletedScript;
+        /// <summary>
+        /// Occurs after Delete
+        /// </summary>
+        public static event TypedEventHandler<IFileService, DeleteEventArgs<Script>> DeletedScript;
 
-		/// <summary>
-		/// Occurs before Delete
-		/// </summary>        
-		public static event TypedEventHandler<IFileService, DeleteEventArgs<Stylesheet>> DeletingStylesheet;
+        /// <summary>
+        /// Occurs before Delete
+        /// </summary>        
+        public static event TypedEventHandler<IFileService, DeleteEventArgs<Stylesheet>> DeletingStylesheet;
 
-		/// <summary>
-		/// Occurs after Delete
-		/// </summary>
-		public static event TypedEventHandler<IFileService, DeleteEventArgs<Stylesheet>> DeletedStylesheet;
+        /// <summary>
+        /// Occurs after Delete
+        /// </summary>
+        public static event TypedEventHandler<IFileService, DeleteEventArgs<Stylesheet>> DeletedStylesheet;
 
         /// <summary>
         /// Occurs before Save
         /// </summary>
-		public static event TypedEventHandler<IFileService, SaveEventArgs<ITemplate>> SavingTemplate;
+        public static event TypedEventHandler<IFileService, SaveEventArgs<ITemplate>> SavingTemplate;
 
         /// <summary>
         /// Occurs after Save
         /// </summary>
-		public static event TypedEventHandler<IFileService, SaveEventArgs<ITemplate>> SavedTemplate;
+        public static event TypedEventHandler<IFileService, SaveEventArgs<ITemplate>> SavedTemplate;
 
-		/// <summary>
-		/// Occurs before Save
-		/// </summary>
-		public static event TypedEventHandler<IFileService, SaveEventArgs<Script>> SavingScript;
+        /// <summary>
+        /// Occurs before Save
+        /// </summary>
+        public static event TypedEventHandler<IFileService, SaveEventArgs<Script>> SavingScript;
 
-		/// <summary>
-		/// Occurs after Save
-		/// </summary>
-		public static event TypedEventHandler<IFileService, SaveEventArgs<Script>> SavedScript;
+        /// <summary>
+        /// Occurs after Save
+        /// </summary>
+        public static event TypedEventHandler<IFileService, SaveEventArgs<Script>> SavedScript;
 
-		/// <summary>
-		/// Occurs before Save
-		/// </summary>
-		public static event TypedEventHandler<IFileService, SaveEventArgs<Stylesheet>> SavingStylesheet;
+        /// <summary>
+        /// Occurs before Save
+        /// </summary>
+        public static event TypedEventHandler<IFileService, SaveEventArgs<Stylesheet>> SavingStylesheet;
 
-		/// <summary>
-		/// Occurs after Save
-		/// </summary>
-		public static event TypedEventHandler<IFileService, SaveEventArgs<Stylesheet>> SavedStylesheet;
+        /// <summary>
+        /// Occurs after Save
+        /// </summary>
+        public static event TypedEventHandler<IFileService, SaveEventArgs<Stylesheet>> SavedStylesheet;
 
         #endregion
     }
diff --git a/src/Umbraco.Core/Services/IFileService.cs b/src/Umbraco.Core/Services/IFileService.cs
index baf2126b20..2e1e2eef49 100644
--- a/src/Umbraco.Core/Services/IFileService.cs
+++ b/src/Umbraco.Core/Services/IFileService.cs
@@ -96,6 +96,21 @@ namespace Umbraco.Core.Services
         /// <returns>A <see cref="ITemplate"/> object</returns>
         ITemplate GetTemplate(int id);
 
+        /// <summary>
+        /// Returns a template as a template node which can be traversed (parent, children)
+        /// </summary>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        TemplateNode GetTemplateNode(string alias);
+
+        /// <summary>
+        /// Given a template node in a tree, this will find the template node with the given alias if it is found in the hierarchy, otherwise null
+        /// </summary>
+        /// <param name="anyNode"></param>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        TemplateNode FindTemplateInTree(TemplateNode anyNode, string alias);
+
         /// <summary>
         /// Saves a <see cref="ITemplate"/>
         /// </summary>
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index f615187f45..ff7a9abf20 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -197,6 +197,7 @@
     <Compile Include="Models\PublishedContent\IPublishedContentModelFactory.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentModel.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentModelFactoryResolver.cs" />
+    <Compile Include="Models\TemplateNode.cs" />
     <Compile Include="PropertyEditors\PropertyCacheValue.cs" />
     <Compile Include="PropertyEditors\PropertyValueCacheAttribute.cs" />
     <Compile Include="PropertyEditors\PropertyValueTypeAttribute.cs" />
diff --git a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs
new file mode 100644
index 0000000000..aa5d4e27d6
--- /dev/null
+++ b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs
@@ -0,0 +1,336 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Umbraco.Core.IO;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Caching;
+using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.Persistence.UnitOfWork;
+using Umbraco.Tests.TestHelpers;
+
+namespace Umbraco.Tests.Persistence.Repositories
+{
+    [TestFixture]
+    public class TemplateRepositoryTest : BaseDatabaseFactoryTest
+    {
+        private IFileSystem _masterPageFileSystem;
+        private IFileSystem _viewsFileSystem;
+
+        [SetUp]
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            _masterPageFileSystem = new PhysicalFileSystem(SystemDirectories.Masterpages);
+            _viewsFileSystem = new PhysicalFileSystem(SystemDirectories.MvcViews);
+        }
+
+        [Test]
+        public void Can_Instantiate_Repository_From_Resolver()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+
+            // Act
+            var repository = RepositoryResolver.Current.ResolveByType<ITemplateRepository>(unitOfWork);
+
+            // Assert
+            Assert.That(repository, Is.Not.Null);
+        }
+
+        [Test]
+        public void Can_Instantiate_Repository()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+
+            // Act
+            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+
+            // Assert
+            Assert.That(repository, Is.Not.Null);
+        }
+
+        [Test]
+        public void Can_Perform_Add_MasterPage()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+
+            // Act
+            var template = new Template("test-add-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
+            repository.AddOrUpdate(template);
+            unitOfWork.Commit();
+
+            //Assert
+            Assert.That(repository.Get("test"), Is.Not.Null);
+            Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+        }
+
+        [Test]
+        public void Can_Perform_Update_MasterPage()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+
+            // Act
+            var template = new Template("test-updated-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
+            repository.AddOrUpdate(template);
+            unitOfWork.Commit();
+
+            template.Content = @"<%@ Master Language=""VB"" %>";
+            repository.AddOrUpdate(template);
+            unitOfWork.Commit();
+
+            var updated = repository.Get("test");
+
+            // Assert
+            Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+            Assert.That(updated.Content, Is.EqualTo(@"<%@ Master Language=""VB"" %>"));
+        }
+
+        [Test]
+        public void Can_Perform_Delete()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+
+            var template = new Template("test-add-masterpage.master", "test", "test") { Content = @"<%@ Master Language=""C#"" %>" };
+            repository.AddOrUpdate(template);
+            unitOfWork.Commit();
+
+            // Act
+            var templates = repository.Get("test");
+            repository.Delete(templates);
+            unitOfWork.Commit();
+
+            // Assert
+            Assert.IsNull(repository.Get("test"));
+        }
+
+        [Test]
+        public void Can_Perform_Delete_On_Nested_Templates()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+
+            var parent = new Template("test-parent-masterpage.master", "parent", "parent") { Content = @"<%@ Master Language=""C#"" %>" };
+            var child = new Template("test-child-masterpage.master", "child", "child") { Content = @"<%@ Master Language=""C#"" %>" };
+            var baby = new Template("test-baby-masterpage.master", "baby", "baby") { Content = @"<%@ Master Language=""C#"" %>" };
+            child.MasterTemplateAlias = parent.Alias;
+            child.MasterTemplateId = new Lazy<int>(() => parent.Id);
+            baby.MasterTemplateAlias = child.Alias;
+            baby.MasterTemplateId = new Lazy<int>(() => child.Id);
+            repository.AddOrUpdate(parent);
+            repository.AddOrUpdate(child);
+            repository.AddOrUpdate(baby);
+            unitOfWork.Commit();
+
+            // Act
+            var templates = repository.Get("parent");
+            repository.Delete(templates);
+            unitOfWork.Commit();
+
+            // Assert
+            Assert.IsNull(repository.Get("test"));
+        }
+
+        [Test]
+        public void Can_Get_Template_Tree()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, _masterPageFileSystem, _viewsFileSystem);
+
+            var parent = new Template("test-parent-masterpage.master", "parent", "parent") { Content = @"<%@ Master Language=""C#"" %>" };
+
+            var child1 = new Template("test-child1-masterpage.master", "child1", "child1") { Content = @"<%@ Master Language=""C#"" %>" };
+            var toddler1 = new Template("test-toddler1-masterpage.master", "toddler1", "toddler1") { Content = @"<%@ Master Language=""C#"" %>" };
+            var toddler2 = new Template("test-toddler2-masterpage.master", "toddler2", "toddler2") { Content = @"<%@ Master Language=""C#"" %>" };
+            var baby1 = new Template("test-baby1-masterpage.master", "baby1", "baby1") { Content = @"<%@ Master Language=""C#"" %>" };
+
+            var child2 = new Template("test-child2-masterpage.master", "child2", "child2") { Content = @"<%@ Master Language=""C#"" %>" };
+            var toddler3 = new Template("test-toddler3-masterpage.master", "toddler3", "toddler3") { Content = @"<%@ Master Language=""C#"" %>" };
+            var toddler4 = new Template("test-toddler4-masterpage.master", "toddler4", "toddler4") { Content = @"<%@ Master Language=""C#"" %>" };
+            var baby2 = new Template("test-baby2-masterpage.master", "baby2", "baby2") { Content = @"<%@ Master Language=""C#"" %>" };
+
+
+            child1.MasterTemplateAlias = parent.Alias;
+            child1.MasterTemplateId = new Lazy<int>(() => parent.Id);
+            child2.MasterTemplateAlias = parent.Alias;
+            child2.MasterTemplateId = new Lazy<int>(() => parent.Id);
+
+            toddler1.MasterTemplateAlias = child1.Alias;
+            toddler1.MasterTemplateId = new Lazy<int>(() => child1.Id);
+            toddler2.MasterTemplateAlias = child1.Alias;
+            toddler2.MasterTemplateId = new Lazy<int>(() => child1.Id);
+
+            toddler3.MasterTemplateAlias = child2.Alias;
+            toddler3.MasterTemplateId = new Lazy<int>(() => child2.Id);
+            toddler4.MasterTemplateAlias = child2.Alias;
+            toddler4.MasterTemplateId = new Lazy<int>(() => child2.Id);
+
+            baby1.MasterTemplateAlias = toddler2.Alias;
+            baby1.MasterTemplateId = new Lazy<int>(() => toddler2.Id);
+
+            baby2.MasterTemplateAlias = toddler4.Alias;
+            baby2.MasterTemplateId = new Lazy<int>(() => toddler4.Id);
+
+            repository.AddOrUpdate(parent);
+            repository.AddOrUpdate(child1);
+            repository.AddOrUpdate(child2);
+            repository.AddOrUpdate(toddler1);
+            repository.AddOrUpdate(toddler2);
+            repository.AddOrUpdate(toddler3);
+            repository.AddOrUpdate(toddler4);
+            repository.AddOrUpdate(baby1);
+            repository.AddOrUpdate(baby2);
+            unitOfWork.Commit();
+
+            // Act
+            var rootNode = repository.GetTemplateNode("parent");
+
+            // Assert
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "parent"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "child1"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "child2"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler1"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler2"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler3"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "toddler4"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "baby1"));
+            Assert.IsNotNull(repository.FindTemplateInTree(rootNode, "baby2"));
+        }
+
+        //[Test]
+        //public void Can_Perform_Get_On_ScriptRepository()
+        //{
+        //    // Arrange
+        //    var provider = new FileUnitOfWorkProvider();
+        //    var unitOfWork = provider.GetUnitOfWork();
+        //    var repository = new ScriptRepository(unitOfWork, _masterPageFileSystem);
+
+        //    // Act
+        //    var exists = repository.Get("test-script.js");
+
+        //    // Assert
+        //    Assert.That(exists, Is.Not.Null);
+        //    Assert.That(exists.Alias, Is.EqualTo("test-script"));
+        //    Assert.That(exists.Name, Is.EqualTo("test-script.js"));
+        //}
+
+        //[Test]
+        //public void Can_Perform_GetAll_On_ScriptRepository()
+        //{
+        //    // Arrange
+        //    var provider = new FileUnitOfWorkProvider();
+        //    var unitOfWork = provider.GetUnitOfWork();
+        //    var repository = new ScriptRepository(unitOfWork, _masterPageFileSystem);
+
+        //    var script = new Script("test-script1.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
+        //    repository.AddOrUpdate(script);
+        //    var script2 = new Script("test-script2.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
+        //    repository.AddOrUpdate(script2);
+        //    var script3 = new Script("test-script3.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
+        //    repository.AddOrUpdate(script3);
+        //    unitOfWork.Commit();
+
+        //    // Act
+        //    var scripts = repository.GetAll();
+
+        //    // Assert
+        //    Assert.That(scripts, Is.Not.Null);
+        //    Assert.That(scripts.Any(), Is.True);
+        //    Assert.That(scripts.Any(x => x == null), Is.False);
+        //    Assert.That(scripts.Count(), Is.EqualTo(4));
+        //}
+
+        //[Test]
+        //public void Can_Perform_GetAll_With_Params_On_ScriptRepository()
+        //{
+        //    // Arrange
+        //    var provider = new FileUnitOfWorkProvider();
+        //    var unitOfWork = provider.GetUnitOfWork();
+        //    var repository = new ScriptRepository(unitOfWork, _masterPageFileSystem);
+
+        //    var script = new Script("test-script1.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
+        //    repository.AddOrUpdate(script);
+        //    var script2 = new Script("test-script2.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
+        //    repository.AddOrUpdate(script2);
+        //    var script3 = new Script("test-script3.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
+        //    repository.AddOrUpdate(script3);
+        //    unitOfWork.Commit();
+
+        //    // Act
+        //    var scripts = repository.GetAll("test-script1.js", "test-script2.js");
+
+        //    // Assert
+        //    Assert.That(scripts, Is.Not.Null);
+        //    Assert.That(scripts.Any(), Is.True);
+        //    Assert.That(scripts.Any(x => x == null), Is.False);
+        //    Assert.That(scripts.Count(), Is.EqualTo(2));
+        //}
+
+        //[Test]
+        //public void Can_Perform_Exists_On_ScriptRepository()
+        //{
+        //    // Arrange
+        //    var provider = new FileUnitOfWorkProvider();
+        //    var unitOfWork = provider.GetUnitOfWork();
+        //    var repository = new ScriptRepository(unitOfWork, _masterPageFileSystem);
+
+        //    // Act
+        //    var exists = repository.Exists("test-script.js");
+
+        //    // Assert
+        //    Assert.That(exists, Is.True);
+        //}
+
+        [TearDown]
+        public override void TearDown()
+        {
+            base.TearDown();
+
+            _masterPageFileSystem = null;
+            _viewsFileSystem = null;
+            //Delete all files
+            var fsMaster = new PhysicalFileSystem(SystemDirectories.Masterpages);
+            var masterPages = fsMaster.GetFiles("", "*.master");
+            foreach (var file in masterPages)
+            {
+                fsMaster.DeleteFile(file);
+            }
+            var fsViews = new PhysicalFileSystem(SystemDirectories.MvcViews);
+            var views = fsMaster.GetFiles("", "*.cshtml");
+            foreach (var file in views)
+            {
+                fsMaster.DeleteFile(file);
+            }
+        }
+
+        protected Stream CreateStream(string contents = null)
+        {
+            if (string.IsNullOrEmpty(contents))
+                contents = "/* test */";
+
+            var bytes = Encoding.UTF8.GetBytes(contents);
+            var stream = new MemoryStream(bytes);
+
+            return stream;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj
index dbe4915ef1..2a8b466173 100644
--- a/src/Umbraco.Tests/Umbraco.Tests.csproj
+++ b/src/Umbraco.Tests/Umbraco.Tests.csproj
@@ -205,6 +205,7 @@
     <Compile Include="Persistence\PetaPocoExtensionsTest.cs" />
     <Compile Include="Persistence\Repositories\MemberRepositoryTest.cs" />
     <Compile Include="Persistence\Repositories\MemberTypeRepositoryTest.cs" />
+    <Compile Include="Persistence\Repositories\TemplateRepositoryTest.cs" />
     <Compile Include="Persistence\Repositories\UserRepositoryTest.cs" />
     <Compile Include="Persistence\Repositories\UserTypeRepositoryTest.cs" />
     <Compile Include="PublishedContent\PublishedContentExtensionTests.cs" />