public async Task <IActionResult> Avatar([FromServices] IBlogCache cache)
{
var fallbackImageFile = Path.Join($"{_env.WebRootPath}", "images", "default-avatar.png");
try
{
var bytes = await cache.GetOrCreateAsync(CacheDivision.General, "avatar", async _ =>
{
_logger.LogTrace("Avatar not on cache, getting new avatar image...");
var data = await _mediator.Send(new GetAssetDataQuery(AssetId.AvatarBase64));
if (string.IsNullOrWhiteSpace(data))
{
return(null);
}
var avatarBytes = Convert.FromBase64String(data);
return(avatarBytes);
});
if (null == bytes)
{
return(PhysicalFile(fallbackImageFile, "image/png"));
}
return(File(bytes, "image/png"));
}
catch (FormatException e)
{
_logger.LogError($"Error {nameof(Avatar)}(), Invalid Base64 string", e);
return(PhysicalFile(fallbackImageFile, "image/png"));
}
}
public async Task Invoke(
HttpContext httpContext,
IBlogConfig blogConfig,
IBlogCache cache,
IOptions <AppSettings> settings,
IRepository <PostEntity> postRepo,
IRepository <PageEntity> pageRepo)
{
if (httpContext.Request.Path == "/sitemap.xml")
{
var xml = await cache.GetOrCreateAsync(CacheDivision.General, "sitemap", async _ =>
{
var url = Helper.ResolveRootUrl(httpContext, blogConfig.GeneralSettings.CanonicalPrefix, true);
var data = await GetSiteMapData(url, settings.Value.SiteMap, postRepo, pageRepo);
return(data);
});
httpContext.Response.ContentType = "text/xml";
await httpContext.Response.WriteAsync(xml, httpContext.RequestAborted);
}
else
{
await _next(httpContext);
}
}
public async Task <IActionResult> Index(string slug)
{
if (string.IsNullOrWhiteSpace(slug))
{
return(BadRequest());
}
var page = await _cache.GetOrCreateAsync(CacheDivision.Page, slug.ToLower(), async entry =>
{
entry.SlidingExpiration = TimeSpan.FromMinutes(AppSettings.CacheSlidingExpirationMinutes["Page"]);
var p = await _customPageService.GetAsync(slug);
return(p);
});
if (page == null)
{
Logger.LogWarning($"Page not found. {nameof(slug)}: '{slug}'");
return(NotFound());
}
if (!page.IsPublished)
{
return(NotFound());
}
return(View(page));
}
public async Task <IActionResult> OnGetAsync(string routeName)
{
if (string.IsNullOrWhiteSpace(routeName))
{
return(NotFound());
}
var pageSize = _blogConfig.ContentSettings.PostListPageSize;
var cat = await _mediator.Send(new GetCategoryByRouteCommand(routeName));
if (cat is null)
{
return(NotFound());
}
ViewData["CategoryDisplayName"] = cat.DisplayName;
ViewData["CategoryRouteName"] = cat.RouteName;
ViewData["CategoryDescription"] = cat.Note;
var postCount = await _cache.GetOrCreateAsync(CacheDivision.PostCountCategory, cat.Id.ToString(),
_ => _mediator.Send(new CountPostQuery(CountType.Category, cat.Id)));
var postList = await _mediator.Send(new ListPostsQuery(pageSize, P, cat.Id));
Posts = new(postList, P, pageSize, postCount);
return(Page());
}
public Task <IReadOnlyList <Category> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
return(_cache.GetOrCreateAsync(CacheDivision.General, "allcats", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
var list = await _catRepo.SelectAsync(Category.EntitySelector);
return list;
}));
}
public Task <IReadOnlyList <Category> > GetAll()
{
return(_cache.GetOrCreateAsync(CacheDivision.General, "allcats", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
var list = await _catRepo.SelectAsync(_categorySelector);
return list;
}));
}
public async Task <PostSlug> GetAsync(PostSlugInfo slugInfo)
{
var date = new DateTime(slugInfo.Year, slugInfo.Month, slugInfo.Day);
var spec = new PostSpec(date, slugInfo.Slug);
var pid = await _postRepository.SelectFirstOrDefaultAsync(spec, p => p.Id);
if (pid == Guid.Empty)
{
return(null);
}
var psm = await _cache.GetOrCreateAsync(CacheDivision.Post, $"{pid}", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromMinutes(AppSettings.CacheSlidingExpirationMinutes["Post"]);
var postSlugModel = await _postRepository.SelectFirstOrDefaultAsync(spec, post => new PostSlug
{
Title = post.Title,
ContentAbstract = post.ContentAbstract,
PubDateUtc = post.PubDateUtc.GetValueOrDefault(),
Categories = post.PostCategory.Select(pc => pc.Category).Select(p => new Category
{
DisplayName = p.DisplayName,
RouteName = p.RouteName
}).ToArray(),
RawPostContent = post.PostContent,
Hits = post.PostExtension.Hits,
Likes = post.PostExtension.Likes,
Tags = post.PostTag.Select(pt => pt.Tag)
.Select(p => new Tag
{
NormalizedName = p.NormalizedName,
DisplayName = p.DisplayName
}).ToArray(),
Id = post.Id,
CommentEnabled = post.CommentEnabled,
ExposedToSiteMap = post.ExposedToSiteMap,
LastModifyOnUtc = post.LastModifiedUtc,
ContentLanguageCode = post.ContentLanguageCode,
CommentCount = post.Comment.Count(c => c.IsApproved)
});
if (null != postSlugModel)
{
postSlugModel.RawPostContent = AddLazyLoadToImgTag(postSlugModel.RawPostContent);
}
return(postSlugModel);
});
return(psm);
}
public async Task <IActionResult> Atom([FromServices] IBlogCache cache)
{
return(await cache.GetOrCreateAsync(CacheDivision.General, "atom", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
var xml = await _syndicationService.GetAtomData();
return Content(xml, "text/xml");
}));
}
public async Task <IActionResult> Rss(string routeName = null)
{
bool hasRoute = !string.IsNullOrWhiteSpace(routeName);
var route = hasRoute ? routeName.ToLower().Trim() : null;
return(await _cache.GetOrCreateAsync(
hasRoute?CacheDivision.PostCountCategory : CacheDivision.General, route ?? "rss", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
var xml = await _syndicationService.GetRssStringAsync(routeName);
if (string.IsNullOrWhiteSpace(xml))
{
return (IActionResult)NotFound();
}
return Content(xml, "text/xml");
}));
}
public async Task <IActionResult> SiteMap([FromServices] IBlogConfig blogConfig, [FromServices] IBlogCache cache)
{
return(await cache.GetOrCreateAsync(CacheDivision.General, "sitemap", async entry =>
{
var url = ResolveRootUrl(blogConfig);
var bytes = await _searchService.GetSiteMapStreamArrayAsync(url);
var xmlContent = Encoding.UTF8.GetString(bytes);
return Content(xmlContent, "text/xml");
}));
}
public async Task <IActionResult> SiteMap([FromServices] IBlogConfig blogConfig, [FromServices] IBlogCache cache)
{
return(await cache.GetOrCreateAsync(CacheDivision.General, "sitemap", async _ =>
{
var url = Helper.ResolveRootUrl(HttpContext, blogConfig.GeneralSettings.CanonicalPrefix, true);
var bytes = await _searchService.GetSiteMapStreamArrayAsync(url);
var xmlContent = Encoding.UTF8.GetString(bytes);
return Content(xmlContent, "text/xml");
}));
}
public async Task OnGet(int p = 1)
{
var pagesize = _blogConfig.ContentSettings.PostListPageSize;
var posts = await _mediator.Send(new ListPostsQuery(pagesize, p));
var count = await _cache.GetOrCreateAsync(CacheDivision.General, "postcount", _ => _mediator.Send(new CountPostQuery(CountType.Public)));
var list = new StaticPagedList <PostDigest>(posts, p, pagesize, count);
Posts = list;
}
public Task <IReadOnlyList <Category> > GetAllAsync()
{
return(_cache.GetOrCreateAsync(CacheDivision.General, "allcats", async entry =>
{
var list = await _categoryRepository.SelectAsync(c => new Category
{
Id = c.Id,
DisplayName = c.DisplayName,
RouteName = c.RouteName,
Note = c.Note
});
return list;
}));
}
public async Task <IActionResult> Rss([FromServices] IBlogCache cache, string routeName = null)
{
bool hasRoute = !string.IsNullOrWhiteSpace(routeName);
var route = hasRoute ? routeName.ToLower().Trim() : null;
return(await cache.GetOrCreateAsync(
hasRoute?CacheDivision.PostCountCategory : CacheDivision.General, route ?? "rss", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
var bytes = await _syndicationService.GetRssStreamDataAsync(routeName);
var xmlContent = Encoding.UTF8.GetString(bytes);
return Content(xmlContent, "text/xml");
}));
}
public Task <IReadOnlyList <Category> > GetAllAsync()
{
return(_cache.GetOrCreateAsync(CacheDivision.General, "allcats", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
var list = await _catRepo.SelectAsync(c => new Category
{
Id = c.Id,
DisplayName = c.DisplayName,
RouteName = c.RouteName,
Note = c.Note
});
return list;
}));
}
public async Task Invoke(HttpContext httpContext, IBlogConfig blogConfig, IBlogCache cache, ISiteMapWriter siteMapWriter)
{
if (httpContext.Request.Path == "/sitemap.xml")
{
var xml = await cache.GetOrCreateAsync(CacheDivision.General, "sitemap", async _ =>
{
var url = Helper.ResolveRootUrl(httpContext, blogConfig.GeneralSettings.CanonicalPrefix, true);
var data = await siteMapWriter.GetSiteMapData(url);
return(data);
});
httpContext.Response.ContentType = "text/xml";
await httpContext.Response.WriteAsync(xml);
}
else
{
await _next(httpContext);
}
}
public async Task <IViewComponentResult> InvokeAsync()
{
try
{
var menus = await _cache.GetOrCreateAsync(CacheDivision.General, "menu", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromMinutes(20);
var items = await _menuService.GetAllAsync();
return(items);
});
return(View(menus));
}
catch (Exception e)
{
return(Content(e.Message));
}
}
public async Task <IActionResult> Page(string slug)
{
if (string.IsNullOrWhiteSpace(slug))
{
return(BadRequest());
}
var page = await _cache.GetOrCreateAsync(CacheDivision.Page, slug.ToLower(), async entry =>
{
entry.SlidingExpiration = TimeSpan.FromMinutes(_settings.CacheSlidingExpirationMinutes["Page"]);
var p = await _pageService.GetAsync(slug);
return(p);
});
if (page is null || !page.IsPublished)
{
return(NotFound());
}
return(View(page));
}
public async Task <IActionResult> OnGet(string normalizedName)
{
var tagResponse = await _mediator.Send(new GetTagQuery(normalizedName));
if (tagResponse is null)
{
return(NotFound());
}
var pagesize = _blogConfig.ContentSettings.PostListPageSize;
var posts = await _mediator.Send(new ListByTagQuery(tagResponse.Id, pagesize, P));
var count = await _cache.GetOrCreateAsync(CacheDivision.PostCountTag, tagResponse.Id.ToString(), _ => _mediator.Send(new CountPostQuery(CountType.Tag, tagId: tagResponse.Id)));
ViewData["TitlePrefix"] = tagResponse.DisplayName;
var list = new StaticPagedList <PostDigest>(posts, P, pagesize, count);
Posts = list;
return(Page());
}
public async Task <Post> Handle(GetPostBySlugQuery request, CancellationToken cancellationToken)
{
var date = new DateTime(request.Slug.Year, request.Slug.Month, request.Slug.Day);
// Try to find by checksum
var slugCheckSum = Helper.ComputeCheckSum($"{request.Slug.Slug}#{date:yyyyMMdd}");
ISpecification <PostEntity> spec = new PostSpec(slugCheckSum);
var pid = await _postRepo.SelectFirstOrDefaultAsync(spec, p => p.Id);
if (pid == Guid.Empty)
{
// Post does not have a checksum, fall back to old method
spec = new PostSpec(date, request.Slug.Slug);
pid = await _postRepo.SelectFirstOrDefaultAsync(spec, x => x.Id);
if (pid == Guid.Empty)
{
return(null);
}
// Post is found, fill it's checksum so that next time the query can be run against checksum
var p = await _postRepo.GetAsync(pid);
p.HashCheckSum = slugCheckSum;
await _postRepo.UpdateAsync(p);
}
var psm = await _cache.GetOrCreateAsync(CacheDivision.Post, $"{pid}", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromMinutes(_settings.CacheSlidingExpirationMinutes["Post"]);
var post = await _postRepo.SelectFirstOrDefaultAsync(spec, Post.EntitySelector);
return(post);
});
return(psm);
}
public async Task <IActionResult> OnGetAsync(string slug)
{
if (string.IsNullOrWhiteSpace(slug))
{
return(BadRequest());
}
var page = await _cache.GetOrCreateAsync(CacheDivision.Page, slug.ToLower(), async entry =>
{
entry.SlidingExpiration = TimeSpan.FromMinutes(_settings.CacheSlidingExpirationMinutes["Page"]);
var p = await _mediator.Send(new GetPageBySlugQuery(slug));
return(p);
});
if (page is null || !page.IsPublished)
{
return(NotFound());
}
BlogPage = page;
return(Page());
}
public async Task <IActionResult> Css()
{
try
{
var css = await _cache.GetOrCreateAsync(CacheDivision.General, "theme", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromMinutes(20);
// Fall back to default theme for migration
if (_blogConfig.GeneralSettings.ThemeId == 0)
{
_blogConfig.GeneralSettings.ThemeId = 1;
await _blogConfig.SaveAsync(_blogConfig.GeneralSettings);
}
var data = await _themeService.GetStyleSheet(_blogConfig.GeneralSettings.ThemeId);
return(data);
});
if (css == null)
{
return(NotFound());
}
var uCss = Uglify.Css(css);
if (uCss.HasErrors)
{
return(Conflict(uCss.Errors));
}
return(Content(uCss.Code, "text/css"));
}
catch (InvalidDataException e)
{
return(Conflict(e.Message));
}
}