UserContext - Code Metrics - Inspection of "[ElasticSearch] Adjust deletion code to work with..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — signal_search_issues ( 907e1e...5556b2 )

by André

created 2016-08-25 13:30 UTC

UserContext F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	568
Duplicated Lines	5.99 %

Coupling/Cohesion

Components	1
Dependencies	18

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	34
loc	568
rs	2.9203
wmc	68
lcom	1
cbo	18

25 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	searchUserByLogin()	0	22	6
A	searchUserGroups()	0	17	2
B	createUser()	0	30	4
A	createUserGroup()	0	11	2
B	ensureUserExists()	8	38	6
C	ensureUserDoesntExist()	8	31	8
A	checkUserExistenceByUsername()	0	17	4
B	checkUserExistenceByEmail()	0	19	6
A	createPasswordHash()	18	18	4
A	iHaveUser()	0	6	1
A	iHaveUserWithUsernameEmailAndPassword()	0	4	1
A	iHaveUserInGroup()	0	6	1
A	iHaveUserWithUsernameEmailAndPasswordInGroup()	0	4	1
A	iDontHaveUser()	0	4	1
A	iDontHaveUserInGroup()	0	4	1
A	iHaveTheFollowingUsers()	0	9	2
A	assertUserWithNameExists()	0	7	1
A	assertUserWithNameDoesntExist()	0	7	1
A	assertUserWithNameExistsInGroup()	0	7	1
A	assertUserWithNameDoesntExistInGroup()	0	7	1
A	assertUserWithNameDoesntExistInGroups()	0	12	2
B	assertUserWithNameExistsWithFields()	0	31	4
A	findNonExistingUserEmail()	0	16	4
A	findNonExistingUserName()	0	11	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like UserContext often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use UserContext, and based on these observations, apply Extract Interface, too.

<?php
/**
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 * @version //autogentag//
 */
namespace eZ\Bundle\EzPublishCoreBundle\Features\Context;

use Behat\Gherkin\Node\TableNode;
use Behat\Behat\Context\Context;
use PHPUnit_Framework_Assert as Assertion;
use EzSystems\PlatformBehatBundle\Context\RepositoryContext;
use eZ\Publish\API\Repository\Repository;
use eZ\Publish\API\Repository\UserService;
use eZ\Publish\API\Repository\SearchService;
use eZ\Publish\API\Repository\Values\ValueObject;
use eZ\Publish\API\Repository\Exceptions as ApiExceptions;
use eZ\Publish\API\Repository\Values\Content\Query;
use eZ\Publish\API\Repository\Values\Content\Query\Criterion;
use eZ\Publish\API\Repository\Exceptions\NotFoundException;

/**
 * Sentences for Users.
 */
class UserContext implements Context
{
    use RepositoryContext;

    const DEFAULT_LANGUAGE = 'eng-GB';

    /**
     * These values are set by the default eZ Publish installation.
     */
    const USER_IDENTIFIER = 'user';

    const USERGROUP_ROOT_CONTENT_ID = 4;
    const USERGROUP_ROOT_LOCATION = 5;
    const USERGROUP_ROOT_SUBTREE = '/1/5/';
    const USERGROUP_CONTENT_IDENTIFIER = 'user_group';

    /**
     * @var \eZ\Publish\API\Repository\UserService
     */
    protected $userService;

    /**
     * @var \eZ\Publish\API\Repository\SearchService
     */
    protected $searchService;

    /**
     * @injectService $repository @ezpublish.api.repository
     * @injectService $userService @ezpublish.api.service.user
     * @injectService $searchService @ezpublish.api.service.search
     */
    public function __construct(Repository $repository, UserService $userService, SearchService $searchService)
    {
        $this->setRepository($repository);
        $this->userService = $userService;
        $this->searchService = $searchService;
    }

    /**
     * Search User with given username, optionally at given location.
     *
     * @param string $username name of User to search for
     * @param string $parentGroupLocationId where to search, in User Group tree
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return User found
     */
    public function searchUserByLogin($username, $parentGroupId = null)
    {
        try {
            $user = $this->userService->loadUserByLogin($username);
        } catch (ApiExceptions\NotFoundException $e) {
            return null;
        }

        if ($user && $parentGroupId) {
            $userGroups = $this->userService->loadUserGroupsOfUser($user);

            foreach ($userGroups as $userGroup) {
                if ($userGroup->getVersionInfo()->getContentInfo()->id == $parentGroupId) {
                    return $user;
                }
            }
            // user not found in $parentGroupId
            return null;
        }

        return $user;
    }

    /**
     * Search User Groups with given name.
     *
     * @param string $name name of User Group to search for
     * @param string $parentLocationId (optional) parent location id to search in
     *
     * @return search results
     */
    public function searchUserGroups($name, $parentLocationId = null)
    {
        $criterionArray = array(
            new Criterion\Subtree(self::USERGROUP_ROOT_SUBTREE),
            new Criterion\ContentTypeIdentifier(self::USERGROUP_CONTENT_IDENTIFIER),
            new Criterion\Field('name', Criterion\Operator::EQ, $name),
        );
        if ($parentLocationId) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $criterionArray[] = new Criterion\ParentLocationId($parentLocationId);
        }
        $query = new Query();
        $query->filter = new Criterion\LogicalAnd($criterionArray);

        $result = $this->searchService->findContent($query, array(), false);

        return $result->searchHits;
    }

    /**
     * Create user inside given User Group; DELETES existing User if login already exists!
     *
     * @param $username username of the user to create
     * @param $email email address of user to create
     * @param $password account password for user to create
     * @param $parentGroup pathstring wherein to create user
     *
     * @return eZ\Publish\API\Repository\Values\User\User
     */
    protected function createUser($username, $email, $password, $parentGroup = null, $fields = array())
    {
        $userCreateStruct = $this->userService->newUserCreateStruct(
            $username,
            $email,
            $password,
            self::DEFAULT_LANGUAGE
        );
        $userCreateStruct->setField('first_name', $username);
        $userCreateStruct->setField('last_name', $username);

        foreach ($fields as $fieldName => $fieldValue) {
            $userCreateStruct->setField($fieldName, $fieldValue);
        }

        try {
            $existingUser = $this->userService->loadUserByLogin($username);
            $this->userService->deleteUser($existingUser);
        } catch (NotFoundException $e) {
            // do nothing
        }

        if (!$parentGroup) {
            $parentGroup = $this->userService->loadUserGroup(self::USERGROUP_ROOT_CONTENT_ID);
        }

        $user = $this->userService->createUser($userCreateStruct, array($parentGroup));

        return $user;
    }

    /**
     * Create new User Group inside existing parent User Group.
     *
     * @param string $name  User Group name
     * @param \eZ\Publish\API\Repository\Values\User\UserGroup $parentGroup  (optional) parent user group, defaults to UserGroup "/Users"
     *
     * @return \eZ\Publish\API\Repository\Values\User\UserGroup
     */
    public function createUserGroup($name, $parentGroup = null)
    {
        if (!$parentGroup) {
            $parentGroup = $this->userService->loadUserGroup(self::USERGROUP_ROOT_CONTENT_ID);
        }

        $userGroupCreateStruct = $this->userService->newUserGroupCreateStruct('eng-GB');
        $userGroupCreateStruct->setField('name', $name);

        return $this->userService->createUserGroup($userGroupCreateStruct, $parentGroup);
    }

    /**
     * Make sure a User with name $username, $email and $password exists in parent group.
     *
     * @param string $username User name
     * @param string $email User's email
     * @param string $password User's password
     * @param string $parentGroupName (optional) name of the parent group to check
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     */
    public function ensureUserExists($username, $email, $password, $parentGroupName = null)
    {
        if ($parentGroupName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $parentSearchHits = $this->searchUserGroups($parentGroupName);

            // Found matching Group(s)
            if (!empty($parentSearchHits)) {
                $firstGroupId = $parentSearchHits[0]->valueObject->contentInfo->id;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                foreach ($parentSearchHits as $userGroupHit) {

                    $groupId = $userGroupHit->valueObject->contentInfo->id;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                    // Search for user in this group
                    $user = $this->searchUserByLogin($username, $groupId);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                    if ($user) {
                        return $user;
                    }
                }

                // create user inside existing parent Group, use first group found
                $parentGroup = $this->userService->loadUserGroup($firstGroupId);

                return $this->createUser($username, $email, $password, $parentGroup);
            } // else

            // Parent Group does not exist yet, so create it at "root" User Group.
            $rootGroup = $this->userService->loadUserGroup(self::USERGROUP_ROOT_CONTENT_ID);
            $parentGroup = $this->createUserGroup($parentGroupName, $rootGroup);

            return $this->createUser($username, $email, $password, $parentGroup);
        }
        // else,

        $user = $this->searchUserByLogin($username);
        if (!$user) {
            $user = $this->createUser($username, $email, $password);
        }

        return $user;
    }

    /**
     * Make sure a User with name $username does not exist (in parent group).
     *
     * @param string $username          User name
     * @param string $parentGroupName   (optional) name of the parent group to check
     */
    public function ensureUserDoesntExist($username, $parentGroupName = null)
    {
        $user = null;
        if ($parentGroupName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            // find matching Parent Group name
            $parentSearchHits = $this->searchUserGroups($parentGroupName, self::USERGROUP_ROOT_LOCATION);
            if (!empty($parentSearchHits)) {
                foreach ($parentSearchHits as $parentGroupFound) {

                    $groupId = $parentGroupFound->valueObject->contentInfo->id;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                    //Search for already existing matching Child user
                    $user = $this->searchUserByLogin($username, $groupId);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                    if ($user) {
                        break;
                    }
                }
            }
        } else {
            try {
                $user = $this->userService->loadUserByLogin($username);
            } catch (ApiExceptions\NotFoundException $e) {
                // nothing to do
            }
        }
        if ($user) {
            try {
                $this->userService->deleteUser($user);
            } catch (ApiExceptions\NotFoundException $e) {
                // nothing to do
            }
        }
    }

    /**
     * Checks if the User with username $username exists.
     *
     * @param string $username User name
     * @param string $parentGroupName User group name to search inside
     *
     * @return bool true if it exists, false if user or group don't exist
     */
    public function checkUserExistenceByUsername($username, $parentGroupName = null)
    {
        if ($parentGroupName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            // find parent group name
            $searchResults = $this->searchUserGroups($parentGroupName);
            if (empty($searchResults)) {
                // group not found, so return immediately
                return false;
            }
            $groupId = $searchResults[0]->valueObject->contentInfo->id;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        } else {
            $groupId = null;
        }
        $searchResults = $this->searchUserByLogin($username, $groupId);

        return empty($searchResults) ? false : true;
    }

    /**
     * Checks if the User with email $email exists.
     *
     * @param string $email User email
     * @param string $parentGroupName User group name to search inside
     *
     * @return bool true if it exists, false if not
     */
    public function checkUserExistenceByEmail($email, $parentGroupName = null)
    {
        $existingUsers = $this->userService->loadUsersByEmail($email);
        if (count($existingUsers) == 0) {
            return false;
        }
        if ($parentGroupName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            foreach ($existingUsers as $user) {
                $userGroups = $this->userService->loadUserGroupsOfUser($user);
                foreach ($userGroups as $userGroup) {
                    if ($userGroup->getFieldValue('name') == $parentGroupName) {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    public function createPasswordHash($login, $password, $type)
    {
        switch ($type) {
            case 2:
                /* PASSWORD_HASH_MD5_USER */
                return md5("{$login}\n{$password}");
            case 3:
                /* PASSWORD_HASH_MD5_SITE */
                $site = null;

                return md5("{$login}\n{$password}\n{$site}");
            case 5:
                /* PASSWORD_HASH_PLAINTEXT */
                return $password;
        }
        /* PASSWORD_HASH_MD5_PASSWORD (1) */
        return md5($password);
    }

    /**
     * @Given there is a User with name :username
     *
     * Ensures a user with username ':username' exists, creating a new one if necessary.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     */
    public function iHaveUser($username)
    {
        $email = $this->findNonExistingUserEmail($username);
        $password = $username;
        $user = $this->ensureUserExists($username, $email, $password);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    /**
     * @Given there is a User with name :username, email :email and password :password
     *
     * Ensures a user exists with given username/email/password, creating a new one if necessary.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     */
    public function iHaveUserWithUsernameEmailAndPassword($username, $email, $password)
    {
        $this->ensureUserExists($username, $email, $password);
    }
    /**
     * @Given there is a User with name :username in :parentGroup group
     *
     * Ensures a user with username ':username' exists as a child of ':parentGroup' user group, can create either one.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     */
    public function iHaveUserInGroup($username, $parentGroupName)
    {
        $email = $this->findNonExistingUserEmail($username);
        $password = $username;
        $user = $this->ensureUserExists($username, $email, $password, $parentGroupName);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }
    /**
     * @Given there is a User with name :username, email :email and password :password in :parentGroup group
     *
     * Ensures a user with given username/email/password as a child of ':parentGroup' user group, can create either one.
     *
     * @return \eZ\Publish\API\Repository\Values\User\User
     */
    public function iHaveUserWithUsernameEmailAndPasswordInGroup($username, $email, $password, $parentGroupName)
    {
        return $this->ensureUserExists($username, $email, $password, $parentGroupName);
    }

    /**
     * @Given there isn't a User with name :username
     *
     * Makes sure a user with username ':username' doesn't exist, removing it if necessary.
     */
    public function iDontHaveUser($username)
    {
        $this->ensureUserDoesntExist($username);
    }
    /**
     * @Given there isn't a User with name :username in :parentGroup group
     *
     * Makes sure a user with username ':username' doesn't exist as a chield of group ':parentGroup', removing it if necessary.
     */
    public function iDontHaveUserInGroup($username, $parentGroup)
    {
        $this->ensureUserDoesntExist($username, $parentGroup);
    }

    /**
     * @Given there are the following Users:
     *
     * Make sure that users in the provided table exist in their respective parent group. Example:
     *      | username        | parentGroup      |
     *      | testUser1       | Members          |
     *      | testUser2       | Editors          |
     *      | testUser3       | NewParent        | # Both user and group should be created
     */
    public function iHaveTheFollowingUsers(TableNode $table)
    {
        $users = $table->getTable();
        array_shift($users);
        foreach ($users as $user) {
            // array( [0] => userName, [1] => groupName );
            $this->ensureUserExists($user[0], $user[1]);
        }
    }

    /**
     * @Given a User with name :username already exists
     * @Then User with name :username exists
     *
     * Checks that user ':username' exists.
     */
    public function assertUserWithNameExists($username)
    {
        Assertion::assertTrue(
            $this->checkUserExistenceByUsername($username),
            "Couldn't find User with name '$username'."
        );
    }

    /**
     * @Then User with name :username doesn't exist
     *
     * Checks that user ':username' does not exist.
     */
    public function assertUserWithNameDoesntExist($username)
    {
        Assertion::assertFalse(
            $this->checkUserExistenceByUsername($username),
            "User with name '$username' was found."
        );
    }

    /**
     * @Then User with name :username exists in group :parentGroup
     * @Then User with name :username exists in :parentGroup group
     *
     * Checks that user ':username' exists as a child of group ':parentGroup'.
     */
    public function assertUserWithNameExistsInGroup($username, $parentGroup)
    {
        Assertion::assertTrue(
            $this->checkUserExistenceByUsername($username, $parentGroup),
            "Couldn't find User with name '$username' in parent group '$parentGroup'."
        );
    }

    /**
     * @Then User with name :username doesn't exist in group :parentGroup
     * @Then User with name :username doesn't exist in :parentGroup group
     *
     * Checks that user ':username' does not exist as a child of group ':parentGroup'.
     */
    public function assertUserWithNameDoesntExistInGroup($username, $parentGroup)
    {
        Assertion::assertFalse(
            $this->checkUserExistenceByUsername($username, $parentGroup),
            "User with name '$username' was found in parent group '$parentGroup'."
        );
    }

    /**
     * @Then User with name :username doesn't exist in the following groups:
     *
     * Checks that user ':username' does not exist in any of the provided groups. Example:
     *      | parentGroup           |
     *      | Partners              |
     *      | Anonymous Users       |
     *      | Editors               |
     *      | Administrator users   |
     */
    public function assertUserWithNameDoesntExistInGroups($username, TableNode $table)
    {
        $groups = $table->getTable();
        array_shift($groups);
        foreach ($groups as $group) {
            $parentGroupName = $group[0];
            Assertion::assertFalse(
                $this->checkUserExistenceByUsername($username, $parentGroupName),
                "User with name '$username' was found in parent group '$parentGroupName'."
            );
        }
    }

    /**
     * @Then User with name :username has the following fields:
     * @Then User with name :username exists with the following fields:
     *
     * Checks that user ':username' exists with the values provided in the field/value table. example:
     *       | Name          | value           |
     *       | email         | [email protected]  |
     *       | password      | testuser        |
     *       | first_name    | Test            |
     *       | last_name     | User            |
     */
    public function assertUserWithNameExistsWithFields($username, TableNode $table)
    {
        Assertion::assertTrue(
            $this->checkUserExistenceByUsername($username),
            "Couldn't find User with name '$username'."
        );
        $user = $this->userService->loadUserByLogin($username);
        $fieldsTable = $table->getTable();
        array_shift($fieldsTable);
        $updateFields = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($fieldsTable as $fieldRow) {
            $fieldName = $fieldRow[0];
            $expectedValue = $fieldRow[1];
            switch ($fieldName) {
                case 'email':
                    $fieldValue = $user->email;
                    break;
                case 'password':
                    $fieldValue = $user->passwordHash;
                    $expectedValue = $this->createPasswordHash($username, $expectedValue, $user->hashAlgorithm);
                    break;
                default:
                    $fieldValue = $user->getFieldValue($fieldName);
            }
            Assertion::assertEquals(
                $expectedValue,
                $fieldValue,
                "Field '$fieldName' did not contain expected value '$expectedValue'."
            );
        }
    }

    /**
     * Find a non existing User email.
     *
     * @return string A not used email
     *
     * @throws \Exception Possible endless loop
     */
    private function findNonExistingUserEmail($username = 'User')
    {
        $email = "${username}@ez.no";
        if ($this->checkUserExistenceByEmail($email)) {
            return $email;
        }

        for ($i = 0; $i < 20; ++$i) {
            $email = 'User#' . uniqid() . '@ez.no';
            if (!$this->checkUserExistenceByEmail($email)) {
                return $email;
            }
        }

        throw new \Exception('Possible endless loop when attempting to find a new email for User.');
    }

    /**
     * Find a non existing User name.
     *
     * @return string A not used name
     *
     * @throws \Exception Possible endless loop
     */
    private function findNonExistingUserName()

    {
        for ($i = 0; $i < 20; ++$i) {
            $username = 'User#' . uniqid();
            if (!$this->checkUserExistenceByUsername($username)) {
                return $username;
            }
        }

        throw new \Exception('Possible endless loop when attempting to find a new name for User.');
    }
}


ezsystems / ezpublish-kernel