GlobalContribsRepository::getRevisions() - Code Metrics - Inspection of "Add IP range support to XTools (excluding Pages Cr..." - x-tools/xtools - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — ip-ranges ( 157734...88dad8 )

by MusikAnimal
created 2021-05-20 18:43 UTC
GlobalContribsRepository::getRevisions() C

↳ Parent: GlobalContribsRepository
Complexity

Conditions	12
Paths	67
Size

Total Lines	107
Code Lines	55
Duplication

Lines	0
Ratio	0 %
Importance

Changes	4
Bugs	1	Features	0
Metric	Value
cc	12
eloc	55
nc	67
nop	7
dl	0
loc	107
rs	6.9666
c	4
b	1
f	0
How to fix Long Method Complexity

<?php
declare(strict_types = 1);

namespace AppBundle\Repository;

use AppBundle\Model\Project;
use AppBundle\Model\User;
use PDO;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Wikimedia\IPUtils;

/**
 * A GlobalContribsRepository is responsible for retrieving information from the database for the GlobalContribs tool.
 * @codeCoverageIgnore
 */
class GlobalContribsRepository extends Repository
{
    /** @var Project CentralAuth project (meta.wikimedia for WMF installation). */
    protected $caProject;

    /**
     * Create Project and ProjectRepository once we have the container.
     * @param ContainerInterface $container
     */
    public function setContainer(ContainerInterface $container): void
    {
        parent::setContainer($container);

        $this->caProject = ProjectRepository::getProject(
            $this->container->getParameter('central_auth_project'),
            $this->container
        );
        $this->caProject->getRepository()
            ->setContainer($this->container);
    }

    /**
     * Get a user's edit count for each project.
     * @see GlobalContribsRepository::globalEditCountsFromCentralAuth()
     * @see GlobalContribsRepository::globalEditCountsFromDatabases()
     * @param User $user The user.
     * @return mixed[] Elements are arrays with 'project' (Project), and 'total' (int). Null if anon (too slow).
     */
    public function globalEditCounts(User $user): ?array
    {
        if ($user->isAnon()) {
            return null;
        }

        // Get the edit counts from CentralAuth or database.
        $editCounts = $this->globalEditCountsFromCentralAuth($user);

        // Pre-populate all projects' metadata, to prevent each project call from fetching it.
        $this->caProject->getRepository()->getAll();
        $this->caProject->getRepository()->/** @scrutinizer ignore-call */ getAll();

        // Compile the output.
        $out = [];
        foreach ($editCounts as $editCount) {
            $out[] = [
                'dbName' => $editCount['dbName'],
                'total' => $editCount['total'],
                'project' => ProjectRepository::getProject($editCount['dbName'], $this->container),
            ];
        }
        return $out;
    }

    /**
     * Get a user's total edit count on one or more project.
     * Requires the CentralAuth extension to be installed on the project.
     * @param User $user The user.
     * @return mixed[]|false Elements are arrays with 'dbName' (string), and 'total' (int). False for logged out users.
     */
    protected function globalEditCountsFromCentralAuth(User $user)
    {
        if (true === $user->isAnon()) {
            return false;
        }

        // Set up cache.
        $cacheKey = $this->getCacheKey(func_get_args(), 'gc_globaleditcounts');
        if ($this->cache->hasItem($cacheKey)) {
            return $this->cache->getItem($cacheKey)->get();
        }

        $params = [
            'meta' => 'globaluserinfo',
            'guiprop' => 'editcount|merged',
            'guiuser' => $user->getUsername(),
        ];
        $result = $this->executeApiRequest($this->caProject, $params);
        if (!isset($result['query']['globaluserinfo']['merged'])) {
            return [];
        }
        $out = [];
        foreach ($result['query']['globaluserinfo']['merged'] as $result) {
            $out[] = [
                'dbName' => $result['wiki'],
                'total' => $result['editcount'],
            ];
        }

        // Cache and return.
        return $this->setCache($cacheKey, $out);
    }

    /**
     * Loop through the given dbNames and create Project objects for each.
     * @param array $dbNames
     * @return Project[] Keyed by database name.
     */
    private function formatProjects(array $dbNames): array
    {
        $projects = [];

        foreach ($dbNames as $dbName) {
            $projects[$dbName] = ProjectRepository::getProject($dbName, $this->container);
        }

        return $projects;
    }

    /**
     * Get all Projects on which the user has made at least one edit.
     * @param User $user
     * @return Project[]
     */
    public function getProjectsWithEdits(User $user): array
    {
        if ($user->isAnon()) {
            $dbNames = array_keys($this->getDbNamesAndActorIds($user));
        } else {
            $dbNames = [];

            foreach ($this->globalEditCountsFromCentralAuth($user) as $projectMeta) {
                if ($projectMeta['total'] > 0) {
                    $dbNames[] = $projectMeta['dbName'];
                }
            }
        }

        return $this->formatProjects($dbNames);
    }

    /**
     * Get projects that the user has made at least one edit on, and the associated actor ID.
     * @param User $user
     * @param string[] $dbNames Loop over these projects instead of all of them.
     * @return mixed[] Keys are database names, values are actor IDs.
     */
    public function getDbNamesAndActorIds(User $user, ?array $dbNames = null): array
    {
        // Check cache.
        $cacheKey = $this->getCacheKey(func_get_args(), 'gc_db_names_actor_ids');
        if ($this->cache->hasItem($cacheKey)) {
            return $this->cache->getItem($cacheKey)->get();
        }

        if (!$dbNames) {
            $dbNames = array_column($this->caProject->getRepository()->getAll(), 'dbName');
        }

        if ($user->isIpRange()) {
            $username = $user->getIpSubstringFromCidr().'%';
            $whereClause = "actor_name LIKE :actor";
        } else {
            $username = $user->getUsername();
            $whereClause = "actor_name = :actor";
        }

        $queriesBySlice = [];

        foreach ($dbNames as $dbName) {
            $slice = $this->getDbList()[$dbName];
            // actor_revision table only includes users who have made at least one edit.
            $actorTable = $this->getTableName($dbName, 'actor', 'revision');
            $queriesBySlice[$slice][] = "SELECT '$dbName' AS `dbName`, actor_id " .
                "FROM $actorTable WHERE $whereClause";
        }

        $actorIds = [];

        foreach ($queriesBySlice as $slice => $queries) {
            $sql = implode(' UNION ', $queries);
            $resultQuery = $this->executeProjectsQuery($slice, $sql, [
                'actor' => $username,
            ]);

            while ($row = $resultQuery->fetch()) {
                $actorIds[$row['dbName']] = (int)$row['actor_id'];
            }
        }

        return $this->setCache($cacheKey, $actorIds);
    }

    /**
     * Get revisions by this user across the given Projects.
     * @param string[] $dbNames Database names of projects to iterate over.
     * @param User $user The user.
     * @param int|string $namespace Namespace ID or 'all' for all namespaces.
     * @param int|false $start Unix timestamp or false.
     * @param int|false $end Unix timestamp or false.
     * @param int $limit The maximum number of revisions to fetch from each project.
     * @param int|false $offset Unix timestamp. Used for pagination.
     * @return array
     */
    public function getRevisions(
        array $dbNames,
        User $user,
        $namespace = 'all',
        $start = false,
        $end = false,
        int $limit = 31, // One extra to know whether there should be another page.
        $offset = false
    ): array {
        // Check cache.
        $cacheKey = $this->getCacheKey(func_get_args(), 'gc_revisions');
        if ($this->cache->hasItem($cacheKey)) {
            return $this->cache->getItem($cacheKey)->get();
        }

        // Just need any Connection to use the ->quote() method.
        $quoteConn = $this->getProjectsConnection('s1');
        $username = $quoteConn->quote($user->getUsername(), PDO::PARAM_STR);

        // IP range handling.
        $startIp = '';
        $endIp = '';
        if ($user->isIpRange()) {
            [$startIp, $endIp] = IPUtils::parseRange($user->getUsername());
            $startIp = $quoteConn->quote($startIp, PDO::PARAM_STR);
            $endIp = $quoteConn->quote($endIp, PDO::PARAM_STR);
        }

        // Fetch actor IDs (for IP ranges, it strips trailing zeros and uses a LIKE query).
        $actorIds = $this->getDbNamesAndActorIds($user, $dbNames);

        if (!$actorIds) {
            return [];
        }

        $namespaceCond = 'all' === $namespace
            ? ''
            : 'AND page_namespace = '.(int)$namespace;
        $revDateConditions = $this->getDateConditions($start, $end, $offset, 'revs.', 'rev_timestamp');

        // Assemble queries.
        $queriesBySlice = [];
        $projectRepo = $this->caProject->getRepository();
        foreach ($dbNames as $dbName) {
            if (isset($actorIds[$dbName])) {
                $revisionTable = $projectRepo->getTableName($dbName, 'revision');
                $pageTable = $projectRepo->getTableName($dbName, 'page');
                $commentTable = $projectRepo->getTableName($dbName, 'comment', 'revision');

                if ($user->isIpRange()) {
                    $ipcTable = $projectRepo->getTableName($dbName, 'ip_changes');
                    $ipcJoin = "JOIN $ipcTable ON revs.rev_id = ipc_rev_id";
                    $whereClause = "ipc_hex BETWEEN $startIp AND $endIp";
                } else {
                    $ipcJoin = '';
                    $whereClause = 'revs.rev_actor = '.$actorIds[$dbName];
                }

                $slice = $this->getDbList()[$dbName];
                $queriesBySlice[$slice][] = "
                    SELECT
                        '$dbName' AS dbName,
                        revs.rev_id AS id,
                        revs.rev_timestamp AS timestamp,
                        UNIX_TIMESTAMP(revs.rev_timestamp) AS unix_timestamp,
                        revs.rev_minor_edit AS minor,
                        revs.rev_deleted AS deleted,
                        revs.rev_len AS length,
                        (CAST(revs.rev_len AS SIGNED) - IFNULL(parentrevs.rev_len, 0)) AS length_change,
                        revs.rev_parent_id AS parent_id,
                        $username AS username,
                        page.page_title,
                        page.page_namespace,
                        comment_text AS `comment`
                    FROM $revisionTable AS revs
                        $ipcJoin
                        JOIN $pageTable AS page ON (rev_page = page_id)
                        LEFT JOIN $revisionTable AS parentrevs ON (revs.rev_parent_id = parentrevs.rev_id)
                        LEFT OUTER JOIN $commentTable ON revs.rev_comment_id = comment_id
                    WHERE $whereClause
                        $namespaceCond
                        $revDateConditions";
            }
        }

        // Re-assemble into UNIONed queries, executing as many per slice as possible.
        $revisions = [];
        foreach ($queriesBySlice as $slice => $queries) {
            $sql = "SELECT * FROM ((\n" . join("\n) UNION (\n", $queries) . ")) a ORDER BY timestamp DESC LIMIT $limit";
            $revisions = array_merge($revisions, $this->executeProjectsQuery($slice, $sql)->fetchAll());
        }

        // If there are more than $limit results, re-sort by timestamp.
        if (count($revisions) > $limit) {
            usort($revisions, function ($a, $b) {
                if ($a['unix_timestamp'] === $b['unix_timestamp']) {
                    return 0;
                }
                return $a['unix_timestamp'] > $b['unix_timestamp'] ? -1 : 1;
            });

            // Truncate size to $limit.
            $revisions = array_slice($revisions, 0, $limit);
        }

        // Cache and return.
        return $this->setCache($cacheKey, $revisions);
    }
}

x-tools / xtools

Push — ip-ranges ( 157734...88dad8 )

GlobalContribsRepository::getRevisions() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
