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); }
function it_provide_product_completeness_if_a_family_is_defined($familyRepository, $productValueCompleteChecker, QueryBuilder $qb, AbstractQuery $query, AttributeRequirementInterface $requirement, ProductInterface $product, ChannelInterface $mobile, LocaleInterface $en, FamilyInterface $shirt, CompletenessInterface $completeness, ProductValueInterface $nameValue, AttributeInterface $name) { $product->getFamily()->willReturn($shirt); $product->getCompletenesses()->willReturn([$completeness]); $en->getCode()->willReturn('en_US'); $mobile->getCode()->willReturn('mobile'); $completeness->getLocale()->willReturn($en); $completeness->getChannel()->willReturn($mobile); $completeness->getMissingCount()->willReturn(1); $familyRepository->getFullRequirementsQB($shirt, 'en_US')->willReturn($qb); $qb->getQuery()->willReturn($query); $query->getResult()->willReturn([$requirement]); $requirement->getChannel()->willReturn($mobile); $requirement->getAttribute()->willReturn($name); $requirement->isRequired()->willReturn(true); $name->getCode()->willReturn('name'); $name->isLocalizable()->willreturn(true); $name->isScopable()->willReturn(false); $name->isLocaleSpecific()->willReturn(true); $name->hasLocaleSpecific($en)->willReturn(false); $product->getValues()->willReturn(new ArrayCollection()); $productValueCompleteChecker->supportsValue($nameValue); $productValueCompleteChecker->isComplete($nameValue, $mobile, $en); $this->getProductCompleteness($product, [$mobile], [$en], 'en_US')->shouldReturn([['channels' => [['completeness' => $completeness, 'missing' => []]], 'stats' => ['total' => 1, 'complete' => 0], 'locale' => 'en_US']]); }
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']); }
function it_returns_flat_data_without_media(ChannelInterface $channel, ChannelManager $channelManager, ProductInterface $product, Serializer $serializer) { $product->getValues()->willReturn([]); $this->setDecimalSeparator(','); $serializer->normalize($product, 'flat', ['scopeCode' => 'foobar', 'localeCodes' => '', 'decimal_separator' => ',', 'date_format' => 'yyyy-MM-dd'])->willReturn(['normalized_product']); $channelManager->getChannelByCode('foobar')->willReturn($channel); $this->setChannel('foobar'); $this->process($product)->shouldReturn(['media' => [], 'product' => ['normalized_product']]); }
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.']); }
/** * Converts metric values * * @param DocumentManager $dm * @param ProductInterface $product */ protected function convertMetricValues(DocumentManager $dm, ProductInterface $product) { foreach ($product->getValues() as $value) { $metric = $value->getData(); if ($metric instanceof MetricInterface && $metric->getUnit()) { $this->createMetricBaseValues($metric); if (null !== $metric->getId()) { $metadata = $dm->getClassMetadata(ClassUtils::getClass($metric)); $dm->getUnitOfWork()->recomputeSingleDocumentChangeSet($metadata, $metric); } } } }
function it_normalizes_product(SerializerInterface $serializer, ProductInterface $product, FamilyInterface $family, Completeness $completeness) { $serializer->implement('Symfony\\Component\\Serializer\\Normalizer\\NormalizerInterface'); $this->setSerializer($serializer); $product->getFamily()->willReturn($family); $product->getGroups()->willReturn([]); $product->getValues()->willReturn([]); $product->getCompletenesses()->willReturn([$completeness]); $product->getCreated()->willReturn(null); $product->getUpdated()->willReturn(null); $product->isEnabled()->willReturn(true); $serializer->normalize($family, 'mongodb_json', [])->willReturn('family normalization'); $serializer->normalize($completeness, 'mongodb_json', [])->willReturn(['completenessCode' => 'completeness normalization']); $this->normalize($product, 'mongodb_json', [])->shouldReturn([ProductNormalizer::FAMILY_FIELD => 'family normalization', ProductNormalizer::COMPLETENESSES_FIELD => array('completenessCode' => 'completeness normalization'), ProductNormalizer::ENABLED_FIELD => true]); }
function it_does_not_convert_null_metric_values_in_the_channel($converter, ProductValueInterface $weightValue, AttributeInterface $weight, MetricInterface $weightMetric, ProductInterface $product, ChannelInterface $channel) { $weightValue->getAttribute()->willReturn($weight); $weightValue->getData()->willReturn($weightMetric); $weight->getCode()->willReturn('weight'); $weightMetric->getFamily()->willReturn('Weight'); $weightMetric->getUnit()->willReturn(null); $weightMetric->getData()->willReturn(null); $product->getValues()->willReturn(array($weightValue)); $channel->getConversionUnits()->willReturn(array('weight' => 'GRAM')); $converter->setFamily('Weight')->shouldNotBeCalled(); $converter->convert('KILOGRAM', 'GRAM', 1)->shouldNotBeCalled(); $weightMetric->setData(null)->shouldNotBeCalled(); $weightMetric->setUnit('GRAM')->shouldNotBeCalled(); $this->convert($product, $channel); }
/** * Returns the required attribute codes for a product * * @param ProductInterface $product * * @return array */ public function getRequiredAttributeCodes(ProductInterface $product) { $codes = []; if ($product->getFamily()) { $codes = $this->getFamilyAttributeCodes($product->getFamily()); } foreach ($product->getGroups() as $group) { $codes = array_merge($codes, $this->getGroupAttributeCodes($group)); } if ($product->getId()) { foreach ($product->getValues() as $value) { $codes[] = $value->getAttribute()->getCode(); } } return array_unique($codes); }
/** * Convert all the products metric values into the channel configured conversion units * * @param ProductInterface $product * @param ChannelInterface $channel */ public function convert(ProductInterface $product, ChannelInterface $channel) { $channelUnits = $channel->getConversionUnits(); foreach ($product->getValues() as $value) { $data = $value->getData(); $attribute = $value->getAttribute(); if ($data instanceof MetricInterface && isset($channelUnits[$attribute->getCode()])) { if (null === $data->getData()) { return; } $channelUnit = $channelUnits[$attribute->getCode()]; $this->converter->setFamily($data->getFamily()); $data->setData($this->converter->convert($data->getUnit(), $channelUnit, $data->getData())); $data->setUnit($channelUnit); } } }
function it_normalizes_the_properties_of_the_product(ProductInterface $product, AttributeInterface $attribute, ProductValueInterface $value, ArrayCollection $values, \ArrayIterator $iterator, $filter, $normalizer) { $values->getIterator()->willReturn($iterator); $product->getFamily()->willReturn(null); $product->getGroupCodes()->willReturn([]); $product->getVariantGroup()->willReturn(null); $product->getCategoryCodes()->willReturn([]); $product->isEnabled()->willReturn(true); $value->getAttribute()->willReturn($attribute); $attribute->getCode()->willReturn('name'); $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); $normalizer->normalize($values, 'json', Argument::any())->willReturn(['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']]]); $this->normalize($product, 'json')->shouldReturn(['family' => null, 'groups' => [], 'variant_group' => null, 'categories' => [], 'enabled' => true, 'values' => ['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']]]]); }
/** * Fetch product media * * @param ProductInterface $product * * @return ProductMediaInterface[] */ protected function getProductMedias(ProductInterface $product) { $media = []; foreach ($product->getValues() as $value) { if (in_array($value->getAttribute()->getAttributeType(), [AttributeTypes::IMAGE, AttributeTypes::FILE])) { $media[] = $value->getData(); } } return $media; }
function it_returns_flat_data_with_french_attribute($channelManager, $serializer, ChannelInterface $channel, ProductInterface $product, ProductValueInterface $number, AttributeInterface $attribute, MetricInterface $metric, ProductValueInterface $metricValue, ProductPriceInterface $price, ProductValueInterface $priceValue) { $this->setLocale('fr_FR'); $attribute->getAttributeType()->willReturn('pim_catalog_number'); $number->getDecimal('10.50'); $number->getAttribute()->willReturn($attribute); $attribute->getAttributeType()->willReturn('pim_catalog_metric'); $metric->getData()->willReturn('10.00'); $metric->getUnit()->willReturn('GRAM'); $metricValue->getAttribute()->willReturn($attribute); $metricValue->getData()->willReturn($metric); $attribute->getAttributeType()->willReturn('pim_catalog_price_collection'); $price->getData()->willReturn('10'); $price->getCurrency()->willReturn('EUR'); $priceValue->getAttribute()->willReturn($attribute); $priceValue->getData()->willReturn($price); $product->getValues()->willReturn([$number, $metricValue, $priceValue]); $serializer->normalize($product, 'flat', ['scopeCode' => 'mobile', 'localeCodes' => '', 'locale' => 'fr_FR'])->willReturn(['10,50', '10,00 GRAM', '10,00 EUR', '25/10/2015']); $channelManager->getChannelByCode('mobile')->willReturn($channel); $this->setChannelCode('mobile'); $this->process($product)->shouldReturn(['media' => [], 'product' => ['10,50', '10,00 GRAM', '10,00 EUR', '25/10/2015']]); }
function it_normalizes_product_with_price($filter, ProductInterface $product, AttributeInterface $priceAttribute, ProductValueInterface $price, Collection $prices, Collection $values, ProductPriceInterface $productPrice, FamilyInterface $family, SerializerInterface $serializer) { $family->getCode()->willReturn('shoes'); $priceAttribute->getCode()->willReturn('price'); $priceAttribute->getAttributeType()->willReturn('pim_catalog_price_collection'); $priceAttribute->isLocalizable()->willReturn(false); $priceAttribute->isScopable()->willReturn(false); $price->getAttribute()->willReturn($priceAttribute); $price->getData()->willReturn(null); $productPrice->getData()->willReturn("356.00"); $productPrice->getCurrency()->willReturn("EUR"); $prices->add($productPrice); $price->getPrices()->willReturn($prices); $product->getIdentifier()->willReturn($price); $product->getFamily()->willReturn($family); $product->isEnabled()->willReturn(true); $product->getGroupCodes()->willReturn(['group1', 'group2', 'variant_group_1']); $product->getCategoryCodes()->willReturn(['nice shoes', 'converse']); $product->getAssociations()->willReturn([]); $values->add($price); $product->getValues()->willReturn($values); $filter->filterCollection($values, 'pim.transform.product_value.flat', Argument::cetera())->willReturn([$price]); $serializer->normalize($price, 'flat', Argument::any())->willReturn(['price-EUR' => '356.00']); $this->normalize($product, 'flat', ['price-EUR' => ''])->shouldReturn(['price-EUR' => '356.00', 'family' => 'shoes', 'groups' => 'group1,group2,variant_group_1', 'categories' => 'nice shoes,converse', 'enabled' => 1]); }
/** * Returns an array containing all completeness info and missing attributes for a product * * @param ProductInterface $product * @param \Pim\Bundle\CatalogBundle\Entity\ChannelInterface[] $channels * @param \Pim\Bundle\CatalogBundle\Entity\LocaleInterface[] $locales * @param string $localeCode * * @return array */ public function getProductCompleteness(ProductInterface $product, array $channels, array $locales, $localeCode) { $family = $product->getFamily(); $getCodes = function ($entities) { return array_map(function ($entity) { return $entity->getCode(); }, $entities); }; $channelCodes = $getCodes($channels); $localeCodes = $getCodes($locales); $channelTemplate = ['channels' => array_fill_keys($channelCodes, ['completeness' => null, 'missing' => []]), 'stats' => ['total' => 0, 'complete' => 0]]; $completenesses = array_fill_keys($localeCodes, $channelTemplate); if (!$family) { return $completenesses; } $allCompletenesses = $product->getCompletenesses(); foreach ($allCompletenesses as $completeness) { $locale = $completeness->getLocale(); $channel = $completeness->getChannel(); $compLocaleCode = $locale->getCode(); if (isset($completenesses[$compLocaleCode])) { $completenesses[$compLocaleCode]['channels'][$channel->getCode()]['completeness'] = $completeness; $completenesses[$compLocaleCode]['stats']['total']++; if (0 === $completeness->getMissingCount()) { $completenesses[$compLocaleCode]['stats']['complete']++; } } } $requirements = $this->familyRepository->getFullRequirementsQB($family, $localeCode)->getQuery()->getResult(); $productValues = $product->getValues(); foreach ($requirements as $requirement) { if ($requirement->isRequired()) { $this->addRequirementToCompleteness($completenesses, $requirement, $productValues, $locales); } } return $completenesses; }
/** * Get filtered values * * @param ProductInterface $product * @param array $context * * @return ProductValueInterface[] */ protected function getFilteredValues(ProductInterface $product, array $context = []) { if (null === $this->filter) { return $product->getValues(); } $values = $product->getValues(); foreach ($context['filter_types'] as $filterType) { $values = $this->filter->filterCollection($values, $filterType, ['channels' => [$context['scopeCode']], 'locales' => $context['localeCodes']]); } return $values; }
/** * Returns completenesses filled * * @param array $completenesses * @param ProductInterface $product * @param array $locales * @param string $localeCode * * @return array */ protected function fillCompletenessesTemplate(array $completenesses, ProductInterface $product, array $locales, $localeCode) { $allCompletenesses = $product->getCompletenesses(); foreach ($allCompletenesses as $completeness) { $locale = $completeness->getLocale(); $channel = $completeness->getChannel(); $compLocaleCode = $locale->getCode(); if (isset($completenesses[$compLocaleCode])) { $completenesses[$compLocaleCode]['channels'][$channel->getCode()]['completeness'] = $completeness; $completenesses[$compLocaleCode]['locale'] = $compLocaleCode; $completenesses[$compLocaleCode]['stats']['total']++; if (0 === $completeness->getMissingCount()) { $completenesses[$compLocaleCode]['stats']['complete']++; } } } $requirements = $this->familyRepository->getFullRequirementsQB($product->getFamily(), $localeCode)->getQuery()->getResult(); $productValues = $product->getValues(); foreach ($requirements as $requirement) { if ($requirement->isRequired()) { $this->addRequirementToCompleteness($completenesses, $requirement, $productValues, $locales); } } return $completenesses; }
/** * Denormalize product values * * @param string $data * @param string $format * @param array $context * @param ProductInterface $product */ protected function denormalizeValues($data, $format, array $context, ProductInterface $product) { foreach ($product->getValues() as $value) { $product->removeValue($value); } foreach ($data as $attFieldName => $dataValue) { $attributeInfos = $this->attFieldExtractor->extractColumnInfo($attFieldName); $attribute = $attributeInfos['attribute']; unset($attributeInfos['attribute']); if (!$product->hasAttribute($attribute)) { $this->productBuilder->addAttributeToProduct($product, $attribute); } // Denormalize data value. // The value is already added to the product so automatically updated $productValue = $product->getValue($attribute->getCode(), $attributeInfos['locale_code'], $attributeInfos['scope_code']); $this->serializer->denormalize($dataValue, $this->productValueClass, $format, ['product' => $product, 'entity' => $productValue] + $attributeInfos + $context); } }
/** * Transforms product violations into an array * * @param ConstraintViolationListInterface $violations * @param ProductInterface $product * * @return array */ protected function transformViolations(ConstraintViolationListInterface $violations, ProductInterface $product) { $errors = []; foreach ($violations as $violation) { $path = $violation->getPropertyPath(); if (0 === strpos($path, 'values')) { $codeStart = strpos($path, '[') + 1; $codeLength = strpos($path, ']') - $codeStart; $valueIndex = substr($path, $codeStart, $codeLength); $value = $product->getValues()[$valueIndex]; $attributeCode = $value->getAttribute()->getCode(); $currentError = ['attribute' => $attributeCode, 'locale' => $value->getLocale(), 'scope' => $value->getScope(), 'message' => $violation->getMessage(), 'invalid_value' => $violation->getInvalidValue()]; $errors['values'][$attributeCode] = isset($errors['values'][$attributeCode]) ? $errors['values'][$attributeCode] : []; $identicalErrors = array_filter($errors['values'][$attributeCode], function ($error) use($currentError) { return isset($error['message']) && $error['message'] === $currentError['message']; }); if (empty($identicalErrors)) { $errors['values'][$attributeCode][] = $currentError; } } else { $errors[$path] = ['message' => $violation->getMessage(), 'invalid_value' => $violation->getInvalidValue()]; } } return $errors; }
/** * Fetch medias product values * * @param ProductInterface $product * * @return ProductValueInterface[] */ protected function getMediaProductValues(ProductInterface $product) { $values = []; foreach ($product->getValues() as $value) { if (in_array($value->getAttribute()->getAttributeType(), $this->mediaAttributeTypes)) { $values[] = $value; } } return $values; }
/** * Add missing prices (a price per currency) * * @param ProductInterface $product the product */ protected function addMissingPricesToProduct(ProductInterface $product) { foreach ($product->getValues() as $value) { $this->addMissingPrices($value); } }
/** * Get filtered values * * @param ProductInterface $product * @param array $context * * @return ProductValueInterface[] */ protected function getFilteredValues(ProductInterface $product, array $context = []) { if (null === $this->filter) { return $product->getValues(); } $values = $this->filter->filterCollection($product->getValues(), isset($context['filter_type']) ? $context['filter_type'] : 'pim.transform.product_value.flat', ['channels' => [$context['scopeCode']], 'locales' => $context['localeCodes']]); return $values; }
function it_normalizes_an_existing_product_without_family_into_mongodb_document($mongoFactory, $serializer, ProductInterface $product, \MongoId $mongoId, \MongoDate $mongoDate, Association $assoc1, Association $assoc2, CategoryInterface $category1, CategoryInterface $category2, GroupInterface $group1, GroupInterface $group2, ProductValueInterface $value1, ProductValueInterface $value2) { $mongoFactory->createMongoId('product1')->willReturn($mongoId); $mongoFactory->createMongoDate()->willReturn($mongoDate); $category1->getId()->willReturn(12); $category2->getId()->willReturn(34); $group1->getId()->willReturn(56); $group2->getId()->willReturn(78); $product->getId()->willReturn('product1'); $product->getCreated()->willReturn(null); $product->getFamily()->willReturn(null); $product->isEnabled()->willReturn(true); $product->getGroups()->willReturn([$group1, $group2]); $product->getCategories()->willReturn([$category1, $category2]); $product->getAssociations()->willReturn([$assoc1, $assoc2]); $product->getValues()->willReturn([$value1, $value2]); $context = ['_id' => $mongoId]; $serializer->normalize($product, 'mongodb_json')->willReturn(['data' => 'data', 'completenesses' => 'completenesses']); $serializer->normalize($value1, 'mongodb_document', $context)->willReturn('my_value_1'); $serializer->normalize($value2, 'mongodb_document', $context)->willReturn('my_value_2'); $serializer->normalize($assoc1, 'mongodb_document', $context)->willReturn('my_assoc_1'); $serializer->normalize($assoc2, 'mongodb_document', $context)->willReturn('my_assoc_2'); $this->normalize($product, 'mongodb_document')->shouldReturn(['_id' => $mongoId, 'created' => $mongoDate, 'updated' => $mongoDate, 'enabled' => true, 'groupIds' => [56, 78], 'categoryIds' => [12, 34], 'associations' => ['my_assoc_1', 'my_assoc_2'], 'values' => ['my_value_1', 'my_value_2'], 'normalizedData' => ['data' => 'data'], 'completenesses' => []]); }
/** * Fetch medias on the local filesystem * * @param ProductInterface $product * @param string $directory */ protected function fetchMedia(ProductInterface $product, $directory) { $identifier = $product->getIdentifier()->getData(); $this->mediaFetcher->fetchAll($product->getValues(), $directory, $identifier); foreach ($this->mediaFetcher->getErrors() as $error) { $this->stepExecution->addWarning($error['message'], [], new DataInvalidItem($error['media'])); } }