nystudio107 / craft-instantanalytics-ga4

src/helpers/Analytics.php

<?php
/**
 * Instant Analytics plugin for Craft CMS
 *
 * @author    nystudio107

The tag in position 1 should be the @package tag

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @copyright Copyright (c) 2017 nystudio107

The tag in position 2 should be the @author tag

@copyright tag must contain a year and the name of the copyright holder

 * @link      http://nystudio107.com

The tag in position 3 should be the @copyright tag

 * @package   InstantAnalytics

The tag in position 4 should be the @link tag

 * @since     1.0.0
 */

PHP version not specified

Missing @category tag in file comment

Missing @license tag in file comment

namespace nystudio107\instantanalyticsGa4\helpers;

use Craft;
use craft\elements\User as UserElement;
use craft\helpers\App;
use craft\helpers\StringHelper;
use craft\helpers\UrlHelper;
use Jaybizzle\CrawlerDetect\CrawlerDetect;
use nystudio107\instantanalyticsGa4\InstantAnalytics;
use nystudio107\seomatic\Seomatic;
use yii\base\Exception;

/**

Missing short description in doc comment

 * @author    nystudio107

The tag in position 1 should be the @package tag

Content of the @author tag must be in the form "Display Name <username@example.com>"

Tag value for @author tag indented incorrectly; expected 2 spaces but found 4

 * @package   InstantAnalytics

Tag value for @package tag indented incorrectly; expected 1 spaces but found 3

 * @since     5.0.0

The tag in position 3 should be the @author tag

Tag value for @since tag indented incorrectly; expected 3 spaces but found 5

 */

Missing @category tag in class comment

Missing @license tag in class comment

Missing @link tag in class comment

class Analytics
{
    /**
     * If SEOmatic is installed, set the page title from it
     */

Missing @return tag in function comment

    public static function getTitleFromSeomatic(): ?string
    {
        if (!InstantAnalytics::$seomaticPlugin) {
            return null;
        }
        if (!Seomatic::$settings->renderEnabled) {
            return null;
        }
        $titleTag = Seomatic::$plugin->title->get('title');

        if ($titleTag === null) {
            return null;
        }

        $titleArray = $titleTag->renderAttributes();

        if (empty($titleArray['title'])) {
            return null;
        }

        return $titleArray['title'];
    }

    /**
     * Return a sanitized documentPath from a URL
     *
     * @param string $url

Missing parameter comment

     *
     * @return string
     */
    public static function getDocumentPathFromUrl(string $url = ''): string
    {
        if ($url === '') {
            $url = Craft::$app->getRequest()->getFullPath();
        }

        // We want to send just a path to GA for page views
        if (UrlHelper::isAbsoluteUrl($url)) {
            $urlParts = parse_url($url);
            $url = $urlParts['path'] ?? '/';
            if (isset($urlParts['query'])) {
                $url .= '?' . $urlParts['query'];
            }
        }

        // We don't want to send protocol-relative URLs either
        if (UrlHelper::isProtocolRelativeUrl($url)) {
            $url = substr($url, 1);
        }

        // Strip the query string if that's the global config setting
        if (InstantAnalytics::$settings) {
            if (InstantAnalytics::$settings->stripQueryString !== null
                && InstantAnalytics::$settings->stripQueryString) {

Closing parenthesis of a multi-line IF statement must be on a new line

                $url = UrlHelper::stripQueryString($url);
            }
        }

        // We always want the path to be / rather than empty
        if ($url === '') {
            $url = '/';
        }

        return $url;
    }

    /**
     * Get a PageView tracking URL
     *
     * @param $url

Missing parameter comment

     * @param $title

Missing parameter comment

     *
     * @return string
     * @throws Exception
     */
    public static function getPageViewTrackingUrl($url, $title): string
    {
        $urlParams = compact('url', 'title');

        $path = parse_url($url, PHP_URL_PATH);
        $pathFragments = explode('/', rtrim($path, '/'));
        $fileName = end($pathFragments);
        $trackingUrl = UrlHelper::siteUrl('instantanalytics/pageViewTrack/' . $fileName, $urlParams);

        InstantAnalytics::$plugin->logAnalyticsEvent(

The method logAnalyticsEvent() does not exist on null.

            'Created pageViewTrackingUrl for: {trackingUrl}',
            [
                'trackingUrl' => $trackingUrl,
            ],
            __METHOD__
        );

        return $trackingUrl;
    }

    /**
     * Get an Event tracking URL
     *
     * @param string $url

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param string $eventName

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param array $params

Missing parameter comment

Expected 2 spaces after parameter type; 1 found

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return string

Tag @return cannot be grouped with parameter tags in a doc comment

     * @throws Exception

Tag @throws cannot be grouped with parameter tags in a doc comment

     */
    public static function getEventTrackingUrl(
        string $url,
        string $eventName,
        array  $params = [],
    ): string {
        $urlParams = compact('url', 'eventName', 'params');

        $fileName = pathinfo(parse_url($url, PHP_URL_PATH), PATHINFO_BASENAME);
        $trackingUrl = UrlHelper::siteUrl('instantanalytics/eventTrack/' . $fileName, $urlParams);

Are you sure $fileName of type array|string can be used in concatenation?

        InstantAnalytics::$plugin->logAnalyticsEvent(
            'Created eventTrackingUrl for: {trackingUrl}',
            [
                'trackingUrl' => $trackingUrl,
            ],
            __METHOD__
        );

        return $trackingUrl;
    }

    /**
     * _shouldSendAnalytics determines whether we should be sending Google
     * Analytics data
     *
     * @return bool
     */
    public static function shouldSendAnalytics(): bool
    {
        $result = true;
        $request = Craft::$app->getRequest();

        $logExclusion = static function(string $setting) {

Expected 1 space after FUNCTION keyword; 0 found

            if (InstantAnalytics::$settings->logExcludedAnalytics) {
                $request = Craft::$app->getRequest();
                $requestIp = $request->getUserIP();
                InstantAnalytics::$plugin->logAnalyticsEvent(
                    'Analytics excluded for:: {requestIp} due to: `{setting}`',
                    compact('requestIp', 'setting'),
                    __METHOD__
                );
            }
        };

        if (!InstantAnalytics::$settings->sendAnalyticsData) {
            $logExclusion('sendAnalyticsData');
            return false;
        }

        if (!InstantAnalytics::$settings->sendAnalyticsInDevMode && Craft::$app->getConfig()->getGeneral()->devMode) {
            $logExclusion('sendAnalyticsInDevMode');
            return false;
        }

        if ($request->getIsConsoleRequest()) {
            $logExclusion('Craft::$app->getRequest()->getIsConsoleRequest()');
            return false;
        }

        if ($request->getIsCpRequest()) {
            $logExclusion('Craft::$app->getRequest()->getIsCpRequest()');
            return false;
        }

        if ($request->getIsLivePreview()) {
            $logExclusion('Craft::$app->getRequest()->getIsLivePreview()');
            return false;
        }

        // Check the $_SERVER[] super-global exclusions
        if (InstantAnalytics::$settings->serverExcludes !== null
            && !empty(InstantAnalytics::$settings->serverExcludes)) {

Closing parenthesis of a multi-line IF statement must be on a new line

            foreach (InstantAnalytics::$settings->serverExcludes as $match => $matchArray) {
                if (isset($_SERVER[$match])) {
                    foreach ($matchArray as $matchItem) {
                        if (preg_match($matchItem, $_SERVER[$match])) {
                            $logExclusion('serverExcludes');

                            return false;
                        }
                    }
                }
            }
        }

        // Filter out bot/spam requests via UserAgent
        if (InstantAnalytics::$settings->filterBotUserAgents) {
            $crawlerDetect = new CrawlerDetect();
            // Check the user agent of the current 'visitor'
            if ($crawlerDetect->isCrawler()) {
                $logExclusion('filterBotUserAgents');

                return false;
            }
        }

        // Filter by user group
        $userService = Craft::$app->getUser();
        /** @var ?UserElement $user */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

        $user = $userService->getIdentity();
        if ($user) {
            if (InstantAnalytics::$settings->adminExclude && $user->admin) {
                $logExclusion('adminExclude');

                return false;
            }

            if (InstantAnalytics::$settings->groupExcludes !== null
                && !empty(InstantAnalytics::$settings->groupExcludes)) {

Closing parenthesis of a multi-line IF statement must be on a new line

                foreach (InstantAnalytics::$settings->groupExcludes as $matchItem) {
                    if ($user->isInGroup($matchItem)) {
                        $logExclusion('groupExcludes');

                        return false;
                    }
                }
            }
        }

        return $result;
    }

    /**
     * getClientId handles the parsing of the _ga cookie or setting it to a

Doc comment short description must start with a capital letter

     * unique identifier
     *
     * @return string the cid
     */
    public static function getClientId(): string
    {
        $cid = '';
        if (isset($_COOKIE['_ga'])) {
            $parts = explode(".", $_COOKIE['_ga'], 4);
            if ($parts !== false) {
                $cid = implode('.', array_slice($parts, 2));
            }
        } elseif (isset($_COOKIE['_ia']) && $_COOKIE['_ia'] !== '') {
            $cid = $_COOKIE['_ia'];
        } else {
            // Generate our own client id, otherwise.
            $cid = static::gaGenUUID() . '.1';
        }

        if (InstantAnalytics::$settings->createGclidCookie && !empty($cid)) {
            setcookie('_ia', $cid, strtotime('+2 years'), '/'); // Two years
        }

        return $cid;
    }

    /**
     * Get the Google Analytics session string from the cookie.
     *
     * @return string
     */
    public static function getSessionString(): string
    {
        $sessionString = '';
        $measurementId = App::parseEnv(InstantAnalytics::$settings->googleAnalyticsMeasurementId);
        $cookieName = '_ga_' . StringHelper::removeLeft($measurementId, 'G-');

It seems like $measurementId can also be of type null; however, parameter $str of craft\helpers\StringHelper::removeLeft() does only seem to accept string, maybe add an additional type check?

        if (isset($_COOKIE[$cookieName])) {
            $parts = explode(".", $_COOKIE[$cookieName], 5);
            if ($parts !== false) {
                $sessionString = implode('.', array_slice($parts, 2, 2));
            }
        }

        return $sessionString;
    }

    /**
     * Get the user id.
     *
     * @return string
     */
    public static function getUserId(): string
    {
        $userId = Craft::$app->getUser()->getId();

        if (!$userId) {
            return '';
        }

        return $userId;
    }

    /**
     * gaGenUUID Generate UUID v4 function - needed to generate a CID when one

Doc comment short description must start with a capital letter

     * isn't available
     *
     * @return string The generated UUID
     */
    protected static function gaGenUUID()
    {
        return sprintf(
            '%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
            // 32 bits for "time_low"
            mt_rand(0, 0xffff),
            mt_rand(0, 0xffff),
            // 16 bits for "time_mid"
            mt_rand(0, 0xffff),
            // 16 bits for "time_hi_and_version",
            // four most significant bits holds version number 4
            mt_rand(0, 0x0fff) | 0x4000,
            // 16 bits, 8 bits for "clk_seq_hi_res",
            // 8 bits for "clk_seq_low",
            // two most significant bits holds zero and one for variant DCE1.1
            mt_rand(0, 0x3fff) | 0x8000,
            // 48 bits for "node"
            mt_rand(0, 0xffff),
            mt_rand(0, 0xffff),
            mt_rand(0, 0xffff)
        );
    }
}