protected virtual string GetPropertyValueInternal( DynamicNode model, string propertyAlias, bool recursive )
        {
            string strValue = "";

              if ( model != null && !string.IsNullOrEmpty( propertyAlias ) ) {
            IProperty property = null;

            if ( !recursive ) {
              property = model.GetProperty( propertyAlias );
            } else {
              DynamicNode tempModel = model;
              IProperty tempProperty = tempModel.GetProperty( propertyAlias );
              if ( tempProperty != null && !string.IsNullOrEmpty( tempProperty.Value ) ) {
            property = tempProperty;
              }

              while ( property == null && tempModel != null && tempModel.Id > 0 ) {
            tempModel = tempModel.Parent;
            if ( tempModel != null ) {
              tempProperty = tempModel.GetProperty( propertyAlias );
              if ( tempProperty != null && !string.IsNullOrEmpty( tempProperty.Value ) ) {
                property = tempProperty;
              }
            }
              }
            }

            if ( property != null ) {
              strValue = property.Value;
            }
              }

              return strValue;
        }

        public virtual string GetPropertyValue( DynamicNode model, string propertyAlias, Func<DynamicNode, bool> func = null )
        {
            string rtnValue = "";

              if ( model != null && !string.IsNullOrEmpty( propertyAlias ) ) {
            //Check if this node or ancestor has it
            DynamicNode currentNode = func != null ? model.AncestorOrSelf( func ) : model;
            if ( currentNode != null ) {
              rtnValue = GetPropertyValueInternal( currentNode, propertyAlias, func == null );
            }

            //Check if we found the value
            if ( string.IsNullOrEmpty( rtnValue ) ) {

              //Check if we can find a master relation
              string masterRelationNodeId = GetPropertyValueInternal( model, Constants.ProductPropertyAliases.MasterRelationPropertyAlias, true );
              if ( !string.IsNullOrEmpty( masterRelationNodeId ) ) {
            rtnValue = GetPropertyValue( new DynamicNode( masterRelationNodeId ), propertyAlias, func );
              }

            }
              }

              return rtnValue;
        }

        public HelperResult ApplyTemplate(DynamicNode node, string mode)
        {
            Func<DynamicNode, string, HelperResult> template;

            //if we are not in debug mode we should use the cached templates
            //please remember to restart your application if you do any template
            //changes in production (for files in App_Code this will happen automatically)
            if (!_debugMode)
            {
                var key = new CacheKey { NodeTypeAlias = node.NodeTypeAlias, Mode = mode };
                if (_templatesCache.ContainsKey(key))
                {
                    template = _templatesCache[key];
                }
                else
                {
                    template = GetTemplate(node.NodeTypeAlias, mode);
                    _templatesCache.Add(key, template);
                }
            }
            else
            {
                template = GetTemplate(node.NodeTypeAlias, mode);
            }

            return template(node, mode);
        }

        private int createFolderScructure(DateTime dt, DynamicNode stream)
        {
            var names = new string[] {dt.Year.ToString(), dt.Month.ToString(), dt.Day.ToString()};

            var cs = new ContentService();
            var current = stream;
            var lookUp = true;

            foreach (var name in names)
            {
                if (lookUp)
                {

                    var exists = current.Children.Where(x => x.Name == name).FirstOrDefault();
                    if (exists == null)
                    {
                        lookUp = false;
                        var node = cs.CreateContent(name, current.Id, "Folder");
                        cs.SaveAndPublish(node);

                        Thread.Sleep(2000);
                        current = current.Children.Where(x => x.Name == name).FirstOrDefault();
                    }
                }
                else
                {
                    var node = cs.CreateContent(name, current.Id, "Folder");
                    cs.SaveAndPublish(node);
                    current = current.Children.Where(x => x.Name == name).FirstOrDefault();
                }
            }

            return current.Id;
        }

        public virtual DynamicXml GetXmlPropertyValue( DynamicNode model, string propertyAlias, Func<DynamicNode, bool> func = null )
        {
            DynamicXml xmlNode = null;
              string propertyValue = GetPropertyValue( model, propertyAlias, func );

              if ( !string.IsNullOrEmpty( propertyValue ) ) {
            xmlNode = new DynamicXml( XElement.Parse( propertyValue, LoadOptions.None ) );
              }

              return xmlNode;
        }

        public static string GetBattleTagByNodeID(int id)
        {
            DynamicNode profile = new DynamicNode(id);
            string battletag = null;

            if(profile.NodeTypeAlias == BattleTagProfile.documentTypeAlias)
            {
                battletag = profile.Name;
                return battletag;
            }
            else
            {
                return battletag;
            }
        }

        public static BlogPost Get(DynamicNodeContext nodeContext, int postId = -1)
        {
            if (postId == -1)
            {
                postId = GetBlogPostId();
            }

            if (postId <= 0)
            {
                return GetEmptyPost();
            }

            var post = new DynamicNode(postId);

            return MapToBlogPost(post);
        }

        public static List<RelatedLink> GetRelatedLinks(string property, DynamicNode model)
        {
            var rlinks = new List<RelatedLink>();

            if (string.IsNullOrEmpty(model.GetPropertyValue(property)))
            {
                return rlinks;
            }

            foreach (var item in (IEnumerable<dynamic>)JsonConvert.DeserializeObject(model.GetPropertyValue(property)))
            {
                var result = new RelatedLink();
                result.Url = (bool)item.isInternal ? new DynamicNode(item["internal"]).Url : item.link;
                result.Target = (bool)item.newWindow ? "_blank" : null;
                result.Caption = item.caption;
                rlinks.Add(result);
            }

            return rlinks;
        }

        /// <summary>
        /// The site map.
        /// </summary>
        /// <param name="renderModel">
        /// The render model.
        /// </param>
        /// <returns>
        /// The <see cref="ActionResult"/>.
        /// </returns>
        public ActionResult SiteMapTemplate(RenderModel renderModel)
        {
            List<SiteMapViewModel> sitemapElements = new List<SiteMapViewModel>();

            DynamicNode homepage = new DynamicNode(1089);

            if (homepage.GetProperty("showInSiteMap") != null && homepage.GetProperty("showInSiteMap").Value == "1")
            {
                sitemapElements.Add(new SiteMapViewModel { Url = homepage.Url, LastModified = homepage.UpdateDate });
            }

            DynamicNodeList sitemapPages =
                homepage.Descendants(
                    n => n.GetProperty("showInSiteMap") != null && n.GetProperty("showInSiteMap").HasValue() && n.GetProperty("showInSiteMap").Value == "1");

            foreach (DynamicNode page in sitemapPages)
            {
                sitemapElements.Add(new SiteMapViewModel { Url = page.Url, LastModified = page.UpdateDate });
            }

            return this.View("SiteMapTemplate", sitemapElements);
        }

    protected void Page_Load(object sender, EventArgs e)
    {
        currentNode = new DynamicNode(Node.getCurrentNodeId());
        heroPageUrl = "/profile/heroes/hero.aspx";

        if (!Page.IsPostBack && !string.IsNullOrEmpty(Request.QueryString["id"]))
        {

            profile = new DynamicNode(Convert.ToInt32(Request.QueryString["id"]));

            //check if profile has heroes else show the download heroes panel
            if (!profile.Descendants(x => x.NodeTypeAlias == Hero.documentTypeAlias).IsNull())
            {
                rViewHeroes.DataSource = profile.Descendants(Hero.documentTypeAlias);
                rViewHeroes.DataBind();
            }
            else
            {

            }
        }
    }

 public bool IsAncestorOrSelf(DynamicNode other)
 {
     var descendants = this.DescendantsOrSelf();
     return IsHelper(n => descendants.Items.Find(descendant => descendant.Id == other.Id) != null);
 }

 public HtmlString IsDescendantOrSelf(DynamicNode other, string valueIfTrue, string valueIfFalse)
 {
     var ancestors = this.AncestorsOrSelf();
     return IsHelper(n => ancestors.Items.Find(ancestor => ancestor.Id == other.Id) != null, valueIfTrue, valueIfFalse);
 }

 public HtmlString IsNotEqual(DynamicNode other, string valueIfTrue, string valueIfFalse)
 {
     return IsHelper(n => n.Id != other.Id, valueIfTrue, valueIfFalse);
 }

 public static HelperResult Render(DynamicNode node, string mode = "")
 {
     return RazorScaffoldCore.Instance.ApplyTemplate(node, mode);
 }

 public static DynamicNode GetHomeNodeStrongTyped(DynamicNode model)
 {
     return model.AncestorOrSelf("Home");
 }

 /// <summary>Get URL by content item.</summary>
 public static string GetUrl(Object id)
 {
     var cmsItem = new DynamicNode(id);
     var url = GetUrl(cmsItem);
     return String.IsNullOrEmpty(url) ? null : url;
 }

 public static dynamic GetNodeByNameRelative(DynamicNode model, string name)
 {
     return model.Descendants(
         x => string.Compare(x.Name, name, StringComparison.OrdinalIgnoreCase) == 0).Items.FirstOrDefault();
 }

    private static string ReplaceUmbracoLinks(string macroTagString)
    {
        var regex = new Regex("{localLink:[0-9]+}", RegexOptions.Multiline | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
        var matches = regex.Matches(macroTagString);

        foreach (Match match in matches)
        {

            var regexNum = new Regex(@"\d+");
            var matchesNum = regexNum.Matches(match.ToString());

            if (matchesNum.Count > 0)
            {
                DynamicNode node = new DynamicNode(matchesNum[0].Value);
                string url = node.Url;
                url = url.Remove(0, 1);
                macroTagString = macroTagString.Replace(match.ToString(), url);
            }
        }

        return macroTagString;
    }

 private static BlogPost MapToBlogPost(DynamicNode post)
 {
     return new BlogPost
         {
             Id = post.Id,
             Author = GetAuthor(post.GetPropertyValue("uBlogsyPostAuthor")),
             Date = DateTime.Parse(post.GetPropertyValue("uBlogsyPostDate", DateTime.UtcNow.ToString("dd MMM yyyy"))).ToString("dd MMM yyyy"),
             Title = post.GetPropertyValue("uBlogsyContentTitle", "Sorry, nothing found").Wikify(),
             Summary = post.GetPropertyValue("uBlogsyContentSummary", "Sorry, nothing found").Wikify(),
             Content = post.GetPropertyValue("uBlogsyContentBody", "Sorry, nothing found").Wikify(),
             Image = GetImageUrl(post.GetPropertyValue("uBlogsyPostImage"))
         };
 }

        public static string GetTitle(this DynamicNode dynamicNode)
        {
            dynamic node = new DynamicNode(dynamicNode.Id);

            return Util.Coalesce(node.NavivationTitle.ToString(), node.PageTitle.ToString(), node.Name.ToString());
        }