Application\Auth\AuthProvider

Complexity

Total Complexity

24

Size/Duplication

Total Lines	205
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

43.84%

Importance

Changes	19
Bugs	1	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	getHybridauth()	0	8	2
A	setHybridauth()	0	4	1
A	setIdentity()	0	4	1
A	getIdentity()	0	4	1
A	getProviderName()	0	4	1
A	setProviderName()	0	4	1
A	getAuthAdapter()	0	13	3
A	setAuthAdapter()	0	4	1
A	registration()	0	14	2
B	authProcess()	0	29	4
A	getOptions()	0	4	1
A	getAvailableProviders()	0	4	1
A	alreadyRegisteredLogic()	0	11	2
A	getProfile()	0	4	1

<?php
/**
 * Hybrid Auth integration
 * @author yuklia <yuliakostrikova@gmail.com>
 */
namespace Application\Auth;

use Bluz\Application\Exception\ApplicationException;
use Bluz\Proxy\Config;
use Bluz\Proxy\Messages;
use Bluz\Proxy\Response;
use Application\Auth;
use Application\Users;

/**
 * Class AuthProvider
 * @package Application\Auth
 */
class AuthProvider implements AuthInterface
{
    /**
     * @var \Application\Users\Row $identity
     */
    protected $identity;

    /**
     * @var \Hybrid_Auth $hybridauth
     */
    protected $hybridauth;

    /**
     * @var \Hybrid_Provider_Adapter $authAdapter
     */
    protected $authAdapter;

    /**
     * the same name as was mentioned in hybridauth config section providers
     * @var string
     */
    protected $providerName;

    public function __construct($providerName)
    {
        if (!in_array(ucfirst($providerName), $this->getAvailableProviders())) {
            throw new ApplicationException(sprintf('Provider % is not defined
            in configuration file', ucfirst($providerName)));
        }
        $this->providerName = ucfirst($providerName);
    }


    /**
     * @return \Hybrid_Auth
     */
    public function getHybridauth()
    {
        if (!$this->hybridauth) {
            $this->hybridauth = new \Hybrid_Auth($this->getOptions());
        }

        return $this->hybridauth;
    }

    /**
     * @param \Hybrid_Auth $hybridauth
     */
    public function setHybridauth($hybridauth)
    {
        $this->hybridauth = $hybridauth;
    }

    /**
     * @param \Application\Users\Row $identity
     */
    public function setIdentity($identity)
    {
        $this->identity = $identity;
    }

    /**
     * @return \Application\Users\Row $user
     */
    public function getIdentity()
    {
        return $this->identity;
    }

    /**
     * @return string
     */
    public function getProviderName()
    {
        return $this->providerName;
    }

    /**
     * @param string $providerName
     */
    public function setProviderName($providerName)
    {
        $this->providerName = $providerName;
    }

    /**
     * @return \Hybrid_Provider_Adapter
     * @throws \Exception
     */
    public function getAuthAdapter()
    {
        if (!$this->authAdapter) {
            /** @var \Hybrid_Provider_Adapter $authProvider */
            $this->authAdapter = $this->getHybridauth()->authenticate($this->providerName);

            if (!$this->authAdapter->isUserConnected()) {
                throw new \Exception('Cannot connect to current provider !');
            }
        }

        return $this->authAdapter;
    }

    /**
     * @param \Hybrid_Provider_Adapter $authAdapter
     */
    public function setAuthAdapter($authAdapter)
    {
        $this->authAdapter = $authAdapter;
    }

    /**
     * @param \Hybrid_User_Profile $data
     * @param  \Application\Users\Row $user
     * @return void
     */
    public function registration($data, $user)
    {
        $row = new Auth\Row();
        $row->userId = $user->id;
        $row->provider = strtolower($this->providerName);
        $row->foreignKey = $data->identifier;
        $row->token = $this->authAdapter->getAccessToken()['access_token'];
        $row->tokenSecret = ($this->authAdapter->getAccessToken()['access_token_secret']) ? : '';
        $row->tokenType = Auth\Table::TYPE_ACCESS;
        $row->save();

        Messages::addNotice(sprintf('Your account was linked to %s successfully !', $this->providerName));

The call to addNotice() misses a required argument $...$text.

        Response::redirectTo('users', 'profile', ['id' => $user->id]);
    }

    /**
     * @return void
     */
    public function authProcess()
    {
        $this->authAdapter = $this->getAuthAdapter();
        $profile = $this->getProfile();

        /**
         * @var Auth\Table $authTable
         */
        $authTable = Auth\Table::getInstance();
        $auth = $authTable->getAuthRow(strtolower($this->providerName), $profile->identifier);


        if ($this->identity) {
            if ($auth) {
                Messages::addNotice(sprintf('You have already linked to %s', $this->providerName));

The call to addNotice() misses a required argument $...$text.

                Response::redirectTo('users', 'profile', ['id' => $this->identity->id]);
            } else {
                $user = Users\Table::findRow($this->identity->id);
                $this->registration($profile, $user);
            }
        }

        if ($auth) {
            $this->alreadyRegisteredLogic($auth);

$auth of type object<Bluz\Auth\AbstractRow> is not a sub-type of object<Application\Auth\Row>. It seems like you assume a child class of the class Bluz\Auth\AbstractRow to be always present.

        } else {
            Messages::addError(sprintf('First you need to be linked to %s', $this->providerName));

The call to addError() misses a required argument $...$text.

            Response::redirectTo('users', 'signin');
        }
    }

    /**
     * @return array
     * @throws \Application\Exception
     */
    public function getOptions()
    {
        return Config::getData('hybridauth');
    }

    /**
     * @return array
     */
    public function getAvailableProviders()
    {
        return array_keys(Config::getData('hybridauth')['providers']);
    }

    /**
     * @param $auth
     * @return mixed
     */
    public function alreadyRegisteredLogic($auth)
    {
        $user = Users\Table::findRow($auth->userId);

        if ($user->status != Users\Table::STATUS_ACTIVE) {
            Messages::addError('User is not active');

The call to addError() misses a required argument $...$text.

        }

        $user->tryLogin();
        Response::redirectTo('index', 'index');
    }

    /**
     * @return \Hybrid_User_Profile
     */
    public function getProfile()
    {
        return $this->authAdapter->getUserProfile();
    }
}