public override void delete()
        {
            DeleteEventArgs e = new DeleteEventArgs();
            FireBeforeDelete(e);
            if (!e.Cancel)
            {
                //first clear the prevalues
                PreValues.DeleteByDataTypeDefinition(this.Id);

                //next clear out the property types
                var propTypes = PropertyType.GetByDataTypeDefinition(this.Id);
                foreach (var p in propTypes)
                {
                    p.delete();
                }

                //delete the cmsDataType role, then the umbracoNode
                SqlHelper.ExecuteNonQuery("delete from cmsDataType where [email protected]",
                                          SqlHelper.CreateParameter("@nodeId", this.Id));
                base.delete();

                cache.Cache.ClearCacheItem(string.Format("UmbracoDataTypeDefinition{0}", Id));
                FireAfterDelete(e);
            }
        }

 static void MediaServiceDeleting(IMediaService sender, DeleteEventArgs<IMedia> e)
 {
     foreach (var item in e.DeletedEntities)
     {
         library.ClearLibraryCacheForMedia(item.Id);
     }
 }

 void MediaService_Deleted(IMediaService sender, DeleteEventArgs<IMedia> e)
 {
     foreach (IMedia entity in e.DeletedEntities.Where(entity => entity.ContentType.Alias == PPC_2010.Data.Constants.SermonAlias))
     {
         ServiceLocator.Instance.Locate<ISermonRepository>().RefreshSermon(entity.Id, true);
     }
 }

 private void ContentServiceOnDeleted(IContentService sender, DeleteEventArgs<IContent> deleteEventArgs)
 {
     foreach(var deletedEntity in deleteEventArgs.DeletedEntities)
     {
         DeleteEntityIndex(deletedEntity);
     }
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void MediaService_Deleted(IMediaService sender, DeleteEventArgs<IMedia> e)
        {
            if (connection.State != ConnectionState.Open)
            {
                connection.Open();
            }

            foreach (var item in e.DeletedEntities)
            {
                string Resource = item.Name;

                SqlTransaction tran = connection.BeginTransaction();
                var command = new SqlCommand("dbo.[RequestCdnResourceInvalidation]", connection, tran);
                command.CommandType = CommandType.StoredProcedure;

                command.Parameters.Add("@resource", SqlDbType.NVarChar, 256);
                command.Parameters["@resource"].Value = Resource;

                command.Parameters.Add("@ConversationHandle", SqlDbType.UniqueIdentifier);
                command.Parameters["@ConversationHandle"].Direction = ParameterDirection.Output;

                command.ExecuteNonQuery();
                tran.Commit();
            }
        }

 /// <summary>
 /// The entity collection service on deleted.
 /// </summary>
 /// <param name="sender">
 /// The sender.
 /// </param>
 /// <param name="e">
 /// The e.
 /// </param>
 private void EntityCollectionServiceOnDeleted(IEntityCollectionService sender, DeleteEventArgs<IEntityCollection> e)
 {
     if (!EntityCollectionProviderResolver.HasCurrent) return;
     foreach (var collection in e.DeletedEntities)
     {
         EntityCollectionProviderResolver.Current.RemoveFromCache(collection.Key);
     }
 }

        /// <summary>
        /// The warehouse catalog service deleted.
        /// </summary>
        /// <param name="sender">
        /// The sender.
        /// </param>
        /// <param name="deleteEventArgs">
        /// The delete event args.
        /// </param>
        /// <remarks>
        /// The repository will delete the ship countries and the ship methods but we need to clean up any stored in memory
        /// </remarks>
        private void WarehouseCatalogServiceDeleted(IWarehouseCatalogService sender, DeleteEventArgs<IWarehouseCatalog> deleteEventArgs)
        {
            var providers = GatewayProviderResolver.Current.GetActivatedProviders<ShippingGatewayProviderBase>();

            foreach (var provider in providers)
            {
                ((ShippingGatewayProviderBase)provider).ResetShipMethods();
            }
        }

        private void Member_AfterDelete(Member sender, DeleteEventArgs e)
        {
            var nodeId = sender.Id.ToString();

            //ensure that only the providers are flagged to listen execute
            ExamineManager.Instance.DeleteFromIndex(nodeId,
                ExamineManager.Instance.IndexProviderCollection.OfType<BaseUmbracoIndexer>()
                    .Where(x => x.EnableDefaultEventHandler));
        }

        public void Delete() {
            DeleteEventArgs e = new DeleteEventArgs();
            FireBeforeDelete(e);

            if (!e.Cancel) {
                data.Delete(this.Data.Id, IOHelper.MapPath(Settings.CreatedPackagesSettings));
                FireAfterDelete(e);
            }
        }

 private void ContentService_Deleting(IContentService sender, DeleteEventArgs<IContent> e)
 {
     foreach (var entity in e.DeletedEntities)
     {
         string documentType = entity.ContentType.Alias;
         var mapping = MapProvider.Mappings.SingleOrDefault(n => n.DocumentType == documentType);
         if (mapping != null)
             DeleteDocument(mapping, sender, entity);
     }
 }

 /// <summary>
 /// Called when user empties the recycle bin, or an item in the recycle bin is permanently deleted
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="deleteEventArgs"></param>
 private void ContentServiceOnDeleted(IContentService sender, DeleteEventArgs<IContent> deleteEventArgs)
 {
    if (!deleteEventArgs.DeletedEntities.Any()) return;
    foreach (var entity in deleteEventArgs.DeletedEntities)
    {
       DbProvider.RemoveMediaTrack(entity.Id);
       if (_verbose)
       {
          LogHelper.Info<MediaTrackerHandler>(string.Format("All tracking for the page '{0}' was removed because the page was moved to the recycle bin.", entity.Name));
       }
    }
 }

        public override void delete()
        {
            DeleteEventArgs e = new DeleteEventArgs();
            FireBeforeDelete(e);
            if (!e.Cancel) {
                // delete member specific data!
                SqlHelper.ExecuteNonQuery("Delete from cmsMember2MemberGroup where memberGroup = @id",
                    SqlHelper.CreateParameter("@id", Id));

                // Delete all content and cmsnode specific data!
                base.delete();
                FireAfterDelete(e);
            }
        }

 void Document_BeforeDelete(Document doc, DeleteEventArgs e)
 {
     #if !DEBUG
     try
     #endif
     {
         UrlTrackerRepository.DeleteUrlTrackerEntriesByNodeId(doc.Id);
     }
     #if !DEBUG
     catch (Exception ex)
     {
         ex.LogException(doc.Id);
     }
     #endif
 }

    void MemberService_Deleting(IMemberService sender, DeleteEventArgs<IMember> e)
    {
        foreach (var m in e.DeletedEntities)
        {
           var member = ApplicationContext.Current.Services.ContentService.GetById(int.Parse(m.GetValue("lists").ToString()));
           foreach(var lists in member.Children())
           {
               foreach(var list in lists.Children())
               {
                 //  e.MediaFilesToDelete.Add(c.GetValue("image").ToString());
                   ApplicationContext.Current.Services.ContentService.Delete(list);

               }
               ApplicationContext.Current.Services.ContentService.Delete(lists);
           }
        }
    }

        void ContentService_Deleting(IContentService sender, DeleteEventArgs<IContent> e)
        {
            foreach (IContent content in e.DeletedEntities)
            {
#if !DEBUG
                try
#endif
                {
                    UrlTrackerRepository.DeleteUrlTrackerEntriesByNodeId(content.Id);
                }
#if !DEBUG
                catch (Exception ex)
                {
                    ex.LogException();
                }
#endif
            }
        }

        private void Album_deleted(IContentService sender, DeleteEventArgs<IContent> e)
        {
            foreach (IContent node in e.DeletedEntities)
              {
            if (node.ContentType.ContentTypeCompositionExists("Album") || node.ContentType.Alias == "Album")
            {
              int media_level;
              if (node.ContentType.Alias == "Usersubalbum" || node.ContentType.Alias == "Subalbum")
            media_level = 2;
              else
            media_level = 1;

              IMediaService ms = UmbracoContext.Current.Application.Services.MediaService;
              IMedia media = ms.GetByLevel(media_level).Where(x => x.Name == node.Name).First(x => x.ContentType.Alias == "Folder");
              if (media == null)
            return;
              ms.Delete(media);
            }
              }
        }

 protected virtual void FireAfterDelete(DeleteEventArgs e) {
     if (AfterDelete != null)
         AfterDelete(this, e);
 }

 protected virtual void FireBeforeDelete(DeleteEventArgs e) {
     if (BeforeDelete != null)
         BeforeDelete(this, e);
 }

		/// <summary>
		/// Deletes the current macro
		/// </summary>
		public void Delete() 
		{
            //event
            DeleteEventArgs e = new DeleteEventArgs();
            FireBeforeDelete(e);

            if (!e.Cancel) {
                foreach (MacroProperty p in this.Properties)
                    p.Delete();
                SqlHelper.ExecuteNonQuery("delete from cmsMacro where id = @id", SqlHelper.CreateParameter("@id", this._id));

                FireAfterDelete(e);
            }
        }

 static void MemberBeforeDelete(Member sender, DeleteEventArgs e)
 {
     DistributedCache.Instance.RemoveMemberCache(sender.Id);
 }