function let(AttributeConstraintGuesser $guesser, ProductValueInterface $value, AttributeInterface $color, AttributeOptionInterface $red) { $value->getAttribute()->willReturn($color); $value->getData()->willReturn(new ArrayCollection([$red])); $color->getBackendType()->willReturn(AttributeTypes::BACKEND_TYPE_OPTIONS); $this->beConstructedWith(AttributeTypes::BACKEND_TYPE_OPTIONS, 'pim_ajax_entity', $guesser); }
function it_normalizes_the_properties_of_the_product($filter, $serializer, ProductInterface $product, AttributeInterface $attribute, ProductValueInterface $value, FamilyInterface $family, ArrayCollection $values, \ArrayIterator $iterator, ProductValueInterface $identifier) { $values->getIterator()->willReturn($iterator); $family->getCode()->willReturn('my_family'); $product->getFamily()->willReturn($family); $product->getGroupCodes()->willReturn([]); $product->getVariantGroup()->willReturn(null); $product->getCategoryCodes()->willReturn([]); $product->isEnabled()->willReturn(true); $value->getAttribute()->willReturn($attribute); $attribute->getCode()->willReturn('name'); $product->getIdentifier()->willReturn($identifier); $identifier->getData()->willReturn('my_code'); $product->getValues()->willReturn($values); $filter->filterCollection($values, 'pim.transform.product_value.structured', Argument::type('array'))->shouldBeCalled()->willReturn($values); $iterator->rewind()->willReturn(null); $valueCount = 1; $iterator->valid()->will(function () use(&$valueCount) { return $valueCount-- > 0; }); $iterator->current()->willReturn($value); $iterator->next()->willReturn(null); $context = ['filter_types' => ['pim.transform.product_value.structured']]; $serializer->normalize($value, 'standard', $context)->willReturn(['locale' => null, 'scope' => null, 'value' => 'foo']); $created = new \DateTime('2010-06-23'); $product->getCreated()->willReturn($created); $serializer->normalize($created, 'standard')->willReturn('2010-06-23T00:00:00+01:00'); $updated = new \DateTime('2010-06-23 23:00:00'); $product->getUpdated()->willReturn($updated); $serializer->normalize($updated, 'standard')->willReturn('2010-06-23T23:00:00+01:00'); $this->normalize($product, 'standard', $context)->shouldReturn(['identifier' => 'my_code', 'family' => 'my_family', 'groups' => [], 'variant_group' => null, 'categories' => [], 'enabled' => true, 'values' => ['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']]], 'created' => '2010-06-23T00:00:00+01:00', 'updated' => '2010-06-23T23:00:00+01:00']); }
/** * {@inheritdoc} */ public function prepareValueFormOptions(ProductValueInterface $value) { $referenceDataConf = $this->referenceDataRegistry->get($value->getAttribute()->getReferenceDataName()); $options = parent::prepareValueFormOptions($value); $options['class'] = $referenceDataConf->getClass(); return $options; }
function it_copies_simple_select_value_to_a_product_value($builder, $attrValidatorHelper, AttributeInterface $fromAttribute, AttributeInterface $toAttribute, ProductInterface $product1, ProductInterface $product2, ProductInterface $product3, ProductInterface $product4, ProductValueInterface $fromProductValue, ProductValueInterface $toProductValue, AttributeOptionInterface $attributeOption) { $fromLocale = 'fr_FR'; $toLocale = 'fr_FR'; $toScope = 'mobile'; $fromScope = 'mobile'; $fromAttribute->getCode()->willReturn('fromAttributeCode'); $toAttribute->getCode()->willReturn('toAttributeCode'); $attrValidatorHelper->validateLocale(Argument::cetera())->shouldBeCalled(); $attrValidatorHelper->validateScope(Argument::cetera())->shouldBeCalled(); $fromProductValue->getData()->willReturn($attributeOption); $toProductValue->setOption($attributeOption)->shouldBeCalledTimes(3); $product1->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn($fromProductValue); $product1->getValue('toAttributeCode', $toLocale, $toScope)->willReturn($toProductValue); $product2->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn(null); $product2->getValue('toAttributeCode', $toLocale, $toScope)->willReturn($toProductValue); $product3->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn($fromProductValue); $product3->getValue('toAttributeCode', $toLocale, $toScope)->willReturn(null); $product4->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn($fromProductValue); $product4->getValue('toAttributeCode', $toLocale, $toScope)->willReturn($toProductValue); $builder->addProductValue($product3, $toAttribute, $toLocale, $toScope)->shouldBeCalledTimes(1)->willReturn($toProductValue); $products = [$product1, $product2, $product3, $product4]; foreach ($products as $product) { $this->copyAttributeData($product, $product, $fromAttribute, $toAttribute, ['from_locale' => $fromLocale, 'to_locale' => $toLocale, 'from_scope' => $fromScope, 'to_scope' => $toScope]); } }
/** * {@inheritdoc} */ public function prepareValueFormAlias(ProductValueInterface $value) { if ($value->getAttribute()->isWysiwygEnabled()) { return 'pim_wysiwyg'; } return parent::prepareValueFormAlias($value); }
function it_allows_to_get_errors_if_the_copy_went_wrong($mediaFetcher, $filesystemProvider, $fileExporterPath, FileInfoInterface $fileInfo, FileInfoInterface $fileInfo2, ArrayCollection $productValuesCollection, \ArrayIterator $valuesIterator, ProductValueInterface $productValue, ProductValueInterface $productValue2, AttributeInterface $attribute, FilesystemInterface $filesystem) { $fileInfo->getStorage()->willReturn('storageAlias'); $fileInfo->getKey()->willReturn('a/b/c/d/product.jpg'); $fileInfo->getOriginalFilename()->willReturn('my product.jpg'); $fileInfo2->getStorage()->willReturn('storageAlias'); $fileInfo2->getKey()->willReturn('wrong-path.jpg'); $fileInfo2->getOriginalFilename()->willReturn('my-second-media.jpg'); $productValue->getAttribute()->willReturn($attribute); $productValue->getMedia()->willReturn($fileInfo); $productValue->getLocale()->willReturn('en_US'); $productValue->getScope()->willReturn(null); $productValue2->getAttribute()->willReturn($attribute); $productValue2->getMedia()->willReturn($fileInfo2); $productValue2->getLocale()->willReturn('fr_FR'); $productValue2->getScope()->willReturn('ecommerce'); $attribute->getAttributeType()->willReturn('pim_catalog_image'); $attribute->getCode()->willReturn('my_picture'); $productValuesCollection->getIterator()->willReturn($valuesIterator); $valuesIterator->rewind()->shouldBeCalled(); $valuesCount = 2; $valuesIterator->valid()->will(function () use(&$valuesCount) { return $valuesCount-- > 0; }); $valuesIterator->next()->shouldBeCalled(); $valuesIterator->current()->will(new ReturnPromise([$productValue, $productValue2])); $filesystemProvider->getFilesystem('storageAlias')->willReturn($filesystem); $mediaFetcher->fetch($filesystem, 'a/b/c/d/product.jpg', ['filePath' => $this->directory . 'files/the_sku/my_picture/en_US/', 'filename' => 'my product.jpg'])->willThrow(new FileTransferException()); $fileExporterPath->generate(['locale' => 'en_US', 'scope' => null], ['identifier' => 'the_sku', 'code' => 'my_picture'])->willReturn('files/the_sku/my_picture/en_US/'); $mediaFetcher->fetch($filesystem, 'wrong-path.jpg', ['filePath' => $this->directory . 'files/the_sku/my_picture/fr_FR/ecommerce/', 'filename' => 'my-second-media.jpg'])->willThrow(new \LogicException('Something went wrong.')); $fileExporterPath->generate(['locale' => 'fr_FR', 'scope' => 'ecommerce'], ['identifier' => 'the_sku', 'code' => 'my_picture'])->willReturn('files/the_sku/my_picture/fr_FR/ecommerce/'); $this->fetchAll($productValuesCollection, $this->directory, 'the_sku'); $this->getErrors()->shouldBeEqualTo([['message' => 'The media has not been found or is not currently available', 'media' => ['from' => 'a/b/c/d/product.jpg', 'to' => ['filePath' => $this->directory . 'files/the_sku/my_picture/en_US/', 'filename' => 'my product.jpg'], 'storage' => 'storageAlias']], ['message' => 'The media has not been copied. Something went wrong.', 'media' => ['from' => 'wrong-path.jpg', 'to' => ['filePath' => $this->directory . 'files/the_sku/my_picture/fr_FR/ecommerce/', 'filename' => 'my-second-media.jpg'], 'storage' => 'storageAlias']]]); }
function it_returns_flat_data_with_media($channelManager, Filesystem $filesystem, ChannelInterface $channel, LocaleInterface $locale, ProductInterface $product, FileInfoInterface $media1, FileInfoInterface $media2, ProductValueInterface $value1, ProductValueInterface $value2, AttributeInterface $attribute, ProductValueInterface $identifierValue, AttributeInterface $identifierAttribute, $serializer, $productBuilder) { $localeCodes = ['en_US']; $channel->getLocales()->willReturn(new ArrayCollection([$locale])); $channel->getLocaleCodes()->willReturn($localeCodes); $productBuilder->addMissingProductValues($product, [$channel], [$locale])->shouldBeCalled(); $media1->getKey()->willReturn('key/to/media1.jpg'); $media2->getKey()->willReturn('key/to/media2.jpg'); $value1->getAttribute()->willReturn($attribute); $value1->getMedia()->willReturn($media1); $value2->getAttribute()->willReturn($attribute); $value2->getMedia()->willReturn($media2); $attribute->getAttributeType()->willReturn('pim_catalog_image'); $product->getValues()->willReturn([$value1, $value2, $identifierValue]); $identifierValue->getAttribute()->willReturn($identifierAttribute); $identifierAttribute->getAttributeType()->willReturn('pim_catalog_identifier'); $product->getIdentifier()->willReturn($identifierValue); $identifierValue->getData()->willReturn('data'); $filesystem->has('key/to/media1.jpg')->willReturn(true); $filesystem->has('key/to/media2.jpg')->willReturn(true); $serializer->normalize($media1, 'flat', ['field_name' => 'media', 'prepare_copy' => true, 'value' => $value1])->willReturn(['normalized_media1']); $serializer->normalize($media2, 'flat', ['field_name' => 'media', 'prepare_copy' => true, 'value' => $value2])->willReturn(['normalized_media2']); $serializer->normalize($product, 'flat', ['scopeCode' => 'foobar', 'localeCodes' => $localeCodes, 'decimal_separator' => '.', 'date_format' => 'yyyy-MM-dd'])->willReturn(['normalized_product']); $channelManager->getChannelByCode('foobar')->willReturn($channel); $this->setChannel('foobar'); $this->process($product)->shouldReturn(['media' => [['normalized_media1'], ['normalized_media2']], 'product' => ['normalized_product']]); }
/** * {@inheritdoc} */ public function prepareValueFormData(ProductValueInterface $value) { if (!is_null($value->getData())) { return $value->getData(); } return $this->metricFactory->createMetric($value->getAttribute()->getMetricFamily()); }
function it_adds_missing_product_values_from_family_on_new_product($valuesResolver, FamilyInterface $family, ProductInterface $product, AttributeInterface $sku, AttributeInterface $name, AttributeInterface $desc, ProductValueInterface $skuValue) { $sku->getCode()->willReturn('sku'); $sku->getAttributeType()->willReturn('pim_catalog_identifier'); $sku->isLocalizable()->willReturn(false); $sku->isScopable()->willReturn(false); $name->getCode()->willReturn('name'); $name->getAttributeType()->willReturn('pim_catalog_text'); $name->isLocalizable()->willReturn(true); $name->isScopable()->willReturn(false); $desc->getCode()->willReturn('description'); $desc->getAttributeType()->willReturn('pim_catalog_text'); $desc->isLocalizable()->willReturn(true); $desc->isScopable()->willReturn(true); // get expected attributes $product->getAttributes()->willReturn([$sku]); $family->getAttributes()->willReturn([$sku, $name, $desc]); $product->getFamily()->willReturn($family); // get eligible values $valuesResolver->resolveEligibleValues(['sku' => $sku, 'name' => $name, 'description' => $desc], null, null)->willReturn([['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']]); // get existing values $skuValue->getAttribute()->willReturn($sku); $skuValue->getLocale()->willReturn(null); $skuValue->getScope()->willReturn(null); $product->getValues()->willReturn([$skuValue]); // add 6 new values : 4 desc (locales x scopes) + 2 name (locales $product->addValue(Argument::any())->shouldBeCalledTimes(6); $this->addMissingProductValues($product); }
/** * Validate currency of a price * * @param AttributeInterface|MetricInterface|ProductValueInterface $object * @param Constraint $constraint */ public function validate($object, Constraint $constraint) { if ($object instanceof ProductPriceInterface) { if (!in_array($object->getCurrency(), $this->getCurrencyCodes())) { $this->context->buildViolation($constraint->unitMessage)->atPath('currency')->addViolation(); } } }
function it_denormalizes_a_collection_of_reference_data_values($refDataDenormalizer, AttributeInterface $attribute, ReferenceDataInterface $refData1, ReferenceDataInterface $refData2, ProductValueInterface $productValue) { $productValue->getAttribute()->willReturn($attribute); $context = ['value' => $productValue]; $refDataDenormalizer->denormalize('battlecruiser', 'pim_reference_data_multiselect', null, $context)->shouldBeCalled()->willReturn($refData1); $refDataDenormalizer->denormalize('destroyer', 'pim_reference_data_multiselect', null, $context)->shouldBeCalled()->willReturn($refData2); $this->denormalize('battlecruiser,destroyer', 'pim_reference_data_multiselect', null, $context)->shouldHaveCount(2); }
/** * {@inheritdoc} */ public function supportsValue(ProductValueInterface $productValue) { $data = $productValue->getData(); if (null === $data || '' === $data || [] === $data || $data instanceof \Countable && 0 === count($data)) { return true; } return false; }
function it_denormalizes_data_into_reference_data($resolver, AttributeInterface $attribute, ReferenceDataInterface $battlecruiser, ReferenceDataRepository $referenceDataRepo, ProductValueInterface $productValue) { $attribute->getReferenceDataName()->willReturn('starship'); $productValue->getAttribute()->willReturn($attribute); $resolver->resolve('starship')->willReturn($referenceDataRepo); $referenceDataRepo->findOneBy(['code' => 'battlecruiser'])->willReturn($battlecruiser); $this->denormalize('battlecruiser', 'pim_reference_data_simpleselect', 'csv', ['value' => $productValue])->shouldReturn($battlecruiser); }
/** * Mark attribute as variant * * @param FormView $view * @param ProductValueInterface $value */ protected function markAttributeAsUpdatedByVariant(FormView $view, ProductValueInterface $value) { $view->vars['from_variant'] = $value->getEntity()->getVariantGroup(); $view->vars['disabled'] = true; $view->vars['read_only'] = true; foreach ($view as $child) { $this->markAttributeAsUpdatedByVariant($child, $value); } }
function it_returns_a_price_collection_even_if_the_data_is_empty($productBuilder, ProductValueInterface $priceValue, ProductPriceInterface $price, ArrayCollection $priceCollection) { $productBuilder->addPriceForCurrency(Argument::cetera())->willReturn($price); $priceValue->addPrice($price)->shouldBeCalled(); $priceValue->getPrices()->willReturn($priceCollection); $context = ['value' => $priceValue, 'price_currency' => 'WillNotBeUsed']; $this->denormalize('', 'className', null, $context)->shouldReturn($priceCollection); $this->denormalize(null, 'className', null, $context)->shouldReturn($priceCollection); }
public function it_succesfully_checks_complete_attribute(ProductValueInterface $value, ChannelInterface $channel, LocaleInterface $locale, ProductValueCompleteCheckerInterface $completenessChecker, AttributeInterface $attribute) { $value->getAttribute()->willReturn($attribute); $value->getData()->willReturn('foo'); $this->addProductValueChecker($completenessChecker); $completenessChecker->supportsValue($value)->willReturn(true); $completenessChecker->isComplete($value, $channel, $locale)->willReturn(true); $this->isComplete($value, $channel, $locale)->shouldReturn(true); }
function it_doesnt_remove_value_when_the_attribute_is_not_locale_specific(FormEvent $event, FormInterface $form, FormInterface $field, FormInterface $rootForm, ProductValueInterface $nameValue, AttributeInterface $nameAttribute) { $event->getForm()->willReturn($form); $event->getData()->willReturn(['name' => $nameValue]); $nameValue->getAttribute()->willReturn($nameAttribute); $nameAttribute->isLocaleSpecific()->willReturn(false); $form->remove('name')->shouldNotBeCalled(); $this->preSetData($event); }
function it_denormalizes_attribute_option($repository, ProductValueInterface $productValueInterface, AttributeInterface $color, AttributeOptionInterface $red) { $data = '1'; $context['value'] = $productValueInterface; $productValueInterface->getAttribute()->shouldBeCalled()->willReturn($color); $color->getCode()->willReturn('color'); $repository->findOneByIdentifier('color.1')->shouldBeCalled()->willReturn($red); $this->denormalize($data, 'className', null, $context)->shouldReturn($red); }
function it_adds_violation_when_validates_non_string_product_value($context, IsString $stringConstraint, ProductValueInterface $productValue, AttributeInterface $attribute, ConstraintViolationBuilderInterface $violation) { $productValue->getAttribute()->willReturn($attribute); $attribute->getCode()->willReturn('foo'); $attribute->getBackendType()->willReturn('integer'); $productValue->getInteger()->willReturn(666); $context->buildViolation($stringConstraint->message, ['%attribute%' => 'foo', '%givenType%' => 'integer'])->shouldBeCalled()->willReturn($violation); $this->validate($productValue, $stringConstraint); }
function it_validates_product_value_with_metric_data($accessor, $context, ValidMetric $constraint, ProductValueInterface $value, MetricInterface $metric) { $value->getMetric()->willReturn($metric); $metric->getUnit()->willReturn('cm'); $metric->getData()->willReturn(12); $accessor->getValue($metric, 'family')->shouldBeCalled()->willReturn('Weight'); $accessor->getValue($metric, 'unit')->shouldBeCalled()->willReturn('kg'); $context->buildViolation(Argument::cetera())->shouldNotBeCalled(); $this->validate($value, $constraint)->shouldReturn(null); }
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_normalizes_collection_of_product_values_in_standard_format($serializer, ProductValueInterface $textValue, AttributeInterface $text, ProductValueInterface $priceValue, AttributeInterface $price) { $textValue->getAttribute()->willReturn($text); $priceValue->getAttribute()->willReturn($price); $text->getCode()->willReturn('text'); $price->getCode()->willReturn('price'); $serializer->normalize($textValue, 'standard', [])->shouldBeCalled()->willReturn(['locale' => null, 'scope' => null, 'value' => 'foo']); $serializer->normalize($priceValue, 'standard', [])->shouldBeCalled()->willReturn(['locale' => 'en_US', 'scope' => 'ecommerce', 'value' => [['amount' => '12.50', 'currency' => 'USD'], ['amount' => '15.00', 'currency' => 'EUR']]]); $this->normalize([$textValue, $priceValue], 'standard')->shouldReturn(['text' => [['locale' => null, 'scope' => null, 'value' => 'foo']], 'price' => [['locale' => 'en_US', 'scope' => 'ecommerce', 'value' => [['amount' => '12.50', 'currency' => 'USD'], ['amount' => '15.00', 'currency' => 'EUR']]]]]); }
public function it_succesfully_checks_incomplete_price_collection(ProductValueInterface $value, ChannelInterface $channel, LocaleInterface $locale, ArrayCollection $arrayCollection, CurrencyInterface $currency1, CurrencyInterface $currency2, ProductPriceInterface $price1) { $channel->getCurrencies()->willReturn($arrayCollection); $arrayCollection->toArray()->willReturn([$currency1, $currency2]); $currency1->getCode()->willReturn('USD'); $price1->getCurrency()->willReturn('USD'); $price1->getData()->willReturn(null); $value->getData()->willReturn([$price1]); $this->isComplete($value, $channel, $locale)->shouldReturn(false); }
function it_normalizes_product_values_into_json($serializer, ProductValueInterface $nameValue, ProductValueInterface $colorValue, AttributeInterface $name, AttributeInterface $color) { $nameValue->getAttribute()->willReturn($name); $colorValue->getAttribute()->willReturn($color); $name->getCode()->willReturn('name'); $color->getCode()->willReturn('color'); $serializer->normalize($nameValue, 'json', [])->shouldBeCalled()->willReturn(['locale' => null, 'scope' => null, 'value' => 'foo']); $serializer->normalize($colorValue, 'json', [])->shouldBeCalled()->willReturn(['locale' => 'en_US', 'scope' => 'ecommerce', 'value' => 'red']); $this->normalize([$nameValue, $colorValue], 'json')->shouldReturn(['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']], 'color' => [['locale' => 'en_US', 'scope' => 'ecommerce', 'value' => 'red']]]); }
function it_denormalizes_a_collection_of_reference_data_values($refDataDenormalizer, AttributeInterface $attribute, ReferenceDataInterface $refData1, ReferenceDataInterface $refData2, ProductValueInterface $productValue, ObjectRepository $repository) { $productValue->getAttribute()->willReturn($attribute); $attribute->getReferenceDataName()->willReturn('reference'); $context = ['value' => $productValue]; $refDataDenormalizer->resolve('reference')->willReturn($repository); $repository->findOneBy(['code' => 'battlecruiser'])->willReturn($refData1); $repository->findOneBy(['code' => 'destroyer'])->willReturn($refData2); $this->denormalize('battlecruiser, destroyer', 'pim_reference_data_multiselect', null, $context)->shouldHaveCount(2); }
function it_doesnt_support_multi_targets_constraint($guesser, $factory, ClassMetadata $metadata, ProductValueInterface $value, AttributeInterface $attribute, Constraint $multiTargets, Constraint $validNumber) { $factory->createMetadata(Argument::any())->willReturn($metadata); $value->getAttribute()->willReturn($attribute); $attribute->getBackendType()->willReturn('varchar'); $attribute->getCode()->willReturn('myCode'); $guesser->guessConstraints($attribute)->willReturn([$multiTargets]); $multiTargets->getTargets()->willReturn([Constraint::PROPERTY_CONSTRAINT, Constraint::CLASS_CONSTRAINT]); $this->shouldThrow(new \LogicException('No support provided for constraint on many targets'))->duringGetMetadataFor($value); }
function it_normalizes_constraint_violation(ConstraintViolationInterface $violation, ProductInterface $product, ProductValueInterface $productValue, AttributeInterface $attribute) { $product->getValues()->willReturn(['price' => $productValue]); $productValue->getLocale()->willReturn(null); $productValue->getScope()->willReturn(null); $productValue->getAttribute()->willReturn($attribute); $attribute->getCode()->willReturn('price'); $violation->getPropertyPath()->willReturn('values[price].float'); $violation->getMessage()->willReturn('The price should be above 10.'); $this->normalize($violation, 'internal_api', ['product' => $product])->shouldReturn(['attribute' => 'price', 'locale' => null, 'scope' => null, 'message' => 'The price should be above 10.']); }
/** * The metric is built by many ordered calls, one for the data column, one for the unit column * * @param ProductValueInterface $value * @param string $dataOrUnit * * @return MetricInterface */ protected function addFromManyFields(ProductValueInterface $value, $dataOrUnit) { // TODO come from original implementation, really FRAGIL because depends on many ordered calls if (null === ($metric = $value->getMetric())) { $metric = $this->factory->createMetric($value->getAttribute()->getMetricFamily()); $metric->setData($dataOrUnit); } else { $metric->setUnit($dataOrUnit); } return $metric; }
function it_adds_violations_if_value_is_scopable_and_its_scope_does_not_exist($context, $channelRepository, ProductValueInterface $value, AttributeInterface $scopableAttribute, ScopableValue $constraint, ConstraintViolationBuilderInterface $violation) { $value->getAttribute()->willReturn($scopableAttribute); $scopableAttribute->isScopable()->willReturn(true); $value->getScope()->willReturn('inexistingChannel'); $scopableAttribute->getCode()->willReturn('attributeCode'); $channelRepository->findOneByIdentifier('inexistingChannel')->willReturn(null); $violationData = ['%attribute%' => 'attributeCode', '%channel%' => 'inexistingChannel']; $context->buildViolation($constraint->inexistingScopeMessage, $violationData)->shouldBeCalled()->willReturn($violation); $this->validate($value, $constraint); }
/** * {@inheritdoc} */ public function prepareValueFormData(ProductValueInterface $value) { $iterator = $value->getData()->getIterator(); if (true === $value->getAttribute()->getProperty('autoOptionSorting')) { $iterator->uasort('strcasecmp'); } else { $iterator->uasort(function ($first, $second) { return $first->getSortOrder() < $second->getSortOrder() ? -1 : 1; }); } return new ArrayCollection(iterator_to_array($iterator)); }