Player - Code Metrics - video-games-records/core-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Player A
last analyzed 2025-04-17 18:48 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	454
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

Metric	Value
wmc	40
eloc	223
c	5
b	0
f	0
dl	0
loc	454
rs	9.2

39 Methods

Rating	Name	Size	Complexity
A	setNbConnexion()	3	1
A	setNbChartWithPlatform()	3	1
A	setStatus()	3	1
A	getLastDisplayLostPosition()	3	1
A	setId()	3	1
A	getUserId()	3	1
A	getSluggableFields()	3	1
A	getAvatar()	3	1
A	getId()	3	1
A	setPseudo()	3	1
A	getHasDonate()	3	1
A	setNbChartDisabled()	3	1
A	setGamerCard()	3	1
A	getNbConnexion()	3	1
A	getGamerCard()	3	1
A	getTeam()	3	1
A	setTeam()	3	1
A	getRankCountry()	3	1
A	getLastLogin()	3	1
A	setRankProof()	3	1
A	getNbChartMax()	3	1
A	setBoolMaj()	3	1
A	setLastDisplayLostPosition()	3	1
A	getNbChartDisabled()	3	1
A	setLastLogin()	3	1
A	getNbChartWithPlatform()	3	1
A	setUserId()	4	1
A	setHasDonate()	3	1
A	getBoolMaj()	3	1
A	setNbChartMax()	3	1
A	getPseudo()	3	1
A	setRankCountry()	3	1
A	getRankProof()	3	1
A	getStatus()	3	1
A	__toString()	3	1
A	setAvatar()	3	1
A	getUrl()	6	1
A	isLeader()	3	2
A	getInitial()	3	1

How to fix Complexity

<?php

declare(strict_types=1);

namespace VideoGamesRecords\CoreBundle\Entity;

use ApiPlatform\Doctrine\Common\Filter\DateFilterInterface;
use ApiPlatform\Doctrine\Orm\Filter\BooleanFilter;
use ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
use ApiPlatform\Doctrine\Orm\Filter\DateFilter;
use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
use ApiPlatform\Metadata\ApiFilter;
use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Link;
use ApiPlatform\Metadata\Put;
use ApiPlatform\Serializer\Filter\GroupFilter;
use ApiPlatform\OpenApi\Model;
use DateTime;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Gedmo\Timestampable\Traits\TimestampableEntity;
use Knp\DoctrineBehaviors\Contract\Entity\SluggableInterface;
use Knp\DoctrineBehaviors\Model\Sluggable\SluggableTrait;
use Symfony\Component\Validator\Constraints as Assert;
use VideoGamesRecords\CoreBundle\Controller\Player\Autocomplete;
use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingBadge;
use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingCup;
use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingMedals;
use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingPointChart;
use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingPointGame;
use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingProof;
use VideoGamesRecords\CoreBundle\Controller\Player\LostPosition\GetNbLostPosition;
use VideoGamesRecords\CoreBundle\Controller\Player\LostPosition\GetNbNewLostPosition;
use VideoGamesRecords\CoreBundle\Controller\Player\Game\GetStats as GameGetStats;
use VideoGamesRecords\CoreBundle\Controller\Player\PlayerChart\GetStats as PlayerChartGetStats;
use VideoGamesRecords\CoreBundle\Controller\Player\ProofRequest\CanAskProof;
use VideoGamesRecords\CoreBundle\Repository\PlayerRepository;
use VideoGamesRecords\CoreBundle\Traits\Entity\AverageChartRankTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\AverageGameRankTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank0Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank1Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank2Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank3Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank4Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank5Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank0Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank1Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank2Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank3Trait;
use VideoGamesRecords\CoreBundle\Traits\Entity\NbChartProvenTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\NbChartTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\NbGameTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\NbMasterBadgeTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\NbVideoTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\Player\PlayerCommunicationDataTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\Player\PlayerPersonalDataTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\PointBadgeTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\PointChartTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\PointGameTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\RankCupTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\RankMedalTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\RankPointBadgeTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\RankPointChartTrait;
use VideoGamesRecords\CoreBundle\Traits\Entity\RankPointGameTrait;

#[ORM\Table(name:'vgr_player')]
#[ORM\Entity(repositoryClass: PlayerRepository::class)]
#[ORM\EntityListeners(["VideoGamesRecords\CoreBundle\EventListener\Entity\PlayerListener"])]
#[ORM\Index(name: "idx_point_game", columns: ["point_game"])]
#[ORM\Index(name: "idx_chart_rank", columns: ["chart_rank0", "chart_rank1", "chart_rank2", "chart_rank3"])]
#[ORM\Index(name: "idx_game_rank", columns: ["game_rank0", "game_rank1", "game_rank2", "game_rank3"])]
#[ApiResource(
    order: ['pseudo' => 'ASC'],
    operations: [
        new GetCollection(),
        new GetCollection(
            uriTemplate: '/players/autocomplete',
            controller: Autocomplete::class,
            normalizationContext: ['groups' => [
                'player:read']
            ],
            openapi: new Model\Operation(
                summary: 'Retrieves players by autocompletion',
                description: 'Retrieves players by autocompletion'
            ),
            /*openapiContext: [
                'parameters' => [
                    [
                        'name' => 'query',
                        'in' => 'query',
                        'type' => 'string',
                        'required' => true
                    ]
                ]
            ]*/
        ),
        new GetCollection(
            uriTemplate: '/players/ranking-point-chart',
            controller: GetRankingPointChart::class,
        ),
        new GetCollection(
            uriTemplate: '/players/ranking-point-game',
            controller: GetRankingPointGame::class,
        ),
        new GetCollection(
            uriTemplate: '/players/ranking-medal',
            controller: GetRankingMedals::class,
        ),
        new GetCollection(
            uriTemplate: '/players/ranking-cup',
            controller: GetRankingCup::class,
        ),
        new GetCollection(
            uriTemplate: '/players/ranking-badge',
            controller: GetRankingBadge::class,
        ),
        new GetCollection(
            uriTemplate: '/players/ranking-proof',
            controller: GetRankingProof::class,
        ),
        new Get(),
        new Get(
            uriTemplate: '/players/{id}/nb-lost-position',
            controller: GetNbLostPosition::class,
        ),
        new Get(
            uriTemplate: '/players/{id}/nb-new-lost-position',
            controller: GetNbNewLostPosition::class,
        ),
        new Get(
            uriTemplate: '/players/{id}/can-ask-proof',
            controller: CanAskProof::class,
        ),
        new Get(
            uriTemplate: '/players/{id}/player-chart-stats',
            controller: PlayerChartGetStats::class,
            normalizationContext: ['groups' => [
                'player-chart-status:read']
            ],
        ),
        new Get(
            uriTemplate: '/players/{id}/game-stats',
            controller: GameGetStats::class,
            normalizationContext: ['groups' => [
                'player-game:read', 'player-game:game', 'game:read',
                'game:platforms', 'platform:read',
                'player-game.statuses', 'player-chart-status:read']
            ],
        ),
        new Put(
            denormalizationContext: ['groups' => ['player:update']],
            security: 'is_granted("ROLE_PLAYER") and object.getUserId() == user.getId()'
        ),
    ],
    normalizationContext: ['groups' => [
        'player:read',
        'player:team', 'team:read',
        'player:country', 'country:read',
        'player:status', 'player-status:read']
    ],
)]
#[ApiResource(
    uriTemplate: '/teams/{id}/players',
    uriVariables: [
        'id' => new Link(fromClass: Team::class, toProperty: 'team'),
    ],
    operations: [ new GetCollection() ],
    normalizationContext: ['groups' => ['player:read']],
)]
#[ApiFilter(
    SearchFilter::class,
    properties: [
        'pseudo' => 'partial',
        'user.enabled' => 'exact',
    ]
)]
#[ApiFilter(
    OrderFilter::class,
    properties: [
        'id' => 'ASC',
        'pseudo' => 'ASC',
        'createdAt' => 'ASC',
        'nbConnexion' => 'DESC',
        'lastLogin' => 'DESC',
        'nbForumMessage' => 'DESC',
        'nbChart' => 'DESC',
        'nbVideo' => 'DESC',
    ]
)]
#[ApiFilter(
    GroupFilter::class,
    arguments: [
        'parameterName' => 'groups',
        'overrideDefaultGroups' => true,
        'whitelist' => [
            'player:read',
            'player:team',
            'player:country',
            'country:read',
            'player:read',
            'player:team',
            'team:read',
            'player:status',
            'player-status:read',
        ]
    ]
)]
#[ApiFilter(DateFilter::class, properties: ['lastLogin' => DateFilterInterface::EXCLUDE_NULL])]
#[ApiFilter(RangeFilter::class, properties: ['nbVideo'])]
#[ApiFilter(BooleanFilter::class, properties: ['hasDonate'])]
class Player implements SluggableInterface
{
    use TimestampableEntity;
    use SluggableTrait;
    use RankCupTrait;
    use GameRank0Trait;
    use GameRank1Trait;
    use GameRank2Trait;
    use GameRank3Trait;
    use RankMedalTrait;
    use ChartRank0Trait;
    use ChartRank1Trait;
    use ChartRank2Trait;
    use ChartRank3Trait;
    use ChartRank4Trait;
    use ChartRank5Trait;
    use RankPointBadgeTrait;
    use PointBadgeTrait;
    use RankPointChartTrait;
    use PointChartTrait;
    use RankPointGameTrait;
    use PointGameTrait;
    use AverageChartRankTrait;
    use AverageGameRankTrait;
    use PlayerCommunicationDataTrait;
    use PlayerPersonalDataTrait;
    use NbChartTrait;
    use NbChartProvenTrait;
    use NbGameTrait;
    use NbVideoTrait;
    use NbMasterBadgeTrait;

    #[ORM\Column(nullable: false)]
    private int $user_id;

    #[ApiProperty(identifier: true)]
    #[ORM\Id, ORM\Column, ORM\GeneratedValue]
    private ?int $id = null;

    #[Assert\Length(min: 3, max: 50)]
    #[ORM\Column(length: 50, nullable: false, unique: true)]
    private string $pseudo;

    #[Assert\Length(max: 100)]
    #[ORM\Column(length: 100, nullable: false, options: ['default' => "default.jpg"])]
    private string $avatar = 'default.jpg';

    #[Assert\Length(max: 50)]
    #[ORM\Column(length: 50, nullable: true)]
    private ?string $gamerCard = null;

    #[ORM\Column(nullable: false, options: ['default' => 0])]
    private int $rankProof = 0;

    #[ORM\Column(nullable: false, options: ['default' => 0])]
    private int $rankCountry = 0;

    #[ORM\Column(nullable: false, options: ['default' => 0])]
    private int $nbChartMax = 0;

    #[ORM\Column(nullable: false, options: ['default' => 0])]
    private int $nbChartWithPlatform = 0;

    #[ORM\Column(nullable: false, options: ['default' => 0])]
    private int $nbChartDisabled = 0;

    #[ORM\Column(nullable: true)]
    protected ?DateTime $lastLogin = null;

    #[ORM\Column(nullable: false, options: ['default' => 0])]
    protected int $nbConnexion = 0;

    #[ORM\Column(nullable: false, options: ['default' => false])]
    private bool $boolMaj = false;

    #[ORM\Column(nullable: false, options: ['default' => false])]
    private bool $hasDonate = false;

    #[ORM\ManyToOne(targetEntity: Team::class, inversedBy: 'players')]
    #[ORM\JoinColumn(name:'team_id', referencedColumnName:'id', nullable:true, onDelete: 'SET NULL')]
    private ?Team $team;

    #[ORM\Column(nullable: true)]
    protected ?DateTime $lastDisplayLostPosition;

    #[ORM\ManyToOne(targetEntity: PlayerStatus::class)]
    #[ORM\JoinColumn(name:'status_id', referencedColumnName:'id', nullable:false)]
    private PlayerStatus $status;

    /**
     * @var Collection<int, Proof>
     */
    #[ORM\OneToMany(targetEntity: Proof::class, mappedBy: 'playerResponding')]
    private Collection $proofRespondings;


    /**
     * @var Collection<int, PlayerGame>
     */
    #[ORM\OneToMany(targetEntity: PlayerGame::class, mappedBy: 'player')]
    private Collection $playerGame;



    public function __toString()
    {
        return sprintf('%s (%d)', $this->getPseudo(), $this->getId());
    }

    public function setId(int $id): void
    {
        $this->id = $id;
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function setPseudo(string $pseudo): void
    {
        $this->pseudo = $pseudo;
    }

    public function getPseudo(): string
    {
        return $this->pseudo;
    }

    public function setAvatar(string $avatar): void
    {
        $this->avatar = $avatar;
    }

    public function getAvatar(): string
    {
        return $this->avatar;
    }

    public function setGamerCard(string $gamerCard): void
    {
        $this->gamerCard = $gamerCard;
    }

    public function getGamerCard(): ?string
    {
        return $this->gamerCard;
    }


    public function setRankProof(int $rankProof): void
    {
        $this->rankProof = $rankProof;
    }

    public function getRankProof(): ?int
    {
        return $this->rankProof;
    }

    public function setRankCountry(int $rankCountry): void
    {
        $this->rankCountry = $rankCountry;
    }

    public function getRankCountry(): ?int
    {
        return $this->rankCountry;
    }

    public function setNbChartMax(int $nbChartMax): void
    {
        $this->nbChartMax = $nbChartMax;
    }

    public function getNbChartMax(): int
    {
        return $this->nbChartMax;
    }

    public function setNbChartWithPlatform(int $nbChartWithPlatform): void
    {
        $this->nbChartWithPlatform = $nbChartWithPlatform;
    }

    public function getNbChartWithPlatform(): int
    {
        return $this->nbChartWithPlatform;
    }

    public function setNbChartDisabled(int $nbChartDisabled): void
    {
        $this->nbChartDisabled = $nbChartDisabled;
    }

    public function getNbChartDisabled(): int
    {
        return $this->nbChartDisabled;
    }

    public function getLastLogin(): ?DateTime
    {
        return $this->lastLogin;
    }

    public function setLastLogin(DateTime $time = null): void
    {
        $this->lastLogin = $time;
    }

    /**
     * @return int
     */
    public function getUserId(): int
    {
        return $this->user_id;
    }

    public function setUserId($userId): Player
    {
        $this->user_id = $userId;
        return $this;
    }

    public function setTeam(Team $team = null): void
    {
        $this->team = $team;
    }

    public function getTeam(): ?Team
    {
        return $this->team;
    }

    public function getLastDisplayLostPosition(): ?DateTime
    {
        return $this->lastDisplayLostPosition;
    }


    public function setLastDisplayLostPosition(DateTime $lastDisplayLostPosition = null): void
    {
        $this->lastDisplayLostPosition = $lastDisplayLostPosition;
    }

    public function setBoolMaj(bool $boolMaj): void
    {
        $this->boolMaj = $boolMaj;
    }

    public function getBoolMaj(): bool
    {
        return $this->boolMaj;
    }

    public function getHasDonate(): bool
    {
        return $this->hasDonate;
    }

    public function setHasDonate(bool $hasDonate): void
    {
        $this->hasDonate = $hasDonate;
    }

    public function setStatus(PlayerStatus $status): void
    {
        $this->status = $status;
    }

    public function getStatus(): PlayerStatus
    {
        return $this->status;
    }

    /**
     * @return int
     */
    public function getNbConnexion(): int
    {
        return $this->nbConnexion;
    }

    public function setNbConnexion(int $nbConnexion): void
    {
        $this->nbConnexion = $nbConnexion;
    }


    public function getSluggableFields(): array
    {
        return ['pseudo'];
    }

    public function getInitial(): string
    {
        return substr($this->pseudo, 0, 1);
    }


    public function isLeader(): bool
    {
        return ($this->getTeam() !== null) && ($this->getTeam()->getLeader()->getId() === $this->getId());
    }

    public function getUrl(): string
    {
        return sprintf(
            '%s-player-p%d/index',
            $this->getSlug(),
            $this->getId()
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace VideoGamesRecords\CoreBundle\Entity;
6
7			use ApiPlatform\Doctrine\Common\Filter\DateFilterInterface;
8			use ApiPlatform\Doctrine\Orm\Filter\BooleanFilter;
9			use ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
10			use ApiPlatform\Doctrine\Orm\Filter\DateFilter;
11			use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
12			use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
13			use ApiPlatform\Metadata\ApiFilter;
14			use ApiPlatform\Metadata\ApiProperty;
15			use ApiPlatform\Metadata\ApiResource;
16			use ApiPlatform\Metadata\Get;
17			use ApiPlatform\Metadata\GetCollection;
18			use ApiPlatform\Metadata\Link;
19			use ApiPlatform\Metadata\Put;
20			use ApiPlatform\Serializer\Filter\GroupFilter;
21			use ApiPlatform\OpenApi\Model;
22			use DateTime;
23			use Doctrine\Common\Collections\Collection;
24			use Doctrine\ORM\Mapping as ORM;
25			use Gedmo\Timestampable\Traits\TimestampableEntity;
26			use Knp\DoctrineBehaviors\Contract\Entity\SluggableInterface;
27			use Knp\DoctrineBehaviors\Model\Sluggable\SluggableTrait;
28			use Symfony\Component\Validator\Constraints as Assert;
29			use VideoGamesRecords\CoreBundle\Controller\Player\Autocomplete;
30			use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingBadge;
31			use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingCup;
32			use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingMedals;
33			use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingPointChart;
34			use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingPointGame;
35			use VideoGamesRecords\CoreBundle\Controller\Player\GetRankingProof;
36			use VideoGamesRecords\CoreBundle\Controller\Player\LostPosition\GetNbLostPosition;
37			use VideoGamesRecords\CoreBundle\Controller\Player\LostPosition\GetNbNewLostPosition;
38			use VideoGamesRecords\CoreBundle\Controller\Player\Game\GetStats as GameGetStats;
39			use VideoGamesRecords\CoreBundle\Controller\Player\PlayerChart\GetStats as PlayerChartGetStats;
40			use VideoGamesRecords\CoreBundle\Controller\Player\ProofRequest\CanAskProof;
41			use VideoGamesRecords\CoreBundle\Repository\PlayerRepository;
42			use VideoGamesRecords\CoreBundle\Traits\Entity\AverageChartRankTrait;
43			use VideoGamesRecords\CoreBundle\Traits\Entity\AverageGameRankTrait;
44			use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank0Trait;
45			use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank1Trait;
46			use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank2Trait;
47			use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank3Trait;
48			use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank4Trait;
49			use VideoGamesRecords\CoreBundle\Traits\Entity\ChartRank5Trait;
50			use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank0Trait;
51			use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank1Trait;
52			use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank2Trait;
53			use VideoGamesRecords\CoreBundle\Traits\Entity\GameRank3Trait;
54			use VideoGamesRecords\CoreBundle\Traits\Entity\NbChartProvenTrait;
55			use VideoGamesRecords\CoreBundle\Traits\Entity\NbChartTrait;
56			use VideoGamesRecords\CoreBundle\Traits\Entity\NbGameTrait;
57			use VideoGamesRecords\CoreBundle\Traits\Entity\NbMasterBadgeTrait;
58			use VideoGamesRecords\CoreBundle\Traits\Entity\NbVideoTrait;
59			use VideoGamesRecords\CoreBundle\Traits\Entity\Player\PlayerCommunicationDataTrait;
60			use VideoGamesRecords\CoreBundle\Traits\Entity\Player\PlayerPersonalDataTrait;
61			use VideoGamesRecords\CoreBundle\Traits\Entity\PointBadgeTrait;
62			use VideoGamesRecords\CoreBundle\Traits\Entity\PointChartTrait;
63			use VideoGamesRecords\CoreBundle\Traits\Entity\PointGameTrait;
64			use VideoGamesRecords\CoreBundle\Traits\Entity\RankCupTrait;
65			use VideoGamesRecords\CoreBundle\Traits\Entity\RankMedalTrait;
66			use VideoGamesRecords\CoreBundle\Traits\Entity\RankPointBadgeTrait;
67			use VideoGamesRecords\CoreBundle\Traits\Entity\RankPointChartTrait;
68			use VideoGamesRecords\CoreBundle\Traits\Entity\RankPointGameTrait;
69
70			#[ORM\Table(name:'vgr_player')]
71			#[ORM\Entity(repositoryClass: PlayerRepository::class)]
72			#[ORM\EntityListeners(["VideoGamesRecords\CoreBundle\EventListener\Entity\PlayerListener"])]
73			#[ORM\Index(name: "idx_point_game", columns: ["point_game"])]
74			#[ORM\Index(name: "idx_chart_rank", columns: ["chart_rank0", "chart_rank1", "chart_rank2", "chart_rank3"])]
75			#[ORM\Index(name: "idx_game_rank", columns: ["game_rank0", "game_rank1", "game_rank2", "game_rank3"])]
76			#[ApiResource(
77			order: ['pseudo' => 'ASC'],
78			operations: [
79			new GetCollection(),
80			new GetCollection(
81			uriTemplate: '/players/autocomplete',
82			controller: Autocomplete::class,
83			normalizationContext: ['groups' => [
84			'player:read']
85			],
86			openapi: new Model\Operation(
87			summary: 'Retrieves players by autocompletion',
88			description: 'Retrieves players by autocompletion'
89			),
90			/*openapiContext: [
91			'parameters' => [
92			[
93			'name' => 'query',
94			'in' => 'query',
95			'type' => 'string',
96			'required' => true
97			]
98			]
99			]*/
100			),
101			new GetCollection(
102			uriTemplate: '/players/ranking-point-chart',
103			controller: GetRankingPointChart::class,
104			),
105			new GetCollection(
106			uriTemplate: '/players/ranking-point-game',
107			controller: GetRankingPointGame::class,
108			),
109			new GetCollection(
110			uriTemplate: '/players/ranking-medal',
111			controller: GetRankingMedals::class,
112			),
113			new GetCollection(
114			uriTemplate: '/players/ranking-cup',
115			controller: GetRankingCup::class,
116			),
117			new GetCollection(
118			uriTemplate: '/players/ranking-badge',
119			controller: GetRankingBadge::class,
120			),
121			new GetCollection(
122			uriTemplate: '/players/ranking-proof',
123			controller: GetRankingProof::class,
124			),
125			new Get(),
126			new Get(
127			uriTemplate: '/players/{id}/nb-lost-position',
128			controller: GetNbLostPosition::class,
129			),
130			new Get(
131			uriTemplate: '/players/{id}/nb-new-lost-position',
132			controller: GetNbNewLostPosition::class,
133			),
134			new Get(
135			uriTemplate: '/players/{id}/can-ask-proof',
136			controller: CanAskProof::class,
137			),
138			new Get(
139			uriTemplate: '/players/{id}/player-chart-stats',
140			controller: PlayerChartGetStats::class,
141			normalizationContext: ['groups' => [
142			'player-chart-status:read']
143			],
144			),
145			new Get(
146			uriTemplate: '/players/{id}/game-stats',
147			controller: GameGetStats::class,
148			normalizationContext: ['groups' => [
149			'player-game:read', 'player-game:game', 'game:read',
150			'game:platforms', 'platform:read',
151			'player-game.statuses', 'player-chart-status:read']
152			],
153			),
154			new Put(
155			denormalizationContext: ['groups' => ['player:update']],
156			security: 'is_granted("ROLE_PLAYER") and object.getUserId() == user.getId()'
157			),
158			],
159			normalizationContext: ['groups' => [
160			'player:read',
161			'player:team', 'team:read',
162			'player:country', 'country:read',
163			'player:status', 'player-status:read']
164			],
165			)]
166			#[ApiResource(
167			uriTemplate: '/teams/{id}/players',
168			uriVariables: [
169			'id' => new Link(fromClass: Team::class, toProperty: 'team'),
170			],
171			operations: [ new GetCollection() ],
172			normalizationContext: ['groups' => ['player:read']],
173			)]
174			#[ApiFilter(
175			SearchFilter::class,
176			properties: [
177			'pseudo' => 'partial',
178			'user.enabled' => 'exact',
179			]
180			)]
181			#[ApiFilter(
182			OrderFilter::class,
183			properties: [
184			'id' => 'ASC',
185			'pseudo' => 'ASC',
186			'createdAt' => 'ASC',
187			'nbConnexion' => 'DESC',
188			'lastLogin' => 'DESC',
189			'nbForumMessage' => 'DESC',
190			'nbChart' => 'DESC',
191			'nbVideo' => 'DESC',
192			]
193			)]
194			#[ApiFilter(
195			GroupFilter::class,
196			arguments: [
197			'parameterName' => 'groups',
198			'overrideDefaultGroups' => true,
199			'whitelist' => [
200			'player:read',
201			'player:team',
202			'player:country',
203			'country:read',
204			'player:read',
205			'player:team',
206			'team:read',
207			'player:status',
208			'player-status:read',
209			]
210			]
211			)]
212			#[ApiFilter(DateFilter::class, properties: ['lastLogin' => DateFilterInterface::EXCLUDE_NULL])]
213			#[ApiFilter(RangeFilter::class, properties: ['nbVideo'])]
214			#[ApiFilter(BooleanFilter::class, properties: ['hasDonate'])]
215			class Player implements SluggableInterface
216			{
217			use TimestampableEntity;
218			use SluggableTrait;
219			use RankCupTrait;
220			use GameRank0Trait;
221			use GameRank1Trait;
222			use GameRank2Trait;
223			use GameRank3Trait;
224			use RankMedalTrait;
225			use ChartRank0Trait;
226			use ChartRank1Trait;
227			use ChartRank2Trait;
228			use ChartRank3Trait;
229			use ChartRank4Trait;
230			use ChartRank5Trait;
231			use RankPointBadgeTrait;
232			use PointBadgeTrait;
233			use RankPointChartTrait;
234			use PointChartTrait;
235			use RankPointGameTrait;
236			use PointGameTrait;
237			use AverageChartRankTrait;
238			use AverageGameRankTrait;
239			use PlayerCommunicationDataTrait;
240			use PlayerPersonalDataTrait;
241			use NbChartTrait;
242			use NbChartProvenTrait;
243			use NbGameTrait;
244			use NbVideoTrait;
245			use NbMasterBadgeTrait;
246
247			#[ORM\Column(nullable: false)]
248			private int $user_id;
249
250			#[ApiProperty(identifier: true)]
251			#[ORM\Id, ORM\Column, ORM\GeneratedValue]
252			private ?int $id = null;
253
254			#[Assert\Length(min: 3, max: 50)]
255			#[ORM\Column(length: 50, nullable: false, unique: true)]
256			private string $pseudo;
257
258			#[Assert\Length(max: 100)]
259			#[ORM\Column(length: 100, nullable: false, options: ['default' => "default.jpg"])]
260			private string $avatar = 'default.jpg';
261
262			#[Assert\Length(max: 50)]
263			#[ORM\Column(length: 50, nullable: true)]
264			private ?string $gamerCard = null;
265
266			#[ORM\Column(nullable: false, options: ['default' => 0])]
267			private int $rankProof = 0;
268
269			#[ORM\Column(nullable: false, options: ['default' => 0])]
270			private int $rankCountry = 0;
271
272			#[ORM\Column(nullable: false, options: ['default' => 0])]
273			private int $nbChartMax = 0;
274
275			#[ORM\Column(nullable: false, options: ['default' => 0])]
276			private int $nbChartWithPlatform = 0;
277
278			#[ORM\Column(nullable: false, options: ['default' => 0])]
279			private int $nbChartDisabled = 0;
280
281			#[ORM\Column(nullable: true)]
282			protected ?DateTime $lastLogin = null;
283
284			#[ORM\Column(nullable: false, options: ['default' => 0])]
285			protected int $nbConnexion = 0;
286
287			#[ORM\Column(nullable: false, options: ['default' => false])]
288			private bool $boolMaj = false;
289
290			#[ORM\Column(nullable: false, options: ['default' => false])]
291			private bool $hasDonate = false;
292
293			#[ORM\ManyToOne(targetEntity: Team::class, inversedBy: 'players')]
294			#[ORM\JoinColumn(name:'team_id', referencedColumnName:'id', nullable:true, onDelete: 'SET NULL')]
295			private ?Team $team;
296
297			#[ORM\Column(nullable: true)]
298			protected ?DateTime $lastDisplayLostPosition;
299
300			#[ORM\ManyToOne(targetEntity: PlayerStatus::class)]
301			#[ORM\JoinColumn(name:'status_id', referencedColumnName:'id', nullable:false)]
302			private PlayerStatus $status;
303
304			/**
305			* @var Collection<int, Proof>
306			*/
307			#[ORM\OneToMany(targetEntity: Proof::class, mappedBy: 'playerResponding')]
308			private Collection $proofRespondings;
			0 ignored issues – show introduced 2022-11-12 10:13 UTC by Report Bug Copy Issue Report The private property `$proofRespondings` is not used, and could be removed. Loading history...
309
310			/**
311			* @var Collection<int, PlayerGame>
312			*/
313			#[ORM\OneToMany(targetEntity: PlayerGame::class, mappedBy: 'player')]
314			private Collection $playerGame;
			0 ignored issues – show introduced 2023-05-13 10:17 UTC by Report Bug Copy Issue Report The private property `$playerGame` is not used, and could be removed. Loading history...
315
316
317			public function __toString()
318			{
319			return sprintf('%s (%d)', $this->getPseudo(), $this->getId());
320			}
321
322			public function setId(int $id): void
323			{
324			$this->id = $id;
325			}
326
327			public function getId(): ?int
328			{
329			return $this->id;
330			}
331
332			public function setPseudo(string $pseudo): void
333			{
334			$this->pseudo = $pseudo;
335			}
336
337			public function getPseudo(): string
338			{
339			return $this->pseudo;
340			}
341
342			public function setAvatar(string $avatar): void
343			{
344			$this->avatar = $avatar;
345			}
346
347			public function getAvatar(): string
348			{
349			return $this->avatar;
350			}
351
352			public function setGamerCard(string $gamerCard): void
353			{
354			$this->gamerCard = $gamerCard;
355			}
356
357			public function getGamerCard(): ?string
358			{
359			return $this->gamerCard;
360			}
361
362
363			public function setRankProof(int $rankProof): void
364			{
365			$this->rankProof = $rankProof;
366			}
367
368			public function getRankProof(): ?int
369			{
370			return $this->rankProof;
371			}
372
373			public function setRankCountry(int $rankCountry): void
374			{
375			$this->rankCountry = $rankCountry;
376			}
377
378			public function getRankCountry(): ?int
379			{
380			return $this->rankCountry;
381			}
382
383			public function setNbChartMax(int $nbChartMax): void
384			{
385			$this->nbChartMax = $nbChartMax;
386			}
387
388			public function getNbChartMax(): int
389			{
390			return $this->nbChartMax;
391			}
392
393			public function setNbChartWithPlatform(int $nbChartWithPlatform): void
394			{
395			$this->nbChartWithPlatform = $nbChartWithPlatform;
396			}
397
398			public function getNbChartWithPlatform(): int
399			{
400			return $this->nbChartWithPlatform;
401			}
402
403			public function setNbChartDisabled(int $nbChartDisabled): void
404			{
405			$this->nbChartDisabled = $nbChartDisabled;
406			}
407
408			public function getNbChartDisabled(): int
409			{
410			return $this->nbChartDisabled;
411			}
412
413			public function getLastLogin(): ?DateTime
414			{
415			return $this->lastLogin;
416			}
417
418			public function setLastLogin(DateTime $time = null): void
419			{
420			$this->lastLogin = $time;
421			}
422
423			/**
424			* @return int
425			*/
426			public function getUserId(): int
427			{
428			return $this->user_id;
429			}
430
431			public function setUserId($userId): Player
432			{
433			$this->user_id = $userId;
434			return $this;
435			}
436
437			public function setTeam(Team $team = null): void
438			{
439			$this->team = $team;
440			}
441
442			public function getTeam(): ?Team
443			{
444			return $this->team;
445			}
446
447			public function getLastDisplayLostPosition(): ?DateTime
448			{
449			return $this->lastDisplayLostPosition;
450			}
451
452
453			public function setLastDisplayLostPosition(DateTime $lastDisplayLostPosition = null): void
454			{
455			$this->lastDisplayLostPosition = $lastDisplayLostPosition;
456			}
457
458			public function setBoolMaj(bool $boolMaj): void
459			{
460			$this->boolMaj = $boolMaj;
461			}
462
463			public function getBoolMaj(): bool
464			{
465			return $this->boolMaj;
466			}
467
468			public function getHasDonate(): bool
469			{
470			return $this->hasDonate;
471			}
472
473			public function setHasDonate(bool $hasDonate): void
474			{
475			$this->hasDonate = $hasDonate;
476			}
477
478			public function setStatus(PlayerStatus $status): void
479			{
480			$this->status = $status;
481			}
482
483			public function getStatus(): PlayerStatus
484			{
485			return $this->status;
486			}
487
488			/**
489			* @return int
490			*/
491			public function getNbConnexion(): int
492			{
493			return $this->nbConnexion;
494			}
495
496			public function setNbConnexion(int $nbConnexion): void
497			{
498			$this->nbConnexion = $nbConnexion;
499			}
500
501
502			public function getSluggableFields(): array
503			{
504			return ['pseudo'];
505			}
506
507			public function getInitial(): string
508			{
509			return substr($this->pseudo, 0, 1);
510			}
511
512
513			public function isLeader(): bool
514			{
515			return ($this->getTeam() !== null) && ($this->getTeam()->getLeader()->getId() === $this->getId());
516			}
517
518			public function getUrl(): string
519			{
520			return sprintf(
521			'%s-player-p%d/index',
522			$this->getSlug(),
523			$this->getId()
524			);
525			}
526			}
527

video-games-records / core-bundle

Player A last analyzed 2025-04-17 18:48 UTC

Complexity

Size/Duplication

Importance

39 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like

Player A
last analyzed 2025-04-17 18:48 UTC