Surfnet\StepupMiddleware\ApiBundle\Identity\Projector\AuditLogProjector

Complexity

Total Complexity

23

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	handle()	0	13	3
A	augmentActorCommonName()	0	5	3
A	applyIdentityForgottenEvent()	0	20	4
A	__construct()	0	4	1
C	applyAuditableEvent()	0	63	12

<?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.
 */

Missing @link tag in file comment

namespace Surfnet\StepupMiddleware\ApiBundle\Identity\Projector;

use Broadway\Domain\DomainMessage;
use DateTime as CoreDateTime;
use Ramsey\Uuid\Uuid;
use Surfnet\Stepup\DateTime\DateTime;
use Surfnet\Stepup\Identity\AuditLog\Metadata;
use Surfnet\Stepup\Identity\Event\AuditableEvent;
use Surfnet\Stepup\Identity\Event\CompliedWithRecoveryCodeRevocationEvent;
use Surfnet\Stepup\Identity\Event\IdentityForgottenEvent;
use Surfnet\Stepup\Identity\Event\RecoveryTokenRevokedEvent;
use Surfnet\Stepup\Identity\Value\CommonName;
use Surfnet\Stepup\Identity\Value\Institution;
use Surfnet\Stepup\Identity\Value\RecoveryTokenIdentifierFactory;
use Surfnet\Stepup\Identity\Value\RecoveryTokenType;
use Surfnet\Stepup\Identity\Value\VettingType;
use Surfnet\Stepup\Projector\Projector;
use Surfnet\StepupMiddleware\ApiBundle\Exception\RuntimeException;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\AuditLogEntry;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\Identity;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Repository\AuditLogRepository;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Repository\IdentityRepository;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */

Missing @category tag in class comment

Missing @package tag in class comment

Missing @author tag in class comment

Missing @license tag in class comment

Missing @link tag in class comment

class AuditLogProjector extends Projector
{
    public function __construct(
        private readonly AuditLogRepository $auditLogRepository,
        private readonly IdentityRepository $identityRepository,
    ) {
    }

    /**
     * @param DomainMessage $domainMessage
     */

Missing @return tag in function comment

    public function handle(DomainMessage $domainMessage): void
    {
        $event = $domainMessage->getPayload();

        switch (true) {
            case $event instanceof IdentityForgottenEvent:

Line indented incorrectly; expected 8 spaces, found 12

                // Don't insert the IdentityForgottenEvent into the audit log, as we'd remove it immediately afterwards.
                $this->applyIdentityForgottenEvent($event);
                break;
            // Finally apply the auditable event, most events are auditable this so first handle the unique variants
            case $event instanceof AuditableEvent:

Line indented incorrectly; expected 8 spaces, found 12

                $this->applyAuditableEvent($event, $domainMessage);
                break;
        }
    }

    /**

Parameter $event should have a doc-comment as per coding-style.

Parameter $domainMessage should have a doc-comment as per coding-style.

     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.NPathComplexity)
     */

Missing @return tag in function comment

    private function applyAuditableEvent(AuditableEvent $event, DomainMessage $domainMessage): void

Private method name "AuditLogProjector::applyAuditableEvent" must be prefixed with an underscore

    {
        $auditLogMetadata = $event->getAuditLogMetadata();

        $metadata = $domainMessage->getMetadata()->serialize();
        $entry = new AuditLogEntry();
        $entry->id = (string)Uuid::uuid4();

        if (isset($metadata['actorId'])) {
            $actor = $this->identityRepository->find($metadata['actorId']);

            if (!$actor instanceof Identity) {
                throw new RuntimeException(
                    sprintf(
                        'Cannot create AuditLogEntry, given Actor Identity "%s" does not exist',
                        $metadata['actorId'],
                    ),
                );
            }

            $entry->actorId = $metadata['actorId'];
            $entry->actorCommonName = $actor->commonName;
        }

        $this->augmentActorCommonName($entry, $auditLogMetadata);

        if (isset($metadata['actorInstitution'])) {
            $entry->actorInstitution = new Institution($metadata['actorInstitution']);
        }

        $entry->identityId = (string)$auditLogMetadata->identityId;
        $entry->identityInstitution = $auditLogMetadata->identityInstitution;
        $entry->event = $event::class;
        $entry->recordedOn = new DateTime(new CoreDateTime($domainMessage->getRecordedOn()->toString()));

        if ($auditLogMetadata->secondFactorId instanceof \Surfnet\Stepup\Identity\Value\SecondFactorId) {
            $entry->secondFactorId = (string)$auditLogMetadata->secondFactorId;
        }

        if ($auditLogMetadata->secondFactorType instanceof \Surfnet\StepupBundle\Value\SecondFactorType) {
            $entry->secondFactorType = (string)$auditLogMetadata->secondFactorType;
        }

        if (!$event instanceof RecoveryTokenRevokedEvent
            && !$event instanceof CompliedWithRecoveryCodeRevocationEvent
            && $auditLogMetadata->recoveryTokenId
        ) {
            $entry->recoveryTokenIdentifier = (string)$auditLogMetadata->recoveryTokenId;
        }

        if ($auditLogMetadata->recoveryTokenType instanceof \Surfnet\Stepup\Identity\Value\RecoveryTokenType) {
            $entry->recoveryTokenType = (string)$auditLogMetadata->recoveryTokenType;
        }

        if ($auditLogMetadata->secondFactorIdentifier instanceof \Surfnet\Stepup\Identity\Value\SecondFactorIdentifier) {
            $entry->secondFactorIdentifier = (string)$auditLogMetadata->secondFactorIdentifier;
        }

        if ($auditLogMetadata->raInstitution instanceof \Surfnet\Stepup\Identity\Value\Institution) {
            $entry->raInstitution = (string)$auditLogMetadata->raInstitution;
        }

        $this->auditLogRepository->save($entry);
    }

    protected function applyIdentityForgottenEvent(IdentityForgottenEvent $event): void
    {
        $entries = $this->auditLogRepository->findByIdentityId($event->identityId);
        foreach ($entries as $auditLogEntry) {
            $auditLogEntry->actorCommonName = CommonName::unknown();

            if ($auditLogEntry->recoveryTokenIdentifier) {
                $auditLogEntry->recoveryTokenIdentifier = RecoveryTokenIdentifierFactory::unknownForType(
                    new RecoveryTokenType($auditLogEntry->recoveryTokenType),
                );
            }
        }

        $entriesWhereActor = $this->auditLogRepository->findEntriesWhereIdentityIsActorOnly($event->identityId);
        foreach ($entriesWhereActor as $auditLogEntry) {
            $auditLogEntry->actorCommonName = CommonName::unknown();
        }

        $this->auditLogRepository->saveAll($entries);
        $this->auditLogRepository->saveAll($entriesWhereActor);
    }

    private function augmentActorCommonName(AuditLogEntry $entry, Metadata $auditLogMetadata): void

Private method name "AuditLogProjector::augmentActorCommonName" must be prefixed with an underscore

    {
        if (property_exists($auditLogMetadata, 'vettingType') && $auditLogMetadata->vettingType instanceof VettingType) {
            $entry->actorCommonName = new CommonName(
                $entry->actorCommonName->getCommonName() . $auditLogMetadata->vettingType->auditLog()

The method getCommonName() does not exist on null.

            );
        }
    }
}