Graviton\AuditTrackingBundle\Manager\StoreManager

Complexity

Total Complexity

18

Size/Duplication

Total Lines	141
Duplicated Lines	6.38 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
B	persistEvents()	0	25	6
A	trackEvent()	0	13	2
A	generateUUID()	0	11	2
A	getSecurityUser()	9	9	3
A	getSecurityUsername()	0	16	4

<?php
/**
 * To manage the data to be saved into DB as last thing to do.
 */
namespace Graviton\AuditTrackingBundle\Manager;

use Doctrine\ODM\MongoDB\DocumentManager;
use Graviton\AuditTrackingBundle\Document\AuditTracking;
use Doctrine\Bundle\MongoDBBundle\ManagerRegistry;
use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
use Symfony\Component\Security\Core\Authentication\Token\PreAuthenticatedToken;
use Symfony\Component\Security\Core\User\UserInterface;
use Graviton\SecurityBundle\Entities\SecurityUser;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;

/**
 * Class StoreManager
 * @package Graviton\AuditTrackingBundle\Manager
 *
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class StoreManager
{
    const AUDIT_HEADER_KEY = 'x-header-audit-thread';

    /** @var ActivityManager */
    private $activityManager;

    /** @var DocumentManager */
    private $documentManager;
    
    /** @var SecurityUser */
    private $securityUser;

    /**
     * StoreManager constructor.
     * @param ActivityManager $activityManager Main activity manager
     * @param ManagerRegistry $doctrine        Doctrine document mapper
     * @param TokenStorage    $tokenStorage    Sf Auth token storage
     */
    public function __construct(
        ActivityManager $activityManager,
        ManagerRegistry $doctrine,
        TokenStorage $tokenStorage
    ) {
        $this->activityManager = $activityManager;
        $this->documentManager = $doctrine->getManager();
        $this->tokenStorage = $tokenStorage;
    }

    /**
     * Save data to DB
     * onKernelResponse
     *
     * @param FilterResponseEvent $event Sf fired kernel event
     *
     * @return void
     */
    public function persistEvents(FilterResponseEvent $event)
    {
        if (!($events = $this->activityManager->getEvents())
            || !($username = $this->getSecurityUsername())) {
            return;
        }

        $thread = $this->generateUUID();
        $response = $event->getResponse();
        
        // If request is valid we save it or we do not.
        if (!$this->activityManager->getConfigValue('log_on_failure', 'bool')) {
            if (!$response->isSuccessful()) {
                // TODO log that we do not save
                return;
            }
        }

        // Set Audit header information
        $response->headers->set(self::AUDIT_HEADER_KEY, $thread);

        foreach ($events as $event) {
            $this->trackEvent($event, $thread, $username);
        }
    }

    /**
     * Save the event to DB
     *
     * @param AuditTracking $event    Performed by user
     * @param string        $thread   The thread ID
     * @param string        $username User connected name
     * @return void
     */
    private function trackEvent($event, $thread, $username)
    {
        // Request information
        $event->setThread($thread);
        $event->setUsername($username);

        try {
            $this->documentManager->persist($event);
            $this->documentManager->flush($event);
        } catch (\Exception $e) {
            // TODO LOG the error and event
        }
    }



    /**
     * Generate a unique identifer
     *
     * @return string
     */
    private function generateUUID()
    {
        if (!function_exists('openssl_random_pseudo_bytes')) {
            return uniqid('unq', true);
        }

        $data = openssl_random_pseudo_bytes(16);
        $data[6] = chr(ord($data[6]) & 0x0f | 0x40);    // set version to 0100
        $data[8] = chr(ord($data[8]) & 0x3f | 0x80);    // set bits 6-7 to 10
        return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
    }
    
    /**
     * Find current user
     *
     * @return string|bool

Should the return type not be UserInterface|false?

     */
    private function getSecurityUser()

This method seems to be duplicated in your project.

    {
        /** @var PreAuthenticatedToken $token */
        if (($token = $this->tokenStorage->getToken())
            && ($user = $token->getUser()) instanceof UserInterface ) {
            return $user;
        }
        return false;
    }

    /**
     * Last check before saving the Event into DB
     *
     * @return bool|string

Consider making the return type a bit more specific; maybe use false|string.

     */
    public function getSecurityUsername()
    {
        // No securityUser, no tracking
        if (!($this->securityUser = $this->getSecurityUser())) {

It seems like $this->getSecurityUser() of type object<Symfony\Component\Security\Core\User\UserInterface> or false is incompatible with the declared type object<Graviton\SecurityBundle\Entities\SecurityUser> of property $securityUser.

            return false;
        }

        // Check if we wanna log test and localhost calls
        if (!$this->activityManager->getConfigValue('log_test_calls', 'bool')) {
            if (!$this->securityUser->hasRole(SecurityUser::ROLE_CONSULTANT)) {

It seems like you code against a concrete implementation and not the interface Symfony\Component\Security\Core\User\UserInterface as the method hasRole() does only exist in the following implementations of said interface: Graviton\SecurityBundle\Entities\SecurityUser.

                return false;
            }
        }

        return $this->securityUser->getUsername();
    }
}