public HomeController(
IPropertiesService propertiesService,
IBlogsService blogsService)
{
this.propertiesService = propertiesService;
this.blogsService = blogsService;
}
public HttpResponseMessage DeleteBlog(string id, HttpRequestMessage request)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NoContent);
try
{
IBlogsService blogsService = ObjectFactory.GetInstance <IBlogsService>();
var blog = blogsService.Get(String.Format("blogs/{0}", id));
if (blog != null)
{
blogsService.Delete(String.Format("blogs/{0}", id));
}
else
{
response.StatusCode = HttpStatusCode.NotFound;
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public HttpResponseMessage UpdateBlog(string id, HttpRequestMessage request)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NoContent);
try
{
IBlogsService blogsService = ObjectFactory.GetInstance <IBlogsService>();
var blog = blogsService.Get(String.Format("blogs/{0}", id));
if (blog != null)
{
XmlReader reader = XmlReader.Create(request.Content.ReadAsStreamAsync().Result);
SyndicationFeed feed = SyndicationFeed.Load(reader);
if (feed != null)
{
SyndicationItem item = feed.Items.FirstOrDefault();
if (item != null)
{
blog.name = item.Title.Text;
blog.description = item.Summary.Text;
blog.updated = item.LastUpdatedTime;
blog.published = item.PublishDate;
var author = item.Authors.FirstOrDefault();
if (author != null)
{
blog.author = author.Name;
blogsService.Update(blog);
}
else
{
response.StatusCode = HttpStatusCode.BadRequest;
}
}
else
{
response.StatusCode = HttpStatusCode.BadRequest;
}
}
else
{
response.StatusCode = HttpStatusCode.BadRequest;
}
}
else
{
response.StatusCode = HttpStatusCode.NotFound;
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public HttpResponseMessage CreateBlog(HttpRequestMessage request)
{
HttpResponseMessage response = new HttpResponseMessage();
try
{
IBlogsService blogsService = ObjectFactory.GetInstance <IBlogsService>();
XmlReader reader = XmlReader.Create(request.Content.ReadAsStreamAsync().Result);
SyndicationFeed feed = SyndicationFeed.Load(reader);
if (feed != null)
{
SyndicationItem item = feed.Items.FirstOrDefault();
if (item != null)
{
Blog newBlog = new Blog
{
name = item.Title.Text,
description = item.Summary.Text,
updated = item.LastUpdatedTime,
published = item.PublishDate
};
var author = item.Authors.FirstOrDefault();
if (author != null)
{
newBlog.author = author.Name;
blogsService.Create(newBlog);
response.StatusCode = HttpStatusCode.Created;
response.Headers.Add("Location", String.Format("{0}/{1}", this.serviceURI, newBlog.Id));
}
else
{
response.StatusCode = HttpStatusCode.BadRequest;
}
}
else
{
response.StatusCode = HttpStatusCode.BadRequest;
}
}
else
{
response.StatusCode = HttpStatusCode.BadRequest;
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public BlogController(
UserManager <ApplicationUser> userManager,
IBlogsService blogsService,
IWebHostEnvironment environment,
ICommentService commentService)
{
this.userManager = userManager;
this.blogsService = blogsService;
this.environment = environment;
this.commentService = commentService;
}
public BlogsController(
UserManager <ApplicationUser> userManager,
IBlogsService blogServie,
IWebHostEnvironment environment,
IStringValidatorService stringValidator)
{
this.blogServie = blogServie;
this.userManager = userManager;
this.environment = environment;
this.stringValidator = stringValidator;
}
public BlogsUnitTests(TestsInitialize fixture)
{
this.fixture = fixture;
IQueryable <Blog> _fakeBlogs = new List <Blog>()
{
new Blog()
{
BlogId = 1, Name = "Blog 1", Url = "Url 1", Rating = 1
},
new Blog()
{
BlogId = 2, Name = "Blog 2", Url = "Url 2", Rating = 2
},
new Blog()
{
BlogId = 3, Name = "Blog 3", Url = "Url 3", Rating = 3
}
}.AsQueryable();
Mock <DbSet <Blog> > _mockSet = new Mock <DbSet <Blog> >();
_mockSet.As <IAsyncEnumerable <Blog> >().Setup(m => m.GetEnumerator()).Returns(new TestAsyncEnumerator <Blog>(_fakeBlogs.GetEnumerator()));
_mockSet.As <IQueryable <Blog> >().Setup(m => m.Provider).Returns(new TestAsyncQueryProvider <Blog>(_fakeBlogs.Provider));
_mockSet.As <IQueryable <Blog> >().Setup(m => m.Expression).Returns(_fakeBlogs.Expression);
_mockSet.As <IQueryable <Blog> >().Setup(m => m.ElementType).Returns(_fakeBlogs.ElementType);
_mockSet.As <IQueryable <Blog> >().Setup(m => m.GetEnumerator()).Returns(_fakeBlogs.GetEnumerator());
Mock <BloggingContext> _mockContext = new Mock <BloggingContext>();
_mockContext.Setup(c => c.CreateSet <Blog>()).Returns(_mockSet.Object);
_mockContext.Setup(c => c.Blogs).Returns(_mockSet.Object);
Mock <ILogger <Repository <Blog> > > _mockLogger = new Mock <ILogger <Repository <Blog> > >();
IBlogRepository _blogRepository = new BlogRepository(_mockContext.Object, _mockLogger.Object);
_blogsService = new BlogsService(_blogRepository, null);
}
public BlogsApiController(IBlogsService blogsService)
{
this.blogsService = blogsService;
}
public BlogsController(
IBlogsService blogsService
) : base(blogsService)
{
_blogsService = blogsService;
}
public BlogsController(IBlogsService blogsService, IBlogDataService blogDataService)
{
_blogsService = blogsService;
_blogDataService = blogDataService;
}
public BlogController(ICategoriesService categoriesService, IBlogsService blogsService)
{
this.categoriesService = categoriesService;
this.blogsService = blogsService;
}
public HomeController(IPostsService postsService, IBlogsService blogsService, ICategoriesService categoriesService)
{
this.postsService = postsService;
this.blogsService = blogsService;
this.categoriesService = categoriesService;
}
public PostsController(IBlogsService blogsService)
{
_blogsService = blogsService;
}
public HttpResponseMessage GetBlogTagCloud(string id, HttpRequestMessage request)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
try
{
IBlogsService blogsService = ObjectFactory.GetInstance <IBlogsService>();
var blog = blogsService.Get(String.Format("blogs/{0}", id));
var tagCloud = blogsService.GetTagCloud(String.Format("blogs/{0}", id));
if (blog != null)
{
SyndicationFeed blogFeed = new SyndicationFeed
{
Title = new TextSyndicationContent("Blog tag cloud"),
LastUpdatedTime = new DateTimeOffset(DateTime.Now)
};
blogFeed.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
SyndicationItem item = new SyndicationItem();
List <SyndicationItem> itemList = new List <SyndicationItem> {
item
};
blogFeed.Items = itemList;
item.Id = blog.Id;
item.LastUpdatedTime = blog.updated;
item.PublishDate = blog.published;
item.Title = new TextSyndicationContent("Blog tag cloud");
item.Content = SyndicationContent.CreatePlaintextContent(BuildtagCloud(tagCloud));
item.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
SyndicationFeedFormatter formatter = null;
if (this.ClientAcceptsMediaType("application/atom+xml", request))
{
formatter = blogFeed.GetAtom10Formatter();
}
else
{
if (this.ClientAcceptsMediaType("application/rss+xml", request))
{
formatter = blogFeed.GetRss20Formatter();
}
}
response.Content = new ObjectContent(typeof(SyndicationFeedFormatter), formatter);
}
else
{
response.StatusCode = HttpStatusCode.NotFound;
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public HttpResponseMessage GetBlog(string id, HttpRequestMessage request)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
try
{
IBlogsService blogsService = ObjectFactory.GetInstance <IBlogsService>();
var blog = blogsService.Get(String.Format("blogs/{0}", id));
var etag = request.Headers.IfNoneMatch.FirstOrDefault();
if (etag != null && etag.Tag == blog.etag)
{
response.StatusCode = HttpStatusCode.NotModified;
}
else
{
if (blog != null)
{
if (this.ClientAcceptsMediaType("text/html", request))
{
response.Content = new ObjectContent <string>(blog.ToHtml(), "text/html");
}
else
{
SyndicationFeed blogFeed = new SyndicationFeed
{
Title = new TextSyndicationContent("Single Blog"),
LastUpdatedTime = new DateTimeOffset(DateTime.Now)
};
blogFeed.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
SyndicationItem item = new SyndicationItem();
List <SyndicationItem> itemList = new List <SyndicationItem> {
item
};
blogFeed.Items = itemList;
item.Id = blog.Id;
item.LastUpdatedTime = blog.updated;
item.PublishDate = blog.published;
item.Title = new TextSyndicationContent(blog.name);
item.Summary = new TextSyndicationContent(blog.description);
item.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
item.Links.Add(SyndicationLink.CreateAlternateLink(request.RequestUri, "text/html"));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/{1}", this.serviceURI, blog.Id)), "edit", "Edit blog", "application/atom+xml;type=feed", 0));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/{1}/posts", this.serviceURI, blog.Id)), "posts", "Blog posts", "application/atom+xml;type=feed", 0));
item.Authors.Add(new SyndicationPerson(string.Empty, blog.author, string.Empty));
SyndicationFeedFormatter formatter = null;
if (this.ClientAcceptsMediaType("application/atom+xml", request))
{
formatter = blogFeed.GetAtom10Formatter();
}
else
{
if (this.ClientAcceptsMediaType("application/rss+xml", request))
{
formatter = blogFeed.GetRss20Formatter();
}
}
response.Content = new ObjectContent(typeof(SyndicationFeedFormatter), formatter);
}
}
else
{
response.StatusCode = HttpStatusCode.NotFound;
}
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public LinksController(IBlogsService blogsService)
{
_blogsService = blogsService;
}
public CategoriesController(IBlogsService blogsService)
{
_blogsService = blogsService;
}
public BlogsController(IAdminBlogsService service, IBlogsService blogService)
{
this.service = service;
this.blogService = blogService;
}
public BlogController(IBlogsService blogsService, ICommentsService commentsService)
{
this.blogsService = blogsService;
this.commentsService = commentsService;
}
public TagsController(IBlogsService blogsService)
{
_blogsService = blogsService;
}
public HttpResponseMessage GetBlogs(HttpRequestMessage request, int pageIndex = 1, int pageSize = 10)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
try
{
IBlogsService blogsService = ObjectFactory.GetInstance <IBlogsService>();
List <Blog> blogs = blogsService.GetAll(pageIndex, pageSize);
if (blogs != null)
{
if (this.ClientAcceptsMediaType("text/html", request))
{
var blogsHtml = blogs.GenerateBlogsHtml();
response.Content = new ObjectContent <string>(blogsHtml, "text/html");
}
else
{
SyndicationFeed blogsFeed = new SyndicationFeed
{
Title = new TextSyndicationContent("Blogs List"),
LastUpdatedTime = new DateTimeOffset(DateTime.Now)
};
blogsFeed.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
List <SyndicationItem> itemList = new List <SyndicationItem>();
blogsFeed.Items = itemList;
foreach (var blog in blogs)
{
SyndicationItem item = new SyndicationItem
{
Id = blog.Id,
LastUpdatedTime = blog.updated,
PublishDate = blog.published,
Title = new TextSyndicationContent(blog.name),
Summary = new TextSyndicationContent(blog.description)
};
item.Links.Add(SyndicationLink.CreateSelfLink(new Uri(String.Format("{0}/{1}", this.serviceURI, blog.Id))));
item.Links.Add(SyndicationLink.CreateAlternateLink(request.RequestUri, "text/html"));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/{1}", this.serviceURI, blog.Id)), "service.edit", "Edit Blog", "application/atom+xml;type=feed", 0));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/{1}/posts", this.serviceURI, blog.Id)), "service.posts", "Blog posts", "application/atom+xml;type=feed", 0));
var pagingLinks = this.BuildPagingLinks(blogsService.Count(), pageIndex, pageSize, request.RequestUri);
foreach (var link in pagingLinks)
{
item.Links.Add(link);
}
item.Authors.Add(new SyndicationPerson(string.Empty, blog.author, string.Empty));
itemList.Add(item);
}
SyndicationFeedFormatter formatter = null;
if (this.ClientAcceptsMediaType("application/atom+xml", request))
{
formatter = blogsFeed.GetAtom10Formatter();
}
else
{
if (this.ClientAcceptsMediaType("application/rss+xml", request))
{
formatter = blogsFeed.GetRss20Formatter();
}
}
response.Content = new ObjectContent(typeof(SyndicationFeedFormatter), formatter);
}
}
else
{
response.StatusCode = HttpStatusCode.NoContent;
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public CategoriesController(IBlogsService service)
{
this.service = service;
}
public BlogsClientController(IBlogsService blogsService, ILogger <BlogsClientController> logger)
{
_blogsService = blogsService;
_logger = logger;
}
public RandomBlogPostComponent(IBlogsService blogService)
{
this.blogService = blogService;
}
public BlogsController(IBlogsService service)
{
this.service = service;
}
