Removes listening on legacy events for the CacheRefresherEventHandler

src/Umbraco.Core/Cache/CacheKeys.cs

@@ -48,6 +48,7 @@ namespace Umbraco.Core.Cache
         [Obsolete("This is no longer used and will be removed from the codebase in the future")]
         public const string LanguageCacheKey = "UmbracoLanguageCache";
 
+        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
         public const string DomainCacheKey = "UmbracoDomainList";
 
         [Obsolete("This is no longer used and will be removed from the codebase in the future")]

src/Umbraco.Core/Services/DomainService.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
@@ -9,8 +10,6 @@ using Umbraco.Core.Persistence.UnitOfWork;
 
 namespace Umbraco.Core.Services
 {
-    //TODO: Add events!
-
     public class DomainService : RepositoryService, IDomainService
     {
         public DomainService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
@@ -29,12 +28,18 @@ namespace Umbraco.Core.Services
 
         public void Delete(IDomain domain)
         {
+            if (Deleting.IsRaisedEventCancelled(new DeleteEventArgs<IDomain>(domain), this))
+                return;
+
             var uow = UowProvider.GetUnitOfWork();
             using (var repository = RepositoryFactory.CreateDomainRepository(uow))
             {
                 repository.Delete(domain);
-                uow.Commit();
+                uow.Commit();               
             }
+
+            var args = new DeleteEventArgs<IDomain>(domain, false);
+            Deleted.RaiseEvent(args, this);
         }
 
         public IDomain GetByName(string name)
@@ -77,8 +82,8 @@ namespace Umbraco.Core.Services
         {
             if (raiseEvents)
             {
-                //if (Saving.IsRaisedEventCancelled(new SaveEventArgs<IContent>(content), this))
-                //    return;
+                if (Saving.IsRaisedEventCancelled(new SaveEventArgs<IDomain>(domainEntity), this))
+                    return;
             }
 
             var uow = UowProvider.GetUnitOfWork();
@@ -88,8 +93,32 @@ namespace Umbraco.Core.Services
                 uow.Commit();
             }
 
-            //if (raiseEvents)
-            //    Saved.RaiseEvent(new SaveEventArgs<IContent>(content, false), this);
+            if (raiseEvents)
+                Saved.RaiseEvent(new SaveEventArgs<IDomain>(domainEntity, false), this);
         }
+
+        #region Event Handlers
+        /// <summary>
+        /// Occurs before Delete
+        /// </summary>		
+        public static event TypedEventHandler<IDomainService, DeleteEventArgs<IDomain>> Deleting;
+
+        /// <summary>
+        /// Occurs after Delete
+        /// </summary>
+        public static event TypedEventHandler<IDomainService, DeleteEventArgs<IDomain>> Deleted;
+      
+        /// <summary>
+        /// Occurs before Save
+        /// </summary>
+        public static event TypedEventHandler<IDomainService, SaveEventArgs<IDomain>> Saving;
+
+        /// <summary>
+        /// Occurs after Save
+        /// </summary>
+        public static event TypedEventHandler<IDomainService, SaveEventArgs<IDomain>> Saved;
+
+      
+        #endregion
     }
 }

src/Umbraco.Web/Cache/CacheRefresherEventHandler.cs

@@ -1,25 +1,17 @@
 using System;
-using System.Collections.Generic;
 using Umbraco.Core;
-using Umbraco.Core.Cache;
 using Umbraco.Core.Events;
 using Umbraco.Core.Models;
-using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Services;
-using umbraco;
 using umbraco.BusinessLogic;
 using umbraco.cms.businesslogic;
-using umbraco.cms.businesslogic.member;
 using System.Linq;
 using umbraco.cms.businesslogic.web;
 using Content = Umbraco.Core.Models.Content;
 using ApplicationTree = Umbraco.Core.Models.ApplicationTree;
 using DeleteEventArgs = umbraco.cms.businesslogic.DeleteEventArgs;
-using Macro = umbraco.cms.businesslogic.macro.Macro;
-using Member = umbraco.cms.businesslogic.member.Member;
-using Template = umbraco.cms.businesslogic.template.Template;
 
 namespace Umbraco.Web.Cache
 {
@@ -46,44 +38,30 @@ namespace Umbraco.Web.Cache
             UserService.DeletedUser += UserServiceDeletedUser;
 
             //Bind to dictionary events
-            //NOTE: we need to bind to legacy and new API events currently: http://issues.umbraco.org/issue/U4-1979
 
-            global::umbraco.cms.businesslogic.Dictionary.DictionaryItem.New += DictionaryItemNew;
-            global::umbraco.cms.businesslogic.Dictionary.DictionaryItem.Saving +=DictionaryItemSaving;
-            global::umbraco.cms.businesslogic.Dictionary.DictionaryItem.Deleted +=DictionaryItemDeleted;
             LocalizationService.DeletedDictionaryItem += LocalizationServiceDeletedDictionaryItem;
             LocalizationService.SavedDictionaryItem += LocalizationServiceSavedDictionaryItem;
 
             //Bind to data type events
             //NOTE: we need to bind to legacy and new API events currently: http://issues.umbraco.org/issue/U4-1979
-
+            //TODO: Wrap as much of this api as possible so that we don't need to listen to legacy events!
             global::umbraco.cms.businesslogic.datatype.DataTypeDefinition.AfterDelete += DataTypeDefinitionDeleting;
             global::umbraco.cms.businesslogic.datatype.DataTypeDefinition.Saving += DataTypeDefinitionSaving;
             DataTypeService.Deleted += DataTypeServiceDeleted;
             DataTypeService.Saved += DataTypeServiceSaved;
 
             //Bind to stylesheet events
-            //NOTE: we need to bind to legacy and new API events currently: http://issues.umbraco.org/issue/U4-1979
 
-            global::umbraco.cms.businesslogic.web.StylesheetProperty.AfterSave += StylesheetPropertyAfterSave;
-            global::umbraco.cms.businesslogic.web.StylesheetProperty.AfterDelete += StylesheetPropertyAfterDelete;
-            global::umbraco.cms.businesslogic.web.StyleSheet.AfterDelete += StyleSheetAfterDelete;
-            global::umbraco.cms.businesslogic.web.StyleSheet.AfterSave += StyleSheetAfterSave;
             FileService.SavedStylesheet += FileServiceSavedStylesheet;
             FileService.DeletedStylesheet += FileServiceDeletedStylesheet;
 
             //Bind to domain events
 
-            Domain.AfterSave += DomainAfterSave;
-            Domain.AfterDelete += DomainAfterDelete;
-            Domain.New += DomainNew;
+            DomainService.Saved += DomainService_Saved;
+            DomainService.Deleted += DomainService_Deleted;
 
             //Bind to language events
-            //NOTE: we need to bind to legacy and new API events currently: http://issues.umbraco.org/issue/U4-1979
 
-            global::umbraco.cms.businesslogic.language.Language.AfterDelete += LanguageAfterDelete;
-            global::umbraco.cms.businesslogic.language.Language.New += LanguageNew;
-            global::umbraco.cms.businesslogic.language.Language.AfterSave += LanguageAfterSave;
             LocalizationService.SavedLanguage += LocalizationServiceSavedLanguage;
             LocalizationService.DeletedLanguage += LocalizationServiceDeletedLanguage;
 
@@ -98,23 +76,19 @@ namespace Umbraco.Web.Cache
 
             //Bind to permission events
 
+            //TODO: Wrap legacy permissions so we can get rid of this
             Permission.New += PermissionNew;
             Permission.Updated += PermissionUpdated;
             Permission.Deleted += PermissionDeleted;
             PermissionRepository<IContent>.AssignedPermissions += CacheRefresherEventHandler_AssignedPermissions;
 
             //Bind to template events
-            //NOTE: we need to bind to legacy and new API events currently: http://issues.umbraco.org/issue/U4-1979
 
-            Template.AfterSave += TemplateAfterSave;
-            Template.AfterDelete += TemplateAfterDelete;
             FileService.SavedTemplate += FileServiceSavedTemplate;
             FileService.DeletedTemplate += FileServiceDeletedTemplate;
 
             //Bind to macro events
 
-            Macro.AfterSave += MacroAfterSave;
-            Macro.AfterDelete += MacroAfterDelete;
             MacroService.Saved += MacroServiceSaved;
             MacroService.Deleted += MacroServiceDeleted;
 
@@ -147,6 +121,8 @@ namespace Umbraco.Web.Cache
             Access.AfterSave += Access_AfterSave;
         }
 
+       
+
         #region Public access event handlers
 
         static void Access_AfterSave(Access sender, SaveEventArgs e)
@@ -258,41 +234,41 @@ namespace Umbraco.Web.Cache
         #endregion
 
         #region ApplicationTree event handlers
-        static void ApplicationTreeNew(ApplicationTree sender, System.EventArgs e)
+        static void ApplicationTreeNew(ApplicationTree sender, EventArgs e)
         {
             DistributedCache.Instance.RefreshAllApplicationTreeCache();
         }
 
-        static void ApplicationTreeUpdated(ApplicationTree sender, System.EventArgs e)
+        static void ApplicationTreeUpdated(ApplicationTree sender, EventArgs e)
         {
             DistributedCache.Instance.RefreshAllApplicationTreeCache();
         }
 
-        static void ApplicationTreeDeleted(ApplicationTree sender, System.EventArgs e)
+        static void ApplicationTreeDeleted(ApplicationTree sender, EventArgs e)
         {
             DistributedCache.Instance.RefreshAllApplicationTreeCache();
         } 
         #endregion
 
         #region Application event handlers
-        static void ApplicationNew(Section sender, System.EventArgs e)
+        static void ApplicationNew(Section sender, EventArgs e)
         {
             DistributedCache.Instance.RefreshAllApplicationCache();
         }
 
-        static void ApplicationDeleted(Section sender, System.EventArgs e)
+        static void ApplicationDeleted(Section sender, EventArgs e)
         {
             DistributedCache.Instance.RefreshAllApplicationCache();
         } 
         #endregion
 
         #region UserType event handlers
-        static void UserServiceDeletedUserType(IUserService sender, Core.Events.DeleteEventArgs<Core.Models.Membership.IUserType> e)
+        static void UserServiceDeletedUserType(IUserService sender, DeleteEventArgs<IUserType> e)
         {
             e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveUserTypeCache(x.Id));
         }
 
-        static void UserServiceSavedUserType(IUserService sender, Core.Events.SaveEventArgs<Core.Models.Membership.IUserType> e)
+        static void UserServiceSavedUserType(IUserService sender, SaveEventArgs<IUserType> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshUserTypeCache(x.Id));
         }
@@ -301,40 +277,25 @@ namespace Umbraco.Web.Cache
         
         #region Dictionary event handlers
 
-        static void LocalizationServiceSavedDictionaryItem(ILocalizationService sender, Core.Events.SaveEventArgs<IDictionaryItem> e)
+        static void LocalizationServiceSavedDictionaryItem(ILocalizationService sender, SaveEventArgs<IDictionaryItem> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshDictionaryCache(x.Id));
         }
 
-        static void LocalizationServiceDeletedDictionaryItem(ILocalizationService sender, Core.Events.DeleteEventArgs<IDictionaryItem> e)
+        static void LocalizationServiceDeletedDictionaryItem(ILocalizationService sender, DeleteEventArgs<IDictionaryItem> e)
         {
             e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveDictionaryCache(x.Id));
         }
 
-        static void DictionaryItemDeleted(global::umbraco.cms.businesslogic.Dictionary.DictionaryItem sender, System.EventArgs e)
-        {
-            DistributedCache.Instance.RemoveDictionaryCache(sender.id);
-        }
-
-        static void DictionaryItemSaving(global::umbraco.cms.businesslogic.Dictionary.DictionaryItem sender, System.EventArgs e)
-        {
-            DistributedCache.Instance.RefreshDictionaryCache(sender.id);
-        }
-
-        static void DictionaryItemNew(global::umbraco.cms.businesslogic.Dictionary.DictionaryItem sender, System.EventArgs e)
-        {
-            DistributedCache.Instance.RefreshDictionaryCache(sender.id);
-        } 
-
         #endregion
 
         #region DataType event handlers
-        static void DataTypeServiceSaved(IDataTypeService sender, Core.Events.SaveEventArgs<IDataTypeDefinition> e)
+        static void DataTypeServiceSaved(IDataTypeService sender, SaveEventArgs<IDataTypeDefinition> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshDataTypeCache(x));
         }
 
-        static void DataTypeServiceDeleted(IDataTypeService sender, Core.Events.DeleteEventArgs<IDataTypeDefinition> e)
+        static void DataTypeServiceDeleted(IDataTypeService sender, DeleteEventArgs<IDataTypeDefinition> e)
         {
             e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveDataTypeCache(x));
         }
@@ -351,52 +312,31 @@ namespace Umbraco.Web.Cache
         #endregion
 
         #region Stylesheet and stylesheet property event handlers
-        static void StylesheetPropertyAfterSave(global::umbraco.cms.businesslogic.web.StylesheetProperty sender, SaveEventArgs e)
-        {
-            DistributedCache.Instance.RefreshStylesheetPropertyCache(sender);
-        }
-
-        static void StylesheetPropertyAfterDelete(global::umbraco.cms.businesslogic.web.StylesheetProperty sender, DeleteEventArgs e)
-        {
-            DistributedCache.Instance.RemoveStylesheetPropertyCache(sender);
-        }
-
-        static void FileServiceDeletedStylesheet(IFileService sender, Core.Events.DeleteEventArgs<Stylesheet> e)
+     
+        static void FileServiceDeletedStylesheet(IFileService sender, DeleteEventArgs<Stylesheet> e)
         {
             e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveStylesheetCache(x));
         }
 
-        static void FileServiceSavedStylesheet(IFileService sender, Core.Events.SaveEventArgs<Stylesheet> e)
+        static void FileServiceSavedStylesheet(IFileService sender, SaveEventArgs<Stylesheet> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshStylesheetCache(x));
         }
 
-        static void StyleSheetAfterSave(StyleSheet sender, SaveEventArgs e)
-        {
-            DistributedCache.Instance.RefreshStylesheetCache(sender);
-        }
-
-        static void StyleSheetAfterDelete(StyleSheet sender, DeleteEventArgs e)
-        {
-            DistributedCache.Instance.RemoveStylesheetCache(sender);
-        } 
         #endregion
 
         #region Domain event handlers
-        static void DomainNew(Domain sender, NewEventArgs e)
+
+        static void DomainService_Saved(IDomainService sender, SaveEventArgs<IDomain> e)
         {
-            DistributedCache.Instance.RefreshDomainCache(sender);
+            e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshDomainCache(x));
         }
 
-        static void DomainAfterDelete(Domain sender, DeleteEventArgs e)
+        static void DomainService_Deleted(IDomainService sender, DeleteEventArgs<IDomain> e)
         {
-            DistributedCache.Instance.RemoveDomainCache(sender);
+            e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveDomainCache(x));
         }
 
-        static void DomainAfterSave(Domain sender, SaveEventArgs e)
-        {
-            DistributedCache.Instance.RefreshDomainCache(sender);
-        } 
         #endregion
 
         #region Language event handlers
@@ -405,7 +345,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void LocalizationServiceDeletedLanguage(ILocalizationService sender, Core.Events.DeleteEventArgs<ILanguage> e)
+        static void LocalizationServiceDeletedLanguage(ILocalizationService sender, DeleteEventArgs<ILanguage> e)
         {
             e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveLanguageCache(x));
         }
@@ -415,40 +355,11 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void LocalizationServiceSavedLanguage(ILocalizationService sender, Core.Events.SaveEventArgs<ILanguage> e)
+        static void LocalizationServiceSavedLanguage(ILocalizationService sender, SaveEventArgs<ILanguage> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshLanguageCache(x));
         }
-
-        /// <summary>
-        /// Fires when a langauge is saved
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        static void LanguageAfterSave(global::umbraco.cms.businesslogic.language.Language sender, SaveEventArgs e)
-        {
-            DistributedCache.Instance.RefreshLanguageCache(sender);
-        }
-
-        /// <summary>
-        /// Fires when a langauge is created
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        static void LanguageNew(global::umbraco.cms.businesslogic.language.Language sender, NewEventArgs e)
-        {
-            DistributedCache.Instance.RefreshLanguageCache(sender);
-        }
-
-        /// <summary>
-        /// Fires when a langauge is deleted
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        static void LanguageAfterDelete(global::umbraco.cms.businesslogic.language.Language sender, DeleteEventArgs e)
-        {
-            DistributedCache.Instance.RemoveLanguageCache(sender);
-        } 
+      
         #endregion
 
         #region Content/media/member Type event handlers
@@ -457,7 +368,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void ContentTypeServiceDeletedMediaType(IContentTypeService sender, Core.Events.DeleteEventArgs<IMediaType> e)
+        static void ContentTypeServiceDeletedMediaType(IContentTypeService sender, DeleteEventArgs<IMediaType> e)
         {
             e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveMediaTypeCache(x));
         }
@@ -467,7 +378,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void ContentTypeServiceDeletedContentType(IContentTypeService sender, Core.Events.DeleteEventArgs<IContentType> e)
+        static void ContentTypeServiceDeletedContentType(IContentTypeService sender, DeleteEventArgs<IContentType> e)
         {
             e.DeletedEntities.ForEach(contentType => DistributedCache.Instance.RemoveContentTypeCache(contentType));
         }
@@ -477,7 +388,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void MemberTypeServiceDeleted(IMemberTypeService sender, Core.Events.DeleteEventArgs<IMemberType> e)
+        static void MemberTypeServiceDeleted(IMemberTypeService sender, DeleteEventArgs<IMemberType> e)
         {
             e.DeletedEntities.ForEach(contentType => DistributedCache.Instance.RemoveMemberTypeCache(contentType));
         }
@@ -487,7 +398,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void ContentTypeServiceSavedMediaType(IContentTypeService sender, Core.Events.SaveEventArgs<IMediaType> e)
+        static void ContentTypeServiceSavedMediaType(IContentTypeService sender, SaveEventArgs<IMediaType> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshMediaTypeCache(x));
         }
@@ -497,7 +408,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void ContentTypeServiceSavedContentType(IContentTypeService sender, Core.Events.SaveEventArgs<IContentType> e)
+        static void ContentTypeServiceSavedContentType(IContentTypeService sender, SaveEventArgs<IContentType> e)
         {
             e.SavedEntities.ForEach(contentType => DistributedCache.Instance.RefreshContentTypeCache(contentType));
         }
@@ -507,7 +418,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void MemberTypeServiceSaved(IMemberTypeService sender, Core.Events.SaveEventArgs<IMemberType> e)
+        static void MemberTypeServiceSaved(IMemberTypeService sender, SaveEventArgs<IMemberType> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshMemberTypeCache(x));
         }
@@ -573,7 +484,7 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void FileServiceDeletedTemplate(IFileService sender, Core.Events.DeleteEventArgs<ITemplate> e)
+        static void FileServiceDeletedTemplate(IFileService sender, DeleteEventArgs<ITemplate> e)
         {
             e.DeletedEntities.ForEach(x => DistributedCache.Instance.RemoveTemplateCache(x.Id));
         }
@@ -583,35 +494,16 @@ namespace Umbraco.Web.Cache
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        static void FileServiceSavedTemplate(IFileService sender, Core.Events.SaveEventArgs<ITemplate> e)
+        static void FileServiceSavedTemplate(IFileService sender, SaveEventArgs<ITemplate> e)
         {
             e.SavedEntities.ForEach(x => DistributedCache.Instance.RefreshTemplateCache(x.Id));
         }
-        
-        /// <summary>
-        /// Removes cache for template
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        static void TemplateAfterDelete(Template sender, DeleteEventArgs e)
-        {
-            DistributedCache.Instance.RemoveTemplateCache(sender.Id);
-        }
-
-        /// <summary>
-        /// Refresh cache for template
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        static void TemplateAfterSave(Template sender, SaveEventArgs e)
-        {
-            DistributedCache.Instance.RefreshTemplateCache(sender.Id);
-        } 
+      
         #endregion
 
         #region Macro event handlers
 
-        void MacroServiceDeleted(IMacroService sender, Core.Events.DeleteEventArgs<IMacro> e)
+        void MacroServiceDeleted(IMacroService sender, DeleteEventArgs<IMacro> e)
         {
             foreach (var entity in e.DeletedEntities)
             {
@@ -619,33 +511,14 @@ namespace Umbraco.Web.Cache
             }
         }
 
-        void MacroServiceSaved(IMacroService sender, Core.Events.SaveEventArgs<IMacro> e)
+        void MacroServiceSaved(IMacroService sender, SaveEventArgs<IMacro> e)
         {
             foreach (var entity in e.SavedEntities)
             {
                 DistributedCache.Instance.RefreshMacroCache(entity);
             }
         }
-        
-        /// <summary>
-        /// Flush macro from cache
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        static void MacroAfterDelete(Macro sender, DeleteEventArgs e)
-        {
-            DistributedCache.Instance.RemoveMacroCache(sender);
-        }
-
-        /// <summary>
-        /// Flush macro from cache
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        static void MacroAfterSave(Macro sender, SaveEventArgs e)
-        {
-            DistributedCache.Instance.RefreshMacroCache(sender);
-        } 
+  
         #endregion
 
         #region Media event handlers

src/Umbraco.Web/Cache/DistributedCacheExtensions.cs

@@ -648,7 +648,7 @@ namespace Umbraco.Web.Cache
 
         #region Domain Cache
 
-        public static void RefreshDomainCache(this DistributedCache dc, Domain domain)
+        public static void RefreshDomainCache(this DistributedCache dc, IDomain domain)
         {
             if (domain != null)
             {
@@ -656,7 +656,7 @@ namespace Umbraco.Web.Cache
             }
         }
 
-        public static void RemoveDomainCache(this DistributedCache dc, Domain domain)
+        public static void RemoveDomainCache(this DistributedCache dc, IDomain domain)
         {
             if (domain != null)
             {

src/Umbraco.Web/Cache/DomainCacheRefresher.cs

@@ -40,8 +40,6 @@ namespace Umbraco.Web.Cache
 
         private void ClearCache()
         {
-            ApplicationContext.Current.ApplicationCache.ClearCacheItem(CacheKeys.DomainCacheKey);
-
             // SD: we need to clear the routes cache here!             
             //
             // zpqrtbnk: no, not here, in fact the caches should subsribe to refresh events else we

src/umbraco.cms/businesslogic/Packager/Installer.cs

@@ -352,6 +352,7 @@ namespace umbraco.cms.businesslogic.packager
                 #region Macros
                 foreach (XmlNode n in Config.DocumentElement.SelectNodes("//macro"))
                 {
+                    //TODO: Fix this, this should not use the legacy API
                     Macro m = Macro.Import(n);
 
                     if (m != null)

src/umbraco.cms/businesslogic/datatype/DataTypeDefinition.cs

@@ -17,7 +17,7 @@ using Umbraco.Core;
 namespace umbraco.cms.businesslogic.datatype
 {
 
-    
+    //TODO: Wrap as much of this api as possible so that we don't need to listen to legacy events!
 
     /// <summary>
     /// Datatypedefinitions is the basic buildingblocks of umbraco's documents/medias/members generic datastructure 

src/umbraco.cms/businesslogic/macro/Macro.cs

@@ -250,6 +250,8 @@ namespace umbraco.cms.businesslogic.macro
 		    }
 		}
 
+        //TODO: Fix this, this should wrap a new API!
+
         public static Macro Import(XmlNode n)
         {
             var alias = XmlHelper.GetNodeValue(n.SelectSingleNode("alias"));