Azine\HybridAuthBundle\Services\AzineHybridAuth

Complexity

Total Complexity

33

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

14.85%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	2
D	getInstance()	0	49	13
A	storeHybridAuthSessionData()	0	10	2
A	deleteSession()	0	10	3
A	saveAuthSessionData()	0	19	4
A	getCookieName()	0	4	1
A	getProvider()	0	9	3
A	isConnected()	0	8	1
A	getLinkedIn()	0	4	1
A	getLinkedInApi()	0	4	1
A	isExpiredSession()	0	8	2

<?php

namespace Azine\HybridAuthBundle\Services;

use Azine\HybridAuthBundle\DependencyInjection\AzineHybridAuthExtension;
use Azine\HybridAuthBundle\Entity\HybridAuthSessionData;
use Doctrine\Common\Persistence\ObjectManager;
use Hybridauth\Hybridauth;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\User\UserInterface;

class AzineHybridAuth
{
    /**
     * ID of the sessionDataCookie.
     */
    const cookieName = 'azine_hybridauth_session';

    /**
     * @var ObjectManager
     */
    private $objectManager;

    /**
     * @var UserInterface
     */
    private $currentUser;

    /**
     * @var bool
     */
    private $storeForUser;

    /**
     * @var bool
     */
    private $storeAsCookie;

    /**
     * @var int
     */
    private $expiresInDays;

    /**
     * Configured Instances of HybridAuth.
     *
     * @var array or HybridAuth
     */
    private $instances = array();

    /**
     * HybridAuth configuration.
     *
     * @var array
     */
    private $config;

    /**
     * @param UrlGeneratorInterface $router
     * @param TokenStorageInterface $tokenStorage
     * @param ObjectManager         $manager
     * @param array                 $config
     * @param bool                  $storeForUser
     * @param $storeAsCookie
     * @param $expiresInDays
     */
    public function __construct(UrlGeneratorInterface $router, TokenStorageInterface $tokenStorage, ObjectManager $manager, $config, $storeForUser, $storeAsCookie, $expiresInDays)
    {
        $base_url = $router->generate($config[AzineHybridAuthExtension::ENDPOINT_ROUTE], array(), UrlGeneratorInterface::ABSOLUTE_URL);
        $config[AzineHybridAuthExtension::BASE_URL] = $base_url;
        $this->config = $config;
        $this->config['callback'] = $base_url;
        $this->objectManager = $manager;
        $this->storeForUser = $storeForUser;
        $this->storeAsCookie = $storeAsCookie;
        $user = $tokenStorage->getToken()->getUser();
        if ($user instanceof UserInterface) {
            $this->currentUser = $user;
        }
        $this->expiresInDays = $expiresInDays;
    }

    /**
     * Get a AdapterInterface instance initialised for the given provider.
     * HybridAuthSessions will be restored from DB and/or cookies, according to the bundle configuration.
     *
     * @param $cookieSessionData
     * @param $provider
     *
     * @return \Hybridauth\Adapter\AdapterInterface
     */
    public function getInstance($cookieSessionData, $provider)
    {
        if (array_key_exists($provider, $this->instances)) {
            $hybridAuth = $this->instances[$provider];

$hybridAuth is not used, you could remove the assignment.

        } else {
            $hybridAuth = new Hybridauth($this->config);
            $this->instances[$provider] = $hybridAuth;
        }

        $adapter = $this->instances[$provider]->getAdapter($provider);

        $restoredFromDB = false;
        $sessionData = null;
        $isExpiredSession = false;

        $result = null;
        if ($this->currentUser instanceof UserInterface) {
            $result = $this->objectManager->getRepository('AzineHybridAuthBundle:HybridAuthSessionData')->findOneBy(array('username' => $this->currentUser->getUsername(), 'provider' => $provider));
        }

        if ($result instanceof HybridAuthSessionData) {
            $isExpiredSession = $this->isExpiredSession($result);
        }

        if ($isExpiredSession) {
            $this->deleteSession($provider);
        }

        if (!$isExpiredSession && $this->storeForUser && $this->currentUser instanceof UserInterface) {
            // try from database
            if ($result) {
                $sessionData = $result->getSessionData();
                $restoredFromDB = true;
            }
        }
        if (null === $sessionData && null !== $cookieSessionData) {
            // try from cookie
            $sessionData = gzinflate($cookieSessionData);

            // user is looged in but auth session is not yet stored in db => store now
            if (!$restoredFromDB) {
                $this->saveAuthSessionData($sessionData, $provider);
            }
        }
        if ($sessionData) {

            $adapter->setAccessToken(json_decode($sessionData, true));
        }
        return $adapter;
    }

    /**
     * @param Request $request
     * @param $provider
     * @param $sessionData
     *
     * @return Cookie | null
     */
    public function storeHybridAuthSessionData(Request $request, $provider, $sessionData)
    {
        $this->saveAuthSessionData($sessionData, $provider);

        if ($this->storeAsCookie) {
            return new Cookie($this->getCookieName($provider), gzdeflate($sessionData), new \DateTime($this->expiresInDays.' days'), '/', $request->getHost(), $request->isSecure(), true);

new \DateTime($this->expiresInDays . ' days') is of type object<DateTime>, but the function expects a integer.

        }

        return null;
    }

    /**
     * Delete the HybridAuthSessionData entity from the database.
     *
     * @param $provider
     */
    public function deleteSession($provider)
    {
        if ($this->currentUser instanceof UserInterface) {
            $result = $this->objectManager->getRepository('AzineHybridAuthBundle:HybridAuthSessionData')->findOneBy(array('username' => $this->currentUser->getUsername(), 'provider' => $provider));
            if ($result) {
                $this->objectManager->remove($result);
                $this->objectManager->flush();
            }
        }
    }

    /**
     * Save as HybridAuthSessionData entity to the database.
     * Checks the bundle configuration before saving.
     *
     * @param $sessionData
     * @param $provider
     */
    private function saveAuthSessionData($sessionData, $provider)
    {
        if ($this->storeForUser && $this->currentUser instanceof UserInterface) {
            $hybridAuthData = $this->objectManager->getRepository('AzineHybridAuthBundle:HybridAuthSessionData')->findOneBy(array('username' => $this->currentUser->getUsername(), 'provider' => strtolower($provider)));
            if (!$hybridAuthData) {
                $hybridAuthData = new HybridAuthSessionData();
                $hybridAuthData->setUserName($this->currentUser->getUsername());
                $hybridAuthData->setProvider(strtolower($provider));

                $expirationDate = new \DateTime();
                $expirationDate->modify('+ '.$this->expiresInDays.' day');

                $hybridAuthData->setExpiresAt($expirationDate);
                $this->objectManager->persist($hybridAuthData);
            }
            $hybridAuthData->setSessionData($sessionData);
            $this->objectManager->flush();
        }
    }

    public function getCookieName($provider)
    {
        return self::cookieName.'_'.strtolower($provider);
    }

    /**
     * Use this function to get access to a \Hybridauth\Adapter\AdapterInterface instance.
     *
     * Calling this method will log the user in (make a roundtrip to the providers site and back to your site again)
     * and call the page again that you came from.
     *
     * When logged (allready) it will return the hybridAuth provider.
     *
     * @param $authSessionData
     * @param string $provider_id
     * @param bool   $require_login
     *
     * @return \Hybridauth\Adapter\AdapterInterface
     */
    public function getProvider($authSessionData, $provider_id, $require_login = true)
    {
        $adapter = $this->getInstance($authSessionData, $provider_id);
        if ($require_login && !$adapter->isConnected()) {
            $adapter->login();

The method login() does not seem to exist on object<Hybridauth\Adapter\AdapterInterface>.

        }

        return $adapter;
    }

    /**
     * Check if the current user has allowed access to the given provider.
     *
     * @param Request $request
     * @param string  $provider_id
     *
     * @return bool true if access to the provider is granted for this app
     */
    public function isConnected(Request $request, $provider_id)
    {
        $sessionData = $request->cookies->get($this->getCookieName($provider_id));
        $adapter = $this->getInstance($sessionData, $provider_id);
        $connected = $adapter->isConnected();

        return $connected;
    }

    /**
     * Get the LinkedIn Adapter.
     *
     * @return \Hybrid_Providers_LinkedIn
     */
    public function getLinkedIn()
    {
        return $this->getProvider(null, 'linkedin');
    }

    /**
     * Get the LinkedIn api (LinkedIn PHP-client).
     *
     * @return \LinkedIn
     */
    public function getLinkedInApi()
    {
        return $this->getLinkedIn()->api();

The method api() does not seem to exist on object<Hybridauth\Adapter\AdapterInterface>.

    }

    /**
     * Get if auth token is expired.
     *
     * @param HybridAuthSessionData $data
     *
     * @return bool
     */
    public function isExpiredSession(HybridAuthSessionData $data)
    {
        if ($data->getExpiresAt() < new \DateTime()) {
            return true;
        }

        return false;
    }
}