Quiz - Code Metrics - gregorybesson/PlaygroundGame - Measure and Improve Code Quality continuously with Scrutinizer

Quiz B
last analyzed 2021-03-02 05:29 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	474
Duplicated Lines	0.63 %

Coupling/Cohesion

Components	3
Dependencies	5

Importance

Changes

Metric	Value
wmc	47
lcom	3
cbo	5
dl	3
loc	474
rs	8.64
c	0
b	0
f	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getDisplayStats()	0	4	1
A	setDisplayStats()	0	6	1
A	getDisplayGoodAnswers()	0	4	1
A	setDisplayGoodAnswers()	0	6	1
A	getDrawAuto()	0	4	1
A	setDrawAuto()	0	6	1
A	getWinners()	0	4	1
A	setWinners()	0	6	1
A	getSubstitutes()	0	4	1
A	setSubstitutes()	0	6	1
A	getTimer()	0	4	1
A	setTimer()	0	6	1
A	getTimerDuration()	0	4	1
A	setTimerDuration()	0	6	1
A	getVictoryConditions()	0	4	1
A	setVictoryConditions()	0	6	1
A	getQuestionGrouping()	0	4	1
A	setQuestionGrouping()	0	6	1
A	setQuestions()	0	6	1
A	getMaxPoints()	0	4	1
A	setMaxPoints()	0	6	1
A	getMaxCorrectAnswers()	0	4	1
A	setMaxCorrectAnswers()	0	6	1
A	getQuestions()	0	4	1
A	addQuestion()	0	4	1
A	getArrayCopy()	0	7	1
F	populate()	3	34	17
A	setInputFilter()	0	4	1
B	getInputFilter()	0	103	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Quiz often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Quiz, and based on these observations, apply Extract Interface, too.

<?php
namespace PlaygroundGame\Entity;

use PlaygroundGame\Entity\Game;
use Doctrine\ORM\Mapping as ORM;
use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
use Zend\InputFilter\InputFilter;
use Zend\InputFilter\Factory as InputFactory;
use Zend\InputFilter\InputFilterAwareInterface;
use Zend\InputFilter\InputFilterInterface;

/**
 * @ORM\Entity @HasLifecycleCallbacks
 * @ORM\Table(name="game_quiz")
 */
class Quiz extends Game implements InputFilterAwareInterface
{
    const CLASSTYPE = 'quiz';

    /**
     * Automatic Draw
     * @ORM\Column(name="draw_auto", type="boolean", nullable=false)
     */
    protected $drawAuto = 0;

    /**
     * @ORM\Column(type="integer", nullable=false)
     */
    protected $winners = 0;

    /**
     * @ORM\Column(type="integer", nullable=false)
     */
    protected $substitutes = 0;

    /**
     * display the stats about the quiz (how many entries + distribution of each answer
     * )
     * entry : After each entry
     * game : At the end of the game
     * never : ...
     *
     * @ORM\Column(name="display_stats", type="string", nullable=false)
     */
    protected $displayStats = 'never';

    /**
     * display the good answers
     *
     * question : After the answer to the question
     * entry : after each entry
     * game : at the end of the game
     * never : ...
     *
     * @ORM\Column(name="display_good_answers", type="string", nullable=false)
     */
    protected $displayGoodAnswers = 'never';

    /**
     * @ORM\Column(type="boolean", nullable=false)
     */
    protected $timer = 0;

    /**
     * @ORM\Column(name="timer_duration", type="integer", nullable=false)
     */
    protected $timerDuration = 0;

    /**
     * @ORM\Column(name="question_grouping", type="integer", nullable=false)
     */
    protected $questionGrouping = 0;

    /**
     * @ORM\Column(name="victory_conditions", type="integer", nullable=false)
     */
    protected $victoryConditions = 0;

    /**
     * @ORM\Column(name="max_points", type="integer", nullable=true)
     */
    protected $maxPoints = 0;

    /**
     * @ORM\Column(name="max_correct_answers", type="integer", nullable=true)
     */
    protected $maxCorrectAnswers = 0;

    /**
     * @ORM\OneToMany(targetEntity="QuizQuestion", mappedBy="quiz", cascade={"persist","remove"})
     * @ORM\OrderBy({"position" = "ASC"})
     **/
    private $questions;

    public function __construct()
    {
        parent::__construct();
        $this->setClassType(self::CLASSTYPE);
        $this->questions = new \Doctrine\Common\Collections\ArrayCollection();
    }

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

    /**
     * @param string $displayStats
     */
    public function setDisplayStats($displayStats)
    {
        $this->displayStats = $displayStats;

        return $this;
    }

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

    /**
     * @param string $displayGoodAnswers
     */
    public function setDisplayGoodAnswers($displayGoodAnswers)
    {
        $this->displayGoodAnswers = $displayGoodAnswers;

        return $this;
    }

    /**
     * @return integer
     */
    public function getDrawAuto()
    {
        return $this->drawAuto;
    }

    /**
     * @param integer $drawAuto
     */
    public function setDrawAuto($drawAuto)
    {
        $this->drawAuto = $drawAuto;

        return $this;
    }

    /**
     * @return integer
     */
    public function getWinners()
    {
        return $this->winners;
    }

    /**
     * @param integer $winners
     */
    public function setWinners($winners)
    {
        $this->winners = $winners;

        return $this;
    }

    /**
     * @return integer
     */
    public function getSubstitutes()
    {
        return $this->substitutes;
    }

    /**
     * @param integer $substitutes
     */
    public function setSubstitutes($substitutes)
    {
        $this->substitutes = $substitutes;

        return $this;
    }

    /**
     * @return integer unknown_type
     */
    public function getTimer()
    {
        return $this->timer;
    }

    /**
     * @param unknown_type $timer
     */
    public function setTimer($timer)
    {
        $this->timer = $timer;


        return $this;
    }

    /**
     * @return integer unknown_type
     */
    public function getTimerDuration()
    {
        return $this->timerDuration;
    }

    /**
     * @param unknown_type $timerDuration
     */
    public function setTimerDuration($timerDuration)
    {
        $this->timerDuration = $timerDuration;


        return $this;
    }

    public function getVictoryConditions()
    {
        return $this->victoryConditions;
    }

    /**
     */
    public function setVictoryConditions($victoryConditions)
    {
        $this->victoryConditions = $victoryConditions;

        return $this;
    }

    /**
     * @return integer unknown_type
     */
    public function getQuestionGrouping()
    {
        return $this->questionGrouping;
    }

    /**
     * @param unknown_type $questionGrouping
     */
    public function setQuestionGrouping($questionGrouping)
    {
        $this->questionGrouping = $questionGrouping;


        return $this;
    }

    /**
     * @param unknown_type $questions
     */
    public function setQuestions($questions)
    {
        $this->questions = $questions;

        return $this;
    }

    /**
     * @return integer
     */
    public function getMaxPoints()
    {
        return $this->maxPoints;
    }

    /**
     * @param integer maxPoints
     */
    public function setMaxPoints($maxPoints)
    {
        $this->maxPoints = $maxPoints;

        return $this;
    }

    /**
     * @return integer
     */
    public function getMaxCorrectAnswers()
    {
        return $this->maxCorrectAnswers;
    }

    /**
     * @param integer maxCorrectAnswers
     */
    public function setMaxCorrectAnswers($maxCorrectAnswers)
    {
        $this->maxCorrectAnswers = $maxCorrectAnswers;

        return $this;
    }

    /**
     * Get question.
     *
     * @return \Doctrine\Common\Collections\Collection
     */
    public function getQuestions()
    {
        return $this->questions;
    }

    /**
     * Add a question to the quiz.
     *
     * @param QuizQuestion $question
     *
     * @return void
     */
    public function addQuestion($question)
    {
        $this->questions[] = $question;
    }

    /**
     * Convert the object to an array.
     *
     * @return array
     */
    public function getArrayCopy()
    {
        $obj_vars = parent::getArrayCopy();
        array_merge($obj_vars, get_object_vars($this));

        return $obj_vars;
    }

    /**
     * Populate from an array.
     *
     * @param array $data
     */
    public function populate($data = array())
    {
        parent::populate($data);

        if (isset($data['winners']) && $data['winners'] !== null) {
            $this->winners = $data['winners'];
        }

        if (isset($data['timer']) && $data['timer'] !== null) {

            $this->timer = $data['timer'];
        }
        if (isset($data['timerDuration']) && $data['timerDuration'] !== null) {
            $this->timerDuration = $data['timerDuration'];
        }
        if (isset($data['questionGrouping']) && $data['questionGrouping'] !== null) {
            $this->questionGrouping = $data['questionGrouping'];
        }

        if (isset($data['maxPoints']) && $data['maxPoints'] !== null) {
            $this->maxPoints = $data['maxPoints'];
        }

        if (isset($data['maxCorrectAnswers']) && $data['maxCorrectAnswers'] !== null) {
            $this->maxCorrectAnswers = $data['maxCorrectAnswers'];
        }

        if (isset($data['displayGoodAnswers']) && $data['displayGoodAnswers'] !== null) {
            $this->displayGoodAnswers = $data['displayGoodAnswers'];
        }

        if (isset($data['displayStats']) && $data['displayStats'] !== null) {
            $this->displayStats = $data['displayStats'];
        }
    }

    public function setInputFilter(InputFilterInterface $inputFilter)
    {
        throw new \Exception("Not used");
    }

    public function getInputFilter()
    {
        if (!$this->inputFilter) {
            $inputFilter = new InputFilter();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $factory = new InputFactory();

            $inputFilter = parent::getInputFilter();

            $inputFilter->add($factory->createInput(array(
                    'name'       => 'id',
                    'required'   => true,
                    'filters' => array(
                        array('name' => 'Int'),
                    ),
            )));

            $inputFilter->add($factory->createInput(array(
                   'name'     => 'title',
                   'required' => true,
                   'filters'  => array(
                    array('name' => 'StripTags'),
                    array('name' => 'StringTrim'),
                   ),
                   'validators' => array(
                    array(
                           'name'    => 'StringLength',
                           'options' => array(
                             'encoding' => 'UTF-8',
                            'min'      => 5,
                            'max'      => 255,

                           ),
                      ),
                   ),
            )));

            $inputFilter->add($factory->createInput(array(
                'name' => 'timer',
                'required' => false
            )));

            $inputFilter->add($factory->createInput(array(
                'name' => 'displayGoodAnswers',
                'required' => false
            )));

            $inputFilter->add($factory->createInput(array(
                'name' => 'displayStats',
                'required' => false
            )));

            $inputFilter->add($factory->createInput(array(
                'name'     => 'identifier',
                'required' => true,
                'filters'  => array(
                    array('name' => 'StripTags'),
                    array('name' => 'StringTrim'),
                    array('name' => 'PlaygroundCore\Filter\Slugify'),
                ),
                'validators' => array(
                    array(
                        'name'    => 'StringLength',
                        'options' => array(
                            'encoding' => 'UTF-8',
                            'min'      => 5,
                            'max'      => 255,
                        ),
                    ),
                ),
            )));

            $inputFilter->add($factory->createInput(array(
                'name'     => 'winners',
                'required' => true,
                'validators' => array(
                    array('name'    => 'NotEmpty', ),
                    array('name' => 'Int'),
                ),
            )));

            $inputFilter->add($factory->createInput(array(
                'name'     => 'substitutes',
                'required' => true,
                'validators' => array(
                    array('name'    => 'NotEmpty', ),
                    array('name' => 'Int'),
                ),
            )));

            $inputFilter->add($factory->createInput(array(
                'name'     => 'victoryConditions',
                'required' => false,
                'validators' => array(
                    array('name'    => 'Digits', ),
                    array('name' => 'Int'),
                ),
            )));

            $this->inputFilter = $inputFilter;
        }

        return $this->inputFilter;
    }
}


1		<?php
2		namespace PlaygroundGame\Entity;
3
4		use PlaygroundGame\Entity\Game;
5		use Doctrine\ORM\Mapping as ORM;
6		use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
7		use Zend\InputFilter\InputFilter;
8		use Zend\InputFilter\Factory as InputFactory;
9		use Zend\InputFilter\InputFilterAwareInterface;
10		use Zend\InputFilter\InputFilterInterface;
11
12		/**
13		* @ORM\Entity @HasLifecycleCallbacks
14		* @ORM\Table(name="game_quiz")
15		*/
16		class Quiz extends Game implements InputFilterAwareInterface
17		{
18		const CLASSTYPE = 'quiz';
19
20		/**
21		* Automatic Draw
22		* @ORM\Column(name="draw_auto", type="boolean", nullable=false)
23		*/
24		protected $drawAuto = 0;
25
26		/**
27		* @ORM\Column(type="integer", nullable=false)
28		*/
29		protected $winners = 0;
30
31		/**
32		* @ORM\Column(type="integer", nullable=false)
33		*/
34		protected $substitutes = 0;
35
36		/**
37		* display the stats about the quiz (how many entries + distribution of each answer
38		* )
39		* entry : After each entry
40		* game : At the end of the game
41		* never : ...
42		*
43		* @ORM\Column(name="display_stats", type="string", nullable=false)
44		*/
45		protected $displayStats = 'never';
46
47		/**
48		* display the good answers
49		*
50		* question : After the answer to the question
51		* entry : after each entry
52		* game : at the end of the game
53		* never : ...
54		*
55		* @ORM\Column(name="display_good_answers", type="string", nullable=false)
56		*/
57		protected $displayGoodAnswers = 'never';
58
59		/**
60		* @ORM\Column(type="boolean", nullable=false)
61		*/
62		protected $timer = 0;
63
64		/**
65		* @ORM\Column(name="timer_duration", type="integer", nullable=false)
66		*/
67		protected $timerDuration = 0;
68
69		/**
70		* @ORM\Column(name="question_grouping", type="integer", nullable=false)
71		*/
72		protected $questionGrouping = 0;
73
74		/**
75		* @ORM\Column(name="victory_conditions", type="integer", nullable=false)
76		*/
77		protected $victoryConditions = 0;
78
79		/**
80		* @ORM\Column(name="max_points", type="integer", nullable=true)
81		*/
82		protected $maxPoints = 0;
83
84		/**
85		* @ORM\Column(name="max_correct_answers", type="integer", nullable=true)
86		*/
87		protected $maxCorrectAnswers = 0;
88
89		/**
90		* @ORM\OneToMany(targetEntity="QuizQuestion", mappedBy="quiz", cascade={"persist","remove"})
91		* @ORM\OrderBy({"position" = "ASC"})
92		**/
93		private $questions;
94
95		public function __construct()
96		{
97		parent::__construct();
98		$this->setClassType(self::CLASSTYPE);
99		$this->questions = new \Doctrine\Common\Collections\ArrayCollection();
100		}
101
102		/**
103		* @return string
104		*/
105		public function getDisplayStats()
106		{
107		return $this->displayStats;
108		}
109
110		/**
111		* @param string $displayStats
112		*/
113		public function setDisplayStats($displayStats)
114		{
115		$this->displayStats = $displayStats;
116
117		return $this;
118		}
119
120		/**
121		* @return string
122		*/
123		public function getDisplayGoodAnswers()
124		{
125		return $this->displayGoodAnswers;
126		}
127
128		/**
129		* @param string $displayGoodAnswers
130		*/
131		public function setDisplayGoodAnswers($displayGoodAnswers)
132		{
133		$this->displayGoodAnswers = $displayGoodAnswers;
134
135		return $this;
136		}
137
138		/**
139		* @return integer
140		*/
141		public function getDrawAuto()
142		{
143		return $this->drawAuto;
144		}
145
146		/**
147		* @param integer $drawAuto
148		*/
149		public function setDrawAuto($drawAuto)
150		{
151		$this->drawAuto = $drawAuto;
152
153		return $this;
154		}
155
156		/**
157		* @return integer
158		*/
159		public function getWinners()
160		{
161		return $this->winners;
162		}
163
164		/**
165		* @param integer $winners
166		*/
167		public function setWinners($winners)
168		{
169		$this->winners = $winners;
170
171		return $this;
172		}
173
174		/**
175		* @return integer
176		*/
177		public function getSubstitutes()
178		{
179		return $this->substitutes;
180		}
181
182		/**
183		* @param integer $substitutes
184		*/
185		public function setSubstitutes($substitutes)
186		{
187		$this->substitutes = $substitutes;
188
189		return $this;
190		}
191
192		/**
193		* @return integer unknown_type
194		*/
195		public function getTimer()
196		{
197		return $this->timer;
198		}
199
200		/**
201		* @param unknown_type $timer
202		*/
203		public function setTimer($timer)
204		{
205		$this->timer = $timer;
		0 ignored issues – show Documentation Bug introduced 2015-11-21 00:28 UTC by Report Bug Copy Issue Report It seems like `$timer` of type `object<PlaygroundGame\Entity\unknown_type>` is incompatible with the declared type `integer` of property `$timer`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
206
207		return $this;
208		}
209
210		/**
211		* @return integer unknown_type
212		*/
213		public function getTimerDuration()
214		{
215		return $this->timerDuration;
216		}
217
218		/**
219		* @param unknown_type $timerDuration
220		*/
221		public function setTimerDuration($timerDuration)
222		{
223		$this->timerDuration = $timerDuration;
		0 ignored issues – show Documentation Bug introduced 2015-11-21 00:28 UTC by Report Bug Copy Issue Report It seems like `$timerDuration` of type `object<PlaygroundGame\Entity\unknown_type>` is incompatible with the declared type `integer` of property `$timerDuration`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
224
225		return $this;
226		}
227
228		public function getVictoryConditions()
229		{
230		return $this->victoryConditions;
231		}
232
233		/**
234		*/
235		public function setVictoryConditions($victoryConditions)
236		{
237		$this->victoryConditions = $victoryConditions;
238
239		return $this;
240		}
241
242		/**
243		* @return integer unknown_type
244		*/
245		public function getQuestionGrouping()
246		{
247		return $this->questionGrouping;
248		}
249
250		/**
251		* @param unknown_type $questionGrouping
252		*/
253		public function setQuestionGrouping($questionGrouping)
254		{
255		$this->questionGrouping = $questionGrouping;
		0 ignored issues – show Documentation Bug introduced 2015-11-21 00:28 UTC by Report Bug Copy Issue Report It seems like `$questionGrouping` of type `object<PlaygroundGame\Entity\unknown_type>` is incompatible with the declared type `integer` of property `$questionGrouping`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
256
257		return $this;
258		}
259
260		/**
261		* @param unknown_type $questions
262		*/
263		public function setQuestions($questions)
264		{
265		$this->questions = $questions;
266
267		return $this;
268		}
269
270		/**
271		* @return integer
272		*/
273		public function getMaxPoints()
274		{
275		return $this->maxPoints;
276		}
277
278		/**
279		* @param integer maxPoints
280		*/
281		public function setMaxPoints($maxPoints)
282		{
283		$this->maxPoints = $maxPoints;
284
285		return $this;
286		}
287
288		/**
289		* @return integer
290		*/
291		public function getMaxCorrectAnswers()
292		{
293		return $this->maxCorrectAnswers;
294		}
295
296		/**
297		* @param integer maxCorrectAnswers
298		*/
299		public function setMaxCorrectAnswers($maxCorrectAnswers)
300		{
301		$this->maxCorrectAnswers = $maxCorrectAnswers;
302
303		return $this;
304		}
305
306		/**
307		* Get question.
308		*
309		* @return \Doctrine\Common\Collections\Collection
310		*/
311		public function getQuestions()
312		{
313		return $this->questions;
314		}
315
316		/**
317		* Add a question to the quiz.
318		*
319		* @param QuizQuestion $question
320		*
321		* @return void
322		*/
323		public function addQuestion($question)
324		{
325		$this->questions[] = $question;
326		}
327
328		/**
329		* Convert the object to an array.
330		*
331		* @return array
332		*/
333		public function getArrayCopy()
334		{
335		$obj_vars = parent::getArrayCopy();
336		array_merge($obj_vars, get_object_vars($this));
337
338		return $obj_vars;
339		}
340
341		/**
342		* Populate from an array.
343		*
344		* @param array $data
345		*/
346		public function populate($data = array())
347		{
348		parent::populate($data);
349
350		if (isset($data['winners']) && $data['winners'] !== null) {
351		$this->winners = $data['winners'];
352		}
353
354	View Code Duplication	if (isset($data['timer']) && $data['timer'] !== null) {
		0 ignored issues – show Duplication introduced 2015-11-21 00:28 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
355		$this->timer = $data['timer'];
356		}
357		if (isset($data['timerDuration']) && $data['timerDuration'] !== null) {
358		$this->timerDuration = $data['timerDuration'];
359		}
360		if (isset($data['questionGrouping']) && $data['questionGrouping'] !== null) {
361		$this->questionGrouping = $data['questionGrouping'];
362		}
363
364		if (isset($data['maxPoints']) && $data['maxPoints'] !== null) {
365		$this->maxPoints = $data['maxPoints'];
366		}
367
368		if (isset($data['maxCorrectAnswers']) && $data['maxCorrectAnswers'] !== null) {
369		$this->maxCorrectAnswers = $data['maxCorrectAnswers'];
370		}
371
372		if (isset($data['displayGoodAnswers']) && $data['displayGoodAnswers'] !== null) {
373		$this->displayGoodAnswers = $data['displayGoodAnswers'];
374		}
375
376		if (isset($data['displayStats']) && $data['displayStats'] !== null) {
377		$this->displayStats = $data['displayStats'];
378		}
379		}
380
381		public function setInputFilter(InputFilterInterface $inputFilter)
382		{
383		throw new \Exception("Not used");
384		}
385
386		public function getInputFilter()
387		{
388		if (!$this->inputFilter) {
389		$inputFilter = new InputFilter();
		0 ignored issues – show Unused Code introduced 2015-11-21 00:28 UTC by Report Bug Copy Issue Report `$inputFilter` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
390		$factory = new InputFactory();
391
392		$inputFilter = parent::getInputFilter();
393
394		$inputFilter->add($factory->createInput(array(
395		'name' => 'id',
396		'required' => true,
397		'filters' => array(
398		array('name' => 'Int'),
399		),
400		)));
401
402		$inputFilter->add($factory->createInput(array(
403		'name' => 'title',
404		'required' => true,
405		'filters' => array(
406		array('name' => 'StripTags'),
407		array('name' => 'StringTrim'),
408		),
409		'validators' => array(
410		array(
411		'name' => 'StringLength',
412		'options' => array(
413		'encoding' => 'UTF-8',
414		'min' => 5,
415		'max' => 255,
416
417		),
418		),
419		),
420		)));
421
422		$inputFilter->add($factory->createInput(array(
423		'name' => 'timer',
424		'required' => false
425		)));
426
427		$inputFilter->add($factory->createInput(array(
428		'name' => 'displayGoodAnswers',
429		'required' => false
430		)));
431
432		$inputFilter->add($factory->createInput(array(
433		'name' => 'displayStats',
434		'required' => false
435		)));
436
437		$inputFilter->add($factory->createInput(array(
438		'name' => 'identifier',
439		'required' => true,
440		'filters' => array(
441		array('name' => 'StripTags'),
442		array('name' => 'StringTrim'),
443		array('name' => 'PlaygroundCore\Filter\Slugify'),
444		),
445		'validators' => array(
446		array(
447		'name' => 'StringLength',
448		'options' => array(
449		'encoding' => 'UTF-8',
450		'min' => 5,
451		'max' => 255,
452		),
453		),
454		),
455		)));
456
457		$inputFilter->add($factory->createInput(array(
458		'name' => 'winners',
459		'required' => true,
460		'validators' => array(
461		array('name' => 'NotEmpty', ),
462		array('name' => 'Int'),
463		),
464		)));
465
466		$inputFilter->add($factory->createInput(array(
467		'name' => 'substitutes',
468		'required' => true,
469		'validators' => array(
470		array('name' => 'NotEmpty', ),
471		array('name' => 'Int'),
472		),
473		)));
474
475		$inputFilter->add($factory->createInput(array(
476		'name' => 'victoryConditions',
477		'required' => false,
478		'validators' => array(
479		array('name' => 'Digits', ),
480		array('name' => 'Int'),
481		),
482		)));
483
484		$this->inputFilter = $inputFilter;
485		}
486
487		return $this->inputFilter;
488		}
489		}
490

gregorybesson / PlaygroundGame

Quiz B last analyzed 2021-03-02 05:29 UTC