public ArticleSlugConflictException(
ArticleSlug articleSlug,
string message = null,
Exception innerException = null)
: base(articleSlug, HttpStatusCode.Conflict, message ?? GetDefaultMessage(articleSlug), innerException)
{
}
//private static readonly Regex ExternalLinkRegex = new Regex(HtmlAgilityPackHelper.ExternalLinkRegexPattern);
public ArticleRevision(
ArticleSlug articleSlug,
IPrincipal principal,
string createdByIpAddress,
string markdownContent,
string editSummary = null)
{
if (articleSlug == null)
{
throw new ArgumentNullException("articleSlug");
}
if (principal == null)
{
throw new ArgumentNullException("principal");
}
this.CreatedByUserName = principal.Identity.Name;
this.CreatedByIpAddress = createdByIpAddress;
this.EditSummary = editSummary;
this.MarkdownContent = markdownContent;
this.UpdateInternal();
this.CreatedAt = DateTime.UtcNow;
}
public ArticleRevisionNotFoundException(
ArticleSlug articleSlug,
ArticleRevisionDate articleRevisionDate,
string message = null,
Exception innerException = null)
: this(null, articleSlug, articleRevisionDate, message, innerException)
{
}
public ArticleRedirect(
ArticleSlug targetArticleSlug,
ArticleSlug redirectToArticleSlug,
string redirectToArticleHash = null)
{
this.TargetArticleSlug = targetArticleSlug.Slug;
this.RedirectToArticleHash = redirectToArticleHash;
this.RedirectToArticleSlug = redirectToArticleSlug.Slug;
}
public ArticlePage(
ArticleSlug articleSlug,
Article article,
ArticleRevision articleRevision = null,
ArticleRedirect articleRedirect = null)
: base(articleSlug, article, articleRevision, articleRedirect)
{
this.PopulateArticleRevision(articleRevision);
}
public WikiDownArticleException(
ArticleSlug articleSlug,
HttpStatusCode? httpStatusCode = null,
string message = null,
Exception innerException = null)
: base(httpStatusCode, message, innerException)
{
this.ArticleSlug = articleSlug;
}
public Article(ArticleSlug articleSlug, IEnumerable<string> tags = null, ArticleAccess articleAccess = null)
{
if (articleSlug == null)
{
throw new ArgumentNullException("articleSlug");
}
this.Slug = articleSlug.Slug;
this.Tags = tags ?? Enumerable.Empty<string>();
this.ArticleAccess = articleAccess ?? ArticleAccess.Default();
}
public ArticleRevisionNotFoundException(
string articleRevisionId,
ArticleSlug articleSlug = null,
ArticleRevisionDate articleRevisionDate = null,
string message = null,
Exception innerException = null)
: base(articleSlug,
HttpStatusCode.NotFound,
message ?? GetDefaultMessage(articleRevisionId, articleSlug, articleRevisionDate),
innerException)
{
this.ArticleRevisionId = articleRevisionId;
this.ArticleRevisionDate = articleRevisionDate;
}
public ArticlePageBase(
ArticleSlug articleSlug,
Article article,
ArticleRevision articleRevision = null,
ArticleRedirect articleRedirect = null)
{
this.ArticleSlug = articleSlug;
PopulateArticle(article);
PopulateArticleRevision(articleRevision);
PopulateArticleRedirect(articleRedirect);
this.ArticleAccess = this.ArticleAccess ?? ArticleAccess.Default();
this.ArticleSlug = this.ArticleSlug ?? ArticleSlug.Empty;
this.ArticleTags = this.ArticleTags ?? Enumerable.Empty<string>();
this.ArticleRevisionDate = this.ArticleRevisionDate ?? ArticleRevisionDate.Empty;
this.RedirectedFromArticleSlug = this.RedirectedFromArticleSlug ?? ArticleSlug.Empty;
this.ArticleRevisionOutboundArticleSlugs = this.ArticleRevisionOutboundArticleSlugs
?? Enumerable.Empty<string>();
}
private static string GetDefaultMessage(
string articleRevisionId,
ArticleSlug articleSlug,
ArticleRevisionDate articleRevisionDate)
{
string message = "ArticleRevision not found.";
if (!string.IsNullOrWhiteSpace(articleRevisionId))
{
message += string.Format(" Article Revision ID: '{0}'.", articleRevisionId);
}
if (articleSlug != null && articleSlug.HasValue)
{
message += string.Format(" Article Slug: '{0}'.", articleSlug.Slug);
}
if (articleRevisionDate != null && articleRevisionDate.HasValue)
{
message += string.Format(" Article Revision Date: '{0}'.", articleRevisionDate.DateTimeFormatted);
}
return message;
}
public IRavenQueryable<ArticleRedirect> QueryArticleRedirects(ArticleSlug redirectToArticleSlug)
{
AssertArticleSlug(redirectToArticleSlug, "redirectToArticleSlug");
return (from redirect in this.CurrentSession.Query<ArticleRedirect, ArticleRedirectsIndex>()
where redirect.RedirectToArticleSlug == redirectToArticleSlug.Slug
orderby redirect.TargetArticleSlug
select redirect).Handled();
}
public static ArticleSlugStatus FromArticleRedirect(ArticleSlug articleSlug, ArticleRedirect articleRedirect)
{
if (articleSlug == null)
{
throw new ArgumentNullException("articleSlug");
}
if (articleRedirect == null)
{
throw new ArgumentNullException("articleRedirect");
}
return new ArticleSlugStatus
{
ArticleSlug = articleSlug,
ArticleRedirectToSlug = articleRedirect.RedirectToArticleSlug
};
}
public static ArticleSlugStatus FromCapitalized(ArticleSlug articleSlug, Article capitalizedArticle)
{
if (articleSlug == null)
{
throw new ArgumentNullException("articleSlug");
}
if (capitalizedArticle == null)
{
throw new ArgumentNullException("capitalizedArticle");
}
return new ArticleSlugStatus { ArticleSlug = capitalizedArticle.Slug, ArticleSlugCapitalized = articleSlug };
}
public IRavenQueryable<ArticlePageBase> QueryArticleRevisions(ArticleSlug articleSlug)
{
AssertArticleSlug(articleSlug);
var query = this.QueryActiveArticleRevisions(articleSlug);
return query.TransformWith<ArticleRevisionArticlePageBaseTransformer, ArticlePageBase>().Handled();
}
private static string CapitalizeSlug(ArticleSlug articleSlug)
{
string slug = articleSlug.Slug;
if (slug.Length < 1)
{
return null;
}
string slugUpper = char.ToUpper(slug[0]) + slug.Substring(1);
return (slug != slugUpper) ? slugUpper : null;
}
public ArticleRevision PublishArticleRevision(ArticleSlug articleSlug, ArticleRevisionDate revisionDate)
{
AssertArticleSlug(articleSlug);
AssertArticleRevisionDate(revisionDate, "revisionDate");
var article = this.GetArticleAsserted(articleSlug);
var articleRevision = this.GetArticleRevisionAsserted(articleSlug, revisionDate);
if (article.ActiveArticleRevisionId == null)
{
article.ActiveArticleRevisionId = articleRevision.Id;
}
if (article.ActiveArticleRevisionId == articleRevision.Id)
{
return articleRevision;
}
var publishedArticleRevision = articleRevision.Clone();
publishedArticleRevision.Id = null;
publishedArticleRevision.CreatedAt = DateTime.UtcNow;
publishedArticleRevision.CreatedByUserName = this.currentPrincipalIdentityName;
this.CurrentSession.Store(publishedArticleRevision);
article.ActiveArticleRevisionId = publishedArticleRevision.Id;
return publishedArticleRevision;
}
private static string GetDefaultMessage(ArticleSlug articleSlug)
{
return (articleSlug != null && articleSlug.HasValue)
? string.Format("Article with ID '{0}' not found.", articleSlug.Slug)
: "Cannot find article.";
}
private ArticleRevision TryGetArticleRevision(ArticleSlug articleSlug, ArticleRevisionDate revisionDate)
{
var article = this.GetArticle(articleSlug);
return (article != null) ? this.TryGetArticleRevision(article.Id, revisionDate) : null;
}
public ArticleRevision SaveArticleRevision(ArticleSlug articleSlug, string markdownContent, string editSummary)
{
AssertArticleSlug(articleSlug);
var article = this.TryGetArticle(articleSlug) ?? new Article(articleSlug);
this.SaveArticle(article);
var articleRevision = new ArticleRevision(
articleSlug,
this.currentPrincipal,
this.currentIpAddress,
markdownContent,
editSummary);
if (string.IsNullOrWhiteSpace(markdownContent))
{
return null;
}
var activeArticleRevision = this.GetLatestArticleRevision(article.Id);
bool isContentEqualToActiveRevision = (activeArticleRevision != null)
&& (activeArticleRevision.MarkdownContent
== articleRevision.MarkdownContent);
if (isContentEqualToActiveRevision)
{
return null;
}
articleRevision.ArticleId = article.Id;
this.CurrentSession.Store(articleRevision);
article.ActiveArticleRevisionId = articleRevision.Id;
return articleRevision;
}
private IRavenQueryable<ArticleRevisionsIndex.Result> QueryActiveArticleRevisions(ArticleSlug articleSlug)
{
var query = QueryActiveArticleRevisions();
if (articleSlug != null && articleSlug.HasValue)
{
query = query.Where(x => x.ArticleSlug == articleSlug.Slug);
}
return query.Handled();
}
private Article GetOrCreateArticle(
ArticleSlug articleSlug,
ArticleAccessType accessType = ArticleAccessType.CanRead)
{
var article = this.TryGetArticle(articleSlug, accessType);
if (article == null)
{
article = new Article(articleSlug);
this.CurrentSession.Store(article);
}
return article;
}
private ArticleRevision GetArticleRevisionAsserted(ArticleSlug articleSlug, ArticleRevisionDate revisionDate)
{
AssertArticleSlug(articleSlug);
AssertArticleRevisionDate(revisionDate, "revisionDate");
var articleRevision = this.TryGetArticleRevision(articleSlug, revisionDate);
if (articleRevision == null)
{
throw new ArticleRevisionNotFoundException(articleSlug, revisionDate);
}
return articleRevision;
}
private Article GetArticleAsserted(
ArticleSlug articleSlug,
ArticleAccessType accessType = ArticleAccessType.CanRead)
{
var article = this.TryGetArticle(articleSlug, accessType);
if (article == null)
{
throw new ArticleNotFoundException(articleSlug);
}
return article;
}
public void RevertArticleToDraft(ArticleSlug articleSlug)
{
AssertArticleSlug(articleSlug);
var article = this.GetOrCreateArticle(articleSlug);
article.ActiveArticleRevisionId = null;
}
public IRavenQueryable<ArticlePageBase> QueryArticlePagesByTag(ArticleSlug tagName)
{
var query =
this.QueryAccessibleArticles().Where(x => x.Tags.Contains(tagName.Title)).OrderBy(x => x.ArticleSlug);
return query.TransformWith<ArticleArticlePageBaseTransformer, ArticlePageBase>().Handled();
}
private static string GetDefaultMessage(ArticleSlug articleSlug)
{
return (articleSlug != null && articleSlug.HasValue)
? string.Format("Conflict for Article Slug '{0}'.", articleSlug.Slug)
: "Conflict for Article Slug.";
}
public ArticleNotFoundException(ArticleSlug articleSlug, string message = null, Exception innerException = null)
: base(articleSlug, HttpStatusCode.NotFound, message ?? GetDefaultMessage(articleSlug), innerException)
{
}
public ArticleSlugConflictException(ArticleSlug articleSlug)
: this(articleSlug, GetDefaultMessage(articleSlug))
{
}
private Article TryGetArticle(ArticleSlug articleSlug, ArticleAccessType accessType = ArticleAccessType.CanRead)
{
var articles =
this.CurrentSession.Query<ArticlesIndex.Result, ArticlesIndex>()
.Customize(x => x.WaitForNonStaleResultsAsOfLastWrite())
.Where(
x => this.CurrentPrincipalAccessLevel >= x.CanReadAccess && x.ArticleSlug == articleSlug.Slug)
.OfType<Article>();
var article = articles.FirstOrDefaultHandled();
return article.EnsureAccess(this.currentPrincipal, accessType);
}
private static void AssertArticleSlug(ArticleSlug articleSlug, string paramName = "articleSlug")
{
if (articleSlug == null)
{
throw new ArgumentNullException(paramName);
}
if (!articleSlug.HasValue)
{
throw new ArgumentOutOfRangeException(paramName);
}
}
