static void ContentService_Created(IContentService sender, NewEventArgs<IContent> e)
        {
            if (UmbracoContext.Current == null) return;

            if (e.Entity.ContentType.Alias.InvariantEquals("ArticulateRichText")
                || e.Entity.ContentType.Alias.InvariantEquals("ArticulateMarkdown"))
            {
                if (UmbracoContext.Current.Security.CurrentUser != null)
                {
                    e.Entity.SetValue("author", UmbracoContext.Current.Security.CurrentUser.Name);
                }
                e.Entity.SetValue("publishedDate", DateTime.Now);
                e.Entity.SetValue("enableComments", 1);
            }
            else if (e.Entity.ContentType.Alias.InvariantEquals("Articulate"))
            {
                e.Entity.SetValue("theme", "VAPOR");
                e.Entity.SetValue("pageSize", 10);
                e.Entity.SetValue("categoriesUrlName", "categories");
                e.Entity.SetValue("tagsUrlName", "tags");
                e.Entity.SetValue("searchUrlName", "search");
                e.Entity.SetValue("categoriesPageName", "Categories");
                e.Entity.SetValue("tagsPageName", "Tags");
                e.Entity.SetValue("searchPageName", "Search results");
            }
        }

        /// <summary>
        /// Invoke dbo.[SendMemberWelcomePack]
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void MemberService_Created(IMemberService sender, NewEventArgs<IMember> e)
        {
            string Name = e.Entity.Name;
            string Email = e.Entity.Email;

            if (connection.State != System.Data.ConnectionState.Open)
            {
                connection.Open();
            }

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

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

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

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

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

 public static StylesheetProperty MakeNew(string Text, StyleSheet sheet, BusinessLogic.User user) {
     CMSNode newNode = CMSNode.MakeNew(sheet.Id, moduleObjectType, user.Id, 2, Text, Guid.NewGuid());
     SqlHelper.ExecuteNonQuery(String.Format("Insert into cmsStylesheetProperty (nodeId,stylesheetPropertyAlias,stylesheetPropertyValue) values ('{0}','{1}','')", newNode.Id, Text));
     StylesheetProperty ssp = new StylesheetProperty(newNode.Id);
     NewEventArgs e = new NewEventArgs();
     ssp.OnNew(e);
     return ssp;
 }

        public static CreatedPackage MakeNew(string name) {
            CreatedPackage pack = new CreatedPackage();
            pack.Data = data.MakeNew(name, IOHelper.MapPath(Settings.CreatedPackagesSettings));

            NewEventArgs e = new NewEventArgs();
            pack.OnNew(e);
            
            return pack;
        }

 private void cmdDelete_Click(object sender, EventArgs e)
 {
     var d = new NewEventArgs();
     d.LineItemID = UserControlLineItemID;
     d.PriceChange = txtPrice.Text;
     d.QuantityChange = txtQuantity.Text;
     if (this.DeleteClick != null)
         this.DeleteClick(this, d);
 }

        private void txtPrice_LostFocus(object sender, EventArgs e)
        {
            var d = new NewEventArgs();
            d.LineItemID = UserControlLineItemID;
            d.PriceChange = txtPrice.Text;
            d.QuantityChange = txtQuantity.Text;

            if (this.TextChange != null)
                this.TextChange(sender, d);
        }

 void MediaService_Created(IMediaService sender, NewEventArgs<IMedia> e)
 {
     // When a file is created underneath a bulletin folder, change its type to "Bulletin File"
     if (e.Entity.Parent() != null && e.Entity.Parent().ContentType.Alias == "BulletinFolder" && (e.Entity.ContentType.Alias == "File" || e.Entity.ContentType.Alias == "Image"))
     {
         e.Entity.ChangeContentType(ApplicationContext.Current.Services.ContentTypeService.GetMediaType("BulletinFile"));
     }
     // When a file is created underneath a Manual folder, change its type to "Manual File"
     if (e.Entity.Parent() != null && e.Entity.Parent().ContentType.Alias == "ManualFolder" && (e.Entity.ContentType.Alias == "File" || e.Entity.ContentType.Alias == "Image"))
     {
         e.Entity.ChangeContentType(ApplicationContext.Current.Services.ContentTypeService.GetMediaType("ManualFile"));
     }
 }

		/// <summary>
		/// Create a new MemberType
		/// </summary>
		/// <param name="Text">The name of the MemberType</param>
		/// <param name="u">Creator of the MemberType</param>
		public static MemberType MakeNew(User u,string Text) 
		{		
			int ParentId= -1;
			int level = 1;
			Guid uniqueId = Guid.NewGuid();
			CMSNode n = CMSNode.MakeNew(ParentId, _objectType, u.Id, level,Text, uniqueId);

			ContentType.Create(n.Id, Text,"");
	        MemberType mt = new MemberType(n.Id);
		    mt.IconUrl = "member.gif";
            NewEventArgs e = new NewEventArgs();
            mt.OnNew(e);

            return mt; 
		}

        /// <summary>
        /// Creates a new Media
        /// </summary>
        /// <param name="Name">The name of the media</param>
        /// <param name="dct">The type of the media</param>
        /// <param name="u">The user creating the media</param>
        /// <param name="ParentId">The id of the folder under which the media is created</param>
        /// <returns></returns>
        public static Media MakeNew(string Name, MediaType dct, BusinessLogic.User u, int ParentId)
        {
            Guid newId = Guid.NewGuid();
            // Updated to match level from base node
            CMSNode n = new CMSNode(ParentId);
            int newLevel = n.Level;
            newLevel++;
            CMSNode.MakeNew(ParentId, _objectType, u.Id, newLevel, Name, newId);
            Media tmp = new Media(newId);
            tmp.CreateContent(dct);

            NewEventArgs e = new NewEventArgs();
            tmp.OnNew(e);

            return tmp;
        }

 void Member_New(Member sender, NewEventArgs e)
 {
     //This is a bit of a hack to ensure that the member is approved when created since many people will be using
     // this old api to create members on the front-end and they need to be approved - which is based on whether or not 
     // the Umbraco membership provider is configured.
     var provider = Membership.Provider as UmbracoMembershipProvider;
     if (provider != null)
     {
         var approvedField = provider.ApprovedPropertyTypeAlias;
         var property = sender.getProperty(approvedField);
         if (property != null)
         {
             property.Value = 1;
         }
     }            
 }

        public static Media MakeNew(string Name, MediaType dct, BusinessLogic.User u, int ParentId)
        {
            var e = new NewEventArgs();
            OnNewing(e);
            if (e.Cancel)
            {
                return null;
            }

            var media = ApplicationContext.Current.Services.MediaService.CreateMedia(Name, ParentId, dct.Alias, u.Id);
            //The media object will only have the 'WasCancelled' flag set to 'True' if the 'Creating' event has been cancelled
            if (((Entity)media).WasCancelled)
                return null;

            ApplicationContext.Current.Services.MediaService.Save(media);
            var tmp = new Media(media);

            tmp.OnNew(e);

            return tmp;
        }

        public static DocumentType MakeNew(User u, string Text)
        {
            var contentType = new Umbraco.Core.Models.ContentType(-1) { Name = Text, Alias = Text, CreatorId = u.Id, Thumbnail = "folder.png", Icon = "folder.gif" };
            ApplicationContext.Current.Services.ContentTypeService.Save(contentType, u.Id);
            var newDt = new DocumentType(contentType);

            //event
            NewEventArgs e = new NewEventArgs();
            newDt.OnNew(e);

            return newDt;
        }

        public static void MakeNew(string DomainName, int RootNodeId, int LanguageId)
        {
            if (Exists(DomainName.ToLower()))
                throw new Exception("Domain " + DomainName + " already exists!");
            
            //need to check if the language exists first
            if (Language.GetAllAsList().SingleOrDefault(x => x.id == LanguageId) == null)
            {
                throw new ArgumentException("No language exists for the LanguageId specified");
            }
                
            SqlHelper.ExecuteNonQuery("insert into umbracoDomains (domainDefaultLanguage, domainRootStructureID, domainName) values (@domainDefaultLanguage, @domainRootStructureID, @domainName)",
                                      SqlHelper.CreateParameter("@domainDefaultLanguage", LanguageId),
                                      SqlHelper.CreateParameter("@domainRootStructureID", RootNodeId),
                                      SqlHelper.CreateParameter("@domainName", DomainName.ToLower()));

            var e = new NewEventArgs();
            new Domain(DomainName).OnNew(e);
        }

 void Domain_New(Domain sender, NewEventArgs e)
 {
     UmbracoHelper.ClearDomains();
 }

        public static Member MakeNew(string Name, string LoginName, string Email, MemberType mbt, User u)
        {
            var loginName = (!String.IsNullOrEmpty(LoginName)) ? LoginName : Name;

            if (String.IsNullOrEmpty(loginName))
                throw new ArgumentException("The loginname must be different from an empty string", "loginName");

            // Test for e-mail
            if (Email != "" && Member.GetMemberFromEmail(Email) != null)
                throw new Exception(String.Format("Duplicate Email! A member with the e-mail {0} already exists", Email));
            else if (Member.GetMemberFromLoginName(loginName) != null)
                throw new Exception(String.Format("Duplicate User name! A member with the user name {0} already exists", loginName));

            Guid newId = Guid.NewGuid();

            //create the cms node first
            CMSNode newNode = MakeNew(-1, _objectType, u.Id, 1, Name, newId);

            //we need to create an empty member and set the underlying text property
            Member tmp = new Member(newId, true);
            tmp.SetText(Name);

            //create the content data for the new member
            tmp.CreateContent(mbt);

            // Create member specific data ..
            SqlHelper.ExecuteNonQuery(
                "insert into cmsMember (nodeId,Email,LoginName,Password) values (@id,@email,@loginName,'')",
                SqlHelper.CreateParameter("@id", tmp.Id),
                SqlHelper.CreateParameter("@loginName", loginName),
                SqlHelper.CreateParameter("@email", Email));

            //read the whole object from the db
            Member m = new Member(newId);

            NewEventArgs e = new NewEventArgs();

            m.OnNew(e);

            m.Save();

            return m;
        }

        internal static MediaType MakeNew(BusinessLogic.User u, string text, int parentId)
        {
            var mediaType = new Umbraco.Core.Models.MediaType(parentId) { Name = text, Alias = text, CreatorId = u.Id, Thumbnail = "folder.png", Icon = "folder.gif" };
            ApplicationContext.Current.Services.ContentTypeService.Save(mediaType, u.Id);
            var mt = new MediaType(mediaType.Id);

            NewEventArgs e = new NewEventArgs();
            mt.OnNew(e);

            return mt;
        }

        public static Template MakeNew(string Name, BusinessLogic.User u)
        {
            //ensure unique alias
            if (GetByAlias(Name) != null)
                Name = EnsureUniqueAlias(Name, 1);

            // CMSNode MakeNew(int parentId, Guid objectType, int userId, int level, string text, Guid uniqueID)
            CMSNode n = CMSNode.MakeNew(-1, _objectType, u.Id, 1, Name, Guid.NewGuid());
            Name = Name.Replace("/", ".").Replace("\\", "");

            if (Name.Length > 100)
                Name = Name.Substring(0, 95) + "...";

            SqlHelper.ExecuteNonQuery("INSERT INTO cmsTemplate (NodeId, Alias, design, master) VALUES (@nodeId, @alias, @design, @master)",
                                      SqlHelper.CreateParameter("@nodeId", n.Id),
                                      SqlHelper.CreateParameter("@alias", Name),
                                      SqlHelper.CreateParameter("@design", ' '),
                                      SqlHelper.CreateParameter("@master", DBNull.Value));

            Template t = new Template(n.Id);
            NewEventArgs e = new NewEventArgs();
            t.OnNew(e);

            return t;
        }

		public static Macro MakeNew(string Name) 
		{
            int macroId = 0;
            // The method is synchronized
            SqlHelper.ExecuteNonQuery("INSERT INTO cmsMacro (macroAlias, macroName) values (@macroAlias, @macroName)",
                SqlHelper.CreateParameter("@macroAlias", Name.Replace(" ", String.Empty)),
                SqlHelper.CreateParameter("@macroName", Name));
            macroId = SqlHelper.ExecuteScalar<int>("SELECT MAX(id) FROM cmsMacro");

            Macro newMacro = new Macro(macroId);
           
            //fire new event
            NewEventArgs e = new NewEventArgs();
            newMacro.OnNew(e);
            
            return newMacro;
		}

 /// <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);
 }

        public static StyleSheet MakeNew(BusinessLogic.User user, string Text, string FileName, string Content)
        {

            // Create the umbraco node
            var newNode = CMSNode.MakeNew(-1, ModuleObjectType, user.Id, 1, Text, Guid.NewGuid());

            // Create the stylesheet data
            SqlHelper.ExecuteNonQuery(string.Format("insert into cmsStylesheet (nodeId, filename, content) values ('{0}','{1}',@content)", newNode.Id, FileName), SqlHelper.CreateParameter("@content", Content));

            // save to file to avoid file coherency issues
            var newCss = new StyleSheet(newNode.Id, false, false);
            var e = new NewEventArgs();
            newCss.OnNew(e);

            return newCss;
        }