EditableSpamProtectionField::getFormField() - Code Metrics - Inspection of "Validate field fix" - silverstripe/silverstripe-spamprotection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#44)

by Ingo

created 2016-01-08 03:38 UTC

EditableSpamProtectionField::getFormField() B

↳ Parent: EditableSpamProtectionField

Complexity

Conditions	4
Paths	4

Size

Total Lines	24
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	24
rs	8.6846
cc	4
eloc	13
nc	4
nop	0

<?php

/**
 * Editable Spam Protecter Field. Used with the User Defined Forms module (if
 * installed) to allow the user to have captcha fields with their custom forms
 *
 * @package spamprotection
 */
if (class_exists('EditableFormField')) {
    class EditableSpamProtectionField extends EditableFormField
namespace YourVendor;

class YourClass { }
    {
        private static $singular_name = 'Spam Protection Field';


        private static $plural_name = 'Spam Protection Fields';

        /**
         * Fields to include spam detection for
         *
         * @var array
         * @config
         */
        private static $check_fields = array(

            'EditableEmailField',
            'EditableTextField',
            'EditableNumericField'
        );

        /**
         * @var FormField
         */
        protected $formField = null;

        public function getFormField()
        {
            if ($this->formField) {
                return $this->formField;
            }

            // Get protector
            $protector = FormSpamProtectionExtension::get_protector();
            if (!$protector) {
                return false;
            }

            // Extract saved field mappings and update this field.
            $fieldMapping = array();
            foreach ($this->getCandidateFields() as $otherField) {
                $mapSetting = "Map-{$otherField->Name}";
                $spamField = $this->getSetting($mapSetting);
                $fieldMapping[$otherField->Name] = $spamField;
            }
            $protector->setFieldMapping($fieldMapping);

            // Generate field
            return $protector->getFormField($this->Name, $this->Title, null);
        }

        /**
         * @param FormField $field
         * @return self
         */
        public function setFormField(FormField $field)
        {
            $this->formField = $field;

            return $this;
        }

        /**
         * Gets the list of all candidate spam detectable fields on this field's form
         *
         * @return DataList
         */
        protected function getCandidateFields()
        {

            // Get list of all configured classes available for spam detection
            $types = self::config()->check_fields;
            $typesInherit = array();
            foreach ($types as $type) {
                $subTypes = ClassInfo::subclassesFor($type);
                $typesInherit = array_merge($typesInherit, $subTypes);
            }

            // Get all candidates of the above types
            return $this
                ->Parent()
                ->Fields()
                ->filter('ClassName', $typesInherit)
                ->exclude('Title', ''); // Ignore this field and those without titles
        }

        public function getFieldConfiguration()
        {
            $fields = parent::getFieldConfiguration();

            // Get protector
            $protector = FormSpamProtectionExtension::get_protector();
            if (!$protector) {
                return $fields;
            }

            if ($this->Parent()->Fields() instanceof UnsavedRelationList) {
                return $fields;
            }

            // Each other text field in this group can be assigned a field mapping
            $mapGroup = FieldGroup::create(_t(
                'EditableSpamProtectionField.SPAMFIELDMAPPING',
                'Spam Field Mapping'
            ))->setDescription(_t(
                'EditableSpamProtectionField.SPAMFIELDMAPPINGDESCRIPTION',
                'Select the form fields that correspond to any relevant spam protection identifiers'
            ));

            // Generate field specific settings
            $mappableFields = Config::inst()->get('FormSpamProtectionExtension', 'mappable_fields');
            $mappableFieldsMerged = array_combine($mappableFields, $mappableFields);
            foreach ($this->getCandidateFields() as $otherField) {
                $mapSetting = "Map-{$otherField->Name}";
                $fieldOption = DropdownField::create(
                    $this->getSettingName($mapSetting),
                    $otherField->Title,
                    $mappableFieldsMerged,
                    $this->getSetting($mapSetting)
                )->setEmptyString('');
                $mapGroup->push($fieldOption);
            }
            $fields->insertBefore($mapGroup, $this->getSettingName('ExtraClass'));

            return $fields;
        }

        /**
         * Using custom validateField method
         * as Spam Protection Field implementations may have their own error messages
         * and may not be based on the field being required, e.g. Honeypot Field
         * 
         * @param array $data
         * @param Form $form
         * @return void
         */
        public function validateField($data, $form) 
        {
            $formField = $this->getFormField();
            
            if (isset($data[$this->Name])) {
                $formField->setValue($data[$this->Name]);
            }

            $validator = $form->getValidator();
            if (!$formField->validate($validator)) {
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                $errors = $validator->getErrors();
                $foundError = false;

                // field validate implementation may not add error to validator
                if (count($errors) > 0) {
                    // check if error already added from fields' validate method
                    foreach ($errors as $error) {
                        if ($error['fieldName'] == $this->Name) {
                            $foundError = $error;
                            break;
                        }
                    }
                }

                if ($foundError !== false) {
                    // use error messaging already set from validate method
                    $form->addErrorMessage($this->Name, $foundError['message'], $foundError['messageType'], false);
                } else {
                    // fallback to custom message set in CMS or default message if none set
                    $form->addErrorMessage($this->Name, $this->getErrorMessage()->HTML(), 'error', false);
                }
            }
        }

        public function getFieldValidationOptions()
        {
            return new FieldList();
        }

        public function getRequired()
        {
            return false;
        }

        public function getIcon()
        {
            return 'spamprotection/images/' . strtolower($this->class) . '.png';
        }

        public function showInReports()
        {
            return false;
        }
    }
}


1			<?php
2
3			/**
4			* Editable Spam Protecter Field. Used with the User Defined Forms module (if
5			* installed) to allow the user to have captcha fields with their custom forms
6			*
7			* @package spamprotection
8			*/
9			if (class_exists('EditableFormField')) {
10			class EditableSpamProtectionField extends EditableFormField
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-21 06:29 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
11			{
12			private static $singular_name = 'Spam Protection Field';
			0 ignored issues – show Unused Code introduced 2015-11-21 06:29 UTC by Report Bug Copy Issue Report The property `$singular_name` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
13
14			private static $plural_name = 'Spam Protection Fields';
			0 ignored issues – show Unused Code introduced 2015-11-21 06:29 UTC by Report Bug Copy Issue Report The property `$plural_name` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
15			/**
16			* Fields to include spam detection for
17			*
18			* @var array
19			* @config
20			*/
21			private static $check_fields = array(
			0 ignored issues – show Unused Code introduced 2015-11-21 06:29 UTC by Report Bug Copy Issue Report The property `$check_fields` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
22			'EditableEmailField',
23			'EditableTextField',
24			'EditableNumericField'
25			);
26
27			/**
28			* @var FormField
29			*/
30			protected $formField = null;
31
32			public function getFormField()
33			{
34			if ($this->formField) {
35			return $this->formField;
36			}
37
38			// Get protector
39			$protector = FormSpamProtectionExtension::get_protector();
40			if (!$protector) {
41			return false;
42			}
43
44			// Extract saved field mappings and update this field.
45			$fieldMapping = array();
46			foreach ($this->getCandidateFields() as $otherField) {
47			$mapSetting = "Map-{$otherField->Name}";
48			$spamField = $this->getSetting($mapSetting);
49			$fieldMapping[$otherField->Name] = $spamField;
50			}
51			$protector->setFieldMapping($fieldMapping);
52
53			// Generate field
54			return $protector->getFormField($this->Name, $this->Title, null);
55			}
56
57			/**
58			* @param FormField $field
59			* @return self
60			*/
61			public function setFormField(FormField $field)
62			{
63			$this->formField = $field;
64
65			return $this;
66			}
67
68			/**
69			* Gets the list of all candidate spam detectable fields on this field's form
70			*
71			* @return DataList
72			*/
73			protected function getCandidateFields()
74			{
75
76			// Get list of all configured classes available for spam detection
77			$types = self::config()->check_fields;
78			$typesInherit = array();
79			foreach ($types as $type) {
80			$subTypes = ClassInfo::subclassesFor($type);
81			$typesInherit = array_merge($typesInherit, $subTypes);
82			}
83
84			// Get all candidates of the above types
85			return $this
86			->Parent()
87			->Fields()
88			->filter('ClassName', $typesInherit)
89			->exclude('Title', ''); // Ignore this field and those without titles
90			}
91
92			public function getFieldConfiguration()
93			{
94			$fields = parent::getFieldConfiguration();
95
96			// Get protector
97			$protector = FormSpamProtectionExtension::get_protector();
98			if (!$protector) {
99			return $fields;
100			}
101
102			if ($this->Parent()->Fields() instanceof UnsavedRelationList) {
103			return $fields;
104			}
105
106			// Each other text field in this group can be assigned a field mapping
107			$mapGroup = FieldGroup::create(_t(
108			'EditableSpamProtectionField.SPAMFIELDMAPPING',
109			'Spam Field Mapping'
110			))->setDescription(_t(
111			'EditableSpamProtectionField.SPAMFIELDMAPPINGDESCRIPTION',
112			'Select the form fields that correspond to any relevant spam protection identifiers'
113			));
114
115			// Generate field specific settings
116			$mappableFields = Config::inst()->get('FormSpamProtectionExtension', 'mappable_fields');
117			$mappableFieldsMerged = array_combine($mappableFields, $mappableFields);
118			foreach ($this->getCandidateFields() as $otherField) {
119			$mapSetting = "Map-{$otherField->Name}";
120			$fieldOption = DropdownField::create(
121			$this->getSettingName($mapSetting),
122			$otherField->Title,
123			$mappableFieldsMerged,
124			$this->getSetting($mapSetting)
125			)->setEmptyString('');
126			$mapGroup->push($fieldOption);
127			}
128			$fields->insertBefore($mapGroup, $this->getSettingName('ExtraClass'));
129
130			return $fields;
131			}
132
133			/**
134			* Using custom validateField method
135			* as Spam Protection Field implementations may have their own error messages
136			* and may not be based on the field being required, e.g. Honeypot Field
137			*
138			* @param array $data
139			* @param Form $form
140			* @return void
141			*/
142			public function validateField($data, $form)
143			{
144			$formField = $this->getFormField();
145
146			if (isset($data[$this->Name])) {
147			$formField->setValue($data[$this->Name]);
148			}
149
150			$validator = $form->getValidator();
151			if (!$formField->validate($validator)) {
			0 ignored issues – show Bug introduced 2016-01-08 03:40 UTC by Report Bug Copy Issue Report It seems like `$validator` defined by `$form->getValidator()` on line `150` can be `null`; however, `FormField::validate()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
152			$errors = $validator->getErrors();
153			$foundError = false;
154
155			// field validate implementation may not add error to validator
156			if (count($errors) > 0) {
157			// check if error already added from fields' validate method
158			foreach ($errors as $error) {
159			if ($error['fieldName'] == $this->Name) {
160			$foundError = $error;
161			break;
162			}
163			}
164			}
165
166			if ($foundError !== false) {
167			// use error messaging already set from validate method
168			$form->addErrorMessage($this->Name, $foundError['message'], $foundError['messageType'], false);
169			} else {
170			// fallback to custom message set in CMS or default message if none set
171			$form->addErrorMessage($this->Name, $this->getErrorMessage()->HTML(), 'error', false);
172			}
173			}
174			}
175
176			public function getFieldValidationOptions()
177			{
178			return new FieldList();
179			}
180
181			public function getRequired()
182			{
183			return false;
184			}
185
186			public function getIcon()
187			{
188			return 'spamprotection/images/' . strtolower($this->class) . '.png';
189			}
190
191			public function showInReports()
192			{
193			return false;
194			}
195			}
196			}
197

silverstripe / silverstripe-spamprotection

Pull Request — master (#44)

EditableSpamProtectionField::getFormField() B

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like