FormatFactory::createFormats() - Code Metrics - Inspection of "Deprecate Formats in favour of FormatFactory" - byrokrat/banking - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 07e137...a910cc )

by Hannes

created 2016-12-28 17:27 UTC

FormatFactory::createFormats() B

↳ Parent: FormatFactory

Complexity

Conditions	1
Paths	1

Size

Total Lines	397
Code Lines	262

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	253
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	397
ccs	253
cts	253
cp	1
rs	8.2857
c	0
b	0
f	0
cc	1
eloc	262
nc	1
nop	0
crap	1

How to fix Long Method

<?php

namespace byrokrat\banking;

use byrokrat\banking\Validator\ClearingValidator;
use byrokrat\banking\Validator\PersonalIdValidator;
use byrokrat\banking\Validator\RawLengthValidator;
use byrokrat\banking\Validator\CheckDigitType1AValidator;
use byrokrat\banking\Validator\CheckDigitType1BValidator;
use byrokrat\banking\Validator\CheckDigitType2Validator;
use byrokrat\banking\Validator\CheckDigitHandelsbankenValidator;
use byrokrat\banking\Validator\ClearingCheckDigitValidator;

/**
 * Create account number formats used when parsing
 */
class FormatFactory implements BankNames
{
    /**
     * Structure for accounts of type 1
     */
    const STRUCT_TYPE1 = '/^(\d{4})(),?0{0,5}(\d{6})-?(\d)$/';

    /**
     * Structure for accounts of type 2
     */
    const STRUCT_TYPE2 = '/^(\d{4})(),?0{0,2}(\d{9})-?(\d)$/';

    /**
     * Get the array of formats
     *
     * Note that in rare occasions some of Swedbank's accounts cannot be validated
     * by a checksum calculation.
     *
     * Unknown is a special case account where all is valid.
     *
     * @return Format[]
     */
    public function createFormats()
    {
        return [
            self::FORMAT_AMFA => new Format(
                self::BANK_AMFA,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9660, 9669]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_AVANZA => new Format(
                self::BANK_AVANZA,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9550, 9569]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_BLUESTEP => new Format(
                self::BANK_BLUESTEP,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9680, 9689]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_BNP_PARIBAS => new Format(
                self::BANK_BNP_PARIBAS,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9470, 9479]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_CITIBANK => new Format(
                self::BANK_CITIBANK,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9040, 9049]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_DANSKE_1 => new Format(
                self::BANK_DANSKE,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[1200, 1399], [2400, 2499]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_DNB => new Format(
                self::BANK_DNB,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9190, 9199], [9260, 9269]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_EKOBANKEN => new Format(
                self::BANK_EKOBANKEN,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9700, 9709]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_ERIK_PENSER => new Format(
                self::BANK_ERIK_PENSER,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9590, 9599]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_FOREX => new Format(
                self::BANK_FOREX,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9400, 9449]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_ICA => new Format(
                self::BANK_ICA,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9270, 9279]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_IKANO => new Format(
                self::BANK_IKANO,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9170, 9179]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_JAK => new Format(
                self::BANK_JAK,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9670, 9679]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_LANDSHYPOTEK => new Format(
                self::BANK_LANDSHYPOTEK,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9390, 9399]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_LAN_OCH_SPAR => new Format(
                self::BANK_LAN_OCH_SPAR,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9630, 9639]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_LANSFORSAKRINGAR_1A => new Format(
                self::BANK_LANSFORSAKRINGAR,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[3400, 3409], [9060, 9069]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_LANSFORSAKRINGAR_1B => new Format(
                self::BANK_LANSFORSAKRINGAR,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9020, 9029]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_MARGINALEN => new Format(
                self::BANK_MARGINALEN,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9230, 9239]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_NORDAX => new Format(
                self::BANK_NORDAX,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9640, 9649]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_NORDEA_1A => new Format(
                self::BANK_NORDEA,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator(
                        [
                            [1100, 1199],
                            [1400, 2099],
                            [3000, 3299],
                            [3301, 3399],
                            [3410, 3781],
                            [3783, 3999]
                        ]
                    ),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_NORDEA_1B => new Format(
                self::BANK_NORDEA,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[4000, 4999]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_NORDNET => new Format(
                self::BANK_NORDNET,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9100, 9109]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_RESURS => new Format(
                self::BANK_RESURS,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9280, 9289]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_RIKSGALDEN_1 => new Format(
                self::BANK_RIKSGALDEN,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9880, 9889]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_ROYAL_OF_SCOTLAND => new Format(
                self::BANK_ROYAL_OF_SCOTLAND,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9090, 9099]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_SANTANDER => new Format(
                self::BANK_SANTANDER,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9460, 9469]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_SBAB => new Format(
                self::BANK_SBAB,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9250, 9259]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_SEB => new Format(
                self::BANK_SEB,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator(
                        [
                            [5000, 5999],
                            [9120, 9124],
                            [9130, 9149]
                        ]
                    ),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_SKANDIABANKEN => new Format(
                self::BANK_SKANDIABANKEN,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9150, 9169]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_SWEDBANK_1 => new Format(
                self::BANK_SWEDBANK,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[7000, 7999]]),
                    new CheckDigitType1AValidator
                ]
            ),
            self::FORMAT_ALANDSBANKEN => new Format(
                self::BANK_ALANDSBANKEN,
                self::STRUCT_TYPE1,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[2300, 2399]]),
                    new CheckDigitType1BValidator
                ]
            ),
            self::FORMAT_DANSKE_2 => new Format(
                self::BANK_DANSKE,
                self::STRUCT_TYPE2,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9180, 9189]]),
                    new CheckDigitType2Validator
                ]
            ),
            self::FORMAT_HANDELSBANKEN => new Format(
                self::BANK_HANDELSBANKEN,
                '/^(\d{4})(),?0{0,3}(\d{8})-?(\d)$/',
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[6000, 6999]]),
                    new CheckDigitHandelsbankenValidator
                ]
            ),
            self::FORMAT_NORDEA_PERSONAL => new Format(
                self::BANK_NORDEA,
                '/^(\d{4})?(),?0{0,2}(\d{6}-?\d{3})-?(\d)$/',
                'byrokrat\banking\NordeaPersonal',
                [
                    new ClearingValidator(
                        [
                            [3300, 3300],
                            [3782, 3782]
                        ]
                    ),
                    new PersonalIdValidator
                ]
            ),
            self::FORMAT_RIKSGALDEN_2 => new Format(
                self::BANK_RIKSGALDEN,
                self::STRUCT_TYPE2,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9890, 9899]]),
                    new CheckDigitType2Validator
                ]
            ),
            self::FORMAT_SPARBANKEN_SYD => new Format(
                self::BANK_SPARBANKEN_SYD,
                self::STRUCT_TYPE2,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9570, 9579]]),
                    new CheckDigitType2Validator
                ]
            ),
            self::FORMAT_SWEDBANK_2 => new Format(
                self::BANK_SWEDBANK,
                '/^(\d{4})(?:(?:-?(\d),)|,)?0{0,10}(\d{1,9})-?(\d)$/',
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[8000, 8999]]),
                    new CheckDigitType2Validator,
                    new RawLengthValidator,
                    new ClearingCheckDigitValidator,
                ]
            ),
            self::FORMAT_SPARBANKEN_ORESUND => new Format(
                self::BANK_SWEDBANK, // Sparbanken Öresund merged with Swedbank in 2014/2015
                self::STRUCT_TYPE2,
                'byrokrat\banking\BaseAccount',
                [
                    new ClearingValidator([[9300, 9329], [9330, 9349]]),
                    new CheckDigitType2Validator
                ]
            ),
            self::FORMAT_PLUSGIRO_CLEARING => new Format(
                self::BANK_PLUSGIRO,
                '/^(\d{4})(),?0{0,10}(\d{1,9})-?(\d)$/',
                'byrokrat\banking\PlusGiro',
                [
                    new ClearingValidator([[9500, 9549], [9960, 9969]]),
                    new CheckDigitType2Validator,
                    new RawLengthValidator
                ]
            ),
            self::FORMAT_PLUSGIRO => new Format(
                self::BANK_PLUSGIRO,
                '/^(0{0,4})()0{0,10}(\d{1,7})-?(\d)$/',
                'byrokrat\banking\PlusGiro',
                [
                    new CheckDigitType2Validator,
                    new RawLengthValidator
                ]
            ),
            self::FORMAT_BANKGIRO => new Format(
                self::BANK_BANKGIRO,
                '/^(0{0,4})()0{0,5}(\d{3,4}-?\d{3})(\d)$/',
                'byrokrat\banking\Bankgiro',
                [
                    new CheckDigitType2Validator,
                    new RawLengthValidator
                ]
            )
        ];
    }
}


1		<?php
2
3		namespace byrokrat\banking;
4
5		use byrokrat\banking\Validator\ClearingValidator;
6		use byrokrat\banking\Validator\PersonalIdValidator;
7		use byrokrat\banking\Validator\RawLengthValidator;
8		use byrokrat\banking\Validator\CheckDigitType1AValidator;
9		use byrokrat\banking\Validator\CheckDigitType1BValidator;
10		use byrokrat\banking\Validator\CheckDigitType2Validator;
11		use byrokrat\banking\Validator\CheckDigitHandelsbankenValidator;
12		use byrokrat\banking\Validator\ClearingCheckDigitValidator;
13
14		/**
15		* Create account number formats used when parsing
16		*/
17		class FormatFactory implements BankNames
18		{
19		/**
20		* Structure for accounts of type 1
21		*/
22		const STRUCT_TYPE1 = '/^(\d{4})(),?0{0,5}(\d{6})-?(\d)$/';
23
24		/**
25		* Structure for accounts of type 2
26		*/
27		const STRUCT_TYPE2 = '/^(\d{4})(),?0{0,2}(\d{9})-?(\d)$/';
28
29		/**
30		* Get the array of formats
31		*
32		* Note that in rare occasions some of Swedbank's accounts cannot be validated
33		* by a checksum calculation.
34		*
35		* Unknown is a special case account where all is valid.
36		*
37		* @return Format[]
38		*/
39	2	public function createFormats()
40		{
41		return [
42	2	self::FORMAT_AMFA => new Format(
43	2	self::BANK_AMFA,
44	2	self::STRUCT_TYPE1,
45	2	'byrokrat\banking\BaseAccount',
46		[
47	2	new ClearingValidator([[9660, 9669]]),
48	2	new CheckDigitType1BValidator
49		]
50		),
51	2	self::FORMAT_AVANZA => new Format(
52	2	self::BANK_AVANZA,
53	2	self::STRUCT_TYPE1,
54	2	'byrokrat\banking\BaseAccount',
55		[
56	2	new ClearingValidator([[9550, 9569]]),
57	2	new CheckDigitType1BValidator
58		]
59		),
60	2	self::FORMAT_BLUESTEP => new Format(
61	2	self::BANK_BLUESTEP,
62	2	self::STRUCT_TYPE1,
63	2	'byrokrat\banking\BaseAccount',
64		[
65	2	new ClearingValidator([[9680, 9689]]),
66	2	new CheckDigitType1AValidator
67		]
68		),
69	2	self::FORMAT_BNP_PARIBAS => new Format(
70	2	self::BANK_BNP_PARIBAS,
71	2	self::STRUCT_TYPE1,
72	2	'byrokrat\banking\BaseAccount',
73		[
74	2	new ClearingValidator([[9470, 9479]]),
75	2	new CheckDigitType1BValidator
76		]
77		),
78	2	self::FORMAT_CITIBANK => new Format(
79	2	self::BANK_CITIBANK,
80	2	self::STRUCT_TYPE1,
81	2	'byrokrat\banking\BaseAccount',
82		[
83	2	new ClearingValidator([[9040, 9049]]),
84	2	new CheckDigitType1BValidator
85		]
86		),
87	2	self::FORMAT_DANSKE_1 => new Format(
88	2	self::BANK_DANSKE,
89	2	self::STRUCT_TYPE1,
90	2	'byrokrat\banking\BaseAccount',
91		[
92	2	new ClearingValidator([[1200, 1399], [2400, 2499]]),
93	2	new CheckDigitType1AValidator
94		]
95		),
96	2	self::FORMAT_DNB => new Format(
97	2	self::BANK_DNB,
98	2	self::STRUCT_TYPE1,
99	2	'byrokrat\banking\BaseAccount',
100		[
101	2	new ClearingValidator([[9190, 9199], [9260, 9269]]),
102	2	new CheckDigitType1BValidator
103		]
104		),
105	2	self::FORMAT_EKOBANKEN => new Format(
106	2	self::BANK_EKOBANKEN,
107	2	self::STRUCT_TYPE1,
108	2	'byrokrat\banking\BaseAccount',
109		[
110	2	new ClearingValidator([[9700, 9709]]),
111	2	new CheckDigitType1BValidator
112		]
113		),
114	2	self::FORMAT_ERIK_PENSER => new Format(
115	2	self::BANK_ERIK_PENSER,
116	2	self::STRUCT_TYPE1,
117	2	'byrokrat\banking\BaseAccount',
118		[
119	2	new ClearingValidator([[9590, 9599]]),
120	2	new CheckDigitType1BValidator
121		]
122		),
123	2	self::FORMAT_FOREX => new Format(
124	2	self::BANK_FOREX,
125	2	self::STRUCT_TYPE1,
126	2	'byrokrat\banking\BaseAccount',
127		[
128	2	new ClearingValidator([[9400, 9449]]),
129	2	new CheckDigitType1AValidator
130		]
131		),
132	2	self::FORMAT_ICA => new Format(
133	2	self::BANK_ICA,
134	2	self::STRUCT_TYPE1,
135	2	'byrokrat\banking\BaseAccount',
136		[
137	2	new ClearingValidator([[9270, 9279]]),
138	2	new CheckDigitType1AValidator
139		]
140		),
141	2	self::FORMAT_IKANO => new Format(
142	2	self::BANK_IKANO,
143	2	self::STRUCT_TYPE1,
144	2	'byrokrat\banking\BaseAccount',
145		[
146	2	new ClearingValidator([[9170, 9179]]),
147	2	new CheckDigitType1AValidator
148		]
149		),
150	2	self::FORMAT_JAK => new Format(
151	2	self::BANK_JAK,
152	2	self::STRUCT_TYPE1,
153	2	'byrokrat\banking\BaseAccount',
154		[
155	2	new ClearingValidator([[9670, 9679]]),
156	2	new CheckDigitType1BValidator
157		]
158		),
159	2	self::FORMAT_LANDSHYPOTEK => new Format(
160	2	self::BANK_LANDSHYPOTEK,
161	2	self::STRUCT_TYPE1,
162	2	'byrokrat\banking\BaseAccount',
163		[
164	2	new ClearingValidator([[9390, 9399]]),
165	2	new CheckDigitType1BValidator
166		]
167		),
168	2	self::FORMAT_LAN_OCH_SPAR => new Format(
169	2	self::BANK_LAN_OCH_SPAR,
170	2	self::STRUCT_TYPE1,
171	2	'byrokrat\banking\BaseAccount',
172		[
173	2	new ClearingValidator([[9630, 9639]]),
174	2	new CheckDigitType1AValidator
175		]
176		),
177	2	self::FORMAT_LANSFORSAKRINGAR_1A => new Format(
178	2	self::BANK_LANSFORSAKRINGAR,
179	2	self::STRUCT_TYPE1,
180	2	'byrokrat\banking\BaseAccount',
181		[
182	2	new ClearingValidator([[3400, 3409], [9060, 9069]]),
183	2	new CheckDigitType1AValidator
184		]
185		),
186	2	self::FORMAT_LANSFORSAKRINGAR_1B => new Format(
187	2	self::BANK_LANSFORSAKRINGAR,
188	2	self::STRUCT_TYPE1,
189	2	'byrokrat\banking\BaseAccount',
190		[
191	2	new ClearingValidator([[9020, 9029]]),
192	2	new CheckDigitType1BValidator
193		]
194		),
195	2	self::FORMAT_MARGINALEN => new Format(
196	2	self::BANK_MARGINALEN,
197	2	self::STRUCT_TYPE1,
198	2	'byrokrat\banking\BaseAccount',
199		[
200	2	new ClearingValidator([[9230, 9239]]),
201	2	new CheckDigitType1AValidator
202		]
203		),
204	2	self::FORMAT_NORDAX => new Format(
205	2	self::BANK_NORDAX,
206	2	self::STRUCT_TYPE1,
207	2	'byrokrat\banking\BaseAccount',
208		[
209	2	new ClearingValidator([[9640, 9649]]),
210	2	new CheckDigitType1BValidator
211		]
212		),
213	2	self::FORMAT_NORDEA_1A => new Format(
214	2	self::BANK_NORDEA,
215	2	self::STRUCT_TYPE1,
216	2	'byrokrat\banking\BaseAccount',
217		[
218	2	new ClearingValidator(
219		[
220	2	[1100, 1199],
221		[1400, 2099],
222		[3000, 3299],
223		[3301, 3399],
224		[3410, 3781],
225		[3783, 3999]
226		]
227		),
228	2	new CheckDigitType1AValidator
229		]
230		),
231	2	self::FORMAT_NORDEA_1B => new Format(
232	2	self::BANK_NORDEA,
233	2	self::STRUCT_TYPE1,
234	2	'byrokrat\banking\BaseAccount',
235		[
236	2	new ClearingValidator([[4000, 4999]]),
237	2	new CheckDigitType1BValidator
238		]
239		),
240	2	self::FORMAT_NORDNET => new Format(
241	2	self::BANK_NORDNET,
242	2	self::STRUCT_TYPE1,
243	2	'byrokrat\banking\BaseAccount',
244		[
245	2	new ClearingValidator([[9100, 9109]]),
246	2	new CheckDigitType1BValidator
247		]
248		),
249	2	self::FORMAT_RESURS => new Format(
250	2	self::BANK_RESURS,
251	2	self::STRUCT_TYPE1,
252	2	'byrokrat\banking\BaseAccount',
253		[
254	2	new ClearingValidator([[9280, 9289]]),
255	2	new CheckDigitType1AValidator
256		]
257		),
258	2	self::FORMAT_RIKSGALDEN_1 => new Format(
259	2	self::BANK_RIKSGALDEN,
260	2	self::STRUCT_TYPE1,
261	2	'byrokrat\banking\BaseAccount',
262		[
263	2	new ClearingValidator([[9880, 9889]]),
264	2	new CheckDigitType1BValidator
265		]
266		),
267	2	self::FORMAT_ROYAL_OF_SCOTLAND => new Format(
268	2	self::BANK_ROYAL_OF_SCOTLAND,
269	2	self::STRUCT_TYPE1,
270	2	'byrokrat\banking\BaseAccount',
271		[
272	2	new ClearingValidator([[9090, 9099]]),
273	2	new CheckDigitType1BValidator
274		]
275		),
276	2	self::FORMAT_SANTANDER => new Format(
277	2	self::BANK_SANTANDER,
278	2	self::STRUCT_TYPE1,
279	2	'byrokrat\banking\BaseAccount',
280		[
281	2	new ClearingValidator([[9460, 9469]]),
282	2	new CheckDigitType1AValidator
283		]
284		),
285	2	self::FORMAT_SBAB => new Format(
286	2	self::BANK_SBAB,
287	2	self::STRUCT_TYPE1,
288	2	'byrokrat\banking\BaseAccount',
289		[
290	2	new ClearingValidator([[9250, 9259]]),
291	2	new CheckDigitType1AValidator
292		]
293		),
294	2	self::FORMAT_SEB => new Format(
295	2	self::BANK_SEB,
296	2	self::STRUCT_TYPE1,
297	2	'byrokrat\banking\BaseAccount',
298		[
299	2	new ClearingValidator(
300		[
301	2	[5000, 5999],
302		[9120, 9124],
303		[9130, 9149]
304		]
305		),
306	2	new CheckDigitType1AValidator
307		]
308		),
309	2	self::FORMAT_SKANDIABANKEN => new Format(
310	2	self::BANK_SKANDIABANKEN,
311	2	self::STRUCT_TYPE1,
312	2	'byrokrat\banking\BaseAccount',
313		[
314	2	new ClearingValidator([[9150, 9169]]),
315	2	new CheckDigitType1BValidator
316		]
317		),
318	2	self::FORMAT_SWEDBANK_1 => new Format(
319	2	self::BANK_SWEDBANK,
320	2	self::STRUCT_TYPE1,
321	2	'byrokrat\banking\BaseAccount',
322		[
323	2	new ClearingValidator([[7000, 7999]]),
324	2	new CheckDigitType1AValidator
325		]
326		),
327	2	self::FORMAT_ALANDSBANKEN => new Format(
328	2	self::BANK_ALANDSBANKEN,
329	2	self::STRUCT_TYPE1,
330	2	'byrokrat\banking\BaseAccount',
331		[
332	2	new ClearingValidator([[2300, 2399]]),
333	2	new CheckDigitType1BValidator
334		]
335		),
336	2	self::FORMAT_DANSKE_2 => new Format(
337	2	self::BANK_DANSKE,
338	2	self::STRUCT_TYPE2,
339	2	'byrokrat\banking\BaseAccount',
340		[
341	2	new ClearingValidator([[9180, 9189]]),
342	2	new CheckDigitType2Validator
343		]
344		),
345	2	self::FORMAT_HANDELSBANKEN => new Format(
346	2	self::BANK_HANDELSBANKEN,
347	2	'/^(\d{4})(),?0{0,3}(\d{8})-?(\d)$/',
348	2	'byrokrat\banking\BaseAccount',
349		[
350	2	new ClearingValidator([[6000, 6999]]),
351	2	new CheckDigitHandelsbankenValidator
352		]
353		),
354	2	self::FORMAT_NORDEA_PERSONAL => new Format(
355	2	self::BANK_NORDEA,
356	2	'/^(\d{4})?(),?0{0,2}(\d{6}-?\d{3})-?(\d)$/',
357	2	'byrokrat\banking\NordeaPersonal',
358		[
359	2	new ClearingValidator(
360		[
361	2	[3300, 3300],
362		[3782, 3782]
363		]
364		),
365	2	new PersonalIdValidator
366		]
367		),
368	2	self::FORMAT_RIKSGALDEN_2 => new Format(
369	2	self::BANK_RIKSGALDEN,
370	2	self::STRUCT_TYPE2,
371	2	'byrokrat\banking\BaseAccount',
372		[
373	2	new ClearingValidator([[9890, 9899]]),
374	2	new CheckDigitType2Validator
375		]
376		),
377	2	self::FORMAT_SPARBANKEN_SYD => new Format(
378	2	self::BANK_SPARBANKEN_SYD,
379	2	self::STRUCT_TYPE2,
380	2	'byrokrat\banking\BaseAccount',
381		[
382	2	new ClearingValidator([[9570, 9579]]),
383	2	new CheckDigitType2Validator
384		]
385		),
386	2	self::FORMAT_SWEDBANK_2 => new Format(
387	2	self::BANK_SWEDBANK,
388	2	'/^(\d{4})(?:(?:-?(\d),)\|,)?0{0,10}(\d{1,9})-?(\d)$/',
389	2	'byrokrat\banking\BaseAccount',
390		[
391	2	new ClearingValidator([[8000, 8999]]),
392	2	new CheckDigitType2Validator,
393	2	new RawLengthValidator,
394	2	new ClearingCheckDigitValidator,
395		]
396		),
397	2	self::FORMAT_SPARBANKEN_ORESUND => new Format(
398	2	self::BANK_SWEDBANK, // Sparbanken Öresund merged with Swedbank in 2014/2015
399	2	self::STRUCT_TYPE2,
400	2	'byrokrat\banking\BaseAccount',
401		[
402	2	new ClearingValidator([[9300, 9329], [9330, 9349]]),
403	2	new CheckDigitType2Validator
404		]
405		),
406	2	self::FORMAT_PLUSGIRO_CLEARING => new Format(
407	2	self::BANK_PLUSGIRO,
408	2	'/^(\d{4})(),?0{0,10}(\d{1,9})-?(\d)$/',
409	2	'byrokrat\banking\PlusGiro',
410		[
411	2	new ClearingValidator([[9500, 9549], [9960, 9969]]),
412	2	new CheckDigitType2Validator,
413	2	new RawLengthValidator
414		]
415		),
416	2	self::FORMAT_PLUSGIRO => new Format(
417	2	self::BANK_PLUSGIRO,
418	2	'/^(0{0,4})()0{0,10}(\d{1,7})-?(\d)$/',
419	2	'byrokrat\banking\PlusGiro',
420		[
421	2	new CheckDigitType2Validator,
422	2	new RawLengthValidator
423		]
424		),
425	2	self::FORMAT_BANKGIRO => new Format(
426	2	self::BANK_BANKGIRO,
427	2	'/^(0{0,4})()0{0,5}(\d{3,4}-?\d{3})(\d)$/',
428	2	'byrokrat\banking\Bankgiro',
429		[
430	2	new CheckDigitType2Validator,
431	2	new RawLengthValidator
432		]
433		)
434		];
435		}
436		}
437

byrokrat / banking

Push — master ( 07e137...a910cc )

FormatFactory::createFormats() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like