yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP more template repo work and more unit tests

Browse Source
This commit is contained in:
Shannon
2014-12-01 16:22:18 +11:00
parent bf82a70744
commit c656bb632e
10 changed files with 252 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

414
src/Umbraco.Core/IO/MasterPageHelper.cs Normal file
View File

@@ -0,0 +1,414 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Umbraco.Core.Models;
using Umbraco.Core.Services;
namespace Umbraco.Core.IO
{
internal class MasterPageHelper
{
internal static readonly string DefaultMasterTemplate = SystemDirectories.Umbraco + "/masterpages/default.master";
private static readonly char[] NewLineChars = Environment.NewLine.ToCharArray();
internal static bool MasterPageExists(ITemplate t)
{
return System.IO.File.Exists(GetFilePath(t));
}
internal static string GetFilePath(ITemplate t)
{
return IOHelper.MapPath(SystemDirectories.Masterpages + "/" + t.Alias.Replace(" ", "") + ".master");
}
internal static string CreateMasterPage(ITemplate t, IFileService fileService, bool overWrite = false)
{
string masterpageContent = "";
if (System.IO.File.Exists(GetFilePath(t)) == false || overWrite)
{
masterpageContent = CreateDefaultMasterPageContent(t, t.Alias, fileService);
SaveDesignToFile(t, null, masterpageContent);
}
else
{
using (var tr = new StreamReader(GetFilePath(t)))
{
masterpageContent = tr.ReadToEnd();
tr.Close();
}
}
return masterpageContent;
}
internal static string GetFileContents(ITemplate t)
{
string masterpageContent = "";
if (System.IO.File.Exists(GetFilePath(t)))
{
using (var tr = new StreamReader(GetFilePath(t)))
{
masterpageContent = tr.ReadToEnd();
tr.Close();
}
}
return masterpageContent;
}
internal static string UpdateMasterPageFile(ITemplate t, string currentAlias, IFileService fileService)
{
var template = UpdateMasterPageContent(t, currentAlias);
UpdateChildTemplates(t, currentAlias, fileService);
SaveDesignToFile(t, currentAlias, template);
return template;
}
internal static string CreateDefaultMasterPageContent(ITemplate template, string currentAlias, IFileService fileService)
{
var design = new StringBuilder();
design.Append(GetMasterPageHeader(template) + Environment.NewLine);
if (template.MasterTemplateAlias.IsNullOrWhiteSpace() == false)
{
var master = fileService.GetTemplate(template.MasterTemplateAlias);
if (master != null)
{
foreach (var cpId in GetContentPlaceholderIds(master))
{
design.Append("<asp:content ContentPlaceHolderId=\"" + cpId + "\" runat=\"server\">" +
Environment.NewLine +
Environment.NewLine +
"</asp:content>" +
Environment.NewLine +
Environment.NewLine);
}
return design.ToString();
}
}
design.Append(GetMasterContentElement(template) + Environment.NewLine);
design.Append(template.Content + Environment.NewLine);
design.Append("</asp:Content>" + Environment.NewLine);
return design.ToString();
}
internal static IEnumerable<string> GetContentPlaceholderIds(ITemplate template)
{
var retVal = new List<string>();
var mp = template.Content;
var path = "<asp:ContentPlaceHolder+(\\s+[a-zA-Z]+\\s*=\\s*(\"([^\"]*)\"|'([^']*)'))*\\s*/?>";
var r = new Regex(path, RegexOptions.IgnoreCase);
var m = r.Match(mp);
while (m.Success)
{
var cc = m.Groups[3].Captures;
retVal.AddRange(cc.Cast<Capture>().Where(c => c.Value != "server").Select(c => c.Value));
m = m.NextMatch();
}
return retVal;
}
internal static string UpdateMasterPageContent(ITemplate template, string currentAlias)
{
var masterPageContent = template.Content;
if (string.IsNullOrEmpty(currentAlias) == false && currentAlias != template.Alias)
{
var masterHeader =
masterPageContent.Substring(0, masterPageContent.IndexOf("%>", StringComparison.Ordinal) + 2).Trim(
Environment.NewLine.ToCharArray());
// find the masterpagefile attribute
var m = Regex.Matches(masterHeader, "(?<attributeName>\\S*)=\"(?<attributeValue>[^\"]*)\"",
RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
foreach (Match attributeSet in m)
{
if (attributeSet.Groups["attributeName"].Value.ToLower() == "masterpagefile")
{
// validate the masterpagefile
var currentMasterPageFile = attributeSet.Groups["attributeValue"].Value;
var currentMasterTemplateFile = ParentTemplatePath(template);
if (currentMasterPageFile != currentMasterTemplateFile)
{
masterPageContent =
masterPageContent.Replace(
attributeSet.Groups["attributeName"].Value + "=\"" + currentMasterPageFile + "\"",
attributeSet.Groups["attributeName"].Value + "=\"" + currentMasterTemplateFile +
"\"");
}
}
}
}
return masterPageContent;
}
private static void UpdateChildTemplates(ITemplate template, string currentAlias, IFileService fileService)
{
//if we have a Old Alias if the alias and therefor the masterpage file name has changed...
//so before we save the new masterfile, we'll clear the old one, so we don't up with
//Unused masterpage files
if (string.IsNullOrEmpty(currentAlias) == false && currentAlias != template.Alias)
{
//Ensure that child templates have the right master masterpage file name
if (template.IsMasterTemplate)
{
var children = fileService.GetTemplates(template.Id);
foreach (var t in children)
UpdateMasterPageFile(t, null, fileService);
}
}
}
private static void SaveDesignToFile(ITemplate t, string currentAlias, string design)
{
//kill the old file..
if (string.IsNullOrEmpty(currentAlias) == false && currentAlias != t.Alias)
{
var oldFile =
IOHelper.MapPath(SystemDirectories.Masterpages + "/" + currentAlias.Replace(" ", "") + ".master");
if (System.IO.File.Exists(oldFile))
System.IO.File.Delete(oldFile);
}
// save the file in UTF-8
System.IO.File.WriteAllText(GetFilePath(t), design, Encoding.UTF8);
}
internal static void RemoveMasterPageFile(string alias)
{
if (string.IsNullOrWhiteSpace(alias) == false)
{
string file = IOHelper.MapPath(SystemDirectories.Masterpages + "/" + alias.Replace(" ", "") + ".master");
if (System.IO.File.Exists(file))
System.IO.File.Delete(file);
}
}
internal static string SaveTemplateToFile(ITemplate template, string currentAlias, IFileService fileService)
{
var masterPageContent = template.Content;
if (IsMasterPageSyntax(masterPageContent) == false)
masterPageContent = ConvertToMasterPageSyntax(template);
// Add header to master page if it doesn't exist
if (masterPageContent.TrimStart().StartsWith("<%@") == false)
{
masterPageContent = GetMasterPageHeader(template) + Environment.NewLine + masterPageContent;
}
else
{
// verify that the masterpage attribute is the same as the masterpage
var masterHeader =
masterPageContent.Substring(0, masterPageContent.IndexOf("%>", StringComparison.Ordinal) + 2).Trim(NewLineChars);
// find the masterpagefile attribute
var m = Regex.Matches(masterHeader, "(?<attributeName>\\S*)=\"(?<attributeValue>[^\"]*)\"",
RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
foreach (Match attributeSet in m)
{
if (attributeSet.Groups["attributeName"].Value.ToLower() == "masterpagefile")
{
// validate the masterpagefile
var currentMasterPageFile = attributeSet.Groups["attributeValue"].Value;
var currentMasterTemplateFile = ParentTemplatePath(template);
if (currentMasterPageFile != currentMasterTemplateFile)
{
masterPageContent =
masterPageContent.Replace(
attributeSet.Groups["attributeName"].Value + "=\"" + currentMasterPageFile + "\"",
attributeSet.Groups["attributeName"].Value + "=\"" + currentMasterTemplateFile +
"\"");
}
}
}
}
//we have a Old Alias if the alias and therefor the masterpage file name has changed...
//so before we save the new masterfile, we'll clear the old one, so we don't up with
//Unused masterpage files
if (string.IsNullOrEmpty(currentAlias) == false && currentAlias != template.Alias)
{
//Ensure that child templates have the right master masterpage file name
if (template.IsMasterTemplate)
{
var children = fileService.GetTemplates(template.Id);
foreach (var t in children)
UpdateMasterPageFile(t, null, fileService);
}
//then kill the old file..
var oldFile = IOHelper.MapPath(SystemDirectories.Masterpages + "/" + currentAlias.Replace(" ", "") + ".master");
if (System.IO.File.Exists(oldFile))
System.IO.File.Delete(oldFile);
}
// save the file in UTF-8
System.IO.File.WriteAllText(GetFilePath(template), masterPageContent, Encoding.UTF8);
return masterPageContent;
}
internal static string ConvertToMasterPageSyntax(ITemplate template)
{
string masterPageContent = GetMasterContentElement(template) + Environment.NewLine;
masterPageContent += template.Content;
// Parse the design for getitems
masterPageContent = EnsureMasterPageSyntax(template.Alias, masterPageContent);
// append ending asp:content element
masterPageContent += Environment.NewLine + "</asp:Content>" + Environment.NewLine;
return masterPageContent;
}
internal static bool IsMasterPageSyntax(string code)
{
return Regex.IsMatch(code, @"<%@\s*Master", RegexOptions.IgnoreCase) ||
code.InvariantContains("<umbraco:Item") || code.InvariantContains("<asp:") || code.InvariantContains("<umbraco:Macro");
}
private static string GetMasterPageHeader(ITemplate template)
{
return String.Format("<%@ Master Language=\"C#\" MasterPageFile=\"{0}\" AutoEventWireup=\"true\" %>", ParentTemplatePath(template)) + Environment.NewLine;
}
private static string ParentTemplatePath(ITemplate template)
{
var masterTemplate = DefaultMasterTemplate;
if (template.MasterTemplateAlias.IsNullOrWhiteSpace() == false)
masterTemplate = SystemDirectories.Masterpages + "/" + template.MasterTemplateAlias + ".master";
return masterTemplate;
}
private static string GetMasterContentElement(ITemplate template)
{
if (template.MasterTemplateAlias.IsNullOrWhiteSpace() == false)
{
string masterAlias = template.MasterTemplateAlias;
return
String.Format("<asp:Content ContentPlaceHolderID=\"{0}ContentPlaceHolder\" runat=\"server\">", masterAlias);
}
else
return
String.Format("<asp:Content ContentPlaceHolderID=\"ContentPlaceHolderDefault\" runat=\"server\">");
}
internal static string EnsureMasterPageSyntax(string templateAlias, string masterPageContent)
{
ReplaceElement(ref masterPageContent, "?UMBRACO_GETITEM", "umbraco:Item", true);
ReplaceElement(ref masterPageContent, "?UMBRACO_GETITEM", "umbraco:Item", false);
// Parse the design for macros
ReplaceElement(ref masterPageContent, "?UMBRACO_MACRO", "umbraco:Macro", true);
ReplaceElement(ref masterPageContent, "?UMBRACO_MACRO", "umbraco:Macro", false);
// Parse the design for load childs
masterPageContent = masterPageContent.Replace("<?UMBRACO_TEMPLATE_LOAD_CHILD/>", CreateDefaultPlaceHolder(templateAlias))
.Replace("<?UMBRACO_TEMPLATE_LOAD_CHILD />", CreateDefaultPlaceHolder(templateAlias));
// Parse the design for aspnet forms
GetAspNetMasterPageForm(ref masterPageContent, templateAlias);
masterPageContent = masterPageContent.Replace("</?ASPNET_FORM>", "</form>");
// Parse the design for aspnet heads
masterPageContent = masterPageContent.Replace("</ASPNET_HEAD>", String.Format("<head id=\"{0}Head\" runat=\"server\">", templateAlias.Replace(" ", "")));
masterPageContent = masterPageContent.Replace("</?ASPNET_HEAD>", "</head>");
return masterPageContent;
}
private static void GetAspNetMasterPageForm(ref string design, string templateAlias)
{
var formElement = Regex.Match(design, GetElementRegExp("?ASPNET_FORM", false), RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
if (string.IsNullOrEmpty(formElement.Value) == false)
{
string formReplace = String.Format("<form id=\"{0}Form\" runat=\"server\">", templateAlias.Replace(" ", ""));
if (formElement.Groups.Count == 0)
{
formReplace += "<asp:scriptmanager runat=\"server\"></asp:scriptmanager>";
}
design = design.Replace(formElement.Value, formReplace);
}
}
private static string CreateDefaultPlaceHolder(string templateAlias)
{
return String.Format("<asp:ContentPlaceHolder ID=\"{0}ContentPlaceHolder\" runat=\"server\"></asp:ContentPlaceHolder>", templateAlias.Replace(" ", ""));
}
private static void ReplaceElement(ref string design, string elementName, string newElementName, bool checkForQuotes)
{
var m =
Regex.Matches(design, GetElementRegExp(elementName, checkForQuotes),
RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
foreach (Match match in m)
{
GroupCollection groups = match.Groups;
// generate new element (compensate for a closing trail on single elements ("/"))
string elementAttributes = groups[1].Value;
// test for macro alias
if (elementName == "?UMBRACO_MACRO")
{
var tags = XmlHelper.GetAttributesFromElement(match.Value);
if (tags["macroAlias"] != null)
elementAttributes = String.Format(" Alias=\"{0}\"", tags["macroAlias"]) + elementAttributes;
else if (tags["macroalias"] != null)
elementAttributes = String.Format(" Alias=\"{0}\"", tags["macroalias"]) + elementAttributes;
}
string newElement = "<" + newElementName + " runat=\"server\" " + elementAttributes.Trim() + ">";
if (elementAttributes.EndsWith("/"))
{
elementAttributes = elementAttributes.Substring(0, elementAttributes.Length - 1);
}
else if (groups[0].Value.StartsWith("</"))
// It's a closing element, so generate that instead of a starting element
newElement = "</" + newElementName + ">";
if (checkForQuotes)
{
// if it's inside quotes, we'll change element attribute quotes to single quotes
newElement = newElement.Replace("\"", "'");
newElement = String.Format("\"{0}\"", newElement);
}
design = design.Replace(match.Value, newElement);
}
}
private static string GetElementRegExp(string elementName, bool checkForQuotes)
{
if (checkForQuotes)
return String.Format("\"<[^>\\s]*\\b{0}(\\b[^>]*)>\"", elementName);
else
return String.Format("<[^>\\s]*\\b{0}(\\b[^>]*)>", elementName);
}
}
}

155
src/Umbraco.Core/IO/ViewHelper.cs Normal file
View File

@@ -0,0 +1,155 @@
using System;
using System.IO;
using System.Text;
using Umbraco.Core.Models;
namespace Umbraco.Core.IO
{
internal class ViewHelper
{
private readonly IFileSystem _viewFileSystem;
public ViewHelper(IFileSystem viewFileSystem)
{
if (viewFileSystem == null) throw new ArgumentNullException("viewFileSystem");
_viewFileSystem = viewFileSystem;
}
internal bool ViewExists(ITemplate t)
{
return _viewFileSystem.FileExists(ViewPath(t.Alias));
}
[Obsolete("This is only used for legacy purposes and will be removed in future versions")]
internal string GetPhysicalFilePath(ITemplate t)
{
return _viewFileSystem.GetFullPath(ViewPath(t.Alias));
}
internal string GetFileContents(ITemplate t)
{
string viewContent = "";
string path = ViewPath(t.Alias);
if (_viewFileSystem.FileExists(path))
{
using (var tr = new StreamReader(_viewFileSystem.OpenFile(path)))
{
viewContent = tr.ReadToEnd();
tr.Close();
}
}
return viewContent;
}
internal string CreateViewFile(ITemplate t, bool overWrite = false)
{
string viewContent;
string path = ViewPath(t.Alias);
if (_viewFileSystem.FileExists(path) == false || overWrite)
{
viewContent = SaveTemplateToFile(t, t.Alias);
}
else
{
using (var tr = new StreamReader(_viewFileSystem.OpenFile(path)))
{
viewContent = tr.ReadToEnd();
tr.Close();
}
}
return viewContent;
}
internal static string GetDefaultFileContent(string layoutPageAlias = null)
{
var design = @"@inherits Umbraco.Web.Mvc.UmbracoTemplatePage
@{
Layout = null;
}";
if (layoutPageAlias.IsNullOrWhiteSpace() == false)
design = design.Replace("null", string.Format("\"{0}.cshtml\"", layoutPageAlias));
return design;
}
internal string SaveTemplateToFile(ITemplate template, string currentAlias)
{
var design = EnsureInheritedLayout(template);
var path = ViewPath(template.Alias);
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms, Encoding.UTF8))
{
writer.Write(design);
_viewFileSystem.AddFile(path, ms, true);
}
return template.Content;
}
internal string UpdateViewFile(ITemplate t, string currentAlias = null)
{
var path = ViewPath(t.Alias);
if (string.IsNullOrEmpty(currentAlias) == false && currentAlias != t.Alias)
{
//NOTE: I don't think this is needed for MVC, this was ported over from the
// masterpages helper but I think only relates to when templates are stored in the db.
////Ensure that child templates have the right master masterpage file name
//if (t.HasChildren)
//{
// var c = t.Children;
// foreach (CMSNode cmn in c)
// UpdateViewFile(new Template(cmn.Id), null);
//}
//then kill the old file..
var oldFile = ViewPath(currentAlias);
if (_viewFileSystem.FileExists(oldFile))
_viewFileSystem.DeleteFile(oldFile);
}
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms, Encoding.UTF8))
{
writer.Write(t.Content);
_viewFileSystem.AddFile(path, ms, true);
}
return t.Content;
}
internal void RemoveViewFile(string alias)
{
if (string.IsNullOrWhiteSpace(alias) == false)
{
var file = ViewPath(alias);
if (_viewFileSystem.FileExists(file))
_viewFileSystem.DeleteFile(file);
}
}
public string ViewPath(string alias)
{
return _viewFileSystem.GetRelativePath(alias.Replace(" ", "") + ".cshtml");
//return SystemDirectories.MvcViews + "/" + alias.Replace(" ", "") + ".cshtml";
}
private string EnsureInheritedLayout(ITemplate template)
{
string design = template.Content;
if (string.IsNullOrEmpty(design))
{
design = GetDefaultFileContent(template.MasterTemplateAlias);
}
return design;
}
}
}