Code tidy up for you

.gitignore

@@ -7,4 +7,4 @@ _ReSharper*
 *.resharper.user
 *.suo
 *.cache
-http%3a%2f%2fmirrors.dotsrc.org%2fcygwin%2f
+packages

.nuget/NuGet.Config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <solution>
+    <add key="disableSourceControlIntegration" value="true" />
+  </solution>
+</configuration>

.nuget/NuGet.targets

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <PropertyGroup>
+        <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">$(MSBuildProjectDirectory)\..\</SolutionDir>
+        <NuGetToolsPath>$([System.IO.Path]::Combine($(SolutionDir), ".nuget"))</NuGetToolsPath>
+        <NuGetExePath>$(NuGetToolsPath)\nuget.exe</NuGetExePath>
+        <PackagesConfig>$([System.IO.Path]::Combine($(ProjectDir), "packages.config"))</PackagesConfig>
+        <PackagesDir>$([System.IO.Path]::Combine($(SolutionDir), "packages"))</PackagesDir>
+        <PackageOutputDir Condition="$(PackageOutputDir) == ''">$(TargetDir.Trim('\\'))</PackageOutputDir>
+
+        <!-- Package sources used to restore packages. By default will used the registered sources under %APPDATA%\NuGet\NuGet.Config -->
+        <PackageSources>""</PackageSources>
+
+        <!-- Enable the restore command to run before builds -->
+        <RestorePackages Condition="$(RestorePackages) == ''">false</RestorePackages>
+
+        <!-- Property that enables building a package from a project -->
+        <BuildPackage Condition="$(BuildPackage) == ''">false</BuildPackage>
+
+        <!-- Commands -->
+        <RestoreCommand>"$(NuGetExePath)" install "$(PackagesConfig)" -source $(PackageSources) -o "$(PackagesDir)"</RestoreCommand>
+        <BuildCommand>"$(NuGetExePath)" pack "$(ProjectPath)" -p Configuration=$(Configuration) -o "$(PackageOutputDir)" -symbols</BuildCommand>
+
+        <!-- Make the build depend on restore packages -->
+        <BuildDependsOn Condition="$(RestorePackages) == 'true'">
+            RestorePackages;
+            $(BuildDependsOn);
+        </BuildDependsOn>
+
+        <!-- Make the build depend on restore packages -->
+        <BuildDependsOn Condition="$(BuildPackage) == 'true'">
+            $(BuildDependsOn);
+            BuildPackage;
+        </BuildDependsOn>
+    </PropertyGroup>
+
+    <Target Name="CheckPrerequisites">
+        <!-- Raise an error if we're unable to locate nuget.exe  -->
+        <Error Condition="!Exists('$(NuGetExePath)')" Text="Unable to locate '$(NuGetExePath)'" />
+    </Target>
+
+    <Target Name="RestorePackages" DependsOnTargets="CheckPrerequisites">
+        <Exec Command="$(RestoreCommand)"
+              LogStandardErrorAsError="true"
+              Condition="Exists('$(PackagesConfig)')" />
+    </Target>
+
+    <Target Name="BuildPackage" DependsOnTargets="CheckPrerequisites">
+        <Exec Command="$(BuildCommand)"
+              LogStandardErrorAsError="true" />
+    </Target>
+</Project>

Extensions/PageReferenceChildExtensions.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Linq;
+using EPiServer;
+using EPiServer.Core;
+using EPiServer.DataAccess;
+using EPiServer.Security;
+using PageTypeBuilder;
+
+namespace PageStructureBuilder.Extensions
+{
+    /// <summary>
+    /// Contains extension methods for PageReference to simplify finding / creating child pages.<br/>
+    /// Allows code to be agnostic as to whether the page already exists.<br/>
+    /// See also <a href="http://joelabrahamsson.com/entry/automatically-organize-episerver-pages">http://joelabrahamsson.com/entry/automatically-organize-episerver-pages</a>
+    /// </summary>
+    public static class PageReferenceChildExtensions
+    {
+        /// <summary>
+        /// Gets the existing child page or create it and return it if it is new.
+        /// </summary>
+        /// <typeparam name="TChildType">The type of page to find / create.</typeparam>
+        /// <param name="parent">The parent link.</param>
+        /// <param name="pageName">Name of the page to find / create.</param>
+        /// <param name="action">Whether to publish the page immediately if it is new.</param>
+        /// <returns>The new / existing page at the specified location.</returns>
+        public static TChildType GetOrCreateChildPage<TChildType>(this PageReference parent, string pageName, SaveAction action = SaveAction.Publish)
+            where TChildType : PageData
+        {
+            return parent.GetExistingChild<TChildType>(pageName) ?? parent.CreateChild<TChildType>(pageName, action);
+        }
+
+        /// <summary>
+        /// Find an existing child page by type and name.
+        /// </summary>
+        /// <typeparam name="TChildType">The type of the result.</typeparam>
+        /// <param name="parent">The parent.</param>
+        /// <param name="pageName">Name of the page to find.</param>
+        /// <returns></returns>
+        public static TChildType GetExistingChild<TChildType>(this PageReference parent, string pageName)
+            where TChildType : PageData
+        {
+            var children = DataFactory.Instance.GetChildren(parent);
+            return children
+                .OfType<TChildType>()
+                .FirstOrDefault(c => c.PageName.Equals(
+                    pageName, StringComparison.InvariantCulture));
+        }
+
+        /// <summary>
+        /// Creates a child page of the specified type.
+        /// </summary>
+        /// <typeparam name="TChildType">The type of the result.</typeparam>
+        /// <param name="parent">The parent.</param>
+        /// <param name="pageName">Name of the new page.</param>
+        /// <param name="action">Whether to publish the page immediately.</param>
+        /// <returns></returns>
+        public static TChildType CreateChild<TChildType>(this PageReference parent, string pageName, SaveAction action = SaveAction.Publish)
+            where TChildType : PageData
+        {
+            var resultPageTypeId = PageTypeResolver.Instance.GetPageTypeID(typeof(TChildType));
+            if (resultPageTypeId == null)
+            {
+                throw new Exception(String.Format("PageTypeID not found for {0}", typeof(TChildType)));
+            }
+            var child = DataFactory.Instance.GetDefaultPageData(parent, resultPageTypeId.Value) as TChildType;
+            if (child == null)
+            {
+                throw new Exception(string.Format(
+                    "Failed to GetDefaultPageData for parent {0} and PageTypeID {1}", parent, resultPageTypeId));
+            }
+            child.PageName = pageName;
+            DataFactory.Instance.Save(child, action, AccessLevel.NoAccess);
+            return child;
+        }
+    }
+}

IOrganizeChildren.cs

@@ -0,0 +1,21 @@
+using EPiServer.Core;
+
+namespace PageStructureBuilder
+{
+    /// <summary>
+    /// Implement this interface to create a folder (really just a page)
+    /// that will automatically organise child pages of the same type into a
+    /// desired hierarchy.
+    /// </summary>
+    public interface IOrganizeChildren
+    {
+        /// <summary>
+        /// Gets the corrected parent page for new / moved page.<br/>
+        /// This will possibly be a new folder in the hierarchy.<br/>
+        /// The location is defined by the implementing class.
+        /// </summary>
+        /// <param name="page">The page to get a corrected parent page.</param>
+        /// <returns></returns>
+        PageReference GetParentForPage(PageData page);
+    }
+}

OrganizationTypes/AlphabeticalStructureBase.cs

@@ -0,0 +1,19 @@
+using EPiServer.Core;
+
+namespace PageStructureBuilder.OrganizationTypes
+{
+    /// <summary>
+    /// Inherit a page type from this to automatically organise pages into folders
+    /// named with the first letter of the page name.
+    /// </summary>
+    /// <typeparam name="TCharacter">The type page that will provide single character folders.</typeparam>
+    public abstract class AlphabeticalStructureBase<TCharacter> 
+        : SingleLevelStructureBase<TCharacter>
+        where TCharacter : PageData, new()
+    {
+        protected override string GetContainerPageName(PageData childPage)
+        {
+            return childPage.PageName[0].ToString().ToUpperInvariant();
+        }
+    }
+}

OrganizationTypes/DateStructureBase.cs

@@ -0,0 +1,58 @@
+using System;
+using EPiServer.Core;
+using PageStructureBuilder.Extensions;
+using PageTypeBuilder;
+
+namespace PageStructureBuilder.OrganizationTypes
+{
+    /// <summary>
+    /// Inherit from this page type to make your pages automatically
+    /// move themselves to the date based folder structure of yyyy/mm/dd/pagename<br/>
+    /// The default date source is creation date. To change this override <see cref="GetStructureDate"/>.
+    /// </summary>
+    /// <typeparam name="TYear">Desired PageData type for year level container pages.</typeparam>
+    /// <typeparam name="TMonth">Desired PageData type for month level container pages.</typeparam>
+    /// <typeparam name="TDay">Desired PageData type for day level container pages.</typeparam>
+    /// <example>Usage: <code>
+    /// [PageType]
+    /// public class Container : TypedPageData { }
+    /// [PageType]
+    /// public class DateStructure : DateStructureBase&lt;Container, Container, Container&gt; { }
+    /// </code></example>
+    /// <remarks>
+    /// See also <a href="http://joelabrahamsson.com/entry/automatically-organize-episerver-pages-part-2/">http://joelabrahamsson.com/entry/automatically-organize-episerver-pages-part-2/</a>
+    /// </remarks>
+    public abstract class DateStructureBase<TYear, TMonth, TDay> 
+        : TypedPageData, IOrganizeChildren
+        where TYear : PageData 
+        where TMonth : PageData 
+        where TDay : PageData
+    {
+        public PageReference GetParentForPage(PageData page)
+        {
+            if (page is TYear)
+            {
+                return PageLink;
+            }
+
+            var pageDate = GetStructureDate(page);
+            var yearPage = PageLink.GetOrCreateChildPage<TYear>(pageDate.Year.ToString());
+            var monthPage = yearPage.PageLink.GetOrCreateChildPage<TMonth>(pageDate.Month.ToString());
+            var dayPage = monthPage.PageLink.GetOrCreateChildPage<TDay>(pageDate.Day.ToString());
+            return dayPage.PageLink;
+        }
+
+        /// <summary>
+        /// Returns the date that will be used when creating the page's folder
+        /// hierarchy. Default implementation uses the Created property of the page.<br/>
+        /// Override this method to use a different date for the hierarchy.
+        /// </summary>
+        /// <param name="pageToGetParentFor">The page to get parent for.</param>
+        /// <returns></returns>
+        protected virtual DateTime GetStructureDate(
+            PageData pageToGetParentFor)
+        {
+            return pageToGetParentFor.Created;
+        }
+    }
+}

OrganizationTypes/PageTypeStructureBase.cs

@@ -0,0 +1,20 @@
+using EPiServer.Core;
+using EPiServer.DataAbstraction;
+
+namespace PageStructureBuilder.OrganizationTypes
+{
+    /// <summary>
+    /// Inherit a page type from this to automatically organise pages into folders
+    /// named with the first letter of the page name.
+    /// </summary>
+    /// <typeparam name="TContainer">The type page that will provide page type based folders.</typeparam>
+    public abstract class PageTypeStructureBase<TContainer> : SingleLevelStructureBase<TContainer>
+        where TContainer : PageData
+    {
+        protected override string GetContainerPageName(PageData childPage)
+        {
+            var pageType = PageType.Load(childPage.PageTypeID);
+            return pageType.Name;
+        }
+    }
+}

OrganizationTypes/SingleLevelStructureBase.cs

@@ -0,0 +1,39 @@
+using EPiServer.Core;
+using PageStructureBuilder.Extensions;
+using PageTypeBuilder;
+
+namespace PageStructureBuilder.OrganizationTypes
+{
+    /// <summary>
+    /// Base class for all single folder based automatic page organisation.
+    /// </summary>
+    /// <typeparam name="TContainer">The type of the container (folder) pages.</typeparam>
+    public abstract class SingleLevelStructureBase<TContainer> 
+        : TypedPageData, IOrganizeChildren
+        where TContainer : PageData
+    {
+        public virtual PageReference GetParentForPage(PageData page)
+        {
+            if (page is TContainer)
+            {
+                return PageLink;
+            }
+
+            if (string.IsNullOrEmpty(page.PageName))
+            {
+                return PageLink;
+            }
+
+            var container = PageLink.GetOrCreateChildPage<TContainer>(GetContainerPageName(page));
+            return container.PageLink;
+        }
+
+        /// <summary>
+        /// Derived classes should override this method to control
+        /// the naming convention of the generated containing pages (i.e. folders).
+        /// </summary>
+        /// <param name="childPage">The child page for which to find the folder name.</param>
+        /// <returns>The name of the folder this page should be placed in.</returns>
+        protected abstract string GetContainerPageName(PageData childPage);
+    }
+}