protected override async Task BootstrapProcessAsync(TagHelperContext context, TagHelperOutput output) {
ChildDetectionMode = true;
await output.GetChildContentAsync();
ChildDetectionMode = false;
output.TagName = RenderAsDiv ? "div" : "ul";
output.AddCssClass("list-group");
await output.GetChildContentAsync(false);
}
private async Task<string> GetContent(TagHelperOutput output)
{
if (Content == null)
return (await output.GetChildContentAsync()).GetContent();
return Content.Model?.ToString();
}
/// <inheritdoc />
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
await output.GetChildContentAsync();
var formContext = ViewContext.FormContext;
if (formContext.HasEndOfFormContent)
{
foreach (var content in formContext.EndOfFormContent)
{
output.PostContent.Append(content);
}
}
// Reset the FormContext
ViewContext.FormContext = null;
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var localizer = Localizer ?? GetViewLocalizer();
var aspLocAttr = output.Attributes["asp-loc"];
if (aspLocAttr != null)
{
var resourceKey = aspLocAttr.Minimized
? (await output.GetChildContentAsync()).GetContent()
: aspLocAttr.Value.ToString();
output.Content.SetContent(localizer.GetHtml(resourceKey));
output.Attributes.Remove(aspLocAttr);
}
var localizeAttributes = output.Attributes.Where(attr => attr.Name.StartsWith("asp-loc-", StringComparison.OrdinalIgnoreCase)).ToList();
foreach (var attribute in localizeAttributes)
{
var attributeToLocalize = output.Attributes[attribute.Name.Substring("asp-loc-".Length)];
if (attributeToLocalize != null)
{
var resourceKey = attribute.Minimized
? attributeToLocalize.Value.ToString()
: attribute.Value.ToString();
attributeToLocalize.Value = localizer.GetHtml(resourceKey);
}
output.Attributes.Remove(attribute);
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "div";
if (output.Attributes["class"].IsNull())
{
output.Attributes["class"] = "item";
}
else
{
output.Attributes["class"].Value += " item";
}
/*
<div class="item">
<i class="marker icon"></i>
<div class="content">@Html.DisplayFor(x => item.FullAddress)</div>
</div>
*/
var html = new StringBuilder();
html.Append($"<i class='{Icon} icon'></i>");
html.Append($"<div class='content'>{Content}</div>");
var childContent = output.GetChildContentAsync();
output.Content.SetHtmlContent(html.ToString());
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var childContent = await output.GetChildContentAsync();
var modalContext = (ModalContext)context.Items[typeof(ModalTagHelper)];
modalContext.Body = childContent;
output.SuppressOutput();
}
/// <inheritdoc />
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
await output.GetChildContentAsync();
var formContext = ViewContext.FormContext;
if (formContext.HasEndOfFormContent)
{
// Perf: Avoid allocating enumerator
for (var i = 0; i < formContext.EndOfFormContent.Count; i++)
{
output.PostContent.AppendHtml(formContext.EndOfFormContent[i]);
}
}
// Reset the FormContext
ViewContext.FormContext = null;
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
(HtmlHelper as ICanHasViewContext)?.Contextualize(ViewContext);
var content = await output.GetChildContentAsync();
output.Content.SetContent(HtmlHelper.Hidden(Name, content.GetContent(HtmlEncoder)));
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "div";
output.AppendClass("widget-box");
output.AppendClass(Class);
var originalContent = await output.GetChildContentAsync();
var innerHtml = originalContent.GetContent();
output.Content.Clear();
if (!innerHtml.Contains(WidgetBoxHeaderHelper.HeaderCss))
{
// user is taking easy/lazy way of declaring the widget box
output.Content.Append(WidgetBoxHeaderHelper.GetFullHeader(Title, IsCollapsible));
var widgetBodyDiv = WidgetBoxBodyHelper.GetFullBodyInternals(Padding, innerHtml);
output.Content.Append(widgetBodyDiv);
}
else
{
// user is doing the hardwork themselves
output.Content.AppendHtml(innerHtml);
}
base.Process(context, output);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var bytes = await _redisCache.GetAsync(context.UniqueId);
string content;
if (bytes == null)
{
var childContent = await output.GetChildContentAsync();
content = childContent.GetContent();
bytes = Encoding.UTF8.GetBytes(content);
await _redisCache.SetAsync(context.UniqueId, bytes, new DistributedCacheEntryOptions
{
AbsoluteExpiration = AbsoluteExpiration,
AbsoluteExpirationRelativeToNow = RelativeAbsoluteExpiration,
SlidingExpiration = SlidingExpiration
});
}
else
{
content = Encoding.UTF8.GetString(bytes);
}
output.SuppressOutput();
// Unsupress by setting the content again.
output.Content.SetHtmlContent(content);
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
var originalContent = await output.GetChildContentAsync();
output.AppendClass("form-group");
TagBuilder labelBuilder = null;
if (!originalContent.GetContent().Contains("<label"))
{
labelBuilder = FormGroupLabel.Get(Horizontal, LabelText);
}
var contentDiv = new TagBuilder("div");
if (Horizontal)
{
contentDiv.AddCssClass("col-sm-8");
}
contentDiv.InnerHtml.AppendHtml(originalContent.GetContent());
output.TagName = "div";
output.Content.Clear();
if (labelBuilder != null)
{
output.Content.Append(labelBuilder);
}
output.Content.Append(contentDiv);
base.Process(context, output);
}
protected override async Task BootstrapProcessAsync(TagHelperContext context, TagHelperOutput output) {
output.TagName = "nav";
output.PreContent.AppendHtml(Size == SimpleSize.Default
? "<ul class=\"pagination\">"
: $"<ul class=\"pagination pagination-{Size.GetDescription()}\">");
ChildDetectionMode = true;
context.SetPaginationContext(this);
await output.GetChildContentAsync(true);
ChildDetectionMode = false;
if (!DisableAutoActive && Items.TrueForAll(pI => !pI.Active)) {
PaginationItemTagHelper activeItem = Items.FirstOrDefault(ItemHasCurrentUrl);
if (activeItem != null)
activeItem.Active = true;
}
for (var i = 0; i < Items.Count; i++)
if (string.IsNullOrEmpty(Items[i].Content))
Items[i].Content = (i + 1).ToString();
if (Items.Any(pI => pI.Active)) {
if (PrevHref == null)
PrevHref = Items.TakeWhile(pI => !pI.Active).LastOrDefault(pI => !pI.Disabled)?.Href;
if (NextHref == null)
NextHref = Items.SkipWhile(pI => !pI.Active).Skip(1).FirstOrDefault(pI => !pI.Disabled)?.Href;
}
DisableNext = NextHref == null || DisableNext.HasValue && DisableNext.Value == false;
DisablePrev = PrevHref == null || DisablePrev.HasValue && DisablePrev.Value == false;
output.PreContent.AppendHtml(
PaginationItemTagHelper.RenderItemTag(
"<span aria-hidden=\"true\">«</span>",
PrevHref, DisablePrev.Value, false,
PrevText ?? Ressources.Previous));
output.PostContent.AppendHtml(
PaginationItemTagHelper.RenderItemTag(
"<span aria-hidden=\"true\">»</span>",
NextHref, DisableNext.Value, false,
NextText ?? Ressources.Next));
if (MaxDisplayedItems > 0 && Items.Count > MaxDisplayedItems)
if (Items.Any(pI => pI.Active)) {
MaxDisplayedItems--;
List<PaginationItemTagHelper> itemsBeforeActive =
Items.TakeWhile(pI => !pI.Active).Reverse().ToList();
List<PaginationItemTagHelper> itemsAfterActive = Items.SkipWhile(pI => !pI.Active).Skip(1).ToList();
var itemsCountBeforeActive = (int) Math.Floor((decimal) MaxDisplayedItems/2);
var itemsCountAfterActive = (int) Math.Ceiling((decimal) MaxDisplayedItems/2);
if (itemsCountAfterActive > itemsAfterActive.Count)
itemsCountBeforeActive += itemsCountAfterActive - itemsAfterActive.Count;
else if (itemsCountBeforeActive > itemsBeforeActive.Count)
itemsCountAfterActive += itemsCountBeforeActive - itemsBeforeActive.Count;
foreach (PaginationItemTagHelper item in itemsBeforeActive.Skip(itemsCountBeforeActive))
item.RenderOutput = false;
foreach (PaginationItemTagHelper item in itemsAfterActive.Skip(itemsCountAfterActive))
item.RenderOutput = false;
}
else
foreach (PaginationItemTagHelper item in Items.Skip(MaxDisplayedItems))
item.RenderOutput = false;
foreach (PaginationItemTagHelper item in Items.Where(pI => pI.RenderOutput))
output.Content.AppendHtml(PaginationItemTagHelper.RenderItemTag(item));
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
output.TagName = null;
for (int i = 0; i < Count; i++)
{
output.Content.Append(await output.GetChildContentAsync());
}
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var childContent = await output.GetChildContentAsync();
// Find Urls in the content and replace them with their anchor tag equivalent.
output.Content.SetHtmlContent(Regex.Replace(
childContent.GetContent(),
@"\b(www\.)(\S+)\b",
"<a target=\"_blank\" href=\"http://$0\">$0</a>")); // www version
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "a"; // Replaces <email> with <a> tag
var content = await output.GetChildContentAsync();
var target = content.GetContent() + "@" + EmailDomain;
output.Attributes["href"] = "mailto:" + target;
output.Content.SetContent(target);
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
var originalContent = await output.GetChildContentAsync();
var labelBuilder = Get(Horizontal, originalContent.GetContent());
output.TagName = labelBuilder.TagName;
if (labelBuilder.Attributes.ContainsKey("class"))
{
output.Attributes.Add("class", labelBuilder.Attributes["class"]);
}
output.Content.SetContent(labelBuilder.InnerHtml);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var varVal = Environment.GetEnvironmentVariable("Hosting:Environment");
if (varVal == NamesValue || (string.IsNullOrEmpty(NamesValue) && string.IsNullOrEmpty(varVal)))
{
var childContent = output.GetChildContentAsync().Result;
output.Content.AppendHtml(childContent.GetContent());
}
else
{
output.SuppressOutput();
}
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
output.SuppressOutput();
var originalContent = await output.GetChildContentAsync();
var headerDiv = GetHeader();
headerDiv.InnerHtml.AppendHtml(originalContent.GetContent());
output.Content.Clear();
output.Content.Append(headerDiv);
base.Process(context, output);
}
protected override async Task BootstrapProcessAsync(TagHelperContext context, TagHelperOutput output) {
output.TagName = "div";
output.AddCssClass("alert");
output.AddCssClass("alert-" + Context.ToString().ToLower());
output.Attributes.Add("role", "attribute");
if (Dismissable)
output.PreContent.SetHtmlContent(
$"<button type=\"button\" class=\"close\" data-dismiss=\"alert\" aria-label=\"{Ressources.CloseIconText}\"><span aria-hidden=\"true\">×</span></button>");
if (!DisableLinkStyling) {
var content = await output.GetChildContentAsync(true);
output.Content.SetHtmlContent(Regex.Replace(content.GetContent(), "<a( [^>]+)?>", AddLinkStyle));
}
}
protected override async Task BootstrapProcessAsync(TagHelperContext context, TagHelperOutput output) {
output.TagName = Href == null ? "div" : "a";
output.AddCssClass("thumbnail");
output.TagMode=TagMode.StartTagAndEndTag;
output.PreContent.AppendHtml($"<img src=\"{Src}\" alt=\"{Alt}\" />" );
if (Href!=null)
output.Attributes.Add("href",Href);
TagHelperContent content = (await output.GetChildContentAsync(true));
if (!content.IsEmpty && !content.IsWhiteSpace) {
output.PreContent.AppendHtml("<div class=\"caption\">");
output.PostContent.SetHtmlContent("</div>");
}
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var childContent = await output.GetChildContentAsync();
var lines = childContent
.GetContent()
.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
.Select(line => line.Trim());
var content = string.Join(" ", lines);
var transformedContent = CommonMark.CommonMarkConverter.Convert(content);
output.Content.SetHtmlContent(transformedContent);
output.Attributes.RemoveAll("markdown");
}
public async override Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (String.IsNullOrEmpty(Name))
{
throw new ArgumentException("The name attribute can't be empty");
}
var childContent = await output.GetChildContentAsync();
var zone = _layoutAccessor.GetLayout().Zones[Name];
zone.Add(childContent, Position);
// Don't render the zone tag or the inner content
output.SuppressOutput();
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
output.SuppressOutput();
var originalContent = await output.GetChildContentAsync();
var bodyContainer = GetBodyContainer(Padding);
bodyContainer.WidgetMain.InnerHtml.AppendHtml(originalContent.GetContent());
output.Content.Clear();
output.Content.Append(bodyContainer.WidgetBody);
base.Process(context, output);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var content = await output.GetChildContentAsync();
string copyright = $"<p>© {DateTime.Now.Year} {content.GetContent()}</p>";
output.Content.SetHtmlContent(copyright);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (ShowDismiss)
{
output.PreContent.AppendFormat(@"<button type='button' class='btn btn-default' data-dismiss='modal'>{0}</button>", DismissText);
}
var childContent = await output.GetChildContentAsync();
var footerContent = new DefaultTagHelperContent();
if (ShowDismiss)
{
footerContent.AppendFormat(@"<button type='button' class='btn btn-default' data-dismiss='modal'>{0}</button>", DismissText);
}
footerContent.Append(childContent);
var modalContext = (ModalContext)context.Items[typeof(ModalTagHelper)];
modalContext.Footer = footerContent;
output.SuppressOutput();
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "table";
var c = await output.GetChildContentAsync();
var input = c.GetContent().Replace(""", "\"");
Regex r = new Regex("({|,)\\D(?<propName>\\w+)\\D:\\D(?<value>[^\"]+)\\D");
var matches = r.Matches(input);
var outputBuilder = new StringBuilder();
foreach (Match match in matches)
{
var prop = match.Groups["propName"];
var value = match.Groups["value"];
outputBuilder.Append($"<tr><td>{prop.Value}</td><td>{value.Value}</td><tr>");
}
output.Content.SetContent(new HtmlString(outputBuilder.ToString()));
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
(HtmlHelper as ICanHasViewContext)?.Contextualize(ViewContext);
var content = await output.GetChildContentAsync();
var repeatContent = HtmlHelper.Encode(Expression.Model.ToString());
if (string.IsNullOrEmpty(repeatContent))
{
repeatContent = content.GetContent();
}
for (int i = 0; i < RepeatContent; i++)
{
output.Content.Append(repeatContent);
}
}
/// <inheritdoc />
/// <remarks>Does nothing if <see cref="For"/> is <c>null</c>.</remarks>
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
if (For != null)
{
var tagBuilder = Generator.GenerateValidationMessage(ViewContext,
For.Name,
message: null,
tag: null,
htmlAttributes: null);
if (tagBuilder != null)
{
output.MergeAttributes(tagBuilder);
// We check for whitespace to detect scenarios such as:
// <span validation-for="Name">
// </span>
if (!output.IsContentModified)
{
var childContent = await output.GetChildContentAsync();
if (childContent.IsWhiteSpace)
{
// Provide default label text since there was nothing useful in the Razor source.
output.Content.SetContent(tagBuilder.InnerHtml);
}
else
{
output.Content.SetContent(childContent);
}
}
}
}
}
public async Task GetChildContentAsync_PassesUseCachedResultAsExpected(bool expectedUseCachedResultValue)
{
// Arrange
bool? useCachedResultValue = null;
var output = new TagHelperOutput(
tagName: "p",
attributes: new TagHelperAttributeList(),
getChildContentAsync: useCachedResult =>
{
useCachedResultValue = useCachedResult;
return Task.FromResult<TagHelperContent>(new DefaultTagHelperContent());
});
// Act
await output.GetChildContentAsync(expectedUseCachedResultValue);
// Assert
Assert.Equal(expectedUseCachedResultValue, useCachedResultValue);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
string content = output.GetChildContentAsync().Result.GetContent();
base.Process(context, output);
output.TagName = "li";
var hrefAttr = output.Attributes.FirstOrDefault(a => a.Name == "href");
if (hrefAttr != null)
{
output.Content.SetHtmlContent($@"<a href=""{hrefAttr.Value}"">{content}</a>");
output.Attributes.Remove(hrefAttr);
}
else
output.Content.SetHtmlContent(content);
if (ShouldBeActive())
{
MakeActive(output);
}
}
public async Task GetChildContentAsync_PassesUseCachedResultAsExpected(bool expectedUseCachedResultValue)
{
// Arrange
bool?useCachedResultValue = null;
var output = new TagHelperOutput(
tagName: "p",
attributes: new TagHelperAttributeList(),
getChildContentAsync: useCachedResult =>
{
useCachedResultValue = useCachedResult;
return(Task.FromResult <TagHelperContent>(new DefaultTagHelperContent()));
});
// Act
await output.GetChildContentAsync(expectedUseCachedResultValue);
// Assert
Assert.Equal(expectedUseCachedResultValue, useCachedResultValue);
}
