C# IPublishedContent.HasValue方法代码示例

        public static PortfolioItem GetFromContent(IPublishedContent content)
        {
            if (content == null) return null;

            string[] catArr = content.HasValue("categories") ? content.GetPropertyValue<string>("categories").Split(',') : null;

            return new PortfolioItem
            {
                Headline = content.GetPropertyValue<string>("headline"),
                Tags = "Not implented",
                Image = content.HasValue("overviewImage") ? content.TypedMedia("overviewImage") : null,
                Url = content.Url,
                CategoryClasses = catArr != null ? String.Join(" ", catArr) : ""
            };
        }

 /// <summary>
 /// Gets the path to the currently assigned theme.
 /// </summary>
 /// <param name="model">
 /// The <see cref="IMasterModel"/>.
 /// </param>
 /// <returns>
 /// The <see cref="string"/> representing the path to the starter kit theme folder.
 /// </returns>
 public static string GetThemePath(IPublishedContent model)
 {
     const string Path = "~/App_Plugins/Merchello.Bazaar/Themes/{0}/";
     return model.HasProperty("theme") && model.HasValue("theme") ? 
         string.Format(Path, model.GetPropertyValue<string>("theme")) :
         string.Empty;
 }

        public static string TitleTag(IPublishedContent currentPage)
        {
            if (currentPage.HasProperty(Up.Mixins.Seo.TitleTag) && currentPage.HasValue(Up.Mixins.Seo.TitleTag)) { return currentPage.GetPropertyValue<string>(Up.Mixins.Seo.TitleTag); }

            if (currentPage.Level > 1) { return currentPage.Name; }

            return Settings.DefaultTitleTag;
        }

        public SimpleDataSet MapProjectToSimpleDataIndexItem(IPublishedContent project, SimpleDataSet simpleDataSet, string indexType,
            int karma, IEnumerable<WikiFile> files, int downloads, IEnumerable<string> compatVersions)
        {
            simpleDataSet.NodeDefinition.NodeId = project.Id;
            simpleDataSet.NodeDefinition.Type = indexType;

            var desciption = project.GetPropertyValue<string>("description");
            if (!string.IsNullOrEmpty(desciption))
            {
                simpleDataSet.RowData.Add("body", umbraco.library.StripHtml(desciption));
            }
            simpleDataSet.RowData.Add("nodeName", project.Name);
            simpleDataSet.RowData.Add("updateDate", project.UpdateDate.ToString("yyyy-MM-dd HH:mm:ss"));
            simpleDataSet.RowData.Add("createDate", project.CreateDate.ToString("yyyy-MM-dd HH:mm:ss"));
            simpleDataSet.RowData.Add("nodeTypeAlias", "project");
            simpleDataSet.RowData.Add("url", project.Url );
            simpleDataSet.RowData.Add("uniqueId", project.GetPropertyValue<string>("packageGuid"));
            simpleDataSet.RowData.Add("worksOnUaaS", project.GetPropertyValue<string>("worksOnUaaS"));

            var imageFile = string.Empty;
            if (project.HasValue("defaultScreenshotPath"))
            {
                imageFile = project.GetPropertyValue<string>("defaultScreenshotPath");
            }
            if(string.IsNullOrWhiteSpace(imageFile))
            {
                var image = files.FirstOrDefault(x => x.FileType == "screenshot");
                if (image != null)
                    imageFile = image.Path;
            }
            //Clean up version data before its included in the index
            int o;
            var version = project.GetProperty("compatibleVersions").Value;
            var versions = version.ToString().ToLower()
                            .Replace("nan", "")
                            .Replace("saved", "")
                            .Replace("v", "")
                            .Trim(',').Split(',')
                            .Where(x => int.TryParse(x, out o))
                            .Select(x => (decimal.Parse(x.PadRight(3, '0') ) / 100));

            //popularity for sorting number = downloads + karma * 100;
            var pop = downloads + (karma * 100);

            simpleDataSet.RowData.Add("popularity", pop.ToString());
            simpleDataSet.RowData.Add("karma", karma.ToString());
            simpleDataSet.RowData.Add("downloads", downloads.ToString());
            simpleDataSet.RowData.Add("image", imageFile);

            //now we need to add the versions and compat versions
            // first, this is the versions that the project has files tagged against
            simpleDataSet.RowData.Add("versions", string.Join(",", versions));

            //then we index the versions that the project has actually been flagged as compatible against
            simpleDataSet.RowData.Add("compatVersions", string.Join(",", compatVersions));

            return simpleDataSet;
        }

 /// <summary>
 /// Common properties to map
 /// </summary>
 /// <param name="modelObject"></param>
 /// <param name="model"></param>
 public static void PopulateCommonUmbracoProperties(MasterModel modelObject, IPublishedContent model)
 {
     modelObject.PageTitle = model.HasValue(AppConstants.PropPageTitle) ? model.GetPropertyValue<string>(AppConstants.PropPageTitle) : model.Name;
     modelObject.MetaDesc = model.GetPropertyValue(AppConstants.PropMetaDesc, library.TruncateString(library.StripHtml(model.GetPropertyValue<string>(AppConstants.PropBodyText, "")), 160, "")).ToString();
     modelObject.NodePath = model.Path.Split(',').Select(x => Convert.ToInt32(x)).ToList();
     modelObject.HideFromNavigation = model.GetPropertyValue<bool>(AppConstants.PropUmbracoNaviHide);
     modelObject.ShowInFooter = model.GetPropertyValue<bool>(AppConstants.PropShowInFooter);
     modelObject.ConversionCode = model.GetPropertyValue<string>(AppConstants.PropConversionCodes);
 }

        public static string OGImage(IPublishedContent currentPage)
        {
            if (currentPage.HasProperty(Up.Mixins.Seo.OgImage) && currentPage.HasValue(Up.Mixins.Seo.OgImage))
            {
                return @"<meta property=""og:image"" content=""" + Settings.BaseUrlWithoutSlash + new UmbracoHelper(UmbracoContext.Current).TypedMedia(currentPage.GetPropertyValue<int>(Up.Mixins.Seo.OgImage)).GetCropUrl(CropSize.OGImage_1200_x_630) + @""">";
            }

            return "";
        }

        public static WebsiteHouse Map(IPublishedContent content)
        {
            var model = new WebsiteHouse
                {
                    HouseNumber = content.GetProperty("husnummer") != null
                            ? content.GetPropertyValue<int>("husnummer")
                            : -1,

                    Residents = WebsiteResidentMapper.MapResidents(content),

                    ResidentsString = content.HasValue("antalPersonerIHusstanden") ? content.GetPropertyValue<string>("antalPersonerIHusstanden") : "",

                    MoveInDate = content.GetProperty("indflytningsdato") != null
                            ? content.GetPropertyValue<DateTime>("indflytningsdato")
                            : DateTime.MinValue
                };

            return model;
        }

        private SelfServiceActionPage(SearchResult result, IPublishedContent content) {

            Id = result.Id;

            if (content == null) {

                string title;
                Title = result.Fields.TryGetValue("title", out title) ? title : result.Fields["nodeName"];

                Categories = new SelfServiceCategory[0];

            } else {

                Title = content.HasValue("title") ? content.GetPropertyValue<string>("title") : content.Name;

                Url = content.Url;

                Categories = content.GetPropertyValue<SelfServiceCategory[]>("skySelfServiceCategories") ?? new SelfServiceCategory[0];

            }
        
        }

        public static CanvasModel GetObjectByNode(IPublishedContent node)
        {
            try
            {
                var model = new CanvasModel();

                if (node.HasProperty("canvas") && node.HasValue("canvas"))
                {

                    string json = node.GetPropertyValue<string>("canvas");

                    model = JsonConvert.DeserializeObject<CanvasModel>(json);

                }

                return model;
            }
            catch (Exception ex)
            {
                Log.Error("Canvas error on GetObjectByNode in Repository.", ex);
                return null;
            }

        }

        private ItemPreview ConvertToItem(IPublishedContent result)
        {
            var item = new ItemPreview();
            item.NodeId = result.Id;
            item.NodeTypeAlias = result.DocumentTypeAlias;
            item.ParentName = result.Parent.Name;
            item.ParentUrl = result.Parent.Url;
            item.Url = result.Url;
            if (result.HasProperty("contentTitle") && result.HasValue("contentTitle"))
            {
                item.Title = result.GetPropertyValue<string>("contentTitle");
            }
            if (result.HasProperty("contentSubtitle") && result.HasValue("contentSubtitle"))
            {
                item.Subtitle = result.GetPropertyValue<string>("contentSubtitle");
            }
            if (result.HasProperty("contentDescription") && result.HasValue("contentDescription"))
            {
                item.Description = result.GetPropertyValue<string>("contentDescription");
            }
            if (result.HasProperty("contentThumbnail") && result.HasValue("contentThumbnail"))
            {
                item.ThumbnailImageUrl = umbracoHelper.TypedMedia(result.GetPropertyValue("contentThumbnail")).Url;
            }
            if (result.HasProperty("contentThumbnailVideo") && result.HasValue("contentThumbnailVideo"))
            {
                item.ThumnailVideoUrl = result.GetPropertyValue<string>("contentThumbnailVideo");
            }
            if (result.HasProperty("contentDate") && result.HasValue("contentDate"))
            {
                item.Date = result.GetPropertyValue<DateTime>("contentDate");
                item.DateFormatted = item.Date.ToString("dd MMMMMMMMM, yyyy", CultureInfo.GetCultureInfoByIetfLanguageTag("pt"));
            }

            return item;
        }

    public static int GetIntValue(IPublishedContent node, string propertyName)
    {
        if (node.HasValue(propertyName))
        {
            var property = node.GetProperty(propertyName);
            if (property == null) return 0;

            return Convert.ToInt32(property.Value);
        }

        return 0;
    }

        private static string MemberAvatarPath(IPublishedContent member)
        {
            try
            {
                var hasAvatar = member.HasValue("avatar");
                if (hasAvatar)
                {
                    var avatarPath = member.GetPropertyValue("avatar").ToString();
                    var path = HostingEnvironment.MapPath(avatarPath);
                    if (System.IO.File.Exists(path))
                        return path;
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error<Utils>("Could not get MemberAvatarPath", ex);
            }

            return string.Empty;
        }

        private static string MemberAvatarPath(IPublishedContent member)
        {
            var hasAvatar = member.HasValue("avatar");
            if (hasAvatar)
            {
                var avatarPath = member.GetPropertyValue("avatar").ToString();
                var path = HostingEnvironment.MapPath(avatarPath);
                if (System.IO.File.Exists(path))
                    return path;
            }

            return string.Empty;
        }

        /// <summary>
        /// Gets selected users list from Multi User Select type field
        /// </summary>
        /// <param name="node"></param>
        /// <param name="propertyAlias"></param>
        /// <returns></returns>
        public static IEnumerable<User> GetSelectedUsers(IPublishedContent node, String propertyAlias)
        {
            List<User> selectedUsers = new List<User>();

            if (node != null && !String.IsNullOrEmpty(propertyAlias) && node.HasProperty(propertyAlias) && node.HasValue(propertyAlias))
            {
                var userIds = node.GetPropertyValue<String>(propertyAlias).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (var selectedUserId in userIds)
                {
                    User user = User.GetUser(Int32.Parse(selectedUserId));
                    if (user != null)
                    {
                        selectedUsers.Add(user);
                    }
                }
            }

            return selectedUsers;
        }

        public SimpleDataSet MapProjectToSimpleDataIndexItem(IPublishedContent project, SimpleDataSet simpleDataSet, string indexType,
            int projectVotes, WikiFile[] files, int downloads, IEnumerable<string> compatVersions)
        {
            var isLive = project.GetPropertyValue<bool>("projectLive");
            var isApproved = project.GetPropertyValue<bool>("approved");

            var minimumVersionStrict = string.Empty;
            var currentFileId = project.GetPropertyValue<int>("file");
            if (currentFileId > 0)
            {
                var currentFile = files.FirstOrDefault(x => x.Id == currentFileId);
                if (currentFile != null)
                    minimumVersionStrict = currentFile.MinimumVersionStrict;
            }

            simpleDataSet.NodeDefinition.NodeId = project.Id;
            simpleDataSet.NodeDefinition.Type = indexType;

            simpleDataSet.RowData.Add("body", project.GetPropertyValue<string>("description"));
            simpleDataSet.RowData.Add("nodeName", project.Name);
            simpleDataSet.RowData.Add("categoryFolder", project.Parent.Name.ToLowerInvariant().Trim());
            simpleDataSet.RowData.Add("updateDate", project.UpdateDate.ToString("yyyy-MM-dd HH:mm:ss"));
            simpleDataSet.RowData.Add("createDate", project.CreateDate.ToString("yyyy-MM-dd HH:mm:ss"));
            simpleDataSet.RowData.Add("nodeTypeAlias", "project");
            simpleDataSet.RowData.Add("url", project.Url);
            simpleDataSet.RowData.Add("uniqueId", project.GetPropertyValue<string>("packageGuid"));
            simpleDataSet.RowData.Add("worksOnUaaS", project.GetPropertyValue<string>("worksOnUaaS"));
            simpleDataSet.RowData.Add("minimumVersionStrict", minimumVersionStrict);

            var imageFile = string.Empty;
            if (project.HasValue("defaultScreenshotPath"))
            {
                imageFile = project.GetPropertyValue<string>("defaultScreenshotPath");
            }
            if (string.IsNullOrWhiteSpace(imageFile))
            {
                var image = files.FirstOrDefault(x => x.FileType == "screenshot");
                if (image != null)
                    imageFile = image.Path;
            }

            //Clean up version data before its included in the index, the reason we have to do this
            // is due to the way the version data is stored, you can see it in uVersion.config - it's super strange
            // because of the 3 digit nature but when it doesn't end with a '0' it's actually just the major/minor version
            // so we have to do all of this parsing.
            var version = project.GetPropertyValue<string>("compatibleVersions") ?? string.Empty;
            var cleanedVersions = version.ToLower()
                .Replace("nan", "")
                .Replace("saved", "")
                .Replace("v", "")
                .Trim(',')
                .Split(',')
                //it's stored as an int like 721 (for version 7.2.1)
                .Where(x => x.Length <= 3 && x.Length > 0)
                //pad it out to 3 digits
                .Select(x => x.PadRight(3, '0'))
                .Select(x =>
                {
                    int o;
                    if (int.TryParse(x, out o))
                    {
                        //if it ends with '0', that means it's a X.X.X version
                        // if it does not end with '0', that means that the last 2 digits are the
                        // Minor part of the version
                        return x.EndsWith("0")
                            ? string.Format("{0}.{1}.{2}", x[0], x[1], 0)
                            : string.Format("{0}.{1}.{2}", x[0], x.Substring(1), 0);
                    }
                    return null;
                })
                .Where(x => x != null);

            var cleanedCompatVersions = compatVersions.Select(x => x.Replace("nan", "")
                .Replace("saved", "")
                .Replace("nan", "")
                .Replace("v", "")
                .Replace(".x", "")
                .Trim(','));

            //popularity for sorting number = downloads + karma * 100;
            //TODO: Change score so that we take into account:
            // - recently updated
            // - works on latest umbraco versions
            // - works on uaas
            // - has a forum
            // - has source code link
            // - open for collab / has collaborators
            // - download count in a recent timeframe - since old downloads should count for less

            var pop = downloads + (projectVotes * 100);

            simpleDataSet.RowData.Add("popularity", pop.ToString());
            simpleDataSet.RowData.Add("karma", projectVotes.ToString());
            simpleDataSet.RowData.Add("downloads", downloads.ToString());
            simpleDataSet.RowData.Add("image", imageFile);

            var packageFiles = files.Count(x => x.FileType == "package");
            simpleDataSet.RowData.Add("packageFiles", packageFiles.ToString());

            simpleDataSet.RowData.Add("projectLive", isLive ? "1" : "0");
//.........这里部分代码省略.........