Palladium\Service\Registration

Complexity

Total Complexity

7

Size/Duplication

Total Lines	121
Duplicated Lines	5.79 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	7	7	1
B	createStandardIdentity()	0	24	2
A	createNonceIdentity()	0	21	1
A	prepareNewIdentity()	0	6	1
A	bindAccountToIdentity()	0	12	1
A	verifyStandardIdentity()	0	17	1

<?php

namespace Palladium\Service;

/**
 * Code for creating new identities
 */

use Palladium\Entity as Entity;
use Palladium\Component\DataMapper;
use Palladium\Exception\IdentityConflict;

use Palladium\Repository\Identity as Repository;
use Palladium\Contract\HasId;
use Psr\Log\LoggerInterface;

class Registration
{

    const DEFAULT_TOKEN_LIFESPAN = 28800; // 8 hours
    const DEFAULT_NONCE_LIFESPAN = 7200; // 2 hours
    const DEFAULT_HASH_COST = 12;

    private $repository;
    private $logger;
    private $hashCost;

    /**
     * @param Palladium\Repository\Identity $repository Repository for abstracting persistence layer structures
     * @param Psr\Log\LoggerInterface $logger PSR-3 compatible logger
     * @param int $hashCost Optional value for setting the cost of hashing algorythm (default: 12)
     */
    public function __construct(Repository $repository, DataMapper $accountMapper, LoggerInterface $logger, $hashCost = self::DEFAULT_HASH_COST)

This method seems to be duplicated in your project.

    {
        $this->repository = $repository;
        $this->accountMapper = $accountMapper;

The property accountMapper does not exist. Did you maybe forget to declare it?

        $this->logger = $logger;
        $this->hashCost = $hashCost;
    }


    /**
     * @param string $identifier
     * @param string $password
     * @param int $tokenLifespan
     *
     * @return Palladium\Entity\StandardIdentity
     */
    public function createStandardIdentity(string $identifier, string $password, $tokenLifespan = self::DEFAULT_TOKEN_LIFESPAN)
    {
        $identity = new Entity\StandardIdentity;

        $identity->setIdentifier($identifier);
        $identity->setPassword($password, $this->hashCost);
        $identity->setTokenEndOfLife(time() + $tokenLifespan);

        $this->prepareNewIdentity($identity);

        if ($this->repository->has($identity)) {
            $this->logger->notice('identifier already registered', [
                'input' => [
                    'identifier' => $identifier,
                ],
            ]);

            throw new IdentityConflict;
        }

        $this->repository->save($identity);

        return $identity;
    }


    public function createNonceIdentity($accountId, $identityLifespan = self::DEFAULT_NONCE_LIFESPAN)
    {
        $identity = new Entity\NonceIdentity;

        $identity->setAccountId($accountId);
        $identity->setExpiresOn(time() + $identityLifespan);
        $identity->setStatus(Entity\Identity::STATUS_ACTIVE);
        $identity->generateNewNonce();
        $identity->generateNewKey($this->hashCost);

        $this->repository->save($identity);

        $this->logger->info('new single-use identity created', [
            'user' => [
                'account' => $identity->getAccountId(),
                'identity' => $identity->getId(),
            ],
        ]);

        return $identity;
    }


    private function prepareNewIdentity(Entity\StandardIdentity $identity)
    {
        $identity->setStatus(Entity\Identity::STATUS_NEW);
        $identity->generateToken();
        $identity->setTokenAction(Entity\Identity::ACTION_VERIFY);
    }


    public function bindAccountToIdentity(int $accountId, Entity\Identity $identity)
    {
        $identity->setAccountId($accountId);
        $this->accountMapper->store($identity);

        $this->logger->info('new identifier registered', [
            'user' => [
                'account' => $identity->getAccountId(),
                'identity' => $identity->getId(),
            ],
        ]);
    }


    public function verifyStandardIdentity(Entity\StandardIdentity $identity)
    {
        $identity->setStatus(Entity\Identity::STATUS_ACTIVE);
        $identity->clearToken();

        $this->repository->save($identity);

        $this->logger->info('identity verified', [
            'input' => [
                'token' => $identity->getToken(),
            ],
            'user' => [
                'account' => $identity->getAccountId(),
                'identity' => $identity->getId(),
            ],
        ]);
    }
}