#26796

pending completion

Build # #26796

Build Type

push

github

Committed by

web-flow

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/6bbb6101d7e4ee308b987ecbf16bd9d15f31dfcf">6bbb6101d<a href="https://github.com/api-platform/core/commit/6bbb6101d7e4ee308b987ecbf16bd9d15f31dfcf">">Merge </a><a class="double-link" href="https://github.com/api-platform/core/commit/<a class="double-link" href="https://github.com/api-platform/core/commit/5a30c277b4472bad80a6f625b5ad6f6c2e5d21d1">5a30c277b</a>">5a30c277b</a><a href="https://github.com/api-platform/core/commit/6bbb6101d7e4ee308b987ecbf16bd9d15f31dfcf"> into 8b02b2b3f">8b02b2b3f</a>

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

9560 of 11513 relevant lines covered (83.04%)

14.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.65

/src/Bridge/Doctrine/Orm/Filter/SearchFilter.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Core\Bridge\Doctrine\Orm\Filter;

use ApiPlatform\Core\Api\IdentifiersExtractorInterface;
use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterInterface;
use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterTrait;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryBuilderHelper;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryNameGeneratorInterface;
use ApiPlatform\Core\Exception\InvalidArgumentException;
use Doctrine\DBAL\Types\Type as DBALType;
use Doctrine\ORM\Query\Parameter;
use Doctrine\ORM\QueryBuilder;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\Persistence\Mapping\ClassMetadata;
use Psr\Log\LoggerInterface;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;

/**
 * Filter the collection by given properties.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
class SearchFilter extends AbstractContextAwareFilter implements SearchFilterInterface
{
    use SearchFilterTrait;

    public const DOCTRINE_INTEGER_TYPE = DBALType::INTEGER;

    public function __construct(ManagerRegistry $managerRegistry, ?RequestStack $requestStack, IriConverterInterface $iriConverter, PropertyAccessorInterface $propertyAccessor = null, LoggerInterface $logger = null, array $properties = null, IdentifiersExtractorInterface $identifiersExtractor = null, NameConverterInterface $nameConverter = null)
    {
        parent::__construct($managerRegistry, $requestStack, $logger, $properties, $nameConverter);

        if (null === $identifiersExtractor) {
            @trigger_error('Not injecting ItemIdentifiersExtractor is deprecated since API Platform 2.5 and can lead to unexpected behaviors, it will not be possible anymore in API Platform 3.0.', \E_USER_DEPRECATED);
        }

        $this->iriConverter = $iriConverter;
        $this->identifiersExtractor = $identifiersExtractor;
        $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();
    }

    protected function getIriConverter(): IriConverterInterface
    {
        return $this->iriConverter;
    }

    protected function getPropertyAccessor(): PropertyAccessorInterface
    {
        return $this->propertyAccessor;
    }

    /**
     * {@inheritdoc}
     */
    protected function filterProperty(string $property, $value, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass, string $operationName = null)
    {
        if (
            null === $value ||
            !$this->isPropertyEnabled($property, $resourceClass) ||
            !$this->isPropertyMapped($property, $resourceClass, true)
        ) {
            return;
        }

        $alias = $queryBuilder->getRootAliases()[0];
        $field = $property;

        $values = $this->normalizeValues((array) $value, $property);
        if (null === $values) {
            return;
        }

        $associations = [];
        if ($this->isPropertyNested($property, $resourceClass)) {
            [$alias, $field, $associations] = $this->addJoinsForNestedProperty($property, $alias, $queryBuilder, $queryNameGenerator, $resourceClass);
        }

        $caseSensitive = true;
        $strategy = $this->properties[$property] ?? self::STRATEGY_EXACT;

        // prefixing the strategy with i makes it case insensitive
        if (0 === strpos($strategy, 'i')) {
            $strategy = substr($strategy, 1);
            $caseSensitive = false;
        }

        $metadata = $this->getNestedMetadata($resourceClass, $associations);

        if ($metadata->hasField($field)) {
            if ('id' === $field) {
                $values = array_map([$this, 'getIdFromValue'], $values);
            }

            if (!$this->hasValidValues($values, $this->getDoctrineFieldType($property, $resourceClass))) {
                $this->logger->notice('Invalid filter ignored', [
                    'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),
                ]);

                return;
            }

            $this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $alias, $field, $values, $caseSensitive, $metadata);

            return;
        }

        // metadata doesn't have the field, nor an association on the field
        if (!$metadata->hasAssociation($field)) {
            return;
        }

        $values = array_map([$this, 'getIdFromValue'], $values);
        $associationFieldIdentifier = 'id';
        $doctrineTypeField = $this->getDoctrineFieldType($property, $resourceClass);

        if (null !== $this->identifiersExtractor) {
            $associationResourceClass = $metadata->getAssociationTargetClass($field);
            $associationFieldIdentifier = $this->identifiersExtractor->getIdentifiersFromResourceClass($associationResourceClass)[0];
            $doctrineTypeField = $this->getDoctrineFieldType($associationFieldIdentifier, $associationResourceClass);
        }

        if (!$this->hasValidValues($values, $doctrineTypeField)) {
            $this->logger->notice('Invalid filter ignored', [
                'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),
            ]);

            return;
        }

        $associationAlias = $alias;
        $associationField = $field;
        if ($metadata->isCollectionValuedAssociation($associationField)) {
            $associationAlias = QueryBuilderHelper::addJoinOnce($queryBuilder, $queryNameGenerator, $alias, $associationField);
            $associationField = $associationFieldIdentifier;
        }

        $this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $associationAlias, $associationField, $values, $caseSensitive, $metadata);
    }

    /**
     * Adds where clause according to the strategy.
     *
     * @throws InvalidArgumentException If strategy does not exist
     */
    protected function addWhereByStrategy(string $strategy, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $alias, string $field, $values, bool $caseSensitive/*, ClassMetadata $metadata*/)
    {
        if (\func_num_args() > 7 && ($metadata = func_get_arg(7)) instanceof ClassMetadata) {
            $type = $metadata->getTypeOfField($field);
            if ($type && DBALType::getTypeRegistry()->has($type)) {
                $type = null;
            }
        } else {
            @trigger_error(sprintf('Method %s() will have a 8th argument `$metadata` in version API Platform 3.0.', __FUNCTION__), \E_USER_DEPRECATED);
            $type = null;
        }

        if (!\is_array($values)) {
            $values = [$values];
        }

        $wrapCase = $this->createWrapCase($caseSensitive);
        $valueParameter = ':'.$queryNameGenerator->generateParameterName($field);
        $aliasedField = sprintf('%s.%s', $alias, $field);

        if (self::STRATEGY_EXACT === $strategy) {
            if (1 === \count($values)) {
                $queryBuilder
                    ->andWhere($queryBuilder->expr()->eq($wrapCase($aliasedField), $wrapCase($valueParameter)))
                    ->setParameter($valueParameter, $values[0], $type);

                return;
            }

            $parameters = $queryBuilder->getParameters();
            $inQuery = [];
            foreach ($values as $value) {
                $inQuery[] = $valueParameter;
                $parameters->add(new Parameter($valueParameter, $caseSensitive ? $value : strtolower($value), $type));
                $valueParameter = ':'.$queryNameGenerator->generateParameterName($field);
            }

            $queryBuilder
                ->andWhere($wrapCase($aliasedField).' IN ('.implode(', ', $inQuery).')')
                ->setParameters($parameters);

            return;
        }

        $ors = [];
        $parameters = [];
        foreach ($values as $key => $value) {
            $keyValueParameter = sprintf('%s_%s', $valueParameter, $key);
            $parameters[$caseSensitive ? $value : strtolower($value)] = $keyValueParameter;

            switch ($strategy) {
                case self::STRATEGY_PARTIAL:
                    $ors[] = $queryBuilder->expr()->like(
                        $wrapCase($aliasedField),
                        $wrapCase((string) $queryBuilder->expr()->concat("'%'", $keyValueParameter, "'%'"))
                    );
                    break;
                case self::STRATEGY_START:
                    $ors[] = $queryBuilder->expr()->like(
                        $wrapCase($aliasedField),
                        $wrapCase((string) $queryBuilder->expr()->concat($keyValueParameter, "'%'"))
                    );
                    break;
                case self::STRATEGY_END:
                    $ors[] = $queryBuilder->expr()->like(
                        $wrapCase($aliasedField),
                        $wrapCase((string) $queryBuilder->expr()->concat("'%'", $keyValueParameter))
                    );
                    break;
                case self::STRATEGY_WORD_START:
                    $ors[] = $queryBuilder->expr()->orX(
                        $queryBuilder->expr()->like($wrapCase($aliasedField), $wrapCase((string) $queryBuilder->expr()->concat($keyValueParameter, "'%'"))),
                        $queryBuilder->expr()->like($wrapCase($aliasedField), $wrapCase((string) $queryBuilder->expr()->concat("'% '", $keyValueParameter, "'%'")))
                    );
                    break;
                default:
                    throw new InvalidArgumentException(sprintf('strategy %s does not exist.', $strategy));
            }
        }

        $queryBuilder->andWhere($queryBuilder->expr()->orX(...$ors));
        array_walk($parameters, [$queryBuilder, 'setParameter'], $type);
    }

    /**
     * Creates a function that will wrap a Doctrine expression according to the
     * specified case sensitivity.
     *
     * For example, "o.name" will get wrapped into "LOWER(o.name)" when $caseSensitive
     * is false.
     */
    protected function createWrapCase(bool $caseSensitive): \Closure
    {
        return static function (string $expr) use ($caseSensitive): string {
            if ($caseSensitive) {
                return $expr;
            }

            return sprintf('LOWER(%s)', $expr);
        };
    }

    /**
     * {@inheritdoc}
     */
    protected function getType(string $doctrineType): string
    {
        switch ($doctrineType) {
            case DBALType::TARRAY:
                return 'array';
            case DBALType::BIGINT:
            case DBALType::INTEGER:
            case DBALType::SMALLINT:
                return 'int';
            case DBALType::BOOLEAN:
                return 'bool';
            case DBALType::DATE:
            case DBALType::TIME:
            case DBALType::DATETIME:
            case DBALType::DATETIMETZ:
                return \DateTimeInterface::class;
            case DBALType::FLOAT:
                return 'float';
        }

        if (\defined(DBALType::class.'::DATE_IMMUTABLE')) {
            switch ($doctrineType) {
                case DBALType::DATE_IMMUTABLE:
                case DBALType::TIME_IMMUTABLE:
                case DBALType::DATETIME_IMMUTABLE:
                case DBALType::DATETIMETZ_IMMUTABLE:
                    return \DateTimeInterface::class;
            }
        }

        return 'string';
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Core\Bridge\Doctrine\Orm\Filter;
15
16	use ApiPlatform\Core\Api\IdentifiersExtractorInterface;
17	use ApiPlatform\Core\Api\IriConverterInterface;
18	use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterInterface;
19	use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterTrait;
20	use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryBuilderHelper;
21	use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryNameGeneratorInterface;
22	use ApiPlatform\Core\Exception\InvalidArgumentException;
23	use Doctrine\DBAL\Types\Type as DBALType;
24	use Doctrine\ORM\Query\Parameter;
25	use Doctrine\ORM\QueryBuilder;
26	use Doctrine\Persistence\ManagerRegistry;
27	use Doctrine\Persistence\Mapping\ClassMetadata;
28	use Psr\Log\LoggerInterface;
29	use Symfony\Component\HttpFoundation\RequestStack;
30	use Symfony\Component\PropertyAccess\PropertyAccess;
31	use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
32	use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
33
34	/**
35	* Filter the collection by given properties.
36	*
37	* @author Kévin Dunglas <dunglas@gmail.com>
38	*/
39	class SearchFilter extends AbstractContextAwareFilter implements SearchFilterInterface
40	{
41	use SearchFilterTrait;
42
43	public const DOCTRINE_INTEGER_TYPE = DBALType::INTEGER;
44
45	public function __construct(ManagerRegistry $managerRegistry, ?RequestStack $requestStack, IriConverterInterface $iriConverter, PropertyAccessorInterface $propertyAccessor = null, LoggerInterface $logger = null, array $properties = null, IdentifiersExtractorInterface $identifiersExtractor = null, NameConverterInterface $nameConverter = null)
46	{
47	parent::__construct($managerRegistry, $requestStack, $logger, $properties, $nameConverter);	83✔
48
49	if (null === $identifiersExtractor) {	83✔
50	@trigger_error('Not injecting ItemIdentifiersExtractor is deprecated since API Platform 2.5 and can lead to unexpected behaviors, it will not be possible anymore in API Platform 3.0.', \E_USER_DEPRECATED);	1✔
51	}
52
53	$this->iriConverter = $iriConverter;	83✔
54	$this->identifiersExtractor = $identifiersExtractor;	83✔
55	$this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();	83✔
56	}	83✔
57
58	protected function getIriConverter(): IriConverterInterface
59	{
60	return $this->iriConverter;	10✔
61	}
62
63	protected function getPropertyAccessor(): PropertyAccessorInterface
64	{
65	return $this->propertyAccessor;	4✔
66	}
67
68	/**
69	* {@inheritdoc}
70	*/
71	protected function filterProperty(string $property, $value, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass, string $operationName = null)
72	{
73	if (
74	null === $value \|\|	66✔
75	!$this->isPropertyEnabled($property, $resourceClass) \|\|	66✔
76	!$this->isPropertyMapped($property, $resourceClass, true)	66✔
77	) {
78	return;	2✔
79	}
80
81	$alias = $queryBuilder->getRootAliases()[0];	64✔
82	$field = $property;	64✔
83
84	$values = $this->normalizeValues((array) $value, $property);	64✔
85	if (null === $values) {	64✔
86	return;	4✔
87	}
88
89	$associations = [];	62✔
90	if ($this->isPropertyNested($property, $resourceClass)) {	62✔
91	[$alias, $field, $associations] = $this->addJoinsForNestedProperty($property, $alias, $queryBuilder, $queryNameGenerator, $resourceClass);	10✔
92	}
93
94	$caseSensitive = true;	62✔
95	$strategy = $this->properties[$property] ?? self::STRATEGY_EXACT;	62✔
96
97	// prefixing the strategy with i makes it case insensitive
98	if (0 === strpos($strategy, 'i')) {	62✔
99	$strategy = substr($strategy, 1);	22✔
100	$caseSensitive = false;	22✔
101	}
102
103	$metadata = $this->getNestedMetadata($resourceClass, $associations);	62✔
104
105	if ($metadata->hasField($field)) {	62✔
106	if ('id' === $field) {	56✔
107	$values = array_map([$this, 'getIdFromValue'], $values);	2✔
108	}
109
110	if (!$this->hasValidValues($values, $this->getDoctrineFieldType($property, $resourceClass))) {	56✔
111	$this->logger->notice('Invalid filter ignored', [	×
112	'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),	×
113	]);
114
115	return;	×
116	}
117
118	$this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $alias, $field, $values, $caseSensitive, $metadata);	56✔
119
120	return;	56✔
121	}
122
123	// metadata doesn't have the field, nor an association on the field
124	if (!$metadata->hasAssociation($field)) {	8✔
125	return;	×
126	}
127
128	$values = array_map([$this, 'getIdFromValue'], $values);	8✔
129	$associationFieldIdentifier = 'id';	8✔
130	$doctrineTypeField = $this->getDoctrineFieldType($property, $resourceClass);	8✔
131
132	if (null !== $this->identifiersExtractor) {	8✔
133	$associationResourceClass = $metadata->getAssociationTargetClass($field);	8✔
134	$associationFieldIdentifier = $this->identifiersExtractor->getIdentifiersFromResourceClass($associationResourceClass)[0];	8✔
135	$doctrineTypeField = $this->getDoctrineFieldType($associationFieldIdentifier, $associationResourceClass);	8✔
136	}
137
138	if (!$this->hasValidValues($values, $doctrineTypeField)) {	8✔
139	$this->logger->notice('Invalid filter ignored', [	6✔
140	'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),	6✔
141	]);
142
143	return;	6✔
144	}
145
146	$associationAlias = $alias;	2✔
147	$associationField = $field;	2✔
148	if ($metadata->isCollectionValuedAssociation($associationField)) {	2✔
149	$associationAlias = QueryBuilderHelper::addJoinOnce($queryBuilder, $queryNameGenerator, $alias, $associationField);	2✔
150	$associationField = $associationFieldIdentifier;	2✔
151	}
152
153	$this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $associationAlias, $associationField, $values, $caseSensitive, $metadata);	2✔
154	}	2✔
155
156	/**
157	* Adds where clause according to the strategy.
158	*
159	* @throws InvalidArgumentException If strategy does not exist
160	*/
161	protected function addWhereByStrategy(string $strategy, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $alias, string $field, $values, bool $caseSensitive/, ClassMetadata $metadata/)
162	{
163	if (\func_num_args() > 7 && ($metadata = func_get_arg(7)) instanceof ClassMetadata) {	58✔
164	$type = $metadata->getTypeOfField($field);	58✔
165	if ($type && DBALType::getTypeRegistry()->has($type)) {	58✔
166	$type = null;	58✔
167	}
168	} else {
169	@trigger_error(sprintf('Method %s() will have a 8th argument `$metadata` in version API Platform 3.0.', __FUNCTION__), \E_USER_DEPRECATED);	×
170	$type = null;	×
171	}
172
173	if (!\is_array($values)) {	58✔
174	$values = [$values];	×
175	}
176
177	$wrapCase = $this->createWrapCase($caseSensitive);	58✔
178	$valueParameter = ':'.$queryNameGenerator->generateParameterName($field);	58✔
179	$aliasedField = sprintf('%s.%s', $alias, $field);	58✔
180
181	if (self::STRATEGY_EXACT === $strategy) {	58✔
182	if (1 === \count($values)) {	26✔
183	$queryBuilder
184	->andWhere($queryBuilder->expr()->eq($wrapCase($aliasedField), $wrapCase($valueParameter)))	22✔
185	->setParameter($valueParameter, $values[0], $type);	22✔
186
187	return;	22✔
188	}
189
190	$parameters = $queryBuilder->getParameters();	6✔
191	$inQuery = [];	6✔
192	foreach ($values as $value) {	6✔
193	$inQuery[] = $valueParameter;	6✔
194	$parameters->add(new Parameter($valueParameter, $caseSensitive ? $value : strtolower($value), $type));	6✔
195	$valueParameter = ':'.$queryNameGenerator->generateParameterName($field);	6✔
196	}
197
198	$queryBuilder
199	->andWhere($wrapCase($aliasedField).' IN ('.implode(', ', $inQuery).')')	6✔
200	->setParameters($parameters);	6✔
201
202	return;	6✔
203	}
204
205	$ors = [];	32✔
206	$parameters = [];	32✔
207	foreach ($values as $key => $value) {	32✔
208	$keyValueParameter = sprintf('%s_%s', $valueParameter, $key);	32✔
209	$parameters[$caseSensitive ? $value : strtolower($value)] = $keyValueParameter;	32✔
210
211	switch ($strategy) {
212	case self::STRATEGY_PARTIAL:	32✔
213	$ors[] = $queryBuilder->expr()->like(	8✔
214	$wrapCase($aliasedField),	8✔
215	$wrapCase((string) $queryBuilder->expr()->concat("'%'", $keyValueParameter, "'%'"))	8✔
216	);
217	break;	8✔
218	case self::STRATEGY_START:	24✔
219	$ors[] = $queryBuilder->expr()->like(	8✔
220	$wrapCase($aliasedField),	8✔
221	$wrapCase((string) $queryBuilder->expr()->concat($keyValueParameter, "'%'"))	8✔
222	);
223	break;	8✔
224	case self::STRATEGY_END:	16✔
225	$ors[] = $queryBuilder->expr()->like(	8✔
226	$wrapCase($aliasedField),	8✔
227	$wrapCase((string) $queryBuilder->expr()->concat("'%'", $keyValueParameter))	8✔
228	);
229	break;	8✔
230	case self::STRATEGY_WORD_START:	8✔
231	$ors[] = $queryBuilder->expr()->orX(	8✔
232	$queryBuilder->expr()->like($wrapCase($aliasedField), $wrapCase((string) $queryBuilder->expr()->concat($keyValueParameter, "'%'"))),	8✔
233	$queryBuilder->expr()->like($wrapCase($aliasedField), $wrapCase((string) $queryBuilder->expr()->concat("'% '", $keyValueParameter, "'%'")))	8✔
234	);
235	break;	8✔
236	default:
237	throw new InvalidArgumentException(sprintf('strategy %s does not exist.', $strategy));	×
238	}
239	}
240
241	$queryBuilder->andWhere($queryBuilder->expr()->orX(...$ors));	32✔
242	array_walk($parameters, [$queryBuilder, 'setParameter'], $type);	32✔
243	}	32✔
244
245	/**
246	* Creates a function that will wrap a Doctrine expression according to the
247	* specified case sensitivity.
248	*
249	* For example, "o.name" will get wrapped into "LOWER(o.name)" when $caseSensitive
250	* is false.
251	*/
252	protected function createWrapCase(bool $caseSensitive): \Closure
253	{
254	return static function (string $expr) use ($caseSensitive): string {
255	if ($caseSensitive) {	58✔
256	return $expr;	36✔
257	}
258
259	return sprintf('LOWER(%s)', $expr);	22✔
260	};	58✔
261	}
262
263	/**
264	* {@inheritdoc}
265	*/
266	protected function getType(string $doctrineType): string
267	{
268	switch ($doctrineType) {
269	case DBALType::TARRAY:	11✔
270	return 'array';	×
271	case DBALType::BIGINT:	11✔
272	case DBALType::INTEGER:	11✔
273	case DBALType::SMALLINT:	11✔
274	return 'int';	11✔
275	case DBALType::BOOLEAN:	11✔
276	return 'bool';	1✔
277	case DBALType::DATE:	11✔
278	case DBALType::TIME:	11✔
279	case DBALType::DATETIME:	11✔
280	case DBALType::DATETIMETZ:	11✔
281	return \DateTimeInterface::class;	8✔
282	case DBALType::FLOAT:	11✔
283	return 'float';	1✔
284	}
285
286	if (\defined(DBALType::class.'::DATE_IMMUTABLE')) {	11✔
287	switch ($doctrineType) {
288	case DBALType::DATE_IMMUTABLE:	11✔
289	case DBALType::TIME_IMMUTABLE:	11✔
290	case DBALType::DATETIME_IMMUTABLE:	11✔
291	case DBALType::DATETIMETZ_IMMUTABLE:	11✔
292	return \DateTimeInterface::class;	×
293	}
294	}
295
296	return 'string';	11✔
297	}
298	}

api-platform / core / #26796

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous