paint_layout_page.inc

<?php
require_once SQ_CORE_PACKAGE_PATH.'/page_templates/page_standard/page_standard.inc';
require_once SQ_CORE_PACKAGE_PATH.'/paint_layout/paint_layout_bodycopy/paint_layout_bodycopy.inc';

define('SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE', 'paint_layout_bodycopy');
define('SQ_PAINT_LAYOUT_REQUEST_VAR_ASSET', 'sqpa');
define('SQ_PAINT_LAYOUT_DEFAULT_FORMAT_NAME', 'default_format');


class Paint_Layout_Page extends Page_Standard
{


    function __construct($assetid=0)
    {
        $this->_ser_attrs = TRUE;
        parent::__construct($assetid);

    }//end constructor


    protected function _createAdditional(Array &$link)
    {
        if (!parent::_createAdditional($link, Array('content' => '%paint_layout%'))) return FALSE;

        // add a bodycopy to this page when creating
        $GLOBALS['SQ_SYSTEM']->am->includeAsset(SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE);

        // 1. create type formats folder
        $GLOBALS['SQ_SYSTEM']->am->includeAsset('folder');

        $sub_assets= Array(
                        'type_formats'  => 'folder',
                     );

        $type_formats = NULL;
        foreach ($sub_assets as $name => $type) {
            $asset = new $type();
            $copy_link = Array('asset' => &$this, 'value' => $name ,'link_type' => SQ_LINK_TYPE_2, 'is_dependant' => 1, 'is_exclusive' => 1);

            $asset->setAttrValue('name', ucwords(str_replace('_',' ', $name)));
            if (!$asset->create($copy_link)) return FALSE;

            if ($name == 'type_formats') $type_formats = $asset;

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($asset);
            unset($asset);
        }

        // 2. create default format bodycopy
        $type_format_asset_type_code = SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE;
        $asset = new $type_format_asset_type_code();

        $copy_link = Array(
                        'asset'         => &$type_formats,
                        'value'         => SQ_PAINT_LAYOUT_DEFAULT_FORMAT_NAME,
                        'link_type'     => SQ_LINK_TYPE_2,
                        'is_dependant'  => 1,
                        'is_exclusive'  => 1,
                     );

        $asset->setAttrValue('name', 'Default Format');

        return $asset->create($copy_link, Array('content' => '%asset_contents%'));

    }//end _createAdditional()


    public function setAttrValue($name, $value)
    {
        if ($name == 'types' && !empty($value)) {
            // because of way that we use the 'types' attribute in _getBodycopyFromAssetTypeCode() we need to make sure
            // that all the types that inherit from other types are at the start of the list
            // otherwise if we have 'page' and 'page_standard' in the list in that order, and we are viewing a page_standard asset
            // it will pick the 'page' format bodycopy because 'page_standard' inherits from 'page'
            $orig_value = $value;
            $value = Array();
            $levels = $GLOBALS['SQ_SYSTEM']->am->getTypeInfo(array_keys($orig_value), 'lvl');
            arsort($levels);
            foreach ($levels as $type_code => $lvl) {
                $value[$type_code] = $orig_value[$type_code];
            }

        }

        return parent::setAttrValue($name, $value);

    }//end setAttrValue()


    public function printBody()
    {
        $assetid = $this->_getAssetToPaint();
        $this->paintAssetFromId($assetid);

    }//end printBody()


    public function onRequestKeywords(Asset $broadcaster, Array $vars=Array())
    {
        if (!isset($vars['keywords'])) return;

        $parents = $GLOBALS['SQ_SYSTEM']->am->getParents($broadcaster->id);

        // if we're being handled here (instead of one of our extensions),
        // it must be from one of our format bodycopies, or something else altogether,
        // so we'll try to find out which of the format types it is.
        $folder = $this->getFolder();
        if (is_null($folder)) return;

        if (isset($parents[$folder->id])) {
            $type_links = $GLOBALS['SQ_SYSTEM']->am->getLinks($folder->id, SQ_LINK_TYPE_2, SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE);

            foreach ($type_links as $link_info) {
                if (isset($parents[$link_info['minorid']])) {
                    $type_code = $link_info['value'];
                    if ($type_code == SQ_PAINT_LAYOUT_DEFAULT_FORMAT_NAME) {
                        $type_code = '';
                    }

                    $type_format = $GLOBALS['SQ_SYSTEM']->am->getAsset($link_info['minorid']);
                    if (!empty($type_format)) {
                        $type_format->getKeywordsDescription($vars['keywords'], $type_code);
                    }

                    break;
                }
            }

        } else {
            // must be our page contents bodycopy
            $vars['keywords']['paint_layout'] = 'Paint Layout';
        }

    }//end onRequestKeywords()


    protected function _getAssetToPaint()
    {
        $ret = 0;

        if (!empty($_REQUEST[SQ_PAINT_LAYOUT_REQUEST_VAR_ASSET])) {
            $ret = $_REQUEST[SQ_PAINT_LAYOUT_REQUEST_VAR_ASSET];
        }

        return $ret;

    }//end _getAssetToPaint()


    public function paintAssetFromId($assetid=0)
    {
        if (!empty($assetid)) {
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
            $this->paint($asset);
        }


    }//end paintAssetFromId()


    public function paint(Asset $asset)
    {
        if (!empty($asset)) {
            $bodycopy = $this->getBodycopy();
            if (is_null($bodycopy) || !$bodycopy->readAccess()) {
                $asset->printBody();
            } else {
                $keywords = $bodycopy->getKeywords();
                $replacements = $this->_getKeywordReplacements($keywords, $asset);
                $bodycopy->setKeywordReplacements($replacements);
                $bodycopy->printBody();
            }
        }

    }//end paint()


    protected function &_getKeywordReplacements($keywords, &$asset)
    {
        $ret = Array();

        if (in_array('paint_layout', $keywords)) {
            $asset_type_code = $asset->type();
            $bodycopy = $this->_getBodycopyFromAssetTypeCode($asset_type_code);

            $ret['paint_layout'] = $bodycopy->paintAsset($asset);
        }

        return $ret;

    }//end _getKeywordReplacements()


    protected function _getBodycopyFromAssetTypeCode($asset_type_code)
    {
        $ret = NULL;

        $supported_types = $this->attr('types');

        $format_type = '';
        foreach ($supported_types as $supported_type => $inherited) {
            $supported_type_and_children = ($inherited) ? $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($supported_type, TRUE) : Array($supported_type);
            if (in_array($asset_type_code, $supported_type_and_children)) {
                $format_type = $supported_type;
                break;
            }
        }

        $folder = $this->getFolder();

        if (!empty($format_type)) {
            $format_link = $GLOBALS['SQ_SYSTEM']->am->getLink($folder->id, SQ_LINK_TYPE_2, SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE, TRUE, $format_type);
        } else {
            // not a customized type, so let's take the default format
            $format_link = $GLOBALS['SQ_SYSTEM']->am->getLink($folder->id, SQ_LINK_TYPE_2, SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE, TRUE, SQ_PAINT_LAYOUT_DEFAULT_FORMAT_NAME);
        }

        if (!empty($format_link)) {
            $ret = $GLOBALS['SQ_SYSTEM']->am->getAsset($format_link['minorid'], $format_link['minor_type_code']);
        }

        return $ret;

    }//end _getBodycopyFromAssetTypeCode()


    public function getFolder($type='type_formats')
    {
        $null = NULL;
        $link = $GLOBALS['SQ_SYSTEM']->am->getLink($this->id, SQ_LINK_TYPE_2, 'folder', TRUE, $type);
        if (empty($link)) return $null;

        $folder = $GLOBALS['SQ_SYSTEM']->am->getAsset($link['minorid'], $link['minor_type_code']);
        if (is_null($folder)) return $null;

        return $folder;

    }//end getFolder()


    public function getFormats($type='type_formats')
    {
        if (!isset($this->_tmp['formats'][$type])) {
            $folder = $this->getFolder($type);
            $format_links = $GLOBALS['SQ_SYSTEM']->am->getLinks($folder->id, SQ_LINK_TYPE_2, SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE, TRUE);
            if (empty($format_links)) return Array();

            $formats = Array();
            foreach ($format_links as $link_data) {
                $formats[$link_data['minorid']] = $link_data['value'];
            }
            $this->_tmp['formats'][$type] = $formats;
        }
        return $this->_tmp['formats'][$type];

    }//end getFormats()


    public function createTypeFormatBodycopy($type)
    {
        $ret = FALSE;

        // create new bodycopy for that type
        $folder = $this->getFolder('type_formats');
        $new_type = $type;
        // check that this type isnt already customised
        $current_link = $GLOBALS['SQ_SYSTEM']->am->getLink($folder->id, SQ_LINK_TYPE_2, SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE, TRUE, $new_type);
        if (empty($current_link)) {
            // create a new format bodycopy for this type
            $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
            $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');
            $GLOBALS['SQ_SYSTEM']->am->includeAsset(SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE);

            $copy_link = Array('asset' => &$folder, 'value' => $new_type, 'link_type' => SQ_LINK_TYPE_2, 'is_dependant' => 1, 'is_exclusive' => 1);

            $type_format_asset_type_code = SQ_PAINT_LAYOUT_FORMAT_ASSET_TYPE;
            $bodycopy = new $type_format_asset_type_code();
            $bodycopy->setAttrValue('name', $GLOBALS['SQ_SYSTEM']->am->getTypeInfo($new_type, 'name').' Format');
            $bodycopy->setAttrValue('associated_asset_type', $type);

            if ($bodycopy->create($copy_link)) {
                $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
                $ret = TRUE;
            } else {
                $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
            }
            $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
        } else {
            $ret = TRUE;
        }

        return $ret;

    }//end createTypeFormatBodycopy()


}//end class

?>