private void ProcessAsset(TagHelperOutput output)
{
if (string.IsNullOrEmpty(Src))
{
return;
}
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
if (!urlHelper.IsLocalUrl(Src))
{
output.Attributes.SetAttribute(SRC_ATTRIBUTE_NAME, Src);
return;
}
//remove the application path from the generated URL if exists
var pathBase = ViewContext.HttpContext?.Request?.PathBase ?? PathString.Empty;
PathString.FromUriComponent(Src).StartsWithSegments(pathBase, out var sourceFile);
if (!_assetPipeline.TryGetAssetFromRoute(sourceFile, out var asset))
{
asset = _assetPipeline.AddJavaScriptBundle(sourceFile, sourceFile);
}
output.Attributes.SetAttribute(SRC_ATTRIBUTE_NAME, $"{Src}?v={asset.GenerateCacheKey(ViewContext.HttpContext)}");
}
static public Link BeginLink(
this IHtmlHelper html,
string controllerName,
string actionName,
object routeValues,
object htmlAttributes)
{
IUrlHelperFactory urlHelperFactory = new UrlHelperFactory();
string action;
if (actionName == null && controllerName == null && routeValues == null)
{
var request = html.ViewContext.HttpContext.Request;
action = request.PathBase + request.Path + request.QueryString;
}
else
{
var urlHelper = urlHelperFactory.GetUrlHelper(html.ViewContext);
action = urlHelper.Action(action: actionName, controller: controllerName, values: routeValues);
}
var writer = html.ViewContext.Writer;
TagBuilder linkCore = GenerateLinkCore(action, htmlAttributes);
if (linkCore != null)
{
linkCore.TagRenderMode = TagRenderMode.StartTag;
writer.WriteLine(linkCore);
}
return(new Link(writer));
}
/// <summary>
/// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
/// </summary>
/// <param name="url">The URL to resolve.</param>
/// <param name="resolvedUrl">
/// Absolute URL beginning with the application's virtual root. <c>null</c> if <paramref name="url"/> could
/// not be resolved.
/// </param>
/// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
protected bool TryResolveUrl(string url, out IHtmlContent resolvedUrl)
{
resolvedUrl = null;
var start = FindRelativeStart(url);
if (start == -1)
{
return(false);
}
var trimmedUrl = CreateTrimmedString(url, start);
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
var appRelativeUrl = urlHelper.Content(trimmedUrl);
var postTildeSlashUrlValue = trimmedUrl.Substring(2);
if (!appRelativeUrl.EndsWith(postTildeSlashUrlValue, StringComparison.Ordinal))
{
throw new InvalidOperationException(
Resources.FormatCouldNotResolveApplicationRelativeUrl_TagHelper(
url,
nameof(IUrlHelper),
nameof(IUrlHelper.Content),
"removeTagHelper",
typeof(UrlResolutionTagHelper).FullName,
typeof(UrlResolutionTagHelper).GetTypeInfo().Assembly.GetName().Name));
}
resolvedUrl = new EncodeFirstSegmentContent(
appRelativeUrl,
appRelativeUrl.Length - postTildeSlashUrlValue.Length,
postTildeSlashUrlValue);
return(true);
}
public IUrlHelper GetUrlHelper(ActionContext context)
{
var originalUrlHelperFactory = new UrlHelperFactory();
var originalUrlHelper = originalUrlHelperFactory.GetUrlHelper(context);
return(new CustomUrlHelper(context, originalUrlHelper, _urlRoutesOptions));
}
public async Task Enrich(ResultExecutingContext response)
{
var urlHelper = new UrlHelperFactory().GetUrlHelper(response);
if (response.Result is OkObjectResult okObjectResult)
{
if (okObjectResult.Value is T model)
{
await EnrichModel(model, urlHelper);
}
else if (okObjectResult.Value is List <T> collection)
{
ConcurrentBag <T> bag = new ConcurrentBag <T>(collection);
Parallel.ForEach(bag, (element) =>
{
EnrichModel(element, urlHelper);
});
}
else if (okObjectResult.Value is PagedSearchDTO <T> pageSearch)
{
Parallel.ForEach(pageSearch.List.ToList(), (element) =>
{
EnrichModel(element, urlHelper);
});
}
}
await Task.FromResult <object>(null);
}
public void ReturnAUrlHelper_WhenCalledWithANonNullRequestContext()
{
var factory = new UrlHelperFactory();
var urlHelper = factory.Create(new RequestContext());
Assert.IsInstanceOf <UrlHelper>(urlHelper);
}
/// <summary>
/// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
/// </summary>
/// <param name="url">The URL to resolve.</param>
/// <param name="resolvedUrl">
/// Absolute URL beginning with the application's virtual root. <c>null</c> if <paramref name="url"/> could
/// not be resolved.
/// </param>
/// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
protected bool TryResolveUrl(string url, out IHtmlContent resolvedUrl)
{
resolvedUrl = null;
var start = FindRelativeStart(url);
if (start == -1)
{
return(false);
}
url = url.Remove(start, 2).Insert(start, $"~/themes/{Theme.Key}/");
var trimmedUrl = CreateTrimmedString(url, start);
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
var appRelativeUrl = urlHelper.Content(trimmedUrl);
var postTildeSlashUrlValue = trimmedUrl.Substring(2);
if (!appRelativeUrl.EndsWith(postTildeSlashUrlValue, StringComparison.Ordinal))
{
throw new InvalidOperationException("");
}
resolvedUrl = new EncodeFirstSegmentContent(
appRelativeUrl,
appRelativeUrl.Length - postTildeSlashUrlValue.Length,
postTildeSlashUrlValue);
return(true);
}
public void Activate_ActivatesAndContextualizesPropertiesOnViews()
{
// Arrange
var modelMetadataProvider = new EmptyModelMetadataProvider();
var modelExpressionProvider = new ModelExpressionProvider(modelMetadataProvider, new ExpressionTextCache());
var urlHelperFactory = new UrlHelperFactory();
var jsonHelper = new JsonHelper(
new JsonOutputFormatter(new JsonSerializerSettings(), ArrayPool <char> .Shared),
ArrayPool <char> .Shared);
var htmlEncoder = new HtmlTestEncoder();
var diagnosticSource = new DiagnosticListener("Microsoft.AspNetCore");
var activator = new RazorPageActivator(
new EmptyModelMetadataProvider(),
urlHelperFactory,
jsonHelper,
diagnosticSource,
htmlEncoder,
modelExpressionProvider);
var instance = new TestRazorPage();
var myService = new MyService();
var helper = Mock.Of <IHtmlHelper <object> >();
var serviceProvider = new ServiceCollection()
.AddSingleton(myService)
.AddSingleton(helper)
.AddSingleton(new ExpressionTextCache())
.BuildServiceProvider();
var httpContext = new DefaultHttpContext
{
RequestServices = serviceProvider
};
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewContext = new ViewContext(
actionContext,
Mock.Of <IView>(),
new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary()),
Mock.Of <ITempDataDictionary>(),
TextWriter.Null,
new HtmlHelperOptions());
var urlHelper = urlHelperFactory.GetUrlHelper(viewContext);
// Act
activator.Activate(instance, viewContext);
// Assert
Assert.Same(helper, instance.Html);
Assert.Same(myService, instance.MyService);
Assert.Same(viewContext, myService.ViewContext);
Assert.Same(diagnosticSource, instance.DiagnosticSource);
Assert.Same(htmlEncoder, instance.HtmlEncoder);
Assert.Same(jsonHelper, instance.Json);
Assert.Same(urlHelper, instance.Url);
Assert.Null(instance.MyService2);
}
public static void setPagesPath(ActionContext ctx, IEnumerable <ControlPage> pages)
{
var urlHelper = new UrlHelperFactory().GetUrlHelper(ctx);
foreach (var page in pages)
{
setPagePath(urlHelper, page);
}
}
public RazorPageActivatorTest()
{
DiagnosticListener = new DiagnosticListener("Microsoft.AspNetCore");
HtmlEncoder = new HtmlTestEncoder();
JsonHelper = Mock.Of <IJsonHelper>();
MetadataProvider = new EmptyModelMetadataProvider();
ModelExpressionProvider = new ModelExpressionProvider(MetadataProvider);
UrlHelperFactory = new UrlHelperFactory();
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
output.Attributes.SetAttribute("href", urlHelper.Action(new UrlActionContext
{
Controller = Controller,
Action = Action
}));
output.PreContent.SetContent($"{nameof(TestTagHelper)} content.");
}
public virtual void Contextualize(ViewContext viewContext)
{
ViewContext = viewContext;
UrlHelper = UrlHelperFactory.GetUrlHelper(viewContext);
parents = (Stack <IWritableItem>)viewContext.HttpContext.Items[ParentStackContextKey];
if (parents == null)
{
parents = new Stack <IWritableItem>(5);
parents.Push(null);
viewContext.HttpContext.Items[ParentStackContextKey] = parents;
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
if (AngHref != null)
{
string href = "{{" + AngHref.GetName() + "}}";
if (AngHrefRoute != null)
{
href = UrlHelperFactory.GetUrlHelper(ViewContext).Content(AngHrefRoute) + href;
}
href = $"{AngHrefPrefix}{href}{AngHrefSuffix}";
output.Attributes.SetAttribute("ng-href", href);
}
}
private string GetFormAction()
{
var routeLink = Route != null;
var actionLink = Controller != null || Action != null;
var pageLink = Page != null || PageHandler != null;
// make local copy
var routeValues = new RouteValueDictionary(RouteValues);
// Unconditionally replace any value from asp-route-area.
if (Area != null)
{
routeValues["area"] = Area;
}
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
if (pageLink)
{
return(urlHelper.Page(
Page,
PageHandler,
routeValues,
protocol: null,
host: null,
fragment: Fragment));
}
if (routeLink)
{
return(urlHelper.RouteUrl(
Route,
routeValues,
protocol: null,
host: null,
fragment: Fragment));
}
return(urlHelper.Action(
Action,
Controller,
routeValues,
protocol: null,
host: null,
fragment: Fragment));
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
base.Process(context, output);
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext) as FullUrlHelper;
if (urlHelper == null)
{
return;
}
if (output.PostElement != null && !output.PostElement.IsEmptyOrWhiteSpace)
{
var content = output.PostElement.GetContent();
output.PostElement.SetHtmlContent(hrefRegex.Replace(content,
match => "src=\"" + urlHelper.Content(match.Groups[1].Value) + "\""));
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
if (Controller != null && Action != null)
{
var methodParameters = output.Attributes.ToDictionary(attribute => attribute.Name,
attribute => attribute.Value);
// We remove all attributes from the resulting HTML element because they're supposed to
// be parameters to our final href value.
output.Attributes.Clear();
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
output.Attributes.SetAttribute("href", urlHelper.Action(Action, Controller, methodParameters));
output.PreContent.SetContent("My ");
}
}
public void GetUrlHelper_CreatesNewInstance_IfNotAlreadyPresent()
{
// Arrange
var httpContext = new Mock <HttpContext>();
httpContext.SetupGet(h => h.Features).Returns(new FeatureCollection());
httpContext.Setup(h => h.Items).Returns(new Dictionary <object, object>());
var actionContext = CreateActionContext(httpContext.Object);
var urlHelperFactory = new UrlHelperFactory();
// Act
var urlHelper = urlHelperFactory.GetUrlHelper(actionContext);
// Assert
Assert.NotNull(urlHelper);
Assert.Same(urlHelper, actionContext.HttpContext.Items[typeof(IUrlHelper)] as IUrlHelper);
}
public void AssignThumbnailUrl(FileSystemInfo fileSystemInfo, IClientFileSystemItem clientItem)
{
if (clientItem.IsDirectory || !CanGenerateThumbnail(fileSystemInfo))
{
return;
}
if (!(fileSystemInfo is FileInfo fileInfo))
{
return;
}
var helper = UrlHelperFactory.GetUrlHelper(ActionContextAccessor.ActionContext);
var thumbnail = GetThumbnail(fileInfo);
var relativeThumbnailPath = Path.Combine(ThumbnailsDirectory.Name, thumbnail.Directory?.Name, thumbnail.Name);
clientItem.CustomFields["thumbnailUrl"] = helper.Content(relativeThumbnailPath);
}
/// <summary>
/// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
/// </summary>
/// <param name="url">The URL to resolve.</param>
/// <param name="resolvedUrl">Absolute URL beginning with the application's virtual root. <c>null</c> if
/// <paramref name="url"/> could not be resolved.</param>
/// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
protected bool TryResolveUrl(string url, out string resolvedUrl)
{
resolvedUrl = null;
var start = FindRelativeStart(url);
if (start == -1)
{
return(false);
}
var trimmedUrl = CreateTrimmedString(url, start);
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
resolvedUrl = urlHelper.Content(trimmedUrl);
return(true);
}
/// <summary>
/// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
/// </summary>
/// <param name="url">The URL to resolve.</param>
/// <param name="resolvedUrl">Absolute URL beginning with the application's virtual root. <c>null</c> if
/// <paramref name="url"/> could not be resolved.</param>
/// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
protected bool TryResolveUrl(string url, out string resolvedUrl)
{
resolvedUrl = null;
var start = FindRelativeStart(url);
if (start == -1)
{
return(false);
}
url = url.Remove(start, 2).Insert(start, $"~/themes/{Theme.Key}/");
var trimmedUrl = CreateTrimmedString(url, start);
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
resolvedUrl = urlHelper.Content(trimmedUrl);
return(true);
}
public void Can_Generate_Page_Links()
{
//Arrange
var urlHelper = new Mock<IUrlHelper>();
urlHelper.SetupSequence(x => x.Action(It.IsAny<UrlActionContext>())
.Returns("Test/Page1")
.Returns("Test/Page2")
.Returns("Test/Page3");
var urlHelperFactory = new Mock<IUrlHelperFactory>();
UrlHelperFactory.Setup(f =>
f.GetUrlHelper(It.IsAny<ActionContext>()))
.Returns(urlHelper.Object);
PageLinkTagHelper helper =
new PageLinkTagHelper(UrlHelperFactory.Object)
{
PageModel = new PagingInfo
{
CurrentPage = 2,
TotalItems = 28,
ItemsPerPage = 10
},
PageAction = "Test"
};
TagHelperContext ctx = new TagHelperContext(
new TagHelperAttributeList(),
new Dictionary<object, object>(), "");
var content = new Mock<TagHelperContent>();
TagHelperOutput output = new TagHelperOutput("div",
new TagHelperAttributeList(),
(cache, encoder) => Task.FromResult(content.Object));
//Act
helper.Process(ctx, output);
// Assert
Assert.Equal(@"<a href=""Test/Page1"">1</a>"
+ @"<a href=""Test/Page2"">2</a>"
+ @"<a href=""Test/Page3"">3</a>",
output.Content.GetContent());
}
/// <summary>
/// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
/// </summary>
/// <param name="url">The URL to resolve.</param>
/// <param name="resolvedUrl">Absolute URL beginning with the application's virtual root. <c>null</c> if
/// <paramref name="url"/> could not be resolved.</param>
/// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
protected bool TryResolveUrl(string url, out string resolvedUrl)
{
resolvedUrl = null;
if (url == null)
{
return(false);
}
var trimmedUrl = url.Trim(ValidAttributeWhitespaceChars);
// Before doing more work, ensure that the URL we're looking at is app-relative.
if (trimmedUrl.Length >= 2 && trimmedUrl[0] == '~' && trimmedUrl[1] == '/')
{
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
resolvedUrl = urlHelper.Content(trimmedUrl);
return(true);
}
return(false);
}
public async Task Format(ResultExecutingContext context)
{
var urlHelper = new UrlHelperFactory().GetUrlHelper(context);
if (context.Result is OkObjectResult okObjectResult)
{
if (okObjectResult.Value is T model)
{
await FormatModel(model, urlHelper);
}
else if (okObjectResult.Value is List <T> collection)
{
ConcurrentBag <T> bag = new ConcurrentBag <T>(collection);
Parallel.ForEach(bag, (element) =>
{
FormatModel(element, urlHelper);
});
}
}
await Task.FromResult <object>(null);
}
public async Task Enrich(ResultExecutingContext response) //Ela precisa ser asincrona, por ser multiplas exec simultanea
{
var urlHelper = new UrlHelperFactory().GetUrlHelper(response);
if (response.Result is OkObjectResult okObjectResult)
{
if (okObjectResult.Value is T model)
{
await EnrichModel(model, urlHelper);
}
else if (okObjectResult.Value is List <T> collection)
{
ConcurrentBag <T> bag = new ConcurrentBag <T>(collection);
Parallel.ForEach(bag, (element) =>
{
EnrichModel(element, urlHelper);
});
}
}
await Task.FromResult <object>(null);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var actionContext = Accessor.ActionContext;
var urlHelper = UrlHelperFactory.GetUrlHelper(actionContext);
output.TagName = "ul";
var content = await output.GetChildContentAsync();
if (string.IsNullOrWhiteSpace(content.GetContent()) == false)
{
var tags = content.GetContent().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var sb = new StringBuilder();
foreach (var tag in tags)
{
sb.AppendFormat("<li class='d-inline p-1'><a href='{0}' class='btn btn-success'>{1}</a></li>",
urlHelper.Page("index", "tag", new { tag = tag }), tag);
}
output.Content.SetHtmlContent(sb.ToString());
}
}
public async Task Enrich(ResultExecutingContext response)
{
var urlHelper = new UrlHelperFactory().GetUrlHelper(response);
if (response.Result is OkObjectResult okObjectResult)
{
if (okObjectResult.Value is T model)
{
/*await*/ EnrichModel(model, urlHelper); //await removido gerando bug
}
else if (okObjectResult.Value is List <T> collection)
{
ConcurrentBag <T> bag = new ConcurrentBag <T>(collection);
Parallel.ForEach(bag, (element) =>
{
EnrichModel(element, urlHelper);
});
}
await Task.FromResult <object>(null);
}
}
/// <summary>
/// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
/// </summary>
/// <param name="url">The URL to resolve.</param>
/// <param name="resolvedUrl">
/// Absolute URL beginning with the application's virtual root. <c>null</c> if <paramref name="url"/> could
/// not be resolved.
/// </param>
/// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
protected bool TryResolveUrl(string url, out IHtmlContent resolvedUrl)
{
resolvedUrl = null;
if (url == null)
{
return(false);
}
var trimmedUrl = url.Trim(ValidAttributeWhitespaceChars);
// Before doing more work, ensure that the URL we're looking at is app-relative.
if (trimmedUrl.Length >= 2 && trimmedUrl[0] == '~' && trimmedUrl[1] == '/')
{
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
var appRelativeUrl = urlHelper.Content(trimmedUrl);
var postTildeSlashUrlValue = trimmedUrl.Substring(2);
if (!appRelativeUrl.EndsWith(postTildeSlashUrlValue, StringComparison.Ordinal))
{
throw new InvalidOperationException(
Resources.FormatCouldNotResolveApplicationRelativeUrl_TagHelper(
url,
nameof(IUrlHelper),
nameof(IUrlHelper.Content),
"removeTagHelper",
typeof(UrlResolutionTagHelper).FullName,
typeof(UrlResolutionTagHelper).GetTypeInfo().Assembly.GetName().Name));
}
resolvedUrl = new EncodeFirstSegmentContent(
appRelativeUrl,
appRelativeUrl.Length - postTildeSlashUrlValue.Length,
postTildeSlashUrlValue);
return(true);
}
return(false);
}
public void GetUrlHelper_ReturnsSameInstance_IfAlreadyPresent()
{
// Arrange
var expectedUrlHelper = CreateUrlHelper();
var httpContext = new Mock <HttpContext>();
httpContext.SetupGet(h => h.Features).Returns(new FeatureCollection());
var mockItems = new Dictionary <object, object>
{
{ typeof(IUrlHelper), expectedUrlHelper }
};
httpContext.Setup(h => h.Items).Returns(mockItems);
var actionContext = CreateActionContext(httpContext.Object);
var urlHelperFactory = new UrlHelperFactory();
// Act
var urlHelper = urlHelperFactory.GetUrlHelper(actionContext);
// Assert
Assert.Same(expectedUrlHelper, urlHelper);
}
public virtual async Task <RssChannel> GetChannel(CancellationToken cancellationToken = default(CancellationToken))
{
var project = await ProjectService.GetCurrentProjectSettings();
if (project == null)
{
return(null);
}
var itemsToGet = project.DefaultFeedItems;
var requestedFeedItems = ContextAccessor.HttpContext?.Request.Query["maxItems"].ToString();
if (!string.IsNullOrWhiteSpace(requestedFeedItems))
{
int.TryParse(requestedFeedItems, out itemsToGet);
if (itemsToGet > project.MaxFeedItems)
{
itemsToGet = project.MaxFeedItems;
}
}
var posts = await BlogService.GetRecentPosts(itemsToGet);
if (posts == null)
{
return(null);
}
var channel = new RssChannel
{
Title = project.Title,
Copyright = project.CopyrightNotice,
Generator = Name,
RemoteFeedUrl = project.RemoteFeedUrl,
RemoteFeedProcessorUseAgentFragment = project.RemoteFeedProcessorUseAgentFragment
};
if (!string.IsNullOrEmpty(project.Description))
{
channel.Description = project.Description;
}
else
{
// prevent error, channel desc cannot be empty
channel.Description = "Welcome to my blog";
}
if (!string.IsNullOrEmpty(project.ChannelCategoriesCsv))
{
var channelCats = project.ChannelCategoriesCsv.Split(',');
foreach (var cat in channelCats)
{
channel.Categories.Add(new RssCategory(cat));
}
}
var urlHelper = UrlHelperFactory.GetUrlHelper(ActionContextAccesor.ActionContext);
if (!string.IsNullOrEmpty(project.Image))
{
channel.Image.Url = new Uri(urlHelper.Content(project.Image));
}
if (!string.IsNullOrEmpty(project.LanguageCode))
{
channel.Language = new CultureInfo(project.LanguageCode);
}
var baseUrl = string.Concat(
ContextAccessor.HttpContext.Request.Scheme,
"://",
ContextAccessor.HttpContext.Request.Host.ToUriComponent()
);
// asp.net bug? the comments for this method say it returns an absolute fully qualified url but it returns relative
// looking at latest code seems ok so maybe just a bug in rc1
//https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Core/UrlHelperExtensions.cs
//https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Core/Routing/UrlHelper.cs
var indexUrl = urlHelper.RouteUrl(BlogRoutes.BlogIndexRouteName);
if (indexUrl == null)
{
indexUrl = urlHelper.Action("Index", "Blog");
}
if (indexUrl.StartsWith("/"))
{
indexUrl = string.Concat(baseUrl, indexUrl);
}
channel.Link = new Uri(indexUrl);
if (!string.IsNullOrEmpty(project.ManagingEditorEmail))
{
channel.ManagingEditor = project.ManagingEditorEmail;
}
if (!string.IsNullOrEmpty(project.ChannelRating))
{
channel.Rating = project.ChannelRating;
}
var feedUrl = string.Concat(
ContextAccessor.HttpContext.Request.Scheme,
"://",
ContextAccessor.HttpContext.Request.Host.ToUriComponent(),
ContextAccessor.HttpContext.Request.PathBase.ToUriComponent(),
ContextAccessor.HttpContext.Request.Path.ToUriComponent(),
ContextAccessor.HttpContext.Request.QueryString.ToUriComponent());
channel.SelfLink = new Uri(feedUrl);
channel.TimeToLive = project.ChannelTimeToLive;
if (!string.IsNullOrEmpty(project.WebmasterEmail))
{
channel.Webmaster = project.WebmasterEmail;
}
DateTime mostRecentPubDate = DateTime.MinValue;
var items = new List <RssItem>();
foreach (var post in posts)
{
if (!post.PubDate.HasValue)
{
continue;
}
if (post.PubDate.Value > mostRecentPubDate)
{
mostRecentPubDate = post.PubDate.Value;
}
var rssItem = new RssItem
{
Author = post.Author
};
if (post.Categories.Count > 0)
{
foreach (var c in post.Categories)
{
rssItem.Categories.Add(new RssCategory(c));
}
}
var postUrl = await BlogUrlResolver.ResolvePostUrl(post, project).ConfigureAwait(false);
if (string.IsNullOrEmpty(postUrl))
{
//TODO: log
continue;
}
if (postUrl.StartsWith("/"))
{
//postUrl = urlHelper.Content(postUrl);
postUrl = string.Concat(
ContextAccessor.HttpContext.Request.Scheme,
"://",
ContextAccessor.HttpContext.Request.Host.ToUriComponent(),
postUrl);
}
var filteredResult = ContentProcessor.FilterHtmlForRss(post, project, baseUrl);
rssItem.Description = filteredResult.FilteredContent;
if (!filteredResult.IsFullContent)
{
//TODO: localize
var readMore = " <a href='" + postUrl + "'>...read more</a>";
rssItem.Description += readMore;
}
//rssItem.Enclosures
rssItem.Guid = new RssGuid(postUrl, true);
rssItem.Link = new Uri(postUrl);
rssItem.PublicationDate = post.PubDate.Value;
//rssItem.Source
rssItem.Title = post.Title;
items.Add(rssItem);
}
channel.PublicationDate = mostRecentPubDate;
channel.Items = items;
return(channel);
}
/// <inheritdoc />
/// <remarks>Does nothing if user provides an <c>formaction</c> attribute.</remarks>
/// <exception cref="InvalidOperationException">
/// Thrown if <c>formaction</c> attribute is provided and <see cref="Action"/>, <see cref="Controller"/>,
/// <see cref="Fragment"/> or <see cref="Route"/> are non-<c>null</c> or if the user provided <c>asp-route-*</c> attributes.
/// Also thrown if <see cref="Route"/> and one or both of <see cref="Action"/> and <see cref="Controller"/>
/// are non-<c>null</c>
/// </exception>
public override void Process(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
// If "formaction" is already set, it means the user is attempting to use a normal button or input element.
if (output.Attributes.ContainsName(FormAction))
{
if (Action != null ||
Controller != null ||
Area != null ||
Page != null ||
PageHandler != null ||
Fragment != null ||
Route != null ||
(_routeValues != null && _routeValues.Count > 0))
{
// User specified a formaction and one of the bound attributes; can't override that formaction
// attribute.
throw new InvalidOperationException(
Resources.FormatFormActionTagHelper_CannotOverrideFormAction(
FormAction,
output.TagName,
RouteValuesPrefix,
ActionAttributeName,
ControllerAttributeName,
AreaAttributeName,
FragmentAttributeName,
RouteAttributeName,
PageAttributeName,
PageHandlerAttributeName));
}
return;
}
var routeLink = Route != null;
var actionLink = Controller != null || Action != null;
var pageLink = Page != null || PageHandler != null;
if ((routeLink && actionLink) || (routeLink && pageLink) || (actionLink && pageLink))
{
var message = string.Join(
Environment.NewLine,
Resources.FormatCannotDetermineAttributeFor(FormAction, '<' + output.TagName + '>'),
RouteAttributeName,
ControllerAttributeName + ", " + ActionAttributeName,
PageAttributeName + ", " + PageHandlerAttributeName);
throw new InvalidOperationException(message);
}
RouteValueDictionary routeValues = null;
if (_routeValues != null && _routeValues.Count > 0)
{
routeValues = new RouteValueDictionary(_routeValues);
}
if (Area != null)
{
if (routeValues == null)
{
routeValues = new RouteValueDictionary();
}
// Unconditionally replace any value from asp-route-area.
routeValues["area"] = Area;
}
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
string url;
if (pageLink)
{
url = urlHelper.Page(Page, PageHandler, routeValues, protocol: null, host: null, fragment: Fragment);
}
else if (routeLink)
{
url = urlHelper.RouteUrl(Route, routeValues, protocol: null, host: null, fragment: Fragment);
}
else
{
url = urlHelper.Action(Action, Controller, routeValues, protocol: null, host: null, fragment: Fragment);
}
output.Attributes.SetAttribute(FormAction, url);
}
