Pamo\Game\Game

Complexity

Total Complexity

51

Size/Duplication

Total Lines	410
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	11	1
A	getASort()	0	10	2
A	getAnswerForm()	0	19	4
A	getASortType()	0	10	2
A	getCommentForm()	0	20	4
B	vote()	0	51	9
A	activeUser()	0	9	3
A	getDatabases()	0	22	1
A	validUser()	0	6	2
B	updateRank()	0	26	6
A	getFormSettings()	0	7	1
A	getUserForm()	0	14	5
A	getNav()	0	12	2
A	canUserVote()	0	3	1
A	getQuestionForm()	0	16	4
A	getQSort()	0	10	2
A	getQSortType()	0	10	2

<?php

namespace Pamo\Game;

use Pamo\Question\HTMLForm\CreateQuestionForm;
use Pamo\Question\HTMLForm\DeleteQuestionForm;
use Pamo\Question\HTMLForm\UpdateQuestionForm;
use Pamo\Answer\HTMLForm\CreateAnswerForm;
use Pamo\Answer\HTMLForm\DeleteAnswerForm;
use Pamo\Answer\HTMLForm\UpdateAnswerForm;
use Pamo\Comment\HTMLForm\CreateCommentForm;
use Pamo\Comment\HTMLForm\DeleteCommentForm;
use Pamo\Comment\HTMLForm\UpdateCommentForm;
use Pamo\User\HTMLForm\CreateUserForm;
use Pamo\User\HTMLForm\UpdateUserForm;
use Pamo\User\HTMLForm\DeleteUserForm;

/**
 * Game
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class Game
{
    /**
     * @var object $di.
     */
    private $di;



    /**
     * Game class
     *
     */
    public function init($di)
    {
        $this->di = $di;
        $this->game = [];

The property game does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->session = $this->di->get("session");

The property session does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->request = $this->di->get("request");

The property request does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->gravatar = $this->di->get("gravatar");

The property gravatar does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->sortQBy = $this->session->get("sortQBy", "created");

The property sortQBy does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->sortQType = $this->session->get("sortQType", "DESC");

The property sortQType does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->sortABy = $this->session->get("sortABy", "created");

The property sortABy does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->sortAType = $this->session->get("sortAType", "ASC");

The property sortAType does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }



    /**
     * Get and setup all databases.
     *
     */
    public function getDatabases()
    {
        $this->question = $this->di->get("question");

The property question does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->question->setDb($this->di->get("dbqb"));

        $this->answer = $this->di->get("answer");

The property answer does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->answer->setDb($this->di->get("dbqb"));

        $this->user = $this->di->get("user");

The property user does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->user->setDb($this->di->get("dbqb"));

        $this->commentQuestion = $this->di->get("comment-question");

The property commentQuestion does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->commentQuestion->setDb($this->di->get("dbqb"));

        $this->commentAnswer = $this->di->get("comment-answer");

The property commentAnswer does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->commentAnswer->setDb($this->di->get("dbqb"));

        $this->tag = $this->di->get("tag");

The property tag does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->tag->setDb($this->di->get("dbqb"));

        $this->tagQuestion = $this->di->get("tag-question");

The property tagQuestion does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->tagQuestion->setDb($this->di->get("dbqb"));
    }



    /**
     * Vote
     *
     * @return object
     */
    public function vote($type, $id, $vote)
    {
        $currentUser = $this->session->get("user", null);

        switch ($type) {
            case "question":
                $table = $this->question;
                break;
            case "answer":
                $table = $this->answer;
                break;
            case "comment-question":
                $table = $this->commentQuestion;
                break;
            case "comment-answer":
                $table = $this->commentAnswer;
                break;
        }

        $table->find("id", $id);

The variable $table does not seem to be defined for all execution paths leading up to this point.

        $eligible = $this->canUserVote($table->user);

Are you sure the assignment to $eligible is correct as $this->canUserVote($table->user) targeting Pamo\Game\Game::canUserVote() seems to always return null.

        if (!$eligible) {

$eligible is of type null, thus it always evaluated to false.

            return false;

The expression return false returns the type false which is incompatible with the documented return type object.

        }

        if ($vote === "up") {
            $table->vote += 1;
            $this->updateRank($table->user, $table->vote);
        } else if ($vote === "down") {
            $table->vote -= 1;
        } else {
            $table->vote = $table->vote;
        }

        $table->save();

        if ($type === "question") {
            $questionId = $table->id;
        } else {
            $questionId = $table->questionid;
        }

        $user = $this->user;
        $user->find("username", $currentUser["username"]);
        $user->voted += 1;
        $user->save();
        $this->updateRank($currentUser["username"], 1);

        return $questionId;
    }

    /**
     * Rank
     *
     * @return null
     */
    public function updateRank($username, $rank)
    {
        switch (true) {
            case $rank <= 1:
                $value = 1;
                break;
            case $rank <= 5:
                $value = 5;
                break;
            case $rank <= 10:
                $value = 10;
                break;
            case $rank <= 20:
                $value = 20;
                break;
            case $rank <= 30:
                $value = 30;
                break;
            default:
                $value = 50;
        }

        $user = $this->user;
        $user->find("username", $username);
        $user->rank += $value;
        $user->save();
    }



    /**
     * Return question form
     *
     * @return object
     */
    public function getUserForm($adminType, $username = null)
    {
        switch ($adminType) {
            case "create":
                $userForm = new CreateUserForm($this->di);
                break;
            case "edit":
                $userForm = new UpdateUserForm($this->di, $username);
                break;
            case "delete":
                $userForm = new DeleteUserForm($this->di, $username);
                break;
        }
        return isset($userForm) ? $userForm : null;
    }



    /**
     * Return question form
     *
     * @return object
     */
    public function getQuestionForm($adminType, $questionId = null)
    {
        switch ($adminType) {
            case "create":
                $questionForm = new CreateQuestionForm($this->di);
                break;
            case "edit":
                $questionForm = new UpdateQuestionForm($this->di, $questionId);
                break;
            case "delete":
                $questionForm = new DeleteQuestionForm($this->di, $questionId);
                break;
            default:
                $questionForm = null;
        }
        return $questionForm;
    }



    /**
     * Return answer form
     *
     * @return object
     */
    public function getAnswerForm($adminType, $questionId)
    {
        $request = $this->di->get("request");
        $adminId = $request->getGet("adminId", null);

        switch ($adminType) {
            case "create":
                $answerForm = new CreateAnswerForm($this->di, $questionId, $this->activeUser("username"));

$this->activeUser('username') of type array is incompatible with the type string expected by parameter $user of Pamo\Answer\HTMLForm\CreateAnswerForm::__construct().

                break;
            case "edit":
                $answerForm = new UpdateAnswerForm($this->di, $adminId);
                break;
            case "delete":
                $answerForm = new DeleteAnswerForm($this->di, $adminId);
                break;
            default:
                $answerForm = null;
        }
        return $answerForm;
    }



    /**
     * Return comment form
     *
     * @return object
     */
    public function getCommentForm($adminType, $questionId, $table)
    {
        $request = $this->di->get("request");
        $adminId = $request->getGet("adminId", null);
        $answerId = $request->getGet("answerId", null);

        switch ($adminType) {
            case "create":
                $commentForm = new CreateCommentForm($this->di, $table, $questionId, $answerId);
                break;
            case "edit":
                $commentForm = new UpdateCommentForm($this->di, $table, $adminId);
                break;
            case "delete":
                $commentForm = new DeleteCommentForm($this->di, $table, $adminId);
                break;
            default:
                $commentForm = null;
        }
        return $commentForm;
    }



    /**
     * Return nav
     *
     * @return array
     */
    public function getNav()
    {
        $navData = [];

        if ($this->activeUser()) {
            $navData = [
                "activeUser" => $this->activeUser(),
                "gravatar" => $this->gravatar->get($this->activeUser("email"))
            ];
        }

        return $navData;
    }



    /**
     * Return form settings
     *
     * @return array
     */
    public function getFormSettings()
    {
        $formSettings = [
            "use_fieldset" => false
        ];

        return $formSettings;
    }



    /**
     * Return current user
     *
     * @return array
     */
    public function activeUser($item = null)
    {
        $user = $this->session->get("user", null);

        if ($item && $user) {
            return $user[$item];
        }

        return $user;
    }



    /**
     * Is the logged in user the content owner.
     *
     * @return bool
     */
    public function validUser($username)
    {
        if ($this->activeUser("username") != $username) {
            return false;
        }
        return true;
    }



    /**
     * Is the logged in user the content owner.
     *
     * @return null
     */
    public function canUserVote($username)
    {
        return $this->activeUser("username") != $username;

The expression return $this->activeUser('username') != $username returns the type boolean which is incompatible with the documented return type null.

    }



    /**
     * Return question sort
     *
     * @return string
     */
    public function getQSort()
    {
        $sort = $this->request->getGet("sortQBy", null);

        if ($sort) {
            $this->session->set("sortQBy", $sort);
            $this->sortQBy = $sort;

The property sortQBy does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $this->sortQBy;
    }



    /**
     * Return question sort type
     *
     * @return string
     */
    public function getQSortType()
    {
        $sortType = $this->request->getGet("sortQType", null);

        if ($sortType) {
            $this->session->set("sortQType", $sortType);
            $this->sortQType = $sortType;

The property sortQType does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $this->sortQType;
    }



    /**
     * Return answer sort
     *
     * @return string
     */
    public function getASort()
    {
        $sort = $this->request->getGet("sortABy", null);

        if ($sort) {
            $this->session->set("sortABy", $sort);
            $this->sortABy = $sort;

The property sortABy does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $this->sortABy;
    }



    /**
     * Return answer sort type
     *
     * @return string
     */
    public function getASortType()
    {
        $sortType = $this->request->getGet("sortAType", null);

        if ($sortType) {
            $this->session->set("sortAType", $sortType);
            $this->sortAType = $sortType;

The property sortAType does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $this->sortAType;
    }
}