Symfony2/Doctrine, having to put business logic in my controller? And duplicating controller?

Question

I have a somewhat complex pricing mechanism in my application- Here are some of my business rules to set the stage (Entities are bolded):

• A Product may have unique Price Points for a given Customer, Website, or Customer Group.
• A Product can sometimes have one or more additional Options that may have their own Price Points or Price Rules.
• A Product has one Unique Addition selected by the user, which is essentially a price and an integer.

Right now, I have an EntityRepository for Price Points to essentially determine the correct price point for the base product. The same goes for the Unique Addition and the Options.

PricePointRepository

public function getThePrice($Product, $qty, $Website, $Customer = null) 
{
    //all logic to get product price for this given instance goes here. Good.
}

Controller (simplified)

public function indexAction() 
{
    $Product = $em->dostuffwithpostdata;
    $qty = POST['qty']; //inb4insecure trolls
    $Website = $em->dostuff();
    $Customer = (if user is logged in, return their object with $em, otherwise null as it is a guest or public person); // No business logic here, just understanding the request.

    $price = $em->getRepository(PricePointRepository)->getThePrice($Product,$qty,Website,$Customer);

    $Options[] = $em->dostuffwithPOSTdata;
    $optionsPrice = 0;
    //Below is some logic directly related to pricing the product. 
    foreach($Options as $option) {
        if($option->hasRule()) {
            $optionsPrice += $ruleprice; //after some other stuff of course)
        } else {
            $optionsPrice += $em->getRepository(OptionPricePoints)->getPrice($option->getID(),$qty);
        }
    }

    $uniqueAdditionPrice = $em->stuff;

    $finalprice = $price + $optionsPrice + $uniqueAdditionPrice; //This is logic related to how I price this type of product!
    $unitprice = $finalprice / $qty;

    //twig stuff to render and show $finalprice, $unitprice, $uniqueAdditionPrice
}

That's just for the product page. What happens when I get to the cart, saving the order, etc, when this logic needs to be reused. As you can see, I use Doctrine throughout to pull data based on my business logic in the repository classes.

I gladly welcome urdoingitwrong answers, because I really do think this is wrong. How do I go about fixing this? Something beautiful would be a service that essentially goes like this:

$pricer = getPricerService->Pricer($Entities,$postdata,$etc);
$unitPrice = $pricer->getUnitPrice();
$totalPrice = $pricer->getTotalPrice();
$optionsPrice = $pricer->getOptionsPrice();

But I have no idea how to go about doing that inside of Symfony/Doctrine, especially the way Doctrine and Repositories are accessed in Controllers.

Answer 1

You're correct that you should have all your re-usable business logic farmed off to a service so that different controllers can re-use the code.

Have you checked out the "how to create a service" documentation:

Service Container Documentation

I'll give you the speed run-down though.

In config.yml you need to define your service:

services:
    pricing_service:
        class: Acme\ProductBundle\Service\PricingService
        arguments: [@doctrine]

Then you just need to make a bog standard PHP class to represent your service:

namespace Acme\ProductBundle\Service;

class PricingService {

    private $doctrine;        

    function __construct($doctrine) {
        $this->doctrine = $doctrine; // Note that this was injected using the arguments in the config.yml
    }

    // Now the rest of your functions go here such as "getUnitPrice" etc etc.
}

Lastly to get your service from a controller you just need to do:

$pricingService = $this->get('pricing_service');

There are other ways you can modularise the service such as not dumping all your services into config.yml but all of that is explained in the documentation. Also note that you can inject any other service you wish into your service so if you need stuff like arguments: [@doctrine, @security.context, @validator] you can do all that stuff or even: [@my_other_service].

I suspect from your other question on injecting the EntityManager you may have already gleamed this was the way to go though!

Hopefully this was still useful to you!

Answer 2

You simplified your example so I don't really know all the details but here's my attemt to solve your problem.

Note that you might actually need more then one service but you should get the idea based on my example.

Basically follow the principle - One class has one responsobility.

Price calculator calculates the Price:

namespace MyNamespace;

class PriceCalculator
{
    private $entityManager = null;

    public function __construct(Doctrine\ORM\EntityManager $entityManager)
    {
        $this->entityManager = $entityManager;
    }

    /**
     * @return PriceInterface
     */
    public function calculate()
    {
        // do your stuff and return Price
    }
}

Price is described by the PriceInterface:

namespace MyNamespace;

interface PriceInterface
{
    public function getUnitPrice();

    public function getTotalPrice();

    public function getOptionsPrice();
}

Price calculator service has a dependency on the entity manager:

my_namespace.price_calculator:
  class:     MyNamespace\PriceCalculator
  arguments: [ @doctrine.orm.default_entity_manager ]

Controller uses price calculator service to get the price:

public function indexAction() 
{
    $priceCalculator = $this->get('my_namespace.price_calculator');
    $price = $priceCalculator->calculate();

    $unitPrice = $price->getUnitPrice();
    $totalPrice = $price->getTotalPrice();
    $optionsPrice = $price->getOptionsPrice();
}

If you need a Request or other service you can inject them using DIC or manually as a parameter to calculate() method.

Note that I injected EntityManager to the PriceCalculator service but you might define data providers as services and inject them instead (for really complicated things).

You could also push all queries to repositories and pass entities to your PriceCalculator.