UserProvider::__construct() - Code Metrics - Inspection of "Fix build" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — pull-request/8600 ( 367a7c )

by Kamil

created 2017-09-22 12:22 UTC

UserProvider::__construct() A

↳ Parent: UserProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	20
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	17
nc	1
nop	9

How to fix Many Parameters

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Sylius\Bundle\CoreBundle\OAuth;

use Doctrine\Common\Persistence\ObjectManager;
use HWI\Bundle\OAuthBundle\Connect\AccountConnectorInterface;
use HWI\Bundle\OAuthBundle\OAuth\Response\UserResponseInterface;
use HWI\Bundle\OAuthBundle\Security\Core\User\OAuthAwareUserProviderInterface;
use Sylius\Bundle\UserBundle\Provider\UsernameOrEmailProvider as BaseUserProvider;
use Sylius\Component\Core\Model\CustomerInterface;
use Sylius\Component\Core\Model\ShopUserInterface as SyliusUserInterface;
use Sylius\Component\Core\Repository\CustomerRepositoryInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;
use Sylius\Component\Resource\Repository\RepositoryInterface;
use Sylius\Component\User\Canonicalizer\CanonicalizerInterface;
use Sylius\Component\User\Model\UserOAuthInterface;
use Sylius\Component\User\Repository\UserRepositoryInterface;
use Symfony\Component\Security\Core\User\UserInterface;

/**
 * Loading and ad-hoc creation of a user by an OAuth sign-in provider account.
 *
 * @author Fabian Kiss <[email protected]>
 * @author Joseph Bielawski <[email protected]>
 * @author Łukasz Chruściel <[email protected]>
 */
class UserProvider extends BaseUserProvider implements AccountConnectorInterface, OAuthAwareUserProviderInterface
{
    /**
     * @var FactoryInterface
     */
    private $oauthFactory;

    /**
     * @var RepositoryInterface
     */
    private $oauthRepository;

    /**
     * @var FactoryInterface
     */
    private $customerFactory;

    /**
     * @var FactoryInterface
     */
    private $userFactory;

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

    /**
     * @var CustomerRepositoryInterface
     */
    private $customerRepository;

    /**
     * @param string $supportedUserClass
     * @param FactoryInterface $customerFactory
     * @param FactoryInterface $userFactory
     * @param UserRepositoryInterface $userRepository
     * @param FactoryInterface $oauthFactory
     * @param RepositoryInterface $oauthRepository
     * @param ObjectManager $userManager
     * @param CanonicalizerInterface $canonicalizer
     * @param CustomerRepositoryInterface $customerRepository
     */
    public function __construct(
        string $supportedUserClass,
        FactoryInterface $customerFactory,
        FactoryInterface $userFactory,
        UserRepositoryInterface $userRepository,
        FactoryInterface $oauthFactory,
        RepositoryInterface $oauthRepository,
        ObjectManager $userManager,
        CanonicalizerInterface $canonicalizer,
        CustomerRepositoryInterface $customerRepository
    ) {
        parent::__construct($supportedUserClass, $userRepository, $canonicalizer);

        $this->customerFactory = $customerFactory;
        $this->oauthFactory = $oauthFactory;
        $this->oauthRepository = $oauthRepository;
        $this->userFactory = $userFactory;
        $this->userManager = $userManager;
        $this->customerRepository = $customerRepository;
    }

    /**
     * {@inheritdoc}
     */
    public function loadUserByOAuthUserResponse(UserResponseInterface $response): UserInterface
    {
        $oauth = $this->oauthRepository->findOneBy([
            'provider' => $response->getResourceOwner()->getName(),
            'identifier' => $response->getUsername(),
        ]);

        if ($oauth instanceof UserOAuthInterface) {
            return $oauth->getUser();
        }

        if (null !== $response->getEmail()) {
            $user = $this->userRepository->findOneByEmail($response->getEmail());
            if (null !== $user) {
                return $this->updateUserByOAuthUserResponse($user, $response);
            }
        }

        return $this->createUserByOAuthUserResponse($response);
    }

    /**
     * {@inheritdoc}
     */
    public function connect(UserInterface $user, UserResponseInterface $response): void
    {
        $this->updateUserByOAuthUserResponse($user, $response);
    }

    /**
     * Ad-hoc creation of user.
     *
     * @param UserResponseInterface $response
     *
     * @return SyliusUserInterface
     */
    private function createUserByOAuthUserResponse(UserResponseInterface $response): SyliusUserInterface
    {
        /** @var SyliusUserInterface $user */
        $user = $this->userFactory->createNew();

        $canonicalEmail = $this->canonicalizer->canonicalize($response->getEmail());

        /** @var CustomerInterface $customer */
        $customer = $this->customerRepository->findOneBy(['emailCanonical' => $canonicalEmail]);

        if (null === $customer) {
            $customer = $this->customerFactory->createNew();
        }

        $user->setCustomer($customer);

        // set default values taken from OAuth sign-in provider account
        if (null !== $email = $response->getEmail()) {
            $customer->setEmail($email);
        }

        if (null !== $name = $response->getFirstName()) {
            $customer->setFirstName($name);
        } elseif (null !== $realName = $response->getRealName()) {
            $customer->setFirstName($realName);
        }

        if (null !== $lastName = $response->getLastName()) {
            $customer->setLastName($lastName);
        }

        if (!$user->getUsername()) {
            $user->setUsername($response->getEmail() ?: $response->getNickname());
        }

        // set random password to prevent issue with not nullable field & potential security hole
        $user->setPlainPassword(substr(sha1($response->getAccessToken()), 0, 10));

        $user->setEnabled(true);

        return $this->updateUserByOAuthUserResponse($user, $response);
    }

    /**
     * Attach OAuth sign-in provider account to existing user.
     *
     * @param UserInterface $user
     * @param UserResponseInterface $response
     *
     * @return UserInterface
     */
    private function updateUserByOAuthUserResponse(UserInterface $user, UserResponseInterface $response): UserInterface
    {
        $oauth = $this->oauthFactory->createNew();
        $oauth->setIdentifier($response->getUsername());
        $oauth->setProvider($response->getResourceOwner()->getName());
        $oauth->setAccessToken($response->getAccessToken());
        $oauth->setRefreshToken($response->getRefreshToken());

        /* @var $user SyliusUserInterface */
        $user->addOAuthAccount($oauth);

        $this->userManager->persist($user);
        $this->userManager->flush();

        return $user;
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace Sylius\Bundle\CoreBundle\OAuth;
15
16			use Doctrine\Common\Persistence\ObjectManager;
17			use HWI\Bundle\OAuthBundle\Connect\AccountConnectorInterface;
18			use HWI\Bundle\OAuthBundle\OAuth\Response\UserResponseInterface;
19			use HWI\Bundle\OAuthBundle\Security\Core\User\OAuthAwareUserProviderInterface;
20			use Sylius\Bundle\UserBundle\Provider\UsernameOrEmailProvider as BaseUserProvider;
21			use Sylius\Component\Core\Model\CustomerInterface;
22			use Sylius\Component\Core\Model\ShopUserInterface as SyliusUserInterface;
23			use Sylius\Component\Core\Repository\CustomerRepositoryInterface;
24			use Sylius\Component\Resource\Factory\FactoryInterface;
25			use Sylius\Component\Resource\Repository\RepositoryInterface;
26			use Sylius\Component\User\Canonicalizer\CanonicalizerInterface;
27			use Sylius\Component\User\Model\UserOAuthInterface;
28			use Sylius\Component\User\Repository\UserRepositoryInterface;
29			use Symfony\Component\Security\Core\User\UserInterface;
30
31			/**
32			* Loading and ad-hoc creation of a user by an OAuth sign-in provider account.
33			*
34			* @author Fabian Kiss <[email protected]>
35			* @author Joseph Bielawski <[email protected]>
36			* @author Łukasz Chruściel <[email protected]>
37			*/
38			class UserProvider extends BaseUserProvider implements AccountConnectorInterface, OAuthAwareUserProviderInterface
39			{
40			/**
41			* @var FactoryInterface
42			*/
43			private $oauthFactory;
44
45			/**
46			* @var RepositoryInterface
47			*/
48			private $oauthRepository;
49
50			/**
51			* @var FactoryInterface
52			*/
53			private $customerFactory;
54
55			/**
56			* @var FactoryInterface
57			*/
58			private $userFactory;
59
60			/**
61			* @var ObjectManager
62			*/
63			private $userManager;
64
65			/**
66			* @var CustomerRepositoryInterface
67			*/
68			private $customerRepository;
69
70			/**
71			* @param string $supportedUserClass
72			* @param FactoryInterface $customerFactory
73			* @param FactoryInterface $userFactory
74			* @param UserRepositoryInterface $userRepository
75			* @param FactoryInterface $oauthFactory
76			* @param RepositoryInterface $oauthRepository
77			* @param ObjectManager $userManager
78			* @param CanonicalizerInterface $canonicalizer
79			* @param CustomerRepositoryInterface $customerRepository
80			*/
81			public function __construct(
82			string $supportedUserClass,
83			FactoryInterface $customerFactory,
84			FactoryInterface $userFactory,
85			UserRepositoryInterface $userRepository,
86			FactoryInterface $oauthFactory,
87			RepositoryInterface $oauthRepository,
88			ObjectManager $userManager,
89			CanonicalizerInterface $canonicalizer,
90			CustomerRepositoryInterface $customerRepository
91			) {
92			parent::__construct($supportedUserClass, $userRepository, $canonicalizer);
93
94			$this->customerFactory = $customerFactory;
95			$this->oauthFactory = $oauthFactory;
96			$this->oauthRepository = $oauthRepository;
97			$this->userFactory = $userFactory;
98			$this->userManager = $userManager;
99			$this->customerRepository = $customerRepository;
100			}
101
102			/**
103			* {@inheritdoc}
104			*/
105			public function loadUserByOAuthUserResponse(UserResponseInterface $response): UserInterface
106			{
107			$oauth = $this->oauthRepository->findOneBy([
108			'provider' => $response->getResourceOwner()->getName(),
109			'identifier' => $response->getUsername(),
110			]);
111
112			if ($oauth instanceof UserOAuthInterface) {
113			return $oauth->getUser();
114			}
115
116			if (null !== $response->getEmail()) {
117			$user = $this->userRepository->findOneByEmail($response->getEmail());
118			if (null !== $user) {
119			return $this->updateUserByOAuthUserResponse($user, $response);
120			}
121			}
122
123			return $this->createUserByOAuthUserResponse($response);
124			}
125
126			/**
127			* {@inheritdoc}
128			*/
129			public function connect(UserInterface $user, UserResponseInterface $response): void
130			{
131			$this->updateUserByOAuthUserResponse($user, $response);
132			}
133
134			/**
135			* Ad-hoc creation of user.
136			*
137			* @param UserResponseInterface $response
138			*
139			* @return SyliusUserInterface
140			*/
141			private function createUserByOAuthUserResponse(UserResponseInterface $response): SyliusUserInterface
142			{
143			/** @var SyliusUserInterface $user */
144			$user = $this->userFactory->createNew();
145
146			$canonicalEmail = $this->canonicalizer->canonicalize($response->getEmail());
147
148			/** @var CustomerInterface $customer */
149			$customer = $this->customerRepository->findOneBy(['emailCanonical' => $canonicalEmail]);
150
151			if (null === $customer) {
152			$customer = $this->customerFactory->createNew();
153			}
154
155			$user->setCustomer($customer);
156
157			// set default values taken from OAuth sign-in provider account
158			if (null !== $email = $response->getEmail()) {
159			$customer->setEmail($email);
160			}
161
162			if (null !== $name = $response->getFirstName()) {
163			$customer->setFirstName($name);
164			} elseif (null !== $realName = $response->getRealName()) {
165			$customer->setFirstName($realName);
166			}
167
168			if (null !== $lastName = $response->getLastName()) {
169			$customer->setLastName($lastName);
170			}
171
172			if (!$user->getUsername()) {
173			$user->setUsername($response->getEmail() ?: $response->getNickname());
174			}
175
176			// set random password to prevent issue with not nullable field & potential security hole
177			$user->setPlainPassword(substr(sha1($response->getAccessToken()), 0, 10));
178
179			$user->setEnabled(true);
180
181			return $this->updateUserByOAuthUserResponse($user, $response);
182			}
183
184			/**
185			* Attach OAuth sign-in provider account to existing user.
186			*
187			* @param UserInterface $user
188			* @param UserResponseInterface $response
189			*
190			* @return UserInterface
191			*/
192			private function updateUserByOAuthUserResponse(UserInterface $user, UserResponseInterface $response): UserInterface
193			{
194			$oauth = $this->oauthFactory->createNew();
195			$oauth->setIdentifier($response->getUsername());
196			$oauth->setProvider($response->getResourceOwner()->getName());
197			$oauth->setAccessToken($response->getAccessToken());
198			$oauth->setRefreshToken($response->getRefreshToken());
199
200			/* @var $user SyliusUserInterface */
201			$user->addOAuthAccount($oauth);
202
203			$this->userManager->persist($user);
204			$this->userManager->flush();
205
206			return $user;
207			}
208			}
209

pamil / Sylius

Push — pull-request/8600 ( 367a7c )

UserProvider::__construct() A

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like