UserRequirementsConditionChecker.php

Go to the documentation of this file.

<?php
namespace MediaWiki\User;
 
use InvalidArgumentException;
use LogicException;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Context\IContextSource;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\MainConfigNames;
use MediaWiki\WikiMap\WikiMap;
 
class UserRequirementsConditionChecker {
 
    public const VALID_OPS = [ '&', '|', '^', '!' ];
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::UserRequirementsPrivateConditions,
    ];
 
    private HookRunner $hookRunner;
 
    public function __construct(
        private readonly ServiceOptions $options,
        HookContainer $hookContainer,
        private readonly UserFactory $userFactory,
        private readonly IContextSource $context,
        private readonly UserRequirementsConditionValidator $userRequirementsConditionValidator,
        private readonly array $evaluators = [],
    ) {
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
    }
 
    protected function checkCondition( array $cond, UserIdentity $user ): ?bool {
        $isPerformingRequest = !defined( 'MW_NO_SESSION' ) && $user->equals( $this->context->getUser() );
 
        $conditionType = $cond[0];
        $args = array_slice( $cond, 1 );
 
        foreach ( $this->evaluators as $evaluator ) {
            $result = $evaluator->checkCondition( $conditionType, $args, $user, $isPerformingRequest );
            if ( $result !== null ) {
                return $result;
            }
        }
 
        $result = null;
        $type = $cond[0];
        $args = array_slice( $cond, 1 );
        $this->hookRunner->onUserRequirementsCondition( $conditionType, $args, $user, $isPerformingRequest, $result );
 
        $isCurrentWiki = ( $user->getWikiId() === false ) || WikiMap::isCurrentWikiId( $user->getWikiId() );
        if ( $isPerformingRequest && $isCurrentWiki ) {
            // The legacy hook is run only if the tested user is the one performing
            // the request (like for autopromote), and the user is from the local wiki.
            // If any of these conditions is not met, we cannot invoke the hook,
            // as it may produce incorrect results.
            $userObject = $this->userFactory->newFromUserIdentity( $user );
            $this->hookRunner->onAutopromoteCondition( $conditionType, $args, $userObject, $result );
        }
 
        if ( $result === null ) {
            throw new InvalidArgumentException(
                "Unrecognized condition $type in UserRequirementsCondition!"
            );
        }
 
        return (bool)$result;
    }
 
    public function recursivelyCheckCondition( $cond, UserIdentity $user, bool $usePrivateConditions = true ): ?bool {
        if ( !$this->userRequirementsConditionValidator->isValid( $cond ) ) {
            return false;
        }
 
        $skippedConditions = [];
        if ( !$usePrivateConditions ) {
            $skippedConditions = $this->options->get( MainConfigNames::UserRequirementsPrivateConditions );
            $skippedConditions = array_fill_keys( $skippedConditions, true );
        }
 
        return $this->recursivelyCheckConditionInternal( $cond, $user, $skippedConditions );
    }
 
    private function recursivelyCheckConditionInternal( $cond, UserIdentity $user, array $skippedConditions ): ?bool {
        if ( is_array( $cond ) && count( $cond ) >= 2 && in_array( $cond[0], self::VALID_OPS ) ) {
            // Recursive condition
 
            // AND (all conditions pass)
            if ( $cond[0] === '&' ) {
                $hasNulls = false;
                foreach ( array_slice( $cond, 1 ) as $subcond ) {
                    $result = $this->recursivelyCheckConditionInternal( $subcond, $user, $skippedConditions );
                    if ( $result === false ) {
                        return false;
                    }
                    $hasNulls = $hasNulls || $result === null;
                }
 
                return $hasNulls ? null : true;
            }
 
            // OR (at least one condition passes)
            if ( $cond[0] === '|' ) {
                $hasNulls = false;
                foreach ( array_slice( $cond, 1 ) as $subcond ) {
                    $result = $this->recursivelyCheckConditionInternal( $subcond, $user, $skippedConditions );
                    if ( $result === true ) {
                        return true;
                    }
                    $hasNulls = $hasNulls || $result === null;
                }
 
                return $hasNulls ? null : false;
            }
 
            // XOR (exactly one condition passes)
            if ( $cond[0] === '^' ) {
                $result1 = $this->recursivelyCheckConditionInternal( $cond[1], $user, $skippedConditions );
                $result2 = $this->recursivelyCheckConditionInternal( $cond[2], $user, $skippedConditions );
                if ( $result1 === null || $result2 === null ) {
                    return null;
                }
                return $result1 xor $result2;
            }
 
            // NOT (no conditions pass)
            if ( $cond[0] === '!' ) {
                $hasNulls = false;
                foreach ( array_slice( $cond, 1 ) as $subcond ) {
                    $result = $this->recursivelyCheckConditionInternal( $subcond, $user, $skippedConditions );
                    if ( $result === true ) {
                        return false;
                    }
                    $hasNulls = $hasNulls || $result === null;
                }
 
                return $hasNulls ? null : true;
            }
        }
        // If we got here, the array presumably does not contain other conditions;
        // it's not recursive. Pass it off to checkCondition.
        if ( !is_array( $cond ) ) {
            $cond = [ $cond ];
        }
 
        // Ensure the condition makes sense at all
        if ( count( $cond ) < 1 ) {
            return false;
        }
 
        if ( isset( $skippedConditions[$cond[0]] ) ) {
            return null;
        }
 
        return $this->checkCondition( $cond, $user );
    }
 
    public function extractPrivateConditions( $cond ): array {
        $allPrivateConditions = $this->options->get( MainConfigNames::UserRequirementsPrivateConditions );
        $allConditionsUsed = $this->extractConditions( $cond );
        $privateConditionsUsed = array_intersect( $allPrivateConditions, $allConditionsUsed );
        return array_values( $privateConditionsUsed );
    }
 
    public function extractConditions( $cond ): array {
        $result = $this->extractConditionsInternal( $cond );
        return array_values( array_unique( $result ) );
    }
 
    private function extractConditionsInternal( $cond ): array {
        if ( $cond === [] ) {
            return [];
        }
 
        $result = [];
        if ( is_array( $cond ) ) {
            $op = $cond[0];
            if ( in_array( $op, self::VALID_OPS ) ) {
                foreach ( array_slice( $cond, 1 ) as $subcond ) {
                    $result = array_merge(
                        $result, $this->extractConditionsInternal( $subcond ) );
                }
            } else {
                $result[] = $op;
            }
        } else {
            $result[] = $cond;
        }
        return $result;
    }
}