Issues in MediaValidator.php - All Issues - Inspection of "[MediaBundle] Code improvement found by static cod..." - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( aba493...5356ed )

by Ruud

created 2019-06-11 15:20 UTC

Validator/Constraints/MediaValidator.php (1 issue)

Labels

Severity

Minor 1

Maciej Łebkowski 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Kunstmaan\MediaBundle\Validator\Constraints;

use Kunstmaan\MediaBundle\Entity\Media as MediaObject;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;

class MediaValidator extends ConstraintValidator
{
    /**
     * @param MediaObject $value
     * @param Constraint  $constraint
     *
     * @throws ConstraintDefinitionException
     */
    public function validate($value, Constraint $constraint)
    {
        if (!$constraint instanceof Media) {
            throw new UnexpectedTypeException($constraint, __NAMESPACE__ . '\Media');
        }

        if (!$value instanceof MediaObject) {
            return;
        }

        $mimeType = $value->getContentType();

        if ($constraint->mimeTypes) {

            $mimeTypes = (array) $constraint->mimeTypes;

            if (false === $this->validateMimeType($value, $mimeTypes)) {
                $this->context->buildViolation($constraint->mimeTypesMessage)
                    ->setParameter('{{ type }}', $this->formatValue($mimeType))
                    ->setParameter('{{ types }}', $this->formatValues($mimeTypes))
                    ->setCode(Media::INVALID_MIME_TYPE_ERROR)
                    ->addViolation();

                return;
            }
        }

        if (!preg_match('^image\/*^', $mimeType) || $mimeType === 'image/svg+xml') {
            return;
        }

        $this->validateDimensions($value, $constraint);
    }

    private function validateMimeType(MediaObject $value, $allowedMimeTypes)
    {
        $mimeType = strtolower($value->getContentType());

        foreach ($allowedMimeTypes as $type) {
            $type = strtolower($type);
            if ($type === $mimeType) {
                return true;
            }

            if ($discrete = strstr($type, '/*', true)) {
                if (strstr($mimeType, '/', true) === $discrete) {
                    return true;
                }
            }
        }

        return false;
    }

    private function validateDimensions(MediaObject $value, Media $constraint)
    {
        $height = $value->getMetadataValue('original_height');
        $width = $value->getMetadataValue('original_width');

        if ($constraint->minHeight) {
            if (!ctype_digit((string) $constraint->minHeight)) {
                throw new ConstraintDefinitionException(
                    sprintf(
                        '"%s" is not a valid minimum height',
                        $constraint->minHeight
                    )
                );
            }

            if ($height < $constraint->minHeight) {
                $this->context->buildViolation($constraint->minHeightMessage)
                    ->setParameter('{{ height }}', $height)
                    ->setParameter('{{ min_height }}', $constraint->minHeight)
                    ->setCode(Media::TOO_LOW_ERROR)
                    ->addViolation();

                return;
            }
        }

        if ($constraint->maxHeight) {
            if (!ctype_digit((string) $constraint->maxHeight)) {
                throw new ConstraintDefinitionException(
                    sprintf(
                        '"%s" is not a valid maximum height',
                        $constraint->maxHeight
                    )
                );
            }

            if ($height > $constraint->maxHeight) {
                $this->context->buildViolation($constraint->maxHeightMessage)
                    ->setParameter('{{ height }}', $height)
                    ->setParameter('{{ max_height }}', $constraint->maxHeight)
                    ->setCode(Media::TOO_HIGH_ERROR)
                    ->addViolation();

                return;
            }
        }

        if ($constraint->minWidth) {
            if (!ctype_digit((string) $constraint->minWidth)) {
                throw new ConstraintDefinitionException(
                    sprintf(
                        '"%s" is not a valid minimum width',
                        $constraint->minWidth
                    )
                );
            }

            if ($width < $constraint->minWidth) {
                $this->context->buildViolation($constraint->minWidthMessage)
                    ->setParameter('{{ width }}', $width)
                    ->setParameter('{{ min_width }}', $constraint->minWidth)
                    ->setCode(Media::TOO_NARROW_ERROR)
                    ->addViolation();

                return;
            }
        }

        if ($constraint->maxWidth) {
            if (!ctype_digit((string) $constraint->maxWidth)) {
                throw new ConstraintDefinitionException(
                    sprintf(
                        '"%s" is not a valid maximum width',
                        $constraint->maxWidth
                    )
                );
            }

            if ($width > $constraint->maxWidth) {
                $this->context->buildViolation($constraint->maxWidthMessage)
                    ->setParameter('{{ width }}', $width)
                    ->setParameter('{{ max_width }}', $constraint->maxWidth)
                    ->setCode(Media::TOO_WIDE_ERROR)
                    ->addViolation();

                return;
            }
        }
    }
}


1			<?php
2
3			namespace Kunstmaan\MediaBundle\Validator\Constraints;
4
5			use Kunstmaan\MediaBundle\Entity\Media as MediaObject;
6			use Symfony\Component\Validator\Constraint;
7			use Symfony\Component\Validator\ConstraintValidator;
8			use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
9			use Symfony\Component\Validator\Exception\UnexpectedTypeException;
10
11			class MediaValidator extends ConstraintValidator
12			{
13			/**
14			* @param MediaObject $value
15			* @param Constraint $constraint
16			*
17			* @throws ConstraintDefinitionException
18			*/
19	17		public function validate($value, Constraint $constraint)
20			{
21	17		if (!$constraint instanceof Media) {
22			throw new UnexpectedTypeException($constraint, __NAMESPACE__ . '\Media');
23			}
24
25	17		if (!$value instanceof MediaObject) {
26			return;
27			}
28
29	17		$mimeType = $value->getContentType();
30
31	17		if ($constraint->mimeTypes) {
			0 ignored issues – show Bug Best Practice introduced 2017-11-21 06:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `$constraint->mimeTypes` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
32	7		$mimeTypes = (array) $constraint->mimeTypes;
33
34	7		if (false === $this->validateMimeType($value, $mimeTypes)) {
35	2		$this->context->buildViolation($constraint->mimeTypesMessage)
36	2		->setParameter('{{ type }}', $this->formatValue($mimeType))
37	2		->setParameter('{{ types }}', $this->formatValues($mimeTypes))
38	2		->setCode(Media::INVALID_MIME_TYPE_ERROR)
39	2		->addViolation();
40
41	2		return;
42			}
43			}
44
45	15		if (!preg_match('^image\/*^', $mimeType) \|\| $mimeType === 'image/svg+xml') {
46	2		return;
47			}
48
49	13		$this->validateDimensions($value, $constraint);
50	13		}
51
52	7		private function validateMimeType(MediaObject $value, $allowedMimeTypes)
53			{
54	7		$mimeType = strtolower($value->getContentType());
55
56	7		foreach ($allowedMimeTypes as $type) {
57	7		$type = strtolower($type);
58	7		if ($type === $mimeType) {
59	4		return true;
60			}
61
62	4		if ($discrete = strstr($type, '/*', true)) {
63	2		if (strstr($mimeType, '/', true) === $discrete) {
64	1		return true;
65			}
66			}
67			}
68
69	2		return false;
70			}
71
72	13		private function validateDimensions(MediaObject $value, Media $constraint)
73			{
74	13		$height = $value->getMetadataValue('original_height');
75	13		$width = $value->getMetadataValue('original_width');
76
77	13	View Code Duplication	if ($constraint->minHeight) {
78	2		if (!ctype_digit((string) $constraint->minHeight)) {
79			throw new ConstraintDefinitionException(
80			sprintf(
81			'"%s" is not a valid minimum height',
82			$constraint->minHeight
83			)
84			);
85			}
86
87	2		if ($height < $constraint->minHeight) {
88	1		$this->context->buildViolation($constraint->minHeightMessage)
89	1		->setParameter('{{ height }}', $height)
90	1		->setParameter('{{ min_height }}', $constraint->minHeight)
91	1		->setCode(Media::TOO_LOW_ERROR)
92	1		->addViolation();
93
94	1		return;
95			}
96			}
97
98	12	View Code Duplication	if ($constraint->maxHeight) {
99	2		if (!ctype_digit((string) $constraint->maxHeight)) {
100			throw new ConstraintDefinitionException(
101			sprintf(
102			'"%s" is not a valid maximum height',
103			$constraint->maxHeight
104			)
105			);
106			}
107
108	2		if ($height > $constraint->maxHeight) {
109	1		$this->context->buildViolation($constraint->maxHeightMessage)
110	1		->setParameter('{{ height }}', $height)
111	1		->setParameter('{{ max_height }}', $constraint->maxHeight)
112	1		->setCode(Media::TOO_HIGH_ERROR)
113	1		->addViolation();
114
115	1		return;
116			}
117			}
118
119	11	View Code Duplication	if ($constraint->minWidth) {
120	2		if (!ctype_digit((string) $constraint->minWidth)) {
121			throw new ConstraintDefinitionException(
122			sprintf(
123			'"%s" is not a valid minimum width',
124			$constraint->minWidth
125			)
126			);
127			}
128
129	2		if ($width < $constraint->minWidth) {
130	1		$this->context->buildViolation($constraint->minWidthMessage)
131	1		->setParameter('{{ width }}', $width)
132	1		->setParameter('{{ min_width }}', $constraint->minWidth)
133	1		->setCode(Media::TOO_NARROW_ERROR)
134	1		->addViolation();
135
136	1		return;
137			}
138			}
139
140	10	View Code Duplication	if ($constraint->maxWidth) {
141	2		if (!ctype_digit((string) $constraint->maxWidth)) {
142			throw new ConstraintDefinitionException(
143			sprintf(
144			'"%s" is not a valid maximum width',
145			$constraint->maxWidth
146			)
147			);
148			}
149
150	2		if ($width > $constraint->maxWidth) {
151	1		$this->context->buildViolation($constraint->maxWidthMessage)
152	1		->setParameter('{{ width }}', $width)
153	1		->setParameter('{{ max_width }}', $constraint->maxWidth)
154	1		->setCode(Media::TOO_WIDE_ERROR)
155	1		->addViolation();
156
157	1		return;
158			}
159			}
160	9		}
161			}
162

Kunstmaan / KunstmaanBundlesCMS

Push — master ( aba493...5356ed )

Validator/Constraints/MediaValidator.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like