Files

598 lines
22 KiB
C#

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Web;
using HtmlAgilityPack;
using Swarmops.Basic.Types;
using Swarmops.Basic.Types.Communications;
using Swarmops.Database;
using Swarmops.Logic.Cache;
using Swarmops.Logic.Structure;
namespace Swarmops.Logic.Communications
{
public class MailTemplate : BasicMailTemplate
{
private readonly string originallyLoadedContent = "";
private HtmlDocument htmlDoc;
internal MailTemplate()
: base (0, "", "", "", 0, "")
{
}
public MailTemplate (BasicMailTemplate basic)
: base (basic)
{
this.originallyLoadedContent = basic.TemplateBody;
}
public new string TemplateBody
{
get
{
if (this.htmlDoc != null)
{
return this.htmlDoc.DocumentNode.OuterHtml;
}
return base.TemplateBody;
}
set
{
try
{
if (this.htmlDoc != null)
{
this.htmlDoc = new HtmlDocument();
this.htmlDoc.LoadHtml (value);
}
}
catch
{
throw;
}
base.TemplateBody = value;
}
}
public HtmlNode HtmlBody
{
get
{
if (HtmlDoc.DocumentNode == null
|| HtmlDoc.DocumentNode.SelectSingleNode ("//body") == null)
{
NormalizeHtml();
}
return HtmlDoc.DocumentNode.SelectSingleNode ("//body");
}
}
public string Html
{
get { return HtmlDoc.DocumentNode.OuterHtml; }
}
public string PlainText
{
get
{
string htmlText = HtmlDoc.DocumentNode.OuterHtml;
Regex re = new Regex (@"\r{0,1}\n +");
//Templates for plain text are supposedly already in a reasonable <PRE> format
if (TemplateName.EndsWith ("Plain"))
htmlText = re.Replace (htmlText, "\r\n");
else
htmlText = re.Replace (htmlText, " ");
HtmlDocument htmlDoc = new HtmlDocument();
htmlDoc.LoadHtml (htmlText);
if (htmlDoc.DocumentNode == null)
{
throw new Exception ("MailTemplate.PlainText detected htmlDoc.DocumentNode== null:\nHTML:" +
htmlText);
}
HtmlNodeCollection tagsArray = htmlDoc.DocumentNode.SelectNodes ("//a");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
if (n.InnerText.Trim().ToLower() != n.GetAttributeValue ("href", "").Trim().ToLower())
n.AppendChild (htmlDoc.CreateTextNode (" (" + n.GetAttributeValue ("href", "") + ")"));
}
}
tagsArray = htmlDoc.DocumentNode.SelectNodes ("//h1");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
n.InsertAfter (htmlDoc.CreateTextNode ("\r\n\r\n"), null);
}
}
tagsArray = htmlDoc.DocumentNode.SelectNodes ("//h2");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
n.InsertAfter (htmlDoc.CreateTextNode ("\r\n\r\n"), null);
n.AppendChild (htmlDoc.CreateTextNode ("\r\n\r\n"));
}
}
tagsArray = htmlDoc.DocumentNode.SelectNodes ("//h3");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
n.InsertAfter (htmlDoc.CreateTextNode ("\r\n\r\n"), null);
n.AppendChild (htmlDoc.CreateTextNode ("\r\n\r\n"));
}
}
tagsArray = htmlDoc.DocumentNode.SelectNodes ("//li");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
n.InsertAfter (htmlDoc.CreateTextNode ("\r\n\r\n- "), null);
n.AppendChild (htmlDoc.CreateTextNode ("\r\n"));
}
}
tagsArray = htmlDoc.DocumentNode.SelectNodes ("//tr");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
n.InsertAfter (htmlDoc.CreateTextNode ("\r\n"), null);
}
}
tagsArray = htmlDoc.DocumentNode.SelectNodes ("//p");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
n.InsertAfter (htmlDoc.CreateTextNode ("\r\n\r\n"), null);
n.AppendChild (htmlDoc.CreateTextNode ("\r\n"));
}
}
tagsArray = htmlDoc.DocumentNode.SelectNodes ("//br");
if (tagsArray != null)
{
foreach (HtmlNode n in tagsArray)
{
n.AppendChild (htmlDoc.CreateTextNode ("\r\n"));
}
}
HtmlNode bodyNode = htmlDoc.DocumentNode.SelectSingleNode ("//body");
string retval = "";
if (bodyNode != null)
retval = htmlDoc.DocumentNode.SelectSingleNode ("//body").InnerText;
else
throw new Exception ("ERROR: No body in document in MailTemplate.PlainText");
re = new Regex (@"\r\n\s+(?=\r\n)"); //replace rows with only whitespace with empty
retval = re.Replace (retval, "\r\n");
re = new Regex (@"\r\n\r\n(\r\n)+"); //replace three or more linefeeds with two.
retval = re.Replace (retval, "\r\n\r\n");
return HttpUtility.HtmlDecode (retval);
}
}
public HtmlDocument HtmlDoc
{
get
{
if (this.htmlDoc == null)
{
this.htmlDoc = new HtmlDocument();
try
{
this.htmlDoc.LoadHtml (base.TemplateBody);
}
catch (Exception ex)
{
throw new Exception ("Failed to load Html in MailTemplate", ex);
}
}
return this.htmlDoc;
}
}
public string TemplateTitle
{
get
{
HtmlNode titleNode = TitleNode();
if (titleNode != null)
return titleNode.InnerHtml;
return "";
}
set
{
HtmlNode titleNode = TitleNode();
if (titleNode != null)
titleNode.InnerHtml = value;
}
}
public string TemplateTitleText
{
get
{
HtmlNode titleNode = TitleNode();
if (titleNode != null)
return HttpUtility.HtmlDecode (HttpUtility.HtmlDecode (titleNode.InnerText));
return "";
}
}
//Returns an empty template to be filled by the caller
public static MailTemplate None
{
get { return new MailTemplate(); }
}
#region Data layer access
public static MailTemplate FromIdentity (int templateId)
{
BasicMailTemplate basic = SwarmDb.GetDatabaseForReading().GetMailTemplateById (templateId);
return FromBasic (basic);
}
internal static MailTemplate FromBasic (BasicMailTemplate basic)
{
MailTemplate templ = new MailTemplate (basic);
return templ;
}
public static List<MailTemplate> GetAll()
{
BasicMailTemplate[] basic = SwarmDb.GetDatabaseForReading().GetAllMailTemplates();
List<MailTemplate> resultlist = new List<MailTemplate>();
foreach (BasicMailTemplate bt in basic)
{
resultlist.Add (FromBasic (bt));
}
return resultlist;
}
public static MailTemplate Create (
string templateName,
string languageCode,
string countryCode,
int organizationId,
string templateBody)
{
int retId = SwarmDb.GetDatabaseForWriting().SetMailTemplate (0,
templateName,
languageCode,
countryCode,
organizationId,
templateBody);
MailTemplateCache.loadCache = true;
return FromIdentity (retId);
}
public void Update()
{
TemplateBody = TemplateBody; //to make sure the HTMlDoc is taken into account
SwarmDb.GetDatabaseForWriting().SetMailTemplate (this); // saves changes
MailTemplateCache.loadCache = true;
}
//----------------------------------------------//
// Cached retreval
public static MailTemplate FromNameCountryAndOrg (string name, string countrycode, int orgId)
{
if (name == "")
return None;
Country country = Country.FromCode (countrycode);
string lang = country.Culture.Substring (0, 2);
Organization org = Organization.FromIdentity (orgId);
BasicMailTemplate basic = MailTemplateCache.GetBestMatch (name, lang, countrycode, org);
return FromBasic (basic);
}
public static MailTemplate FromNameAndOrg (string name, Organization sender)
{
if (name == "")
return None;
Country country = sender.DefaultCountry;
string countrycode = country.Code;
string lang = country.Culture.Substring (0, 2);
BasicMailTemplate basic = MailTemplateCache.GetBestMatch (name, lang, countrycode, sender);
return FromBasic (basic);
}
#endregion
public void ResetContent()
{
this.htmlDoc = null;
TemplateBody = this.originallyLoadedContent;
}
public void NormalizeHtml()
{
//Make sure there is a full html document defined
this.htmlDoc = NormalizeHtmlExtracted (HtmlDoc, TemplateName.EndsWith ("Plain"));
}
private HtmlDocument NormalizeHtmlExtracted (HtmlDocument htDoc, bool forPlainText)
{
if (htDoc == null)
{
throw new Exception ("NormalizeHtmlExtracted was called with null document:\nTemplateBody:" +
TemplateBody);
}
if (htDoc.DocumentNode == null)
{
throw new Exception ("NormalizeHtmlExtracted was called with null DocumentNode:\nTemplateBody:" +
TemplateBody);
}
string newHtml = "";
HtmlNode headNode = htDoc.DocumentNode.SelectSingleNode ("//head");
HtmlNode bodyNode = htDoc.DocumentNode.SelectSingleNode ("//body");
HtmlNode htmlNode = htDoc.DocumentNode.SelectSingleNode ("//html");
HtmlNode titleNode = htDoc.DocumentNode.SelectSingleNode ("//head/title");
if (bodyNode == null && headNode == null && htmlNode == null)
newHtml = "<html><head><title>Untitled</title></head><body>" + htDoc.DocumentNode.OuterHtml +
"</body></html>";
else if (bodyNode != null && headNode == null && htmlNode == null)
newHtml = "<html><head><title>Untitled</title></head>" + bodyNode.OuterHtml + "</html>";
else if (bodyNode != null && headNode != null && htmlNode == null)
newHtml = "<html>" + bodyNode.OuterHtml + "</html>";
else if (headNode == null && htmlNode != null)
{
headNode = htDoc.CreateElement ("head");
htmlNode.InsertAfter (headNode, null);
titleNode = htDoc.CreateElement ("title");
titleNode.InnerHtml = "Untitled";
headNode.AppendChild (titleNode);
}
else if (titleNode == null && headNode != null)
{
titleNode = htDoc.CreateElement ("title");
titleNode.InnerHtml = "Untitled";
headNode.AppendChild (titleNode);
}
if (newHtml != "")
{
htDoc = new HtmlDocument();
htDoc.LoadHtml (newHtml);
}
if (htDoc.DocumentNode == null)
{
throw new Exception ("NormalizeHtmlExtracted Document Node is null for " + newHtml);
}
//"Plain" templates should have the whole body in a pre tag
HtmlNode bodyNode2 = htDoc.DocumentNode.SelectSingleNode ("//body");
if (bodyNode2 == null)
{
throw new Exception ("NormalizeHtmlExtracted bodyNode2 is null for " + newHtml);
}
int preIx = 0;
for (preIx = 0; preIx < bodyNode2.ChildNodes.Count; ++preIx)
{
if (bodyNode2.ChildNodes[preIx].Name.ToLower() == "pre") break;
}
if (forPlainText && preIx == bodyNode2.ChildNodes.Count)
{
bodyNode2.InsertAfter (htDoc.CreateElement ("pre"), null);
for (int i = bodyNode2.ChildNodes.Count - 1; i > 0; --i)
{
HtmlNode nodeToMove = bodyNode2.ChildNodes[i];
bodyNode2.RemoveChild (nodeToMove);
bodyNode2.FirstChild.InsertAfter (nodeToMove, null);
}
string html = htDoc.DocumentNode.OuterHtml;
htDoc = new HtmlDocument();
htDoc.LoadHtml (html);
}
return htDoc;
}
public void MarkPlaceholderSpans()
{
MarkPlaceholderSpans (HtmlDoc);
}
public void MarkPlaceholderSpans (Dictionary<string, string> allowedPlaceholders)
{
MarkPlaceholderSpans();
HtmlNodeCollection allTags = HtmlBody.SelectNodes ("//*[@class='placeholder2']");
Regex reCleanup = new Regex (@"[\s%]");
if (allTags != null)
{
foreach (HtmlNode n in allTags)
{
string key = reCleanup.Replace (n.InnerText, "");
string keyLow = key.ToLower();
if (!allowedPlaceholders.ContainsKey (keyLow))
{
string classname = n.GetAttributeValue ("class", "");
classname = classname.Replace ("placeholder2", "placeholderUnkn");
n.SetAttributeValue ("class", classname);
}
else if (allowedPlaceholders[keyLow] != key
&& allowedPlaceholders[keyLow].ToUpper() != key
&& allowedPlaceholders[keyLow].ToLower() != key)
{
n.InnerHtml = "%" + allowedPlaceholders[keyLow] + "%";
}
}
}
}
public static void MarkPlaceholderSpans (HtmlDocument htDoc)
{
//Code below is for inserting span's around %tag% placeholders so they can be redered with bg-color in editor
//(It is a bit hairy, because it is meddling with the same structure it is looping on
//and that gives some strange effects...)
Regex reTags = new Regex (@"(%[a-z���0-9]+%)", RegexOptions.IgnoreCase);
HtmlNodeCollection allWithTextNodes = htDoc.DocumentNode.SelectNodes ("//body//text()/..");
//select nodes that have text below them
if (allWithTextNodes != null)
{
foreach (HtmlNode n in allWithTextNodes)
{
HtmlNodeCollection allTextNodes = n.SelectNodes ("./text()"); //select the #text children
if (allTextNodes != null)
{
foreach (HtmlNode tn in allTextNodes)
{
if (tn.PreviousSibling is HtmlTextNode)
{
//try to normalize textnodes, accumulating the text.
tn.InnerHtml = tn.PreviousSibling.InnerHtml + tn.InnerHtml;
tn.PreviousSibling.InnerHtml = "";
}
//insert span tags around %tag%, trying to avoid doing it twice.
if (reTags.IsMatch (tn.InnerText) && !n.OuterHtml.Contains ("placeholder2") &&
!tn.OuterHtml.Contains ("placeholder2"))
{
tn.InnerHtml = reTags.Replace (tn.InnerHtml, "<span class=\"placeholder2\">$1</span>");
}
}
}
}
}
}
public void RemovePlaceholderSpans()
{
RemovePlaceholderSpans (HtmlDoc);
}
public static void RemovePlaceholderSpans (HtmlDocument htDoc)
{
HtmlNodeCollection placeholder2Spans = htDoc.DocumentNode.SelectNodes ("//*[@class='placeholder2']");
if (placeholder2Spans != null)
{
foreach (HtmlNode n in placeholder2Spans)
{
n.ParentNode.RemoveChild (n, true);
}
}
placeholder2Spans = htDoc.DocumentNode.SelectNodes ("//*[@class='placeholderUnkn']");
if (placeholder2Spans != null)
{
foreach (HtmlNode n in placeholder2Spans)
{
n.ParentNode.RemoveChild (n, true);
}
}
}
public HtmlNode GetElementById (string id)
{
return HtmlDoc.DocumentNode.SelectSingleNode ("//*[@id='" + id + "']");
}
public HtmlNodeCollection GetElementsById (string id)
{
return HtmlDoc.DocumentNode.SelectNodes ("//*[@id='" + id + "']");
}
public void RemoveElementById (string id)
{
HtmlNodeCollection nodes = HtmlDoc.DocumentNode.SelectNodes ("//*[@id='" + id + "']");
if (nodes != null)
foreach (HtmlNode node in nodes)
{
node.ParentNode.RemoveChild (node);
}
}
public void RemoveEnclosingTag (string id)
{
HtmlNodeCollection nodes = HtmlDoc.DocumentNode.SelectNodes ("//*[@id='" + id + "']");
if (nodes != null)
foreach (HtmlNode node in nodes)
{
node.ParentNode.RemoveChild (node, true);
}
}
public bool ReplaceContentById (string id, string InnerHtml)
{
HtmlNodeCollection nodes = HtmlDoc.DocumentNode.SelectNodes ("//*[@id='" + id + "']");
bool retval = false;
if (nodes != null)
foreach (HtmlNode node in nodes)
{
node.InnerHtml = InnerHtml;
node.ParentNode.RemoveChild (node, true);
retval = true;
}
return retval;
}
public void ReplaceContentByPattern (string pattern, string InnerHtml)
{
// Replace pattern tags taking case into account.
Regex UpperPattern = new Regex ("%" + pattern.ToUpper() + "%");
Regex LowerPattern = new Regex ("%" + pattern.ToLower() + "%");
Regex JustPattern = new Regex ("%" + pattern + "%", RegexOptions.IgnoreCase);
string content = UpperPattern.Replace (TemplateBody, InnerHtml.ToUpper());
content = LowerPattern.Replace (content, InnerHtml.ToLower());
TemplateBody = JustPattern.Replace (content, InnerHtml);
}
private HtmlNode TitleNode()
{
//Since NormalizeHtml is expensive try without first
HtmlNode titlenode = null;
if (HtmlDoc != null && HtmlDoc.DocumentNode != null)
titlenode = HtmlDoc.DocumentNode.SelectSingleNode ("//head/title");
if (titlenode == null)
{
NormalizeHtml();
titlenode = HtmlDoc.DocumentNode.SelectSingleNode ("//head/title");
if (titlenode == null)
{
return null;
}
}
titlenode.InnerHtml = titlenode.InnerHtml.Replace ("&lt;", "<").Replace ("&gt;", ">");
return titlenode;
}
}
}