/** * Sets the attribute * * @param AttributeInterface $attribute * * @throws ColumnLabelException */ public function setAttribute(AttributeInterface $attribute = null) { $this->attribute = $attribute; if (null === $attribute) { $this->locale = null; $this->scope = null; $this->suffixes = $this->rawSuffixes; $this->propertyPath = lcfirst(Inflector::classify($this->name)); } else { if (!in_array($attribute->getBackendType(), [AbstractAttributeType::BACKEND_TYPE_REF_DATA_OPTION, AbstractAttributeType::BACKEND_TYPE_REF_DATA_OPTIONS])) { $this->propertyPath = $attribute->getBackendType(); } else { $this->propertyPath = $attribute->getReferenceDataName(); } $suffixes = $this->rawSuffixes; if ($attribute->isLocalizable()) { if (count($suffixes)) { $this->locale = array_shift($suffixes); } else { throw new ColumnLabelException('The column "%column%" must contain a locale code', ['%column%' => $this->label]); } } if ($attribute->isScopable()) { if (count($suffixes)) { $this->scope = array_shift($suffixes); } else { throw new ColumnLabelException('The column "%column%" must contain a scope code', ['%column%' => $this->label]); } } $this->suffixes = $suffixes; } }
/** * Sets the attribute * * @param AttributeInterface $attribute * * @throws ColumnLabelException */ public function setAttribute(AttributeInterface $attribute = null) { $this->attribute = $attribute; if (null === $attribute) { $this->locale = null; $this->scope = null; $this->suffixes = $this->rawSuffixes; $this->propertyPath = lcfirst(Inflector::classify($this->name)); } else { $this->propertyPath = $attribute->getBackendType(); $suffixes = $this->rawSuffixes; if ($attribute->isLocalizable()) { if (count($suffixes)) { $this->locale = array_shift($suffixes); } else { throw new ColumnLabelException('The column "%column%" must contain a locale code', array('%column%' => $this->label)); } } if ($attribute->isScopable()) { if (count($suffixes)) { $this->scope = array_shift($suffixes); } else { throw new ColumnLabelException('The column "%column%" must contain a scope code', array('%column%' => $this->label)); } } $this->suffixes = $suffixes; } }
function it_throws_an_exception_when_the_locale_is_not_provided($qb, AttributeInterface $attribute) { $attribute->getCode()->willReturn('my_code'); $attribute->getBackendType()->willReturn('options'); $attribute->getAttributeType()->willReturn('pim_catalog_simpleselect'); $this->shouldThrow('\\InvalidArgumentException')->duringAddAttributeSorter($attribute, 'desc', null, 'ecommerce'); }
function it_returns_not_blank_and_datetime_constraints(AttributeInterface $attribute) { $attribute->isRequired()->willReturn(true); $attribute->getBackendType()->willReturn(AbstractAttributeType::BACKEND_TYPE_DATETIME); $constraints = $this->guessConstraints($attribute); $constraints->shouldHaveCount(2); $constraints->offsetGet(0)->shouldReturnAnInstanceOf('Symfony\\Component\\Validator\\Constraints\\NotBlank'); $constraints->offsetGet(1)->shouldReturnAnInstanceOf('Symfony\\Component\\Validator\\Constraints\\DateTime'); }
/** * {@inheritdoc} */ public function addData($data) { $backendType = $this->attribute->getBackendType(); if (substr($backendType, -1, 1) === 's') { $backendType = substr($backendType, 0, strlen($backendType) - 1); } $name = 'add' . ucfirst($backendType); return $this->{$name}($data); }
function it_normalizes_value_with_decimal_support_backend(ProductValueInterface $value, AttributeInterface $attribute) { $attribute->getCode()->willReturn('code'); $attribute->getBackendType()->willReturn('decimal'); $attribute->isLocalizable()->willReturn(false); $attribute->isScopable()->willReturn(false); $value->getData()->willReturn('42.42'); $value->getAttribute()->willReturn($attribute); $this->normalize($value, 'mongodb_json', [])->shouldReturn(['code' => 42.42]); }
/** * @param ClassMetadata $metadata * @param Constraint $constraint * @param AttributeInterface $attribute */ protected function addConstraint(ClassMetadata $metadata, Constraint $constraint, AttributeInterface $attribute) { $target = $constraint->getTargets(); if (is_array($target)) { throw new \LogicException('No support provided for constraint on many targets'); } elseif (Constraint::PROPERTY_CONSTRAINT === $target) { $metadata->addPropertyConstraint($attribute->getBackendType(), $constraint); } elseif (Constraint::CLASS_CONSTRAINT === $target) { $metadata->addConstraint($constraint); } }
function let(QueryBuilder $qb, AttributeValidatorHelper $attrValidatorHelper, Expr $expr, AttributeInterface $image) { $this->beConstructedWith($attrValidatorHelper, ['pim_catalog_image', 'pim_catalog_file'], ['STARTS WITH', 'ENDS WITH', 'CONTAINS', 'DOES NOT CONTAIN', '=', 'EMPTY']); $this->setQueryBuilder($qb); $qb->getRootAlias()->willReturn('p'); $qb->expr()->willReturn($expr); $image->getId()->willReturn(1); $image->getCode()->willReturn('picture'); $image->isLocalizable()->willReturn(false); $image->isScopable()->willReturn(false); $image->getBackendType()->willReturn('media'); }
function it_normalizes_a_product_value_into_mongodb_document($mongoFactory, $serializer, ProductValueInterface $value, AttributeInterface $attribute, \MongoDBRef $mongoDBRef, \MongoId $mongoId) { $context = ['_id' => $mongoId, 'collection_name' => 'product']; $mongoFactory->createMongoId()->willReturn($mongoId); $mongoFactory->createMongoDBRef('product', $mongoId)->willReturn($mongoDBRef); $attribute->getId()->willReturn(123); $attribute->getBackendType()->willReturn('text'); $value->getAttribute()->willReturn($attribute); $value->getData()->willReturn('my description'); $value->getLocale()->willReturn(null); $value->getScope()->willReturn(null); $this->normalize($value, 'mongodb_document', $context)->shouldReturn(['_id' => $mongoId, 'attribute' => 123, 'entity' => $mongoDBRef, 'text' => 'my description']); }
function it_sets_the_locale_and_scope_when_denormalizing_values($serializer, AttributeInterface $attribute) { $attribute->getAttributeType()->willReturn('pim_catalog_number'); $attribute->getBackendType()->willReturn('decimal'); $attribute->isLocalizable()->willReturn(true); $attribute->isScopable()->willReturn(true); $serializer->denormalize(1, 'pim_catalog_number', 'json', Argument::type('array'))->shouldBeCalled()->willReturn(1); $value = $this->denormalize(['value' => 1, 'locale' => 'en_US', 'scope' => 'ecommerce'], 'Pim\\Bundle\\CatalogBundle\\Model\\ProductValue', 'json', ['attribute' => $attribute]); $value->shouldBeAnInstanceOf('Pim\\Bundle\\CatalogBundle\\Model\\ProductValue'); $value->getData()->shouldReturn(1); $value->getLocale()->shouldReturn('en_US'); $value->getScope()->shouldReturn('ecommerce'); }
/** * {@inheritdoc} */ public function addAttributeSorter(AttributeInterface $attribute, $direction, $locale = null, $scope = null) { $aliasPrefix = 'sorter'; $joinAlias = $aliasPrefix . 'V' . $attribute->getCode(); $backendType = $attribute->getBackendType(); // join to value $condition = $this->prepareAttributeJoinCondition($attribute, $joinAlias, $locale, $scope); $this->qb->leftJoin($this->qb->getRootAlias() . '.values', $joinAlias, 'WITH', $condition); $joinAliasMetric = $aliasPrefix . 'M' . $attribute->getCode(); $this->qb->leftJoin($joinAlias . '.' . $backendType, $joinAliasMetric); $this->qb->addOrderBy($joinAliasMetric . '.baseData', $direction); $idField = $this->qb->getRootAlias() . '.id'; $this->qb->addOrderBy($idField); return $this; }
function it_adds_a_sorter_to_the_query($qb, AttributeInterface $metric) { $metric->getId()->willReturn(42); $metric->getCode()->willReturn('metric_code'); $metric->getBackendType()->willReturn('metric'); $metric->isLocalizable()->willReturn(false); $metric->isScopable()->willReturn(false); $condition = "sorterVmetric_code.attribute = 42"; $qb->getRootAlias()->willReturn('r'); $qb->leftJoin('r.values', 'sorterVmetric_code', 'WITH', $condition)->shouldBeCalled(); $qb->leftJoin('sorterVmetric_code.metric', 'sorterMmetric_code')->shouldBeCalled(); $qb->addOrderBy('sorterMmetric_code.baseData', 'DESC')->shouldBeCalled(); $qb->addOrderBy('r.id')->shouldBeCalled(); $this->addAttributeSorter($metric, 'DESC'); }
/** * {@inheritdoc} */ public function guessConstraints(AttributeInterface $attribute) { $constraints = array(); if ($attribute->isRequired()) { $constraints[] = new Constraints\NotBlank(); } switch ($attribute->getBackendType()) { case AbstractAttributeType::BACKEND_TYPE_DATE: $constraints[] = new Constraints\Date(); break; case AbstractAttributeType::BACKEND_TYPE_DATETIME: $constraints[] = new Constraints\DateTime(); break; } return $constraints; }
function it_adds_an_equal_filter_on_an_attribute_in_the_query($qb, $attrValidatorHelper, AttributeInterface $attribute, Expr $expr) { $attribute->getBackendType()->willReturn('backend_type'); $attribute->getCode()->willReturn('code'); $attribute->getId()->willReturn(42); $attribute->isLocalizable()->willReturn(false); $attribute->isScopable()->willReturn(false); $attrValidatorHelper->validateLocale($attribute, Argument::any())->shouldBeCalled(); $attrValidatorHelper->validateScope($attribute, Argument::any())->shouldBeCalled(); $qb->expr()->willReturn($expr); $qb->getRootAlias()->willReturn('p'); $expr->eq(Argument::any(), true)->willReturn('filtercode.backend_type = true'); $expr->literal(true)->willReturn(true); $qb->innerJoin('p.values', Argument::any(), 'WITH', Argument::any())->shouldBeCalled(); $this->addAttributeFilter($attribute, '=', true); }
function it_adds_an_attribute_sorter_to_the_query($qb, AttributeInterface $sku) { $sku->getId()->willReturn(42); $sku->getCode()->willReturn('sku'); $sku->getBackendType()->willReturn('varchar'); $sku->isLocalizable()->willReturn(false); $sku->isScopable()->willReturn(false); $qb->expr()->willReturn(new Expr()); $qb->getRootAlias()->willReturn('p'); $qb->getDQLPart('join')->willReturn([]); $qb->resetDQLPart('join')->shouldBeCalled(); $condition = "sorterVsku.attribute = 42"; $qb->leftJoin('p.values', 'sorterVsku', 'WITH', $condition)->shouldBeCalled(); $qb->addOrderBy('sorterVsku.varchar', 'DESC')->shouldBeCalled(); $qb->getRootAlias()->willReturn('p'); $qb->addOrderBy("p.id")->shouldBeCalled(); $this->addAttributeSorter($sku, 'DESC'); }
/** * {@inheritdoc} */ public function addAttributeSorter(AttributeInterface $attribute, $direction, $locale = null, $scope = null) { $aliasPrefix = 'sorter'; $joinAlias = $aliasPrefix . 'V' . $attribute->getCode(); $backendType = $attribute->getBackendType(); // join to value and sort on $condition = $this->prepareAttributeJoinCondition($attribute, $joinAlias, $locale, $scope); // Remove current join in order to put the orderBy related join // at first place in the join queue for performances reasons $joinsSet = $this->qb->getDQLPart('join'); $this->qb->resetDQLPart('join'); $this->qb->leftJoin($this->qb->getRootAlias() . '.values', $joinAlias, 'WITH', $condition); $this->qb->addOrderBy($joinAlias . '.' . $backendType, $direction); $idField = $this->qb->getRootAlias() . '.id'; $this->qb->addOrderBy($idField); // Reapply previous join after the orderBy related join // TODO : move this part in re-usable class $this->applyJoins($joinsSet); return $this; }
/** * {@inheritdoc} */ public function addAttributeSorter(AttributeInterface $attribute, $direction, $locale = null, $scope = null) { $aliasPrefix = 'sorter'; $joinAlias = $aliasPrefix . 'V' . $attribute->getCode(); $backendType = $attribute->getBackendType(); if (null === $locale) { throw new \InvalidArgumentException(sprintf('Cannot prepare condition on type "%s" without locale', $attribute->getAttributeType())); } // join to value $condition = $this->prepareAttributeJoinCondition($attribute, $joinAlias, $locale, $scope); $this->qb->leftJoin($this->qb->getRootAlias() . '.values', $joinAlias, 'WITH', $condition); // then to option and option value to sort on $joinAliasOpt = $aliasPrefix . 'O' . $attribute->getCode(); $condition = $joinAliasOpt . ".attribute = " . $attribute->getId(); $this->qb->leftJoin($joinAlias . '.' . $backendType, $joinAliasOpt, 'WITH', $condition); $joinAliasOptVal = $aliasPrefix . 'OV' . $attribute->getCode(); $condition = $joinAliasOptVal . '.locale = ' . $this->qb->expr()->literal($locale); $this->qb->leftJoin($joinAliasOpt . '.optionValues', $joinAliasOptVal, 'WITH', $condition); $this->qb->addOrderBy($joinAliasOpt . '.code', $direction); $this->qb->addOrderBy($joinAliasOptVal . '.value', $direction); $idField = $this->qb->getRootAlias() . '.id'; $this->qb->addOrderBy($idField); return $this; }
/** * {@inheritdoc} */ public function supportAttribute(AttributeInterface $attribute) { $availableTypes = [AbstractAttributeType::BACKEND_TYPE_VARCHAR, AbstractAttributeType::BACKEND_TYPE_DATE, AbstractAttributeType::BACKEND_TYPE_DATETIME, AbstractAttributeType::BACKEND_TYPE_DECIMAL, AbstractAttributeType::BACKEND_TYPE_INTEGER]; return in_array($attribute->getBackendType(), $availableTypes); }
/** * Add non empty filter to the query * * @param AttributeInterface $attribute * @param string $operator * @param string $value * @param string $locale * @param string $scope */ protected function addNonEmptyFilter(AttributeInterface $attribute, $operator, $value, $locale = null, $scope = null) { $backendType = $attribute->getBackendType(); $joinAlias = $this->getUniqueAlias('filter' . $attribute->getCode(), true); // inner join to value $condition = $this->prepareAttributeJoinCondition($attribute, $joinAlias, $locale, $scope); $this->qb->innerJoin($this->qb->getRootAlias() . '.values', $joinAlias, 'WITH', $condition); $joinAliasOpt = $this->getUniqueAlias('filterM' . $attribute->getCode()); $backendField = sprintf('%s.%s', $joinAliasOpt, 'baseData'); $condition = $this->prepareCriteriaCondition($backendField, $operator, $value); $this->qb->innerJoin($joinAlias . '.' . $backendType, $joinAliasOpt, 'WITH', $condition); }
/** * return bool */ protected function isBackendTypeReferenceData() { return in_array($this->attribute->getBackendType(), [AbstractAttributeType::BACKEND_TYPE_REF_DATA_OPTION, AbstractAttributeType::BACKEND_TYPE_REF_DATA_OPTIONS]); }
function it_adds_an_empty_filter_in_the_query($currencyManager, QueryBuilder $queryBuilder, AttributeInterface $price, Expr $expr, Comparison $comparison) { $price->getId()->willReturn(42); $price->getCode()->willReturn('price'); $price->getBackendType()->willReturn('prices'); $price->isLocalizable()->willReturn(false); $price->isScopable()->willReturn(false); $queryBuilder->expr()->willReturn(new Expr()); $queryBuilder->getRootAlias()->willReturn('p'); $value = ['data' => null, 'currency' => 'EUR']; $currencyManager->getActiveCodes()->willReturn(['EUR', 'USD']); $queryBuilder->leftJoin('p.values', Argument::any(), 'WITH', Argument::any())->shouldBeCalled(); $queryBuilder->leftJoin(Argument::any(), Argument::any())->shouldBeCalled(); $queryBuilder->expr()->willReturn($expr); $expr->literal('EUR')->willReturn('EUR'); $expr->eq(Argument::any(), 'EUR')->willReturn($comparison); $expr->isNull(Argument::any())->willReturn('filterPprice.data IS NULL'); $expr->isNull(Argument::any())->willReturn('filterPprice.id IS NULL'); $expr->orX(Argument::any(), Argument::any())->shouldBeCalled(); $queryBuilder->andWhere(null)->shouldBeCalled(); $this->addAttributeFilter($price, 'EMPTY', $value); }
function it_returns_null_when_unknown_backendtype($context, ProductValueComplete $constraint, ProductValueInterface $productValue, AttributeInterface $attribute) { $constraint->getChannel()->willReturn($this->getChannel()); $metric = new Metric(); $productValue->getMetric()->willReturn($metric); $productValue->getData()->willReturn('data'); $attribute->getBackendType()->willReturn('unknown_metric'); $productValue->getAttribute()->willReturn($attribute); $context->buildViolation(Argument::any())->shouldNotBeCalled(); $this->validate($productValue, $constraint); }
/** * @param AttributeInterface $attribute the attribute * @param string $joinAlias the join alias * @param string $joinAliasMedia the join alias */ protected function addMediaLeftJoin(AttributeInterface $attribute, $joinAlias, $joinAliasMedia) { $backendType = $attribute->getBackendType(); $this->qb->leftJoin($joinAlias . '.' . $backendType, $joinAliasMedia); }
public function it_does_not_guess_unique_value(AttributeInterface $attribute) { $attribute->getBackendType()->willReturn(AbstractAttributeType::BACKEND_TYPE_VARCHAR); $attribute->isUnique()->willReturn(false); $this->guessConstraints($attribute)->shouldReturn([]); }
function it_throws_an_exception_when_given_an_incorrect_label_length(AttributeInterface $attribute) { $this->beConstructedWith('name-en_US'); $attribute->isLocalizable()->willReturn(true); $attribute->isScopable()->willReturn(true); $attribute->getBackendType()->willReturn(null); $this->shouldThrow(new ColumnLabelException('The column "%column%" must contain a scope code', array('%column%' => 'name-en_US')))->during('setAttribute', [$attribute]); }
function it_throws_exception_when_the_field_name_is_not_consistent_with_the_channel_locale($managerRegistry, IdentifiableObjectRepositoryInterface $repository, AttributeInterface $attribute, IdentifiableObjectRepositoryInterface $channelRepository, IdentifiableObjectRepositoryInterface $localeRepository, LocaleInterface $locale, ChannelInterface $channel) { // localizable without the associated locale not in the channel $attribute->getCode()->willReturn('description'); $attribute->isLocalizable()->willReturn(true); $attribute->isScopable()->willReturn(true); $attribute->getBackendType()->willReturn('text'); $attribute->isLocaleSpecific()->willReturn(false); $attributeInfos = ['attribute' => $attribute, 'locale_code' => 'de_DE', 'scope_code' => 'mobile']; $managerRegistry->getRepository(self::ATTRIBUTE_CLASS)->willReturn($repository); $repository->findOneByIdentifier('description')->willReturn($attribute); $managerRegistry->getRepository(self::CHANNEL_CLASS)->shouldBeCalled()->willReturn($channelRepository); $channelRepository->findOneByIdentifier($attributeInfos['scope_code'])->shouldBeCalled()->willReturn($channel); $managerRegistry->getRepository(self::LOCALE_CLASS)->shouldBeCalled()->willReturn($localeRepository); $localeRepository->findOneByIdentifier($attributeInfos['locale_code'])->shouldBeCalled()->willReturn($locale); $channel->hasLocale($locale)->shouldBeCalled()->willReturn(false); $this->shouldThrow(new \InvalidArgumentException('The locale "de_DE" of the field "description-de_DE-mobile" is not available in scope "mobile"'))->duringExtractAttributeFieldNameInfos('description-de_DE-mobile'); }
function it_merges_columns_which_represents_price_attribute_value_in_many_columns($fieldExtractor, AttributeInterface $price) { $row = ['price-EUR' => '10', 'price-USD' => '12', 'price-CHF' => '14']; $attributeInfoEur = ['attribute' => $price, 'locale_code' => null, 'scope_code' => null, 'price_currency' => 'EUR']; $fieldExtractor->extractColumnInfo('price-EUR')->willReturn($attributeInfoEur); $attributeInfoUsd = ['attribute' => $price, 'locale_code' => null, 'scope_code' => null, 'price_currency' => 'USD']; $fieldExtractor->extractColumnInfo('price-USD')->willReturn($attributeInfoUsd); $attributeInfoChf = ['attribute' => $price, 'locale_code' => null, 'scope_code' => null, 'price_currency' => 'CHF']; $fieldExtractor->extractColumnInfo('price-CHF')->willReturn($attributeInfoChf); $price->getCode()->willReturn('price'); $price->getBackendType()->willReturn('prices'); $mergedRow = ['price' => '10 EUR,12 USD,14 CHF']; $this->merge($row)->shouldReturn($mergedRow); }
/** * Check the consistency of the field with the attribute and it properties locale, scope, currency * * @param AttributeInterface $attribute * @param string $fieldName * @param array $explodedFieldName * * @throws \InvalidArgumentException */ protected function checkFieldNameTokens(AttributeInterface $attribute, $fieldName, array $explodedFieldName) { // the expected number of tokens in a field may vary, // - with the current price import, the currency can be optionally present in the header, // - with the current metric import, a "-unit" field can be added in the header, // // To avoid BC break, we keep the support in this fix, a next minor version could contain only the // support of currency code in the header and metric in a single field $isLocalizable = $attribute->isLocalizable(); $isScopable = $attribute->isScopable(); $isPrice = 'prices' === $attribute->getBackendType(); $isMetric = 'metric' === $attribute->getBackendType(); if ($isLocalizable && $isScopable && $isPrice) { $expectedSize = [3, 4]; } elseif ($isLocalizable && $isScopable && $isMetric) { $expectedSize = [3, 4]; } elseif ($isLocalizable && $isScopable) { $expectedSize = [3]; } elseif ($isLocalizable && $isPrice) { $expectedSize = [2, 3]; } elseif ($isScopable && $isPrice) { $expectedSize = [2, 3]; } elseif ($isLocalizable && $isMetric) { $expectedSize = [2, 3]; } elseif ($isScopable && $isMetric) { $expectedSize = [2, 3]; } elseif ($isLocalizable) { $expectedSize = [2]; } elseif ($isScopable) { $expectedSize = [2]; } elseif ($isPrice) { $expectedSize = [1, 2]; } elseif ($isMetric) { $expectedSize = [1, 2]; } else { $expectedSize = [1]; } $nbTokens = count($explodedFieldName); if (!in_array($nbTokens, $expectedSize)) { $expected = [$isLocalizable ? 'a locale' : 'no locale', $isScopable ? 'a scope' : 'no scope', $isPrice ? 'an optional currency' : 'no currency']; $expected = implode($expected, ', '); throw new \InvalidArgumentException(sprintf('The field "%s" is not well-formatted, attribute "%s" expects %s', $fieldName, $attribute->getCode(), $expected)); } if ($isLocalizable) { $this->checkForLocaleSpecificValue($attribute, $explodedFieldName); } }
function it_logs_error_when_the_maximum_number_of_indexes_is_reached($collection, AttributeInterface $description, $namingUtility, $logger) { $description->getCode()->willReturn('description'); $description->getBackendType()->willReturn('varchar'); $description->isLocalizable()->willReturn(true); $description->isScopable()->willReturn(false); $description->isUseableAsGridFilter()->willReturn(true); $description->getAttributeType()->willReturn('pim_catalog_textarea'); $namingUtility->getAttributeNormFields($description)->willReturn(['normalizedData.description-en_US', 'normalizedData.description-de_DE']); $indexes = array_fill(0, 64, 'fake_index'); $collection->getIndexInfo()->willReturn($indexes); $logger->error(Argument::any())->shouldBeCalled(); $collection->ensureIndex(Argument::any(), Argument::any())->shouldNotBeCalled(); $this->ensureIndexesFromAttribute($description); }
/** * @param AttributeInterface $attribute * @param array $value * @param string $operator * @param string $locale * @param string $scope */ protected function addNonEmptyFilter(AttributeInterface $attribute, array $value, $operator, $locale = null, $scope = null) { $backendType = $attribute->getBackendType(); $joinAlias = $this->getUniqueAlias('filter' . $attribute->getCode(), true); // join to value $condition = $this->prepareAttributeJoinCondition($attribute, $joinAlias, $locale, $scope); $this->qb->innerJoin($this->qb->getRootAlias() . '.values', $joinAlias, 'WITH', $condition); $joinAliasPrice = $this->getUniqueAlias('filterP' . $attribute->getCode()); $condition = $this->preparePriceCondition($value, $joinAliasPrice, $operator); $this->qb->innerJoin($joinAlias . '.' . $backendType, $joinAliasPrice, 'WITH', $condition); }