SemanticMediaWiki/specials/AskSpecial/SMW_QueryUIHelper.php

Go to the documentation of this file.

<?php

class SMWQueryUIHelper {

        protected $queryString = '';

        protected $parameters = array();

        protected $printOuts = array(); // Properties to be printed along with results

        protected $printOutStrings = array();

        private $errorsOccured = false;

        private $context;

        private $errors = array();

        private $defaultResultPrinter = 'broadtable';

        private $queryResult = null;

        const SPECIAL_PAGE = 0;// parameters passed from special page
        const WIKI_LINK = 1;// parameters passed from 'further links' in the wiki.

        protected static $uiPages = array();

        public function __construct( $context = SMWQueryUIHelper::SPECIAL_PAGE ) {
                $this->context = $context;
        }

        public function hasError() {
                return $this->errorsOccured;
        }

        public function getLimit() {
                if ( array_key_exists( 'limit', $this->parameters ) ) {
                        return $this->parameters['limit'];
                } else {
                        return 0;
                }
        }

        public function getOffset() {
                if ( array_key_exists( 'offset', $this->parameters ) ) {
                        return $this->parameters['offset'];
                } else {
                        return 20;
                }
        }

        public function hasFurtherResults() {
                if ( !is_null( $this->queryResult ) ) { // The queryResult may not be set
                        return $this->queryResult->hasFurtherResults();
                } else {
                        return false;
                }
        }

        public function getResultObject() {
                return $this->queryResult;
        }

        public function getErrors() {
                return $this->errors;
        }

        public static function addUI( SpecialPage &$page ) {
                /*
                * This way of registering, instead of using a global variable will cause
                * SMWQueryUIHelper to AutoLoad, but the alternate would break encapsulation.
                */
                self::$uiPages[] = $page;
        }

        public static function getUiList() {
                return self::$uiPages;
        }

        public function setQueryString( $queryString = "", $enableValidation = false ) {
                $this -> queryString = $queryString;

                $errors = array();
                if ( $enableValidation ) {
                        if ( $queryString === '' ) {
                                $errors[] = wfMsg( 'smw_qui_noquery' );
                        } else {
                                $query = SMWQueryProcessor::createQuery( $queryString, array() );
                                $errors = $query ->getErrors();
                        }
                        if ( !empty ( $errors ) ) {
                                $this->errorsOccured = true;
                        }
                        $this->errors = array_merge( $errors, $this->errors );
                }

                return $errors;
        }

        public function setPrintOuts( array $printOuts = array(), $enableValidation = false ) {
                /*
                 * Note: property validation is not very clearly defined yet, so validation is disabled by default
                 */

                $errors = array();
                if ( $enableValidation ) {
                        foreach ( $printOuts as $key => $prop ) {
                                if ( $prop[0] != '?' ) {
                                        $printOuts[$key] = "?" . $printOuts[$key];
                                }
                                if ( !$this->validateProperty( $prop ) ) {
                                        $errors[] = wfMsg( 'smw_qui_invalidprop', $prop );
                                        $this->errorsOccured = true;
                                }
                        }
                }
                $this -> printOutStrings = $printOuts;
                $this->errors = array_merge( $errors, $this->errors );
                return $errors;
        }

        public function setParams( array $params = array(), $enableValidation = false ) {
                global $smwgQMaxInlineLimit, $smwgResultFormats;
                $errors = array();

                // checking for missing parameters and adding them
                if ( !array_key_exists( 'format', $params ) || ! array_key_exists ( $params['format'], $smwgResultFormats ) ) {
                        $params[ 'format' ] = $this->defaultResultPrinter;
                }
                if ( !array_key_exists( 'limit', $params ) ) {
                        $params[ 'limit' ] = 20;
                }
                $params[ 'limit' ] = min( $params[ 'limit' ], $smwgQMaxInlineLimit );
                if ( !array_key_exists( 'offset', $params ) ) {
                        $params['offset'] = 0;
                }

                if ( $enableValidation ) { // validating the format
                        if ( !array_key_exists( $params['format'], $smwgResultFormats ) ) {
                                $errors[] = wfMsg( 'smw_qui_invalidformat', $params['format'] );
                                $this->errorsOccured = true;
                        } else { // validating parameters for result printer
                                $printer = SMWQueryProcessor::getResultPrinter( $params[ 'format' ] );
                                $para_meters = $printer->getParameters();
                                if ( is_array( $para_meters ) ) {
                                        $validator = new Validator();
                                        $validator->setParameters( $params, $para_meters );
                                        $validator->validateParameters();
                                        if ( $validator->hasFatalError() ) {
                                                array_merge ( $errors, $validator->getErrorMessages () );
                                                $this->errorsOccured = true;
                                        }
                                }
                        }
                }

                $this->parameters = $params;
                $this->errors = array_merge( $errors, $this->errors );
                return $errors;
        }

        public function extractParameters( $p ) {
                if ( $this->context == self::SPECIAL_PAGE ) {
                        // assume setParams(), setPintouts and setQueryString have been called
                        $rawParams = array_merge( $this->parameters, array( $this->queryString ), $this->printOutStrings );
                } else {// context is WIKI_LINK
                        $rawParams = SMWInfolink::decodeParameters( $p, true );
                        // calling setParams to fill in missing parameters
                        $this->setParams( $rawParams );
                        $rawParams = $this->parameters;
                }

                SMWQueryProcessor::processFunctionParams( $rawParams, $this->queryString, $this->parameters, $this->printOuts );
        }

        public function execute() {
                $errors = array();

                if ( $this->queryString !== '' ) {
                        // FIXME: this is a hack
                        SMWQueryProcessor::addThisPrintout( $this->printOuts, $this->parameters );
                        $params = SMWQueryProcessor::getProcessedParams( $this->parameters, $this->printOuts );
                        $this->parameters['format'] = $params['format'];
                        $this->params = $params;

                        $query = SMWQueryProcessor::createQuery(
                                $this->queryString,
                                $params,
                                SMWQueryProcessor::SPECIAL_PAGE,
                                $this->parameters['format'],
                                $this->printOuts
                        );

                        $res = smwfGetStore()->getQueryResult( $query );
                        $this->queryResult = $res;

                        $errors = array_merge( $errors, $res->getErrors() );
                        if ( !empty( $errors ) ) {
                                $this->errorsOccured = true;
                                $this->errors = array_merge( $errors, $this->errors );
                        }

                        // BEGIN: Try to be smart for rss/ical if no description/title is given and we have a concept query
                        if ( $this->parameters['format'] == 'rss' ) {
                                $descKey = 'rssdescription';
                                $titleKey = 'rsstitle';
                        } elseif ( $this->parameters['format'] == 'icalendar' ) {
                                $descKey = 'icalendardescription';
                                $titleKey = 'icalendartitle';
                        } else {
                                $descKey = false;
                        }

                        if ( $descKey && ( $query->getDescription() instanceof SMWConceptDescription ) &&
                                 ( !isset( $this->parameters[$descKey] ) || !isset( $this->parameters[$titleKey] ) ) ) {
                                $concept = $query->getDescription()->getConcept();

                                if ( !isset( $this->parameters[$titleKey] ) ) {
                                        $this->parameters[$titleKey] = $concept->getText();
                                }

                                if ( !isset( $this->parameters[$descKey] ) ) {
                                        // / @bug The current SMWStore will never return SMWConceptValue (an SMWDataValue) here; it might return SMWDIConcept (an SMWDataItem)
                                        $dv = end( smwfGetStore()->getPropertyValues( SMWWikiPageValue::makePageFromTitle( $concept ), new SMWDIProperty( '_CONC' ) ) );
                                        if ( $dv instanceof SMWConceptValue ) {
                                                $this->parameters[$descKey] = $dv->getDocu();
                                        }
                                }
                        }
                        // END: Try to be smart for rss/ical if no description/title is given and we have a concept query

                        /*
                         * If parameters have been passed in the infolink-style and the
                         * mimie-type of format is defined, generate the export, instead of
                         * showing more html.
                         */
                        $printer = SMWQueryProcessor::getResultPrinter(
                                $this->parameters['format'],
                                SMWQueryProcessor::SPECIAL_PAGE
                        );
                        $resultMime = $printer->getMimeType( $res );
                        if ( $this->context == self::WIKI_LINK && $resultMime != false ) {
                                global $wgOut;
                                $result = $printer->getResult( $res, $this->parameters, SMW_OUTPUT_FILE );
                                $resultName = $printer->getFileName( $res );
                                $wgOut->disable();
                                header( "Content-type: $resultMime; charset=UTF-8" );
                                if ( $resultName !== false ) {
                                        header( "content-disposition: attachment; filename=$resultName" );
                                }
                                echo $result;
                        }
                }
        }

        public function getHTMLResult() {
                $result = '';

                $res = $this->queryResult;
                $printer = SMWQueryProcessor::getResultPrinter( $this->parameters['format'],
                        SMWQueryProcessor::SPECIAL_PAGE );

                if ( $res->getCount() > 0 ) {
                        $queryResult = $printer->getResult( $res, $this->params, SMW_OUTPUT_HTML );

                        if ( is_array( $queryResult ) ) {
                                $result .= $queryResult[0];
                        } else {
                                $result .= $queryResult;
                        }
                } else {
                        $result = wfMsg( 'smw_result_noresults' );
                }

                return $result;
        }

        public function getAsk() {
                $result = '{{#ask:' . htmlspecialchars( $this->queryString ) . "\n";
                foreach ( $this->printOuts as $printout ) {
                        $result .= '|' . $printout->getSerialisation() . "\n";
                }
                foreach ( $this->parameters as $param_name => $param_value ) {
                        $result .= '|' . htmlspecialchars( $param_name ) .
                                '=' . htmlspecialchars( $param_value ) . "\n";
                }
                $result .= '}}';
                return $result;
        }

        public function getQueryString() {
                return $this->queryString;
        }

        public function getResultCount() {
                if ( !is_null( $this->queryResult ) ) {
                        return $this->queryResult->getCount();
                } else {
                        return 0;
                }
        }

        public function getParameters() {
                return $this->parameters;
        }

        public function getPrintOuts() {
                if ( !empty( $this->printOuts ) &&
                ( $this->printOuts[0] instanceof SMWPrintRequest ) ) {
                        return $this->printOuts;
                }
                return array();
        }

        public static function makeForInfoLink( $p, $enableValidation = false ) {
                $result = new SMWQueryUIHelper( self::WIKI_LINK );
                $result->extractParameters( $p );
                $result->execute();
                return $result;
        }

        public static function makeForUI( $query, array $params, array $printouts, $enableValidation = false ) {
                $result = new SMWQueryUIHelper( self::SPECIAL_PAGE );
                $result->setParams( $params, $enableValidation );
                $result->setPrintOuts( $printouts, $enableValidation );
                $result->setQueryString( $query, $enableValidation );
                $result->extractParameters( '' );
                return $result;
        }

        protected static function validateProperty( $property ) {
                /*
                 * Curently there isn't a simple, back-end agnost way of searching for properties from
                 * SMWStore. We hence we check if $property has a corresponding page describing it.
                 */
                $prop = substr( $property, 1 ); // removing the leading '?' while checking.
                $property_page = Title::newFromText( $prop, SMW_NS_PROPERTY );
                if ( $property_page instanceof Title ) {
                        return( $property_page->exists() );
                } else {
                        return false;
                }
        }

}

---