Player::getMatchAverageCaps() - Code Metrics - Inspection of "[WIP] Introduce FM Support" - allejo/bzion - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#51)

by Konstantinos
created 2016-08-28 16:30 UTC
Player::getMatchAverageCaps() B

↳ Parent: Player
Complexity

Conditions	2
Paths	2
Size

Total Lines	24
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	3.6875
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
c	1
b	0
f	1
dl	0
loc	24
rs	8.9713
ccs	1
cts	4
cp	0.25
cc	2
eloc	8
nc	2
nop	0
crap	3.6875
<?php
/**
 * This file contains functionality relating to a league player
 *
 * @package    BZiON\Models
 * @license    https://github.com/allejo/bzion/blob/master/LICENSE.md GNU General Public License Version 3
 */

use Symfony\Component\Security\Core\Util\SecureRandom;
use Symfony\Component\Security\Core\Util\StringUtils;

/**
 * A league player
 * @package    BZiON\Models
 */
class Player extends AvatarModel implements NamedModel
{
    /**
     * These are built-in roles that cannot be deleted via the web interface so we will be storing these values as
     * constant variables. Hopefully, a user won't be silly enough to delete them manually from the database.
     *
     * @TODO Deprecate these and use the Role constants
     */
    const DEVELOPER    = Role::DEVELOPER;
    const ADMIN        = Role::ADMINISTRATOR;
    const COP          = Role::COP;
    const REFEREE      = Role::REFEREE;
    const S_ADMIN      = Role::SYSADMIN;
    const PLAYER       = Role::PLAYER;
    const PLAYER_NO_PM = Role::PLAYER_NO_PM;

    /**
     * The bzid of the player
     * @var int
     */
    protected $bzid;

    /**
     * The id of the player's team
     * @var int
     */
    protected $team;

    /**
     * The player's status
     * @var string
     */
    protected $status;

    /**
     * The player's e-mail address
     * @var string
     */
    protected $email;

    /**
     * Whether the player has verified their e-mail address
     * @var bool
     */
    protected $verified;

    /**
     * What kind of events the player should be e-mailed about
     * @var string
     */
    protected $receives;

    /**
     * A confirmation code for the player's e-mail address verification
     * @var string
     */
    protected $confirmCode;

    /**
     * Whether the callsign of the player is outdated
     * @var bool
     */
    protected $outdated;

    /**
     * The player's profile description
     * @var string
     */
    protected $description;

    /**
     * The id of the player's country
     * @var int
     */
    protected $country;

    /**
     * The player's timezone PHP identifier, e.g. "Europe/Paris"
     * @var string
     */
    protected $timezone;

    /**
     * The date the player joined the site
     * @var TimeDate
     */
    protected $joined;

    /**
     * The date of the player's last login
     * @var TimeDate
     */
    protected $last_login;

    /**
     * The roles a player belongs to
     * @var Role[]
     */
    protected $roles;

    /**
     * The permissions a player has
     * @var Permission[]
     */
    protected $permissions;

    /**
     * A section for admins to write notes about players
     * @var string
     */
    protected $admin_notes;

    /**
     * The ban of the player, or null if the player is not banned
     * @var Ban|null
     */
    protected $ban;

    /**
     * The cached match count for a player
     *
     * @var int
     */
    private $cachedMatchCount = null;

    /**
     * The name of the database table used for queries
     */
    const TABLE = "players";

    /**
     * The location where avatars will be stored
     */
    const AVATAR_LOCATION = "/web/assets/imgs/avatars/players/";

    const EDIT_PERMISSION = Permission::EDIT_USER;
    const SOFT_DELETE_PERMISSION = Permission::SOFT_DELETE_USER;
    const HARD_DELETE_PERMISSION = Permission::HARD_DELETE_USER;

    /**
     * {@inheritdoc}
     */
    protected function assignResult($player)
    {
        $this->bzid = $player['bzid'];
        $this->name = $player['username'];
        $this->alias = $player['alias'];
        $this->team = $player['team'];
        $this->status = $player['status'];
        $this->avatar = $player['avatar'];
        $this->country = $player['country'];
    }

    /**
     * {@inheritdoc}
     */
    protected function assignLazyResult($player)
    {
        $this->email = $player['email'];
        $this->verified = $player['verified'];
        $this->receives = $player['receives'];
        $this->confirmCode = $player['confirm_code'];
        $this->outdated = $player['outdated'];
        $this->description = $player['description'];
        $this->timezone = $player['timezone'];
        $this->joined = TimeDate::fromMysql($player['joined']);
        $this->last_login = TimeDate::fromMysql($player['last_login']);
        $this->admin_notes = $player['admin_notes'];
        $this->ban = Ban::getBan($this->id);

        $this->updateUserPermissions();
    }

    /**
     * Add a player a new role
     *
     * @param Role|int $role_id The role ID to add a player to
     *
     * @return bool Whether the operation was successful or not
     */
    public function addRole($role_id)
    {
        if ($role_id instanceof Role) {
            $role_id = $role_id->getId();
        }

        $this->lazyLoad();

        // Make sure the player doesn't already have the role
        foreach ($this->roles as $playerRole) {
            if ($playerRole->getId() == $role_id) {
                return false;
            }
        }

        $status = $this->modifyRole($role_id, "add");
        $this->refresh();

        return $status;
    }

    /**
     * Get the notes admins have left about a player
     * @return string The notes
     */
    public function getAdminNotes()
    {
        $this->lazyLoad();

        return $this->admin_notes;
    }

    /**
     * Get the player's BZID
     * @return int The BZID
     */
    public function getBZID()
    {
        return $this->bzid;
    }

    /**
     * Get the country a player belongs to
     *
     * @return Country The country belongs to
     */
    public function getCountry()
    {
        return Country::get($this->country);
    }

    /**
     * Get the e-mail address of the player
     *
     * @return string The address
     */
    public function getEmailAddress()
    {
        $this->lazyLoad();

        return $this->email;
    }

    /**
     * Returns whether the player has verified their e-mail address
     *
     * @return bool `true` for verified players
     */
    public function isVerified()
    {
        $this->lazyLoad();

        return $this->verified;
    }

    /**
     * Returns the confirmation code for the player's e-mail address verification
     *
     * @return string The player's confirmation code
     */
    public function getConfirmCode()
    {
        $this->lazyLoad();

        return $this->confirmCode;
    }

    /**
     * Returns what kind of events the player should be e-mailed about
     *
     * @return string The type of notifications
     */
    public function getReceives()
    {
        $this->lazyLoad();

        return $this->receives;
    }

    /**
     * Finds out whether the specified player wants and can receive an e-mail
     * message
     *
     * @param  string  $type
     * @return bool `true` if the player should be sent an e-mail
     */
    public function canReceive($type)
    {
        $this->lazyLoad();

        if (!$this->email || !$this->isVerified()) {
            // Unverified e-mail means the user will receive nothing
            return false;
        }

        if ($this->receives == 'everything') {
            return true;
        }

        return $this->receives == $type;
    }

    /**
     * Find out whether the specified confirmation code is correct
     *
     * This method protects against timing attacks
     *
     * @param  string $code The confirmation code to check
     * @return bool `true` for a correct e-mail verification code
     */
    public function isCorrectConfirmCode($code)
    {
        $this->lazyLoad();

        if ($this->confirmCode === null) {
            return false;
        }

        return StringUtils::equals($code, $this->confirmCode);
    }

    /**
     * Get the player's sanitized description
     * @return string The description
     */
    public function getDescription()
    {
        $this->lazyLoad();

        return $this->description;
    }

    /**
     * Get the joined date of the player
     * @return TimeDate The joined date of the player
     */
    public function getJoinedDate()
    {
        $this->lazyLoad();

        return $this->joined->copy();
    }

    /**
     * Get all of the known IPs used by the player
     *
     * @return string[][] An array containing IPs and hosts
     */
    public function getKnownIPs()
    {
        return $this->db->query("SELECT DISTINCT ip, host FROM visits WHERE player = ? LIMIT 10", array($this->getId()));
    }

    /**
     * Get the last login for a player
     * @return TimeDate The date of the last login
     */
    public function getLastLogin()
    {
        $this->lazyLoad();

        return $this->last_login->copy();
    }

    /**
     * Get all of the callsigns a player has used to log in to the website
     * @return string[] An array containing all of the past callsigns recorded for a player
     */
    public function getPastCallsigns()
    {
        return self::fetchIds("WHERE player = ?", array($this->id), "past_callsigns", "username");
    }

    /**
     * Get the player's team
     * @return Team The object representing the team
     */
    public function getTeam()
    {
        return Team::get($this->team);
    }

    /**
     * Get the player's timezone PHP identifier (example: "Europe/Paris")
     * @return string The timezone
     */
    public function getTimezone()
    {
        $this->lazyLoad();

        return ($this->timezone) ?: date_default_timezone_get();
    }

    /**
     * Get the roles of the player
     * @return Role[]
     */
    public function getRoles()
    {
        $this->lazyLoad();

        return $this->roles;
    }

    /**
     * Rebuild the list of permissions a user has been granted
     */
    private function updateUserPermissions()
    {
        $this->roles = Role::getRoles($this->id);

        $this->permissions = array();

        foreach ($this->roles as $role) {
            $this->permissions = array_merge($this->permissions, $role->getPerms());
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }
    }

    /**
     * Check if a player has a specific permission
     *
     * @param string|null $permission The permission to check for
     *
     * @return bool Whether or not the player has the permission
     */
    public function hasPermission($permission)
    {
        if ($permission === null) {
            return false;
        }

        $this->lazyLoad();

        return isset($this->permissions[$permission]);
    }

    /**
     * Check whether the callsign of the player is outdated
     *
     * Returns true if this player has probably changed their callsign, making
     * the current username stored in the database obsolete
     *
     * @return bool Whether or not the player is disabled
     */
    public function isOutdated()
    {
        $this->lazyLoad();

        return $this->outdated;
    }

    /**
     * Check if a player's account has been disabled
     *
     * @return bool Whether or not the player is disabled
     */
    public function isDisabled()
    {
        return $this->status == "disabled";
    }

    /**
     * Check if everyone can log in as this user on a test environment
     *
     * @return bool
     */
    public function isTestUser()
    {
        return $this->status == "test";
    }

    /**
     * Check if a player is teamless
     *
     * @return bool True if the player is teamless
     */
    public function isTeamless()
    {
        return empty($this->team);
    }

    /**
     * Mark a player's account as banned
     */
    public function markAsBanned()
    {
        if ($this->status != 'active') {
            return $this;
        }

        return $this->updateProperty($this->status, "status", "banned");
    }

    /**
     * Mark a player's account as unbanned
     */
    public function markAsUnbanned()
    {
        if ($this->status != 'banned') {
            return $this;
        }

        return $this->updateProperty($this->status, "status", "active");
    }

    /**
     * Find out if a player is banned
     *
     * @return bool
     */
    public function isBanned()
    {
        return Ban::getBan($this->id) !== null;
    }

    /**
     * Get the ban of the player
     *
     * This method performs a load of all the lazy parameters of the Player
     *
     * @return Ban|null The current ban of the player, or null if the player is
     *                  is not banned
     */
    public function getBan()
    {
        $this->lazyLoad();

        return $this->ban;
    }

    /**
     * Remove a player from a role
     *
     * @param int $role_id The role ID to add or remove
     *
     * @return bool Whether the operation was successful or not
     */
    public function removeRole($role_id)
    {
        $status = $this->modifyRole($role_id, "remove");
        $this->refresh();

        return $status;
    }

    /**
     * Set the player's email address and reset their verification status
     * @param string $email The address
     */
    public function setEmailAddress($email)
    {
        $this->lazyLoad();

        if ($this->email == $email) {
            // The e-mail hasn't changed, don't do anything
            return;
        }

        $this->setVerified(false);
        $this->generateNewConfirmCode();

        $this->updateProperty($this->email, 'email', $email);
    }

    /**
     * Set whether the player has verified their e-mail address
     *
     * @param  bool $verified Whether the player is verified or not
     * @return self
     */
    public function setVerified($verified)
    {
        $this->lazyLoad();

        if ($verified) {
            $this->setConfirmCode(null);
        }

        return $this->updateProperty($this->verified, 'verified', $verified);
    }

    /**
     * Generate a new random confirmation token for e-mail address verification
     *
     * @return self
     */
    public function generateNewConfirmCode()
    {
        $generator = new SecureRandom();

        $random = $generator->nextBytes(16);

        return $this->setConfirmCode(bin2hex($random));
    }

    /**
     * Set the confirmation token for e-mail address verification
     *
     * @param  string $code The confirmation code
     * @return self
     */
    private function setConfirmCode($code)
    {
        $this->lazyLoad();

        return $this->updateProperty($this->confirmCode, 'confirm_code', $code);
    }

    /**
     * Set what kind of events the player should be e-mailed about
     *
     * @param  string $receives The type of notification
     * @return self
     */
    public function setReceives($receives)
    {
        $this->lazyLoad();

        return $this->updateProperty($this->receives, 'receives', $receives);
    }

    /**
     * Set whether the callsign of the player is outdated
     *
     * @param  bool $outdated Whether the callsign is outdated
     * @return self
     */
    public function setOutdated($outdated)
    {
        $this->lazyLoad();

        return $this->updateProperty($this->outdated, 'outdated', $outdated);
    }

    /**
     * Set the player's description
     * @param string $description The description
     */
    public function setDescription($description)
    {
        $this->updateProperty($this->description, "description", $description);
    }

    /**
     * Set the player's timezone
     * @param string $timezone The timezone
     */
    public function setTimezone($timezone)
    {
        $this->updateProperty($this->timezone, "timezone", $timezone);
    }

    /**
     * Set the player's team
     * @param int $team The team's ID
     */
    public function setTeam($team)
    {
        $this->updateProperty($this->team, "team", $team);
    }

    /**
     * Set the player's status
     * @param string $status The new status
     */
    public function setStatus($status)
    {
        $this->updateProperty($this->status, 'status', $status);
    }

    /**
     * Set the player's admin notes
     * @param  string $admin_notes The new admin notes
     * @return self
     */
    public function setAdminNotes($admin_notes)
    {
        return $this->updateProperty($this->admin_notes, 'admin_notes', $admin_notes);
    }

    /**
     * Set the player's country
     * @param  int   $country The ID of the new country
     * @return self
     */
    public function setCountry($country)
    {
        return $this->updateProperty($this->country, 'country', $country);
    }

    /**
     * Updates this player's last login
     */
    public function updateLastLogin()
    {
        $this->update("last_login", TimeDate::now()->toMysql());
    }

    /**
     * Get the player's username
     * @return string The username
     */
    public function getUsername()
    {
        return $this->name;
    }

    /**
     * Get the player's username, safe for use in your HTML
     * @return string The username
     */
    public function getEscapedUsername()
    {
        return $this->getEscapedName();
    }

    /**
     * Alias for Player::setUsername()
     *
     * @param  string $username The new username
     * @return self
     */
    public function setName($username)
    {
        return $this->setUsername($username);
    }

    /**
     * Mark all the unread messages of a player as read
     *
     * @return void
     */
    public function markMessagesAsRead()
    {
        $this->db->execute(
            "UPDATE `player_conversations` SET `read` = 1 WHERE `player` = ? AND `read` = 0",
            array($this->id)
        );
    }

    /**
     * Set the roles of a user
     *
     * @todo   Is it worth making this faster?
     * @param  Role[] $roles The new roles of the user
     * @return self
     */
    public function setRoles($roles)
    {
        $this->lazyLoad();

        $oldRoles = Role::mapToIds($this->roles);
        $this->roles = $roles;
        $roleIds = Role::mapToIds($roles);

        $newRoles     = array_diff($roleIds, $oldRoles);
        $removedRoles = array_diff($oldRoles, $roleIds);

        foreach ($newRoles as $role) {
            $this->modifyRole($role, 'add');
        }

        foreach ($removedRoles as $role) {
            $this->modifyRole($role, 'remove');
        }

        $this->refresh();

        return $this;
    }

    /**
     * Give or remove a role to/form a player
     *
     * @param int    $role_id The role ID to add or remove
     * @param string $action  Whether to "add" or "remove" a role for a player
     *
     * @return bool Whether the operation was successful or not
     */
    private function modifyRole($role_id, $action)
    {
        $role = Role::get($role_id);

        if ($role->isValid()) {
            if ($action == "add") {
                $this->db->execute("INSERT INTO player_roles (user_id, role_id) VALUES (?, ?)", array($this->getId(), $role_id));
            } elseif ($action == "remove") {
                $this->db->execute("DELETE FROM player_roles WHERE user_id = ? AND role_id = ?", array($this->getId(), $role_id));
            } else {
                throw new Exception("Unrecognized role action");
            }

            return true;
        }

        return false;
    }

    /**
     * Given a player's BZID, get a player object
     *
     * @param  int    $bzid The player's BZID
     * @return Player
     */
    public static function getFromBZID($bzid)
    {
        return self::get(self::fetchIdFrom($bzid, "bzid"));
    }

    /**
     * Get a single player by their username
     *
     * @param  string $username The username to look for
     * @return Player
     */
    public static function getFromUsername($username)
    {
        $player = static::get(self::fetchIdFrom($username, 'username'));

        return $player->inject('name', $username);
    }

    /**
     * Get all the players in the database that have an active status
     * @return Player[] An array of player BZIDs
     */
    public static function getPlayers()
    {
        return self::arrayIdToModel(
            self::fetchIdsFrom("status", array("active", "test"), false)
        );
    }

    /**
     * Show the number of notifications the user hasn't read yet
     * @return int
     */
    public function countUnreadNotifications()
    {
        return Notification::countUnreadNotifications($this->id);
    }

    /**
     * Count the number of matches a player has participated in
     * @return int
     */
    public function getMatchCount()
    {
        if ($this->cachedMatchCount === null) {
            $this->cachedMatchCount = Match::getQueryBuilder()
                ->active()
                ->with($this)
                ->count();
        }

        return $this->cachedMatchCount;
    }

    /**
     * Get the (victory/total matches) ratio of the player
     * @return float
     */
    public function getMatchWinRatio()
    {
        $count = $this->getMatchCount();

        if ($count == 0) {
            return 0;
        }

        $wins = Match::getQueryBuilder()
            ->active()
            ->with($this, 'win')
            ->count();

        return $wins/$count;
    }

    /**
     * Get the (total caps made by team/total matches) ratio of the player
     * @return float
     */
    public function getMatchAverageCaps()
    {
        $count = $this->getMatchCount();

        if ($count == 0) {
            return 0;
        }

        // Get the sum of team A points if the player was in team A, team B
        // points if the player was in team B, and their average if the player
        // was on both teams for some reason
        $query = $this->db->query(
            "SELECT SUM(
                IF(
                    FIND_IN_SET(?, team_a_players) AND FIND_IN_SET(?, team_b_players),
                    (team_a_points+team_b_points)/2,
                    IF(FIND_IN_SET(?, team_a_players), team_a_points, team_b_points)
                )
            ) AS sum FROM matches WHERE status='entered' AND (FIND_IN_SET(?, team_a_players) OR FIND_IN_SET(?, team_b_players))",
            "iiiii", array_fill(0, 5, $this->id)

        );

        return $query[0]['sum']/$count;
    }

    /**
     * Show the number of messages the user hasn't read yet
     * @return int
     */
    public function countUnreadMessages()
    {
        return $this->fetchCount("WHERE `player` = ? AND `read` = 0",
            $this->id, 'player_conversations'
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    /**
     * Get all of the members belonging to a team
     * @param  int      $teamID The ID of the team to fetch the members of
     * @return Player[] An array of Player objects of the team members
     */
    public static function getTeamMembers($teamID)
    {
        return self::arrayIdToModel(
            self::fetchIds("WHERE team = ?", array($teamID))
        );
    }

    /**
     * {@inheritdoc}
     */
    public static function getActiveStatuses()
    {
        return array('active', 'reported', 'test');
    }

    /**
     * {@inheritdoc}
     */
    public static function getEagerColumns()
    {
        return 'id,bzid,team,username,alias,status,avatar,country';
    }

    /**
     * {@inheritdoc}
     */
    public static function getLazyColumns()
    {
        return 'email,verified,receives,confirm_code,outdated,description,timezone,joined,last_login,admin_notes';
    }

    /**
     * Get a query builder for players
     * @return QueryBuilder
     */
    public static function getQueryBuilder()

    {
        return new QueryBuilder('Player', array(
            'columns' => array(
                'name'     => 'username',
                'team'     => 'team',
                'outdated' => 'outdated',
                'status'   => 'status'
            ),
            'name' => 'name',
        ));
    }

    /**
     * Enter a new player to the database
     * @param  int              $bzid        The player's bzid
     * @param  string           $username    The player's username
     * @param  int              $team        The player's team
     * @param  string           $status      The player's status
     * @param  int              $role_id     The player's role when they are first created
     * @param  string           $avatar      The player's profile avatar
     * @param  string           $description The player's profile description
     * @param  int              $country     The player's country
     * @param  string           $timezone    The player's timezone
     * @param  string|\TimeDate $joined      The date the player joined
     * @param  string|\TimeDate $last_login  The timestamp of the player's last login
     * @return Player           An object representing the player that was just entered
     */
    public static function newPlayer($bzid, $username, $team = null, $status = "active", $role_id = self::PLAYER, $avatar = "", $description = "", $country = 1, $timezone = null, $joined = "now", $last_login = "now")
    {
        $joined = TimeDate::from($joined);
        $last_login = TimeDate::from($last_login);
        $timezone = ($timezone) ?: date_default_timezone_get();

        $player = self::create(array(
            'bzid'        => $bzid,
            'team'        => $team,
            'username'    => $username,
            'alias'       => self::generateAlias($username),
            'status'      => $status,
            'avatar'      => $avatar,
            'description' => $description,
            'country'     => $country,
            'timezone'    => $timezone,
            'joined'      => $joined->toMysql(),
            'last_login'  => $last_login->toMysql(),
        ));

        $player->addRole($role_id);
        $player->getIdenticon($player->getId());
        $player->setUsername($username);

        return $player;
    }

    /**
     * Determine if a player exists in the database
     * @param  int  $bzid The player's bzid
     * @return bool Whether the player exists in the database
     */
    public static function playerBZIDExists($bzid)
    {
        return self::getFromBZID($bzid)->isValid();
    }

    /**
     * Change a player's callsign and add it to the database if it does not
     * exist as a past callsign
     *
     * @param  string $username The new username of the player
     * @return self
     */
    public function setUsername($username)
    {
        // The player's username was just fetched from BzDB, it's definitely not
        // outdated
        $this->setOutdated(false);

        // Players who have this player's username are considered outdated
        $this->db->execute("UPDATE {$this->table} SET outdated = 1 WHERE username = ? AND id != ?", array($username, $this->id));

        if ($username === $this->name) {
            // The player's username hasn't changed, no need to do anything
            return $this;
        }

        // Players who used to have our player's username are not outdated anymore,
        // unless they are more than one.
        // Even though we are sure that the old and new usernames are not equal,
        // MySQL makes a different type of string equality tests, which is why we
        // also check IDs to make sure not to affect our own player's outdatedness.
        $this->db->execute("
            UPDATE {$this->table} SET outdated =
                (SELECT (COUNT(*)>1) FROM (SELECT 1 FROM {$this->table} WHERE username = ? AND id != ?) t)
            WHERE username = ? AND id != ?",
            array($this->name, $this->id, $this->name, $this->id));

        $this->updateProperty($this->name, 'username', $username);
        $this->db->execute("INSERT IGNORE INTO past_callsigns (player, username) VALUES (?, ?)", array($this->id, $username));
        $this->resetAlias();

        return $this;
    }

    /**
     * Alphabetical order function for use in usort (case-insensitive)
     * @return Closure The sort function
     */
    public static function getAlphabeticalSort()
    {
        return function (Player $a, Player $b) {
            return strcasecmp($a->getUsername(), $b->getUsername());
        };
    }

    /**
     * {@inheritdoc}
     * @todo Add a constraint that does this automatically
     */
    public function wipe()
    {
        $this->db->execute("DELETE FROM past_callsigns WHERE player = ?", $this->id);

        parent::wipe();
    }

    /**
     * Find whether the player can delete a model
     *
     * @param  PermissionModel $model       The model that will be seen
     * @param  bool         $showDeleted Whether to show deleted models to admins
     * @return bool
     */
    public function canSee($model, $showDeleted = false)
    {
        return $model->canBeSeenBy($this, $showDeleted);
    }

    /**
     * Find whether the player can delete a model
     *
     * @param  PermissionModel $model The model that will be deleted
     * @param  bool         $hard  Whether to check for hard-delete perms, as opposed
     *                                to soft-delete ones
     * @return bool
     */
    public function canDelete($model, $hard = false)
    {
        if ($hard) {
            return $model->canBeHardDeletedBy($this);
        } else {
            return $model->canBeSoftDeletedBy($this);
        }
    }

    /**
     * Find whether the player can create a model
     *
     * @param  string  $modelName The PHP class identifier of the model type
     * @return bool
     */
    public function canCreate($modelName)
    {
        return $modelName::canBeCreatedBy($this);
    }

    /**
     * Find whether the player can edit a model
     *
     * @param  PermissionModel $model The model which will be edited
     * @return bool
     */
    public function canEdit($model)
    {
        return $model->canBeEditedBy($this);
    }
}

allejo / bzion

Pull Request — master (#51)

Player::getMatchAverageCaps() B

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
