private (AkismetSpamCheck processor, CreateCommentArgs args, Mock <IAkismet> akismetApiMock) CreateAkismetSpamCheck(IWeBlogCommentSettings settings, IWorkflowProvider workflowProvider)
{
var linkManager = Mock.Of <BaseLinkManager>(x =>
#if FEATURE_URL_BUILDERS
x.GetItemUrl(It.IsAny <Item>(), It.Is <ItemUrlBuilderOptions>(y => y.AlwaysIncludeServerUrl == true)) == "link"
#else
x.GetItemUrl(It.IsAny <Item>(), It.Is <UrlOptions>(y => y.AlwaysIncludeServerUrl == true)) == "link"
#endif
);
var blogItem = ItemFactory.CreateItem().Object;
var blogManager = Mock.Of <IBlogManager>(x =>
x.GetCurrentBlog() == new BlogHomeItem(blogItem)
);
var akismetApiMock = new Mock <IAkismet>();
var processor = new AkismetSpamCheck(settings, blogManager, akismetApiMock.Object, linkManager);
var item = CreateCommentItem();
var database = Mock.Of <Database>(x =>
x.WorkflowProvider == workflowProvider
);
var args = new CreateCommentArgs();
args.CommentItem = new CommentItem(item);
args.Database = database;
return(processor, args, akismetApiMock);
}
public void NullLanguage()
{
var processor = new CreateCommentItem(Mock.Of <IBlogManager>(), Mock.Of <IBlogSettingsResolver>());
using (var db = new Db
{
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var entry = db.GetItem("/sitecore/content/blog/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment"
}
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
public void Process(CreateCommentArgs args)
{
Assert.IsNotNull(args.CommentItem, "Comment Item cannot be null");
if (!string.IsNullOrEmpty(Settings.AkismetAPIKey) && !string.IsNullOrEmpty(Settings.CommentWorkflowCommandSpam))
{
var workflow = args.Database.WorkflowProvider.GetWorkflow(args.CommentItem);
if (workflow != null)
{
var api = new Akismet(Settings.AkismetAPIKey, ManagerFactory.BlogManagerInstance.GetCurrentBlog().SafeGet(x => x.Url), "WeBlog/2.1");
var isSpam = api.CommentCheck(args.CommentItem);
if (isSpam)
{
//Need to switch to shell website to execute workflow
using (new SiteContextSwitcher(SiteContextFactory.GetSiteContext(Sitecore.Constants.ShellSiteName)))
{
workflow.Execute(Settings.CommentWorkflowCommandSpam, args.CommentItem, "Akismet classified this comment as spam", false, new object[0]);
}
args.AbortPipeline();
}
}
}
}
public void InvalidEntryID()
{
var blogTemplateId = ID.NewID;
using (var db = new Db
{
new DbItem("blog", ID.NewID, blogTemplateId)
})
{
var blog = db.GetItem("/sitecore/content/blog");
var blogManager = Mock.Of <IBlogManager>(x =>
x.GetCurrentBlog(It.IsAny <Item>()) == new BlogHomeItem(blog)
);
var processor = new CreateCommentItem(blogManager);
var args = new CreateCommentArgs
{
Database = blog.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**"
},
EntryID = ID.NewID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Null);
}
}
public void InvalidEntryId()
{
using (var db = new Db
{
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var processor = CreateDuplicateSubmissionGuard(entry, blog, ID.NewID);
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Language = Language.Parse("de"),
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment"
}
};
processor.Process(args);
Assert.That(args.Aborted, Is.False);
}
}
public void InvalidEntryID()
{
var blogTemplateId = ID.NewID;
using (var db = new Db
{
new DbItem("blog", ID.NewID, blogTemplateId)
})
{
var blog = db.GetItem("/sitecore/content/blog");
var processor = CreateCreateCommentItem(null, blog, ID.NewID);
var args = new CreateCommentArgs
{
Database = blog.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**"
},
EntryID = ID.NewID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Null);
}
}
public void NullEntryId()
{
var processor = new DuplicateSubmissionGuard();
using (var db = new Db
{
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var entry = db.GetItem("/sitecore/content/blog/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
Language = Language.Parse("de"),
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment"
}
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
public void MultipleCommentsSameName()
{
using (var db = new Db
{
new DbTemplate(Settings.CommentTemplateID)
{
new DbField("Name"),
new DbField("Email"),
new DbField("Comment"),
new DbField("Website"),
new DbField("IP Address"),
},
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var blogManager = Mock.Of <IBlogManager>(x =>
x.GetCurrentBlog(entry) == new BlogHomeItem(blog)
);
var processor = new TestableCreateCommentItemProcessor(blogManager);
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**",
Text = "the comment"
},
EntryID = entry.ID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
var firstComment = args.CommentItem;
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
Assert.That(args.CommentItem.ID, Is.Not.EqualTo(firstComment.ID));
Assert.That(args.CommentItem.InnerItem.Name, Is.Not.EqualTo(firstComment.InnerItem.Name));
Assert.That(args.CommentItem.InnerItem.Name, Does.Match(".+\\d$"));
}
}
public void CustomFields()
{
using (var db = new Db
{
new DbTemplate(Settings.CommentTemplateID)
{
new DbField("Name"),
new DbField("Email"),
new DbField("Comment"),
new DbField("Website"),
new DbField("IP Address"),
new DbField("field1"),
new DbField("field2")
},
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var blogManager = Mock.Of <IBlogManager>(x =>
x.GetCurrentBlog(entry) == new BlogHomeItem(blog)
);
var processor = new CreateCommentItem(blogManager);
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**",
Text = "the comment",
Fields =
{
{ "field1", "value1" },
{ "field2", "value2" },
}
},
EntryID = entry.ID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
Assert.That(args.CommentItem["field1"], Is.EqualTo("value1"));
Assert.That(args.CommentItem["field2"], Is.EqualTo("value2"));
}
}
public void CustomFields()
{
using (var db = new Db
{
new DbTemplate(Settings.CommentTemplateID)
{
new DbField("Name"),
new DbField("Email"),
new DbField("Comment"),
new DbField("Website"),
new DbField("IP Address"),
new DbField("field1"),
new DbField("field2")
},
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var blogManager = Mock.Of<IBlogManager>(x =>
x.GetCurrentBlog(entry) == new BlogHomeItem(blog)
);
var processor = new CreateCommentItem(blogManager);
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**",
Text = "the comment",
Fields =
{
{ "field1", "value1" },
{ "field2", "value2" },
}
},
EntryID = entry.ID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
Assert.That(args.CommentItem["field1"], Is.EqualTo("value1"));
Assert.That(args.CommentItem["field2"], Is.EqualTo("value2"));
}
}
public void DifferentText()
{
var commentTemplate = CreateCommentTemplate();
using (var db = new Db
{
commentTemplate,
new DbItem("blog")
{
new DbItem("entry")
{
new DbItem("comment", ID.NewID, commentTemplate.ID)
{
new DbField("Name")
{
{ "de", "commentor" }
},
new DbField("Email")
{
{ "de", "*****@*****.**" }
},
new DbField("Comment")
{
{ "de", "the comment" }
},
}
}
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var processor = CreateDuplicateSubmissionGuard(entry, blog, commentTemplate.ID);
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Language = Language.Parse("de"),
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment updated"
}
};
processor.Process(args);
Assert.That(args.Aborted, Is.False);
}
}
public void Process(CreateCommentArgs args)
{
Assert.IsNotNull(args.Comment, "Comment cannot be null");
ProfanityFilterArgs filterArgs = new ProfanityFilterArgs
{
Input = args.Comment.Text
};
CorePipeline.Run("weblogProfanityFilter", filterArgs);
if (!filterArgs.Valid)
{
args.AbortPipeline();
}
args.Comment.Text = filterArgs.Input;
}
public void MultipleCommentsSameName()
{
var commentTemplate = CreateCommentTemplate();
using (var db = new Db
{
commentTemplate,
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var processor = CreateCreateCommentItem(entry, blog, commentTemplate.ID);
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**",
Text = "the comment"
},
EntryID = entry.ID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
var firstComment = args.CommentItem;
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
Assert.That(args.CommentItem.ID, Is.Not.EqualTo(firstComment.ID));
Assert.That(args.CommentItem.InnerItem.Name, Is.Not.EqualTo(firstComment.InnerItem.Name));
Assert.That(args.CommentItem.InnerItem.Name, Does.Match(".+\\d$"));
}
}
public void Process(CreateCommentArgs args)
{
if (!string.IsNullOrEmpty(Settings.CommentWorkflowCommandCreated))
{
var workflow = args.Database.WorkflowProvider.GetWorkflow(args.CommentItem);
if (workflow != null)
{
//Need to switch to shell website to execute workflow
using (new SiteContextSwitcher(SiteContextFactory.GetSiteContext(Sitecore.Constants.ShellSiteName)))
{
workflow.Execute(Settings.CommentWorkflowCommandCreated, args.CommentItem, "WeBlog automated submit", false, new object[0]);
}
//workflow should take care of publishing the item following this, if it's configured to do so
}
}
}
public void Process(CreateCommentArgs args)
{
Assert.IsNotNull(args.Database, "Database cannot be null");
Assert.IsNotNull(args.Comment, "Comment cannot be null");
Assert.IsNotNull(args.EntryID, "Entry ID cannot be null");
var entryItem = args.Database.GetItem(args.EntryID, args.Language);
if (entryItem != null)
{
// End at end of today to make sure we cover comments from today properly
var dateEnd = System.DateTime.UtcNow.Date.AddDays(1);
var dateStart = dateEnd - TimeSpan;
var blog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(entryItem);
if (blog != null)
{
var commentTemplate = blog.BlogSettings.CommentTemplateID;
var query = "{0}//*[@@templateid='{1}' and @__created > '{2}' and @__created < '{3}']".FormatWith(
ContentHelper.EscapePath(entryItem.Paths.FullPath), commentTemplate, DateUtil.ToIsoDate(dateStart), DateUtil.ToIsoDate(dateEnd));
var comments = args.Database.SelectItems(query);
var match = false;
foreach (var item in comments)
{
var commentItem = (CommentItem)item;
if (string.Compare(commentItem.AuthorName, args.Comment.AuthorName, StringComparison.OrdinalIgnoreCase) == 0 &&
string.Compare(commentItem.Email.Raw, args.Comment.AuthorEmail, StringComparison.OrdinalIgnoreCase) == 0 &&
string.Compare(commentItem.Comment.Raw, args.Comment.Text, StringComparison.OrdinalIgnoreCase) == 0)
{
match = true;
Log.Warn("[WeBlog] Duplicate comment submission. Existing item: {0}".FormatWith(commentItem.ID), this);
}
}
if (match)
{
args.AbortPipeline();
}
}
}
}
public void NoDuplicateComment()
{
using (var db = new Db
{
new DbTemplate(Settings.CommentTemplateID)
{
new DbField("Name"),
new DbField("Email"),
new DbField("Comment"),
new DbField("Website"),
new DbField("IP Address"),
},
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var blogManager = Mock.Of <IBlogManager>(x =>
x.GetCurrentBlog(entry) == new BlogHomeItem(blog)
);
var processor = new DuplicateSubmissionGuard(blogManager);
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Language = Language.Parse("de"),
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment"
}
};
processor.Process(args);
Assert.That(args.Aborted, Is.False);
}
}
public void NullEntryId()
{
var processor = new CreateCommentItem(Mock.Of <IBlogManager>(), Mock.Of <IBlogSettingsResolver>());
using (var db = new Db
{
new DbItem("entry")
})
{
var entry = db.GetItem("/sitecore/content/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment(),
Language = Language.Parse("da")
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
public void Process(CreateCommentArgs args)
{
Assert.IsNotNull(args.Database, "Database cannot be null");
Assert.IsNotNull(args.Comment, "Comment cannot be null");
Assert.IsNotNull(args.EntryID, "Entry ID cannot be null");
var entryItem = args.Database.GetItem(args.EntryID, args.Language);
if (entryItem != null)
{
var query = "fast:{0}//*[@email='{1}' and @name='{2}' and @comment='{3}']".FormatWith(
entryItem.Paths.FullPath, args.Comment.AuthorEmail, args.Comment.AuthorName, args.Comment.Text);
var comments = args.Database.SelectItems(query);
if (comments.Length > 0)
{
args.AbortPipeline();
}
}
}
public void NullLanguage()
{
var processor = new CreateCommentItem();
using (var db = new Db
{
new DbItem("entry")
})
{
var entry = db.GetItem("/sitecore/content/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment(),
EntryID = entry.ID
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
/// <summary>
/// Adds a comment to a blog
/// </summary>
/// <param name="entryId">The ID of the entry to add the comment to</param>
/// <param name="comment">The comment to add to the entry</param>
/// <param name="language">The language to create the comment in</param>
/// <returns>The ID of the created comment item, or ID.Null if creation failed</returns>
public virtual ID AddCommentToEntry(ID entryId, Model.Comment comment, Language language = null)
{
var args = new CreateCommentArgs();
args.EntryID = entryId;
args.Comment = comment;
args.Database = ContentHelper.GetContentDatabase();
args.Language = language ?? Context.Language;
CorePipeline.Run("weblogCreateComment", args, true);
if (args.CommentItem != null)
{
return(args.CommentItem.ID);
}
else
{
return(ID.Null);
}
}
public void Process(CreateCommentArgs args)
{
Assert.IsNotNull(args.CommentItem, "Comment Item cannot be null");
if (!string.IsNullOrEmpty(_commentSettings.AkismetAPIKey) && !string.IsNullOrEmpty(_commentSettings.CommentWorkflowCommandSpam))
{
var workflow = args.Database.WorkflowProvider.GetWorkflow(args.CommentItem);
if (workflow != null)
{
var api = _akismetApi;
if (api == null)
{
api = new Akismet();
}
var version = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion;
var blogItem = _blogManager.GetCurrentBlog(args.CommentItem);
var url = _linkManager.GetAbsoluteItemUrl(blogItem);
api.Init(_commentSettings.AkismetAPIKey, url, "WeBlog/" + version);
var isSpam = api.CommentCheck(args.CommentItem);
if (isSpam)
{
//Need to switch to shell website to execute workflow
using (new SiteContextSwitcher(SiteContextFactory.GetSiteContext(Sitecore.Constants.ShellSiteName)))
{
workflow.Execute(_commentSettings.CommentWorkflowCommandSpam, args.CommentItem, "Akismet classified this comment as spam", false, new object[0]);
}
args.AbortPipeline();
}
}
}
}
public void NullComment()
{
var processor = new DuplicateSubmissionGuard();
using (var db = new Db
{
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var entry = db.GetItem("/sitecore/content/blog/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Language = Language.Parse("de")
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
public void DashesInPath()
{
var commentTemplate = CreateCommentTemplate();
using (var db = new Db
{
commentTemplate,
new DbItem("my-blog")
{
new DbItem("the-entry")
}
})
{
var blog = db.GetItem("/sitecore/content/my-blog");
var entry = db.GetItem("/sitecore/content/my-blog/the-entry");
var processor = CreateCreateCommentItem(entry, blog, commentTemplate.ID);
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**",
Text = "the comment"
},
EntryID = entry.ID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
}
}
public void NullComment()
{
var processor = new DuplicateSubmissionGuard();
using (var db = new Db
{
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var entry = db.GetItem("/sitecore/content/blog/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Language = Language.Parse("de")
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
public void NullLanguage()
{
var processor = new CreateCommentItem();
using (var db = new Db
{
new DbItem("entry")
})
{
var entry = db.GetItem("/sitecore/content/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment(),
EntryID = entry.ID
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
public void Process(CreateCommentArgs args)
{
Assert.ArgumentNotNull(args, "args cannot be null");
Assert.IsNotNull(args.Database, "Database cannot be null");
Assert.IsNotNull(args.Comment, "Comment cannot be null");
Assert.IsNotNull(args.EntryID, "Entry ID cannot be null");
Assert.IsNotNull(args.Language, "Language cannot be null");
var entryItem = args.Database.GetItem(args.EntryID, args.Language);
if (entryItem != null)
{
var blogItem = BlogManager.GetCurrentBlog(entryItem);
if (blogItem != null)
{
var template = args.Database.GetTemplate(blogItem.BlogSettings.CommentTemplateID);
var itemName =
ItemUtil.ProposeValidItemName(string.Format("Comment at {0} by {1}",
GetDateTime().ToString("yyyyMMdd HHmmss"), args.Comment.AuthorName));
if (itemName.Length > 100)
{
itemName = itemName.Substring(0, 100);
}
// verify the comment item name is unique for this entry
var query = BuildFastQuery(entryItem, itemName);
var num = 1;
var nondupItemName = itemName;
while (entryItem.Database.SelectSingleItem(query) != null)
{
nondupItemName = itemName + " " + num;
num++;
query = BuildFastQuery(entryItem, nondupItemName);
}
// need to create the comment within the shell site to ensure workflow is applied to comment
var shellSite = SiteContextFactory.GetSiteContext(Sitecore.Constants.ShellSiteName);
SiteContextSwitcher siteSwitcher = null;
try
{
if (shellSite != null)
{
siteSwitcher = new SiteContextSwitcher(shellSite);
}
using (new SecurityDisabler())
{
var newItem = entryItem.Add(nondupItemName, template);
var newComment = new CommentItem(newItem);
newComment.BeginEdit();
newComment.Name.Field.Value = args.Comment.AuthorName;
newComment.Email.Field.Value = args.Comment.AuthorEmail;
newComment.Comment.Field.Value = args.Comment.Text;
foreach (var entry in args.Comment.Fields)
{
newComment.InnerItem[entry.Key] = entry.Value;
}
newComment.EndEdit();
args.CommentItem = newComment;
}
}
finally
{
siteSwitcher?.Dispose();
}
}
else
{
var message = "Failed to find blog for entry {0}\r\nIgnoring comment: name='{1}', email='{2}', commentText='{3}'";
Logger.Error(string.Format(message, args.EntryID, args.Comment.AuthorName, args.Comment.AuthorEmail, args.Comment.Text), typeof(CreateCommentItem));
}
}
else
{
var message = "Failed to find blog entry {0}\r\nIgnoring comment: name='{1}', email='{2}', commentText='{3}'";
Logger.Error(string.Format(message, args.EntryID, args.Comment.AuthorName, args.Comment.AuthorEmail, args.Comment.Text), typeof(CreateCommentItem));
}
}
public void Process(CreateCommentArgs args)
{
Assert.IsNotNull(args.Database, "Database cannot be null");
Assert.IsNotNull(args.Comment, "Comment cannot be null");
Assert.IsNotNull(args.EntryID, "Entry ID cannot be null");
var entryItem = args.Database.GetItem(args.EntryID, args.Language);
if (entryItem != null)
{
var blogItem = ManagerFactory.BlogManagerInstance.GetCurrentBlog(entryItem);
if (blogItem != null)
{
var template = args.Database.GetTemplate(blogItem.BlogSettings.CommentTemplateID);
var itemName = ItemUtil.ProposeValidItemName(string.Format("Comment at {0} by {1}", DateTime.Now.ToString("yyyyMMdd HHmmss"), args.Comment.AuthorName));
// verify the comment item name is unique for this entry
var query = "{0}//{1}".FormatWith(entryItem.Paths.FullPath, itemName);
#if !SC62
query = "fast:" + query;
#endif
var num = 1;
var nondupItemName = itemName;
while (entryItem.Database.SelectSingleItem(query) != null)
{
nondupItemName = itemName + " " + num;
num++;
query = "fast:{0}//{1}".FormatWith(entryItem.Paths.FullPath, nondupItemName);
}
//need to emulate creation within shell site to ensure workflow is applied to comment
using (new SiteContextSwitcher(SiteContextFactory.GetSiteContext(Sitecore.Constants.ShellSiteName)))
{
using (new SecurityDisabler())
{
var newItem = entryItem.Add(nondupItemName, template);
var newComment = new CommentItem(newItem);
newComment.BeginEdit();
newComment.Name.Field.Value = args.Comment.AuthorName;
newComment.Email.Field.Value = args.Comment.AuthorEmail;
newComment.Comment.Field.Value = args.Comment.Text;
foreach (var entry in args.Comment.Fields)
{
newComment.InnerItem[entry.Key] = entry.Value;
}
newComment.EndEdit();
args.CommentItem = newComment;
}
}
}
else
{
var message = "Failed to find blog for entry {0}\r\nIgnoring comment: name='{1}', email='{2}', commentText='{3}'";
Log.Error(string.Format(message, args.EntryID, args.Comment.AuthorName, args.Comment.AuthorEmail, args.Comment.Text), typeof(CreateCommentItem));
}
}
else
{
var message = "Failed to find blog entry {0}\r\nIgnoring comment: name='{1}', email='{2}', commentText='{3}'";
Log.Error(string.Format(message, args.EntryID, args.Comment.AuthorName, args.Comment.AuthorEmail, args.Comment.Text), typeof(CreateCommentItem));
}
}
public void InvalidEntryId()
{
var processor = new DuplicateSubmissionGuard();
using (var db = new Db
{
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var entry = db.GetItem("/sitecore/content/blog/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Language = Language.Parse("de"),
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment"
}
};
processor.Process(args);
Assert.That(args.Aborted, Is.False);
}
}
public void MultipleCommentsSameName()
{
using (var db = new Db
{
new DbTemplate(Settings.CommentTemplateID)
{
new DbField("Name"),
new DbField("Email"),
new DbField("Comment"),
new DbField("Website"),
new DbField("IP Address"),
},
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var blogManager = Mock.Of<IBlogManager>(x =>
x.GetCurrentBlog(entry) == new BlogHomeItem(blog)
);
var processor = new TestableCreateCommentItemProcessor(blogManager);
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**",
Text = "the comment"
},
EntryID = entry.ID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
var firstComment = args.CommentItem;
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
Assert.That(args.CommentItem.ID, Is.Not.EqualTo(firstComment.ID));
Assert.That(args.CommentItem.InnerItem.Name, Is.Not.EqualTo(firstComment.InnerItem.Name));
Assert.That(args.CommentItem.InnerItem.Name, Does.Match(".+\\d$"));
}
}
public void DifferentText()
{
using (var db = new Db
{
new DbTemplate(Settings.CommentTemplateID)
{
new DbField("Name"),
new DbField("Email"),
new DbField("Comment"),
new DbField("Website"),
new DbField("IP Address"),
},
new DbItem("blog")
{
new DbItem("entry")
{
new DbItem("comment", ID.NewID, Settings.CommentTemplateID)
{
new DbField("Name")
{
{ "de", "commentor" }
},
new DbField("Email")
{
{ "de", "*****@*****.**" }
},
new DbField("Comment")
{
{ "de", "the comment" }
},
}
}
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var blogManager = Mock.Of<IBlogManager>(x =>
x.GetCurrentBlog(entry) == new BlogHomeItem(blog)
);
var processor = new DuplicateSubmissionGuard(blogManager);
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Language = Language.Parse("de"),
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment updated"
}
};
processor.Process(args);
Assert.That(args.Aborted, Is.False);
}
}
public void NullLanguage()
{
var processor = new DuplicateSubmissionGuard();
using (var db = new Db
{
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var entry = db.GetItem("/sitecore/content/blog/entry");
var args = new CreateCommentArgs
{
Database = entry.Database,
EntryID = entry.ID,
Comment = new Comment
{
AuthorEmail = "*****@*****.**",
AuthorName = "commentor",
Text = "the comment"
}
};
Assert.That(() => processor.Process(args), Throws.InvalidOperationException);
}
}
public void InvalidEntryID()
{
var blogTemplateId = ID.NewID;
using (var db = new Db
{
new DbItem("blog", ID.NewID, blogTemplateId)
})
{
var blog = db.GetItem("/sitecore/content/blog");
var blogManager = Mock.Of<IBlogManager>(x =>
x.GetCurrentBlog(It.IsAny<Item>()) == new BlogHomeItem(blog)
);
var processor = new CreateCommentItem(blogManager);
var args = new CreateCommentArgs
{
Database = blog.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**"
},
EntryID = ID.NewID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Null);
}
}
