protected void Page_Load(object sender, EventArgs e)
        {
            eventId = Convert.ToInt64(Request.Params.Get("eventId"));
            commentId = Convert.ToInt64(Request.Params.Get("commentId"));

            IUnityContainer container = (IUnityContainer)HttpContext.Current.Application["unityContainer"];
            commentService = container.Resolve<ICommentService>();

            if (!IsPostBack)
            {
                CommentInfo c = commentService.GetCommentById(commentId);
                List<Tag> tags = commentService.GetTagsByCommentId(commentId);

                string stags = ParseTags(tags);

                this.txtComment.Text = c.texto;
                this.txtTags.Text = stags;

            }
            if (!SessionManager.IsUserAuthenticated(Context))
            {
                /* Do action. */
                String url =
                    Settings.Default.PracticaMaD_applicationURL +
                                    "Pages/User/Authentication.aspx" + "?eventId=" + eventId;

                Response.Redirect(Response.ApplyAppPathModifier(url));
            }
            else
            {
                userId = SessionManager.GetUserSession(Context).UserProfileId;
            }
        }

        static ProductDetails() {
            IUnityContainer container =
             (IUnityContainer)HttpContext.Current.Application["unityContainer"];

            productService   = container.Resolve<IProductService>();
            commentService = container.Resolve<ICommentService>();
        }

 public AdminCommentController(ILog log, IContentItemService<Post> contentItemService, ICommentService commentService, ILocalizationService localizationService, IUserService userService, ISiteService siteService)
     : base(log, localizationService, userService, siteService)
 {
     this.log = log;
      this.commentService = commentService;
      this.contentItemService = contentItemService;
 }

 public PostController(DbContext dbContext, IPostService postService, ICommentService commentService, IPagingHandler<Post> pagingHandler)
     : base(dbContext)
 {
     this._postService = postService;
     _commentService = commentService;
     _pagingHandler = pagingHandler;
 }

 public CommentController(IOrchardServices services, ICommentService commentService, INotifier notifier)
 {
     Services = services;
     _commentService = commentService;
     _notifier = notifier;
     T = NullLocalizer.Instance;
 }

 public CommentController(ICommentMapper commentMapper, IImageAlbumService imageAlbumService, ICommentService commentService, IMembershipService membershipService)
 {
     this._commentMapper = commentMapper;
     this._imageAlbumService = imageAlbumService;
     this._commentService = commentService;
     this._membershipService = membershipService;
 }

 public CommentsController(IUsersService users, ICommentService comments, IHomeService homes, INeedService needs)
     : base(users)
 {
     this.comments = comments;
     this.homes = homes;
     this.needs = needs;
 }

 public ChatApiController(IUserService service, IChatService service2, ICommentService service3, ILiveChat service4)
 {
     this._userService = service;
     this._chatService = service2;
     this._commentService = service3;
     this._LiveChat = service4;
 }

 public ArticleController(IBlogService blogService, IArticleService articleService, ITagService tagService, ICommentService commentService)
 {
     _blogService = blogService;
     _articleService = articleService;
     _tagService = tagService;
     _commentService = commentService;
 }

        public CommentsPartHandler(
            IContentManager contentManager,
            IRepository<CommentsPartRecord> commentsRepository,
            ICommentService commentService) {

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

            OnInitializing<CommentsPart>((ctx, part) => {
                part.CommentsActive = true;
                part.CommentsShown = true;
                part.Comments = new List<CommentPart>();
            });

            OnLoading<CommentsPart>((context, comments) => {
                comments.CommentsField.Loader(list => contentManager
                    .Query<CommentPart, CommentPartRecord>()
                    .Where(x => x.CommentsPartRecord == context.ContentItem.As<CommentsPart>().Record && x.Status == CommentStatus.Approved)
                    .OrderBy(x => x.Position)
                    .List().ToList());

                comments.PendingCommentsField.Loader(list => contentManager
                    .Query<CommentPart, CommentPartRecord>()
                    .Where(x => x.CommentsPartRecord == context.ContentItem.As<CommentsPart>().Record && x.Status == CommentStatus.Pending)
                    .List().ToList());
            });

            OnRemoved<CommentsPart>(
                (context, c) => {
                    var comments = commentService.GetCommentsForCommentedContent(context.ContentItem.Id).List();
                    foreach (var comment in comments) {
                        contentManager.Remove(comment.ContentItem);
                    }
                });
        }

 public BlogImportRepository(ISubtextContext context, ICommentService commentService, IEntryPublisher entryPublisher, IBlogMLImportMapper mapper)
 {
     SubtextContext = context;
     CommentService = commentService;
     EntryPublisher = entryPublisher;
     Mapper = mapper;
 }

 public CommentsController(ICommentService comments, IAnimalService animals, IUserService users, ISanitizer sanitizeService)
 {
     this.comments = comments;
     this.animals = animals;
     this.users = users;
     this.sanitizeService = sanitizeService;
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="log"></param>
        /// <param name="localizationService"></param>
        /// <param name="siteService"></param>
        /// <param name="userService"></param>
        /// <param name="contentItemService"></param>
        /// <param name="contentItemServiceForPage"></param>
        /// <param name="commentService"></param>
        /// <param name="categoryService"></param>
        /// <param name="tagService"></param>
        /// <param name="searchService"></param>
        /// <param name="widgetService"></param>
        /// <param name="messageService"></param>
        protected ContentControllerBase( ILog log, 
                                       ILocalizationService localizationService,
                                       ISiteService siteService,
                                       IUserService userService,
                                       IContentItemService<Post> contentItemService,
                                       IContentItemService<Page> contentItemServiceForPage,
                                       ICommentService commentService,
                                       ICategoryService categoryService,
                                       ITagService tagService,
                                       ISearchService searchService,
                                       IWidgetService widgetService,
                                       IMessageService messageService)
        {
            this.log = log;
             this.localizationService = IoC.Resolve<ILocalizationService>();
             this.userService = IoC.Resolve<IUserService>();
             this.siteService = IoC.Resolve<ISiteService>();
             this.categoryService = IoC.Resolve<ICategoryService>();
             this.tagService = IoC.Resolve<ITagService>();
             this.contentItemService = contentItemService;
             this.contentItemServiceForPage = contentItemServiceForPage;
             this.commentService = commentService;
             this.searchService = searchService;
             this.widgetService = widgetService;
             this.messageService = messageService;

             registeredWidgetComponents = new List<IWidgetComponent>();

             currentCulture = Thread.CurrentThread.CurrentUICulture;
        }

 public EntryController(IEntryService entryService, ICommentService commentService, IBlogService blogService, ITagService tagService)
 {
     _entryService = entryService;
     _commentService = commentService;
     _blogService = blogService;
     _tagService = tagService;
 }

 public PostController(IPostService service, ITagService ts, ICommentService commentService, IUserService us)
 {
     this.postService = service;
     this.tagService = ts;
     this.userService = us;
     this.commentService = commentService;
 }

        public HasCommentsHandler(
            IContentManager contentManager,
            IRepository<HasCommentsRecord> hasCommentsRepository,
            ICommentService commentService) {

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

            OnActivated<HasComments>((ctx, x) => {
                x.CommentsActive = true;
                x.CommentsShown = true;
            });

            OnLoading<HasComments>((context, comments) => {
                comments._comments.Loader(list => contentManager
                    .Query<Comment, CommentRecord>()
                    .Where(x => x.CommentedOn == context.ContentItem.Id && x.Status == CommentStatus.Approved)
                    .List().ToList());

                comments._pendingComments.Loader(list => contentManager
                    .Query<Comment, CommentRecord>()
                    .Where(x => x.CommentedOn == context.ContentItem.Id && x.Status == CommentStatus.Pending)
                    .List().ToList());
            });

            OnRemoved<HasComments>(
                (context, c) => {
                    foreach (var comment in commentService.GetCommentsForCommentedContent(context.ContentItem.Id)) {
                        contentManager.Remove(comment.ContentItem);
                    }
                });
        }

 public CommentTokens(
     IContentManager contentManager,
     ICommentService commentService) {
     _contentManager = contentManager;
     _commentService = commentService;
     T = NullLocalizer.Instance;
 }

        public CommentPartHandler(
            IRepository<CommentPartRecord> commentsRepository,
            IContentManager contentManager,
            ICommentService commentService
            ) {

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

            OnLoading<CommentPart>((context, comment) => {
                comment.CommentedOnContentItemField.Loader(
                    item => contentManager.Get(comment.CommentedOn)
                );

                comment.CommentedOnContentItemMetadataField.Loader(
                    item => contentManager.GetItemMetadata(comment.CommentedOnContentItem)
                );
            });

            OnRemoving<CommentPart>((context, comment) => {
                foreach(var response in contentManager.Query<CommentPart, CommentPartRecord>().Where(x => x.RepliedOn == comment.Id).List()) {
                    contentManager.Remove(response.ContentItem);
                }
            });

            // keep CommentsPart.Count in sync
            OnPublished<CommentPart>((context, part) => commentService.ProcessCommentsCount(part.CommentedOn));
            OnUnpublished<CommentPart>((context, part) => commentService.ProcessCommentsCount(part.CommentedOn));
            OnVersioned<CommentPart>((context, part, newVersionPart) => commentService.ProcessCommentsCount(newVersionPart.CommentedOn));
            OnRemoved<CommentPart>((context, part) => commentService.ProcessCommentsCount(part.CommentedOn));

            OnIndexing<CommentPart>((context, commentPart) => context.DocumentIndex
                                                                .Add("commentText", commentPart.Record.CommentText));
        }

 public ArticleController(IUserService service, IBlogService blogService,
     IArticleService articleService, ICommentService commentService)
 {
     _userService = service;
     _blogService = blogService;
     _articleService = articleService;
     _commentService = commentService;
 }

 public AdministratorController(IBlogService blogService, IEntryService entryService, IUserService userService, ITagService tagService, ICommentService commentService)
 {
     _blogService = blogService;
     _entryService = entryService;
     _userService = userService;
     _tagService = tagService;
     _commentService = commentService;
 }