public SetupModel(
UserManager <User> userManager,
RoleManager <Role> roleManager,
SignInManager <User> signInManager,
IBlogPostService blogService,
ICategoryService catService,
ITagService tagService,
ISettingService settingService,
IThemeService themeService,
IWidgetService widgetService,
IPluginService pluginService,
ILogger <SetupModel> logger)
{
_userManager = userManager;
_roleManager = roleManager;
_signInManager = signInManager;
_blogSvc = blogService;
_catSvc = catService;
_tagSvc = tagService;
_settingSvc = settingService;
_themeService = themeService;
_widgetSvc = widgetService;
this.pluginService = pluginService;
_logger = logger;
}
public BlogIndexingContentProvider(
IBlogPostService blogService,
UrlHelper urlHelper)
{
this.blogService = blogService;
this.urlHelper = urlHelper;
}
public HomeController(
ICustomerService _customerService,
IBlogPostService _blogComentService)
{
this._blogComentService = _blogComentService;
this._customerService = _customerService;
}
/// <summary>
/// Initializes a new instance of the <see cref="BlogPostController"/> class.
/// </summary>
public BlogPostController()
{
if (svc == null)
{
svc = new BlogPostService();
}
}
public BlogPostAdminController(IOrchardServices services, IBlogService blogService, IBlogPostService blogPostService)
{
Services = services;
_blogService = blogService;
_blogPostService = blogPostService;
T = NullLocalizer.Instance;
}
public SettingsModel(
IBlogPostService blogService,
ISettingService settingService)
{
_blogSvc = blogService;
_settingSvc = settingService;
}
public StartPageViewModelFactory(IUmbracoMapper umbracoMapper, IUmbracoService umbracoService,
IBlogPostService blogPostService, IUmbracoHelper umbracoHelper) : base(umbracoMapper, umbracoHelper)
{
_umbracoMapper = umbracoMapper;
_umbracoService = umbracoService;
_blogPostService = blogPostService;
}
public BlogController(IBlogPostService blogPostService, IBlogCommentService blogCommentService, IBlogLikeService blogLikeService, UserManager <ApplicationUser> userManager)
{
this.blogPostService = blogPostService;
this.blogCommentService = blogCommentService;
this.blogLikeService = blogLikeService;
this.userManager = userManager;
}
private static void RecalculateBlogArchive(IRepository<BlogPartArchiveRecord> blogArchiveRepository, IBlogPostService blogPostService, BlogPostPart blogPostPart)
{
blogArchiveRepository.Flush();
// remove all current blog archive records
var blogArchiveRecords =
from bar in blogArchiveRepository.Table
where bar.BlogPart == blogPostPart.BlogPart.Record
select bar;
blogArchiveRecords.ToList().ForEach(blogArchiveRepository.Delete);
// get all blog posts for the current blog
var posts = blogPostService.Get(blogPostPart.BlogPart, VersionOptions.Published);
// create a dictionary of all the year/month combinations and their count of posts that are published in this blog
var inMemoryBlogArchives = new Dictionary<DateTime, int>();
foreach (var post in posts) {
if (!post.Has<CommonPart>())
continue;
var commonPart = post.As<CommonPart>();
var key = new DateTime(commonPart.CreatedUtc.Value.Year, commonPart.CreatedUtc.Value.Month, 1);
if (inMemoryBlogArchives.ContainsKey(key))
inMemoryBlogArchives[key]++;
else
inMemoryBlogArchives[key] = 1;
}
// create the new blog archive records based on the in memory values
foreach (KeyValuePair<DateTime, int> item in inMemoryBlogArchives) {
blogArchiveRepository.Create(new BlogPartArchiveRecord {BlogPart = blogPostPart.BlogPart.Record, Year = item.Key.Year, Month = item.Key.Month, PostCount = item.Value});
}
}
public SettingsModel(
IBlogPostService blogService,
ISettingService settingService)
{
this.blogService = blogService;
this.settingService = settingService;
}
public SetupModel(
IWebHostEnvironment hostingEnvironment,
UserManager <User> userManager,
RoleManager <Role> roleManager,
SignInManager <User> signInManager,
IBlogPostService blogService,
IPageService pageService,
ICategoryService catService,
INavigationService navigationService,
ISettingService settingService,
IThemeService themeService,
IPluginService pluginService,
IWidgetService widgetService,
ILogger <SetupModel> logger)
{
this.hostingEnvironment = hostingEnvironment;
_userManager = userManager;
_roleManager = roleManager;
_signInManager = signInManager;
_blogSvc = blogService;
this.pageService = pageService;
_catSvc = catService;
this.navigationService = navigationService;
this.settingService = settingService;
_themeService = themeService;
this.pluginService = pluginService;
_widgetSvc = widgetService;
_logger = logger;
}
public void SetUp()
{
mockery = new MockRepository();
blogPostService = mockery.DynamicMock<IBlogPostService>();
controller = new PostController(blogPostService);
PrepareController(controller, "post");
}
public GetBlogPost(
IBlogService blogService,
IBlogPostService blogPostService
)
{
_blogService = blogService;
_blogPostService = blogPostService;
}
public ProfileController(IBlogPostService blogPostService, IAccountService accountService,
IUserInfoService userInfoService)
: base(accountService)
{
_accountService = accountService;
_blogPostService = blogPostService;
_userInfoService = userInfoService;
}
public GetBlogPost(
IBlogService blogService,
IBlogPostService blogPostService
)
{
_blogService = blogService;
_blogPostService = blogPostService;
}
public HomeController(IExerciseService exerciseService, IExerciseTypeService exerciseTypeService, SignInManager <CustomIdentityUser> signInManager, ITrainerService trainerService, IBlogPostService blogPostService)
{
_exerciseService = exerciseService;
_exerciseTypeService = exerciseTypeService;
_signInManager = signInManager;
_trainerService = trainerService;
_blogPostService = blogPostService;
}
public RssFeedController(IPostService <TblPosts> postService,
IProductService productService,
IBlogPostService blogPostService)
{
_postService = postService;
_productService = productService;
_blogPostService = blogPostService;
}
public HomeController(UserManager <User> userManager, ICourseService courseService, ISearchService searchService, IBlogPostService blogPostService, IProfileService profileService)
{
this.userManager = userManager;
this.profileService = profileService;
this.blogPostService = blogPostService;
this.courseService = courseService;
this.searchService = searchService;
}
public PostsModel(IBlogPostService blogPostService,
IStatsService statsService,
ISettingService settingService)
{
this.blogPostService = blogPostService;
this.statsService = statsService;
this.settingService = settingService;
}
public DefaultBlogApiOperations(IBlogPostsService blogPosts, IBlogPostService blogPost, IAuthorsService authors,
IAuthorService author)
{
BlogPost = blogPost;
BlogPosts = blogPosts;
Author = author;
Authors = authors;
}
public DefaultBlogApiOperations(IBlogPostsService blogPosts, IBlogPostService blogPost, IAuthorsService authors,
IAuthorService author)
{
BlogPost = blogPost;
BlogPosts = blogPosts;
Author = author;
Authors = authors;
}
public PostsController(ICloudinaryService cloudinaryService, ICommentService commentService, IBlogPostService blogPostService, IHtmlSanitizerService htmlSanitizerService, UserManager <User> userManager)
{
this.cloudinaryService = cloudinaryService;
this.commentService = commentService;
this.userManager = userManager;
this.htmlSanitizerService = htmlSanitizerService;
this.blogPostService = blogPostService;
}
public HomePageViewModel(IBlogPostService blogPostService)
{
_blogPostService = blogPostService;
// Hardcode for now, we'll tweak this later
AvatarImage = "images/nullko.webp";
GreetingsTitle = "Hey, you've found my ooland";
GreetingsText = "I've been hibernating in my cave, waiting for spring flowers to blossom.";
}
public BlogPostsController(IBlogPostService blogPostService, IBlogCategoryService blogCategoryService, ITagService tagService, IBlogPostCategoryService blogPostCategoryService, IBlogPostTagService blogPostTagService, IBlogPostMediaService blogPostMediaService)
{
_blogPostService = blogPostService ?? throw new ArgumentNullException(nameof(blogPostService));
_blogCategoryService = blogCategoryService ?? throw new ArgumentNullException(nameof(blogCategoryService));
_tagService = tagService ?? throw new ArgumentNullException(nameof(tagService));
_blogPostCategoryService = blogPostCategoryService ?? throw new ArgumentNullException(nameof(blogPostCategoryService));
_blogPostTagService = blogPostTagService ?? throw new ArgumentNullException(nameof(blogPostTagService));
_blogPostMediaService = blogPostMediaService ?? throw new ArgumentNullException(nameof(blogPostMediaService));
}
public BlogMutation(IBlogPostService blogService, IUserService userService, IConfiguration configuration)
{
_blogPostService = blogService;
_userService = userService;
_configuration = configuration;
SetupAuthenticationFields();
SetupPostFields();
}
public BlogArchivesPartDriver(
IBlogService blogService,
IBlogPostService blogPostService,
IBlogPathConstraint blogPathConstraint)
{
_blogService = blogService;
_blogPostService = blogPostService;
_blogPathConstraint = blogPathConstraint;
}
public void Setup()
{
mockery = new MockRepository();
blogPostMapper = mockery.DynamicMock<IBlogPostMapper>();
post = mockery.DynamicMock<IBlogPost>();
blogPostRepository = mockery.DynamicMock<IBlogPostRepository>();
service = new BlogPostService(blogPostMapper, blogPostRepository);
}
public AdminController(IBlogPostService blogPostService, IAccountService accountService,
IUserInfoService userInfoService, ICommentService commentService)
: base(accountService)
{
_accountService = accountService;
_blogPostService = blogPostService;
_userInfoService = userInfoService;
_commentService = commentService;
}
public BlogArchivesPartDriver(
IBlogService blogService,
IBlogPostService blogPostService,
IContentManager contentManager)
{
_blogService = blogService;
_blogPostService = blogPostService;
_contentManager = contentManager;
}
public HomeController(
IBlogPostService blogPostService,
IMapper mapper,
AppSettings appSettings)
{
_blogPostService = blogPostService;
_mapper = mapper;
_appSettings = appSettings;
}
public BlogController(
IBlogPostService blogPostService,
IPostModelFactory postModelFactory,
IPostCategoriesService categoriesService)
{
_blogPostService = blogPostService;
_postModelFactory = postModelFactory;
_categoriesService = categoriesService;
}
public HomeController(
IMemcachedClient memcachedClient,
IBlogPostService blogPostService,
ILoggerFactory loggerFactory)
{
_memcachedClient = memcachedClient;
_blogPostService = blogPostService;
_logger = loggerFactory.CreateLogger <HomeController>();
}
public BlogPostController(ILogger <BlogPostController> logger,
IBlogPostService blogPostService,
UserManager <ApplicationUser> userManager,
IMapper mapper)
{
_logger = logger;
this.blogPostService = blogPostService;
this.userManager = userManager;
this.mapper = mapper;
}
public ManageBlogPostsController(IBlogPostService blogPostService,
IAdminBlogPostModelFactory adminBlogPostModelFactory,
ILocalizationService localizationService,
ILocalizedEntityService localizedEntityService)
{
_blogPostService = blogPostService;
_adminBlogPostModelFactory = adminBlogPostModelFactory;
_localizationService = localizationService;
_localizedEntityService = localizedEntityService;
}
// ReSharper disable once UnusedMember.Global
public async Task <BlogPost> CreateBlogPost([Service] IBlogPostService authorService, [Service] ITopicEventSender eventSender, string title, string content, int authorId)
{
var createdPost = authorService.CreatePost(title, content, authorId);
var allPosts = authorService.GetAllPosts();
await eventSender.SendAsync("BlogPostreated", allPosts);
return(createdPost);
}
public BlogController(IBlogService blogService, IBlogPostService blogPostService,
IBlogPostCommentService blogPostCommentService, ICacheService cacheService,
ICurrentUser currentUser)
{
this.blogService = blogService;
this.blogPostService = blogPostService;
this.blogPostCommentService = blogPostCommentService;
this.cacheService = cacheService;
this.currentUser = currentUser;
}
public XmlRpcHandler(IBlogService blogService, IBlogPostService blogPostService, IContentManager contentManager,
IAuthorizationService authorizationService, IMembershipService membershipService,
RouteCollection routeCollection) {
_blogService = blogService;
_blogPostService = blogPostService;
_contentManager = contentManager;
_authorizationService = authorizationService;
_membershipService = membershipService;
_routeCollection = routeCollection;
Logger = NullLogger.Instance;
}
public BlogPostController(
IOrchardServices services,
IBlogService blogService,
IBlogPostService blogPostService,
IFeedManager feedManager) {
_services = services;
_blogService = blogService;
_blogPostService = blogPostService;
_feedManager = feedManager;
T = NullLocalizer.Instance;
}
public BlogPostController(
IOrchardServices services,
IBlogService blogService,
IBlogPostService blogPostService,
IFeedManager feedManager,
IShapeFactory shapeFactory) {
_services = services;
_blogService = blogService;
_blogPostService = blogPostService;
_feedManager = feedManager;
T = NullLocalizer.Instance;
Shape = shapeFactory;
}
public BlogController(
IOrchardServices services,
IBlogService blogService,
IBlogPostService blogPostService,
IFeedManager feedManager,
IShapeFactory shapeFactory,
ISiteService siteService) {
_services = services;
_blogService = blogService;
_blogPostService = blogPostService;
_feedManager = feedManager;
_siteService = siteService;
Logger = NullLogger.Instance;
Shape = shapeFactory;
}
public BlogPostHandler(IBlogService blogService, IBlogPostService blogPostService, IOrchardServices orchardServices, RequestContext requestContext) {
_blogPostService = blogPostService;
_orchardServices = orchardServices;
T = NullLocalizer.Instance;
Filters.Add(new ActivatingFilter<BlogPost>(BlogPostDriver.ContentType.Name));
Filters.Add(new ActivatingFilter<CommonAspect>(BlogPostDriver.ContentType.Name));
Filters.Add(new ActivatingFilter<ContentPart<CommonVersionRecord>>(BlogPostDriver.ContentType.Name));
Filters.Add(new ActivatingFilter<RoutableAspect>(BlogPostDriver.ContentType.Name));
Filters.Add(new ActivatingFilter<BodyAspect>(BlogPostDriver.ContentType.Name));
OnLoaded<BlogPost>((context, p) => p.ScheduledPublishUtc = _blogPostService.GetScheduledPublishUtc(p));
Action<Blog> updateBlogPostCount =
(blog => {
// Ensure we get the "right" set of published posts for the blog
blog.ContentItem.ContentManager.Flush();
var posts = _blogPostService.Get(blog, VersionOptions.Published).ToList();
blog.PostCount = posts.Count;
});
OnActivated<BlogPost>((context, bp) => {
var blogSlug = requestContext.RouteData.Values.ContainsKey("blogSlug") ? requestContext.RouteData.Values["blogSlug"] as string : null;
if (!string.IsNullOrEmpty(blogSlug)) {
bp.Blog = blogService.Get(blogSlug);
return;
}
var containerId = requestContext.HttpContext.Request.Form["containerId"];
if (!string.IsNullOrEmpty(containerId)) {
int cId;
if (int.TryParse(containerId, out cId)) {
bp.Blog = context.ContentItem.ContentManager.Get(cId).As<Blog>();
return;
}
}
});
OnCreated<BlogPost>((context, bp) => updateBlogPostCount(bp.Blog));
OnPublished<BlogPost>((context, bp) => updateBlogPostCount(bp.Blog));
OnVersioned<BlogPost>((context, bp1, bp2) => updateBlogPostCount(bp2.Blog));
OnRemoved<BlogPost>((context, bp) => updateBlogPostCount(bp.Blog));
OnRemoved<Blog>(
(context, b) =>
blogPostService.Get(context.ContentItem.As<Blog>()).ToList().ForEach(
blogPost => context.ContentManager.Remove(blogPost.ContentItem)));
}
public AdminController(
IOrchardServices services,
ISignals signals,
IBlogService blogService,
IBlogPostService blogPostService,
ITagService tagsService,
ICommentService commentService,
IContentManager contentManager)
{
_signals = signals;
_blogService = blogService;
_blogPostService = blogPostService;
_tagsService = tagsService;
_commentService = commentService;
Services = services;
}
public BlogPartArchiveHandler(
IRepository<BlogPartArchiveRecord> blogArchiveRepository,
IBlogPostService blogPostService,
IWorkContextAccessor workContextAccessor,
IContentManager contentManager) {
_blogArchiveRepository = blogArchiveRepository;
_workContextAccessor = workContextAccessor;
_contentManager = contentManager;
OnPublishing<BlogPostPart>((context, bp) => SavePreviousPublishDate(context.Id));
OnRemoving<BlogPostPart>((context, bp) => SavePreviousPublishDate(context.Id));
OnUnpublishing<BlogPostPart>((context, bp) => SavePreviousPublishDate(context.Id));
OnPublished<BlogPostPart>((context, bp) => IncreaseBlogArchive(bp));
OnUnpublished<BlogPostPart>((context, bp) => ReduceBlogArchive(bp));
OnRemoved<BlogPostPart>((context, bp) => ReduceBlogArchive(bp));
}
public BlogPostPartHandler(IBlogService blogService, IBlogPostService blogPostService, RequestContext requestContext) {
_blogService = blogService;
OnGetDisplayShape<BlogPostPart>(SetModelProperties);
OnGetEditorShape<BlogPostPart>(SetModelProperties);
OnUpdateEditorShape<BlogPostPart>(SetModelProperties);
OnCreated<BlogPostPart>((context, part) => ProcessBlogPostsCount(part));
OnPublished<BlogPostPart>((context, part) => ProcessBlogPostsCount(part));
OnUnpublished<BlogPostPart>((context, part) => ProcessBlogPostsCount(part));
OnVersioned<BlogPostPart>((context, part, newVersionPart) => ProcessBlogPostsCount(newVersionPart));
OnRemoved<BlogPostPart>((context, part) => ProcessBlogPostsCount(part));
OnRemoved<BlogPart>(
(context, b) =>
blogPostService.Get(context.ContentItem.As<BlogPart>()).ToList().ForEach(
blogPost => context.ContentManager.Remove(blogPost.ContentItem)));
}
public BlogPartArchiveHandler(
IRepository<BlogPartArchiveRecord> blogArchiveRepository,
IBlogPostService blogPostService,
IWorkContextAccessor workContextAccessor) {
_workContextAccessor = workContextAccessor;
OnVersioning<BlogPostPart>((context, bp1, bp2) => {
var commonPart = bp1.As<CommonPart>();
if(commonPart == null || !commonPart.CreatedUtc.HasValue || !bp1.IsPublished)
return;
_previousCreatedUtc[bp2] = commonPart.CreatedUtc.Value;
});
OnPublished<BlogPostPart>((context, bp) => RecalculateBlogArchive(blogArchiveRepository, bp));
OnUnpublished<BlogPostPart>((context, bp) => ReduceBlogArchive(blogArchiveRepository, bp));
OnRemoved<BlogPostPart>((context, bp) => ReduceBlogArchive(blogArchiveRepository, bp));
}
public BlogController(
IOrchardServices services,
IBlogService blogService,
IBlogPostService blogPostService,
IBlogPathConstraint blogPathConstraint,
IFeedManager feedManager,
IShapeFactory shapeFactory,
IWorkContextAccessor workContextAccessor,
IEnumerable<IHomePageProvider> homePageProviders,
ISiteService siteService) {
_services = services;
_blogService = blogService;
_blogPostService = blogPostService;
_blogPathConstraint = blogPathConstraint;
_feedManager = feedManager;
_workContextAccessor = workContextAccessor;
_siteService = siteService;
_routableHomePageProvider = homePageProviders.SingleOrDefault(p => p.GetProviderName() == RoutableHomePageProvider.Name);
Logger = NullLogger.Instance;
Shape = shapeFactory;
}
public BlogPartArchiveHandler(
IRepository<BlogPartArchiveRecord> blogArchiveRepository,
IBlogPostService blogPostService,
IWorkContextAccessor workContextAccessor,
IContentManager contentManager) {
_blogArchiveRepository = blogArchiveRepository;
_workContextAccessor = workContextAccessor;
_contentManager = contentManager;
//OnVersioning<BlogPostPart>((context, bp1, bp2) => {
// var commonPart = bp1.As<ICommonPart>();
// if (commonPart == null || !commonPart.CreatedUtc.HasValue)
// return;
// if (context.BuildingItemVersionRecord.Published == context.ExistingContentItem.IsPublished()) {
// return;
// }
// var previousPublishedVersion = contentManager.Get(commonPart.Id, VersionOptions.Published);
// // retrieve the creation date when it was published
// if (previousPublishedVersion != null) {
// var versionCommonPart = previousPublishedVersion.As<ICommonPart>();
// if (versionCommonPart.VersionCreatedUtc.HasValue) {
// _previousCreatedUtc[commonPart.Id] = versionCommonPart.VersionCreatedUtc.Value;
// }
// }
//});
//OnUpdating<BlogPostPart>((context, bp) => SavePreviousPublishDate(context.Id));
OnPublishing<BlogPostPart>((context, bp) => SavePreviousPublishDate(context.Id));
OnRemoving<BlogPostPart>((context, bp) => SavePreviousPublishDate(context.Id));
OnUnpublishing<BlogPostPart>((context, bp) => SavePreviousPublishDate(context.Id));
OnPublished<BlogPostPart>((context, bp) => IncreaseBlogArchive(bp));
OnUnpublished<BlogPostPart>((context, bp) => ReduceBlogArchive(bp));
OnRemoved<BlogPostPart>((context, bp) => ReduceBlogArchive(bp));
}
public CategoryController() {
postService = new BlogPostService();
categoryService = new BlogCategoryService();
}
public MigrateController(IArchiveConstraint archiveConstraint, IBlogService blogService, IBlogPostService blogPostService)
{
_archiveConstraint = archiveConstraint;
_blogService = blogService;
_blogPostService = blogPostService;
}
public HomeController(IBlogPostService blogPostService)
{
_blogPostService = blogPostService;
}
public BlogPartArchiveHandler(IRepository<BlogPartArchiveRecord> blogArchiveRepository, IBlogPostService blogPostService)
{
OnPublished<BlogPostPart>((context, bp) => RecalculateBlogArchive(blogArchiveRepository, blogPostService, bp));
OnUnpublished<BlogPostPart>((context, bp) => RecalculateBlogArchive(blogArchiveRepository, blogPostService, bp));
OnRemoved<BlogPostPart>((context, bp) => RecalculateBlogArchive(blogArchiveRepository, blogPostService, bp));
}
public BlogPostController()
{
// Use DI here.
_blogPost = new BlogPostService();
}
public BlogPostClientExt(IBlogPostService blogPostService)
{
this._blogPostService = blogPostService;
}
public ArchivesFilter(IBlogPostService blogPostService) {
_blogPostService = blogPostService;
}
public BlogPostController(IBlogPostService blogPostService, IBlogService blogService, IDeleterService deleterService)
{
this.deleterService = deleterService;
this.blogService = blogService;
this.blogPostService = blogPostService;
}
public BlogPostController(IBlogPostService blogPostService)
{
this._blogPostService = blogPostService;
}
public BlogPostsController(IBlogPostService blogPostService)
{
BlogPostService = blogPostService;
}
