BitWasp\PinEntry\PinRequest

Complexity

Total Complexity

44

Size/Duplication

Total Lines	240
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

43 Methods

Rating	Name	Duplication	Size	Complexity
A	getDesc()	0	3	1
A	hasCancelButton()	0	3	1
A	withCancelButton()	0	4	1
A	hasRepeat()	0	3	1
A	withTimeout()	0	4	1
A	withError()	0	4	1
A	getTitle()	0	3	1
A	getError()	0	3	1
A	getKeyInfo()	0	3	1
A	withQualityBarTooltip()	0	4	1
A	withOkButton()	0	4	1
A	getQualityBarTooltip()	0	3	1
A	hasTitle()	0	3	1
A	withQualityBar()	0	4	1
A	hasDesc()	0	3	1
A	hasOkButton()	0	3	1
A	withCommand()	0	3	1
A	hasRepeatError()	0	3	1
A	withKeyInfo()	0	4	1
A	hasError()	0	3	1
A	getNotOk()	0	3	1
A	hasPrompt()	0	3	1
A	getCommand()	0	6	2
A	getOkButton()	0	3	1
A	withDesc()	0	4	1
A	getTimeout()	0	3	1
A	withNotOk()	0	4	1
A	getCancelButton()	0	3	1
A	hasQualityBar()	0	3	1
A	hasCommand()	0	3	1
A	hasQualityBarTooltip()	0	3	1
A	hasKeyInfo()	0	3	1
A	hasTimeout()	0	3	1
A	getCommands()	0	3	1
A	getRepeat()	0	3	1
A	getQualityBar()	0	3	1
A	withRepeatError()	0	4	1
A	withPrompt()	0	4	1
A	withTitle()	0	4	1
A	getRepeatError()	0	3	1
A	getPrompt()	0	3	1
A	withRepeat()	0	4	1
A	hasNotOk()	0	3	1

<?php

declare(strict_types=1);

namespace BitWasp\PinEntry;

class PinRequest
{
    /**
     * keyed by the command, here we store a command => param map
     * @var string[]
     */
    private $commands = [];

    /**
     * @return string[]
     */
    public function getCommands(): array
    {
        return $this->commands;
    }

    private function withCommand(string $command, string $param)
    {
        $this->commands[$command] = $param;
    }

    private function hasCommand(string $command): bool
    {
        return array_key_exists($command, $this->commands);
    }

    private function getCommand(string $command)
    {
        if (!$this->hasCommand($command)) {
            return null;
        }
        return $this->commands[$command];
    }

    public function withDesc(string $desc)
    {
        $this->withCommand(Command::SETDESC, $desc);
        return $this;
    }

    public function hasDesc(): bool
    {
        return $this->hasCommand(Command::SETDESC);
    }

    public function getDesc()
    {
        return $this->getCommand(Command::SETDESC);
    }

    public function withPrompt(string $desc)
    {
        $this->withCommand(Command::SETPROMPT, $desc);
        return $this;
    }

    public function hasPrompt(): bool
    {
        return $this->hasCommand(Command::SETPROMPT);
    }

    public function getPrompt()
    {
        return $this->getCommand(Command::SETPROMPT);
    }

    public function withKeyInfo(string $keyInfo)
    {
        $this->withCommand(Command::SETKEYINFO, $keyInfo);
        return $this;
    }

    public function hasKeyInfo(): bool
    {
        return $this->hasCommand(Command::SETKEYINFO);
    }

    public function getKeyInfo()
    {
        return $this->getCommand(Command::SETKEYINFO);
    }

    public function withRepeat($repeat)
    {
        $this->withCommand(Command::SETREPEAT, $repeat);
        return $this;
    }

    public function hasRepeat(): bool
    {
        return $this->hasCommand(Command::SETREPEAT);
    }

    public function getRepeat()
    {
        return $this->getCommand(Command::SETREPEAT);
    }

    public function withRepeatError(string $repeatError)
    {
        $this->withCommand(Command::SETREPEATERROR, $repeatError);
        return $this;
    }

    public function hasRepeatError(): bool
    {
        return $this->hasCommand(Command::SETREPEATERROR);
    }

    public function getRepeatError()
    {
        return $this->getCommand(Command::SETREPEATERROR);
    }

    public function withError(string $error)
    {
        $this->withCommand(Command::SETERROR, $error);
        return $this;
    }

    public function hasError(): bool
    {
        return $this->hasCommand(Command::SETERROR);
    }

    public function getError()
    {
        return $this->getCommand(Command::SETERROR);
    }

    public function withOkButton(string $ok)
    {
        $this->withCommand(Command::SETOK, $ok);
        return $this;
    }

    public function hasOkButton(): bool
    {
        return $this->hasCommand(Command::SETOK);
    }

    public function getOkButton()
    {
        return $this->getCommand(Command::SETOK);
    }

    public function withNotOk(string $ok)
    {
        $this->withCommand(Command::SETNOTOK, $ok);
        return $this;
    }

    public function hasNotOk(): bool
    {
        return $this->hasCommand(Command::SETNOTOK);
    }

    public function getNotOk()
    {
        return $this->getCommand(Command::SETNOTOK);
    }

    public function withCancelButton(string $cancel)
    {
        $this->withCommand(Command::SETCANCEL, $cancel);
        return $this;
    }

    public function hasCancelButton(): bool
    {
        return $this->hasCommand(Command::SETCANCEL);
    }

    public function getCancelButton()
    {
        return $this->getCommand(Command::SETCANCEL);
    }

    public function withTitle(string $title)
    {
        $this->withCommand(Command::SETTITLE, $title);
        return $this;
    }

    public function hasTitle(): bool
    {
        return $this->hasCommand(Command::SETTITLE);
    }

    public function getTitle()
    {
        return $this->getCommand(Command::SETTITLE);
    }

    public function withQualityBar(string $qualityBar)
    {
        $this->withCommand(Command::SETQUALITYBAR, $qualityBar);
        return $this;
    }

    public function hasQualityBar(): bool
    {
        return $this->hasCommand(Command::SETQUALITYBAR);
    }

    public function getQualityBar()
    {
        return $this->getCommand(Command::SETQUALITYBAR);
    }

    public function withQualityBarTooltip(string $tooltip)
    {
        $this->withCommand(Command::SETQUALITYBAR_TT, $tooltip);
        return $this;
    }

    public function hasQualityBarTooltip(): bool
    {
        return $this->hasCommand(Command::SETQUALITYBAR_TT);
    }

    public function getQualityBarTooltip()
    {
        return $this->getCommand(Command::SETQUALITYBAR_TT);
    }

    public function withTimeout(int $timeout)
    {
        $this->withCommand(Command::SETTIMEOUT, (string) $timeout);
        return $this;
    }

    public function hasTimeout(): bool
    {
        return $this->hasCommand(Command::SETTIMEOUT);
    }

    public function getTimeout()
    {
        return $this->getCommand(Command::SETTIMEOUT);
    }
}