CustomerContext::createCustomerWithUserAccount() - Code Metrics - Inspection of "Remove ContentBundle" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — remove-content-bundle ( 201341...8d07b3 )

by Kamil

created 2016-11-14 09:52 UTC

CustomerContext::createCustomerWithUserAccount() B

↳ Parent: CustomerContext

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	26
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	19
nc	1
nop	6

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

namespace Sylius\Behat\Context\Setup;

use Behat\Behat\Context\Context;
use Doctrine\Common\Persistence\ObjectManager;
use Sylius\Behat\Service\SharedStorageInterface;
use Sylius\Component\Core\Model\CustomerInterface;
use Sylius\Component\Core\Repository\CustomerRepositoryInterface;
use Sylius\Component\Customer\Model\CustomerGroupInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;

/**
 * @author Anna Walasek <[email protected]>
 */
final class CustomerContext implements Context
{
    /**
     * @var SharedStorageInterface
     */
    private $sharedStorage;

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

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

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

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

    /**
     * @param SharedStorageInterface $sharedStorage
     * @param CustomerRepositoryInterface $customerRepository
     * @param ObjectManager $customerManager
     * @param FactoryInterface $customerFactory
     * @param FactoryInterface $userFactory
     */
    public function __construct(
        SharedStorageInterface $sharedStorage,
        CustomerRepositoryInterface $customerRepository,
        ObjectManager $customerManager,
        FactoryInterface $customerFactory,
        FactoryInterface $userFactory
    ) {
        $this->sharedStorage = $sharedStorage;
        $this->customerRepository = $customerRepository;
        $this->customerManager = $customerManager;
        $this->customerFactory = $customerFactory;
        $this->userFactory = $userFactory;
    }

    /**
     * @Given the store has customer :name with email :email
     */
    public function theStoreHasCustomerWithNameAndEmail($name, $email)
    {
        $partsOfName = explode(' ', $name);
        $this->createCustomer($email, $partsOfName[0], $partsOfName[1]);
    }

    /**
     * @Given the store has customer :email
     */
    public function theStoreHasCustomer($email)
    {
        $this->createCustomer($email);
    }

    /**
     * @Given the store has customer :email with first name :firstName
     */
    public function theStoreHasCustomerWithFirstName($email, $firstName)
    {
        $this->createCustomer($email, $firstName);
    }

    /**
     * @Given the store has customer :email with last name :lastName
     */
    public function theStoreHasCustomerWithLastName($email, $lastName)
    {
        $this->createCustomer($email, null, $lastName);
    }

    /**
     * @Given the store has customer :email with name :fullName since :since
     */
    public function theStoreHasCustomerWithNameAndRegistrationDate($email, $fullName, $since)
    {
        $names = explode(' ', $fullName);
        $this->createCustomer($email, $names[0], $names[1], new \DateTime($since));
    }

    /**
     * @Given there is disabled customer account :email with password :password
     */
    public function thereIsDisabledCustomerAccountWithPassword($email, $password)
    {
        $this->createCustomerWithUserAccount($email, $password, false);
    }

    /**
     * @Given there is enabled customer account :email with password :password
     * @Given there is a customer account :email identified by :password
     */
    public function theStoreHasEnabledCustomerAccountWithPassword($email, $password)
    {
        $this->createCustomerWithUserAccount($email, $password, true);
    }

    /**
     * @Given there is a customer :name identified by an email :email and a password :password
     */
    public function theStoreHasCustomerAccountWithEmailAndPassword($name, $email, $password)
    {
        $names = explode(' ', $name);
        $firstName = $names[0];
        $lastName = count($names) > 1 ? $names[1] : null;

        $this->createCustomerWithUserAccount($email, $password, true, $firstName, $lastName);
    }

    /**
     * @Given there is an administrator :name identified by an email :email and a password :password
     */
    public function thereIsAdministratorIdentifiedByEmailAndPassword($name, $email, $password)
    {
        $names = explode(' ', $name);
        $firstName = $names[0];
        $lastName = count($names) > 1 ? $names[1] : null;

        $this->createCustomerWithUserAccount($email, $password, true, $firstName, $lastName, 'ROLE_ADMINISTRATION_ACCESS');
    }

    /**
     * @Given /^(the customer) subscribed to the newsletter$/
     */
    public function theCustomerSubscribedToTheNewsletter(CustomerInterface $customer)
    {
        $customer->setSubscribedToNewsletter(true);

        $this->customerManager->flush();
    }

    /**
     * @Given /^(this customer) verified their email$/
     */
    public function theCustomerVerifiedTheirEmail(CustomerInterface $customer)
    {
        $customer->getUser()->setVerifiedAt(new \DateTime());

        $this->customerManager->flush();
    }

    /**
     * @Given /^(the customer) belongs to (group "([^"]+)")$/
     */
    public function theCustomerBelongsToGroup(CustomerInterface $customer, CustomerGroupInterface $customerGroup)
    {
        $customer->setGroup($customerGroup);
        
        $this->customerManager->flush();
    }

    /**
     * @param string $email
     * @param string|null $firstName
     * @param string|null $lastName
     * @param \DateTime|null $createdAt
     */
    private function createCustomer($email, $firstName = null, $lastName = null, \DateTime $createdAt = null)
    {
        /** @var CustomerInterface $customer */
        $customer = $this->customerFactory->createNew();

        $customer->setFirstName($firstName);
        $customer->setLastName($lastName);
        $customer->setEmail($email);
        if (null !== $createdAt) {
            $customer->setCreatedAt($createdAt);
        }

        $this->sharedStorage->set('customer', $customer);
        $this->customerRepository->add($customer);
    }

    /**
     * @param string $email
     * @param string $password
     * @param bool $enabled
     * @param string|null $firstName
     * @param string|null $lastName
     * @param string|null $role
     */
    private function createCustomerWithUserAccount(
        $email,
        $password,
        $enabled = true,
        $firstName = null,
        $lastName = null,
        $role = null
    ) {
        $user = $this->userFactory->createNew();
        /** @var CustomerInterface $customer */
        $customer = $this->customerFactory->createNew();

        $customer->setFirstName($firstName);
        $customer->setLastName($lastName);
        $customer->setEmail($email);

        $user->setUsername($email);
        $user->setPlainPassword($password);
        $user->setEnabled($enabled);
        $user->addRole($role);

        $customer->setUser($user);

        $this->sharedStorage->set('customer', $customer);
        $this->customerRepository->add($customer);
    }
}


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			namespace Sylius\Behat\Context\Setup;
13
14			use Behat\Behat\Context\Context;
15			use Doctrine\Common\Persistence\ObjectManager;
16			use Sylius\Behat\Service\SharedStorageInterface;
17			use Sylius\Component\Core\Model\CustomerInterface;
18			use Sylius\Component\Core\Repository\CustomerRepositoryInterface;
19			use Sylius\Component\Customer\Model\CustomerGroupInterface;
20			use Sylius\Component\Resource\Factory\FactoryInterface;
21
22			/**
23			* @author Anna Walasek <[email protected]>
24			*/
25			final class CustomerContext implements Context
26			{
27			/**
28			* @var SharedStorageInterface
29			*/
30			private $sharedStorage;
31
32			/**
33			* @var CustomerRepositoryInterface
34			*/
35			private $customerRepository;
36
37			/**
38			* @var ObjectManager
39			*/
40			private $customerManager;
41
42			/**
43			* @var FactoryInterface
44			*/
45			private $customerFactory;
46
47			/**
48			* @var FactoryInterface
49			*/
50			private $userFactory;
51
52			/**
53			* @param SharedStorageInterface $sharedStorage
54			* @param CustomerRepositoryInterface $customerRepository
55			* @param ObjectManager $customerManager
56			* @param FactoryInterface $customerFactory
57			* @param FactoryInterface $userFactory
58			*/
59			public function __construct(
60			SharedStorageInterface $sharedStorage,
61			CustomerRepositoryInterface $customerRepository,
62			ObjectManager $customerManager,
63			FactoryInterface $customerFactory,
64			FactoryInterface $userFactory
65			) {
66			$this->sharedStorage = $sharedStorage;
67			$this->customerRepository = $customerRepository;
68			$this->customerManager = $customerManager;
69			$this->customerFactory = $customerFactory;
70			$this->userFactory = $userFactory;
71			}
72
73			/**
74			* @Given the store has customer :name with email :email
75			*/
76			public function theStoreHasCustomerWithNameAndEmail($name, $email)
77			{
78			$partsOfName = explode(' ', $name);
79			$this->createCustomer($email, $partsOfName[0], $partsOfName[1]);
80			}
81
82			/**
83			* @Given the store has customer :email
84			*/
85			public function theStoreHasCustomer($email)
86			{
87			$this->createCustomer($email);
88			}
89
90			/**
91			* @Given the store has customer :email with first name :firstName
92			*/
93			public function theStoreHasCustomerWithFirstName($email, $firstName)
94			{
95			$this->createCustomer($email, $firstName);
96			}
97
98			/**
99			* @Given the store has customer :email with last name :lastName
100			*/
101			public function theStoreHasCustomerWithLastName($email, $lastName)
102			{
103			$this->createCustomer($email, null, $lastName);
104			}
105
106			/**
107			* @Given the store has customer :email with name :fullName since :since
108			*/
109			public function theStoreHasCustomerWithNameAndRegistrationDate($email, $fullName, $since)
110			{
111			$names = explode(' ', $fullName);
112			$this->createCustomer($email, $names[0], $names[1], new \DateTime($since));
113			}
114
115			/**
116			* @Given there is disabled customer account :email with password :password
117			*/
118			public function thereIsDisabledCustomerAccountWithPassword($email, $password)
119			{
120			$this->createCustomerWithUserAccount($email, $password, false);
121			}
122
123			/**
124			* @Given there is enabled customer account :email with password :password
125			* @Given there is a customer account :email identified by :password
126			*/
127			public function theStoreHasEnabledCustomerAccountWithPassword($email, $password)
128			{
129			$this->createCustomerWithUserAccount($email, $password, true);
130			}
131
132			/**
133			* @Given there is a customer :name identified by an email :email and a password :password
134			*/
135			public function theStoreHasCustomerAccountWithEmailAndPassword($name, $email, $password)
136			{
137			$names = explode(' ', $name);
138			$firstName = $names[0];
139			$lastName = count($names) > 1 ? $names[1] : null;
140
141			$this->createCustomerWithUserAccount($email, $password, true, $firstName, $lastName);
142			}
143
144			/**
145			* @Given there is an administrator :name identified by an email :email and a password :password
146			*/
147			public function thereIsAdministratorIdentifiedByEmailAndPassword($name, $email, $password)
148			{
149			$names = explode(' ', $name);
150			$firstName = $names[0];
151			$lastName = count($names) > 1 ? $names[1] : null;
152
153			$this->createCustomerWithUserAccount($email, $password, true, $firstName, $lastName, 'ROLE_ADMINISTRATION_ACCESS');
154			}
155
156			/**
157			* @Given /^(the customer) subscribed to the newsletter$/
158			*/
159			public function theCustomerSubscribedToTheNewsletter(CustomerInterface $customer)
160			{
161			$customer->setSubscribedToNewsletter(true);
162
163			$this->customerManager->flush();
164			}
165
166			/**
167			* @Given /^(this customer) verified their email$/
168			*/
169			public function theCustomerVerifiedTheirEmail(CustomerInterface $customer)
170			{
171			$customer->getUser()->setVerifiedAt(new \DateTime());
172
173			$this->customerManager->flush();
174			}
175
176			/**
177			* @Given /^(the customer) belongs to (group "([^"]+)")$/
178			*/
179			public function theCustomerBelongsToGroup(CustomerInterface $customer, CustomerGroupInterface $customerGroup)
180			{
181			$customer->setGroup($customerGroup);
182
183			$this->customerManager->flush();
184			}
185
186			/**
187			* @param string $email
188			* @param string\|null $firstName
189			* @param string\|null $lastName
190			* @param \DateTime\|null $createdAt
191			*/
192			private function createCustomer($email, $firstName = null, $lastName = null, \DateTime $createdAt = null)
193			{
194			/** @var CustomerInterface $customer */
195			$customer = $this->customerFactory->createNew();
196
197			$customer->setFirstName($firstName);
198			$customer->setLastName($lastName);
199			$customer->setEmail($email);
200			if (null !== $createdAt) {
201			$customer->setCreatedAt($createdAt);
202			}
203
204			$this->sharedStorage->set('customer', $customer);
205			$this->customerRepository->add($customer);
206			}
207
208			/**
209			* @param string $email
210			* @param string $password
211			* @param bool $enabled
212			* @param string\|null $firstName
213			* @param string\|null $lastName
214			* @param string\|null $role
215			*/
216			private function createCustomerWithUserAccount(
217			$email,
218			$password,
219			$enabled = true,
220			$firstName = null,
221			$lastName = null,
222			$role = null
223			) {
224			$user = $this->userFactory->createNew();
225			/** @var CustomerInterface $customer */
226			$customer = $this->customerFactory->createNew();
227
228			$customer->setFirstName($firstName);
229			$customer->setLastName($lastName);
230			$customer->setEmail($email);
231
232			$user->setUsername($email);
233			$user->setPlainPassword($password);
234			$user->setEnabled($enabled);
235			$user->addRole($role);
236
237			$customer->setUser($user);
238
239			$this->sharedStorage->set('customer', $customer);
240			$this->customerRepository->add($customer);
241			}
242			}
243

pamil / Sylius

Push — remove-content-bundle ( 201341...8d07b3 )

CustomerContext::createCustomerWithUserAccount() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like