Palladium\Entity\StandardIdentity

Complexity

Total Complexity

11

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setIdentifier()	0	4	1
A	getIdentifier()	0	4	1
A	getFingerprint()	0	4	1
A	setPassword()	0	5	1
A	rehashPassword()	0	4	1
A	getHash()	0	4	1
A	createHash()	0	4	1
A	setHash()	0	8	2
A	matchPassword()	0	4	1
A	hasOldHash()	0	4	1

<?php

namespace Palladium\Entity;

use RuntimeException;

class StandardIdentity extends Identity
{

    const HASH_ALGO = PASSWORD_BCRYPT;
    const HASH_COST = 12;

    private $identifier;
    private $password;
    private $hash;

    protected $type = Identity::TYPE_EMAIL;


    public function setIdentifier(string $identifier)
    {
        $this->identifier = strtolower($identifier);
    }


    /**
     * @codeCoverageIgnore
     */
    public function getIdentifier()
    {
        return $this->identifier;
    }


    public function getFingerprint(): string
    {
        return hash('sha384', $this->identifier);
    }


    public function setPassword($password, $cost = self::HASH_COST)
    {
        $this->password = (string) $password;
        $this->hash = $this->createHash($password, $cost);
    }


    public function rehashPassword($cost = self::HASH_COST)
    {
        $this->hash = $this->createHash($this->password, $cost);
    }

    /**
     * @codeCoverageIgnore
     */
    public function getHash()
    {
        return $this->hash;
    }


    private function createHash($password, int $cost): string
    {
        return password_hash($password, self::HASH_ALGO, ['cost' => $cost]);
    }


    public function setHash($hash)
    {
        if (null === $hash) {
            $this->hash = null;
            return;
        }
        $this->hash = (string) $hash;
    }


    public function matchPassword($password): bool
    {
        return password_verify($password, $this->hash);
    }


    public function hasOldHash($cost = self::HASH_COST): bool
    {
        return password_needs_rehash($this->hash, self::HASH_ALGO, ['cost' => $cost]);
    }
}