/// <summary>
/// The event this handles fires after a document is published in the back office and the cache is updated.
/// We render out the page and store it's HTML in the database for retrieval by the indexer.
/// </summary>
/// <param name="sender">Document being published</param>
/// <param name="e">Event Arguments</param>
/// <remarks>
/// the indexer thread doesn't always access to a fully initialised umbraco core to do the rendering,
/// whereas this event always should, hence this method rather than doing both rendering and indexing
/// in the same thread
/// </remarks>
private void ContentAfterUpdateDocumentCache(Document sender, DocumentCacheEventArgs e)
{
if (sender == null || sender.Id < 1)
{
return;
}
var id = sender.Id;
// get config and check we're enabled and good to go
if (!CheckConfig())
{
return;
}
// this can take a while...
Library.SetTimeout(Config.Instance.GetByKey("ScriptTimeout"));
var nodeTypeAlias = sender.ContentType.Alias;
var renderer = Manager.Instance.DocumentRendererFactory.CreateNew(nodeTypeAlias);
string fullHtml;
if (renderer.Render(id, out fullHtml))
{
HtmlCache.Store(id, ref fullHtml);
}
else
{
HtmlCache.Remove(id);
}
}
private static void ContentAfterUpdateDocumentCache(Document sender, DocumentCacheEventArgs e)
{
//ensure that only the providers that have DONT unpublishing support enabled
//that are also flagged to listen
ExamineManager.Instance.ReIndexNode(ToXDocument(sender, true).Root, IndexTypes.Content,
ExamineManager.Instance.IndexProviderCollection.OfType <BaseUmbracoIndexer>()
.Where(x => !x.SupportUnpublishedContent &&
x.EnableDefaultEventHandler));
}
private void content_AfterClearDocumentCache(Document sender, DocumentCacheEventArgs e)
{
var nodeId = sender.Id.ToString();
//ensure that only the providers that DONT have unpublishing support enabled
//that are also flagged to listen
ExamineManager.Instance.DeleteFromIndex(nodeId,
ExamineManager.Instance.IndexProviderCollection.OfType <BaseUmbracoIndexer>()
.Where(x => !x.SupportUnpublishedContent &&
x.EnableDefaultEventHandler));
}
void ContentAfterUpdateDocumentCache(Document sender, DocumentCacheEventArgs e)
{
Logger.Info("Received update cache event");
var content = UmbracoContext.Current.Application.Services.ContentService.GetById(sender.Id);
var runtimeContentModel = RuntimeUmbracoContext.Instance.UmbracoContentSerialiser.Serialise(content);
foreach (var adapter in RuntimeUmbracoContext.Instance.DeploymentAdapters)
{
adapter.DeployContent(runtimeContentModel, DeploymentAction.Deploy);
}
}
void content_BeforeClearDocumentCache(Document doc, DocumentCacheEventArgs e)
{
#if !DEBUG
try
#endif
{
UrlTrackerRepository.AddGoneEntryByNodeId(doc.Id);
}
#if !DEBUG
catch (Exception ex)
{
ex.LogException(doc.Id);
}
#endif
}
void content_BeforeClearDocumentCache(Document doc, DocumentCacheEventArgs e)
{
#if !DEBUG
try
#endif
{
UrlTrackerRepository.AddGoneEntryByNodeId(doc.Id);
}
#if !DEBUG
catch (Exception ex)
{
ex.LogException();
}
#endif
}
private void ContentOnAfterUpdateDocumentCache(Document sender, DocumentCacheEventArgs documentCacheEventArgs)
{
//if (sender.ContentType.Alias.StartsWith("uwbs") && sender.ContentType.Alias != Order.NodeAlias)
//todo: work with aliasses from config
var alias = sender.ContentType.Alias;
// todo: make a nice way for this block
if (Product.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (ProductVariant.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (Category.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (PaymentProvider.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (PaymentProviderMethod.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (DiscountProduct.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (DiscountOrder.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (ShippingProvider.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (ShippingProviderMethod.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (Store.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (alias.StartsWith("uwbs") && alias != Order.NodeAlias)
{
ResetAll(sender.Id, alias);
}
var storePickerProperty = sender.getProperty(Constants.StorePickerAlias);
if (storePickerProperty != null)
{
int storeId;
if (storePickerProperty.Value != null && int.TryParse(storePickerProperty.Value.ToString(), out storeId))
{
var storeService = StoreHelper.StoreService;
var storeById = storeService.GetById(storeId, null);
if (storeById != null)
{
storeService.TriggerStoreChangedEvent(storeById);
}
}
}
if (alias.StartsWith(Settings.NodeAlias))
{
IO.Container.Resolve <ISettingsService>().TriggerSettingsChangedEvent(SettingsLoader.GetSettings());
}
if (alias.StartsWith(Store.NodeAlias))
{
//todo: naar nieuwe v6+ API omzetten
var storeService = StoreHelper.StoreService;
storeService.TriggerStoreChangedEvent(storeService.GetById(sender.Id, null));
var node = new Node(sender.Id);
if (!sender.Text.Equals(node.Name))
{
StoreHelper.RenameStore(node.Name, sender.Text);
}
}
}
/// <summary>
/// Fires the after document cache unpublish.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="umbraco.cms.businesslogic.DocumentCacheEventArgs"/> instance containing the event data.</param>
protected virtual void FireAfterClearDocumentCache(Document sender, DocumentCacheEventArgs e)
{
if (AfterClearDocumentCache != null)
{
AfterClearDocumentCache(sender, e);
}
}
/// <summary>
/// Fires the before document cache unpublish.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="umbraco.cms.businesslogic.DocumentCacheEventArgs"/> instance containing the event data.</param>
protected virtual void FireBeforeClearDocumentCache(Document sender, DocumentCacheEventArgs e)
{
if (BeforeClearDocumentCache != null)
{
BeforeClearDocumentCache(sender, e);
}
}
/// <summary>
/// Clears the document cache and removes the document from the xml db cache.
/// This means the node gets unpublished from the website.
/// </summary>
/// <param name="documentId">The document id.</param>
public virtual void ClearDocumentCache(int documentId)
{
// Get the document
var d = new Document(documentId);
var e = new DocumentCacheEventArgs();
FireBeforeClearDocumentCache(d, e);
if (!e.Cancel)
{
XmlNode x;
// remove from xml db cache
d.XmlRemoveFromDB();
// Check if node present, before cloning
x = XmlContentInternal.GetElementById(d.Id.ToString());
if (x == null)
return;
// We need to lock content cache here, because we cannot allow other threads
// making changes at the same time, they need to be queued
lock (_xmlContentInternalSyncLock)
{
// Make copy of memory content, we cannot make changes to the same document
// the is read from elsewhere
XmlDocument xmlContentCopy = CloneXmlDoc(XmlContentInternal);
// Find the document in the xml cache
x = xmlContentCopy.GetElementById(d.Id.ToString());
if (x != null)
{
// The document already exists in cache, so repopulate it
x.ParentNode.RemoveChild(x);
XmlContentInternal = xmlContentCopy;
ClearContextCache();
}
}
if (x != null)
{
// Run Handler
Action.RunActionHandlers(d, ActionUnPublish.Instance);
}
// update sitemapprovider
if (SiteMap.Provider is UmbracoSiteMapProvider)
{
var prov = (UmbracoSiteMapProvider)SiteMap.Provider;
prov.RemoveNode(d.Id);
}
FireAfterClearDocumentCache(d, e);
}
}
/// <summary>
/// Updates the document cache.
/// </summary>
/// <param name="d">The d.</param>
public virtual void UpdateDocumentCache(Document d)
{
var e = new DocumentCacheEventArgs();
FireBeforeUpdateDocumentCache(d, e);
if (!e.Cancel)
{
// lock the xml cache so no other thread can write to it at the same time
// note that some threads could read from it while we hold the lock, though
lock (_xmlContentInternalSyncLock)
{
// modify a clone of the cache because even though we're into the write-lock
// we may have threads reading at the same time. why is this an option?
XmlDocument wip = UmbracoSettings.CloneXmlCacheOnPublish
? CloneXmlDoc(XmlContentInternal)
: XmlContentInternal;
wip = PublishNodeDo(d, wip, true);
XmlContentInternal = wip;
ClearContextCache();
}
// clear cached field values
if (HttpContext.Current != null)
{
System.Web.Caching.Cache httpCache = HttpContext.Current.Cache;
string cachedFieldKeyStart = String.Format("contentItem{0}_", d.Id);
var foundKeys = new List<string>();
foreach (DictionaryEntry cacheItem in httpCache)
{
string key = cacheItem.Key.ToString();
if (key.StartsWith(cachedFieldKeyStart))
foundKeys.Add(key);
}
foreach (string foundKey in foundKeys)
{
httpCache.Remove(foundKey);
}
}
Action.RunActionHandlers(d, ActionPublish.Instance);
FireAfterUpdateDocumentCache(d, e);
}
}
private static void ContentAfterClearDocumentCache(Document sender, DocumentCacheEventArgs e)
{
var nodeId = sender.Id.ToString();
//ensure that only the providers that DONT have unpublishing support enabled
//that are also flagged to listen
ExamineManager.Instance.DeleteFromIndex(nodeId,
ExamineManager.Instance.IndexProviderCollection.OfType<BaseUmbracoIndexer>()
.Where(x => !x.SupportUnpublishedContent
&& x.EnableDefaultEventHandler));
}
private static void ContentAfterUpdateDocumentCache(Document sender, DocumentCacheEventArgs e)
{
//ensure that only the providers that have DONT unpublishing support enabled
//that are also flagged to listen
ExamineManager.Instance.ReIndexNode(ToXDocument(sender, true).Root, IndexTypes.Content,
ExamineManager.Instance.IndexProviderCollection.OfType<BaseUmbracoIndexer>()
.Where(x => !x.SupportUnpublishedContent
&& x.EnableDefaultEventHandler));
}
/// <summary>
/// Updates the document cache.
/// </summary>
/// <param name="d">The d.</param>
public virtual void UpdateDocumentCache(Document d)
{
var e = new DocumentCacheEventArgs();
FireBeforeUpdateDocumentCache(d, e);
if (!e.Cancel)
{
// lock the xml cache so no other thread can write to it at the same time
// note that some threads could read from it while we hold the lock, though
lock (XmlContentInternalSyncLock)
{
// modify a clone of the cache because even though we're into the write-lock
// we may have threads reading at the same time. why is this an option?
XmlDocument wip = UmbracoConfig.For.UmbracoSettings().Content.CloneXmlContent
? CloneXmlDoc(XmlContentInternal)
: XmlContentInternal;
wip = PublishNodeDo(d, wip, true);
XmlContentInternal = wip;
ClearContextCache();
}
var cachedFieldKeyStart = string.Format("{0}{1}_", CacheKeys.ContentItemCacheKey, d.Id);
ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch(cachedFieldKeyStart);
FireAfterUpdateDocumentCache(d, e);
}
}
private void ContentOnAfterUpdateDocumentCache(Document sender, DocumentCacheEventArgs documentCacheEventArgs)
{
//if (sender.ContentType.Alias.StartsWith("uwbs") && sender.ContentType.Alias != Order.NodeAlias)
//todo: work with aliasses from config
var alias = sender.ContentType.Alias;
// todo: make a nice way for this block
if (Product.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (ProductVariant.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (Category.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (PaymentProvider.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (PaymentProviderMethod.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (DiscountProduct.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (DiscountOrder.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (ShippingProvider.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (ShippingProviderMethod.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (Store.IsAlias(alias))
{
ResetAll(sender.Id, alias);
}
else if (alias.StartsWith("uwbs") && alias != Order.NodeAlias)
{
ResetAll(sender.Id, alias);
}
var storePickerProperty = sender.getProperty(Constants.StorePickerAlias);
if (storePickerProperty != null)
{
int storeId;
if (storePickerProperty.Value != null && int.TryParse(storePickerProperty.Value.ToString(), out storeId))
{
var storeService = StoreHelper.StoreService;
var storeById = storeService.GetById(storeId, null);
if (storeById != null)
{
storeService.TriggerStoreChangedEvent(storeById);
}
}
}
if (alias.StartsWith(Settings.NodeAlias))
{
IO.Container.Resolve<ISettingsService>().TriggerSettingsChangedEvent(SettingsLoader.GetSettings());
}
if (alias.StartsWith(Store.NodeAlias))
{
//todo: naar nieuwe v6+ API omzetten
var storeService = StoreHelper.StoreService;
storeService.TriggerStoreChangedEvent(storeService.GetById(sender.Id, null));
var node = new Node(sender.Id);
if (!sender.Text.Equals(node.Name))
{
StoreHelper.RenameStore(node.Name, sender.Text);
}
}
}
