/// <summary>
/// Fires the before a publish action updates the content cache
/// </summary>
/// <param name="node">The sender.</param>
/// <param name="e">The <see cref="umbraco.cms.businesslogic.ContentCacheLoadNodeEventArgs"/> instance containing the event data.</param>
public static void FireBeforePublishNodeToContentCache(XmlNode node, ContentCacheLoadNodeEventArgs e)
{
if (BeforePublishNodeToContentCache != null)
{
BeforePublishNodeToContentCache(node, e);
}
}
/// <summary>
/// Fires the after loading document cache xml node from database
/// </summary>
/// <param name="node">The sender.</param>
/// <param name="e">The <see cref="umbraco.cms.businesslogic.ContentCacheLoadNodeEventArgs"/> instance containing the event data.</param>
internal static void FireAfterContentCacheLoadNodeFromDatabase(XmlNode node, ContentCacheLoadNodeEventArgs e)
{
if (AfterContentCacheLoadNodeFromDatabase != null)
{
AfterContentCacheLoadNodeFromDatabase(node, e);
}
}
/// <summary>
/// Fires the before when creating the document cache from database
/// </summary>
/// <param name="node">The sender.</param>
/// <param name="e">The <see cref="umbraco.cms.businesslogic.ContentCacheLoadNodeEventArgs"/> instance containing the event data.</param>
internal static void FireAfterContentCacheDatabaseLoadXmlString(ref string xml, ContentCacheLoadNodeEventArgs e)
{
if (AfterContentCacheDatabaseLoadXmlString != null)
{
AfterContentCacheDatabaseLoadXmlString(ref xml, e);
}
}
/// <summary>
/// Fires the before when creating the document cache from database
/// </summary>
/// <param name="node">The sender.</param>
/// <param name="e">The <see cref="umbraco.cms.businesslogic.ContentCacheLoadNodeEventArgs"/> instance containing the event data.</param>
internal static void FireBeforeContentCacheLoadNode(XmlNode node, ContentCacheLoadNodeEventArgs e)
{
if (BeforeContentCacheLoadNode != null)
{
BeforeContentCacheLoadNode(node, e);
}
}
/// <summary>
/// Load content from database
/// </summary>
private XmlDocument LoadContentFromDatabase()
{
// Alex N - 2010 06 - Very generic try-catch simply because at the moment, unfortunately, this method gets called inside a ThreadPool thread
// and we need to guarantee it won't tear down the app pool by throwing an unhandled exception
try
{
// Moved User to a local variable - why are we causing user 0 to load from the DB though?
// Alex N 20100212
User staticUser = null;
try
{
staticUser = User.GetCurrent(); //User.GetUser(0);
}
catch
{
/* We don't care later if the staticUser is null */
}
// Try to log to the DB
Log.Add(LogTypes.System, staticUser, -1, "Loading content from database...");
var hierarchy = new Dictionary<int, List<int>>();
var nodeIndex = new Dictionary<int, XmlNode>();
try
{
Log.Add(LogTypes.Debug, staticUser, -1, "Republishing starting");
// Lets cache the DTD to save on the DB hit on the subsequent use
string dtd = DocumentType.GenerateDtd();
// Prepare an XmlDocument with an appropriate inline DTD to match
// the expected content
var xmlDoc = new XmlDocument();
InitContentDocument(xmlDoc, dtd);
// Esben Carlsen: At some point we really need to put all data access into to a tier of its own.
string sql =
@"select umbracoNode.id, umbracoNode.parentId, umbracoNode.sortOrder, cmsContentXml.xml from umbracoNode
inner join cmsContentXml on cmsContentXml.nodeId = umbracoNode.id and umbracoNode.nodeObjectType = @type
order by umbracoNode.level, umbracoNode.sortOrder";
lock (_dbReadSyncLock)
{
using (
IRecordsReader dr = SqlHelper.ExecuteReader(sql,
SqlHelper.CreateParameter("@type",
new Guid(
"C66BA18E-EAF3-4CFF-8A22-41B16D66A972")))
)
{
while (dr.Read())
{
int currentId = dr.GetInt("id");
int parentId = dr.GetInt("parentId");
string xml = dr.GetString("xml");
// Call the eventhandler to allow modification of the string
var e1 = new ContentCacheLoadNodeEventArgs();
FireAfterContentCacheDatabaseLoadXmlString(ref xml, e1);
// check if a listener has canceled the event
if (!e1.Cancel)
{
// and parse it into a DOM node
xmlDoc.LoadXml(xml);
XmlNode node = xmlDoc.FirstChild;
// same event handler loader form the xml node
var e2 = new ContentCacheLoadNodeEventArgs();
FireAfterContentCacheLoadNodeFromDatabase(node, e2);
// and checking if it was canceled again
if (!e1.Cancel)
{
nodeIndex.Add(currentId, node);
// verify if either of the handlers canceled the children to load
if (!e1.CancelChildren && !e2.CancelChildren)
{
// Build the content hierarchy
List<int> children;
if (!hierarchy.TryGetValue(parentId, out children))
{
// No children for this parent, so add one
children = new List<int>();
hierarchy.Add(parentId, children);
}
children.Add(currentId);
}
}
}
}
}
}
Log.Add(LogTypes.Debug, staticUser, -1, "Xml Pages loaded");
try
{
// If we got to here we must have successfully retrieved the content from the DB so
// we can safely initialise and compose the final content DOM.
// Note: We are reusing the XmlDocument used to create the xml nodes above so
// we don't have to import them into a new XmlDocument
// Initialise the document ready for the final composition of content
InitContentDocument(xmlDoc, dtd);
// Start building the content tree recursively from the root (-1) node
GenerateXmlDocument(hierarchy, nodeIndex, -1, xmlDoc.DocumentElement);
Log.Add(LogTypes.Debug, staticUser, -1, "Done republishing Xml Index");
return xmlDoc;
}
catch (Exception ee)
{
Log.Add(LogTypes.Error, staticUser, -1,
string.Format("Error while generating XmlDocument from database: {0}", ee));
}
}
catch (OutOfMemoryException)
{
Log.Add(LogTypes.Error, staticUser, -1,
string.Format("Error Republishing: Out Of Memory. Parents: {0}, Nodes: {1}",
hierarchy.Count, nodeIndex.Count));
}
catch (Exception ee)
{
Log.Add(LogTypes.Error, staticUser, -1, string.Format("Error Republishing: {0}", ee));
}
}
catch (Exception ee)
{
Log.Add(LogTypes.Error, -1, string.Format("Error Republishing: {0}", ee));
}
// An error of some sort must have stopped us from successfully generating
// the content tree, so lets return null signifying there is no content available
return null;
}
