C# IContent.SetValue方法代码示例

 private static void PublishErrorPage(CancellableEventArgs e, IContent content)
 {
     var helper = new UmbracoHelper(UmbracoContext.Current);
     var published = helper.TypedContent(content.Id);
     if (published != null)
     {
         var publisher = NinjectWebCommon.Kernel.GetService<IPublishingService>();
         if (publisher.PublishWebFormsPage(published.UrlWithDomain(), content.ContentType.Alias))
         {
             e.Messages.Add(new EventMessage("Success", "Static error page updated", EventMessageType.Info));
             content.SetValue(PropertyAliases.StaticPage, string.Format("/{0}.aspx", content.ContentType.Alias));
         }
         else
         {
             e.Messages.Add(new EventMessage("Error", "Failure updating static error page", EventMessageType.Error));
         }
     }
     else
     {
         e.Messages.Add(new EventMessage("Warning", "Publish again to update static error page", EventMessageType.Warning));
     }
 }

 private IContent FormBulkUpdate(IContent form, BulkUpdateModel model)
 {
     if (model.Tags != null)
     {
         form.SetTags("formTags", model.Tags, true, TAG_GROUP_GLEANER_FORM);
     }
     if (model.Groups != null)
     {
         form.SetValue("associatedGroups", string.Join(",", model.Groups));
     }
     if (model.IsPublic.HasValue)
     {
         form.SetValue("isPublic", model.IsPublic.Value);
     }
     if (model.IsRequired.HasValue)
     {
         form.SetValue("isRequired", model.IsRequired.Value);
     }
     if (model.StartDate.HasValue)
     {
         form.SetValue("startDate", model.StartDate.Value);
     }
     if (model.EndDate.HasValue)
     {
         form.SetValue("endDate", model.EndDate.Value);
     }
     return form;
 }

 private IContent FormBulkRemove(IContent form, BulkUpdateModel model)
 {
     if (model.Tags != null)
     {
         form.RemoveTags("formTags", model.Tags, TAG_GROUP_GLEANER_FORM);
     }
     if (model.Groups != null)
     {
         var currentValue = form.GetValue<string>("associatedGroups").ToDelimitedList().Select(Int32.Parse);
         form.SetValue("associatedGroups", string.Join(",", currentValue.Except(model.Groups)));
     }
     return form;
 }

 private IContent FormBulkArchive(IContent form)
 {
     form.SetValue("isArchived", true);
     return form;
 }

        private IContent SetDescription(IContent content, bool hasLowKarma, ref bool hasAnchors)
        {
            content.SetValue("description", tb_desc.Text);

            // Filter out links when karma is low, probably a spammer
            if (hasLowKarma)
            {
                var doc = new HtmlAgilityPack.HtmlDocument();
                doc.LoadHtml(tb_desc.Text);

                var anchorNodes = doc.DocumentNode.SelectNodes("//a");
                if (anchorNodes != null)
                {
                    hasAnchors = true;

                    foreach (var anchor in anchorNodes)
                        anchor.ParentNode.RemoveChild(anchor, true);
                }

                content.SetValue("description", doc.DocumentNode.OuterHtml);
            }

            return content;
        }

        private static void SetModelToContent(ref IContent content, ArborEventModel model)
        {
            DateTime startDate;
            DateTime.TryParse(model.StartDate + " " + model.StartTime, out startDate);
            DateTime endDate;
            DateTime.TryParse(model.EndDate + " " + model.EndTime, out endDate);

            content.SetValue("title", model.Title);
            content.SetValue("description", model.Description);
            content.SetValue("startDate", startDate);
            content.SetValue("endDate", endDate);
            content.SetValue("location", JsonConvert.SerializeObject(new List<Address>
            {
                new Address()
                {
                    Street = model.Street,
                    City = model.City,
                    State = model.State,
                    ZipCode = model.ZipCode
                }
            }));
            content.SetValue("links", JsonConvert.SerializeObject(new List<SocialLinks>
            {
                new SocialLinks()
                {
                    Facebook = model.Facebook,
                    Twitter = model.Twitter,
                    Instagram = model.Instagram,
                    Blog = model.Blog
                }
            }));
            content.SetValue("images", model.Images);
        }

        private void SaveContent(XElement node, IContent content, Content newContent, ZipFile zip)
        {
            var dataTypes = new Config().GetSpecialDataTypes();

            content.ParentId = GetContentParentId(newContent);
            content.SortOrder = newContent.SortOrder;
            content.Name = newContent.Name;
            content.CreatorId = User.GetCurrent().Id;
            content.WriterId = User.GetCurrent().Id;

            if (content.Template != null)
            {
                content.Template.Id = newContent.TemplateId;
            }

            if (newContent.ReleaseDate != DateTime.MinValue)
            {
                content.ReleaseDate = newContent.ReleaseDate;
            }

            if (newContent.ExpireDate != DateTime.MinValue)
            {
                content.ExpireDate = newContent.ExpireDate;
            }

            foreach (var propertyTag in node.Elements())
            {
                var dataTypeGuid = new Guid(propertyTag.Attribute("dataTypeGuid").Value);

                var value = propertyTag.Value;

                // The null check here is necessary. Blank content exports into the xml, which is fine, since on
                // import the blank value gets mapped across. However, for upload datatypes, this blank value
                // causes an exception here - unless we perform the null check.
                if (dataTypeGuid == new Guid(Constants.UploadDataTypeGuid) && propertyTag.Attribute("fileName") != null)
                {
                    var fileName = propertyTag.Attribute("fileName").Value;
                    var umbracoFile = propertyTag.Attribute("umbracoFile").Value;

                    if (!string.IsNullOrWhiteSpace(umbracoFile))
                    {
                        content.SetValue(propertyTag.Name.ToString(), fileName, GetFileStream(umbracoFile, zip));
                    }
                    else
                    {
                        content.SetValue(propertyTag.Name.ToString(), string.Empty);
                    }
                }
                else if (!dataTypes.ContainsKey(dataTypeGuid))
                {
                    content.SetValue(propertyTag.Name.ToString(), value);
                }
            }

            SaveContent(content, bool.Parse(node.Attribute("published").Value));
        }

        private void AddOrUpdateContent(IContent content, MetaWeblogPost post, IUser user, bool publish)
        {
            content.Name = post.Title;
            content.SetValue("author", user.Name);
            if (content.HasProperty("richText"))
            {
                content.SetValue("richText", post.Content);
            }
            if (!post.Slug.IsNullOrWhiteSpace())
            {
                content.SetValue("umbracoUrlName", post.Slug);
            }
            if (!post.Excerpt.IsNullOrWhiteSpace())
            {
                content.SetValue("excerpt", post.Excerpt);
            }
            if (post.AllowComments == 1)
            {
                content.SetValue("enableComments", 1);
            }
            else if (post.AllowComments == 2)
            {
                content.SetValue("enableComments", 0);
            }
            content.SetTags("categories", post.Categories, true, "ArticulateCategories");
            var tags = post.Tags.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries).Distinct().ToArray();
            content.SetTags("tags", tags, true, "ArticulateTags");

            if (publish)
            {
                if (post.CreateDate != DateTime.MinValue)
                {
                    content.SetValue("publishedDate", post.CreateDate);
                }

                _applicationContext.Services.ContentService.SaveAndPublishWithStatus(content, user.Id);
            }
            else
            {
                _applicationContext.Services.ContentService.Save(content, user.Id);
            }
        }

        private void SetPropertyOnIContent(IContent content, UmbracoPropertyAttribute umbracoPropertyAttribute, object propertyValue, string alias = null)
        {
            object convertedValue;
            if (umbracoPropertyAttribute.ConverterType != null)
            {

                TypeConverter converter = (TypeConverter)Activator.CreateInstance(umbracoPropertyAttribute.ConverterType);
                convertedValue = converter.ConvertTo(null, CultureInfo.InvariantCulture, propertyValue, typeof(string));
            }
            else
            {
                //No converter is given so basically we push the string back into umbraco
                convertedValue = propertyValue.ToString();
            }

            if (alias == null) alias = umbracoPropertyAttribute.Alias;

            content.SetValue(alias, convertedValue);
        }

        private void AddOrUpdateContent(IContent content, MetaWeblogPost post, IUser user, bool publish, bool extractFirstImageAsProperty)
        {
            content.Name = post.Title;
            content.SetValue("author", user.Name);
            if (content.HasProperty("richText"))
            {
                var firstImage = "";

                //we need to replace all absolute image paths with relative ones
                var contentToSave = _mediaSrc.Replace(post.Content, match =>
                {
                    if (match.Groups.Count == 2)
                    {
                        var imageSrc = match.Groups[1].Value.EnsureStartsWith('/');
                        if (firstImage.IsNullOrWhiteSpace())
                        {
                            firstImage = imageSrc;
                        }
                        return " src=\"" + imageSrc + "\"";
                    }
                    return null;
                });

                var imagesProcessed = 0;

                //now replace all absolute anchor paths with relative ones
                contentToSave = _mediaHref.Replace(contentToSave, match =>
                {
                    if (match.Groups.Count == 2)
                    {
                        var href = " href=\"" +
                               match.Groups[1].Value.EnsureStartsWith('/') +
                               "\" class=\"a-image-" + imagesProcessed + "\" ";

                        imagesProcessed++;

                        return href;
                    }
                    return null;
                });

                content.SetValue("richText", contentToSave);

                if (extractFirstImageAsProperty
                    && content.HasProperty("postImage")
                    && !firstImage.IsNullOrWhiteSpace())
                {
                    content.SetValue("postImage", firstImage);
                    //content.SetValue("postImage", JsonConvert.SerializeObject(JObject.FromObject(new
                    //{
                    //    src = firstImage
                    //})));
                }
            }

            if (!post.Slug.IsNullOrWhiteSpace())
            {
                content.SetValue("umbracoUrlName", post.Slug);
            }
            if (!post.Excerpt.IsNullOrWhiteSpace())
            {
                content.SetValue("excerpt", post.Excerpt);
            }

            if (post.AllowComments == 1)
            {
                content.SetValue("enableComments", 1);
            }
            else if (post.AllowComments == 2)
            {
                content.SetValue("enableComments", 0);
            }

            content.SetTags("categories", post.Categories, true, "ArticulateCategories");
            var tags = post.Tags.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Distinct().ToArray();
            content.SetTags("tags", tags, true, "ArticulateTags");

            if (publish)
            {
                if (post.CreateDate != DateTime.MinValue)
                {
                    content.SetValue("publishedDate", post.CreateDate);
                }

                _applicationContext.Services.ContentService.SaveAndPublishWithStatus(content, user.Id);
            }
            else
            {
                _applicationContext.Services.ContentService.Save(content, user.Id);
            }
        }

		private void SetPropertyDefaults(DefinedContentItem item, IContent contentItem)
		{
			foreach (PropertyDefault property in item.PropertyDefaults)
			{
				if (!string.IsNullOrEmpty(property.PropertyAlias) && !string.IsNullOrEmpty(property.Value))
				{
					string propertyValue = "";

					switch (property.ValueType)
					{
						case PropertyDefaultValueType.Key:
							propertyValue = GetId(property.Value).ToString();
							break;
						case PropertyDefaultValueType.StaticValue:
							propertyValue = property.Value;
							break;
						default:
							throw new Exception("Unknown property default value type for property " + property.PropertyAlias + " on key " + item.Key);
					}

					contentItem.SetValue(property.PropertyAlias, propertyValue);
				}
			}
		}

 private void UpdateFormVersion(IContent savingContent)
 {
     if (!savingContent.IsDirty())
     {
         return;
     }
     var glVersion = savingContent.GetValue<string>("glVersion");
     var version = "1";
     if (!string.IsNullOrEmpty(glVersion))
     {
         var parts = glVersion.ToDelimitedList(".");
         var major = Int32.Parse(parts[0]);
         var minor = parts.Count > 1 ? Int32.Parse(parts[1]) : 0;
         var isNewVersion = savingContent.IsPropertyDirty("formUpload");
         version = isNewVersion
             ? (major + 1).ToString()
             : string.Join(".", major, minor + 1);
     }
     savingContent.SetValue("glVersion", version);
 }

		private static void SetProperty(IContent orderedProductDoc, string propertyAlias, object value)
		{
			if (orderedProductDoc.HasProperty(propertyAlias))
				orderedProductDoc.SetValue(propertyAlias, value);
		}

        /// <summary>
        /// Ensures that the node name is the same as the post title
        /// </summary>
        /// <param name="doc"></param>
        /// <returns></returns>
        public IContent EnsureNavigationTitle(IContent doc)
        {
            var navTitle = doc.GetValue<string>("uBlogsyNavigationTitle");
            var title = doc.GetValue<string>("uBlogsyContentTitle");

            if (string.IsNullOrEmpty(navTitle) && !string.IsNullOrEmpty(title))
            {
                navTitle = title;
                // ensure node name is same as title
                doc.SetValue("uBlogsyNavigationTitle", navTitle);
                ApplicationContext.Current.Services.ContentService.Save(doc, 0, false);
            }

            return doc;
        }

        /// <summary>
        /// Ensures that the node name is the same as the post title
        /// </summary>
        /// <param name="doc"></param>
        /// <returns></returns>
        public IContent EnsureCorrectPostTitle(IContent doc)
        {
            var title = doc.GetValue<string>("uBlogsyContentTitle");
            if (string.IsNullOrEmpty(title))
            {
                // ensure node name is same as title
                doc.SetValue("uBlogsyContentTitle", doc.Name);
                ApplicationContext.Current.Services.ContentService.Save(doc, 0, false);
            }

            return doc;
        }