eXpansion\Framework\Core\Plugins\GuiHandler

Complexity

Total Complexity

46

Size/Duplication

Total Lines	322
Duplicated Lines	6.83 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	onEverySecond()	0	3	1
A	onExpansionGroupAddUser()	11	11	3
A	__construct()	0	16	1
A	addToDisplay()	0	12	2
A	addToHide()	0	16	3
A	getManialink()	0	12	4
B	displayManialinks()	0	32	5
A	executeMultiCall()	0	9	2
D	getManialinksToDisplay()	0	43	12
A	setCharLimit()	0	4	1
A	getDisplayeds()	0	4	1
A	onPostLoop()	0	4	1
A	onPreLoop()	0	3	1
A	onExpansionGroupRemoveUser()	11	11	3
A	onExpansionGroupDestroy()	0	6	2
A	onPlayerConnect()	0	3	1
A	onPlayerDisconnect()	0	4	1
A	onPlayerInfoChanged()	0	3	1
A	onPlayerAlliesChanged()	0	3	1

<?php

namespace eXpansion\Framework\Core\Plugins;

use eXpansion\Framework\Core\DataProviders\Listener\ListenerInterfaceExpTimer;
use eXpansion\Framework\Core\DataProviders\Listener\ListenerInterfaceExpUserGroup;
use eXpansion\Framework\Core\DataProviders\Listener\ListenerInterfaceMpLegacyPlayer;
use eXpansion\Framework\Core\Model\Gui\ManialinkFactoryInterface;
use eXpansion\Framework\Core\Model\Gui\ManialinkInterface;
use eXpansion\Framework\Core\Model\UserGroups\Group;
use eXpansion\Framework\Core\Plugins\Gui\ActionFactory;
use eXpansion\Framework\Core\Plugins\Gui\ManialinkFactory;
use eXpansion\Framework\Core\Services\Console;
use eXpansion\Framework\Core\Storage\Data\Player;
use Maniaplanet\DedicatedServer\Connection;
use oliverde8\AssociativeArraySimplified\AssociativeArray;
use Psr\Log\LoggerInterface;

/**
 * Class GuiHandler will send manialinks to player as needed.
 *
 * @package eXpansion\Framework\Core\Plugins\Gui
 * @author Oliver de Cramer
 */
class GuiHandler implements
    ListenerInterfaceExpTimer,
    ListenerInterfaceExpUserGroup,
    ListenerInterfaceMpLegacyPlayer,
    GuiHandlerInterface
{
    /** @var Connection */
    protected $connection;

    /** @var LoggerInterface */
    protected $logger;

    /** @var Console */
    protected $console;

    /** @var ActionFactory */
    protected $actionFactory;

    /** @var int */
    protected $charLimit;

    /** @var ManialinkInterface[][] */
    protected $displayQueu = [];

    /** @var ManialinkInterface[][] */
    protected $individualQueu = [];

    /** @var ManialinkInterface[][] */
    protected $displayeds = [];

    /** @var ManialinkInterface[][] */
    protected $hideQueu = [];

    /** @var String[][] */
    protected $hideIndividualQueu = [];

    /** @var String[] */
    protected $disconnectedLogins = [];

    /**
     * GuiHandler constructor.
     *
     * @param Connection $connection
     */
    public function __construct(
        Connection $connection,
        LoggerInterface $logger,
        Console $console,
        ActionFactory $actionFactory,
        $charLimit = 262144
    ) {
        $this->connection = $connection;

        $this->connection->sendHideManialinkPage(null);

        $this->logger = $logger;
        $this->console = $console;
        $this->actionFactory = $actionFactory;
        $this->charLimit = $charLimit;
    }


    /**
     * Add a manialink to the display queue.
     *
     * @param ManialinkInterface $manialink
     * @param ManialinkFactory   $manialinkFactory
     *
     * @return void
     */
    public function addToDisplay(ManialinkInterface $manialink, ManialinkFactoryInterface $manialinkFactory)
    {

        $userGroup = $manialink->getUserGroup()->getName();
        $id = $manialinkFactory->getId();

        if (AssociativeArray::getFromKey($this->hideQueu, [$userGroup, $id])) {
            unset($this->hideQueu[$userGroup][$id]);
        }

        $this->displayQueu[$userGroup][$id] = $manialink;
    }

    /**
     * Add a manialink to the destruction queue.
     *
     * @param ManialinkInterface $manialink
     * @param ManialinkFactory   $manialinkFactory
     */
    public function addToHide(ManialinkInterface $manialink, ManialinkFactoryInterface $manialinkFactory)
    {
        $userGroup = $manialink->getUserGroup()->getName();
        $id = $manialinkFactory->getId();

        if (AssociativeArray::getFromKey($this->displayQueu, [$userGroup, $id])) {
            unset($this->displayQueu[$userGroup][$id]);
        }

        if (AssociativeArray::getFromKey($this->displayeds, [$userGroup, $id])) {
            unset($this->displayeds[$userGroup][$id]);
        }

        $this->actionFactory->destroyManialinkActions($manialink);
        $this->hideQueu[$userGroup][$id] = $manialink;
    }

    /**
     * Get manialink for a group and manialink factory.
     *
     * @param Group            $group
     * @param ManialinkFactory $manialinkFactory
     *
     * @return null
     */
    public function getManialink(Group $group, ManialinkFactoryInterface $manialinkFactory)
    {
        $varsToCheck = ['displayeds', 'hideQueu', 'displayQueu'];

        foreach ($varsToCheck as $var) {
            if (isset($this->$var[$group->getName()]) && isset($this->$var[$group->getName()][$manialinkFactory->getId()])) {
                return $this->$var[$group->getName()][$manialinkFactory->getId()];
            }
        }

        return null;
    }

    /**
     * Display & hide all manialinks.
     */
    protected function displayManialinks()
    {
        $size = 0;
        foreach ($this->getManialinksToDisplay() as $mlData) {
            $currentSize = $size;
            $size += strlen($mlData['ml']);

            if ($currentSize != 0 && $size > $this->charLimit) {
                $this->executeMultiCall();
                $size = strlen($mlData['ml']);
            }

            $this->connection->sendDisplayManialinkPage(
                $mlData['logins'],
                $mlData['ml'],
                0,
                false,
                true
            );
        }

        if ($size > 0) {
            $this->executeMultiCall();
        }

        // Reset the queues.
        $this->displayQueu = [];
        $this->individualQueu = [];
        $this->hideQueu = [];
        $this->hideIndividualQueu = [];
        $this->disconnectedLogins = [];
    }

    /**
     * Execute multi call & handle error.
     */
    protected function executeMultiCall()
    {
        try {
            $this->connection->executeMulticall();
        } catch (\Exception $e) {
            $this->logger->error("Couldn't deliver all manialinks : ".$e->getMessage(), ['exception' => $e]);
            $this->console->writeln('$F00ERROR - Couldn\'t deliver all manialinks : '.$e->getMessage());
        }
    }

    /**
     * Get list of all manialinks that needs to be displayed
     *
     * @return \Generator
     */
    protected function getManialinksToDisplay()
    {
        foreach ($this->displayQueu as $groupName => $manialinks) {
            foreach ($manialinks as $factoryId => $manialink) {
                $logins = $manialink->getUserGroup()->getLogins();

                $this->displayeds[$groupName][$factoryId] = $manialink;
                if (!empty($logins)) {
                    yield ['logins' => $logins, 'ml' => $manialink->getXml()];
                }
            }
        }

        foreach ($this->individualQueu as $login => $manialinks) {
            foreach ($manialinks as $manialink) {
                $xml = $manialink->getXml();
                yield ['logins' => $login, 'ml' => $xml];
            }
        }

        foreach ($this->hideQueu as $manialinks) {
            foreach ($manialinks as $manialink) {
                $id = $manialink->getId();

                $logins = $manialink->getUserGroup()->getLogins();
                $logins = array_diff($logins, $this->disconnectedLogins);

                if (!empty($logins)) {
                    yield ['logins' => $logins, 'ml' => '<manialink id="'.$id.'" />'];
                }
            }
        }

        foreach ($this->hideIndividualQueu as $login => $manialinks) {
            foreach ($manialinks as $manialink) {
                $id = $manialink->getId();

The method getId cannot be called on $manialink (of type string).

                if (!in_array($login, $this->disconnectedLogins)) {
                    yield ['logins' => $login, 'ml' => '<manialink id="'.$id.'" />'];
                }
            }
        }
    }

    /**
     * @param int $charLimit
     */
    public function setCharLimit($charLimit)
    {
        $this->charLimit = $charLimit;
    }

    /**
     * List of all manialinks that are currently displayed.
     *
     * @return ManialinkInterface[][]
     */
    public function getDisplayeds()
    {
        return $this->displayeds;
    }

    /**
     * @inheritdoc
     */
    public function onPostLoop()
    {
        $this->displayManialinks();
    }

    /**
     * @inheritdoc
     */
    public function onPreLoop()
    {
    }

    /**
     * @inheritdoc
     */
    public function onEverySecond()
    {
    }

    /**
     * @inheritdoc
     */
    public function onExpansionGroupAddUser(Group $group, $loginAdded)

This method seems to be duplicated in your project.

    {
        $group = $group->getName();

        // User was added to group, need to display all manialinks of the group to this user
        if (isset($this->displayeds[$group])) {
            foreach ($this->displayeds[$group] as $mlId => $manialink) {
                $this->individualQueu[$loginAdded][$mlId] = $manialink;
            }
        }
    }

    /**
     * @inheritdoc
     */
    public function onExpansionGroupRemoveUser(Group $group, $loginRemoved)

This method seems to be duplicated in your project.

    {
        $group = $group->getName();

        // User was removed from group, need to hide all manialinks of the group to this user
        if (isset($this->displayeds[$group])) {
            foreach ($this->displayeds[$group] as $mlId => $manialink) {
                $this->hideIndividualQueu[$loginRemoved][$mlId] = $manialink;
            }
        }
    }

    /**
     * @inheritdoc
     */
    public function onExpansionGroupDestroy(Group $group, $lastLogin)
    {
        if (isset($this->displayeds[$group->getName()])) {
            unset($this->displayeds[$group->getName()]);
        }
    }

    public function onPlayerConnect(Player $player)
    {
    }

    public function onPlayerDisconnect(Player $player, $disconnectionReason)
    {
        $this->disconnectedLogins[] = $player->getLogin();
    }

    public function onPlayerInfoChanged(Player $oldPlayer, Player $player)
    {
    }

    public function onPlayerAlliesChanged(Player $oldPlayer, Player $player)
    {
    }
}