Surfnet\Stepup\Identity\Entity\VerifiedSecondFactor

Complexity

Total Complexity

13

Size/Duplication

Total Lines	169
Duplicated Lines	27.81 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	22	22	2
A	__construct()	0	3	1
A	getId()	0	4	1
A	hasRegistrationCodeAndIdentifier()	0	5	2
A	canBeVettedNow()	0	8	1
A	vet()	0	17	1
A	revoke()	12	12	1
A	complyWithRevocation()	13	13	1
A	asVetted()	0	9	1
A	applyIdentityForgottenEvent()	0	6	1
A	getType()	0	4	1

<?php

/**
 * Copyright 2014 SURFnet bv
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Surfnet\Stepup\Identity\Entity;

use Surfnet\Stepup\DateTime\DateTime;
use Surfnet\Stepup\Exception\InvalidArgumentException;
use Surfnet\Stepup\Identity\Api\Identity;
use Surfnet\Stepup\Identity\Event\CompliedWithVerifiedSecondFactorRevocationEvent;
use Surfnet\Stepup\Identity\Event\IdentityForgottenEvent;
use Surfnet\Stepup\Identity\Event\SecondFactorVettedEvent;
use Surfnet\Stepup\Identity\Event\VerifiedSecondFactorRevokedEvent;
use Surfnet\Stepup\Identity\Value\DocumentNumber;
use Surfnet\Stepup\Identity\Value\IdentityId;
use Surfnet\Stepup\Identity\Value\SecondFactorId;
use Surfnet\Stepup\Identity\Value\SecondFactorIdentifier;
use Surfnet\Stepup\Identity\Value\SecondFactorIdentifierFactory;
use Surfnet\StepupBundle\Value\SecondFactorType;

/**
 * A second factor whose possession has been proven by the registrant and the registrant's e-mail address has been
 * verified. The registrant must visit a registration authority next.
 *
 * @SuppressWarnings(PHPMD.UnusedPrivateFields)
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class VerifiedSecondFactor extends AbstractSecondFactor
{
    /**
     * @var \Surfnet\Stepup\Identity\Value\SecondFactorId
     */
    private $id;

    /**
     * @var \Surfnet\Stepup\Identity\Api\Identity
     */
    private $identity;

    /**
     * @var \Surfnet\StepupBundle\Value\SecondFactorType
     */
    private $type;

    /**
     * @var \Surfnet\Stepup\Identity\Value\SecondFactorIdentifier
     */
    private $secondFactorIdentifier;

    /**
     * @var \Surfnet\Stepup\DateTime\DateTime
     */
    private $registrationRequestedAt;

    /**
     * @var string
     */
    private $registrationCode;

    /**
     * @param SecondFactorId $id
     * @param Identity $identity
     * @param SecondFactorType $type
     * @param SecondFactorIdentifier $secondFactorIdentifier
     * @param DateTime $registrationRequestedAt
     * @param string $registrationCode
     * @return self
     */
    public static function create(

This method seems to be duplicated in your project.

        SecondFactorId $id,
        Identity $identity,
        SecondFactorType $type,
        SecondFactorIdentifier $secondFactorIdentifier,
        DateTime $registrationRequestedAt,
        $registrationCode
    ) {
        if (!is_string($registrationCode)) {
            throw InvalidArgumentException::invalidType('string', 'registrationCode', $registrationCode);
        }

        $secondFactor = new self;
        $secondFactor->id = $id;
        $secondFactor->identity = $identity;
        $secondFactor->type = $type;
        $secondFactor->secondFactorIdentifier = $secondFactorIdentifier;
        $secondFactor->registrationRequestedAt = $registrationRequestedAt;
        $secondFactor->registrationCode = $registrationCode;

        return $secondFactor;
    }

    final private function __construct()

Instead of declaring the constructor as final, maybe you should declare the entire class as final.

    {
    }

    /**
     * @return SecondFactorId
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @param string $registrationCode
     * @param SecondFactorIdentifier $secondFactorIdentifier
     * @return bool
     */
    public function hasRegistrationCodeAndIdentifier($registrationCode, SecondFactorIdentifier $secondFactorIdentifier)
    {
        return strcasecmp($registrationCode, $this->registrationCode) === 0
            && $secondFactorIdentifier->equals($this->secondFactorIdentifier);
    }

    /**
     * @return bool
     */
    public function canBeVettedNow()
    {
        return !DateTime::now()->comesAfter(
            $this->registrationRequestedAt
                ->add(new \DateInterval('P14D'))
                ->endOfDay()
        );
    }

    public function vet(DocumentNumber $documentNumber)
    {
        $this->apply(
            new SecondFactorVettedEvent(
                $this->identity->getId(),
                $this->identity->getNameId(),
                $this->identity->getInstitution(),
                $this->id,
                $this->type,
                $this->secondFactorIdentifier,
                $documentNumber,
                $this->identity->getCommonName(),
                $this->identity->getEmail(),
                $this->identity->getPreferredLocale()
            )
        );
    }

    public function revoke()

This method seems to be duplicated in your project.

    {
        $this->apply(
            new VerifiedSecondFactorRevokedEvent(
                $this->identity->getId(),
                $this->identity->getInstitution(),
                $this->id,
                $this->type,
                $this->secondFactorIdentifier
            )
        );
    }

    public function complyWithRevocation(IdentityId $authorityId)

This method seems to be duplicated in your project.

    {
        $this->apply(
            new CompliedWithVerifiedSecondFactorRevocationEvent(
                $this->identity->getId(),
                $this->identity->getInstitution(),
                $this->id,
                $this->type,
                $this->secondFactorIdentifier,
                $authorityId
            )
        );
    }

    /**
     * @return VettedSecondFactor
     */
    public function asVetted()
    {
        return VettedSecondFactor::create(
            $this->id,
            $this->identity,
            $this->type,
            $this->secondFactorIdentifier
        );
    }

    protected function applyIdentityForgottenEvent(IdentityForgottenEvent $event)

The parameter $event is not used and could be removed.

    {
        $secondFactorIdentifierClass = get_class($this->secondFactorIdentifier);

        $this->secondFactorIdentifier = $secondFactorIdentifierClass::unknown();
    }

    public function getType()
    {
        return $this->type;
    }
}