remap_manager.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset.inc';

class Remap_Manager extends Asset
{


    function Remap_Manager($assetid=0)
    {
        $this->Asset($assetid);

    }//end constructor


    public function create(Array &$link)
    {
        require_once SQ_CORE_PACKAGE_PATH.'/system/system_asset_fns.inc';
        if (!system_asset_fns_create_pre_check($this)) {
            return FALSE;
        }
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        if ($linkid = parent::create($link)) {
            if (!system_asset_fns_create_cleanup($this)) {
                $linkid = FALSE;
            }
        }

        if ($linkid) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        } else {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
        }

        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
        return $linkid;

    }//end create()


    protected function _getName($short_name=FALSE)
    {
        return $GLOBALS['SQ_SYSTEM']->am->getTypeInfo($this->type(), 'name');

    }//end _getName()


    public function _getAllowedLinks()
    {
        $page_links = parent::_getAllowedLinks();
        // added for root node
        $page_links[SQ_LINK_NOTICE]['asset'] = Array('card' => 'M', 'exclusive' => FALSE);
        return $page_links;

    }//end _getAllowedLinks()


    public function canDelete()
    {
        return FALSE;

    }//end canDelete()


    public function canClone()
    {
        return FALSE;

    }//end canClone()


    public function describeLink($linkid)
    {
        $link = $GLOBALS['SQ_SYSTEM']->am->getLinkById($linkid);
        switch (strtolower($link['value'])) {
            case '404' :
                return translate('404_remap_description');
            break;
            default :
                return parent::describeLink($linkid);
            break;
        }

    }//end describeLink()


    public function addRemapURL($old_url, $new_url, $expires=NULL, $never_delete=NULL, $auto=TRUE)
    {
        // old url and new url must be strings, makes not sense otherwise
        if (!is_string($old_url) || !is_string($new_url)) {
            trigger_localised_error('CORE0093', E_USER_WARNING);
            return 0;
        }

        $old_url = strip_url($old_url);
        $new_url = strip_url($new_url);

        // there is no use remapping a URL to itself
        if (strcmp($old_url, $new_url) == 0) return 1;

        // can't remap to a blank URL
        if ($new_url === '') {
            trigger_localised_error('CORE0271', E_USER_WARNING);
            return 0;
        }

        $db = MatrixDAL::getDb();

        $sql = 'SELECT remap_url
                FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_lookup_remap';
        $where = 'url = :url';
        $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where);

        try {
            $query = MatrixDAL::preparePdoQuery($sql.$where);
            MatrixDAL::bindValueToPdo($query, 'url', $old_url);
            $remap_urls = MatrixDAL::executePdoAssoc($query, 0);
        } catch (Exception $e) {
            throw new Exception('Unable to get remap URLs for URL: '.$old_url.' due to database error: '.$e->getMessage());
        }

        if (in_array($new_url, $remap_urls)) return 1;

        if (count($remap_urls) > 0) {
            trigger_localised_error('CORE0024', E_USER_WARNING, $old_url);
            return -1;
        }
        
        if ($never_delete === NULL){
            $never_delete = ($this->attr('never_delete_remap_default') == FALSE) ? 0 : 1;
        }
        
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $db = MatrixDAL::getDb();
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        // check if the new URL is already remapping to something else, and delete it
        $sql = 'DELETE FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_lookup_remap';
        $where = ' WHERE url = :url';

        try {
            $query = MatrixDAL::preparePdoQuery($sql.$where);
            MatrixDAL::bindValueToPdo($query, 'url', $new_url);
            MatrixDAL::execPdoQuery($query);
        } catch (Exception $e) {
            throw new Exception('Unable to delete old remap URLs for URL: '.$new_url.' due to database error: '.$e->getMessage());
        }
        
        try {
            $bind_vars  = Array (
                            'url'       => $old_url,
                            'remap_url' => $new_url,
                            'expires'   => (is_null($expires)) ? $expires : ts_iso8601($expires),
                            'never_delete' => $never_delete,
                            'auto_remap' => ($auto === TRUE) ? '1' : (($auto === FALSE) ? '0' : NULL),
                          );
            $type_codes = MatrixDAL::executeQuery('core', 'insertRemap', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to insert new remap from: '.$old_url.' to: '.$new_url.' due to database error: '. $e->getMessage());
        }

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return 1;

    }//end addRemapURL()


    public function getRemapURLs(Asset $asset)
    {
        $null = NULL;
        if (is_null($asset)) return $null;

        $urls = $asset->getURLs();
        $remaps = Array();

        if (!empty($urls)) {

            $bind_vars = Array();

            // This sub-query gets all URLs for this asset that have HTTP enabled
            // and adds http protocol to them to create a usable URL - then same
            // or similar for HTTPS enabled.
            $sql = 'SELECT url, remap_url, expires, never_delete, auto_remap
                    FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_lookup_remap';
            $union_select = '(SELECT
                                (\'http://\' || url)
                            FROM sq_ast_lookup
                            '.$GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause('http = \'1\'
                                AND assetid = :assetid').')
                            UNION
                            (SELECT
                                (\'https://\' || url)
                            FROM sq_ast_lookup
                            '.$GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause('https = \'1\'
                                AND assetid = :assetid_1').')';

            $bind_vars['assetid'] = $asset->id;
            $bind_vars['assetid_1'] = $asset->id;
            $where = 'remap_url IN ('.$union_select.')';
            $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where);

            try {
                $query  = MatrixDAL::preparePdoQuery($sql.$where);
                foreach ($bind_vars as $bind_var => $bind_value) {
                    MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
                }
                $remaps = MatrixDAL::executePdoAssoc($query);
            } catch (Exception $e) {
                throw new Exception('Unable to get remap URLs for this asset: '.$asset->id.' due to database error: '.$e->getMessage());
            }

        }//end if

        return $remaps;


    }//end getRemapURLs()


    public function remapAllURLs($assetid, $new_url, $expires=NULL)
    {
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');

        try {
            $bind_vars = Array('assetid' => $assetid);
            $urls = MatrixDAL::executeAll('core', 'getLookupUrlsByAssetId', $bind_vars);
        } catch (DALException $e) {
            throw new Exception('Unable to remap all URLs; could not get existing lookups for asset ID #'.$assetid.' due to database error: '.$e->getMessage);
        }

        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        $protocols = Array ( 'https' => FALSE, 'http' => FALSE );
        $never_delete = ($this->attr('never_delete_remap_default') == FALSE) ? 0 : 1;
        
        foreach ($urls as $url_data) {
            if ($url_data['http']) {
                $retval = @$this->addRemapURL('http://'.$url_data['url'], $new_url, $expires, $never_delete, FALSE);
                if ($retval === 0) {
                    trigger_localised_error('CORE0039', E_USER_WARNING, $assetid, $new_url);
                    $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
                    $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
                    return FALSE;
                }
                $protocols['http'] = TRUE;
            }
            if ($url_data['https']) {
                $retval = @$this->addRemapURL('https://'.$url_data['url'], $new_url, $expires, $never_delete, FALSE);
                if ($retval === 0) {
                    trigger_localised_error('CORE0039', E_USER_WARNING, $assetid, $new_url);
                    $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
                    $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
                    return FALSE;
                }
                $protocols['https'] = TRUE;
            }
        }
        
        //Feature #4759: Asset ID to URL remaps.
        foreach ($protocols as $protocol => $enabled){
            if ($enabled){
                //try deleting first as we want to be able to change remap entries for the assetid.
                try {
                    $bind_vars = Array('urls' => Array($protocol.'://?a='.$assetid));
                    MatrixDAL::executeQuery('remap_manager', 'deleteRemapsByURL', $bind_vars);
                } catch (DALException $e) {
                    throw new Exception('Unable to delete assetid remaps due to database error: '.$e->getMessage());
                }
                $retval = @$this->addRemapURL($protocol.'://?a='.$assetid, $new_url, $expires, $never_delete, FALSE);
                if ($retval !== 1) {
                    trigger_localised_error('CORE0040', E_USER_WARNING, $assetid, $new_url);
                    $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
                    $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
                    return FALSE;
                }
            }
        }

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
        return TRUE;

    }//end remapAllURLs()

    public function loadRemapFromCurrentURL()
    {
        $protocol = current_protocol();

        // URL without parameters
        $url      = strip_url(current_url(FALSE, TRUE));

        // This URL is verbatim
        $url_with_params = strip_url($_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI']);

        // Try verbatim URL first
        if($this->loadRemapFromURL($protocol, $url_with_params))
             return TRUE;

        if(!$this->attr("preserve_url_parameters")) {
            // If the urls are the same with and without params, there's no
            // need to check anything else.
            if ($url === $url_with_params) {
                return FALSE;
            }

            // Try URL without paramters
            return($this->loadRemapFromURL($protocol, $url));
        }

        // Try URL, and preserve all parameters when redirecting
        $parameters = '';
        $pos = strpos($url_with_params, '?');
        if($pos !== FALSE) {
            $parameters = substr($url_with_params, $pos + 1);
        }

        // Try URL and preserve all paramters
        if (!empty($parameters)) {
            if($this->loadRemapFromURL($protocol, $url, $parameters)) {
                return TRUE;
            }
        }
    
        return FALSE;
    }

    public function loadRemapFromURL($protocol=NULL, $url=NULL, $parameters='')
    {
        if (is_null($protocol)) $protocol = current_protocol();
        if (is_null($url)) {
            $url = strip_url(current_url(FALSE, TRUE));
        }

        $url = $protocol.'://'.$url;
        $time      = ts_iso8601(time());
        
        // there is URL parameters to pass
        if(!empty($parameters)) {
            // Try URL + ?, if match is found, this URL is marked as an exception that no need of  preserving parameters
            try {
                
                $bind_vars = Array(
                                'url'  => $url,
                                'url_with_trailing_question_mark'  => $url.'?',
                                'time' => $time,
                            );
                $results = MatrixDAL::executeAssoc('remap_manager', 'getCurrentRemapURLTrailingQuestionMark', $bind_vars);
            } catch (DALException $e) {
                throw new Exception('Unable to get current remap URL for "'.$url.'" due to database error: '.$e->getMessage());
            }
            
            if(empty($results)) return FALSE;
            
            $remap_url = $results[0]['remap_url'];
            
            // if this query returns us a plain url (not with trailing '?'), we should pass URL parameters to remapped url
            if($results[0]['url'] === $url) {
            // preserve parameters to remapped url
            if(strpos($remap_url, '?') !== FALSE) {
                 $remap_url = $remap_url.'&'.$parameters;
            }
            else {
                $remap_url = $remap_url.'?'.$parameters;
            }   
            }
        }
        else {
            // no URL parameters to pass
            try {
                
                $bind_vars = Array(
                                'url'  => $url,
                                'time' => $time,
                            );
                $remap_url = MatrixDAL::executeOne('remap_manager', 'getCurrentRemapURL', $bind_vars);
            } catch (DALException $e) {
                throw new Exception('Unable to get current remap URL for "'.$url.'" due to database error: '.$e->getMessage());
            }
        }

        // if we have a remap url, display it
        if (!empty($remap_url)) {
            
            header('HTTP/1.1 301 Moved Permanently');
            $cm = $GLOBALS['SQ_SYSTEM']->am->getSystemAsset('cache_manager');
            // Send Cacheable Header based on cache manager default setting
            if (SQ_CONF_SEND_CACHEABLE_HEADER && $cm->cacheableHeadersEnabledForCurrentProtocol()) {
                header('Pragma: cache');

                $browser_cache_expiry = $cm->attr('browser_cache_expiry');
                if (empty($browser_cache_expiry)) {
                    $browser_cache_expiry = $cm->attr('expiry');
                }

                header('Cache-Control: max-age='.$browser_cache_expiry.', '.$cm->cacheControlLevel());
                header('Expires: '.gmdate('D, d M Y H:i:s', time() + $browser_cache_expiry).' GMT');            
            }
            header('Location: '.$remap_url);

            return TRUE;
        }

        return FALSE;

    }//end loadRemapFromURL()

    public function getRemapFromURL($protocol=NULL, $url=NULL)
    {
        if (is_null($protocol)) $protocol = current_protocol();
        if (is_null($url)) {
            $url = strip_url(current_url(FALSE, TRUE));
        }

        $url = $protocol.'://'.$url;

        try {
            $time      = ts_iso8601(time());
            $bind_vars = Array(
                            'url'  => $url,
                            'time' => $time,
                         );
            $remap_url = MatrixDAL::executeOne('remap_manager', 'getCurrentRemapURL', $bind_vars);
        } catch (DALException $e) {
            throw new Exception('Unable to get current remap URL for "'.$url.'" due to database error: '.$e->getMessage());
        }

        // if remap is found, keeping finding its remap until the final remap 
        if (!empty($remap_url)) {
            $protocol = parse_url($remap_url, PHP_URL_SCHEME);  
            $search = '#'.$protocol.'\\://#';       
            $url = preg_replace($search, '', $remap_url);
            
            // find the final remap url recursively
            $final_url = $this->getRemapFromURL($protocol, $url);
            if ($final_url !== FALSE) $remap_url = $final_url;
            return $remap_url;
        }
        return FALSE;

    }//end getRemapFromURL()

    public function getPageNotFoundAsset()
    {
        // searching for the root asset
        $link_to_404 = $GLOBALS['SQ_SYSTEM']->am->getLink($this->id, SQ_LINK_NOTICE, '', FALSE, '404');

        if (empty($link_to_404)) {
            $asset = NULL;
        } else {
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($link_to_404['minorid']);
        }

        return $asset;

    }//end getPageNotFoundAsset()


    public function paintPageNotFoundRemap()
    {
        $asset = $this->getPageNotFoundAsset();
        if (is_null($asset)) return FALSE;

        // send a 404 header
        header('HTTP/1.0 404 Not Found');

        $url = strip_url($this->getURL(), TRUE);
        $asset_url = strip_url($asset->getURL(NULL, TRUE), TRUE);

        global $ASSET_LINEAGE;
        $ASSET_LINEAGE = $GLOBALS['SQ_SYSTEM']->am->getLineageFromUrl(NULL, $asset_url);

        $design = $this->getDesign($asset, $url);
        if (!is_null($design)) {
            $design->paint($asset);
            return TRUE;
        }
        // get the first design for this asset
        $design = $this->getDesign($asset);
        if (!is_null($design)) {
            $design->paint($asset);
            return TRUE;
        }
        // give up, and just paint the asset
        // without a design
        $asset->printFrontend();

        return TRUE;

    }//end paintPageNotFoundRemap()


    public function getDesign(Asset $asset, $url=NULL)
    {
        $null = NULL;
        if (is_null($asset)) return $null;

        $bind_vars = Array();

        // get original design or inherited design if no override design
        $sql = 'SELECT lv.value as designid, a.type_code
                FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_lookup l
                        INNER JOIN '.SQ_TABLE_RUNNING_PREFIX.'ast_lookup_value lv ON ((l.url = lv.url) OR (l.url || \'/\' = lv.url))
                        INNER JOIN '.SQ_TABLE_RUNNING_PREFIX.'ast a ON lv.value = a.assetid
                ';
        $where = 'l.assetid  = :assetid AND lv.name = :lookup_name';

        $bind_vars['assetid'] = $asset->id;
        $bind_vars['lookup_name'] = 'design::system::frontend';

        if (!is_null($url)) {
            $where .= ' AND lv.url  LIKE :url';
            $bind_vars['url'] = $url.'%';
        }

        $order_by = ' ORDER BY depth DESC';
        $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where, 'lv');
        $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where, 'l');
        $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where, 'a');
        $sql .= $where.$order_by;
        $sql = db_extras_modify_limit_clause($sql, MatrixDAL::getDbType(), 1);

        try {
            $query = MatrixDAL::preparePdoQuery($sql);
            foreach ($bind_vars as $bind_var => $bind_value) {
                MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
            }
            $result = MatrixDAL::executePdoAll($query);
        } catch (DALException $e) {
            throw new Exception('Unable to select design of remapped asset "'.$asset->name.'" (#'.$asset->id.') due to database error: '.$e->getMessage());
        }

        if ($result) {
            return $GLOBALS['SQ_SYSTEM']->am->getAsset($result[0]['designid'], $result[0]['type_code']);
        }
        return $null;

    }//end getDesign()


}//end class

?>