public static string WikiDeleteArticleRevision(
this UrlHelper urlHelper,
ArticleId articleId,
ArticleRevisionDate revisionDate)
{
return(urlHelper.RouteUrl(RouteNames.WikiArticleRevisionDelete, new { slug = articleId.Slug, revisionDate }));
}
public WikiArticleViewModelBase(
RequestContext requestContext,
ArticleId articleId,
ArticleRevisionDate articleRevisionDate = null,
HeaderTab activeTab = HeaderTab.None)
{
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
if (articleId == null)
{
throw new ArgumentNullException("articleId");
}
this.CurrentRepository = RepositoryRequestInstance.Get(requestContext);
this.CurrentPrincipal = requestContext.HttpContext.User;
this.ArticleId = articleId;
this.DisplayArticleId = articleId;
this.ArticleRevisionDate = articleRevisionDate;
this.ActiveTab = activeTab;
this.Article = this.CurrentRepository.GetArticle(articleId);
this.CanEditArticle = (this.Article == null) || this.Article.CanEdit(this.CurrentPrincipal);
}
public static string WikiArticleEdit(
this UrlHelper urlHelper,
ArticleId articleId,
ArticleRevisionDate revisionDate = null)
{
return(urlHelper.RouteUrl(RouteNames.WikiArticleEdit, new { slug = articleId.Slug, revisionDate }));
}
public ArticleRevisionDiffApiModel(
ArticleId articleId,
ArticleRevisionDate oldRevisionDate,
ArticleRevisionDate newRevisionDate,
Repository repository)
{
var oldRevision = repository.GetArticleRevision(articleId, oldRevisionDate);
string oldHtml = ((oldRevision != null) ? MarkdownService.MakeTextHtmlLinebreaks(oldRevision.MarkdownContent) : null)
?? string.Empty;
var newRevision = repository.GetArticleRevision(articleId, newRevisionDate);
string newHtml = ((newRevision != null) ? MarkdownService.MakeTextHtmlLinebreaks(newRevision.MarkdownContent) : null)
?? string.Empty;
var diff = new Helpers.HtmlDiff(oldHtml, newHtml);
string diffHtml = diff.Build();
this.HtmlDiff = diffHtml;
this.OldText = (oldRevision != null)
? oldRevision.CreatedAt.ToString(ArticleRevisionDate.FormattedDateTimeFormat)
: null;
this.NewText = (newRevision != null)
? newRevision.CreatedAt.ToString(ArticleRevisionDate.FormattedDateTimeFormat)
: null;
}
public ArticleRevisionDiffApiModel(
ArticleSlug articleSlug,
ArticleRevisionDate oldRevisionDate,
ArticleRevisionDate newRevisionDate,
Repository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
var oldRevision = repository.GetArticleRevision(articleSlug, oldRevisionDate);
if (oldRevision == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var newRevision = repository.GetArticleRevision(articleSlug, newRevisionDate);
if (newRevision == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var oldRevisionContent = MarkdownTextService.MakeText(oldRevision.MarkdownContent).ToHtmlLinebreaks();
var newRevisionContent = MarkdownTextService.MakeText(newRevision.MarkdownContent).ToHtmlLinebreaks();
var diff = new Helpers.HtmlDiff(oldRevisionContent ?? string.Empty, newRevisionContent ?? string.Empty);
this.HtmlDiff = diff.Build();
this.OldCreatedAt = oldRevision.CreatedAt.ToString(ArticleRevisionDate.FormattedDateTimeFormat);
this.NewCreatedAt = newRevision.CreatedAt.ToString(ArticleRevisionDate.FormattedDateTimeFormat);
}
public ActionResult Article(string slug, ArticleRevisionDate revisionDate = null, bool redirect = true)
{
var model = new WikiArticleViewModel(this.Request.RequestContext, slug, revisionDate, redirect);
this.Seo.CanonicalUrl = this.GetArticleCanonicalUrl(model);
return(this.View(model));
}
public ArticleRevisionDiffApiModel GetDiff([FromUri] ArticleId slug,
[FromUri] ArticleRevisionDate oldRevisionDate,
[FromUri] ArticleRevisionDate newRevisionDate)
{
var model = new ArticleRevisionDiffApiModel(slug, oldRevisionDate, newRevisionDate, this.CurrentRepository);
return(model);
}
public WikiArticleEditViewModel(
ControllerContext controllerContext,
ArticleSlug articleSlug,
ArticleRevisionDate articleRevisionDate = null)
: base(controllerContext, articleSlug, RouteNames.WikiArticleEdit, articleRevisionDate, HeaderTab.Edit)
{
this.IsCreateMode = !this.ArticlePage.HasArticle;
}
public WikiArticleEditViewModel(
RequestContext requestContext,
ArticleId articleId,
ArticleRevisionDate articleRevisionDate = null)
: base(requestContext, articleId, articleRevisionDate, HeaderTab.Edit)
{
this.IsCreateMode = (this.Article == null || string.IsNullOrWhiteSpace(this.Article.Id));
}
public dynamic GetRevisionPreview([FromUri] ArticleId slug, [FromUri] ArticleRevisionDate revisionDate)
{
var articleRevision = this.GetEnsuredArticleRevision(slug, revisionDate);
var text = articleRevision.CreatedAt.ToString(ArticleRevisionDate.FormattedDateTimeFormat);
var htmlContent = MarkdownService.MakeTextHtmlLinebreaks(articleRevision.MarkdownContent);
return(new { text, htmlContent });
}
public void DeleteRevision([FromUri] ArticleId slug, [FromUri] ArticleRevisionDate revisionDate)
{
bool deleteSuccess = this.CurrentRepository.DeleteArticleRevision(slug, revisionDate);
if (!deleteSuccess)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
}
private ArticleRevision GetEnsuredArticleRevision(ArticleId slug, ArticleRevisionDate articleRevisionDate)
{
var articleRevision = this.CurrentRepository.GetArticleRevision(slug, articleRevisionDate.DateTime);
if (articleRevision == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(articleRevision);
}
public static string WikiArticle(
this UrlHelper urlHelper,
ArticleId articleId,
ArticleRevisionDate revisionDate = null,
bool redirect = true)
{
var noRedirectValue = redirect ? null : "0";
return(urlHelper.RouteUrl(
RouteNames.WikiArticle,
new { slug = articleId.Slug, revisionDate, redirect = noRedirectValue }));
}
public ArticleRevisionListItem(ArticleRevisionItem articleRevision, UserManager <WikiDownUser> userManager)
{
var articleRevisionDate = new ArticleRevisionDate(articleRevision.CreatedAt);
this.Date = articleRevisionDate;
this.IsActive = articleRevision.IsActive;
var createdByUser = !string.IsNullOrWhiteSpace(articleRevision.CreatedByUserName)
? userManager.FindByName(articleRevision.CreatedByUserName)
: null;
this.UserName = (createdByUser != null) ? createdByUser.UserName : null;
}
public WikiArticleViewModel(
ControllerContext controllerContext,
ArticleSlug articleSlug,
ArticleRevisionDate articleRevisionDate = null,
bool shouldRedirect = false,
bool handleIndexSlug = true)
: this(controllerContext,
articleSlug,
articleRevisionDate,
shouldRedirect,
handleIndexSlug,
WikiDownConfig.Instance)
{
}
public WikiArticleViewModel(
ControllerContext controllerContext,
ArticleSlug articleSlug,
ArticleRevisionDate articleRevisionDate,
bool shouldRedirect,
bool handleIndexSlug,
WikiDownConfig config)
: base(controllerContext,
articleSlug,
RouteNames.WikiArticle,
articleRevisionDate,
HeaderTab.Article,
shouldRedirect)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
this.handleIndexSlug = handleIndexSlug;
if (this.ArticlePage.HasRedirect && !this.ShouldRedirect)
{
return;
}
this.articleTags = (this.ArticlePage.HasArticle && this.ArticlePage.ArticleTags != null)
? this.ArticlePage.ArticleTags.ToList()
: this.ArticleTags;
if (!this.HasArticle)
{
return;
}
if (string.IsNullOrWhiteSpace(this.ArticlePage.ArticleRevisionMarkdownContent))
{
return;
}
string articleHtml = GetCachedArticleHtml(
this.ArticlePage.ArticleRevisionId,
this.ArticlePage.ArticleRevisionMarkdownContent,
config);
this.htmlContent = !string.IsNullOrWhiteSpace(articleHtml)
? new WikiDownArticleHtmlString(articleHtml, this.CurrentRepository)
: null;
}
public ArticleRevisionApiModel(ArticleId articleId, ArticleRevision articleRevision)
{
this.Slug = articleId.Slug;
if (articleRevision == null)
{
return;
}
this.MarkdownContent = articleRevision.MarkdownContent;
var articleRevisionDate = new ArticleRevisionDate(articleRevision.CreatedAt);
this.DateId = articleRevisionDate.DateTimeId;
this.DateFormatted = articleRevisionDate.DateTimeFormatted;
}
public ArticleRevisionApiModel(ArticleSlug articleSlug, ArticleRevision articleRevision)
{
this.Slug = articleSlug.Slug;
if (articleRevision == null)
{
return;
}
this.MarkdownContent = articleRevision.MarkdownContent;
var articleRevisionDate = new ArticleRevisionDate(articleRevision.CreatedAt);
this.DateId = articleRevisionDate.DateTimeId;
this.DateFormatted = articleRevisionDate.DateTimeFormatted;
}
public ArticleRevisionListItemApiModel(ArticleRevisionItem articleRevision)
{
this.CreatedByUserName = articleRevision.CreatedByUserName;
this.EditSummary = articleRevision.EditSummary;
this.IsActive = articleRevision.IsActive;
var articleRevisionDate = new ArticleRevisionDate(articleRevision.CreatedAt);
this.Id = articleRevisionDate.DateTimeId;
this.Text = articleRevisionDate.DateTimeFormatted;
var lastPublished = articleRevision.LastPublishedAt;
this.LastPublishedAt = lastPublished.HasValue
? lastPublished.Value.ToString(ArticleRevisionDate.FormattedDateTimeFormat)
: null;
}
protected WikiArticleViewModelBase(
ControllerContext controllerContext,
ArticleSlug articleSlug,
string routeName,
ArticleRevisionDate articleRevisionDate = null,
HeaderTab activeTab = HeaderTab.None,
bool shouldRedirect = false)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (controllerContext.RequestContext == null)
{
throw new ArgumentOutOfRangeException(
"controllerContext",
"RequestContext in ControllerContext is null.");
}
if (articleSlug == null)
{
throw new ArgumentNullException("articleSlug");
}
if (routeName == null)
{
throw new ArgumentNullException("routeName");
}
this.RequestContext = controllerContext.RequestContext;
this.RouteName = routeName;
this.ArticleRevisionDate = articleRevisionDate;
this.ActiveTab = activeTab;
this.ShouldRedirect = shouldRedirect;
this.CurrentRepository = this.RequestContext.HttpContext.GetRepository();
this.CurrentPrincipal = this.RequestContext.HttpContext.User;
this.UrlHelper = new UrlHelper(this.RequestContext);
var revisionDate = (this.ArticleRevisionDate != null) ? this.ArticleRevisionDate.Value : (DateTime?)null;
this.ArticlePage = this.CurrentRepository.GetArticlePage(articleSlug, revisionDate);
this.alternativeActionResultLazy = new Lazy<ActionResult>(this.ResolveAlternativeActionResult);
}
public WikiArticleViewModel(
RequestContext requestContext,
ArticleId articleId,
ArticleRevisionDate articleRevisionDate = null,
bool shouldRedirect = false)
: base(requestContext, articleId, articleRevisionDate, HeaderTab.Article)
{
this.ShouldRedirect = shouldRedirect;
this.HtmlContent = new HtmlString(string.Empty);
this.ArticleTags = EmptyCollection;
var articleResult = CurrentRepository.GetArticleResult(articleId, articleRevisionDate);
this.ArticleRedirectFrom = articleResult.ArticleRedirectFromSlug;
this.ArticleRedirectTo = articleResult.ArticleRedirectToSlug;
if (articleResult.HasRedirect && !shouldRedirect)
{
return;
}
this.ArticleTags = (articleResult.HasArticle && articleResult.Article.Tags != null)
? articleResult.Article.Tags.ToList()
: this.ArticleTags;
this.DisplayArticleId = articleResult.HasArticle ? articleResult.Article.Id : this.DisplayArticleId;
if (!articleResult.HasArticle || articleResult.ArticleRevision == null)
{
return;
}
this.HasArticle = true;
this.HtmlContent = new WikiDownArticleHtmlString(articleResult, this.CurrentRepository);
}
private ArticleRevision GetEnsuredArticleRevision(ArticleSlug slug, ArticleRevisionDate articleRevisionDate)
{
var articleRevision = this.CurrentRepository.GetArticleRevision(slug, articleRevisionDate.DateTime);
if (articleRevision == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return articleRevision;
}
public static string WikiArticle(
this UrlHelper urlHelper,
ArticleSlug articleSlug,
ArticleRevisionDate revisionDate = null,
bool shouldRedirect = true,
bool includeHash = false)
{
var noRedirectValue = shouldRedirect ? null : "0";
var url = urlHelper.RouteUrl(
RouteNames.WikiArticle,
new { slug = articleSlug.Slug, revisionDate, redirect = noRedirectValue });
return includeHash ? AppendHash(url, articleSlug) : url;
}
public static string WikiArticleEdit(
this UrlHelper urlHelper,
ArticleSlug articleSlug,
ArticleRevisionDate revisionDate = null)
{
return urlHelper.RouteUrl(RouteNames.WikiArticleEdit, new { slug = articleSlug.Slug, revisionDate });
}
public ArticleRevisionApiModel GetRevision([FromUri] ArticleId slug, [FromUri] ArticleRevisionDate revisionDate)
{
var articleRevision = this.GetEnsuredArticleRevision(slug, revisionDate);
return(new ArticleRevisionApiModel(slug, articleRevision));
}
public ActionResult Edit(string slug, ArticleRevisionDate revisionDate = null)
{
var model = new WikiArticleEditViewModel(this.Request.RequestContext, slug, revisionDate);
return(this.View(model));
}
public ActionResult Edit(string slug, ArticleRevisionDate revisionDate = null)
{
var model = new WikiArticleEditViewModel(this.ControllerContext, slug, revisionDate);
return model.AlternativeActionResult ?? this.View(model);
}
public ActionResult Article(string slug, ArticleRevisionDate revisionDate = null, bool redirect = true)
{
var model = new WikiArticleViewModel(this.ControllerContext, slug, revisionDate, redirect);
return model.AlternativeActionResult ?? this.View(model);
}
