UserGroupMembership.php

Go to the documentation of this file.

<?php
use Wikimedia\Rdbms\IDatabase;
 
class UserGroupMembership {
    private $userId;
 
    private $group;
 
    private $expiry;
 
    public function __construct( $userId = 0, $group = null, $expiry = null ) {
        $this->userId = (int)$userId;
        $this->group = $group; // TODO throw on invalid group?
        $this->expiry = $expiry ?: null;
    }
 
    public function getUserId() {
        return $this->userId;
    }
 
    public function getGroup() {
        return $this->group;
    }
 
    public function getExpiry() {
        return $this->expiry;
    }
 
    protected function initFromRow( $row ) {
        $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 ) {
        $ugm = new self;
        $ugm->initFromRow( $row );
        return $ugm;
    }
 
    public static function selectFields() {
        return [
            'ug_user',
            'ug_group',
            'ug_expiry',
        ];
    }
 
    public function delete( IDatabase $dbw = null ) {
        if ( wfReadOnly() ) {
            return false;
        }
 
        if ( $dbw === null ) {
            $dbw = wfGetDB( DB_MASTER );
        }
 
        $dbw->delete(
            'user_groups',
            [ 'ug_user' => $this->userId, 'ug_group' => $this->group ],
            __METHOD__ );
        if ( !$dbw->affectedRows() ) {
            return false;
        }
 
        // Remember that the user was in this group
        $dbw->insert(
            'user_former_groups',
            [ 'ufg_user' => $this->userId, 'ufg_group' => $this->group ],
            __METHOD__,
            [ 'IGNORE' ] );
 
        return true;
    }
 
    public function insert( $allowUpdate = false, IDatabase $dbw = null ) {
        if ( $dbw === null ) {
            $dbw = wfGetDB( DB_MASTER );
        }
 
        // Purge old, expired memberships from the DB
        self::purgeExpired( $dbw );
 
        // Check that the values make sense
        if ( $this->group === null ) {
            throw new UnexpectedValueException(
                'Don\'t try inserting an uninitialized UserGroupMembership object' );
        } elseif ( $this->userId <= 0 ) {
            throw new UnexpectedValueException(
                'UserGroupMembership::insert() needs a positive user ID. ' .
                'Did you forget to add your User object to the database before calling addGroup()?' );
        }
 
        $row = $this->getDatabaseArray( $dbw );
        $dbw->insert( 'user_groups', $row, __METHOD__, [ 'IGNORE' ] );
        $affected = $dbw->affectedRows();
 
        // Don't collide with expired user group memberships
        // Do this after trying to insert, in order to avoid locking
        if ( !$affected ) {
            $conds = [
                'ug_user' => $row['ug_user'],
                'ug_group' => $row['ug_group'],
            ];
            // if we're unconditionally updating, check that the expiry is not already the
            // same as what we are trying to update it to; otherwise, only update if
            // the expiry date is in the past
            if ( $allowUpdate ) {
                if ( $this->expiry ) {
                    $conds[] = 'ug_expiry IS NULL OR ug_expiry != ' .
                        $dbw->addQuotes( $dbw->timestamp( $this->expiry ) );
                } else {
                    $conds[] = 'ug_expiry IS NOT NULL';
                }
            } else {
                $conds[] = 'ug_expiry < ' . $dbw->addQuotes( $dbw->timestamp() );
            }
 
            $row = $dbw->selectRow( 'user_groups', $this::selectFields(), $conds, __METHOD__ );
            if ( $row ) {
                $dbw->update(
                    'user_groups',
                    [ 'ug_expiry' => $this->expiry ? $dbw->timestamp( $this->expiry ) : null ],
                    [ 'ug_user' => $row->ug_user, 'ug_group' => $row->ug_group ],
                    __METHOD__ );
                $affected = $dbw->affectedRows();
            }
        }
 
        return $affected > 0;
    }
 
    protected function getDatabaseArray( IDatabase $db ) {
        return [
            'ug_user' => $this->userId,
            'ug_group' => $this->group,
            'ug_expiry' => $this->expiry ? $db->timestamp( $this->expiry ) : null,
        ];
    }
 
    public function isExpired() {
        if ( !$this->expiry ) {
            return false;
        } else {
            return wfTimestampNow() > $this->expiry;
        }
    }
 
    public static function purgeExpired( IDatabase $dbw = null ) {
        if ( wfReadOnly() ) {
            return;
        }
 
        if ( $dbw === null ) {
            $dbw = wfGetDB( DB_MASTER );
        }
 
        DeferredUpdates::addUpdate( new AtomicSectionUpdate(
            $dbw,
            __METHOD__,
            function ( IDatabase $dbw, $fname ) {
                $expiryCond = [ 'ug_expiry < ' . $dbw->addQuotes( $dbw->timestamp() ) ];
                $res = $dbw->select( 'user_groups', self::selectFields(), $expiryCond, $fname );
 
                // save an array of users/groups to insert to user_former_groups
                $usersAndGroups = [];
                foreach ( $res as $row ) {
                    $usersAndGroups[] = [ 'ufg_user' => $row->ug_user, 'ufg_group' => $row->ug_group ];
                }
 
                // delete 'em all
                $dbw->delete( 'user_groups', $expiryCond, $fname );
 
                // and push the groups to user_former_groups
                $dbw->insert( 'user_former_groups', $usersAndGroups, __METHOD__, [ 'IGNORE' ] );
            }
        ) );
    }
 
    public static function getMembershipsForUser( $userId, IDatabase $db = null ) {
        if ( !$db ) {
            $db = wfGetDB( DB_REPLICA );
        }
 
        $res = $db->select( 'user_groups',
            self::selectFields(),
            [ 'ug_user' => $userId ],
            __METHOD__ );
 
        $ugms = [];
        foreach ( $res as $row ) {
            $ugm = self::newFromRow( $row );
            if ( !$ugm->isExpired() ) {
                $ugms[$ugm->group] = $ugm;
            }
        }
 
        return $ugms;
    }
 
    public static function getMembership( $userId, $group, IDatabase $db = null ) {
        if ( !$db ) {
            $db = wfGetDB( DB_REPLICA );
        }
 
        $row = $db->selectRow( 'user_groups',
            self::selectFields(),
            [ 'ug_user' => $userId, 'ug_group' => $group ],
            __METHOD__ );
        if ( !$row ) {
            return false;
        }
 
        $ugm = self::newFromRow( $row );
        if ( !$ugm->isExpired() ) {
            return $ugm;
        } else {
            return 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 );
        if ( $linkTitle ) {
            if ( $format === 'wiki' ) {
                $linkPage = $linkTitle->getFullText();
                $groupLink = "[[$linkPage|$groupName]]";
            } else {
                $groupLink = Linker::link( $linkTitle, htmlspecialchars( $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 === 'html' ) {
                $groupLink = Message::rawParam( $groupLink );
            }
            return $context->msg( 'group-membership-link-with-expiry' )
                ->params( $groupLink, $expiryDT, $expiryD, $expiryT )->text();
        } else {
            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;
    }
}