Question

I’ve built a first-run web service on Zend Framework (1.10), and now I’m looking at ways to refactor some of the logic in my Action Controllers so that it will be easier for me and the rest of my team to expand and maintain the service.

I can see where there are opportunities for refactoring, but I’m not clear on the best strategies on how. The best documentation and tutorials on controllers only talk about small scale applications, and don’t really discuss how to abstract the more repetitive code that creeps into larger scales.

The basic structure for our action controllers are:

1. Extract XML message from the request body – This includes validation against an action-specific relaxNG schema
2. Prepare the XML response
3. Validate the data in the request message (invalid data throws an exception – a message is added to the response which is sent immediately)
4. Perform database action (select/insert/update/delete)
5. Return success or failure of action, with required information

A simple example is this action which returns a list of vendors based on a flexible set of criteria:

class Api_VendorController extends Lib_Controller_Action
{  
    public function getDetailsAction()
    {
        try {
            $request = new Lib_XML_Request('1.0');
            $request->load($this->getRequest()->getRawBody(), dirname(__FILE__) . '/../resources/xml/relaxng/vendor/getDetails.xml');
        } catch (Lib_XML_Request_Exception $e) {
            // Log exception, if logger available
            if ($log = $this->getLog()) {
                $log->warn('API/Vendor/getDetails: Error validating incoming request message', $e);
            }

            // Elevate as general error
            throw new Zend_Controller_Action_Exception($e->getMessage(), 400);
        }

        $response = new Lib_XML_Response('API/vendor/getDetails');

        try {
            $criteria = array();
            $fields = $request->getElementsByTagName('field');
            for ($i = 0; $i < $fields->length; $i++) {
                $name = trim($fields->item($i)->attributes->getNamedItem('name')->nodeValue);
                if (!isset($criteria[$name])) {
                    $criteria[$name] = array();
                }
                $criteria[$name][] = trim($fields->item($i)->childNodes->item(0)->nodeValue);
            }

            $vendors = $this->_mappers['vendor']->find($criteria);
            if (count($vendors) < 1) {
                throw new Api_VendorController_Exception('Could not find any vendors matching your criteria');
            }

            $response->append('success');
            foreach ($vendors as $vendor) {
                $v = $vendor->toArray();
                $response->append('vendor', $v);
            }

        } catch (Api_VendorController_Exception $e) {
            // Send failure message
            $error = $response->append('error');
            $response->appendChild($error, 'message', $e->getMessage());

            // Log exception, if logger available
            if ($log = $this->getLog()) {
                $log->warn('API/Account/GetDetails: ' . $e->getMessage(), $e);
            }
        }

        echo $response->save();
    }
}

So – knowing where the commonalities are in my controllers, what’s the best strategy for refactoring while keeping it Zend-like and also testable with PHPUnit?

I did think about abstracting more of the controller logic into a parent class (Lib_Controller_Action), but this makes unit testing more complicated in a way that seems to me to be wrong.

Answer 1

Two ideas (just creating an answer from the comments above):

1. Push commonality down into service/repository classes? Such classes would be testable, would be usable across controllers, and could make controller code more compact.

2. Gather commonality into action helpers.