public AtomController(IUserService userService, IPostService postService, ILogger logger, ISyndicationFeedService syndicationFeedService)
     : base(logger)
 {
     _userService = userService;
     _postService = postService;
     _syndicationFeedService = syndicationFeedService;
 }

 static void ShowPosts(IPostService postService)
 {
     foreach (var post in postService.GetAll())
     {
         System.Console.WriteLine(post.Url + " " + post.Time.Year + " " + String.Join(",", post.Tags.Select(t => t.Name)));
     }
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="context"></param>
 /// <param name="settingsService"> </param>
 /// <param name="emailService"> </param>
 /// <param name="localizationService"> </param>
 /// <param name="activityService"> </param>
 /// <param name="privateMessageService"> </param>
 /// <param name="membershipUserPointsService"> </param>
 /// <param name="topicNotificationService"> </param>
 /// <param name="voteService"> </param>
 /// <param name="badgeService"> </param>
 /// <param name="categoryNotificationService"> </param>
 /// <param name="loggingService"></param>
 /// <param name="uploadedFileService"></param>
 /// <param name="postService"></param>
 /// <param name="pollVoteService"></param>
 /// <param name="pollAnswerService"></param>
 /// <param name="pollService"></param>
 /// <param name="topicService"></param>
 /// <param name="favouriteService"></param>
 /// <param name="categoryService"></param>
 public MembershipService(IMVCForumContext context, ISettingsService settingsService,
     IEmailService emailService, ILocalizationService localizationService, IActivityService activityService,
     IPrivateMessageService privateMessageService, IMembershipUserPointsService membershipUserPointsService,
     ITopicNotificationService topicNotificationService, IVoteService voteService, IBadgeService badgeService,
     ICategoryNotificationService categoryNotificationService, ILoggingService loggingService, IUploadedFileService uploadedFileService,
     IPostService postService, IPollVoteService pollVoteService, IPollAnswerService pollAnswerService,
     IPollService pollService, ITopicService topicService, IFavouriteService favouriteService, 
     ICategoryService categoryService, IPostEditService postEditService)
 {
     _settingsService = settingsService;
     _emailService = emailService;
     _localizationService = localizationService;
     _activityService = activityService;
     _privateMessageService = privateMessageService;
     _membershipUserPointsService = membershipUserPointsService;
     _topicNotificationService = topicNotificationService;
     _voteService = voteService;
     _badgeService = badgeService;
     _categoryNotificationService = categoryNotificationService;
     _loggingService = loggingService;
     _uploadedFileService = uploadedFileService;
     _postService = postService;
     _pollVoteService = pollVoteService;
     _pollAnswerService = pollAnswerService;
     _pollService = pollService;
     _topicService = topicService;
     _favouriteService = favouriteService;
     _categoryService = categoryService;
     _postEditService = postEditService;
     _context = context as MVCForumContext;
 }

		private void GetPostService(UnitOfWork uow, out ICategoryService categoryService, out IForumService forumService, out ITopicService topicService, out IPostService postService) {
			ICategoryRepository cateRepo = new CategoryRepository(uow);
			IForumRepository forumRepo = new ForumRepository(uow);
			ITopicRepository topicRepo = new TopicRepository(uow);
			IPostRepository postRepo = new PostRepository(uow);
			IForumConfigurationRepository configRepo = new ForumConfigurationRepository(uow);

			IState request = new DummyRequest();

			ILogger logger = new ConsoleLogger();

			IUserRepository userRepo = new UserRepository(uow);
			User user = userRepo.Create(new User {
				Name = "D. Ummy",
				ProviderId = "12345678",
				FullName = "Mr. Doh Ummy",
				EmailAddress = "[email protected]",
				Culture = "th-TH",
				TimeZone = "GMT Standard Time"
			});

			List<IEventSubscriber> subscribers = new List<IEventSubscriber>();

			IEventPublisher eventPublisher = new EventPublisher(subscribers, logger, request);
			IUserProvider userProvider = new DummyUserProvider(user);
			IPermissionService permService = new PermissionService();
			IForumConfigurationService confService = new ForumConfigurationService(configRepo);

			categoryService = new CategoryService(userProvider, cateRepo, eventPublisher, logger, permService);
			forumService = new ForumService(userProvider, cateRepo, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService);
			topicService = new TopicService(userProvider, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService, confService);
			postService = new PostService(userProvider, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService, confService);
		}

 static void ShowDeliciousDates(IPostService postService, string tag)
 {
     foreach (var date in postService.GetDeliciousDates(tag))
     {
         System.Console.WriteLine(date.Date + " " + date.Count);
     }
 }

 public ReportPostAdminController(
     IOrchardServices orchardServices,
     IForumService forumService,
     IThreadService threadService,
     IPostService postService,
     ISiteService siteService,
     IShapeFactory shapeFactory,
     IAuthorizationService authorizationService,
     IAuthenticationService authenticationService,
     ISubscriptionService subscriptionService,
     IReportPostService reportPostService,
     ICountersService countersService
     )
 {
     _orchardServices = orchardServices;
     _forumService = forumService;
     _threadService = threadService;
     _postService = postService;
     _siteService = siteService;
     _subscriptionService = subscriptionService;
     _authorizationService = authorizationService;
     _authenticationService = authenticationService;
     _reportPostService = reportPostService;
     _countersService = countersService;
     T = NullLocalizer.Instance;
     Shape = shapeFactory;
 }

 public PostAdminController(ICategoryService categoryService, IPostService p, ITagService ts, IUserService us)
 {
     this.categoryService = categoryService;
     this.postService = p;
     this.tagService = ts;
     this.userService = us;
 }

 public PostController(ILog logger, IConfigurationService configurationService, IPostService postService, ICategoryService categoryService, IUrlBuilder urlBuilder)
     : base(logger, configurationService)
 {
     this.postService = postService;
     this.categoryService = categoryService;
     this.urlBuilder = urlBuilder;
 }

        public PostPartHandler(IRepository<PostPartRecord> repository, 
            IPostService postService, 
            IThreadService threadService, 
            IForumService forumService)
        {
            _postService = postService;
            _threadService = threadService;
            _forumService = forumService;

            Filters.Add(StorageFilter.For(repository));

            OnGetDisplayShape<PostPart>(SetModelProperties);
            OnGetEditorShape<PostPart>(SetModelProperties);
            OnUpdateEditorShape<PostPart>(SetModelProperties);

            OnCreated<PostPart>((context, part) => UpdatePostCount(part));
            OnPublished<PostPart>((context, part) => UpdatePostCount(part));
            OnUnpublished<PostPart>((context, part) => UpdatePostCount(part));
            OnVersioned<PostPart>((context, part, newVersionPart) => UpdatePostCount(newVersionPart));
            OnRemoved<PostPart>((context, part) => UpdatePostCount(part));

            OnRemoved<ThreadPart>((context, b) =>
                _postService
                    .Get(context.ContentItem.As<ThreadPart>())
                    .ToList()
                    .ForEach(post => context.ContentManager.Remove(post.ContentItem)));
        }

 public PostController(IPostService postService, IDashboardService dashboardService, IBlogService blogService, ILogger logger)
     : base(logger)
 {
     _postService = postService;
     _dashboardService = dashboardService;
     _blogService = blogService;
 }

 public PostsController(IPostService postService, ITagService tagService, ICategoryService catService, IUserService userService)
 {
     this.postService = postService;
     this.tagService = tagService;
     this.catService = catService;
     this.userService = userService;
 }

        public SubscriptionController(
            IOrchardServices orchardServices,
            IForumService forumService,
            IThreadService threadService,
            IPostService postService,
            ISiteService siteService,
            IShapeFactory shapeFactory,
            IAuthorizationService authorizationService,
            IAuthenticationService authenticationService,
            ISubscriptionService subscriptionService,
            IThreadLastReadService threadLastReadService
            )
        {
            _orchardServices = orchardServices;
            _forumService = forumService;
            _threadService = threadService;
            _postService = postService;
            _siteService = siteService;
            _subscriptionService = subscriptionService;
            _authorizationService = authorizationService;
            _authenticationService = authenticationService;
            _threadLastReadService = threadLastReadService;

            T = NullLocalizer.Instance;
            Shape = shapeFactory;
        }

 public PostAdminController(IPostService postService, IUserService userService, IAuthenticationService authenticationService, ICategoryService categoryService)
 {
     _postService = postService;
     _userService = userService;
     _authenticationService = authenticationService;
     _categoryService = categoryService;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="UserController"/> class.
        /// </summary>
        /// <param name="loggerService">Logger Service</param>
        /// <param name="userService">User Service</param>
        /// <param name="tripService">Trip Service</param>
        /// <param name="postService">Post Service</param>
        public UserController(
            ILoggerService loggerService,
            IUserService userService,
            ITripService tripService,
            IPostService postService)
            : base(loggerService)
        {
            if(userService == null)
            {
                throw new ArgumentNullException("User Service, User Controller");
            }

            if (tripService == null)
            {
                throw new ArgumentNullException("Trip Service, User Controller");
            }

            if (postService == null)
            {
                throw new ArgumentNullException("Post Service, User Controller");
            }

            this.userService = userService;
            this.tripService = tripService;
            this.postService = postService;
        }

        public PostController(IPostService service)
        {
            if (service == null)
                throw new ArgumentNullException("service cannot be null");

            PostService = service;
        }

        public ThreadPartHandler(IRepository<ThreadPartRecord> repository, 
            IPostService postService,
            IThreadService threadService,
            IForumService forumService,
            IContentManager contentManager)
        {
            _postService = postService;
            _threadService = threadService;
            _forumService = forumService;
            _contentManager = contentManager;

            Filters.Add(StorageFilter.For(repository));

            OnGetDisplayShape<ThreadPart>(SetModelProperties);
            OnGetEditorShape<ThreadPart>(SetModelProperties);
            OnUpdateEditorShape<ThreadPart>(SetModelProperties);

            OnActivated<ThreadPart>(PropertySetHandlers);
            OnLoading<ThreadPart>((context, part) => LazyLoadHandlers(part));
            OnCreated<ThreadPart>((context, part) => UpdateForumPartCounters(part));
            OnPublished<ThreadPart>((context, part) => UpdateForumPartCounters(part));
            OnUnpublished<ThreadPart>((context, part) => UpdateForumPartCounters(part));
            OnVersioning<ThreadPart>((context, part, newVersionPart) => LazyLoadHandlers(newVersionPart));
            OnVersioned<ThreadPart>((context, part, newVersionPart) => UpdateForumPartCounters(newVersionPart));
            OnRemoved<ThreadPart>((context, part) => UpdateForumPartCounters(part));

            OnRemoved<ForumPart>((context, b) =>
                _threadService
                    .Get(context.ContentItem.As<ForumPart>())
                    .ToList()
                    .ForEach(thread => context.ContentManager.Remove(thread.ContentItem)));
        }

        public ShoutboxHub(Work<IOrchardServices> orchardServices, IHelpers helpers, IShoutboxService shoutboxService, IPostService postService)
        {
            if (orchardServices == null)
            {
                throw new ArgumentNullException("orchardServices");
            }

            if (helpers == null)
            {
                throw new ArgumentNullException("helpers");
            }

            if (postService == null)
            {
                throw new ArgumentNullException("postService");
            }

            if (shoutboxService == null)
            {
                throw new ArgumentNullException("shoutboxService");
            }

            _OrchardServices = orchardServices;
            _Helpers = helpers;
            _ShoutboxService = shoutboxService;
            _PostService = postService;
        }

 public WidgetController(ILog logger, IConfigurationService configurationService, IPostService postService, ICategoryService categoryService, IPageService pageService)
     : base(logger, configurationService)
 {
     this.postService = postService;
     this.categoryService = categoryService;
     this.pageService = pageService;
 }

        public PostPartHandler(IRepository<PostPartRecord> repository, 
            IPostService postService, 
            IClock clock,
            IReportPostService reportPostService,
            ICountersService countersService,
            ISubscriptionService subscriptionService

            ) {
            _postService = postService;
            _clock = clock;
            _reportPostService = reportPostService;
            _countersService = countersService;
            _subscriptionService = subscriptionService;

            Filters.Add(StorageFilter.For(repository));

            OnGetDisplayShape<PostPart>(SetModelProperties);
            OnGetEditorShape<PostPart>(SetModelProperties);
            OnUpdateEditorShape<PostPart>(SetModelProperties);

            OnCreated<PostPart>((context, part) => _countersService.UpdateCounters(part));

            OnPublished<PostPart>((context, part) => {
                _countersService.UpdateCounters(part);
                UpdateThreadVersioningDates(part);
                SendNewPostNotification(part);

                //for purposes of 'last read' need to know the last valid post to the thread.  The last time the user read the thread is tracked
                //and is compared to the lastest posts in the thread to determine if the thread has unread posts.
                if (!part.IsInappropriate)
                {
                    part.ThreadPart.LastestValidPostDate = part.As<CommonPart>().PublishedUtc.Value;
                }
            });
            OnUnpublished<PostPart>((context, part) => _countersService.UpdateCounters(part));
            OnVersioned<PostPart>((context, part, newVersionPart) => _countersService.UpdateCounters(newVersionPart));
            OnRemoved<PostPart>((context, part) =>
            {
                _countersService.UpdateCounters(part); 

                                                    //going to leave the history record for historic purposes
                                                    // RemoveReports(part); 
                                                    });

            OnRemoved<ThreadPart>((context, b) =>
                _postService.Delete(context.ContentItem.As<ThreadPart>()));

            
            OnIndexing<PostPart>((context, postPart) => context.DocumentIndex        
                                                    .Add("body", postPart.Record.Text).RemoveTags().Analyze()
                                                    .Add("format", postPart.Record.Format).Store()
                                                    .Add("forumsHomeId", postPart.ThreadPart.ForumPart.ForumCategoryPart.ForumsHomePagePart.Id)
                                                    .Add("categoryId", postPart.ThreadPart.ForumPart.ForumCategoryPart.Id)
                                                    .Add("forumId", postPart.ThreadPart.ForumPart.Id)
                                                    .Add("threadId", postPart.ThreadPart.Id)
                                                    );

            OnIndexing<ThreadPart>((context, threadPart) => context.DocumentIndex.Add("Title", threadPart.As<TitlePart>().Title ));
          
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="unitOfWorkManager"> </param>
 /// <param name="membershipService"> </param>
 /// <param name="localizationService"></param>
 /// <param name="settingsService"> </param>
 /// <param name="badgeService"> </param>
 /// <param name="loggingService"> </param>
 public AdminBadgeController(IBadgeService badgeService, IPostService postService, ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, 
     IMembershipService membershipService, ILocalizationService localizationService, ISettingsService settingsService)
     : base(loggingService, unitOfWorkManager, membershipService, localizationService, settingsService)
 {
     _badgeService = badgeService;
     _postService = postService;
 }