root/trunk/src/main/php/net/stubbles/websites/xml/stubXMLProcessor.php @ 1392

<?php
/**
 * Default processor delivered by stubbles.
 *
 * @author      Frank Kleine <mikey@stubbles.net>
 * @author      Stephan Schmidt <schst@stubbles.net>
 * @package     stubbles
 * @subpackage  websites_xml
 */
stubClassLoader::load('net::stubbles::websites::processors::stubAbstractPageProcessor',
                      'net::stubbles::websites::xml::stubXMLResponse',
                      'net::stubbles::ioc::stubBinder',
                      'net::stubbles::ipo::request::stubRequestPrefixDecorator',
                      'net::stubbles::ipo::response::stubBaseResponse',
                      'net::stubbles::util::stubRegistry',
                      'net::stubbles::util::validators::stubRegexValidator',
                      'net::stubbles::xml::stubXMLStreamWriterFactory',
                      'net::stubbles::xml::serializer::stubXMLSerializer'
);
/**
 * Default processor delivered by stubbles.
 *
 * @package     stubbles
 * @subpackage  websites_xml
 */
class stubXMLProcessor extends stubAbstractPageProcessor
{
    /**
     * constructor
     *
     * @param  stubRequest      $request      the current request
     * @param  stubSession      $session      the current session
     * @param  stubResponse     $response     the current response
     * @param  stubPageFactory  $pageFactory  page factory to use to read the page configuration
     */
    public function __construct(stubRequest $request, stubSession $session, stubResponse $response, stubPageFactory $pageFactory)
    {
        $response = new stubXMLResponse($response);
        parent::__construct($request, $session, $response, $pageFactory);
        $this->pageDirPrefix = 'conf/';
    }

    /**
     * does the real processing
     *
     * @param  stubPage  $page      the page to process
     * @param  string    $pageName  name of the page to process
     */
    protected function doProcess(stubPage $page, $pageName)
    {
        $xmlSerializer   = $this->createXMLSerializer();
        $xmlStreamWriter = $this->createXMLStreamWriter();
        $this->response->setPage($page);
        $elements        = $page->getElements();
        $xmlStreamWriter->writeStartElement('document');
        $xmlStreamWriter->writeAttribute('page', $pageName);
        $this->writeSessionValues($xmlStreamWriter);
        $prefixRequest = new stubRequestPrefixDecorator($this->request, '');
        $formValues    = array();

        if (stubRegistry::has(stubBinder::REGISTRY_KEY)) {
            $injector = stubRegistry::get(stubBinder::REGISTRY_KEY)->getInjector();
        } else {
            $injector = null;
        }

        foreach ($elements as $name => $element) {
            $prefixRequest->setPrefix($name);
            if (null !== $injector) {
                $injector->handleInjections($element);
            }

            $element->init($prefixRequest, $this->session, $this->response);
            if ($element->isAvailable() == false) {
                continue;
            }

            $data = $element->process();
            if ($prefixRequest->isCancelled() === true) {
                return;
            }

            $xmlSerializer->serialize($data, $xmlStreamWriter, array(stubXMLSerializer::OPT_ROOT_TAG => $name));
            if ($element instanceof stubXMLPageElement) {
                $formValues[$name] = $element->getFormValues();
            }
        }

        $xmlSerializer->serialize($formValues, $xmlStreamWriter, array(stubXMLSerializer::OPT_ROOT_TAG => 'forms'));
        $this->writeRequestValues($xmlStreamWriter, $xmlSerializer);

        // write resources
        if (null !== $injector) {
            $xmlStreamWriter->writeStartElement('resources');
            foreach ($page->getResources() as $name => $interface) {
                $resource = $injector->getInstance($interface);
                $xmlSerializer->serialize($resource, $xmlStreamWriter, array(stubXMLSerializer::OPT_ROOT_TAG => $name));
            }
        }
        
        $xmlStreamWriter->writeEndElement();
        $this->response->setXMLStreamWriter($xmlStreamWriter);
    }

    /**
     * writes the session values into the result document
     *
     * Default values are whether the session is new or not, the current and
     * the next token of the request:
     * <code>
     * <document>
     *   <session>
     *     <acceptsCookies>true</acceptsCookies>
     *     <id>abc123</id>
     *     <name>PHPSESSID</name>
     *     <isNew>true</isNew>
     *     <variant>
     *       <name>foo</name>
     *       <alias>bar</alias>
     *     </variant>
     *     <token>
     *       <current>foo</current>
     *       <next>bar</next>
     *     </token>
     *   </session>
     *   [...]
     * </document>
     * </code>
     * Concrete session data will not be written into the result document.
     *
     * @param  stubXMLStreamWriter  $xmlStreamWriter
     */
    protected function writeSessionValues(stubXMLStreamWriter $xmlStreamWriter)
    {
        $xmlStreamWriter->writeStartElement('session');
        if ($this->request->acceptsCookies() === true) {
            $xmlStreamWriter->writeElement('acceptsCookies', array(), 'true');
        } else {
            $xmlStreamWriter->writeElement('acceptsCookies', array(), 'false');
        }
        
        $xmlStreamWriter->writeElement('id', array(), $this->session->getId());
        $xmlStreamWriter->writeElement('name', array(), stubRegistry::getConfig(stubSession::NAME_REGISTRY_KEY, stubSession::DEFAULT_SESSION_NAME));
        $xmlStreamWriter->writeElement('isNew', array(), (($this->session->isNew() === true) ? ('true') : ('false')));
        $xmlStreamWriter->writeStartElement('variant');
        $xmlStreamWriter->writeElement('name', array(), (string) $this->session->getValue('net.stubbles.websites.variantmanager.variant.name'));
        $xmlStreamWriter->writeElement('alias', array(), (string) $this->session->getValue('net.stubbles.websites.variantmanager.variant.alias'));
        $xmlStreamWriter->writeEndElement();  // end variant
        $xmlStreamWriter->writeStartElement('token');
        $xmlStreamWriter->writeElement('current', array(), $this->session->getCurrentToken());
        $xmlStreamWriter->writeElement('next', array(), $this->session->getNextToken());
        $xmlStreamWriter->writeEndElement();  // end token
        $xmlStreamWriter->writeEndElement();  // end session
    }

    /**
     * writes the request values into the result document
     *
     * Currently this are only the request errors created during processing of the page elements:
     * <code>
     *   [...]
     *   <request>
     *     <errors>
     *       <error id="foo">
     *         <messages>
     *           <de_DE>Dies ist eine deutsche Fehlermeldung.</de_DE>
     *           <en_EN>This is an english error message.</en_EN>
     *         </messages>
     *       </error>
     *       [...]
     *     </errors>
     *   </request>
     * </code>
     * Concrete request values will not be written into the result document.
     *
     * @param  stubXMLStreamWriter  $xmlStreamWriter
     * @param  stubXMLSerializer    $xmlSerializer
     */
    protected function writeRequestValues(stubXMLStreamWriter $xmlStreamWriter, $xmlSerializer)
    {
        $xmlStreamWriter->writeStartElement('request');
        $errors = $this->request->getValueErrors();
        foreach ($errors as $requestValueName => $requestErrorValues) {
            $xmlStreamWriter->writeStartElement('value');
            $xmlStreamWriter->writeAttribute('name', $requestValueName);
            $xmlSerializer->serialize(array_values($requestErrorValues), $xmlStreamWriter, array(stubXMLSerializer::OPT_ROOT_TAG => 'errors'));
            $xmlStreamWriter->writeEndElement();
        }

        $xmlStreamWriter->writeEndElement();  // end request
    }

    /**
     * returns a xml stream writer
     *
     * @return  stubXMLStreamWriter
     */
    protected function createXMLStreamWriter()
    {
        return stubXMLStreamWriterFactory::createAsAvailable();
    }

    /**
     * returns the xml serializer
     *
     * @return  stubXMLSerializer
     */
    protected function createXMLSerializer()
    {
        $xmlSerializer = new stubXMLSerializer();
        return $xmlSerializer;
    }
}
?>