Gateway::getEmbedHtml() - Code Metrics - Inspection of "Refactoring" - dukt/videos - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — v2 ( 62fbe8...8bc98f )

by Benjamin
created 2018-05-08 21:25 UTC
Gateway::getEmbedHtml() B

↳ Parent: Gateway
Complexity

Conditions	6
Paths	20
Size

Total Lines	36
Code Lines	20
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	6
eloc	20
nc	20
nop	2
dl	0
loc	36
rs	8.439
c	0
b	0
f	0
<?php
/**
 * @link      https://dukt.net/videos/
 * @copyright Copyright (c) 2018, Dukt
 * @license   https://github.com/dukt/videos/blob/v2/LICENSE.md
 */

namespace dukt\videos\base;

use Craft;
use craft\helpers\Json;
use craft\helpers\UrlHelper;
use dukt\videos\errors\ApiResponseException;
use dukt\videos\errors\GatewayMethodNotFoundException;
use dukt\videos\errors\JsonParsingException;
use dukt\videos\errors\VideoNotFoundException;
use dukt\videos\Plugin as Videos;
use GuzzleHttp\Exception\BadResponseException;
use Exception;
use Psr\Http\Message\ResponseInterface;
use yii\web\Response;


/**
 * Gateway is the base class for classes representing video gateways.
 *
 * @author Dukt <[email protected]>
 * @since  1.0
 */
abstract class Gateway implements GatewayInterface
{
    // Public Methods
    // =========================================================================

    /**
     * Return the handle of the gateway based on its class name
     *
     * @return string
     */
    public function getHandle(): string
    {
        $handle = \get_class($this);
        $handle = strtolower(substr($handle, strrpos($handle, "\\") + 1));

        return $handle;
    }

    /**
     * Returns the icon URL.
     *
     * @return string|false|null
     */
    public function getIconUrl()
    {
        $iconAlias = $this->getIconAlias();

        if (file_exists(Craft::getAlias($iconAlias))) {
            return Craft::$app->assetManager->getPublishedUrl($iconAlias, true);
        }

        return null;
    }

    /**
     * OAuth Connect.
     *
     * @return Response
     */
    public function oauthConnect(): Response
    {
        $provider = $this->getOauthProvider();

        Craft::$app->getSession()->set('videos.oauthState', $provider->getState());

        $scope = $this->getOauthScope();
        $options = $this->getOauthAuthorizationOptions();

        if (!\is_array($options)) {

            $options = [];
        }

        $options['scope'] = $scope;

        $authorizationUrl = $provider->getAuthorizationUrl($options);

        return Craft::$app->getResponse()->redirect($authorizationUrl);

    }

    /**
     * Returns the gateway's OAuth provider.
     *
     * @return mixed
     */
    public function getOauthProvider()
    {
        $oauthProviderOptions = Videos::$plugin->getSettings()->oauthProviderOptions;

        $options = [];

        if (isset($oauthProviderOptions[$this->getHandle()])) {
            $options = $oauthProviderOptions[$this->getHandle()];
        }

        if (!isset($options['redirectUri'])) {
            $options['redirectUri'] = $this->getRedirectUri();
        }

        return $this->createOauthProvider($options);
    }

    /**
     * Returns the OAuth provider’s name.
     *
     * @return string
     */
    public function getOauthProviderName(): string
    {
        return $this->getName();
    }

    /**
     * Returns the redirect URI.
     *
     * @return string
     */
    public function getRedirectUri(): string
    {
        return UrlHelper::actionUrl('videos/oauth/callback');
    }

    /**
     * OAuth Scope
     *
     * @return array|null
     */
    public function getOauthScope()
    {
        return null;
    }

    /**
     * OAuth Authorization Options
     *
     * @return array|null
     */
    public function getOauthAuthorizationOptions()
    {
        return null;
    }

    /**
     * OAuth Callback
     *
     * @return Response
     */
    public function oauthCallback(): Response
    {
        $provider = $this->getOauthProvider();

        $code = Craft::$app->getRequest()->getParam('code');

        try {
            // Try to get an access token (using the authorization code grant)
            $token = $provider->getAccessToken('authorization_code', [
                'code' => $code
            ]);

            // Save token
            Videos::$plugin->getOauth()->saveToken($this->getHandle(), $token);

            // Reset session variables

            // Redirect
            Craft::$app->getSession()->setNotice(Craft::t('videos', 'Connected to {gateway}.', ['gateway' => $this->getName()]));
        } catch (Exception $e) {
            Craft::error('Couldn’t connect to video gateway:'."\r\n"
                .'Message: '."\r\n".$e->getMessage()."\r\n"
                .'Trace: '."\r\n".$e->getTraceAsString(), __METHOD__);

            // Failed to get the token credentials or user details.
            Craft::$app->getSession()->setError($e->getMessage());
        }

        $redirectUrl = UrlHelper::cpUrl('videos/settings');

        return Craft::$app->getResponse()->redirect($redirectUrl);

    }

    /**
     * Has Token
     *
     * @return bool
     * @throws \yii\base\InvalidConfigException
     */
    public function hasToken(): bool
    {
        $tokenData = Videos::$plugin->getOauth()->getTokenData($this->getHandle());

        if ($tokenData) {
            return true;
        }

        return false;
    }

    /**
     * Returns the gateway's OAuth token.
     *
     * @return mixed
     * @throws \yii\base\InvalidConfigException
     */
    public function getOauthToken()
    {
        return Videos::$plugin->getOauth()->getToken($this->getHandle());
    }

    /**
     * Whether the OAuth flow should be enable or not for this gateway.
     *
     * @return bool
     */
    public function enableOauthFlow(): bool
    {
        return true;
    }

    /**
     * Returns the HTML of the embed from a video ID.
     *
     * @param       $videoId
     * @param array $options
     *
     * @return string
     */
    public function getEmbedHtml($videoId, array $options = []): string
    {
        $embedAttributes = [
            'frameborder' => '0',
            'allowfullscreen' => 'true',
            'allowscriptaccess' => 'true'
        ];

        $disableSize = $options['disable_size'] ?? false;

        if (!$disableSize) {
            if (isset($options['width'])) {
                $embedAttributes['width'] = $options['width'];
                unset($options['width']);
            }

            if (isset($options['height'])) {
                $embedAttributes['height'] = $options['height'];
                unset($options['height']);
            }
        }

        if (!empty($options['iframeClass'])) {
            $embedAttributes['class'] = $options['iframeClass'];
            unset($options['iframeClass']);
        }

        $embedUrl = $this->getEmbedUrl($videoId, $options);

        $embedAttributesString = '';

        foreach ($embedAttributes as $key => $value) {
            $embedAttributesString .= ' '.$key.'="'.$value.'"';
        }

        return '<iframe src="'.$embedUrl.'"'.$embedAttributesString.'></iframe>';
    }

    /**
     * Returns the URL of the embed from a video ID.
     *
     * @param       $videoId
     * @param array $options
     *
     * @return string
     */
    public function getEmbedUrl($videoId, array $options = []): string
    {
        $format = $this->getEmbedFormat();

        if (\count($options) > 0) {
            $queryMark = '?';

            if (strpos($this->getEmbedFormat(), '?') !== false) {
                $queryMark = '&';
            }

            $options = http_build_query($options);

            $format .= $queryMark.$options;
        }

        return sprintf($format, $videoId);
    }

    /**
     * Returns the javascript origin URL.
     *
     * @return string
     * @throws \craft\errors\SiteNotFoundException
     */
    public function getJavascriptOrigin(): string
    {
        return UrlHelper::baseUrl();
    }

    /**
     * Returns the account.
     *
     * @return mixed
     * @throws Exception
     */
    public function getAccount()
    {
        $token = $this->getOauthToken();

        if ($token) {
            $account = Videos::$plugin->getCache()->get(['getAccount', $token]);

            if (!$account) {
                $oauthProvider = $this->getOauthProvider();
                $account = $oauthProvider->getResourceOwner($token);

                Videos::$plugin->getCache()->set(['getAccount', $token], $account);
            }

            if ($account) {
                return $account;
            }
        }

        return null;
    }

    /**
     * Returns a video from its public URL.
     *
     * @param $url
     *
     * @return mixed
     * @throws VideoNotFoundException
     */
    public function getVideoByUrl($url)
    {
        $url = $url['url'];

        $videoId = $this->extractVideoIdFromUrl($url);

        if (!$videoId) {
            throw new VideoNotFoundException('Video not found with url given.');
        }

        return $this->getVideoById($videoId);
        return $this->getVideoById(/** @scrutinizer ignore-type */ $videoId);
    }

    /**
     * Returns a list of videos.
     *
     * @param $method
     * @param $options
     *
     * @return mixed
     * @throws GatewayMethodNotFoundException
     */
    public function getVideos($method, $options)
    {
        $realMethod = 'getVideos'.ucwords($method);

        if (method_exists($this, $realMethod)) {
            return $this->{$realMethod}($options);
        }

        throw new GatewayMethodNotFoundException('Gateway method “'.$realMethod.'” not found.');
    }

    /**
     * Number of videos per page.
     *
     * @return mixed
     */
    public function getVideosPerPage()
    {
        return Videos::$plugin->getSettings()->videosPerPage;
    }

    /**
     * Returns the OAuth provider options.
     *
     * @return array|null
     */
    public function getOauthProviderOptions()
    {
        $allOauthProviderOptions = Videos::$plugin->getSettings()->oauthProviderOptions;

        if (isset($allOauthProviderOptions[$this->getHandle()])) {
            return $allOauthProviderOptions[$this->getHandle()];
        }

        return null;
    }

    /**
     * Whether the gateway supports search or not.
     *
     * @return bool
     */
    public function supportsSearch(): bool
    {
        return false;
    }

    // Protected Methods
    // =========================================================================

    /**
     * Performs a GET request on the API.
     *
     * @param       $uri
     * @param array $options
     *
     * @return array
     * @throws ApiResponseException
     */
    protected function get($uri, array $options = []): array
    {
        $client = $this->createClient();
        $client = $this->createClient();

        try {
            $response = $client->request('GET', $uri, $options);
            $body = (string)$response->getBody();
            $data = Json::decode($body);
        } catch (BadResponseException $badResponseException) {
            $response = $badResponseException->getResponse();
            $body = (string)$response->getBody();

            try {
                $data = Json::decode($body);
            } catch (JsonParsingException $e) {
                throw $badResponseException;
            }
        }

        $this->checkResponse($response, $data);

        return $data;

    }

    /**
     * Checks a provider response for errors.
     *
     * @param ResponseInterface $response
     * @param                   $data
     *
     * @throws ApiResponseException
     */
    protected function checkResponse(ResponseInterface $response, $data)
    {
        if (!empty($data['error'])) {
            $code = 0;
            $error = $data['error'];

            if (\is_array($error)) {
                $code = $error['code'];
                $error = $error['message'];
            }

            throw new ApiResponseException($error, $code);
        }
    }
}

dukt / videos

Push — v2 ( 62fbe8...8bc98f )

Gateway::getEmbedHtml() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
