/** * Normalize the field name from attribute and catalog context * * @param AttributeInterface $attribute * @param string $locale * @param string $scope * * @return string */ public static function getNormalizedValueFieldFromAttribute(AttributeInterface $attribute, $locale = null, $scope = null) { if ($attribute->isLocalizable() && null === $locale) { throw new \LogicException('Locale is not configured'); } if ($attribute->isScopable() && null === $scope) { throw new \LogicException('Scope is not configured'); } return self::getNormalizedValueField($attribute->getCode(), $attribute->isLocalizable(), $attribute->isScopable(), $attribute->isLocalizable() ? $locale : null, $attribute->isScopable() ? $scope : null); }
function it_normalizes_attribute($transNormalizer, $dateTimeNormalizer, AttributeInterface $attribute, AttributeGroupInterface $attributeGroup) { $transNormalizer->normalize(Argument::cetera())->willReturn([]); $dateMin = new \DateTime('2015-05-23 15:55:50'); $dateMax = new \DateTime('2015-06-23 15:55:50'); $attribute->getAttributeType()->willReturn('Yes/No'); $attribute->getCode()->willReturn('attribute_size'); $attribute->getGroup()->willReturn($attributeGroup); $attributeGroup->getCode()->willReturn('size'); $attribute->isUnique()->willReturn(true); $attribute->isUseableAsGridFilter()->willReturn(true); $attribute->getAllowedExtensions()->willReturn(['csv', 'xml', 'json']); $attribute->getMetricFamily()->willReturn('Length'); $attribute->getDefaultMetricUnit()->willReturn('Centimenter'); $attribute->getReferenceDataName()->willReturn('color'); $attribute->isLocalizable()->willReturn(true); $attribute->isScopable()->willReturn(true); $attribute->getLocaleSpecificCodes()->willReturn(['en_US', 'fr_FR']); $attribute->getMaxCharacters()->willReturn(255); $attribute->getValidationRule()->willReturn('email'); $attribute->getValidationRegexp()->willReturn('[0-9]*'); $attribute->isWysiwygEnabled()->willReturn(true); $attribute->getNumberMin()->willReturn('0.55'); $attribute->getNumberMax()->willReturn('1500.55'); $attribute->isDecimalsAllowed()->willReturn(true); $attribute->isNegativeAllowed()->willReturn(true); $attribute->getDateMin()->willReturn($dateMin); $attribute->getDateMax()->willReturn($dateMax); $attribute->getMaxFileSize()->willReturn(1024); $attribute->getMinimumInputLength()->willReturn(2); $attribute->getSortOrder()->willReturn(4); $dateTimeNormalizer->normalize($dateMin)->willReturn('2015-05-23T15:55:50+01:00'); $dateTimeNormalizer->normalize($dateMax)->willReturn('2015-06-23T15:55:50+01:00'); $this->normalize($attribute)->shouldReturn(['code' => 'attribute_size', 'type' => 'Yes/No', 'group' => 'size', 'unique' => true, 'useable_as_grid_filter' => true, 'allowed_extensions' => ['csv', 'xml', 'json'], 'metric_family' => 'Length', 'default_metric_unit' => 'Centimenter', 'reference_data_name' => 'color', 'available_locales' => ['en_US', 'fr_FR'], 'max_characters' => 255, 'validation_rule' => 'email', 'validation_regexp' => '[0-9]*', 'wysiwyg_enabled' => true, 'number_min' => '0.55', 'number_max' => '1500.55', 'decimals_allowed' => true, 'negative_allowed' => true, 'date_min' => '2015-05-23T15:55:50+01:00', 'date_max' => '2015-06-23T15:55:50+01:00', 'max_file_size' => '1024', 'minimum_input_length' => 2, 'sort_order' => 4, 'localizable' => true, 'scopable' => true, 'labels' => []]); }
function it_resolves_eligible_values_for_a_set_of_attributes($localeRepository, $channelRepository, AttributeInterface $sku, AttributeInterface $name, AttributeInterface $desc, AttributeInterface $tax, LocaleInterface $fr, LocaleInterface $en, ChannelInterface $ecom, ChannelInterface $print) { $sku->getCode()->willReturn('sku'); $sku->getAttributeType()->willReturn('pim_catalog_identifier'); $sku->isLocalizable()->willReturn(false); $sku->isScopable()->willReturn(false); $sku->isLocaleSpecific()->willReturn(false); $name->getCode()->willReturn('name'); $name->getAttributeType()->willReturn('pim_catalog_text'); $name->isLocalizable()->willReturn(true); $name->isScopable()->willReturn(false); $name->isLocaleSpecific()->willReturn(false); $desc->getCode()->willReturn('description'); $desc->getAttributeType()->willReturn('pim_catalog_text'); $desc->isLocalizable()->willReturn(true); $desc->isScopable()->willReturn(true); $desc->isLocaleSpecific()->willReturn(false); $tax->getCode()->willReturn('tax'); $tax->getAttributeType()->willReturn('pim_catalog_text'); $tax->isLocalizable()->willReturn(true); $tax->isScopable()->willReturn(false); $tax->isLocaleSpecific()->willReturn(true); $tax->getLocaleSpecificCodes()->willReturn(['fr_FR']); $fr->getCode()->willReturn('fr_FR'); $en->getCode()->willReturn('en_US'); $localeRepository->getActivatedLocales()->willReturn([$fr, $en]); $ecom->getCode()->willReturn('ecommerce'); $ecom->getLocales()->willReturn([$en, $fr]); $print->getCode()->willReturn('print'); $print->getLocales()->willReturn([$en, $fr]); $channelRepository->findAll()->willReturn([$ecom, $print]); $this->resolveEligibleValues([$sku, $name, $desc, $tax])->shouldReturn([['attribute' => 'sku', 'type' => 'pim_catalog_identifier', 'locale' => null, 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => null], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'print'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'print'], ['attribute' => 'tax', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => null]]); }
/** * Returns available information for the attribute and filters which supports it * * @param AttributeInterface $attribute * @param array $attributeFilters * * @return array */ protected function getFilterInformationForAttribute(AttributeInterface $attribute, array $attributeFilters) { $field = $attribute->getCode(); $attributeType = $attribute->getAttributeType(); $isLocalizable = $attribute->isLocalizable() ? 'yes' : 'no'; $isScopable = $attribute->isScopable() ? 'yes' : 'no'; $newEntries = []; if (array_key_exists($attributeType, $attributeFilters)) { foreach ($attributeFilters[$attributeType] as $filter) { $class = get_class($filter); $operators = implode(', ', $filter->getOperators()); $newEntries[] = [$field, $isLocalizable, $isScopable, $attributeType, $operators, $class]; } return $newEntries; } if ($attribute->isBackendTypeReferenceData()) { foreach ($this->registry->getAttributeFilters() as $filter) { if ($filter->supportsAttribute($attribute)) { $class = get_class($filter); $operators = implode(', ', $filter->getOperators()); $newEntries[] = [$field, $isLocalizable, $isScopable, $attributeType, $operators, $class]; } } return $newEntries; } return [[$field, $isLocalizable, $isScopable, $attributeType, '', 'Not supported']]; }
function let(TranslationNormalizer $transnormalizer, AttributeInterface $attribute, AttributeGroupInterface $attributeGroup) { $this->beConstructedWith($transnormalizer); $transnormalizer->normalize(Argument::cetera())->willReturn([]); $attribute->getAttributeType()->willReturn('Yes/No'); $attribute->getCode()->willReturn('attribute_size'); $attribute->getGroup()->willReturn($attributeGroup); $attributeGroup->getCode()->willReturn('size'); $attribute->isUnique()->willReturn(true); $attribute->isUseableAsGridFilter()->willReturn(false); $attribute->getAllowedExtensions()->willReturn(['csv', 'xml', 'json']); $attribute->getMetricFamily()->willReturn('Length'); $attribute->getDefaultMetricUnit()->willReturn('Centimenter'); $attribute->getReferenceDataName()->willReturn('color'); $attribute->isLocalizable()->willReturn(true); $attribute->isScopable()->willReturn(false); $attribute->getLocaleSpecificCodes()->willReturn(['en_US', 'fr_FR']); $attribute->getMaxCharacters()->willReturn(null); $attribute->getValidationRule()->willReturn(null); $attribute->getValidationRegexp()->willReturn(null); $attribute->isWysiwygEnabled()->willReturn(false); $attribute->getNumberMin()->willReturn(''); $attribute->getNumberMax()->willReturn(''); $attribute->isDecimalsAllowed()->willReturn(false); $attribute->isNegativeAllowed()->willReturn(false); $attribute->getDateMin()->willReturn(null); $attribute->getDateMax()->willReturn(null); $attribute->getMaxFileSize()->willReturn(null); $attribute->getMinimumInputLength()->willReturn(null); $attribute->getSortOrder()->willReturn(0); }
function it_throws_an_exception_when_scope_is_not_activated($scopeRepository, AttributeInterface $description) { $scopeRepository->getChannelCodes()->willReturn([]); $description->isScopable()->willReturn(true); $description->getCode()->willReturn('description'); $this->shouldThrow(new \LogicException('Attribute "description" expects an existing scope, "print" given.'))->during('validateScope', [$description, 'print']); }
function let(Builder $qb, AttributeInterface $image, AttributeValidatorHelper $attrValidatorHelper) { $this->beConstructedWith($attrValidatorHelper, ['pim_catalog_image', 'pim_catalog_file'], ['STARTS WITH', 'ENDS WITH', 'CONTAINS', 'DOES NOT CONTAIN', '=', 'EMPTY']); $this->setQueryBuilder($qb); $image->getCode()->willReturn('picture'); $image->isLocalizable()->willReturn(false); $image->isScopable()->willReturn(false); }
function let(SerializerInterface $serializer, AttributeInterface $simpleAttribute) { $serializer->implement('Symfony\\Component\\Serializer\\Normalizer\\NormalizerInterface'); $this->setSerializer($serializer); $simpleAttribute->isLocalizable()->willReturn(false); $simpleAttribute->isScopable()->willReturn(false); $simpleAttribute->getCode()->willReturn('simple'); }
function it_throws_an_exception_when_the_scope_is_not_provided(AttributeInterface $price) { $price->getId()->willReturn(42); $price->isLocalizable()->willReturn(false); $price->isScopable()->willReturn(true); $price->getCode()->willReturn('price'); $this->shouldThrow('\\InvalidArgumentException')->duringPrepareCondition($price, 'alias', 'en_US', null); }
/** * Prepare join to attribute condition with current locale and scope criterias * * @param AttributeInterface $attribute the attribute * @param string $joinAlias the value join alias * @param string $locale the locale * @param string $scope the scope * * @return string */ public function prepareCondition(AttributeInterface $attribute, $joinAlias, $locale = null, $scope = null) { $condition = $joinAlias . '.attribute = ' . $attribute->getId(); if ($attribute->isLocalizable() && null === $locale) { throw new \InvalidArgumentException(sprintf('Cannot prepare condition on localizable attribute "%s" without locale', $attribute->getCode())); } if ($attribute->isLocalizable()) { $condition .= ' AND ' . $joinAlias . '.locale = ' . $this->qb->expr()->literal($locale); } if ($attribute->isScopable() && null === $scope) { throw new \InvalidArgumentException(sprintf('Cannot prepare condition on scopable attribute "%s" without scope', $attribute->getCode())); } if ($attribute->isScopable()) { $condition .= ' AND ' . $joinAlias . '.scope = ' . $this->qb->expr()->literal($scope); } return $condition; }
function let(SerializerInterface $serializer, AttributeInterface $simpleAttribute, LocalizerRegistryInterface $localizerRegistry) { $this->beConstructedWith($localizerRegistry, 4); $serializer->implement('Symfony\\Component\\Serializer\\Normalizer\\NormalizerInterface'); $this->setSerializer($serializer); $simpleAttribute->isLocalizable()->willReturn(false); $simpleAttribute->isScopable()->willReturn(false); $simpleAttribute->getCode()->willReturn('simple'); }
function it_adds_a_order_by_on_an_attribute_value_in_the_query(Builder $queryBuilder, AttributeInterface $sku) { $sku->getCode()->willReturn('sku'); $sku->isLocalizable()->willReturn(false); $sku->isScopable()->willReturn(false); $queryBuilder->sort('normalizedData.sku', 'desc')->willReturn($queryBuilder); $queryBuilder->sort('_id')->shouldBeCalled(); $this->addAttributeSorter($sku, 'desc'); }
/** * Check if scope data is consistent with the attribute scopable property * * @param AttributeInterface $attribute * @param string $scope * * @throws \LogicException */ public function validateScope(AttributeInterface $attribute, $scope) { if (!$attribute->isScopable() && null === $scope) { return; } if ($attribute->isScopable() && null === $scope) { throw new \LogicException(sprintf('Attribute "%s" expects a scope, none given.', $attribute->getCode())); } if (!$attribute->isScopable() && null !== $scope) { throw new \LogicException(sprintf('Attribute "%s" does not expect a scope, "%s" given.', $attribute->getCode(), $scope)); } if (null === static::$scopeCodes) { static::$scopeCodes = $this->getScopeCodes(); } if (!in_array($scope, static::$scopeCodes)) { throw new \LogicException(sprintf('Attribute "%s" expects an existing scope, "%s" given.', $attribute->getCode(), $scope)); } }
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]); }
function it_throws_an_exception_when_scope_is_expected_but_not_existing($attrValidatorHelper, AttributeInterface $attribute) { $e = new \LogicException('Attribute "attributeCode" expects an existing scope, "ecommerce" given.'); $attribute->getCode()->willReturn('attributeCode'); $attribute->isLocalizable()->willReturn(false); $attribute->isScopable()->willReturn(true); $attrValidatorHelper->validateLocale($attribute, null)->shouldBeCalled(); $attrValidatorHelper->validateScope($attribute, 'ecommerce')->willThrow($e); $this->shouldThrow(InvalidArgumentException::expectedFromPreviousException($e, 'attributeCode', 'copier', 'concrete'))->during('testLocaleAndScope', [$attribute, null, 'ecommerce']); }
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', 'NOT 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_denormalizes_variant_group_values($fieldExtractor, $valueDenormalizer, AttributeInterface $description) { $fieldExtractor->extractColumnInfo('description-ecommerce-en_US')->willReturn(['attribute' => $description, 'locale_code' => 'en_US', 'scope_code' => 'ecommerce'])->shouldBeCalled(); $fieldExtractor->extractColumnInfo('description-ecommerce-fr_FR')->willReturn(['attribute' => $description, 'locale_code' => 'fr_FR', 'scope_code' => 'ecommerce'])->shouldBeCalled(); $description->getCode()->willReturn('description'); $description->isLocalizable()->willReturn(true); $description->isScopable()->willReturn(true); $valueDenormalizer->denormalize('My en_US desc', self::VALUE_CLASS, self::FORMAT_CSV, Argument::any())->shouldBeCalled(); $valueDenormalizer->denormalize('My fr_FR desc', self::VALUE_CLASS, self::FORMAT_CSV, Argument::any())->shouldBeCalled(); $csvData = ['description-ecommerce-en_US' => 'My en_US desc', 'description-ecommerce-fr_FR' => 'My fr_FR desc']; $this->denormalize($csvData, 'ProductValue[]', 'csv'); }
function it_sets_the_locale_and_scope_when_denormalizing_values($serializer, AttributeInterface $attribute) { $attribute->getAttributeType()->willReturn('pim_catalog_number'); $attribute->getBackendType()->willReturn('decimal'); $attribute->isBackendTypeReferenceData()->willReturn(false); $attribute->isLocalizable()->willReturn(true); $attribute->isScopable()->willReturn(true); $serializer->denormalize(1, 'pim_catalog_number', 'json', Argument::type('array'))->shouldBeCalled()->willReturn(1); $value = $this->denormalize(['data' => 1, 'locale' => 'en_US', 'scope' => 'ecommerce'], 'Pim\\Component\\Catalog\\Model\\ProductValue', 'json', ['attribute' => $attribute]); $value->shouldBeAnInstanceOf('Pim\\Component\\Catalog\\Model\\ProductValue'); $value->getData()->shouldReturn(1); $value->getLocale()->shouldReturn('en_US'); $value->getScope()->shouldReturn('ecommerce'); }
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'); }
function it_adds_attributes_to_a_product_template($denormalizer, $normalizer, $productBuilder, ProductTemplateInterface $template, ProductValueInterface $colorValue, AttributeInterface $name, AttributeInterface $color) { $color->getCode()->willReturn('color'); $color->isLocalizable()->willReturn(false); $color->isScopable()->willReturn(false); $colorValue->getAttribute()->willReturn($color); $colorValue->setEntity(Argument::type('Pim\\Component\\Catalog\\Model\\Product'))->willReturn($colorValue); $options = ['locale' => 'en_US', 'disable_grouping_separator' => true]; $template->getValuesData()->willReturn(['color' => 'bar']); $denormalizer->denormalize(['color' => 'bar'], 'ProductValue[]', 'json', $options)->shouldBeCalled()->willReturn([$colorValue]); $productBuilder->addAttributeToProduct(Argument::type('Pim\\Component\\Catalog\\Model\\Product'), $name)->shouldBeCalled(); $productBuilder->addMissingProductValues(Argument::type('Pim\\Component\\Catalog\\Model\\Product'))->shouldBeCalled(); $normalizer->normalize(Argument::type('Doctrine\\Common\\Collections\\ArrayCollection'), 'json', ['entity' => 'product', 'locale' => 'en_US', 'disable_grouping_separator' => true])->shouldBeCalled()->willReturn(['name' => 'foo', 'color' => 'bar']); $template->setValuesData(['name' => 'foo', 'color' => 'bar'])->shouldBeCalled(); $this->addAttributes($template, [$name], 'en_US'); }
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_retrieves_field_list_with_product_with_attributes($productRepository, $attributeRepository, $assocTypeRepo, AttributeInterface $bar, AttributeInterface $baz, AssociationTypeInterface $association) { $bar->getCode()->willReturn('bar-code'); $bar->isLocalizable()->willReturn(false); $bar->isScopable()->willReturn(false); $bar->getAttributeType()->willReturn(null); $baz->getCode()->willReturn('baz-code'); $baz->isLocalizable()->willReturn(false); $baz->isScopable()->willReturn(false); $baz->getAttributeType()->willReturn(null); $association->getCode()->willReturn('association-type-code'); $assocTypeRepo->findAll()->willReturn([$association]); $productRepository->getAvailableAttributeIdsToExport(['foo'])->willReturn(['bar', 'baz']); $attributeRepository->findBy(['id' => ['bar', 'baz']])->willReturn([$bar, $baz]); $this->getFieldsList(['foo'])->shouldReturn(["bar-code", "baz-code", "family", "categories", "groups", "association-type-code-groups", "association-type-code-products"]); }
function let(TranslationNormalizer $transnormalizer, AttributeInterface $attribute, AttributeGroupInterface $attributeGroup) { $this->beConstructedWith($transnormalizer); $transnormalizer->normalize(Argument::cetera())->willReturn([]); $attribute->getAttributeType()->willReturn('Yes/No'); $attribute->getCode()->willReturn('attribute_size'); $attribute->getGroup()->willReturn($attributeGroup); $attributeGroup->getCode()->willReturn('size'); $attribute->isUnique()->willReturn(true); $attribute->isUseableAsGridFilter()->willReturn(false); $attribute->getAllowedExtensions()->willReturn(['csv', 'xml', 'json']); $attribute->getMetricFamily()->willReturn('Length'); $attribute->getDefaultMetricUnit()->willReturn('Centimenter'); $attribute->getReferenceDataName()->willReturn('color'); $attribute->isLocalizable()->willReturn(true); $attribute->isScopable()->willReturn(false); }
function it_adds_a_sorter_to_the_query($qb, AttributeInterface $attribute, Expr $expr) { $attribute->getId()->willReturn('42'); $attribute->getCode()->willReturn('entity_code'); $attribute->isLocalizable()->willReturn(false); $attribute->isScopable()->willReturn(false); $attribute->getBackendType()->willReturn('entity'); $qb->getRootAlias()->willReturn('r'); $qb->expr()->willReturn($expr); $qb->leftJoin('r.values', 'sorterVentity_code', 'WITH', 'sorterVentity_code.attribute = 42')->shouldBeCalled(); $qb->leftJoin('sorterVentity_code.entity', 'sorterOentity_code', 'WITH', 'sorterOentity_code.attribute = 42')->shouldBeCalled(); $expr->literal('en_US')->shouldBeCalled()->willReturn('en_US'); $qb->leftJoin('sorterOentity_code.optionValues', 'sorterOVentity_code', 'WITH', 'sorterOVentity_code.locale = en_US')->shouldBeCalled(); $qb->addOrderBy('sorterOentity_code.code', 'DESC')->shouldBeCalled(); $qb->addOrderBy('sorterOVentity_code.value', 'DESC')->shouldBeCalled(); $qb->addOrderBy('r.id')->shouldBeCalled(); $this->addAttributeSorter($attribute, 'DESC', 'en_US'); }
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'); }
function it_dumps_field_filters($repository, $registry, OutputInterface $output, HelperSet $helperSet, TableHelper $table, AttributeFilterInterface $mediaFilter, AttributeInterface $pictureAttribute) { $output->writeln(Argument::any())->shouldBeCalled(); $repository->findAll()->willReturn([$pictureAttribute]); $registry->getAttributeFilters()->willReturn([$mediaFilter]); $mediaFilter->getAttributeTypes()->willReturn([AttributeTypes::IMAGE, AttributeTypes::FILE]); $operators = ['STARTS WITH', 'ENDS WITH']; $mediaFilter->getOperators()->willReturn($operators); $pictureAttribute->getCode()->willReturn('picture'); $pictureAttribute->getAttributeType()->willReturn(AttributeTypes::IMAGE); $pictureAttribute->isScopable()->willReturn(false); $pictureAttribute->isLocalizable()->willReturn(false); $helperSet->get('table')->willReturn($table); $headers = ['attribute', 'localizable', 'scopable', 'attribute type', 'operators', 'filter_class']; $table->setHeaders($headers)->shouldBeCalled()->willReturn($table); $table->setRows(Argument::that(function ($param) { return 'picture' === $param[0][0] && 'no' === $param[0][1] && 'no' === $param[0][2] && AttributeTypes::IMAGE === $param[0][3] && 'STARTS WITH, ENDS WITH' === $param[0][4] && false !== strpos($param[0][5], 'AttributeFilterInterface'); }))->shouldBeCalled(); $table->render(Argument::any())->shouldBeCalled(); $this->dump($output, $helperSet); }
function it_throws_exception_when_the_field_name_is_not_consistent_with_the_channel_locale($attributeRepository, $channelRepository, $localeRepository, AttributeInterface $attribute, 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']; $attributeRepository->findOneByIdentifier('description')->willReturn($attribute); $channelRepository->findOneByIdentifier($attributeInfos['scope_code'])->shouldBeCalled()->willReturn($channel); $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"'))->duringExtractColumnInfo('description-de_DE-mobile'); }
/** * @param AttributeInterface $attribute * @param string $locale * @param string $scope * * @return string */ protected function getValueCode(AttributeInterface $attribute, $locale, $scope) { $valueCode = $attribute->getCode(); if ($attribute->isLocalizable()) { $valueCode .= '-' . $locale; } if ($attribute->isScopable()) { $valueCode .= '-' . $scope; } return $valueCode; }
/** * Add a filter condition on an attribute * * @param AttributeFilterInterface $filter the filter * @param AttributeInterface $attribute the attribute * @param string $operator the operator * @param mixed $value the value to filter * @param array $context the filter context * * @return ProductQueryBuilderInterface */ protected function addAttributeFilter(AttributeFilterInterface $filter, AttributeInterface $attribute, $operator, $value, array $context) { $locale = $attribute->isLocalizable() ? $context['locale'] : null; $scope = $attribute->isScopable() ? $context['scope'] : null; $filter->setQueryBuilder($this->getQueryBuilder()); $filter->addAttributeFilter($attribute, $operator, $value, $locale, $scope, $context); return $this; }
/** * Check the consistency of the field with channel associated * * @param AttributeInterface $attribute * @param string $fieldName * @param array $attributeInfo * * @throws \InvalidArgumentException */ protected function checkFieldNameLocaleByChannel(AttributeInterface $attribute, $fieldName, array $attributeInfo) { if ($attribute->isScopable() && $attribute->isLocalizable() && isset($attributeInfo['scope_code']) && isset($attributeInfo['locale_code'])) { $channel = $this->channelRepository->findOneByIdentifier($attributeInfo['scope_code']); $locale = $this->localeRepository->findOneByIdentifier($attributeInfo['locale_code']); if ($channel !== null && $locale !== null && !$channel->hasLocale($locale)) { throw new \InvalidArgumentException(sprintf('The locale "%s" of the field "%s" is not available in scope "%s"', $attributeInfo['locale_code'], $fieldName, $attributeInfo['scope_code'])); } } }