MVC: how to ajax?

Question

I'm going to start a project using a Zend Framework MVC implementation.

How do I work with ajax? I mean, should I place all ajax code into controller? Or into view?

For example, I want to get posts from author 'ivan' to show on a page.

Normally, I create a link to '/posts/author/ivan' or smth like it, create a new Action like 'byAuthorAction()' in the Posts controller (or maybe Users controller, wherever), view for it (and all code what gets posts from model goes there) and create a new Route to it.

How to add functionality to get any user's posts in json, xml formats for ajax and maybe API, keeping the DRY principle and designing the code structure as smart as I can?

--

Thanks for answers! I will be very glad to see comments about designing MVC in situations like mine. I have some experience in basic MVC principles but not in more complicated cases. Maybe some useful links?

Answer 1

My syntax might be older but this a sketch of my REST action from my Index Controller:

/**
 * REST Action for this application.
 *
 * @return void
 */
public function restAction()
{
    $this->_helper->viewRenderer->setNoRender(true);

    $parameters = (func_num_args() > 0) ? array($key => func_get_arg(0)) : $this->getRequest()->getParams();

    $key = 'restCommand';
    if(!array_key_exists($key, $parameters)) throw new Exception('Request for “' . $key . '” not found.');
    $restCommand = $parameters[$key];

    $xmlString = IndexModel::getEmptyXmlSet($restCommand);
    $xslFile = IndexModel::getModelFilePath('index');

    //Handle OPML-driven REST commands:
    if(stripos($restCommand, 'opml-') === 0)
    {
        $opmlCall = explode('-', $restCommand);
        if(count($opmlCall) != 3)
        {
            $xmlString = Songhay_SimpleXml::getXmlMessage('OPML Call Not Recognized', array('The number of parameters are incorrect.'));
        }
        else
        {
            $opmlSet = $opmlCall[1];
            $opmlId = $opmlCall[2];
            $xmlString = IndexModel::getRssFragmentWithOpml($opmlSet, $opmlId);
        }
    }

    //Handle general REST commands:
    switch($restCommand)
    {
        case 'deeplink':
            $key = 'id';
            if(!array_key_exists($key, $parameters)) throw new Exception('Request for “' . $key . '” not found.');
            $url = $parameters[$key];
            $xmlString = IndexModel::getRssFragment($url);
            $xmlString = Songhay_SimpleXml::loadXslString($restCommand, $xmlString, $xslFile);
            break;
        case 'index':
            $opmlFile = IndexModel::getModelFilePath('index', '.xml');
            $xmlString = Songhay_SimpleXml::loadXmlAndStripNamespaces($opmlFile);
            $xmlString = Songhay_SimpleXml::loadXslString($restCommand, $xmlString, $xslFile);
            break;
        default:
            $xmlString = Songhay_SimpleXml::loadXslString($restCommand, $xmlString, $xslFile);
    }

    $response = $this->getResponse();
    $response->setHeader('Content-Type', 'text/xml');
    $response->setBody($xmlString);

    return;
}

Answer 2

You can utilize the same actions to return XML, JSON or whatever, by detecting ajax requests and thus being able to differentiate ajax requests from normal ones. For example:

public function fooAction()
{
    if($this->getRequest->isXmlHttpRequest()) {
        echo json_encode($someData);
    } else {
        echo 'This is the normal output';
    }
}

Answer 3

Your View can be something other than HTML, and either the pipeline can react to the request being an ajax post, or your controller can react. Either way, it should be as simple as return a different View.

Answer 4

Take a look at the AjaxContext Action-Helper (or the ContextSwitch one, which it extends), and it will allow you to use exactly the same controller code, switching to either a separate view-script (foo.json.phtml, or foo.ajax.phtml etc. - picked up automatically from a ?format parameter), or make use of the JSON Action-Helper that will return an object comprising all the variables you assign to the view - so you don't need to be echoing from your controller (which will mess up unit-tests, should you have them).

Answer 5

You really should read the manual chapter about ContextSwitch Action Helper. But here is a brief outline:

• your view scripts (action-name.phtml) are used for regular HTML output
• you can initialize a context switch for some actions in the controller so thay can output for example XML - xml context is supported by default and you would put your view script for xml context in (action-name.xml.phtml); xml context also disables rendering of the layout
• json is also supported by the built in context switch and default option is to disable both the layout and the view and to output all the variables assigned to the view from the controller action in JSON format, this option can be toggled by using the setAutoJsonSerialization(false) method of the context switch; but if you switch it you have to create a view script action-name.json.phtml and output the variables in JSON format by hand

To switch between these two contexts you have to add a format parameter to your URL, e.g. /posts/author/ivan/format/json or /posts/author/ivan/format/xml. If you do not specify the format your application will output plain html.

Special version of the Context switch is AjaxContext and you also have to configure this one by hand. It does not use the 'format' parameter to identify which format it should use for output but it examines the header sent in your request and looks for 'X-Requested-With: XmlHttpRequest' header and if it is present the AjaxContext is examined. Using the AjaxContext action helper you can specify which context should be used for specific actions if the request is fired using AJAX.

Answer 6

When i use ajax with codeigniter i output straight out of the controller.

I also use seperate controller for simple ajax requests like flagging, favorites, etc. For ajax requests like login, contact, etc i would add logic to the normal path(eg. domain.com/contact) do deal with an ajax request. I then output json and kill script execution.