UserGroupMembership.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
use Wikimedia\Assert\Assert;
use Wikimedia\Assert\ParameterTypeException;
use Wikimedia\Rdbms\IDatabase;
 
class UserGroupMembership {
 
    private $userId;
 
    private $group;
 
    private $expiry;
 
    private $expired;
 
    public function __construct( $userId = 0, $group = null, $expiry = null ) {
        self::assertValidSpec( $userId, $group, $expiry );
        $this->userId = (int)$userId;
        $this->group = $group;
        $this->expiry = $expiry ?: null;
        $this->expired = $expiry ? wfTimestampNow() > $expiry : false;
    }
 
    private static function assertValidSpec( $userId, $group, $expiry ) {
        Assert::parameterType( 'integer', $userId, '$userId' );
        Assert::parameterType( [ 'string', 'null' ], $group, '$group' );
        Assert::parameterType( [ 'string', 'null' ], $expiry, '$expiry' );
    }
 
    public function getUserId() {
        return $this->userId;
    }
 
    public function getGroup() {
        return $this->group;
    }
 
    public function getExpiry() {
        return $this->expiry;
    }
 
    protected function initFromRow( $row ) {
        wfDeprecated( __METHOD__, '1.35' );
        $this->userId = (int)$row->ug_user;
        $this->group = $row->ug_group;
        $this->expiry = $row->ug_expiry === null ?
            null :
            wfTimestamp( TS_MW, $row->ug_expiry );
    }
 
    public static function newFromRow( $row ) {
        wfDeprecated( __METHOD__, '1.35' );
        return new self(
            (int)$row->ug_user,
            $row->ug_group,
            $row->ug_expiry === null ? null : wfTimestamp( TS_MW, $row->ug_expiry )
        );
    }
 
    public static function selectFields() {
        wfDeprecated( __METHOD__, '1.35' );
        return MediaWikiServices::getInstance()->getUserGroupManager()->getQueryInfo()['fields'];
    }
 
    public function delete( IDatabase $dbw = null ) {
        wfDeprecated( __METHOD__, '1.35' );
        return MediaWikiServices::getInstance()
            ->getUserGroupManager()
            ->removeUserFromGroup(
                // TODO: we're forced to forge a User instance here because we don't have
                // a username around to create an artificial UserIdentityValue
                // and the username is being used down the tree. This will be gone once the
                // deprecated method is removed
                User::newFromId( $this->getUserId() ),
                $this->group
            );
    }
 
    public function insert( $allowUpdate = false, IDatabase $dbw = null ) {
        wfDeprecated( __METHOD__, '1.35' );
        return MediaWikiServices::getInstance()
            ->getUserGroupManager()
            ->addUserToGroup(
                // TODO: we're forced to forge a User instance here because we don't have
                // a username around to create an artificial UserIdentityValue
                // and the username is being used down the tree. This will be gone once the
                // deprecated method is removed
                User::newFromId( $this->getUserId() ),
                $this->group,
                $this->expiry,
                $allowUpdate
            );
    }
 
    public function isExpired() {
        return $this->expired;
    }
 
    public static function purgeExpired() {
        wfDeprecated( __METHOD__, '1.35' );
        return MediaWikiServices::getInstance()
            ->getUserGroupManager()
            ->purgeExpired();
    }
 
    public static function getMembershipsForUser( $userId, IDatabase $db = null ) {
        wfDeprecated( __METHOD__, '1.35' );
        return MediaWikiServices::getInstance()
            ->getUserGroupManager()
            ->getUserGroupMemberships(
                // TODO: we're forced to forge a User instance here because we don't have
                // a username around to create an artificial UserIdentityValue
                // and the username is being used down the tree. This will be gone once the
                // deprecated method is removed
                User::newFromId( $userId )
            );
    }
 
    public static function getMembership( $userId, $group, IDatabase $db = null ) {
        wfDeprecated( __METHOD__, '1.35' );
        $ugms = MediaWikiServices::getInstance()
            ->getUserGroupManager()
            ->getUserGroupMemberships(
                // TODO: we're forced to forge a User instance here because we don't have
                // a username around to create an artificial UserIdentityValue
                // and the username is being used down the tree. This will be gone once the
                // deprecated method is removed
                User::newFromId( $userId )
            );
        return $ugms[$group] ?? false;
    }
 
    public static function getLink( $ugm, IContextSource $context, $format, $userName = null ) {
        if ( $format !== 'wiki' && $format !== 'html' ) {
            throw new MWException( 'UserGroupMembership::getLink() $format parameter should be ' .
                "'wiki' or 'html'" );
        }
 
        if ( $ugm instanceof UserGroupMembership ) {
            $expiry = $ugm->getExpiry();
            $group = $ugm->getGroup();
        } else {
            $expiry = null;
            $group = $ugm;
        }
 
        if ( $userName !== null ) {
            $groupName = self::getGroupMemberName( $group, $userName );
        } else {
            $groupName = self::getGroupName( $group );
        }
 
        // link to the group description page, if it exists
        $linkTitle = self::getGroupPage( $group );
        $linkRenderer = MediaWikiServices::getInstance()->getLinkRenderer();
        if ( $format === 'wiki' ) {
            if ( $linkTitle ) {
                $linkPage = $linkTitle->getFullText();
                $groupLink = "[[$linkPage|$groupName]]";
            } else {
                $groupLink = $groupName;
            }
        } else {
            if ( $linkTitle ) {
                $groupLink = $linkRenderer->makeLink( $linkTitle, $groupName );
            } else {
                $groupLink = htmlspecialchars( $groupName );
            }
        }
 
        if ( $expiry ) {
            // format the expiry to a nice string
            $uiLanguage = $context->getLanguage();
            $uiUser = $context->getUser();
            $expiryDT = $uiLanguage->userTimeAndDate( $expiry, $uiUser );
            $expiryD = $uiLanguage->userDate( $expiry, $uiUser );
            $expiryT = $uiLanguage->userTime( $expiry, $uiUser );
 
            if ( $format === 'wiki' ) {
                return $context->msg( 'group-membership-link-with-expiry' )
                    ->params( $groupLink, $expiryDT, $expiryD, $expiryT )->text();
            } else {
                $groupLink = Message::rawParam( $groupLink );
                return $context->msg( 'group-membership-link-with-expiry' )
                    ->params( $groupLink, $expiryDT, $expiryD, $expiryT )->escaped();
            }
        }
        return $groupLink;
    }
 
    public static function getGroupName( $group ) {
        $msg = wfMessage( "group-$group" );
        return $msg->isBlank() ? $group : $msg->text();
    }
 
    public static function getGroupMemberName( $group, $username ) {
        $msg = wfMessage( "group-$group-member", $username );
        return $msg->isBlank() ? $group : $msg->text();
    }
 
    public static function getGroupPage( $group ) {
        $msg = wfMessage( "grouppage-$group" )->inContentLanguage();
        if ( $msg->exists() ) {
            $title = Title::newFromText( $msg->text() );
            if ( is_object( $title ) ) {
                return $title;
            }
        }
        return false;
    }
 
    public function equals( UserGroupMembership $ugm ) {
        return (
            $ugm->getUserId() === $this->userId
            && $ugm->getGroup() === $this->group
        );
    }
 
}