golden hour

/home/godaofbq/hardchambers.com/wp-content/plugins/notificationx-pro/includes/Extensions/Google/inc

File/Folder	Size	Actions
.htaccess	127 B
GoogleClient.php	8.37 KB
class-nxpro-ga-updater.php	13.69 KB
class-nxpro-ga4.php	7.51 KB
class-nxpro-google-client-helper.php	5.44 KB

Edit: GoogleClient.php

<?php
namespace NotificationXPro\Extensions\Google_Analytics;
use InvalidArgumentException;
use LogicException;
use NxProGA\Google\Auth\HttpHandler\HttpHandlerFactory;
use NxProGA\Monolog\Handler\SyslogHandler as MonologSyslogHandler;
use NxProGA\Google\Auth\OAuth2;
use NxProGA\Monolog\Logger;
use NxProGA\Monolog\Handler\StreamHandler as MonologStreamHandler;
use NxProGA\GuzzleHttp\ClientInterface;
use NxProGA\GuzzleHttp\Client as GuzzleClient;

class GoogleClient {
    const OAUTH2_REVOKE_URI = 'https://oauth2.googleapis.com/revoke';
    const OAUTH2_TOKEN_URI = 'https://oauth2.googleapis.com/token';
    const OAUTH2_AUTH_URL = 'https://accounts.google.com/o/oauth2/auth';

private $applicationName;
    private $scopes;
    private $clientId;
    private $clientSecret;
    private $accessType;
    private $redirectUri;
    private $state;
    private $approvalPrompt;
    private $token;
    private $auth;
    private $config;
    private $http;
    /**
     * @var ?LoggerInterface $logger
     */
    private $logger;
    public function setApplicationName($applicationName) {
        $this->applicationName = $applicationName;
    }

public function setScopes($scopes) {
        $this->scopes = $scopes;
    }

public function setClientId($clientId) {
        $this->clientId = $clientId;
    }

public function setClientSecret($clientSecret) {
        $this->clientSecret = $clientSecret;
    }

public function setAccessType($accessType) {
        $this->accessType = $accessType;
    }

public function setRedirectUri($redirectUri) {
        $this->redirectUri = $redirectUri;
    }

public function setState($state) {
        $this->state = $state;
    }

public function setApprovalPrompt($approvalPrompt) {
        $this->approvalPrompt = $approvalPrompt;
    }

public function fetchAccessTokenWithAuthCode($code) {
        // TODO: Implement this method
    }

public function isAccessTokenExpired() {
        if (!$this->token) {
            return true;
        }

$created = 0;
        if (isset($this->token['created'])) {
            $created = $this->token['created'];
        } elseif (isset($this->token['id_token'])) {
            // check the ID token for "iat"
            // signature verification is not required here, as we are just
            // using this for convenience to save a round trip request
            // to the NxProGA\Google API server
            $idToken = $this->token['id_token'];
            if (substr_count($idToken, '.') == 2) {
                $parts = explode('.', $idToken);
                $payload = json_decode(base64_decode($parts[1]), true);
                if ($payload && isset($payload['iat'])) {
                    $created = $payload['iat'];
                }
            }
        }
        if (!isset($this->token['expires_in'])) {
            // if the token does not have an "expires_in", then it's considered expired
            return true;
        }

// If the token is set to expire in the next 30 seconds.
        return ($created + ($this->token['expires_in'] - 30)) < time();
    }

public function setAccessToken($token) {
        if (is_string($token)) {
            if ($json = json_decode($token, true)) {
                $token = $json;
            } else {
                // assume $token is just the token string
                $token = [
                    'access_token' => $token,
                ];
            }
        }
        if ($token == null) {
            throw new InvalidArgumentException('invalid json token');
        }
        if (!isset($token['access_token'])) {
            throw new InvalidArgumentException("Invalid token format");
        }
        $this->token = $token;
    }

public function revokeToken() {
        // TODO: Implement this method
    }

public function getAccessToken() {
        // TODO: Implement this method
    }

public function getRedirectUri() {
        // TODO: Implement this method
    }

/**
     * @return LoggerInterface
     */
    public function getLogger()
    {
        if (!isset($this->logger)) {
            $this->logger = $this->createDefaultLogger();
        }

return $this->logger;
    }
    /**
     * @return OAuth2 implementation
     */
    public function getOAuth2Service()
    {
        if (!isset($this->auth)) {
            $this->auth = $this->createOAuth2Service();
        }

return $this->auth;
    }
    public function getClientId()
    {
        return $this->config['client_id'];
    }

public function getClientSecret()
    {
        return $this->config['client_secret'];
    }

/**
     * create a default google auth object
     */
    protected function createOAuth2Service()
    {
        $auth = new OAuth2([
            'clientId'          => $this->getClientId(),
            'clientSecret'      => $this->getClientSecret(),
            'authorizationUri'   => self::OAUTH2_AUTH_URL,
            'tokenCredentialUri' => self::OAUTH2_TOKEN_URI,
            'redirectUri'       => $this->getRedirectUri(),
            'issuer'            => $this->config['client_id'],
            'signingKey'        => $this->config['signing_key'],
            'signingAlgorithm'  => $this->config['signing_algorithm'],
        ]);

return $auth;
    }

/**
     * Are we running in NxProGA\Google AppEngine?
     * return bool
     */
    public function isAppEngine()
    {
        return (isset($_SERVER['SERVER_SOFTWARE']) &&
            strpos($_SERVER['SERVER_SOFTWARE'], 'NxProGA\Google App Engine') !== false);
    }

protected function createDefaultLogger()
    {
        $logger = new Logger('google-api-php-client');
        if ($this->isAppEngine()) {
            $handler = new MonologSyslogHandler('app', LOG_USER, Logger::NOTICE);
        } else {
            $handler = new MonologStreamHandler('php://stderr', Logger::NOTICE);
        }
        $logger->pushHandler($handler);

return $logger;
    }

/**
     * @return ClientInterface
     */
    public function getHttpClient()
    {
        if (null === $this->http) {
            $this->http = $this->createDefaultHttpClient();
        }

return $this->http;
    }

protected function createDefaultHttpClient()
    {
        $guzzleVersion = null;
        if (defined('\NxProGA\GuzzleHttp\ClientInterface::MAJOR_VERSION')) {
            $guzzleVersion = ClientInterface::MAJOR_VERSION;
        } elseif (defined('\NxProGA\GuzzleHttp\ClientInterface::VERSION')) {
            // @phpstan-ignore-next-line
            $guzzleVersion = (int)substr(ClientInterface::VERSION, 0, 1);
        }

if (5 === $guzzleVersion) {
            $options = [
                'base_url' => $this->config['base_path'],
                'defaults' => ['exceptions' => false],
            ];
            if ($this->isAppEngine()) {
                if (class_exists(StreamHandler::class)) {
                    // set StreamHandler on AppEngine by default
                    $options['handler'] = new StreamHandler();
                    $options['defaults']['verify'] = '/etc/ca-certificates.crt';
                }
            }
        } elseif (6 === $guzzleVersion || 7 === $guzzleVersion) {
            // guzzle 6 or 7
            $options = [
                'base_uri' => $this->config['base_path'],
                'http_errors' => false,
            ];
        } else {
            throw new LogicException('Could not find supported version of Guzzle.');
        }

return new GuzzleClient($options);
    }

public function refreshToken($refreshToken) {
        if (null === $refreshToken) {
            if (!isset($this->token['refresh_token'])) {
                throw new LogicException(
                    'refresh token must be passed in or set as part of setAccessToken'
                );
            }
            $refreshToken = $this->token['refresh_token'];
        }
        $this->getLogger()->info('OAuth2 access token refresh');
        $auth = $this->getOAuth2Service();
        $auth->setRefreshToken($refreshToken);

$httpHandler = HttpHandlerFactory::build($this->getHttpClient());
        $creds = $auth->fetchAuthToken($httpHandler);
        if ($creds && isset($creds['access_token'])) {
            $creds['created'] = time();
            if (!isset($creds['refresh_token'])) {
                $creds['refresh_token'] = $refreshToken;
            }
            $this->setAccessToken($creds);
        }

return $creds;
    }

}