Site.php

Go to the documentation of this file.

<?php
 
use MediaWiki\MediaWikiServices;
use MediaWiki\Site\MediaWikiPageNameNormalizer;
 
class Site implements Serializable {
    public const TYPE_UNKNOWN = 'unknown';
    public const TYPE_MEDIAWIKI = 'mediawiki';
 
    public const GROUP_NONE = 'none';
 
    public const ID_INTERWIKI = 'interwiki';
    public const ID_EQUIVALENT = 'equivalent';
 
    public const SOURCE_LOCAL = 'local';
 
    public const PATH_LINK = 'link';
 
    public const SERIAL_VERSION_ID = '2013-01-23';
 
    protected $globalId = null;
 
    protected $type = self::TYPE_UNKNOWN;
 
    protected $group = self::GROUP_NONE;
 
    protected $source = self::SOURCE_LOCAL;
 
    protected $languageCode = null;
 
    protected $localIds = [];
 
    protected $extraData = [];
 
    protected $extraConfig = [];
 
    protected $forward = false;
 
    protected $internalId = null;
 
    public function __construct( $type = self::TYPE_UNKNOWN ) {
        $this->type = $type;
    }
 
    public function getGlobalId() {
        return $this->globalId;
    }
 
    public function setGlobalId( $globalId ) {
        if ( $globalId !== null && !is_string( $globalId ) ) {
            throw new MWException( '$globalId needs to be string or null' );
        }
 
        $this->globalId = $globalId;
    }
 
    public function getType() {
        return $this->type;
    }
 
    public function getGroup() {
        return $this->group;
    }
 
    public function setGroup( $group ) {
        if ( !is_string( $group ) ) {
            throw new MWException( '$group needs to be a string' );
        }
 
        $this->group = $group;
    }
 
    public function getSource() {
        return $this->source;
    }
 
    public function setSource( $source ) {
        if ( !is_string( $source ) ) {
            throw new MWException( '$source needs to be a string' );
        }
 
        $this->source = $source;
    }
 
    public function shouldForward() {
        return $this->forward;
    }
 
    public function setForward( $shouldForward ) {
        if ( !is_bool( $shouldForward ) ) {
            throw new MWException( '$shouldForward needs to be a boolean' );
        }
 
        $this->forward = $shouldForward;
    }
 
    public function getDomain() {
        $path = $this->getLinkPath();
 
        if ( $path === null ) {
            return null;
        }
 
        return parse_url( $path, PHP_URL_HOST );
    }
 
    public function getProtocol() {
        $path = $this->getLinkPath();
 
        if ( $path === null ) {
            return '';
        }
 
        $protocol = parse_url( $path, PHP_URL_SCHEME );
 
        // Malformed URL
        if ( $protocol === false ) {
            throw new MWException( "failed to parse URL '$path'" );
        }
 
        // No schema
        if ( $protocol === null ) {
            // Used for protocol relative URLs
            $protocol = '';
        }
 
        return $protocol;
    }
 
    public function setLinkPath( $fullUrl ) {
        $type = $this->getLinkPathType();
 
        if ( $type === null ) {
            throw new MWException( "This Site does not support link paths." );
        }
 
        $this->setPath( $type, $fullUrl );
    }
 
    public function getLinkPath() {
        $type = $this->getLinkPathType();
        return $type === null ? null : $this->getPath( $type );
    }
 
    public function getLinkPathType() {
        return self::PATH_LINK;
    }
 
    public function getPageUrl( $pageName = false ) {
        $url = $this->getLinkPath();
 
        if ( $url === null ) {
            return null;
        }
 
        if ( $pageName !== false ) {
            $url = str_replace( '$1', rawurlencode( $pageName ), $url );
        }
 
        return $url;
    }
 
    public function normalizePageName( $pageName, $followRedirect = MediaWikiPageNameNormalizer::FOLLOW_REDIRECT ) {
        return $pageName;
    }
 
    public function getExtraData() {
        return $this->extraData;
    }
 
    public function setExtraData( array $extraData ) {
        $this->extraData = $extraData;
    }
 
    public function getExtraConfig() {
        return $this->extraConfig;
    }
 
    public function setExtraConfig( array $extraConfig ) {
        $this->extraConfig = $extraConfig;
    }
 
    public function getLanguageCode() {
        return $this->languageCode;
    }
 
    public function setLanguageCode( $languageCode ) {
        if ( $languageCode !== null
            && !MediaWikiServices::getInstance()
                ->getLanguageNameUtils()
                ->isValidCode( $languageCode )
        ) {
            throw new InvalidArgumentException( "$languageCode is not a valid language code." );
        }
        $this->languageCode = $languageCode;
    }
 
    public function getInternalId() {
        return $this->internalId;
    }
 
    public function setInternalId( $internalId = null ) {
        $this->internalId = $internalId;
    }
 
    public function addLocalId( $type, $identifier ) {
        if ( $this->localIds === false ) {
            $this->localIds = [];
        }
 
        if ( !array_key_exists( $type, $this->localIds ) ) {
            $this->localIds[$type] = [];
        }
 
        if ( !in_array( $identifier, $this->localIds[$type] ) ) {
            $this->localIds[$type][] = $identifier;
        }
    }
 
    public function addInterwikiId( $identifier ) {
        $this->addLocalId( self::ID_INTERWIKI, $identifier );
    }
 
    public function addNavigationId( $identifier ) {
        $this->addLocalId( self::ID_EQUIVALENT, $identifier );
    }
 
    public function getInterwikiIds() {
        return array_key_exists( self::ID_INTERWIKI, $this->localIds )
            ? $this->localIds[self::ID_INTERWIKI]
            : [];
    }
 
    public function getNavigationIds() {
        return array_key_exists( self::ID_EQUIVALENT, $this->localIds )
            ? $this->localIds[self::ID_EQUIVALENT] :
            [];
    }
 
    public function getLocalIds() {
        return $this->localIds;
    }
 
    public function setPath( $pathType, $fullUrl ) {
        if ( !is_string( $fullUrl ) ) {
            throw new MWException( '$fullUrl needs to be a string' );
        }
 
        if ( !array_key_exists( 'paths', $this->extraData ) ) {
            $this->extraData['paths'] = [];
        }
 
        $this->extraData['paths'][$pathType] = $fullUrl;
    }
 
    public function getPath( $pathType ) {
        $paths = $this->getAllPaths();
        return $paths[$pathType] ?? null;
    }
 
    public function getAllPaths() {
        return $this->extraData['paths'] ?? [];
    }
 
    public function removePath( $pathType ) {
        if ( array_key_exists( 'paths', $this->extraData ) ) {
            unset( $this->extraData['paths'][$pathType] );
        }
    }
 
    public static function newForType( $siteType ) {
        global $wgSiteTypes;
 
        if ( array_key_exists( $siteType, $wgSiteTypes ) ) {
            return new $wgSiteTypes[$siteType]();
        }
 
        return new Site();
    }
 
    public function serialize() {
        $fields = [
            'globalid' => $this->globalId,
            'type' => $this->type,
            'group' => $this->group,
            'source' => $this->source,
            'language' => $this->languageCode,
            'localids' => $this->localIds,
            'config' => $this->extraConfig,
            'data' => $this->extraData,
            'forward' => $this->forward,
            'internalid' => $this->internalId,
 
        ];
 
        return serialize( $fields );
    }
 
    public function unserialize( $serialized ) {
        $fields = unserialize( $serialized );
 
        $this->__construct( $fields['type'] );
 
        $this->setGlobalId( $fields['globalid'] );
        $this->setGroup( $fields['group'] );
        $this->setSource( $fields['source'] );
        $this->setLanguageCode( $fields['language'] );
        $this->localIds = $fields['localids'];
        $this->setExtraConfig( $fields['config'] );
        $this->setExtraData( $fields['data'] );
        $this->setForward( $fields['forward'] );
        $this->setInternalId( $fields['internalid'] );
    }
}