public override void PackagingDataType(Umbraco.Courier.ItemProviders.DataType item)
        {
            //to ensure UI is there, include the digibiz folder of files
            item.Dependencies.Add("~/umbraco/plugins/DigibizAdvancedMediaPicker", Umbraco.Courier.ItemProviders.ProviderIDCollection.folderItemProviderGuid);
            item.Resources.Add("~/bin/DigibizTree.dll");

            var source = item.Prevalues.Where(x => x.SortOrder == 2).FirstOrDefault();
            var defaultType = item.Prevalues.Where(x => x.SortOrder == 13).FirstOrDefault();

            List<string> foundNodes = new List<string>();
            if (source != null && source.Value != null){
                source.Value = Dependencies.ConvertIdentifierCollection(source.Value.ToString(), out foundNodes);

                foreach (var g in foundNodes)
                    item.Dependencies.Add(g, ProviderIDCollection.mediaItemProviderGuid);

            }

            if (defaultType != null && defaultType.Value != null)
            {
                defaultType.Value = Dependencies.ConvertIdentifierCollection(defaultType.Value.ToString(), out foundNodes);

                foreach (var g in foundNodes)
                    item.Dependencies.Add(g, ProviderIDCollection.mediaTypeItemProviderGuid);
            }
        }

        /// <summary>
        /// Hi hacjking in progress! WE are going to search here
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public override System.Web.Mvc.ActionResult Index(Umbraco.Web.Models.RenderModel model)
        {
            //the incoming search term
            string incomingSearch = Request.QueryString["query"];

            //search result model
            var searchResultsToReturn = new SearchPageModel();

            //let's check if the incoming string is empty or not
            if (!string.IsNullOrEmpty(incomingSearch))
            {
                //let's get the searcher
                var umbBookSearch = Examine.ExamineManager.Instance.SearchProviderCollection["UmbBookSearchSearcher"];

                //do some searching
                var searchResults = umbBookSearch.Search(incomingSearch, true);

                foreach (var item in searchResults)
                {
                    SearchResultModel searchResult = new SearchResultModel();
                    searchResult.Name = item.Fields["nodeName"];
                    searchResult.UserId = item.Fields["id"];
                    searchResultsToReturn.Results.Add(searchResult);
                }

            }

            return CurrentTemplate(searchResultsToReturn);
        }

        /// <summary>
        /// Copies first name, last name and email address from saved member to Merchello customer.
        /// </summary>
        /// <param name="sender">
        /// The <see cref="IMemberService"/>.
        /// </param>
        /// <param name="e">
        /// The saved <see cref="IMember"/>s.
        /// </param>
        private static void MemberServiceSaved(IMemberService sender, Umbraco.Core.Events.SaveEventArgs<Umbraco.Core.Models.IMember> e)
        {
            var members = e.SavedEntities.ToArray();

            // Allowed member types for Merchello customers
            var customerMemberTypes = MerchelloConfiguration.Current.CustomerMemberTypes.ToArray();

            // Get a reference to Merchello's customer service
            var customerService = MerchelloContext.Current.Services.CustomerService;

            foreach (var member in members)
            {
                // verify the member is a customer type
                if (!customerMemberTypes.Contains(member.ContentTypeAlias)) continue;

                var customer = customerService.GetByLoginName(member.Username);
                if (customer == null) continue;

                customer.FirstName = member.GetValue<string>("firstName") ?? string.Empty;
                customer.LastName = member.GetValue<string>("lastName") ?? string.Empty;
                customer.Email = member.Username;

                customerService.Save(customer);
            }
        }

        /// <summary>
        /// Gets the property.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="config">The config.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public override object GetProperty(Umbraco.Core.Models.Property property, UmbracoPropertyConfiguration config, UmbracoDataMappingContext context)
        {
            if (property == null || property.Value == null)
                return null;

            var mediaService = new MediaService(new RepositoryFactory());
            int id;

            if (!int.TryParse(property.Value.ToString(), out id))
                return null;

            var file = mediaService.GetById(id);

            if (file != null)
            {
                int bytes;
                int.TryParse(file.Properties["umbracoBytes"].Value.ToString(), out bytes);

                var img = new File
                    {
                        Id = file.Id,
                        Name = file.Name,
                        Src = file.Properties["umbracoFile"].Value.ToString(),
                        Extension = file.Properties["umbracoExtension"].Value.ToString(),
                        Size = bytes
                    };
                return img;
            }

            return null;
        }

        void ContentServicePublished(Umbraco.Core.Publishing.IPublishingStrategy sender, Umbraco.Core.Events.PublishEventArgs<IContent> e)
        {
            // when something is published, (if it's a ForumPost)
            // clear the relevant forum cache.
            // we do it in two steps because more than one post in a forum
            // may have been published, so we only need to clear the cache
            // once.

            List<string> invalidCacheList = new List<string>();

            foreach (var item in e.PublishedEntities)
            {
                // is a forum post...
                if (item.ContentTypeId == postContentTypeId)
                {
                    // get parent Forum.
                    invalidCacheList = AddParentForumCaches(item, invalidCacheList);
                }
            }

            // clear the cache for any forums that have had child pages published...
            foreach (var cache in invalidCacheList)
            {
                LogHelper.Info<SimpilyForumCacheHandler>("Clearing Forum Info Cache: {0}", () => cache);
                ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(cache);
            }
        }

 private void ContentService_Creating(IContentService sender, Umbraco.Core.Events.NewEventArgs<IContent> e)
 {
     //if (e.Alias == "SOSU-Nyhed")
     //{
     //    e.Entity.SetValue("contentDate", DateTime.Now);
     //    //                e.Entity.SetValue("umbracoNaviHide", true);
     //}
 }

 void MediaService_Trashing(IMediaService sender, Umbraco.Core.Events.MoveEventArgs<IMedia> e)
 {
     SourceInfo.Load();
     LogHelper.Info<MediaEvents>("Archiving {0}", () => e.Entity.Name); 
     MediaExporter me = new MediaExporter();
     me.Archive(e.Entity);
     SourceInfo.Save(); 
 }

        /// <summary>
        ///  when something is deleted it's plopped in the recycle bin
        /// </summary>
        void ContentService_Trashing(IContentService sender, Umbraco.Core.Events.MoveEventArgs<IContent> e)
        {
            LogHelper.Info<ContentEvents>("Trashing {0}", () => e.Entity.Name);
            ArchiveContentItem(e.Entity);



        }

 public override ActionResult Index(Umbraco.Web.Models.RenderModel model)
 {
     var image = _imageRepository.GetCurrentAndNextImage();
     var homePageModel = new ImagePageModel();
     homePageModel.CurrentImage = image.Item1;
     homePageModel.NextImage = image.Item2;
     ViewBag.ImageWidth = homePageModel.CurrentImage.Width;
     return View(@"~\Views\Home.cshtml", homePageModel);
 }

 private void DataTypeService_Saved(Umbraco.Core.Services.IDataTypeService sender, Umbraco.Core.Events.SaveEventArgs<IDataTypeDefinition> e)
 {
     var types = CodeFirstManager.Current.Modules.DataTypeModule.DataTypeRegister.GetTypesByDataTypeDefinitionIds(e.SavedEntities.Select(x => x.Id));
     foreach (var type in types)
     {
         List<PreValue> val;
         _cache.TryRemove(type, out val); //invalidate any prevalue cache so prevalues are refreshed when next needed
     }
 }

 void ContentService_Published(Umbraco.Core.Publishing.IPublishingStrategy sender, Umbraco.Core.Events.PublishEventArgs<IContent> e)
 {
     foreach (var item in e.PublishedEntities.Where(x => x.ContentType.Alias == "Project"))
     {
         if (item.GetValue<bool>("projectLive"))
         {
             UpdateProjectExamineIndex(item);
         }
     }
 }

        public override System.Web.Mvc.ActionResult Index(Umbraco.Web.Models.RenderModel model)
        {
            MembersWallModel membersWall = new MembersWallModel();

            if (User.Identity.IsAuthenticated)
            {
                //lets get the user id either from the query or the current user
                int userIdToView;
                int userCurrentUser = _myHelper.getBrowsingUserId();
                if (!Int32.TryParse(Request.Params.Get("id"), out userIdToView) || userIdToView == 0)
                {
                    userIdToView = userCurrentUser;
                }

                //store the user we are going to use
                var user = _memberService.GetById(userIdToView);
                //flag it if the browsing user is looking at his own profile
                if (userCurrentUser == userIdToView)
                {
                    membersWall.isThisHisOwnWall = true;
                }

                //store the basic info
                membersWall.owner = user;

                //lets add the profile image to the user

                //first we need the relation type
                IRelationType relationTypeToFetch = _relationService.GetRelationTypeByAlias("memberToProfileImage");

                //lets try to find a relationship between the member and some profile picture
                var memberToProfileImageRelation = _relationService.GetAllRelationsByRelationType(relationTypeToFetch.Id).Where(x => x.ParentId == membersWall.owner.Id);

                //get all the pictures
                var profileImageToUseRelation = memberToProfileImageRelation.Select(x => Umbraco.TypedMedia(x.ChildId));

                //select the newest picture and get the url for it
                var profileImageToUseMedia = profileImageToUseRelation.OrderByDescending(x => x.CreateDate);

                if (profileImageToUseMedia.Count() > 0)
                {
                    if (profileImageToUseMedia.First() != null)
                    {
                        membersWall.profileImage = profileImageToUseMedia.First().Url;
                    }
                }

            }
            else
            {
                return PartialView("MemberLogin");
            }

            return CurrentTemplate(membersWall);
        }

        void ContentService_Deleted(IContentService sender, Umbraco.Core.Events.DeleteEventArgs<Umbraco.Core.Models.IContent> e)
        {
            var fs = new ForumService(ApplicationContext.Current.DatabaseContext);
            foreach (var ent in e.DeletedEntities.Where(x => x.ContentType.Alias == "Forum"))
            {

                var f = fs.GetById(ent.Id);
                if (f != null)
                    fs.Delete(f);
            }
        }

        internal Property(Umbraco.Core.Models.Property property)
        {
            _id = property.Id;
            _property = property;
            _propertyType = property.PropertyType;

            //Just to ensure that there is a PropertyType available
            _pt = PropertyType.GetPropertyType(property.PropertyTypeId);
            _data = _pt.DataTypeDefinition.DataType.Data;
            _data.PropertyId = Id;
        }

 void FormStorage_Deleted(object sender, Umbraco.Forms.Core.FormEventArgs e)
 {
     // If this Form was stored in a Folder, remove it.
     var form = e.Form;
     var folder = PerplexFolder.Get(f => f.Forms.Any(fid => fid == form.Id.ToString()));
     if (folder != null)
     {
         folder.Forms.Remove(form.Id.ToString());
         PerplexFolder.SaveAll();
     }
 }

        public static void FileService_SavedScript(Umbraco.Core.Services.IFileService sender, Umbraco.Core.Events.SaveEventArgs<Umbraco.Core.Models.Script> e)
        {
            // save triggered - need to work out for what
            foreach (var thing in e.SavedEntities)
            {
                string path = string.Format("~/usync6/{0}/{1}", thing.GetRealType().ToString(), thing.Name ) ;
                string realpath = Umbraco.Core.IO.IOHelper.MapPath(path);

                if (!Directory.Exists(realpath))
                    Directory.CreateDirectory(realpath); 
            }
        }

 public void ContentService_Published(Umbraco.Core.Publishing.IPublishingStrategy sender, Umbraco.Core.Events.PublishEventArgs<Umbraco.Core.Models.IContent> e)
 {
     foreach (var node in e.PublishedEntities)
     {
         if (node.ContentType.Alias.Equals("Box"))
         {
             // Ugh, restart the application to make the route table update, there must be a better way and this won't work in LB environment
             var webConfigPath = HttpContext.Current.Request.PhysicalApplicationPath + "\\\\Web.config";
             System.IO.File.SetLastWriteTimeUtc(webConfigPath, DateTime.UtcNow);
         }
     }
 }

 public static void RewriteUrl(Umbraco.Core.Models.IContent entity, IContentService contentService)
 {
     switch (entity.ContentType.Alias)
     {
         case "People":
             RewritePeople(entity, contentService);
             break;
         case "Person":
             RewritePerson(entity, contentService);
             break;
     }
 }

 private void CacheAfterUnPublishNode(Umbraco.Core.Publishing.IPublishingStrategy sender, Umbraco.Core.Events.PublishEventArgs<IContent> e)
 {
     var motos = e.AsEnumerableOfOne();
     foreach(var moto in motos)
     {
         if(moto.PublishedEntities.Any(z => z.Ancestors().Any(node => node.ContentType.Alias == "Catalog")))
         {
             HttpContext.Current.Cache.Remove("Models");
             HttpContext.Current.Cache.Remove("Motos");
             continue;
         }
     }
 }

 private void DocumentAfterSaving(IContentService sender, Umbraco.Core.Events.SaveEventArgs<Umbraco.Core.Models.IContent> e)
 {
     foreach (var item in e.SavedEntities)
     {
         if (item.ContentType.Alias == "Bike" && String.IsNullOrWhiteSpace(item.Properties["utpText"].Value.ToString()))
         {
             var umbracoHelper = Moto.UmbracoHelper;
             var settingsNode = umbracoHelper.TypedContentSingleAtXPath("/root/sysSiteSettings");
             var contentForUtp = settingsNode.GetPropertyValue<string>("contentForUtp");
             item.SetValue("utpText", contentForUtp);
         }
     }
 }