Comment Bundle Laravel Package

Getting Started

Minimal Steps to Enable Comments

1. Install the Bundle

   composer require friendsofsymfony/comment-bundle
   

2. Enable Required Bundles (Symfony 4.x config/bundles.php or Symfony 3.x AppKernel.php):

   new FOS\RestBundle\FOSRestBundle(),
   new FOS\CommentBundle\FOSCommentBundle(),
   new JMS\SerializerBundle\JMSSerializerBundle($this),
   

3. Configure HTTP Method Override (Symfony 4.x config/packages/framework.yaml or Symfony 3.x config.yml):

   framework:
       http_method_override: true
   

4. Enable Translations (Symfony 4.x config/packages/framework.yaml or Symfony 3.x config.yml):

   framework:
       translator: ~
   

5. Create Custom Comment and Thread Entities Extend BaseComment and BaseThread (see Step 2 docs).

6. Import Routing (Symfony 4.x config/routes.yaml or Symfony 3.x routing.yml):

   fos_comment:
       resource: "@FOSCommentBundle/Resources/config/routing.xml"
       prefix: /
   

7. Enable Comments on a Page Use the fos_comment_box Twig function in your template:

   {{ fos_comment_box(thread) }}
   

First Use Case: Adding Comments to a Blog Post

1. Define a Thread Entity (e.g., BlogPostThread):

   use FOS\CommentBundle\Entity\BaseThread;
   
   class BlogPostThread extends BaseThread
   {
       // Add custom fields (e.g., relation to BlogPost)
   }
   

2. Configure the Thread in config.yml:

   fos_comment:
       thread_class: App\Entity\BlogPostThread
       comment_class: App\Entity\Comment
   

3. Display Comments in Twig:

   {% for thread in blogPost.threads %}
       {{ fos_comment_box(thread) }}
   {% endfor %}
   

Implementation Patterns

Common Workflows

1. Threaded Commenting System

• Pattern: Use Thread entities to group comments under a specific object (e.g., blog post, product).
• Example:

  // In a controller
  $thread = $threadManager->createThread();
  $thread->setObject($blogPost); // Link thread to a blog post
  $threadManager->saveThread($thread);
  

2. Nested Comments with Reply Functionality

• Pattern: Leverage FOSCommentBundle’s built-in tree structure. Use getChildren() and getParent() on Comment entities.
• Example in Twig:

  {% for comment in thread.comments %}
      <div class="comment">
          {{ comment.body }}
          {% if comment.children|length > 0 %}
              <div class="replies">
                  {% for reply in comment.children %}
                      {{ fos_comment_box(reply) }}
                  {% endfor %}
              </div>
          {% endif %}
      </div>
  {% endfor %}
  

3. Form Integration

• Pattern: Use the fos_comment_form Twig function to render a comment form tied to a thread.
• Example:

  {{ form_start(fos_comment_form(thread)) }}
      {{ form_widget(form.body) }}
      {{ form_widget(form.author) }}
      <button type="submit">Post Comment</button>
  {{ form_end(fos_comment_form(thread)) }}
  

4. REST API for Comments

• Pattern: Use FOSRestBundle to expose comment endpoints. Configure routes in routing.yml:

  fos_comment_rest:
      resource: "@FOSCommentBundle/Resources/config/routing/rest.xml"
      prefix: /api
  

• Example Endpoints:
  • GET /api/comments/{threadId}: Fetch comments for a thread.
  • POST /api/comments: Create a new comment.

5. Event-Driven Extensions

• Pattern: Subscribe to FOSCommentBundle events (e.g., fos_comment_post, fos_comment_delete) to extend functionality.
• Example:

  // src/EventListener/CommentListener.php
  use FOS\CommentBundle\Event\CommentEvent;
  
  class CommentListener
  {
      public function onCommentPost(CommentEvent $event)
      {
          $comment = $event->getComment();
          // Send notification email, log comment, etc.
      }
  }
  

  Register the listener in services.yaml:

  services:
      App\EventListener\CommentListener:
          tags:
              - { name: kernel.event_listener, event: fos_comment_post, method: onCommentPost }
  

Integration Tips

1. Doctrine ORM/ODM

• Ensure your Comment and Thread entities extend the correct base classes:

  use FOS\CommentBundle\Model\BaseComment;
  use FOS\CommentBundle\Model\BaseThread;
  

2. Markup Parsing (e.g., Markdown, HTML)

• Configure a parser service (e.g., MarkdownExtraParser) and set it in config.yml:

  fos_comment:
      service:
          markup: markup.markdown_extra
  

3. Security (ACL or FOSUserBundle)

• ACL: Use Symfony’s ACL or FOSCommentBundle’s role-based ACL.
• FOSUserBundle: Extend the Vote class to implement SignedVoteInterface for user-specific votes.

4. Custom Sorting

• Implement SortingInterface for custom sorting logic (e.g., by popularity):

  services:
      app.comment.sorter.popularity:
          class: App\Sorting\PopularitySorting
          tags:
              - { name: fos_comment.sorter, alias: popularity }
  

  Configure in config.yml:

  fos_comment:
      service:
          sorting:
              default: popularity
  

5. JavaScript Integration

• Use the fos_comment.js bundle asset for AJAX comment submission and real-time updates.
• Example initialization:

  $(document).ready(function() {
      $('.comment-form').fosCommentForm();
  });
  

Gotchas and Tips

Pitfalls

1. Thread-Object Linking

• Issue: Forgetting to link a Thread to an object (e.g., BlogPost) will result in orphaned threads.
• Fix: Always set the object in the thread entity:

  $thread->setObject($blogPost);
  

2. Markup Parser Configuration

• Issue: Misconfiguring the markup parser (e.g., HtmlPurifier) can lead to XSS vulnerabilities or broken rendering.
• Fix: Validate parser configuration and use strict HTMLPurifier rules:

  exercise_html_purifier:
      default:
          config:
              HTML.Allowed: 'p[style], em, strong, a[href], ul, ol, li'
  

3. Caching Threads/Comments

• Issue: Caching Thread or Comment entities directly can cause stale data if not invalidated properly.
• Fix: Use fos_comment.manager to refresh entities:

  $threadManager = $this->get('fos_comment.manager');
  $thread = $threadManager->findThreadByObject($blogPost);
  

4. Event Subscriber Order

• Issue: Events fired by FOSCommentBundle may not trigger if subscribers are not properly registered or ordered.
• Fix: Ensure subscribers are tagged with the correct event name and priority:

  tags:
      - { name: kernel.event_listener, event: fos_comment_post, method: onCommentPost, priority: 10 }
  

5. Doctrine Lifecycle Callbacks

• Issue: Using @PrePersist or @PreUpdate on Comment/Thread entities can conflict with FOSCommentBundle’s lifecycle.
• Fix: Prefer event listeners over Doctrine callbacks for comment-related logic.

Debugging Tips

1. Enable Debugging for Events

• Add a temporary listener to log events:

  public function onCommentEvent(GenericEvent $event)
  {
      error_log('Event: ' . $event->getName());
  }
  

2. Check Database Schema

• Verify that commentable_object and commentable_type fields exist in the fos_comment_thread table for object linking.

3. Validate Form Submissions

• Use Symfony’s profiler to inspect form