Xabbuh\XApi\Client\Api\StatementsApiClient

Complexity

Total Complexity

33

Size/Duplication

Total Lines	220
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

89.61%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getStatements()	0	15	3
A	getNextStatements()	0	4	1
A	__construct()	0	13	1
A	storeStatement()	0	13	2
B	storeStatements()	0	15	5
A	voidStatement()	0	4	1
A	getStatement()	0	7	2
A	getVoidedStatement()	0	7	2
C	doStoreStatements()	0	69	13
A	doGetStatements()	0	11	3

<?php

/*
 * This file is part of the xAPI package.
 *
 * (c) Christian Flothmann <christian.flothmann@xabbuh.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Xabbuh\XApi\Client\Api;

use Http\Message\MultipartStream\MultipartStreamBuilder;
use Xabbuh\XApi\Client\Http\AttachmentsBody;
use Xabbuh\XApi\Client\Request\HandlerInterface;
use Xabbuh\XApi\Model\StatementId;
use Xabbuh\XApi\Serializer\ActorSerializerInterface;
use Xabbuh\XApi\Serializer\StatementResultSerializerInterface;
use Xabbuh\XApi\Serializer\StatementSerializerInterface;
use Xabbuh\XApi\Model\Actor;
use Xabbuh\XApi\Model\Statement;
use Xabbuh\XApi\Model\StatementResult;
use Xabbuh\XApi\Model\StatementsFilter;

/**
 * Client to access the statements API of an xAPI based learning record store.
 *
 * @author Christian Flothmann <christian.flothmann@xabbuh.de>
 */
final class StatementsApiClient implements StatementsApiClientInterface
{
    private $requestHandler;
    private $version;
    private $statementSerializer;
    private $statementResultSerializer;
    private $actorSerializer;

    /**
     * @param HandlerInterface                   $requestHandler            The HTTP request handler
     * @param string                             $version                   The xAPI version
     * @param StatementSerializerInterface       $statementSerializer       The statement serializer
     * @param StatementResultSerializerInterface $statementResultSerializer The statement result serializer
     * @param ActorSerializerInterface           $actorSerializer           The actor serializer
     */
    public function __construct(
        HandlerInterface $requestHandler,
        $version,
        StatementSerializerInterface $statementSerializer,
        StatementResultSerializerInterface $statementResultSerializer,
        ActorSerializerInterface $actorSerializer
    ) {
        $this->requestHandler = $requestHandler;
        $this->version = $version;
        $this->statementSerializer = $statementSerializer;
        $this->statementResultSerializer = $statementResultSerializer;
        $this->actorSerializer = $actorSerializer;
    }

    /**
     * {@inheritDoc}
     */
    public function storeStatement(Statement $statement)
    {
        if (null !== $statement->getId()) {
            return $this->doStoreStatements(

The expression $this->doStoreStatements($statement, 'put', array('statementId' => $statement->getId()->getValue()), 204); of type array|Xabbuh\XApi\Model\Statement adds the type array to the return on line 66 which is incompatible with the return type declared by the interface Xabbuh\XApi\Client\Api\StatementsApiClientInterface::storeStatement of type Xabbuh\XApi\Model\Statement.

                $statement,
                'put',
                array('statementId' => $statement->getId()->getValue()),
                204
            );
        } else {
            return $this->doStoreStatements($statement);

The expression $this->doStoreStatements($statement); of type array|Xabbuh\XApi\Model\Statement adds the type array to the return on line 73 which is incompatible with the return type declared by the interface Xabbuh\XApi\Client\Api\StatementsApiClientInterface::storeStatement of type Xabbuh\XApi\Model\Statement.

        }
    }

    /**
     * {@inheritDoc}
     */
    public function storeStatements(array $statements)
    {
        // check that only Statements without ids will be sent to the LRS
        foreach ($statements as $statement) {
            /** @var Statement $statement */

            $isStatement = is_object($statement) && $statement instanceof Statement;

            if (!$isStatement || null !== $statement->getId()) {
                throw new \InvalidArgumentException('API can only handle statements without ids');
            }
        }

        return $this->doStoreStatements($statements);

The expression $this->doStoreStatements($statements); of type array|Xabbuh\XApi\Model\Statement adds the type Xabbuh\XApi\Model\Statement to the return on line 93 which is incompatible with the return type declared by the interface Xabbuh\XApi\Client\Api\StatementsApiClientInterface::storeStatements of type Xabbuh\XApi\Model\Statement[].

    }

    /**
     * {@inheritDoc}
     */
    public function voidStatement(Statement $statement, Actor $actor)
    {
        return $this->storeStatement($statement->getVoidStatement($actor));
    }

    /**
     * {@inheritDoc}
     */
    public function getStatement(StatementId $statementId, $attachments = true)
    {
        return $this->doGetStatements('statements', array(

The expression $this->doGetStatements('statements', array('statementId' => $statementId->getValue(), 'attachments' => $attachments ? 'true' : 'false')); of type Xabbuh\XApi\Model\Statement|Xabbuh\XApi\Model\StatementResult adds the type Xabbuh\XApi\Model\StatementResult to the return on line 109 which is incompatible with the return type declared by the interface Xabbuh\XApi\Client\Api\StatementsApiClientInterface::getStatement of type Xabbuh\XApi\Model\Statement.

            'statementId' => $statementId->getValue(),
            'attachments' => $attachments ? 'true' : 'false',
        ));
    }

    /**
     * {@inheritDoc}
     */
    public function getVoidedStatement(StatementId $statementId, $attachments = true)
    {
        return $this->doGetStatements('statements', array(

The expression $this->doGetStatements('statements', array('voidedStatementId' => $statementId->getValue(), 'attachments' => $attachments ? 'true' : 'false')); of type Xabbuh\XApi\Model\Statement|Xabbuh\XApi\Model\StatementResult adds the type Xabbuh\XApi\Model\StatementResult to the return on line 120 which is incompatible with the return type declared by the interface Xabbuh\XApi\Client\Api\StatementsApiClientInterface::getVoidedStatement of type Xabbuh\XApi\Model\Statement.

            'voidedStatementId' => $statementId->getValue(),
            'attachments' => $attachments ? 'true' : 'false',
        ));
    }

    /**
     * {@inheritDoc}
     */
    public function getStatements(StatementsFilter $filter = null)
    {
        $urlParameters = array();

        if (null !== $filter) {
            $urlParameters = $filter->getFilter();
        }

        // the Agent must be JSON encoded
        if (isset($urlParameters['agent'])) {
            $urlParameters['agent'] = $this->actorSerializer->serializeActor($urlParameters['agent']);
        }

        return $this->doGetStatements('statements', $urlParameters);

The expression $this->doGetStatements('statements', $urlParameters); of type Xabbuh\XApi\Model\Statement|Xabbuh\XApi\Model\StatementResult adds the type Xabbuh\XApi\Model\Statement to the return on line 142 which is incompatible with the return type declared by the interface Xabbuh\XApi\Client\Api\StatementsApiClientInterface::getStatements of type Xabbuh\XApi\Model\StatementResult.

    }

    /**
     * {@inheritDoc}
     */
    public function getNextStatements(StatementResult $statementResult)
    {
        return $this->doGetStatements($statementResult->getMoreUrlPath()->getValue());

The expression $this->doGetStatements($statementResult->getMoreUrlPath()->getValue()); of type Xabbuh\XApi\Model\Statement|Xabbuh\XApi\Model\StatementResult adds the type Xabbuh\XApi\Model\Statement to the return on line 150 which is incompatible with the return type declared by the interface Xabbuh\XApi\Client\Api\StatementsApiClientInterface::getNextStatements of type Xabbuh\XApi\Model\StatementResult.

    }

    /**
     * @param Statement|Statement[] $statements
     * @param string                $method
     * @param string[]              $parameters
     * @param int                   $validStatusCode
     *
     * @return Statement|Statement[] The created statement(s)
     */
    private function doStoreStatements($statements, $method = 'post', $parameters = array(), $validStatusCode = 200)
    {
        $attachments = array();

        if (is_array($statements)) {
            foreach ($statements as $statement) {
                if (null !== $statement->getAttachments()) {
                    foreach ($statement->getAttachments() as $attachment) {
                        if ($attachment->getContent()) {
                            $attachments[] = $attachment;
                        }
                    }
                }
            }

            $serializedStatements = $this->statementSerializer->serializeStatements($statements);
        } else {
            if (null !== $statements->getAttachments()) {
                foreach ($statements->getAttachments() as $attachment) {
                    if ($attachment->getContent()) {

The method getContent() does not exist on Xabbuh\XApi\Model\Attachment. Did you maybe mean getContentType()?

                        $attachments[] = $attachment;
                    }
                }
            }

            $serializedStatements = $this->statementSerializer->serializeStatement($statements);
        }

        $headers = array();

        if (!empty($attachments)) {
            $builder = new AttachmentsBody($serializedStatements, $attachments);
            $headers = array(
                'Content-Type' => 'multipart/mixed; boundary='.$builder->getBoundary(),
            );
            $body = $builder->build();
        } else {
            $body = $serializedStatements;
        }

        $request = $this->requestHandler->createRequest(
            $method,
            'statements',
            $parameters,
            $body,
            $headers
        );
        $response = $this->requestHandler->executeRequest($request, array($validStatusCode));
        $statementIds = json_decode((string) $response->getBody());

        if (is_array($statements)) {
            /** @var Statement[] $statements */
            $createdStatements = array();

            foreach ($statements as $index => $statement) {
                $createdStatements[] = $statement->withId(StatementId::fromString($statementIds[$index]));
            }

            return $createdStatements;
        } else {
            /** @var Statement $statements */

            if (200 === $validStatusCode) {
                return $statements->withId(StatementId::fromString($statementIds[0]));
            } else {
                return $statements;
            }
        }
    }

    /**
     * Fetch one or more Statements.
     *
     * @param string $url           URL to request
     * @param array  $urlParameters URL parameters
     *
     * @return Statement|StatementResult
     */
    private function doGetStatements($url, array $urlParameters = array())
    {
        $request = $this->requestHandler->createRequest('get', $url, $urlParameters);
        $response = $this->requestHandler->executeRequest($request, array(200));

        if (isset($urlParameters['statementId']) || isset($urlParameters['voidedStatementId'])) {
            return $this->statementSerializer->deserializeStatement((string) $response->getBody());
        } else {
            return $this->statementResultSerializer->deserializeStatementResult((string) $response->getBody());
        }
    }
}