Analytics::__call() - Code Metrics - nystudio107/craft-instantanalytics-ga4 - Measure and Improve Code Quality continuously with Scrutinizer

Analytics::__call() A
last analyzed 2024-09-14 20:54 UTC

↳ Parent: Analytics
Complexity

Conditions	4
Paths	3
Size

Total Lines	41
Code Lines	32
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	4
eloc	32
c	2
b	0
f	0
nc	3
nop	2
dl	0
loc	41
rs	9.408
<?php
/**
 * Instant Analytics plugin for Craft CMS
 *
 * @author    nystudio107

 * @copyright Copyright (c) 2017 nystudio107

 * @link      http://nystudio107.com

 * @package   InstantAnalytics

 * @since     1.0.0
 */


namespace nystudio107\instantanalyticsGa4\ga4;

use Br33f\Ga4\MeasurementProtocol\Dto\Event\AbstractEvent;
use Br33f\Ga4\MeasurementProtocol\Dto\Request\BaseRequest;
use Br33f\Ga4\MeasurementProtocol\Exception\HydrationException;
use Br33f\Ga4\MeasurementProtocol\Exception\ValidationException;
use Br33f\Ga4\MeasurementProtocol\HttpClient;
use Craft;
use craft\commerce\elements\Order;
use craft\commerce\elements\Product;
use craft\commerce\elements\Variant;
use craft\errors\MissingComponentException;
use craft\helpers\App;
use nystudio107\instantanalyticsGa4\helpers\Analytics as AnalyticsHelper;
use nystudio107\instantanalyticsGa4\InstantAnalytics;
use nystudio107\seomatic\Seomatic;
use yii\base\InvalidConfigException;

/**

 * @author    nystudio107

 * @package   InstantAnalytics

 * @since     1.2.0

 *
 * @method Analytics setAllowGoogleSignals(string $value)
 * @method Analytics setAllowAdPersonalizationSignals(string $value)
 * @method Analytics setCampaignContent(string $value)
 * @method Analytics setCampaignId(string $value)
 * @method Analytics setCampaignMedium(string $value)
 * @method Analytics setCampaignName(string $value)
 * @method Analytics setCampaignSource(string $value)
 * @method Analytics setCampaignTerm(string $value)
 * @method Analytics setCampaign(string $value)
 * @method Analytics setClientId(string $value)
 * @method Analytics setContentGroup(string $value)
 * @method Analytics setCookieDomain(string $value)
 * @method Analytics setCookieExpires(string $value)
 * @method Analytics setCookieFlags(string $value)
 * @method Analytics setCookiePath(string $value)
 * @method Analytics setCookiePrefix(string $value)
 * @method Analytics setCookieUpdate(string $value)
 * @method Analytics setLanguage(string $value)
 * @method Analytics setPageLocation(string $value)
 * @method Analytics setPageReferrer(string $value)
 * @method Analytics setPageTitle(string $value)
 * @method Analytics setSendPageView(string $value)
 * @method Analytics setScreenResolution(string $value)
 * @method Analytics setUserId(string $value)
 */

class Analytics
{
    /**

     * @var BaseRequest|null
     */
    private ?BaseRequest $_request = null;

    /**

     * @var Service|null|false
     */
    private mixed $_service = null;

    /**

     * @var string|null
     */
    private ?string $_affiliation = null;

    private ?bool $_shouldSendAnalytics = null;

    private ?string $_sessionString = null;

    private array $eventList = [];


    /**
     * Component factory for creating events.
     *
     * @return ComponentFactory
     */
    public function create(): ComponentFactory
    {
        return new ComponentFactory();
    }

    /**
     * Add an event to be sent to Google
     *
     * @param AbstractEvent $event

     * @return void

     */
    public function addEvent(AbstractEvent $event): void
    {
        if ($this->_sessionString === null) {
            $this->_sessionString = AnalyticsHelper::getSessionString();
        }

        if (str_contains($this->_sessionString, '.')) {
        if (str_contains(/** @scrutinizer ignore-type */ $this->_sessionString, '.')) {
            [$sessionId, $sessionNumber] = explode('.', $this->_sessionString);
            [$sessionId, $sessionNumber] = explode('.', /** @scrutinizer ignore-type */ $this->_sessionString);
            $event->setParamValue('sessionId', $sessionId);
            $event->setParamValue('sessionNumber', $sessionNumber);
        }

        $this->eventList[] = $event;
    }

    /**
     * Send the events collected so far.
     *
     * @return ?array
     * @throws HydrationException
     * @throws ValidationException
     */
    public function sendCollectedEvents(): ?array
    {
        if ($this->_shouldSendAnalytics === null) {
            $this->_shouldSendAnalytics = AnalyticsHelper::shouldSendAnalytics();
        }

        if (!$this->_shouldSendAnalytics) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            return null;
        }

        $service = $this->service();

        if (!$service) {
            return null;
        }

        $request = $this->request();
        $eventCount = count($this->eventList);

        if (!InstantAnalytics::$settings->sendAnalyticsData) {
            InstantAnalytics::$plugin->logAnalyticsEvent(
                                       logAnalyticsEvent(
                'Analytics not enabled - skipped sending {count} events',
                ['count' => $eventCount],
                __METHOD__
            );

            return null;
        }

        if ($eventCount === 0) {
            InstantAnalytics::$plugin->logAnalyticsEvent(
                'No events collected to send',
                [],
                __METHOD__
            );

            return null;
        }

        InstantAnalytics::$plugin->logAnalyticsEvent(
            'Sending {count} analytics events',
            ['count' => $eventCount],
            __METHOD__
        );

        // Batch into groups of 25
        $responses = [];

        foreach (array_chunk($this->eventList, 25) as $chunk) {
            $request->getEvents()->setEventList([]);

            /** @var AbstractEvent $event */

            foreach ($chunk as $event) {
                $request->addEvent($event);
            }

            $responses[] = $service->send($request);
        }


        return $responses;
    }

    public function getAffiliation(): ?string

    {
        return $this->_affiliation;
    }

    /**
     * Set affiliation for all the events that incorporate Commerce Product info for the remaining duration of request.
     *
     * @param string $affiliation

     * @return $this

     */
    public function setAffiliation(string $affiliation): self
    {
        $this->_affiliation = $affiliation;
        return $this;
    }

    /**
     * Add a commerce item list impression.
     *
     * @param Product|Variant $productVariant

     * @param int $index

     * @param string $listName

     * @throws InvalidConfigException

     */

    public function addCommerceProductImpression(Product|Variant $productVariant, int $index = 0, string $listName = 'default')
    {
        InstantAnalytics::$plugin->commerce->addCommerceProductImpression($productVariant);
    }

    /**
     * Begin checkout.
     *
     * @param Order $cart

     */

    public function beginCheckout(Order $cart)
    {
        InstantAnalytics::$plugin->commerce->triggerBeginCheckoutEvent($cart);
    }

    /**
     * Add a commerce item list impression.
     *
     * @param Product|Variant $productVariant

     * @param int $index

     * @param string $listName

     * @throws InvalidConfigException

     * @deprecated `Analytics::addCommerceProductDetailView()` is deprecated. Use `Analytics::addCommerceProductImpression()` instead.

     */

    public function addCommerceProductDetailView(Product|Variant $productVariant, int $index = 0, string $listName = 'default')
    {
        Craft::$app->getDeprecator()->log('Analytics::addCommerceProductDetailView()', '`Analytics::addCommerceProductDetailView()` is deprecated. Use `Analytics::addCommerceProductImpression()` instead.');
        $this->addCommerceProductImpression($productVariant);
    }

    /**
     * Add a commerce product list impression.
     *
     * @param array $products

     * @param $listName

     */

    public function addCommerceProductListImpression(array $products, string $listName = 'default')
    {
        InstantAnalytics::$plugin->commerce->addCommerceProductListImpression($products, $listName);
    }

    /**
     * Set the measurement id.
     *
     * @param string $measurementId

     * @return $this

     */
    public function setMeasurementId(string $measurementId): self
    {
        $this->service()?->setMeasurementId($measurementId);
        return $this;
    }

    /**
     * Set the API secret.
     *
     * @param string $apiSecret

     * @return $this

     */
    public function setApiSecret(string $apiSecret): self
    {
        $this->service()?->setApiSecret($apiSecret);
        return $this;
    }

    public function __call(string $methodName, array $arguments): ?self

    {
        $knownProperties = [
            'allowGoogleSignals' => 'allow_google_signals',
            'allowAdPersonalizationSignals' => 'allow_ad_personalization_signals',
            'campaignContent' => 'campaign_content',
            'campaignId' => 'campaign_id',
            'campaignMedium' => 'campaign_medium',
            'campaignName' => 'campaign_name',
            'campaignSource' => 'campaign_source',
            'campaignTerm' => 'campaign_term',
            'campaign' => 'campaign',
            'clientId' => 'client_id',
            'contentGroup' => 'content_group',
            'cookieDomain' => 'cookie_domain',
            'cookieExpires' => 'cookie_expires',
            'cookieFlags' => 'cookie_flags',
            'cookiePath' => 'cookie_path',
            'cookiePrefix' => 'cookie_prefix',
            'cookieUpdate' => 'cookie_update',
            'language' => 'language',
            'pageLocation' => 'page_location',
            'pageReferrer' => 'page_referrer',
            'pageTitle' => 'page_title',
            'sendPageView' => 'send_page_view',
            'screenResolution' => 'screen_resolution',
            'userId' => 'user_id',
        ];

        if (str_starts_with($methodName, 'set')) {
            $methodName = lcfirst(substr($methodName, 3));

            $service = $this->service();
            if ($service && !empty($knownProperties[$methodName])) {
                $service->setAdditionalQueryParam($knownProperties[$methodName], $arguments[0]);

                return $this;
            }
        }

        return null;
    }

    public function request(): BaseRequest

    {
        if ($this->_request === null) {
            $this->_request = new BaseRequest();

            $this->_request->setClientId(AnalyticsHelper::getClientId());
                             setClientId(AnalyticsHelper::getClientId());

            if (InstantAnalytics::$settings->sendUserId) {
                $userId = AnalyticsHelper::getUserId();

                if ($userId) {
                    $this->request()->setUserId($userId);
                }
            }
        }


        return $this->_request;

    }

    /**
     * Init the service used to send events
     */

    public function init(): void
    {
        $this->service();
        $this->request();
    }

    protected function service(): ?Service

    {
        if ($this->_service === null) {
            $settings = InstantAnalytics::$settings;
            $apiSecret = App::parseEnv($settings->googleAnalyticsMeasurementApiSecret);
            $measurementId = App::parseEnv($settings->googleAnalyticsMeasurementId);

            if (empty($apiSecret) || empty($measurementId)) {
                InstantAnalytics::$plugin->logAnalyticsEvent(
                    'API secret or measurement ID not set up for Instant Analytics',
                    [],
                    __METHOD__
                );
                $this->_service = false;

                return null;
            }
            $this->_service = new Service($apiSecret, $measurementId);

            $ga4Client = new HttpClient();
            $ga4Client->setClient(Craft::createGuzzleClient());
            $this->_service->setHttpClient($ga4Client);

            $request = Craft::$app->getRequest();
            try {
                $session = Craft::$app->getSession();
            } catch (MissingComponentException $exception) {
                $session = null;
            }

            $this->setPageReferrer($request->getReferrer());

            // Load any campaign values from session or request
            $campaignParams = [
                'utm_source' => 'CampaignSource',
                'utm_medium' => 'CampaignMedium',
                'utm_campaign' => 'CampaignName',
                'utm_content' => 'CampaignContent',
                'utm_term' => 'CampaignTerm',
            ];

            // Load them up for GA4
            foreach ($campaignParams as $key => $method) {
                $value = $request->getParam($key) ?? $session->get($key) ?? null;
                $method = 'set' . $method;

                $this->$method($value);

                if ($session && $value) {
                    $session->set($key, $value);
                }
            }

            // If SEOmatic is installed, set the affiliation as well
            if (InstantAnalytics::$seomaticPlugin && Seomatic::$settings->renderEnabled && Seomatic::$plugin->metaContainers->metaSiteVars !== null) {
                $siteName = Seomatic::$plugin->metaContainers->metaSiteVars->siteName;
                $this->setAffiliation($siteName);
            }
        }

        if ($this->_service === false) {
            return null;
        }

        return $this->_service;
    }
}

nystudio107 / craft-instantanalytics-ga4

Analytics::__call() A last analyzed 2024-09-14 20:54 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Analytics::__call() A
last analyzed 2024-09-14 20:54 UTC
