AbstractAuthorizer::shouldStartAuthorization() - Code Metrics - Inspection of "Syntax" - fbett/le-acme2-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (fc5382)

by Fabian

created 2021-12-07 15:18 UTC

AbstractAuthorizer::shouldStartAuthorization() A

↳ Parent: AbstractAuthorizer

Complexity

Conditions	4
Paths	3

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
eloc	9
dl	0
loc	17
ccs	0
cts	10
cp	0
rs	9.9666
c	0
b	0
f	0
cc	4
nc	3
nop	0
crap	20

<?php

namespace LE_ACME2\Authorizer;

use LE_ACME2\Response;

use LE_ACME2\Cache;
use LE_ACME2\Utilities;
use LE_ACME2\Exception;

use LE_ACME2\Account;
use LE_ACME2\Order;

abstract class AbstractAuthorizer {

    protected $_account;
    protected $_order;

    /**
     * AbstractAuthorizer constructor.
     *
     * @param Account $account
     * @param Order $order
     *
     * @throws Exception\InvalidResponse
     * @throws Exception\RateLimitReached
     * @throws Exception\ExpiredAuthorization
     */
    public function __construct(Account $account, Order $order) {

        $this->_account = $account;
        $this->_order = $order;

        $this->_fetchAuthorizationResponses();
    }

    /** @var Response\Authorization\Get[] $_authorizationResponses */
    protected $_authorizationResponses = [];

    /**
     * @throws Exception\InvalidResponse
     * @throws Exception\RateLimitReached
     * @throws Exception\ExpiredAuthorization
     */
    protected function _fetchAuthorizationResponses() {

        if(!file_exists($this->_order->getKeyDirectoryPath() . 'private.pem')) {

            Utilities\Logger::getInstance()->add(
            Utilities\Logger::getInstance()->/** @scrutinizer ignore-call */ add(
                Utilities\Logger::LEVEL_DEBUG,
                get_class() . '::' . __FUNCTION__ . ' result suppressed (Order has finished already)',
            );

            return;
        }

        $orderResponse = Cache\OrderResponse::getInstance()->get($this->_order);
        $orderResponse = Cache\OrderResponse::getInstance()->/** @scrutinizer ignore-call */ get($this->_order);

        foreach($orderResponse->getAuthorizations() as $authorization) {

            $this->_authorizationResponses[] = Cache\OrderAuthorizationResponse::getInstance()
                ->get($this->_order, $authorization, $this->_getChallengeType());
        }
    }

    protected function _hasValidAuthorizationResponses() : bool {

        return count($this->_authorizationResponses) > 0;
    }

    public function shouldStartAuthorization() : bool {

        foreach($this->_authorizationResponses as $response) {

            $challenge = $response->getChallenge($this->_getChallengeType());
            if($challenge && $challenge->status == Response\Authorization\Struct\Challenge::STATUS_PENDING) {

                Utilities\Logger::getInstance()->add(
                    Utilities\Logger::LEVEL_DEBUG,
                    get_class() . '::' . __FUNCTION__ . ' "Pending challenge found',
                    [get_class($challenge) => $challenge]
                );

                return true;
            }
        }
        return false;
    }

    abstract protected function _getChallengeType() : string;

    private $_progressed = false;

    /**
     * @throws Exception\AuthorizationInvalid
     * @throws Exception\InvalidResponse
     * @throws Exception\RateLimitReached
     * @throws Exception\ExpiredAuthorization
     */
    public function progress() {

        if($this->_progressed) {
            return;
        }

        $this->_progressed = true;

        if(!$this->_hasValidAuthorizationResponses())
            return;

        $existsNotValidChallenges = false;

        foreach($this->_authorizationResponses as $authorizationResponse) {

            $challenge = $authorizationResponse->getChallenge($this->_getChallengeType());

            if($challenge && $this->_existsNotValidChallenges($challenge, $authorizationResponse)) {
                $existsNotValidChallenges = true;
            }
        }

        $this->_finished = !$existsNotValidChallenges;
    }

    /**
     * @param Response\Authorization\Struct\Challenge $challenge
     * @param Response\Authorization\Get $authorizationResponse
     * @return bool
     *
     * @throws Exception\AuthorizationInvalid
     */
    protected function _existsNotValidChallenges(Response\Authorization\Struct\Challenge $challenge,
                                                 Response\Authorization\Get $authorizationResponse
                                                 /** @scrutinizer ignore-unused */ Response\Authorization\Get $authorizationResponse
    ) : bool {

        if($challenge->status == Response\Authorization\Struct\Challenge::STATUS_PENDING) {

            Utilities\Logger::getInstance()->add(
                Utilities\Logger::LEVEL_DEBUG,
                get_class() . '::' . __FUNCTION__ . ' "Non valid challenge found',
                [get_class($challenge) => $challenge]
            );

            return true;
        }
        else if($challenge->status == Response\Authorization\Struct\Challenge::STATUS_PROGRESSING) {

            // Should come back later
            return true;
        }
        else if($challenge->status == Response\Authorization\Struct\Challenge::STATUS_VALID) {

        }
        else if($challenge->status == Response\Authorization\Struct\Challenge::STATUS_INVALID) {
            throw new Exception\AuthorizationInvalid(
                'Received status "' . Response\Authorization\Struct\Challenge::STATUS_INVALID . '" while challenge should be verified'
            );
        }
        else {

            throw new \RuntimeException('Challenge status "' . $challenge->status . '" is not implemented');
        }

        return false;
    }

    protected $_finished = false;

    public function hasFinished() : bool {

        Utilities\Logger::getInstance()->add(
            Utilities\Logger::LEVEL_DEBUG,
            get_called_class() . '::' . __FUNCTION__,
            ['finished' => $this->_finished]
        );

        return $this->_finished;
    }
}



fbett / le-acme2-php

Branch — master (fc5382)

AbstractAuthorizer::shouldStartAuthorization() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like