Payload::parse() - Code Metrics - FlexyProject/GitHubAPI - Measure and Improve Code Quality continuously with Scrutinizer

Payload::parse() B
last analyzed 2017-05-05 20:59 UTC

↳ Parent: Payload

Complexity

Conditions	4
Paths	4

Size

Total Lines	24
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	24
rs	8.6845
c	0
b	0
f	0
cc	4
eloc	14
nc	4
nop	0

<?php
namespace FlexyProject\GitHub\Event;

use Exception;
use FlexyProject\GitHub\Exception\BadSignatureException;
use FlexyProject\GitHub\WebHook;
use Symfony\Component\HttpFoundation\ServerBag;

/**
 * Payloads
 *
 * @link    https://developer.github.com/webhooks/#payloads
 * @package FlexyProject\GitHub\Event
 */
class Payload implements EventInterface
{
    /** @var WebHook */
    protected $webHook;

    /** @var null|string */
    protected $secret = null;

    /** @var string|resource */
    protected $rawData;

    /** @var mixed */
    protected $parsedData;

    /** @var ServerBag */
    protected $serverBag;

    /**
     * Constructor, pass a WebHook object
     *
     * @param WebHook $webHook
     */
    public function __construct(WebHook $webHook)
    {
        $this->setWebHook($webHook);
        $request = $webHook->getRequest();
        $this->setRawData($request->getContent());
        $this->serverBag = $request->server;
    }

    /**
     * Get webHook
     *
     * @return null|WebHook
     */
    public function getWebHook()
    {
        return $this->webHook;
    }

    /**
     * Set webHook
     *
     * @param mixed $webHook
     *
     * @return Payload
     */
    public function setWebHook($webHook): Payload
    {
        $this->webHook = $webHook;

        return $this;
    }

    /**
     * Set secret, encode this secret with Hmac, SHA1 method
     *
     * @param string $secret
     *
     * @return Payload
     */
    public function setSecret(string $secret): Payload
    {
        $this->secret = hash_hmac('sha1', $this->rawData, $secret);

        return $this;
    }

    /**
     * Get secret
     *
     * @return null|string
     */
    public function getSecret()
    {
        return $this->secret;
    }

    /**
     * Get rawData
     *
     * @return resource|string
     */
    public function getRawData()
    {
        return $this->rawData;
    }

    /**
     * Set rawData
     *
     * @param resource|string $rawData
     *
     * @return Payload
     */
    public function setRawData($rawData): Payload
    {
        $this->rawData = $rawData;

        return $this;
    }

    /**
     * Get parsedData
     *
     * @return mixed
     */
    public function getData()
    {
        return $this->parsedData;
    }

    /**
     * Set parsedData
     *
     * @param mixed $parsedData
     *
     * @return Payload
     */
    protected function setParsedData($parsedData): Payload
    {
        $data = json_decode($parsedData);
        if (JSON_ERROR_NONE === json_last_error()) {
            $this->parsedData = $data;
        }

        return $this;
    }

    /**
     * Debugger
     *
     * @return array
     */
    public function __debugInfo(): array
    {
        return [
            'ramData'     => (array)$this->getRawData(),
            'jsonEncoded' => json_decode($this->getRawData())
        ];
    }

    /**
     * Parse raw data
     *
     * @return Payload
     * @throws BadSignatureException
     * @throws \Exception
     */
    public function parse(): Payload
    {
        /** Check signature from header */
        if (!$this->_checkSignature()) {
            throw new BadSignatureException('Hook secret does not match.');
        }

        /** Get data from different locations according to content-type */
        switch ($this->serverBag->get('CONTENT_TYPE')) {
            case 'application/json':
                $data = $this->getRawData();
                break;

            case 'application/x-www-form-urlencoded':
                $data = $_POST['payload'];
                break;

            default:
                throw new Exception('Unsupported content type: "' . $this->serverBag->get('CONTENT_TYPE') . '"');
        }
        $this->setParsedData($data);

        return $this;
    }

    /**
     * Check X-Hub-Signature
     *
     * @throws BadSignatureException
     * @return bool
     */
    private function _checkSignature(): bool
    {
        $secret           = $this->getSecret();
        $httpHubSignature = $this->serverBag->get('HTTP_X_HUB_SIGNATURE');

        if (null !== $secret) {
            if ($httpHubSignature) {
                /**
                 * Split signature into algorithm and hash
                 *
                 * @link http://isometriks.com/verify-github-webhooks-with-php
                 */
                list(, $hash) = explode('=', $httpHubSignature, 2);

                return $secret == $hash;
            }

            throw new BadSignatureException('HTTP header "X-Hub-Signature" is missing.');
        }

        return true;
    }
}

1			<?php
2			namespace FlexyProject\GitHub\Event;
3
4			use Exception;
5			use FlexyProject\GitHub\Exception\BadSignatureException;
6			use FlexyProject\GitHub\WebHook;
7			use Symfony\Component\HttpFoundation\ServerBag;
8
9			/**
10			* Payloads
11			*
12			* @link https://developer.github.com/webhooks/#payloads
13			* @package FlexyProject\GitHub\Event
14			*/
15			class Payload implements EventInterface
16			{
17			/** @var WebHook */
18			protected $webHook;
19
20			/** @var null\|string */
21			protected $secret = null;
22
23			/** @var string\|resource */
24			protected $rawData;
25
26			/** @var mixed */
27			protected $parsedData;
28
29			/** @var ServerBag */
30			protected $serverBag;
31
32			/**
33			* Constructor, pass a WebHook object
34			*
35			* @param WebHook $webHook
36			*/
37			public function __construct(WebHook $webHook)
38			{
39			$this->setWebHook($webHook);
40			$request = $webHook->getRequest();
41			$this->setRawData($request->getContent());
42			$this->serverBag = $request->server;
43			}
44
45			/**
46			* Get webHook
47			*
48			* @return null\|WebHook
49			*/
50			public function getWebHook()
51			{
52			return $this->webHook;
53			}
54
55			/**
56			* Set webHook
57			*
58			* @param mixed $webHook
59			*
60			* @return Payload
61			*/
62			public function setWebHook($webHook): Payload
63			{
64			$this->webHook = $webHook;
65
66			return $this;
67			}
68
69			/**
70			* Set secret, encode this secret with Hmac, SHA1 method
71			*
72			* @param string $secret
73			*
74			* @return Payload
75			*/
76			public function setSecret(string $secret): Payload
77			{
78			$this->secret = hash_hmac('sha1', $this->rawData, $secret);
79
80			return $this;
81			}
82
83			/**
84			* Get secret
85			*
86			* @return null\|string
87			*/
88			public function getSecret()
89			{
90			return $this->secret;
91			}
92
93			/**
94			* Get rawData
95			*
96			* @return resource\|string
97			*/
98			public function getRawData()
99			{
100			return $this->rawData;
101			}
102
103			/**
104			* Set rawData
105			*
106			* @param resource\|string $rawData
107			*
108			* @return Payload
109			*/
110			public function setRawData($rawData): Payload
111			{
112			$this->rawData = $rawData;
113
114			return $this;
115			}
116
117			/**
118			* Get parsedData
119			*
120			* @return mixed
121			*/
122			public function getData()
123			{
124			return $this->parsedData;
125			}
126
127			/**
128			* Set parsedData
129			*
130			* @param mixed $parsedData
131			*
132			* @return Payload
133			*/
134			protected function setParsedData($parsedData): Payload
135			{
136			$data = json_decode($parsedData);
137			if (JSON_ERROR_NONE === json_last_error()) {
138			$this->parsedData = $data;
139			}
140
141			return $this;
142			}
143
144			/**
145			* Debugger
146			*
147			* @return array
148			*/
149			public function __debugInfo(): array
150			{
151			return [
152			'ramData' => (array)$this->getRawData(),
153			'jsonEncoded' => json_decode($this->getRawData())
154			];
155			}
156
157			/**
158			* Parse raw data
159			*
160			* @return Payload
161			* @throws BadSignatureException
162			* @throws \Exception
163			*/
164			public function parse(): Payload
165			{
166			/** Check signature from header */
167			if (!$this->_checkSignature()) {
168			throw new BadSignatureException('Hook secret does not match.');
169			}
170
171			/** Get data from different locations according to content-type */
172			switch ($this->serverBag->get('CONTENT_TYPE')) {
173			case 'application/json':
174			$data = $this->getRawData();
175			break;
176
177			case 'application/x-www-form-urlencoded':
178			$data = $_POST['payload'];
179			break;
180
181			default:
182			throw new Exception('Unsupported content type: "' . $this->serverBag->get('CONTENT_TYPE') . '"');
183			}
184			$this->setParsedData($data);
185
186			return $this;
187			}
188
189			/**
190			* Check X-Hub-Signature
191			*
192			* @throws BadSignatureException
193			* @return bool
194			*/
195			private function _checkSignature(): bool
196			{
197			$secret = $this->getSecret();
198			$httpHubSignature = $this->serverBag->get('HTTP_X_HUB_SIGNATURE');
199
200			if (null !== $secret) {
201			if ($httpHubSignature) {
202			/**
203			* Split signature into algorithm and hash
204			*
205			* @link http://isometriks.com/verify-github-webhooks-with-php
206			*/
207			list(, $hash) = explode('=', $httpHubSignature, 2);
208
209			return $secret == $hash;
210			}
211
212			throw new BadSignatureException('HTTP header "X-Hub-Signature" is missing.');
213			}
214
215			return true;
216			}
217			}

FlexyProject / GitHubAPI

Payload::parse() B last analyzed 2017-05-05 20:59 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Payload::parse() B
last analyzed 2017-05-05 20:59 UTC