Iban::branchCode() - Code Metrics - xafardero/generate-iban - Measure and Improve Code Quality continuously with Scrutinizer

Iban::branchCode() A
last analyzed 2017-08-09 21:17 UTC

↳ Parent: Iban

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

namespace IbanGenerator;

use IbanGenerator\Bban;
use InvalidArgumentException;

class Iban
{
    /**
     * @var Bban\BbanInterface
     */
    private $bban;

    /**
     * @var string
     */
    private $countryCode;

    /**
     * @var string
     */
    private $checkDigits;

    /**
     * @var array
     */
    private static $countriesSupported = [
        'ES' => Bban\SpainBban::class,
        'AD' => Bban\AndorraBban::class,
    ];

    /**
     * Iban constructor.
     *
     * @param string $countryCode
     * @param string $checkDigits
     * @param Bban\BbanInterface $bban
     *
     * @throws InvalidArgumentException
     */
    public function __construct($countryCode, $checkDigits, Bban\BbanInterface $bban)
    {
        $countryCode = strtoupper($countryCode);
        self::validateCountryCodeFormat($countryCode);
        self::validateCheckDigitsFormat($checkDigits);
        self::validateControlDigit($countryCode, $checkDigits, $bban);
        $this->countryCode = $countryCode;
        $this->checkDigits = $checkDigits;
        $this->bban = $bban;
    }

    /**
     * @param string $iban
     *
     * @throws InvalidArgumentException
     *
     * @return static
     */
    public static function fromString($iban)
    {
        $iban = preg_replace('/[^0-9a-zA-Z]+/', '', $iban);

        if (! preg_match('/^[0-9a-zA-Z]{16,34}$/', $iban)) {
            throw new InvalidArgumentException('Iban should be between 16 and 34 characters');
        }

        $countryCode = strtoupper(substr($iban, 0, 2));
        $checkDigits = strtoupper(substr($iban, 2, 2));
        $bbanString = strtoupper(substr($iban, 4));

        self::validateSupportedCountry($countryCode);
        $bbanClass = self::$countriesSupported[$countryCode];

        /**
         * @var Bban\BbanInterface
         */
        $bban = $bbanClass::fromString($bbanString);

        return new static($countryCode, $checkDigits, $bban);
    }

    /**
     * @param Bban\BbanInterface $bban
     * @param string $countryCode
     *
     * @throws InvalidArgumentException
     *
     * @return static
     */
    public static function fromBbanAndCountry(Bban\BbanInterface $bban, $countryCode)
    {
        self::validateCountryCodeFormat($countryCode);
        self::validateCountryCodeFormat($countryCode);
        self::validateSupportedCountry($countryCode);

        $checksum = self::validateChecksum($countryCode, '00', $bban);
        $checkDigit = 98 - (int) $checksum;
        $checkDigit = str_pad($checkDigit, 2, 0, STR_PAD_LEFT);

        return new static($countryCode, $checkDigit, $bban);
    }

    /**
     * @return string
     */
    public function countryCode()
    {
        return $this->countryCode;
    }

    /**
     * @return string
     */
    public function ibanCheckDigits()
    {
        return $this->checkDigits;
    }

    /**
     * @return string
     */
    public function bankCode()
    {
        return $this->bban->bankCode();
    }

    /**
     * @return string
     */
    public function branchCode()
    {
        return $this->bban->branchCode();
    }

    /**
     * @return string
     */
    public function countryCheckDigits()
    {
        return $this->bban->checkDigits();
    }

    /**
     * @return string
     */
    public function accountNumber()
    {
        return $this->bban->accountNumber();
    }

    /**
     * @return string
     */
    public function __toString()
    {
        $bbanString = $this->bban;

        return $this->countryCode . $this->checkDigits . $bbanString;
    }

    /**
     * @param $countryCode
     *
     * @throws InvalidArgumentException
     */
    private static function validateCountryCodeFormat($countryCode)
    {
        if (! preg_match('/^[A-Z]{2}$/', $countryCode)) {
            throw new InvalidArgumentException('The country code should be 2 letters');
        }
    }

    /**
     * @param $checkDigits
     *
     * @throws InvalidArgumentException
     */
    private static function validateCheckDigitsFormat($checkDigits)
    {
        if (! preg_match('/^[\d]{2}$/', $checkDigits)) {
            throw new InvalidArgumentException('The IBAN checksum must be 2 numeric characters');
        }
    }

    /**
     * @param string $countryCode
     * @param string $checkDigits
     * @param Bban\BbanInterface $bban
     *
     * @throws InvalidArgumentException
     */
    private static function validateControlDigit(
        $countryCode,
        $checkDigits,
        Bban\BbanInterface $bban
    ) {
        $checksum = self::validateChecksum($countryCode, $checkDigits, $bban);

        if ($checksum !== '01') {
            throw new InvalidArgumentException('The IBAN checksum digits are not valid');
        }
    }

    /**
     * @param $countryCode
     *
     * @throws InvalidArgumentException
     */
    private static function validateSupportedCountry($countryCode)
    {
        if (!array_key_exists($countryCode, self::$countriesSupported)) {
            throw new InvalidArgumentException(
                sprintf(
                    'The country code %s is not supported',
                    $countryCode
                )
            );
        }
    }

    /**
     * @param $countryCode
     * @param $checkDigits
     * @param Bban\BbanInterface $bban
     *
     * @return string
     */
    private static function validateChecksum($countryCode, $checkDigits, Bban\BbanInterface $bban)
    {
        $rearranged = (string) $bban . $countryCode . $checkDigits;
        $digitsList = str_split($rearranged);

        $digitsList = array_map(['self', 'digitToInt'], $digitsList);
        $stringToCompute = implode('', $digitsList);

        $checksum = bcmod($stringToCompute, '97');

        return str_pad($checksum, 2, 0, STR_PAD_LEFT);
    }

    /**
     * @param string $value
     *
     * @return int
     */
    private static function digitToInt($value)

    {
        if (is_numeric($value)) {
            return (int) $value;
        }

        return ord($value) - 55;
    }
}


1		<?php
2
3		namespace IbanGenerator;
4
5		use IbanGenerator\Bban;
6		use InvalidArgumentException;
7
8		class Iban
9		{
10		/**
11		* @var Bban\BbanInterface
12		*/
13		private $bban;
14
15		/**
16		* @var string
17		*/
18		private $countryCode;
19
20		/**
21		* @var string
22		*/
23		private $checkDigits;
24
25		/**
26		* @var array
27		*/
28		private static $countriesSupported = [
29		'ES' => Bban\SpainBban::class,
30		'AD' => Bban\AndorraBban::class,
31		];
32
33		/**
34		* Iban constructor.
35		*
36		* @param string $countryCode
37		* @param string $checkDigits
38		* @param Bban\BbanInterface $bban
39		*
40		* @throws InvalidArgumentException
41		*/
42	46	public function __construct($countryCode, $checkDigits, Bban\BbanInterface $bban)
43		{
44	46	$countryCode = strtoupper($countryCode);
45	46	self::validateCountryCodeFormat($countryCode);
46	42	self::validateCheckDigitsFormat($checkDigits);
47	38	self::validateControlDigit($countryCode, $checkDigits, $bban);
48	36	$this->countryCode = $countryCode;
49	36	$this->checkDigits = $checkDigits;
50	36	$this->bban = $bban;
51	36	}
52
53		/**
54		* @param string $iban
55		*
56		* @throws InvalidArgumentException
57		*
58		* @return static
59		*/
60	16	public static function fromString($iban)
61		{
62	16	$iban = preg_replace('/[^0-9a-zA-Z]+/', '', $iban);
63
64	16	if (! preg_match('/^[0-9a-zA-Z]{16,34}$/', $iban)) {
65	3	throw new InvalidArgumentException('Iban should be between 16 and 34 characters');
66		}
67
68	13	$countryCode = strtoupper(substr($iban, 0, 2));
69	13	$checkDigits = strtoupper(substr($iban, 2, 2));
70	13	$bbanString = strtoupper(substr($iban, 4));
71
72	13	self::validateSupportedCountry($countryCode);
73	12	$bbanClass = self::$countriesSupported[$countryCode];
74
75		/**
76		* @var Bban\BbanInterface
77		*/
78	12	$bban = $bbanClass::fromString($bbanString);
79
80	12	return new static($countryCode, $checkDigits, $bban);
81		}
82
83		/**
84		* @param Bban\BbanInterface $bban
85		* @param string $countryCode
86		*
87		* @throws InvalidArgumentException
88		*
89		* @return static
90		*/
91	12	public static function fromBbanAndCountry(Bban\BbanInterface $bban, $countryCode)
92		{
93	12	self::validateCountryCodeFormat($countryCode);
94	12	self::validateCountryCodeFormat($countryCode);
95	12	self::validateSupportedCountry($countryCode);
96
97	12	$checksum = self::validateChecksum($countryCode, '00', $bban);
98	12	$checkDigit = 98 - (int) $checksum;
99	12	$checkDigit = str_pad($checkDigit, 2, 0, STR_PAD_LEFT);
100
101	12	return new static($countryCode, $checkDigit, $bban);
102		}
103
104		/**
105		* @return string
106		*/
107	12	public function countryCode()
108		{
109	12	return $this->countryCode;
110		}
111
112		/**
113		* @return string
114		*/
115	24	public function ibanCheckDigits()
116		{
117	24	return $this->checkDigits;
118		}
119
120		/**
121		* @return string
122		*/
123	12	public function bankCode()
124		{
125	12	return $this->bban->bankCode();
126		}
127
128		/**
129		* @return string
130		*/
131	12	public function branchCode()
132		{
133	12	return $this->bban->branchCode();
134		}
135
136		/**
137		* @return string
138		*/
139	12	public function countryCheckDigits()
140		{
141	12	return $this->bban->checkDigits();
142		}
143
144		/**
145		* @return string
146		*/
147	12	public function accountNumber()
148		{
149	12	return $this->bban->accountNumber();
150		}
151
152		/**
153		* @return string
154		*/
155	12	public function __toString()
156		{
157	12	$bbanString = $this->bban;
158
159	12	return $this->countryCode . $this->checkDigits . $bbanString;
160		}
161
162		/**
163		* @param $countryCode
164		*
165		* @throws InvalidArgumentException
166		*/
167	46	private static function validateCountryCodeFormat($countryCode)
168		{
169	46	if (! preg_match('/^[A-Z]{2}$/', $countryCode)) {
170	4	throw new InvalidArgumentException('The country code should be 2 letters');
171		}
172	42	}
173
174		/**
175		* @param $checkDigits
176		*
177		* @throws InvalidArgumentException
178		*/
179	42	private static function validateCheckDigitsFormat($checkDigits)
180		{
181	42	if (! preg_match('/^[\d]{2}$/', $checkDigits)) {
182	4	throw new InvalidArgumentException('The IBAN checksum must be 2 numeric characters');
183		}
184	38	}
185
186		/**
187		* @param string $countryCode
188		* @param string $checkDigits
189		* @param Bban\BbanInterface $bban
190		*
191		* @throws InvalidArgumentException
192		*/
193	38	private static function validateControlDigit(
194		$countryCode,
195		$checkDigits,
196		Bban\BbanInterface $bban
197		) {
198	38	$checksum = self::validateChecksum($countryCode, $checkDigits, $bban);
199
200	38	if ($checksum !== '01') {
201	2	throw new InvalidArgumentException('The IBAN checksum digits are not valid');
202		}
203	36	}
204
205		/**
206		* @param $countryCode
207		*
208		* @throws InvalidArgumentException
209		*/
210	25	private static function validateSupportedCountry($countryCode)
211		{
212	25	if (!array_key_exists($countryCode, self::$countriesSupported)) {
213	1	throw new InvalidArgumentException(
214	1	sprintf(
215	1	'The country code %s is not supported',
216	1	$countryCode
217		)
218		);
219		}
220	24	}
221
222		/**
223		* @param $countryCode
224		* @param $checkDigits
225		* @param Bban\BbanInterface $bban
226		*
227		* @return string
228		*/
229	38	private static function validateChecksum($countryCode, $checkDigits, Bban\BbanInterface $bban)
230		{
231	38	$rearranged = (string) $bban . $countryCode . $checkDigits;
232	38	$digitsList = str_split($rearranged);
233
234	38	$digitsList = array_map(['self', 'digitToInt'], $digitsList);
235	38	$stringToCompute = implode('', $digitsList);
236
237	38	$checksum = bcmod($stringToCompute, '97');
238
239	38	return str_pad($checksum, 2, 0, STR_PAD_LEFT);
240		}
241
242		/**
243		* @param string $value
244		*
245		* @return int
246		*/
247	38	private static function digitToInt($value)
		0 ignored issues – show Unused Code introduced 2017-02-01 17:31 UTC by Report Bug Copy Issue Report This method is not used, and could be removed. Loading history...
248		{
249	38	if (is_numeric($value)) {
250	38	return (int) $value;
251		}
252
253	38	return ord($value) - 55;
254		}
255		}
256

xafardero / generate-iban

GitHub Access Token became invalid

Iban::branchCode() A last analyzed 2017-08-09 21:17 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Iban::branchCode() A
last analyzed 2017-08-09 21:17 UTC