public void Resolve_ItemNotBasedOnBlogTemplate_ReturnsSettingsBasedOnWeBlogSettings()
{
// arrange
var categoryTemplateId = ID.NewID;
var entryTemplateId = ID.NewID;
var commentTemplateId = ID.NewID;
var item = ItemFactory.CreateItem().Object;
var weBlogsettings = Mock.Of <IWeBlogSettings>(x =>
x.CategoryTemplateIds == new[] { categoryTemplateId } &&
x.EntryTemplateIds == new[] { entryTemplateId } &&
x.CommentTemplateIds == new[] { commentTemplateId }
);
var sut = new BlogSettingsResolver(Mock.Of <BaseTemplateManager>(), weBlogsettings);
// act
var result = sut.Resolve(item);
// assert
Assert.That(result.CategoryTemplateID, Is.EqualTo(categoryTemplateId));
Assert.That(result.EntryTemplateID, Is.EqualTo(entryTemplateId));
Assert.That(result.CommentTemplateID, Is.EqualTo(commentTemplateId));
}
protected virtual IQueryable <CommentResultItem> CreateQueryable(IProviderSearchContext context, Item rootItem, BlogHomeItem blogItem)
{
var settings = BlogSettingsResolver.Resolve(blogItem);
return(context.GetQueryable <CommentResultItem>().Where(x =>
x.Paths.Contains(rootItem.ID) &&
x.TemplateId == settings.CommentTemplateID &&
x.Language == rootItem.Language.Name
));
}
public string Replace(string text, Item contextItem)
{
if (string.IsNullOrEmpty(text))
{
return(string.Empty);
}
var blogHomeItem = BlogManager.GetCurrentBlog(contextItem);
var blogSettings = BlogSettingsResolver.Resolve(blogHomeItem);
CurrentSettings = blogSettings;
var result = _tokenRegex.Replace(text, RegexMatchProcessor);
return(result);
}
public void Process(CreateCommentArgs args)
{
Assert.ArgumentNotNull(args, "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");
Assert.IsNotNull(args.Language, "Language 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 = BlogManager.GetCurrentBlog(entryItem);
if (blog != null)
{
var settings = BlogSettingsResolver.Resolve(blog);
var query = "{0}//*[@@templateid='{1}' and @__created > '{2}' and @__created < '{3}']".FormatWith(
ContentHelper.EscapePath(entryItem.Paths.FullPath), settings.CommentTemplateID, DateUtil.ToIsoDate(dateStart), DateUtil.ToIsoDate(dateEnd));
var comments = args.Database.SelectItems(query);
foreach (var item in comments)
{
var languageItem = args.Database.GetItem(item.ID, args.Language);
var commentItem = (CommentItem)languageItem;
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)
{
Logger.Warn("Duplicate comment submission. Existing item: {0}".FormatWith(commentItem.ID), this);
args.AbortPipeline();
return;
}
}
}
}
}
public void Resolve_ItemBasedOnDerivedBlogTemplate_ReturnsSettingsFromBlog()
{
// arrange
var categoryTemplateId = ID.NewID;
var entryTemplateId = ID.NewID;
var commentTemplateId = ID.NewID;
var blogTemplateId = ID.NewID;
var baseBlogTemplateId = ID.NewID;
var templates = new TemplateCollection();
var baseTemplate = TemplateFactory.CreateTemplate(baseBlogTemplateId, null, templates);
var blogTemplate = TemplateFactory.CreateTemplate(blogTemplateId, baseBlogTemplateId, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { blogTemplate });
var item = ItemFactory.CreateItem(templateId: blogTemplateId);
var categoryField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Category Template", categoryTemplateId.ToString());
var entryField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Entry Template", entryTemplateId.ToString());
var commentField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Comment Template", commentTemplateId.ToString());
ItemFactory.AddFields(item, new[] { categoryField, entryField, commentField });
var weBlogsettings = Mock.Of <IWeBlogSettings>(x =>
x.CategoryTemplateIds == new[] { ID.NewID } &&
x.EntryTemplateIds == new[] { ID.NewID } &&
x.CommentTemplateIds == new[] { ID.NewID } &&
x.BlogTemplateIds == new[] { baseBlogTemplateId }
);
var sut = new BlogSettingsResolver(templateManager, weBlogsettings);
// act
var result = sut.Resolve(item.Object);
// assert
Assert.That(result.CategoryTemplateID, Is.EqualTo(categoryTemplateId));
Assert.That(result.EntryTemplateID, Is.EqualTo(entryTemplateId));
Assert.That(result.CommentTemplateID, Is.EqualTo(commentTemplateId));
}
public string newPost(string blogid, string username, string password, XmlRpcStruct rpcstruct, bool publish)
{
Authenticate(username, password);
CheckUserRights(blogid);
var entryTitleRaw = rpcstruct["title"];
if (entryTitleRaw == null)
{
throw new ArgumentException("'title' must be provided");
}
var entryTitle = entryTitleRaw.ToString();
var currentBlog = GetContentDatabase().GetItem(blogid);
if (currentBlog != null)
{
var blogItem = new BlogHomeItem(currentBlog);
var settings = BlogSettingsResolver.Resolve(blogItem);
var template = new TemplateID(settings.EntryTemplateID);
var newItem = ItemManager.AddFromTemplate(entryTitle, template, currentBlog);
SetItemData(newItem, rpcstruct);
if (publish)
{
ContentHelper.PublishItemAndRequiredAncestors(newItem.ID);
}
return(newItem.ID.ToString());
}
else
{
return(string.Empty);
}
}
/// <summary>
/// Gets blog entries for the given blog which meet the criteria.
/// </summary>
/// <param name="blogRootItem">The root item of the blog to retrieve the entries for.</param>
/// <param name="criteria">The criteria the entries should meet.</param>
/// <param name="resultOrder">The ordering of the results.</param>
/// <returns>The entries matching the criteria.</returns>
public virtual SearchResults <Entry> GetBlogEntries(Item blogRootItem, EntryCriteria criteria, ListOrder resultOrder)
{
if (blogRootItem == null || criteria == null || criteria.PageNumber <= 0 || criteria.PageSize <= 0)
{
return(SearchResults <Entry> .Empty);
}
var cachedEntries = EntryCache?.Get(criteria, resultOrder);
if (cachedEntries != null)
{
return(cachedEntries);
}
var customBlogItem = (from templateId in Settings.BlogTemplateIds
where TemplateManager.TemplateIsOrBasedOn(blogRootItem, templateId)
select(BlogHomeItem) blogRootItem).FirstOrDefault();
if (customBlogItem == null)
{
customBlogItem = (from templateId in Settings.BlogTemplateIds
let item = blogRootItem.FindAncestorByTemplate(templateId, TemplateManager)
where item != null
select(BlogHomeItem) item).FirstOrDefault();
}
if (customBlogItem == null)
{
return(SearchResults <Entry> .Empty);
}
var blogSettings = BlogSettingsResolver.Resolve(customBlogItem);
using (var context = CreateSearchContext(blogRootItem))
{
var builder = PredicateBuilder.Create <EntryResultItem>(searchItem =>
searchItem.TemplateId == blogSettings.EntryTemplateID &&
searchItem.Paths.Contains(customBlogItem.ID) &&
searchItem.Language.Equals(customBlogItem.InnerItem.Language.Name, StringComparison.InvariantCulture)
);
// Tag
if (!string.IsNullOrEmpty(criteria.Tag))
{
builder = builder.And(i => i.Tags.Contains(criteria.Tag));
}
// Categories
if (!string.IsNullOrEmpty(criteria.Category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(customBlogItem, criteria.Category);
// If the category is unknown, don't return any results.
if (categoryItem == null)
{
return(SearchResults <Entry> .Empty);
}
builder = builder.And(i => i.Category.Contains(categoryItem.ID));
}
if (criteria.MinimumDate != null)
{
builder = builder.And(i => i.EntryDate >= criteria.MinimumDate);
}
if (criteria.MaximumDate != null)
{
builder = builder.And(i => i.EntryDate <= criteria.MaximumDate);
}
var indexresults = context.GetQueryable <EntryResultItem>().Where(builder);
if (resultOrder == ListOrder.Descending)
{
indexresults = indexresults.OrderByDescending(item => item.EntryDate)
.ThenByDescending(item => item.CreatedDate)
.ThenByDescending(item => item.Title);
}
else
{
indexresults = indexresults.OrderBy(item => item.EntryDate)
.ThenBy(item => item.CreatedDate)
.ThenBy(item => item.Title);
}
indexresults = indexresults.Skip(criteria.PageSize * (criteria.PageNumber - 1))
.Take(criteria.PageSize < int.MaxValue ? criteria.PageSize + 1 : criteria.PageSize);
var entries = indexresults.Select(resultItem =>
// Keep field access inline so the query analyzer can see which fields will be used.
new Entry
{
Uri = resultItem.Uri,
Title = string.IsNullOrWhiteSpace(resultItem.Title) ? resultItem.Name : resultItem.Title,
Tags = resultItem.Tags != null ? resultItem.Tags : Enumerable.Empty <string>(),
EntryDate = resultItem.EntryDate
}
).ToList();
var hasMore = entries.Count > criteria.PageSize;
var entriesPage = entries.Take(criteria.PageSize).ToList();
var results = new SearchResults <Entry>(entriesPage, hasMore);
EntryCache?.Set(criteria, resultOrder, results);
return(results);
}
}
