Sprain\SwissQrBill\QrBill

Complexity

Total Complexity

29

Size/Duplication

Total Lines	257
Duplicated Lines	0 %

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getCreditor()	0	3	1
A	extractQrCodeDataFromElements()	0	19	4
A	loadValidatorMetadata()	0	37	1
A	setHeader()	0	5	1
A	setPaymentAmountInformation()	0	5	1
A	getHeader()	0	3	1
A	setCreditor()	0	5	1
A	getAdditionalInformation()	0	3	1
A	getQrCode()	0	18	2
A	addAlternativeScheme()	0	5	1
A	setAlternativeSchemes()	0	5	1
A	getQrCodeData()	0	17	3
A	getPaymentReference()	0	3	1
A	setCreditorInformation()	0	5	1
A	setAdditionalInformation()	0	5	1
A	setPaymentReference()	0	5	1
A	getAlternativeSchemes()	0	3	1
A	getUltimateDebtor()	0	3	1
A	create()	0	11	1
A	getPaymentAmountInformation()	0	3	1
A	getCreditorInformation()	0	3	1
A	setUltimateDebtor()	0	5	1
A	setErrorCorrectionLevel()	0	5	1

<?php

namespace Sprain\SwissQrBill;

use Endroid\QrCode\ErrorCorrectionLevel;
use Endroid\QrCode\QrCode;
use Sprain\SwissQrBill\DataGroups\Abstracts\Address;
use Sprain\SwissQrBill\DataGroups\AdditionalInformation;
use Sprain\SwissQrBill\DataGroups\AlternativeScheme;
use Sprain\SwissQrBill\DataGroups\CreditorInformation;
use Sprain\SwissQrBill\DataGroups\Header;
use Sprain\SwissQrBill\DataGroups\Interfaces\QrCodeData;
use Sprain\SwissQrBill\DataGroups\PaymentAmountInformation;
use Sprain\SwissQrBill\DataGroups\PaymentReference;
use Sprain\SwissQrBill\DataGroups\StructuredAddress;
use Sprain\SwissQrBill\Exception\InvalidQrBillDataException;
use Sprain\SwissQrBill\String\StringModifier;
use Sprain\SwissQrBill\Validator\Interfaces\Validatable;
use Sprain\SwissQrBill\Validator\ValidatorTrait;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class QrBill implements Validatable
{
    use ValidatorTrait;

    const SWISS_CROSS_LOGO_FILE = __DIR__ . '/../assets/swiss-cross.png';

    const ERROR_CORRECTION_LEVEL_HIGH = ErrorCorrectionLevel::HIGH;
    const ERROR_CORRECTION_LEVEL_MEDIUM = ErrorCorrectionLevel::MEDIUM;
    const ERROR_CORRECTION_LEVEL_LOW = ErrorCorrectionLevel::LOW;

    /** @var Header */
    private $header;

    /** @var CreditorInformation */
    private $creditorInformation;

    /** @var Address */
    private $creditor;

    /** @var PaymentAmountInformation */
    private $paymentAmountInformation;

    /** @var Address */
    private $ultimateDebtor;

    /** @var PaymentReference */
    private $paymentReference;

    /** @var AdditionalInformation */
    private $additionalInformation;

    /** @var AlternativeScheme[] */
    private $alternativeSchemes = [];

    /** @var string  */
    private $errorCorrectionLevel = self::ERROR_CORRECTION_LEVEL_HIGH;

    public static function create() : self
    {
        $header = new Header();
        $header->setCoding(Header::CODING_LATIN);
        $header->setQrType(Header::QRTYPE_SPC);
        $header->setVersion(Header::VERSION_0200);

        $qrBill = new self();
        $qrBill->setHeader($header);

        return $qrBill;
    }

    public function getHeader(): Header
    {
        return $this->header;
    }

    public function setHeader(Header $header) : self
    {
        $this->header = $header;
        
        return $this;
    }

    public function getCreditorInformation(): CreditorInformation
    {
        return $this->creditorInformation;
    }

    public function setCreditorInformation(CreditorInformation $creditorInformation) : self
    {
        $this->creditorInformation = $creditorInformation;

        return $this;
    }

    public function getCreditor(): Address
    {
        return $this->creditor;
    }

    public function setCreditor(Address $creditor) : self
    {
        $this->creditor = $creditor;
        
        return $this;
    }

    public function getPaymentAmountInformation(): PaymentAmountInformation
    {
        return $this->paymentAmountInformation;
    }

    public function setPaymentAmountInformation(PaymentAmountInformation $paymentAmountInformation) : self
    {
        $this->paymentAmountInformation = $paymentAmountInformation;
        
        return $this;
    }

    public function getUltimateDebtor(): ?Address
    {
        return $this->ultimateDebtor;
    }

    public function setUltimateDebtor(Address $ultimateDebtor) : self
    {
        $this->ultimateDebtor = $ultimateDebtor;
        
        return $this;
    }

    public function getPaymentReference(): PaymentReference
    {
        return $this->paymentReference;
    }

    public function setPaymentReference(PaymentReference $paymentReference) : self
    {
        $this->paymentReference = $paymentReference;
        
        return $this;
    }

    public function getAdditionalInformation(): ?AdditionalInformation
    {
        return $this->additionalInformation;
    }

    public function setAdditionalInformation(AdditionalInformation $additionalInformation) : self
    {
        $this->additionalInformation = $additionalInformation;

        return $this;
    }

    public function getAlternativeSchemes(): array
    {
        return $this->alternativeSchemes;
    }

    public function setAlternativeSchemes(array $alternativeSchemes) : self
    {
        $this->alternativeSchemes = $alternativeSchemes;

        return $this;
    }

    public function addAlternativeScheme(AlternativeScheme $alternativeScheme) : self
    {
        $this->alternativeSchemes[] = $alternativeScheme;

        return $this;
    }

    public function setErrorCorrectionLevel(string $errorCorrectionLevel) : self
    {
        $this->errorCorrectionLevel = $errorCorrectionLevel;

        return $this;
    }

    public function getQrCode() : QrCode
    {
        if (!$this->isValid()) {
            throw new InvalidQrBillDataException(
                'The provided data is not valid to generate a qr code. Use getViolations() to find details.'
            );
        }

        $qrCode = new QrCode();
        $qrCode->setText($this->getQrCodeData());
        $qrCode->setSize(543); // recommended 46x46 mm in px @ 300dpi
        $qrCode->setLogoPath(self::SWISS_CROSS_LOGO_FILE);
        $qrCode->setLogoWidth(83); // recommended 7x7 mm in px @ 300dpi
        $qrCode->setRoundBlockSize(false);
        $qrCode->setMargin(0);
        $qrCode->setErrorCorrectionLevel(new ErrorCorrectionLevel($this->errorCorrectionLevel));

        return $qrCode;
    }

    private function getQrCodeData() : string
    {
        $elements = [
            $this->getHeader(),
            $this->getCreditorInformation(),
            $this->getCreditor(),
            new StructuredAddress(),
            $this->getPaymentAmountInformation(),
            $this->getUltimateDebtor() ?: new StructuredAddress(),
            $this->getPaymentReference(),
            $this->getAdditionalInformation() ?: new AdditionalInformation(),
            $this->getAlternativeSchemes()
        ];

        $qrCodeStringElements = $this->extractQrCodeDataFromElements($elements);

        return implode("\r\n", $qrCodeStringElements);
    }

    private function extractQrCodeDataFromElements(array $elements) : array
    {
        $qrCodeElements = [];

        foreach ($elements as $element) {
            if ($element instanceof QrCodeData) {
                $qrCodeElements = array_merge($qrCodeElements, $element->getQrCodeData());
            } elseif (is_array($element)) {
                $qrCodeElements = array_merge($qrCodeElements, $this->extractQrCodeDataFromElements($element));
            }
        }

        array_walk($qrCodeElements, function(&$string){
            $string = StringModifier::replaceLineBreaksWithString($string);
            $string = StringModifier::replaceMultipleSpacesWithOne($string);
            $string = trim($string);
        });

        return $qrCodeElements;
    }

    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addPropertyConstraints('header', [
            new Assert\NotNull(),
            new Assert\Valid()
        ]);

        $metadata->addPropertyConstraints('creditorInformation', [
            new Assert\NotNull(),
            new Assert\Valid()
        ]);

        $metadata->addPropertyConstraints('creditor', [
            new Assert\NotNull(),
            new Assert\Valid()
        ]);

        $metadata->addPropertyConstraints('paymentAmountInformation', [
            new Assert\NotNull(),
            new Assert\Valid()
        ]);

        $metadata->addPropertyConstraints('ultimateDebtor', [
            new Assert\Valid()
        ]);

        $metadata->addPropertyConstraints('paymentReference', [
            new Assert\NotNull(),
            new Assert\Valid()
        ]);

        $metadata->addPropertyConstraints('alternativeSchemes', [
            new Assert\Count([
                'max' => 2
            ]),
            new Assert\Valid([
                'traverse' => true
            ])
        ]);
    }
}