Bigfoot User Bundle Laravel Package

Getting Started

Minimal Setup

1. Installation Add the bundle to your composer.json:

   composer require 7rin0/bigfoot-user-bundle
   

   Register the bundle in config/bundles.php:

   return [
       // ...
       SevenRin0\BigfootUserBundle\SevenRin0BigfootUserBundle::class => ['all' => true],
   ];
   

2. First Use Case: User Registration

   • Run migrations (if provided) to create the required tables:

     php bin/console doctrine:migrations:diff
     php bin/console doctrine:migrations:migrate
     

   • Use the bundle’s registration form in your controller:

     use SevenRin0\BigfootUserBundle\Form\RegistrationType;
     
     $form = $this->createForm(RegistrationType::class);
     

3. Key Configuration Check config/packages/seven_rin0_bigfoot_user.yaml for default settings (e.g., user class, security roles). Override as needed:

   seven_rin0_bigfoot_user:
       user_class: App\Entity\User
       registration:
           enabled: true
   

Implementation Patterns

Workflows

1. User Management

   • CRUD Operations: Extend the bundle’s User entity or use its repository methods (e.g., findByRole()).
   • Custom Fields: Add fields to the User entity and update the RegistrationType form:

     // src/Form/ExtendedRegistrationType.php
     public function buildForm(FormBuilderInterface $builder, array $options) {
         parent::buildForm($builder, $options);
         $builder->add('customField', TextType::class);
     }
     

     Register the new form type in services.yaml:

     services:
         App\Form\ExtendedRegistrationType:
             tags: [form.type]
     

2. Security Integration

   • Use the bundle’s voter system for custom permissions:

     use SevenRin0\BigfootUserBundle\Security\Voter\UserVoter;
     
     $voter = new UserVoter();
     $vote = $voter->vote($token, $object, array('EDIT'));
     

   • Override the firewall configuration in security.yaml to leverage the bundle’s authentication providers.

3. Theming

   • Override default templates by copying them from: vendor/sevenrin0/bigfoot-user-bundle/Resources/views/ to templates/sevenrin0_bigfoot_user/.
   • Example: Customize registration.html.twig for branding.

4. API Integration

   • Use the bundle’s serializers (if provided) to expose user data via API Platform or API Resource:

     # config/api_platform/resources.yaml
     resources:
         App\Entity\User:
             collectionOperations:
                 - get
             itemOperations:
                 - get
                 - put
     

Gotchas and Tips

Pitfalls

1. Lack of Documentation

   • The bundle’s README is minimal. Refer to Symfony’s User Management docs for gaps.
   • Tip: Enable debug mode (APP_DEBUG=1) and inspect the bundle’s routes (php bin/console debug:router) to discover endpoints.

2. Entity Configuration

   • The bundle assumes a default User entity. If using a custom entity, ensure it implements SevenRin0\BigfootUserBundle\Model\UserInterface.
   • Gotcha: Forgetting to update the user_class in config may cause ClassNotFoundException.

3. Migration Issues

   • The bundle may not include migrations. Manually create them based on the User entity schema or use Doctrine’s reverse-engineering:

     php bin/console doctrine:mapping:import --path=src/Entity App\Entity
     php bin/console make:migration
     

4. Security Quirks

   • The bundle’s security features (e.g., voters) might conflict with existing Symfony security configurations.
   • Tip: Test authentication flows thoroughly:

     php bin/console debug:security
     

Debugging Tips

1. Log User Events Add a listener to log user actions (e.g., registration):

   // src/EventListener/UserListener.php
   public function onRegistration(RegistrationEvent $event) {
       $this->logger->info('User registered', ['email' => $event->getUser()->getEmail()]);
   }
   

   Register the listener in services.yaml:

   services:
       App\EventListener\UserListener:
           tags:
               - { name: kernel.event_listener, event: seven_rin0_bigfoot_user.registration.success }
   

2. Override Bundle Services To modify the bundle’s behavior (e.g., registration logic), override its services:

   services:
       SevenRin0\BigfootUserBundle\Service\RegistrationService:
           class: App\Service\CustomRegistrationService
           arguments:
               $userProvider: '@doctrine.orm.entity_manager'
   

Extension Points

1. Custom User Provider Implement UserProviderInterface to fetch users from external sources (e.g., LDAP):

   class CustomUserProvider implements UserProviderInterface {
       public function loadUserByUsername($username) {
           // Custom logic
       }
   }
   

   Register it in security.yaml:

   providers:
       custom_provider:
           id: App\Security\CustomUserProvider
   

2. Event Dispatching Extend functionality by listening to bundle events:

   • seven_rin0_bigfoot_user.registration.start
   • seven_rin0_bigfoot_user.login.success Example:

   $eventDispatcher->addListener(
       'seven_rin0_bigfoot_user.registration.success',
       function (RegistrationEvent $event) {
           // Send welcome email
       }
   );
   

3. Command-Line Tools Create custom commands to manage users:

   php bin/console make:command
   

   Example: Bulk user creation:

   $userManager = $this->getContainer()->get('seven_rin0_bigfoot_user.user_manager');
   $user = $userManager->createUser();
   $user->setEmail('user@example.com');
   $userManager->updateUser($user);