AbstractUser::getOldPassword() - Code Metrics - Inspection of "User emails configured" - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — v2 ( 7ee84c...a408c1 )

by Daniel

created 2020-04-01 19:13 UTC

AbstractUser::getOldPassword() A

↳ Parent: AbstractUser

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
ccs	0
cts	2
cp	0
rs	10
cc	1
nc	1
nop	0
crap	2

<?php

/*
 * This file is part of the Silverback API Component Bundle Project
 *
 * (c) Daniel West <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Silverback\ApiComponentBundle\Entity\User;

use ApiPlatform\Core\Annotation\ApiProperty;
use DateTime;
use Doctrine\ORM\Mapping as ORM;
use Silverback\ApiComponentBundle\Entity\Utility\IdTrait;
use Silverback\ApiComponentBundle\Validator\Constraints as APIAssert;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Symfony\Component\Security\Core\User\UserInterface as SymfonyUserInterface;
use Symfony\Component\Security\Core\Validator\Constraints\UserPassword;
use Symfony\Component\Serializer\Annotation\Groups;
use Symfony\Component\Validator\Constraints as Assert;

/**
 * @ORM\MappedSuperclass(repositoryClass="Silverback\ApiComponentBundle\Repository\User\UserRepository")
 * @UniqueEntity(fields={"username"}, errorPath="username", message="Sorry, that user already exists in the database.")
 * @APIAssert\NewUsername(groups={"new_email_address", "Default"})
 */
abstract class AbstractUser implements SymfonyUserInterface
{
    use IdTrait;

    /**
     * @ORM\Column(type="string", length=255, unique=true)
     * @Assert\NotBlank(groups={"Default"})
     * @Groups({"admin"})
     */
    protected ?string $username;

    /**
     * @ORM\Column(type="string", length=255, unique=true)
     * @Assert\NotBlank(groups={"Default"})
     * @Assert\Email()
     * @Groups({"admin"})
     */
    protected ?string $emailAddress;

    /**
     * @ORM\Column(type="array")
     * @Groups({"super_admin"})
     */
    protected array $roles;

    /**
     * @ORM\Column(type="boolean")
     * @Groups({"super_admin"})
     */
    protected bool $enabled;

    /**
     * @ORM\Column(type="string", length=255)
     * @ApiProperty(readable=false, writable=false)
     */
    protected string $password;

    /**
     * @ApiProperty(readable=false)
     * @Assert\NotBlank(message="Please enter your desired password", groups={"password_reset", "change_password"})
     * @Assert\Length(max="4096", min="6", maxMessage="Your password cannot be over 4096 characters", minMessage="Your password must be more than 6 characters long", groups={"Default", "password_reset", "change_password"})
     * @Groups({"default_write"})
     */
    protected ?string $plainPassword = null;

    /**
     * Random string sent to the user email address in order to verify it.
     *
     * @ORM\Column(nullable=true)
     * @ApiProperty(readable=false, writable=false)
     */
    protected ?string $newPasswordConfirmationToken = null;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     * @ApiProperty(readable=false, writable=false)
     */
    protected ?DateTime $passwordRequestedAt = null;

    /**
     * @ApiProperty(readable=false)
     * @UserPassword(message="You have not entered your current password correctly. Please try again.", groups={"change_password"})
     * @Groups({"default_write"})
     */
    protected ?string $oldPassword = null;

    /**
     * @ApiProperty(readable=false, writable=false)
     * @ORM\Column(type="datetime", nullable=true)
     */
    protected ?DateTime $passwordLastUpdated = null;

    /**
     * @ORM\Column(type="string", length=255, nullable=true)
     * @Assert\NotBlank(groups={"new_email_address"})
     * @Groups({"default", "new_email_address"})
     */
    protected ?string $newEmailAddress = null;

    /**
     * Random string sent to the user's new email address in order to verify it.
     *
     * @ORM\Column(nullable=true)
     * @ApiProperty(readable=false, writable=false)
     */
    protected ?string $newEmailConfirmationToken = null;

    /**
     * @ORM\Column(type="boolean")
     * @ApiProperty(readable=false, writable=false)
     */
    protected ?bool $emailAddressVerified = false;

    public function __construct(
        string $username = '',
        string $emailAddress = '',
        array $roles = ['ROLE_USER'],
        string $password = '',
        bool $enabled = true
    ) {
        $this->username = $username;
        $this->emailAddress = $emailAddress;
        $this->roles = $roles;
        $this->password = $password;
        $this->enabled = $enabled;
        $this->setId();
    }

    public function getUsername(): ?string
    {
        return $this->username;
    }

    public function setUsername(?string $username): self
    {
        $this->username = $username;

        return $this;
    }

    public function getEmailAddress(): ?string
    {
        return $this->emailAddress;
    }

    public function setEmailAddress(?string $emailAddress): self
    {
        $this->emailAddress = $emailAddress;

        return $this;
    }

    public function getRoles(): array
    {
        return $this->roles;
    }

    public function setRoles(?array $roles): self
    {
        $this->roles = $roles;

        return $this;
    }

    public function isEnabled(): bool
    {
        return $this->enabled;
    }

    public function setEnabled(bool $enabled): self
    {
        $this->enabled = $enabled;

        return $this;
    }

    public function getPassword(): ?string
    {
        return $this->password;
    }

    public function setPassword(string $password): self
    {
        $this->password = $password;

        return $this;
    }

    public function getPlainPassword(): ?string
    {
        return $this->plainPassword;
    }

    public function setPlainPassword(?string $plainPassword): self
    {
        $this->plainPassword = $plainPassword;
        if ($plainPassword) {
            // Needs to update mapped field to trigger update event which will encode the plain password
            $this->passwordLastUpdated = new \DateTime();
        }

        return $this;
    }

    public function getNewPasswordConfirmationToken(): ?string
    {
        return $this->newPasswordConfirmationToken;
    }

    public function setNewPasswordConfirmationToken(?string $newPasswordConfirmationToken): self
    {
        $this->newPasswordConfirmationToken = $newPasswordConfirmationToken;

        return $this;
    }

    public function getPasswordRequestedAt(): ?DateTime
    {
        return $this->passwordRequestedAt;
    }

    public function setPasswordRequestedAt(?DateTime $passwordRequestedAt): self
    {
        $this->passwordRequestedAt = $passwordRequestedAt;

        return $this;
    }

    public function getOldPassword(): ?string
    {
        return $this->oldPassword;
    }

    public function setOldPassword(?string $oldPassword): void
    {
        $this->oldPassword = $oldPassword;
    }

    public function getNewEmailAddress(): ?string
    {
        return $this->newEmailAddress;
    }

    public function setNewEmailAddress(?string $newEmailAddress): self
    {
        $this->newEmailAddress = $newEmailAddress;

        return $this;
    }

    public function getNewEmailConfirmationToken(): ?string
    {
        return $this->newEmailConfirmationToken;
    }

    public function setNewEmailConfirmationToken(?string $newEmailConfirmationToken): self
    {
        $this->newEmailConfirmationToken = $newEmailConfirmationToken;

        return $this;
    }

    public function isEmailAddressVerified(): ?bool
    {
        return $this->emailAddressVerified;
    }

    public function setEmailAddressVerified(?bool $emailAddressVerified): self
    {
        $this->emailAddressVerified = $emailAddressVerified;

        return $this;
    }

    public function isPasswordRequestLimitReached($ttl): bool
    {
        $lastRequest = $this->getPasswordRequestedAt();

        return $lastRequest instanceof DateTime &&
            $lastRequest->getTimestamp() + $ttl > time();
    }

    /** @see \Serializable::serialize() */
    public function serialize(): string
    {
        return serialize([
            $this->id,
            $this->username,
            $this->password,
            $this->enabled,
        ]);
    }

    /**
     * @see \Serializable::unserialize()
     *
     * @param string $serialized
     */
    public function unserialize($serialized): void
    {
        [
            $this->id,
            $this->username,
            $this->password,
            $this->enabled
        ] = unserialize($serialized, ['allowed_classes' => false]);
    }

    /**
     * Not needed - we use bcrypt.
     *
     * @ApiProperty(readable=false, writable=false)
     */
    public function getSalt()
    {
    }

    /**
     * Remove sensitive data - e.g. plain passwords etc.
     */
    public function eraseCredentials(): void
    {
        $this->plainPassword = null;
    }

    public function __toString()
    {
        return (string) $this->id;
    }
}


1			<?php
2
3			/*
4			* This file is part of the Silverback API Component Bundle Project
5			*
6			* (c) Daniel West <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace Silverback\ApiComponentBundle\Entity\User;
15
16			use ApiPlatform\Core\Annotation\ApiProperty;
17			use DateTime;
18			use Doctrine\ORM\Mapping as ORM;
19			use Silverback\ApiComponentBundle\Entity\Utility\IdTrait;
20			use Silverback\ApiComponentBundle\Validator\Constraints as APIAssert;
21			use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
22			use Symfony\Component\Security\Core\User\UserInterface as SymfonyUserInterface;
23			use Symfony\Component\Security\Core\Validator\Constraints\UserPassword;
24			use Symfony\Component\Serializer\Annotation\Groups;
25			use Symfony\Component\Validator\Constraints as Assert;
26
27			/**
28			* @ORM\MappedSuperclass(repositoryClass="Silverback\ApiComponentBundle\Repository\User\UserRepository")
29			* @UniqueEntity(fields={"username"}, errorPath="username", message="Sorry, that user already exists in the database.")
30			* @APIAssert\NewUsername(groups={"new_email_address", "Default"})
31			*/
32			abstract class AbstractUser implements SymfonyUserInterface
33			{
34			use IdTrait;
35
36			/**
37			* @ORM\Column(type="string", length=255, unique=true)
38			* @Assert\NotBlank(groups={"Default"})
39			* @Groups({"admin"})
40			*/
41			protected ?string $username;
42
43			/**
44			* @ORM\Column(type="string", length=255, unique=true)
45			* @Assert\NotBlank(groups={"Default"})
46			* @Assert\Email()
47			* @Groups({"admin"})
48			*/
49			protected ?string $emailAddress;
50
51			/**
52			* @ORM\Column(type="array")
53			* @Groups({"super_admin"})
54			*/
55			protected array $roles;
56
57			/**
58			* @ORM\Column(type="boolean")
59			* @Groups({"super_admin"})
60			*/
61			protected bool $enabled;
62
63			/**
64			* @ORM\Column(type="string", length=255)
65			* @ApiProperty(readable=false, writable=false)
66			*/
67			protected string $password;
68
69			/**
70			* @ApiProperty(readable=false)
71			* @Assert\NotBlank(message="Please enter your desired password", groups={"password_reset", "change_password"})
72			* @Assert\Length(max="4096", min="6", maxMessage="Your password cannot be over 4096 characters", minMessage="Your password must be more than 6 characters long", groups={"Default", "password_reset", "change_password"})
73			* @Groups({"default_write"})
74			*/
75			protected ?string $plainPassword = null;
76
77			/**
78			* Random string sent to the user email address in order to verify it.
79			*
80			* @ORM\Column(nullable=true)
81			* @ApiProperty(readable=false, writable=false)
82			*/
83			protected ?string $newPasswordConfirmationToken = null;
84
85			/**
86			* @ORM\Column(type="datetime", nullable=true)
87			* @ApiProperty(readable=false, writable=false)
88			*/
89			protected ?DateTime $passwordRequestedAt = null;
90
91			/**
92			* @ApiProperty(readable=false)
93			* @UserPassword(message="You have not entered your current password correctly. Please try again.", groups={"change_password"})
94			* @Groups({"default_write"})
95			*/
96			protected ?string $oldPassword = null;
97
98			/**
99			* @ApiProperty(readable=false, writable=false)
100			* @ORM\Column(type="datetime", nullable=true)
101			*/
102			protected ?DateTime $passwordLastUpdated = null;
103
104			/**
105			* @ORM\Column(type="string", length=255, nullable=true)
106			* @Assert\NotBlank(groups={"new_email_address"})
107			* @Groups({"default", "new_email_address"})
108			*/
109			protected ?string $newEmailAddress = null;
110
111			/**
112			* Random string sent to the user's new email address in order to verify it.
113			*
114			* @ORM\Column(nullable=true)
115			* @ApiProperty(readable=false, writable=false)
116			*/
117			protected ?string $newEmailConfirmationToken = null;
118
119			/**
120			* @ORM\Column(type="boolean")
121			* @ApiProperty(readable=false, writable=false)
122			*/
123			protected ?bool $emailAddressVerified = false;
124
125			public function __construct(
126			string $username = '',
127			string $emailAddress = '',
128			array $roles = ['ROLE_USER'],
129			string $password = '',
130			bool $enabled = true
131			) {
132			$this->username = $username;
133			$this->emailAddress = $emailAddress;
134			$this->roles = $roles;
135			$this->password = $password;
136			$this->enabled = $enabled;
137			$this->setId();
138			}
139
140			public function getUsername(): ?string
141			{
142			return $this->username;
143			}
144
145			public function setUsername(?string $username): self
146			{
147			$this->username = $username;
148
149			return $this;
150			}
151
152			public function getEmailAddress(): ?string
153			{
154			return $this->emailAddress;
155			}
156
157			public function setEmailAddress(?string $emailAddress): self
158			{
159			$this->emailAddress = $emailAddress;
160
161			return $this;
162			}
163
164			public function getRoles(): array
165			{
166			return $this->roles;
167			}
168
169			public function setRoles(?array $roles): self
170			{
171			$this->roles = $roles;
172
173			return $this;
174			}
175
176			public function isEnabled(): bool
177			{
178			return $this->enabled;
179			}
180
181			public function setEnabled(bool $enabled): self
182			{
183			$this->enabled = $enabled;
184
185			return $this;
186			}
187
188			public function getPassword(): ?string
189			{
190			return $this->password;
191			}
192
193			public function setPassword(string $password): self
194			{
195			$this->password = $password;
196
197			return $this;
198			}
199
200			public function getPlainPassword(): ?string
201			{
202			return $this->plainPassword;
203			}
204
205			public function setPlainPassword(?string $plainPassword): self
206			{
207			$this->plainPassword = $plainPassword;
208			if ($plainPassword) {
209			// Needs to update mapped field to trigger update event which will encode the plain password
210			$this->passwordLastUpdated = new \DateTime();
211			}
212
213			return $this;
214			}
215
216			public function getNewPasswordConfirmationToken(): ?string
217			{
218			return $this->newPasswordConfirmationToken;
219			}
220
221			public function setNewPasswordConfirmationToken(?string $newPasswordConfirmationToken): self
222			{
223			$this->newPasswordConfirmationToken = $newPasswordConfirmationToken;
224
225			return $this;
226			}
227
228			public function getPasswordRequestedAt(): ?DateTime
229			{
230			return $this->passwordRequestedAt;
231			}
232
233			public function setPasswordRequestedAt(?DateTime $passwordRequestedAt): self
234			{
235			$this->passwordRequestedAt = $passwordRequestedAt;
236
237			return $this;
238			}
239
240			public function getOldPassword(): ?string
241			{
242			return $this->oldPassword;
243			}
244
245			public function setOldPassword(?string $oldPassword): void
246			{
247			$this->oldPassword = $oldPassword;
248			}
249
250			public function getNewEmailAddress(): ?string
251			{
252			return $this->newEmailAddress;
253			}
254
255			public function setNewEmailAddress(?string $newEmailAddress): self
256			{
257			$this->newEmailAddress = $newEmailAddress;
258
259			return $this;
260			}
261
262			public function getNewEmailConfirmationToken(): ?string
263			{
264			return $this->newEmailConfirmationToken;
265			}
266
267			public function setNewEmailConfirmationToken(?string $newEmailConfirmationToken): self
268			{
269			$this->newEmailConfirmationToken = $newEmailConfirmationToken;
270
271			return $this;
272			}
273
274			public function isEmailAddressVerified(): ?bool
275			{
276			return $this->emailAddressVerified;
277			}
278
279			public function setEmailAddressVerified(?bool $emailAddressVerified): self
280			{
281			$this->emailAddressVerified = $emailAddressVerified;
282
283			return $this;
284			}
285
286			public function isPasswordRequestLimitReached($ttl): bool
287			{
288			$lastRequest = $this->getPasswordRequestedAt();
289
290			return $lastRequest instanceof DateTime &&
291			$lastRequest->getTimestamp() + $ttl > time();
292			}
293
294			/** @see \Serializable::serialize() */
295			public function serialize(): string
296			{
297			return serialize([
298			$this->id,
299			$this->username,
300			$this->password,
301			$this->enabled,
302			]);
303			}
304
305			/**
306			* @see \Serializable::unserialize()
307			*
308			* @param string $serialized
309			*/
310			public function unserialize($serialized): void
311			{
312			[
313			$this->id,
314			$this->username,
315			$this->password,
316			$this->enabled
317			] = unserialize($serialized, ['allowed_classes' => false]);
318			}
319
320			/**
321			* Not needed - we use bcrypt.
322			*
323			* @ApiProperty(readable=false, writable=false)
324			*/
325			public function getSalt()
326			{
327			}
328
329			/**
330			* Remove sensitive data - e.g. plain passwords etc.
331			*/
332			public function eraseCredentials(): void
333			{
334			$this->plainPassword = null;
335			}
336
337			public function __toString()
338			{
339			return (string) $this->id;
340			}
341			}
342

components-web-app / api-components-bundle

Push — v2 ( 7ee84c...a408c1 )

AbstractUser::getOldPassword() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like