Dokobit\Gateway\Query\File\Archive

Complexity

Total Complexity

7

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getMethod()	0	3	1
A	createResult()	0	3	1
A	getAction()	0	3	1
A	getFields()	0	7	2
A	getValidationConstraints()	0	23	1

<?php
namespace Dokobit\Gateway\Query\File;

use Dokobit\Gateway\DocumentTypeProvider;
use Dokobit\Gateway\Query\QueryInterface;
use Dokobit\Gateway\Result\File\ArchiveResult;
use Dokobit\Gateway\Result\ResultInterface;
use Symfony\Component\Validator\Constraints as Assert;

/**
 * Archive a signed file.
 * @see https://gateway-sandbox.dokobit.com/api/doc#_api_archive
 */
class Archive implements QueryInterface
{
    use FileFieldsTrait;

    /** @var string intended type of the archived document */
    private $type;

    /** @var string path of the file to be uploded, or a token of an already uploaded file */
    private $path;

    /** @var bool if true: $path will be treated as token, if false: $path is a path to file */
    private $pathIsToken;

    /**
     * @param string $type intended type of the signed file
     * @param string $path path of the file to be uploded, or a token of an already uploaded file
     * @param bool $pathIsToken if true, $path if is an uploaded file token, not a path (defaults to false)
     */
    public function __construct(
        string $type,
        string $path,
        bool $pathIsToken = false
    ) {
        $this->type = $type;
        $this->path = $path;
        $this->pathIsToken = $pathIsToken;
    }

    /**
     * Field and values association used in query
     * @return array
     */
    public function getFields(): array
    {
        return [
            'type' => $this->type,
            'file' => $this->pathIsToken ?
                [ 'token' => $this->path ] :
                $this->getFileFields($this->path),
        ];
    }

    /**
     * Validation constraints for request data validation
     * @return Assert\Collection
     */
    public function getValidationConstraints(): Assert\Collection
    {
        return new Assert\Collection([
            'type' => new Assert\Required([
                new Assert\NotBlank(),
                new Assert\Choice([
                    'choices' => DocumentTypeProvider::getPrimaryDocumentTypes(),
                ]),
            ]),
            'file' => new Assert\Required([
                new Assert\NotBlank(),
                new Assert\Collection([
                    'token' => new Assert\Optional([
                        new Assert\NotBlank(),
                    ]),
                    'name' => new Assert\Optional([
                        new Assert\NotBlank(),
                    ]),
                    'content' => new Assert\Optional([
                        new Assert\NotBlank(),
                    ]),
                    'digest' => new Assert\Optional([
                        new Assert\NotBlank(),
                    ]),
                ]),
            ]),
        ]);
    }

    /**
     * Result object for this query result
     * @return ArchiveResult
     */
    public function createResult(): ResultInterface
    {
        return new ArchiveResult();
    }

    /**
     * API action name, part of full API request url
     * @return string
     */
    public function getAction(): string
    {
        return 'archive';
    }

    /**
     * HTTP method to use
     * @return string
     */
    public function getMethod(): string
    {
        return QueryInterface::POST;
    }
}