Prodibundle Laravel Package

Getting Started

Minimal Setup

1. Install Dependencies:

   composer require ais/prodibundle:dev-master
   

   Ensure your composer.json includes all required dev dependencies (e.g., sensio/generator-bundle, phpunit/phpunit).

2. Register Bundles in app/AppKernel.php:

   new Nelmio\ApiDocBundle\NelmioApiDocBundle(),
   new FOS\RestBundle\FOSRestBundle(),
   new JMSSerializerBundle\JMSSerializerBundle(),
   new Ais\ProdiBundle\AisProdiBundle(),
   

3. Configure Routing in app/config/routing.yml:

   ais_prodis:
     type: rest
     prefix: /api
     resource: "@AisProdiBundle/Resources/config/routes.yml"
   NelmioApiDocBundle:
     resource: "@NelmioApiDocBundle/Resources/config/routing.yml"
     prefix: /api/doc
   

4. Clear Cache:

   php app/console cache:clear
   

5. Access API Docs: Visit http://localhost/app_dev.php/api/doc to explore endpoints.

First Use Case: CRUD Operations

The bundle likely abstracts Prodi-related logic (e.g., product management). Start by inspecting:

• Controller Actions: Check @AisProdiBundle/Controller/ for RESTful endpoints.
• Entities: Review @AisProdiBundle/Entity/ for Prodi models (e.g., Product, Order).
• Serializers: Use JMSSerializerBundle to format responses (e.g., @Serializer\Annotation\Groups).

Example workflow:

1. Create a Prodi entity (e.g., Product) with annotations:

   use Doctrine\ORM\Mapping as ORM;
   use JMS\Serializer\Annotation as Serializer;
   
   #[ORM\Entity]
   #[Serializer\ExclusionPolicy("ALL")]
   class Product {
       #[Serializer\Expose]
       #[ORM\Id]
       private $id;
       // ...
   }
   

2. Test via API docs or Postman:

   curl -X POST http://localhost/api/products -d '{"name":"Test"}'
   

Implementation Patterns

Core Workflows

1. RESTful API Development:

   • Leverage FOSRestBundle for request/response handling. Use @Rest\View in controllers:

     use FOS\RestBundle\Controller\Annotations as Rest;
     
     class ProductController extends Controller {
         #[Rest\View]
         public function getAction() {
             return $this->getDoctrine()->getRepository('AisProdiBundle:Product')->findAll();
         }
     }
     

   • Validate requests with Symfony\Validator or FOSRestBundle's @Rest\QueryParam.

2. Doctrine Integration:

   • Extend entities with custom logic (e.g., lifecycle callbacks):

     #[ORM\PrePersist]
     public function setCreatedAt() {
         $this->createdAt = new \DateTime();
     }
     

   • Use repositories for complex queries:

     $products = $this->getDoctrine()
         ->getRepository('AisProdiBundle:Product')
         ->findBy(['category' => 'Electronics']);
     

3. API Documentation:

   • Annotate controllers with NelmioApiDocBundle:

     /**
      * @ApiDoc(
      *   resource=true,
      *   description="Get all products",
      *   output={"class"="Ais\ProdiBundle\Entity\Product"}
      * )
      */
     public function getAction() { ... }
     

   • Regenerate docs after changes:

     php app/console nelmio:apidoc:generate
     

4. Testing:

   • Use LiipFunctionalTestBundle for API tests:

     public function testGetProducts() {
         $client = static::createClient();
         $client->request('GET', '/api/products');
         $this->assertEquals(200, $client->getResponse()->getStatusCode());
     }
     

Integration Tips

1. Custom Controllers:

   • Extend AisProdiBundle's base controllers (if provided) to add business logic:

     class CustomProductController extends AisProdiBundle\Controller\ProductController {
         public function customAction() { ... }
     }
     

2. Event Subscribers:

   • Listen to Doctrine events (e.g., postPersist) for side effects:

     use Doctrine\Common\EventSubscriber;
     
     class ProductSubscriber implements EventSubscriber {
         public function getSubscribedEvents() {
             return ['postPersist'];
         }
         public function postPersist(LifecycleEventArgs $args) { ... }
     }
     

3. Asset Management:

   • Use AsseticBundle for SCSS/JS processing (e.g., for frontend assets tied to Prodi entities).

4. Email Notifications:

   • Integrate SwiftmailerBundle for order confirmations:

     $message = $this->get('swiftmailer.mailer')->createMessage()
         ->setTo('[email protected]')
         ->setBody('Order confirmed!');
     $this->get('swiftmailer.mailer')->send($message);
     

Gotchas and Tips

Pitfalls

1. Symfony 2.7 Legacy:

   • Avoid modern Laravel/Lumen patterns (e.g., route model binding, resource controllers). Stick to Symfony 2.7 conventions.
   • Example: Use find() instead of findOrFail() (Laravel-specific).

2. Bundle Dependencies:

   • Ensure all required bundles (NelmioApiDocBundle, FOSRestBundle) are registered. Missing dependencies cause silent failures.
   • Debug with:

     php app/console debug:container --parameters
     

3. Routing Conflicts:

   • Prefix routes explicitly to avoid clashes (e.g., /api/products vs. /products).

4. Serialization Issues:

   • Circular references in entities break JMSSerializer. Use @Serializer\MaxDepth or @Serializer\VirtualProperty:

     #[Serializer\VirtualProperty]
     public function getFormattedName() {
         return $this->name . ' (ID: ' . $this->id . ')';
     }
     

5. Dev-Master Instability:

   • The dev-master branch may lack tests. Test thoroughly in a staging environment.

Debugging Tips

1. Enable Profiler:

   // app/config/config_dev.yml
   web_profiler: { toolbar: true, intercept_redirects: false }
   

   Access /_profiler/ for SQL, logs, and request details.

2. Log Entries:

   • Use MonologBundle to trace Prodi operations:

     $this->get('logger')->info('Product created', ['product_id' => $product->getId()]);
     

3. Doctrine Debugging:

   • Enable SQL logging:

     php app/console doctrine:query:sql --em=default
     

4. API Doc Regeneration:

   • Clear cache after adding annotations:

     php app/console cache:clear && php app/console nelmio:apidoc:generate
     

Extension Points

1. Custom Entities:

   • Extend existing entities (e.g., Product) by overriding methods or adding fields:

     #[ORM\Entity]
     class ExtendedProduct extends \Ais\ProdiBundle\Entity\Product {
         #[ORM\Column]
         private $customField;
     }
     

2. Event Dispatchers:

   • Create custom events (e.g., ProductUpdatedEvent) and dispatch them:

     $event = new ProductUpdatedEvent($product);
     $this->get('event_dispatcher')->dispatch('product.updated', $event);
     

3. Twig Extensions:

   • Add Prodi-specific filters/functions:

     class ProdiExtension extends \Twig_Extension {
         public function getFilters() {
             return ['prodi_format' => new \Twig_SimpleFilter('prodi_format', [$this, 'formatProdiData'])];
         }
     }
     

4. Command-Line Tools:

   • Create custom console commands for Prodi tasks:

     class ImportProductsCommand extends ContainerAwareCommand {
         protected function execute(InputInterface $input, OutputInterface $output) {
             // Import logic here
         }
     }
     

     Register in app/config/commands.yml:

     commands:
         ais:import_products: ~