AzineHybridAuth::storeHybridAuthSessionData() - Code Metrics - Inspection of "add timestamp and expiry functionality to hybridau..." - azine/AzineHybridAuthBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#4)

unknown

created 2017-03-06 13:34 UTC

AzineHybridAuth::storeHybridAuthSessionData() A

↳ Parent: AzineHybridAuth

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	8
ccs	0
cts	2
cp	0
rs	9.4285
cc	2
eloc	5
nc	2
nop	3
crap	6

<?php
namespace Azine\HybridAuthBundle\Services;

use Azine\HybridAuthBundle\DependencyInjection\AzineHybridAuthExtension;

use Azine\HybridAuthBundle\Entity\HybridAuthSessionData;
use Doctrine\Common\Persistence\ObjectManager;
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->objectManager = $manager;
		$this->storeForUser = $storeForUser;
		$this->storeAsCookie = $storeAsCookie;
		$user = $tokenStorage->getToken()->getUser();
        if($user instanceof UserInterface) {
			$this->currentUser = $user;
        }
        $this->expiresInDays = $expiresInDays;
	}


	/**
	 * Get a Hybrid_Auth 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 \Hybrid_Auth
	 */
	public function getInstance($cookieSessionData, $provider){
		if(array_key_exists($provider, $this->instances)){
			$hybridAuth = $this->instances[$provider];
		} else {
			$hybridAuth = new \Hybrid_Auth($this->config);
			$this->instances[$provider] = $hybridAuth;
		}
		$restoredFromDB = false;
		$sessionData = null;
        $isExpiredSession = false;

        // try to get from database
        $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){
			if($result){
				$sessionData = $result->getSessionData();
				$restoredFromDB = true;
			}
		}
		if($sessionData === null && $cookieSessionData !== null) {
			// 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) {
			$hybridAuth->restoreSessionData($sessionData);
		}

		return $hybridAuth;
	}

	/**
	 * @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);
		}
		return null;
	}
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

    /**
     * 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));
                $hybridAuthData->setExpiresAt(new \DateTime('+ '. $this->expiresInDays .' days'));
                $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 HybridAuthProvider.
	 *
	 * 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 boolean $require_login
	 * @return \Hybrid_Provider_Model
	 */
	public function getProvider($authSessionData, $provider_id, $require_login = true){
		$adapter = $this->getInstance($authSessionData, $provider_id)->getAdapter($provider_id);
		if($require_login && !$adapter->isUserConnected()){
			$adapter->login();
		}
		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)->getAdapter($provider_id);
		$connected = $adapter->isUserConnected();
		return $connected;
	}

	/**
     * Get the Xing Adapter
     * @return \Hybrid_Providers_XING
     */
	public function getXing(){
		return $this->getProvider(null, "xing");
	}

	/**
	 * Get the Xing api (OAuthClient)
	 *
	 * @return \OAuth1Client
	 */
	public function getXingApi(){
		return $this->getXing()->api();
	}

	/**
	 * 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();
	}

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

			return true;
		}

		return false;
	}
}

1			<?php
2			namespace Azine\HybridAuthBundle\Services;
3
4			use Azine\HybridAuthBundle\DependencyInjection\AzineHybridAuthExtension;
5
6			use Azine\HybridAuthBundle\Entity\HybridAuthSessionData;
7			use Doctrine\Common\Persistence\ObjectManager;
8			use Symfony\Component\HttpFoundation\Cookie;
9			use Symfony\Component\HttpFoundation\Request;
10			use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
11			use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
12			use Symfony\Component\Security\Core\User\UserInterface;
13
14			class AzineHybridAuth {
15			/**
16			* ID of the sessionDataCookie
17			*/
18			const cookieName = "azine_hybridauth_session";
19
20			/**
21			* @var ObjectManager
22			*/
23			private $objectManager;
24
25			/**
26			* @var UserInterface
27			*/
28			private $currentUser;
29
30			/**
31			* @var bool
32			*/
33			private $storeForUser;
34
35			/**
36			* @var bool
37			*/
38			private $storeAsCookie;
39
40			/**
41			* @var int
42			*/
43			private $expiresInDays;
44
45			/**
46			* Configured Instances of HybridAuth
47			* @var array or HybridAuth
48			*/
49			private $instances = array();
50
51			/**
52			* HybridAuth configuration
53			* @var array
54			*/
55			private $config;
56
57			/**
58			*
59			* @param UrlGeneratorInterface $router
60			* @param TokenStorageInterface $tokenStorage
61			* @param ObjectManager $manager
62			* @param array $config
63			* @param bool $storeForUser
64			* @param $storeAsCookie
65			* @param $expiresInDays
66			*/
67			public function __construct(UrlGeneratorInterface $router, TokenStorageInterface $tokenStorage, ObjectManager $manager, $config, $storeForUser, $storeAsCookie, $expiresInDays){
68			$base_url = $router->generate($config[AzineHybridAuthExtension::ENDPOINT_ROUTE], array(), UrlGeneratorInterface::ABSOLUTE_URL);
69			$config[AzineHybridAuthExtension::BASE_URL] = $base_url;
70			$this->config = $config;
71			$this->objectManager = $manager;
72			$this->storeForUser = $storeForUser;
73			$this->storeAsCookie = $storeAsCookie;
74			$user = $tokenStorage->getToken()->getUser();
75			if($user instanceof UserInterface) {
76			$this->currentUser = $user;
77			}
78			$this->expiresInDays = $expiresInDays;
79			}
80
81
82			/**
83			* Get a Hybrid_Auth instance initialised for the given provider.
84			* HybridAuthSessions will be restored from DB and/or cookies, according to the bundle configuration.
85			*
86			* @param $cookieSessionData
87			* @param $provider
88			* @return \Hybrid_Auth
89			*/
90			public function getInstance($cookieSessionData, $provider){
91			if(array_key_exists($provider, $this->instances)){
92			$hybridAuth = $this->instances[$provider];
93			} else {
94			$hybridAuth = new \Hybrid_Auth($this->config);
95			$this->instances[$provider] = $hybridAuth;
96			}
97			$restoredFromDB = false;
98			$sessionData = null;
99			$isExpiredSession = false;
100
101			// try to get from database
102			$result = $this->objectManager->getRepository("AzineHybridAuthBundle:HybridAuthSessionData")->findOneBy(array('username' => $this->currentUser->getUsername(), 'provider' => $provider));
103
104			if($result instanceof HybridAuthSessionData){
105			$isExpiredSession = $this->isExpiredSession($result);
106			}
107
108			if($isExpiredSession){
109			$this->deleteSession($provider);
110			}
111
112			if(!$isExpiredSession && $this->storeForUser && $this->currentUser instanceof UserInterface){
113			if($result){
114			$sessionData = $result->getSessionData();
115			$restoredFromDB = true;
116			}
117			}
118			if($sessionData === null && $cookieSessionData !== null) {
119			// try from cookie
120			$sessionData = gzinflate($cookieSessionData);
121
122			// user is looged in but auth session is not yet stored in db => store now
123			if(!$restoredFromDB){
124			$this->saveAuthSessionData($sessionData, $provider);
125			}
126			}
127			if($sessionData) {
128			$hybridAuth->restoreSessionData($sessionData);
129			}
130
131			return $hybridAuth;
132			}
133
134			/**
135			* @param Request $request
136			* @param $provider
137			* @param $sessionData
138			* @return Cookie \| null
139			*/
140			public function storeHybridAuthSessionData(Request $request, $provider, $sessionData){
141			$this->saveAuthSessionData($sessionData, $provider);
142
143			if($this->storeAsCookie){
144			return new Cookie($this->getCookieName($provider), gzdeflate($sessionData), new \DateTime($this->expiresInDays .' days'), '/', $request->getHost(), $request->isSecure(), true);
145			}
146			return null;
147			}
			0 ignored issues – show Documentation introduced 2017-02-28 13:30 UTC by Report Bug Copy Issue Report `new \DateTime($this->expiresInDays . ' days')` is of type `object<DateTime>`, but the function expects a `integer`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
148
149			/**
150			* Delete the HybridAuthSessionData entity from the database
151			* @param $provider
152			*/
153			public function deleteSession($provider){
154			if($this->currentUser instanceof UserInterface) {
155			$result = $this->objectManager->getRepository("AzineHybridAuthBundle:HybridAuthSessionData")->findOneBy(array('username' => $this->currentUser->getUsername(), 'provider' => $provider));
156			if ($result) {
157			$this->objectManager->remove($result);
158			$this->objectManager->flush();
159			}
160			}
161			}
162
163			/**
164			* Save as HybridAuthSessionData entity to the database.
165			* Checks the bundle configuration before saving.
166			* @param $sessionData
167			* @param $provider
168			*/
169			private function saveAuthSessionData($sessionData, $provider){
170			if($this->storeForUser && $this->currentUser instanceof UserInterface) {
171			$hybridAuthData = $this->objectManager->getRepository("AzineHybridAuthBundle:HybridAuthSessionData")->findOneBy(array('username' => $this->currentUser->getUsername(), 'provider' => strtolower($provider)));
172			if (!$hybridAuthData) {
173			$hybridAuthData = new HybridAuthSessionData();
174			$hybridAuthData->setUserName($this->currentUser->getUsername());
175			$hybridAuthData->setProvider(strtolower($provider));
176			$hybridAuthData->setExpiresAt(new \DateTime('+ '. $this->expiresInDays .' days'));
177			$this->objectManager->persist($hybridAuthData);
178			}
179			$hybridAuthData->setSessionData($sessionData);
180			$this->objectManager->flush();
181			}
182			}
183
184			public function getCookieName($provider){
185			return self::cookieName."_".strtolower($provider);
186			}
187
188			/**
189			* Use this function to get access to a HybridAuthProvider.
190			*
191			* Calling this method will log the user in (make a roundtrip to the providers site and back to your site again)
192			* and call the page again that you came from.
193			*
194			* When logged (allready) it will return the hybridAuth provider.
195			*
196			* @param $authSessionData
197			* @param string $provider_id
198			* @param boolean $require_login
199			* @return \Hybrid_Provider_Model
200			*/
201			public function getProvider($authSessionData, $provider_id, $require_login = true){
202			$adapter = $this->getInstance($authSessionData, $provider_id)->getAdapter($provider_id);
203			if($require_login && !$adapter->isUserConnected()){
204			$adapter->login();
205			}
206			return $adapter;
207			}
208
209			/**
210			* Check if the current user has allowed access to the given provider
211			* @param Request $request
212			* @param string $provider_id
213			* @return bool true if access to the provider is granted for this app.
214			*/
215			public function isConnected(Request $request, $provider_id){
216			$sessionData = $request->cookies->get($this->getCookieName($provider_id));
217			$adapter = $this->getInstance($sessionData, $provider_id)->getAdapter($provider_id);
218			$connected = $adapter->isUserConnected();
219			return $connected;
220			}
221
222			/**
223			* Get the Xing Adapter
224			* @return \Hybrid_Providers_XING
225			*/
226			public function getXing(){
227			return $this->getProvider(null, "xing");
228			}
229
230			/**
231			* Get the Xing api (OAuthClient)
232			*
233			* @return \OAuth1Client
234			*/
235			public function getXingApi(){
236			return $this->getXing()->api();
237			}
238
239			/**
240			* Get the LinkedIn Adapter
241			*
242			* @return \Hybrid_Providers_LinkedIn
243			*/
244			public function getLinkedIn(){
245			return $this->getProvider(null, "linkedin");
246			}
247
248			/**
249			* Get the LinkedIn api (LinkedIn PHP-client)
250			*
251			* @return \LinkedIn
252			*/
253			public function getLinkedInApi(){
254			return $this->getLinkedIn()->api();
255			}
256
257			/**
258			* Get if auth token is expired
259			* @param HybridAuthSessionData $data
260			*
261			* @return boolean
262			*/
263			public function isExpiredSession(HybridAuthSessionData $data)
264			{
265			if($data->getExpiresAt() < new \DateTime()){
266
267			return true;
268			}
269
270			return false;
271			}
272			}

azine / AzineHybridAuthBundle

Pull Request — master (#4)

AzineHybridAuth::storeHybridAuthSessionData() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like