function it_sets_invalid_values_to_attributes($validator, $productUpdater, AttributeInterface $attribute, AttributeRepositoryInterface $attributeRepository, ProductInterface $product, ConstraintViolationListInterface $violations, StepExecution $stepExecution, JobConfigurationRepositoryInterface $jobConfigurationRepo, JobExecution $jobExecution, JobConfigurationInterface $jobConfiguration)
{
$stepExecution->getJobExecution()->willReturn($jobExecution);
$jobConfigurationRepo->findOneBy(['jobExecution' => $jobExecution])->willReturn($jobConfiguration);
$values = ['categories' => [['scope' => null, 'locale' => null, 'data' => ['office', 'bedroom']]]];
$normalizedValues = addslashes(json_encode($values));
$jobConfiguration->getConfiguration()->willReturn(json_encode(['filters' => [], 'actions' => ['normalized_values' => $normalizedValues, 'ui_locale' => 'fr_FR', 'attribute_locale' => 'en_US']]));
$validator->validate($product)->willReturn($violations);
$violation = new ConstraintViolation('error2', 'spec', [], '', '', $product);
$violations = new ConstraintViolationList([$violation, $violation]);
$validator->validate($product)->willReturn($violations);
$attributeRepository->findOneByIdentifier('categories')->willReturn($attribute);
$product->isAttributeEditable($attribute)->willReturn(true);
$productUpdater->update($product, $values)->shouldBeCalled();
$this->setStepExecution($stepExecution);
$stepExecution->addWarning(Argument::cetera())->shouldBeCalled();
$stepExecution->incrementSummaryInfo('skipped_products')->shouldBeCalled();
$this->process($product);
}
/**
* Get a list of available attributes
*
* @param string $typeCode
* @return AttributeInterface[]
*/
public function getAttributes($typeCode)
{
$attributeCodes = $this->repository->getAttributeCodesByType($typeCode);
$attributeList = [];
foreach ($attributeCodes as $attributeCode) {
$attributeList[] = $this->repository->findOneByIdentifier($attributeCode);
}
return $attributeList;
}
/**
* {@inheritdoc}
*/
public function getPresenterByAttributeCode($code)
{
$attribute = $this->attributeRepository->findOneByIdentifier($code);
if (null === $attribute) {
return null;
}
$attributeType = $attribute->getAttributeType();
if (null === $attributeType) {
return null;
}
return $this->getPresenter($attributeType, self::TYPE_PRODUCT_VALUE);
}
/**
* {@inheritdoc}
*/
public function process($family)
{
$actions = $this->getConfiguredActions();
foreach ($actions as $action) {
$attribute = $this->attributeRepository->findOneByIdentifier($action['attribute_code']);
$channel = $this->channelRepository->findOneByIdentifier($action['channel_code']);
$isRequired = $action['is_required'];
$family->addAttribute($attribute);
$family->addAttributeRequirement($this->factory->createAttributeRequirement($attribute, $channel, $isRequired));
}
return $family;
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = [])
{
$values = new ArrayCollection();
foreach ($data as $attributeCode => $valuesData) {
$attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
foreach ($valuesData as $valueData) {
$value = $this->denormalizer->denormalize($valueData, $this->valueClass, 'json', ['attribute' => $attribute] + $context);
$values->add($value);
}
}
return $values;
}
function it_denormalizes_product_values_from_json($denormalizer, $registry, AttributeRepositoryInterface $attributeRepository, ProductValueInterface $nameValue, ProductValueInterface $colorValue, AttributeInterface $name, AttributeInterface $color)
{
$data = ['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']], 'color' => [['locale' => 'en_US', 'scope' => 'ecommerce', 'value' => 'red']]];
$attributeRepository->findOneByIdentifier('name')->willReturn($name);
$attributeRepository->findOneByIdentifier('color')->willReturn($color);
$registry->getRepository('Attribute')->willReturn($attributeRepository);
$denormalizer->denormalize($data['name'][0], 'ProductValue', 'json', ['attribute' => $name])->shouldBeCalled()->willReturn($nameValue);
$denormalizer->denormalize($data['color'][0], 'ProductValue', 'json', ['attribute' => $color])->shouldBeCalled()->willReturn($colorValue);
$values = $this->denormalize($data, 'ProductValue[]', 'json');
$values->shouldHaveCount(2);
$values[0]->shouldBe($nameValue);
$values[1]->shouldBe($colorValue);
}
/**
* {@inheritdoc}
*/
public function validate($attributes, Constraint $constraint)
{
if (null === $attributes || !count($attributes)) {
return;
}
$errorCount = 0;
foreach ($attributes as $attributeCode) {
$attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
if (null === $attribute) {
$this->context->buildViolation($constraint->message)->setParameter('%attributeCode%', $attributeCode)->atPath(sprintf('[%d]', $errorCount))->addViolation();
$errorCount++;
}
}
}
/**
* @param GroupInterface $group
* @param array $data
*/
protected function setAxis(GroupInterface $group, $data)
{
if (isset($data['axis']) && !empty($data['axis'])) {
$axisCodes = explode(',', $data['axis']);
$attributes = [];
foreach ($axisCodes as $code) {
$attribute = $this->attributeRepository->findOneByIdentifier($code);
if (!$attribute) {
throw new \LogicException(sprintf('Attribute with identifier "%s" not found', $code));
}
$attributes[] = $attribute;
}
$group->setAxisAttributes($attributes);
}
}
/**
* @param string $code
*
* @return AttributeInterface
*/
protected function getAttribute($code)
{
if (!array_key_exists($code, $this->attributes)) {
$this->attributes[$code] = $this->attributeRepository->findOneByIdentifier($code);
}
return $this->attributes[$code];
}
/**
* {@inheritdoc}
*/
public function process($family)
{
$configuration = $this->getJobConfiguration();
if (!array_key_exists('actions', $configuration)) {
throw new InvalidArgumentException('Missing configuration for \'actions\'.');
}
$actions = $configuration['actions'];
foreach ($actions as $action) {
$attribute = $this->attributeRepository->findOneByIdentifier($action['attribute_code']);
$channel = $this->channelRepository->findOneByIdentifier($action['channel_code']);
$isRequired = $action['is_required'];
$family->addAttribute($attribute);
$family->addAttributeRequirement($this->factory->createAttributeRequirement($attribute, $channel, $isRequired));
}
return $family;
}
/**
* Extract attribute field name information with attribute code, locale code, scope code
* and optionally price currency
*
* Returned array like:
* [
* "attribute" => AttributeInterface,
* "locale_code" => <locale_code>|null,
* "scope_code" => <scope_code>|null,
* "price_currency" => <currency_code> // this key is optional
* ]
*
* Return null if the field name does not match an attribute.
*
* @param string $fieldName
*
* @return array|null
*/
public function extractColumnInfo($fieldName)
{
if (!isset($this->fieldNameInfoCache[$fieldName]) && !in_array($fieldName, $this->excludedFieldNames)) {
$explodedFieldName = explode(self::FIELD_SEPARATOR, $fieldName);
$attributeCode = $explodedFieldName[0];
$attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
if (null !== $attribute) {
$this->checkFieldNameTokens($attribute, $fieldName, $explodedFieldName);
$attributeInfo = $this->extractAttributeInfo($attribute, $explodedFieldName);
$this->checkFieldNameLocaleByChannel($attribute, $fieldName, $attributeInfo);
$this->fieldNameInfoCache[$fieldName] = $attributeInfo;
} else {
$this->excludedFieldNames[] = $fieldName;
}
}
return isset($this->fieldNameInfoCache[$fieldName]) ? $this->fieldNameInfoCache[$fieldName] : null;
}
/**
* @param AttributeRepositoryInterface $attributeRepository
* @param AttributeOptionRepositoryInterface $attributeOptionRepository
* @param string $attributeCode
* @param FileLoader $loader
* @param string $mappingFile
*/
public function __construct(AttributeRepositoryInterface $attributeRepository, AttributeOptionRepositoryInterface $attributeOptionRepository, $attributeCode, FileLoader $loader = null, $mappingFile = null)
{
$this->attributeRepository = $attributeRepository;
$this->attributeOptionRepository = $attributeOptionRepository;
$this->mapping = [];
$this->attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
if ($this->attribute) {
$this->attributeOptions = $this->attribute->getOptions();
} else {
$this->attributeOptions = new ArrayCollection();
}
if ($mappingFile !== null && $loader !== null) {
foreach ($loader->load($mappingFile) as $rawValue => $optionCode) {
$this->mapTo($rawValue, $optionCode);
}
}
}
/**
* Get non eligible attributes to a product template
*
* @param GroupInterface $variantGroup
*
* @return AttributeInterface[]
*/
public function getNonEligibleAttributes(GroupInterface $variantGroup)
{
$attributes = $variantGroup->getAxisAttributes()->toArray();
$template = $variantGroup->getProductTemplate();
if (null !== $template) {
foreach (array_keys($template->getValuesData()) as $attributeCode) {
$attributes[] = $this->attributeRepository->findOneByIdentifier($attributeCode);
}
}
$uniqueAttributes = $this->attributeRepository->findBy(['unique' => true]);
foreach ($uniqueAttributes as $attribute) {
if (!in_array($attribute, $attributes)) {
$attributes[] = $attribute;
}
}
return $attributes;
}
/**
* @param FamilyInterface $family
* @param string $data
*
* @throws \InvalidArgumentException
*/
protected function setAttributeAsLabel(FamilyInterface $family, $data)
{
if (null !== ($attribute = $this->attributeRepository->findOneByIdentifier($data))) {
$family->setAttributeAsLabel($attribute);
} else {
throw new \InvalidArgumentException(sprintf('Attribute with "%s" code does not exist', $data));
}
}
/**
* Get attribute by identifier
*
* @param string $identifier
*
* @return JsonResponse
*/
public function getAction($identifier)
{
$attribute = $this->attributeRepository->findOneByIdentifier($identifier);
$attribute = $this->attributeFilter->filterObject($attribute, 'pim.internal_api.attribute.view') ? null : $attribute;
if (null === $attribute) {
throw new NotFoundHttpException(sprintf('Attribute with code "%s" not found', $identifier));
}
return new JsonResponse($this->normalizer->normalize($attribute, 'internal_api'));
}
/**
* @param string $code
*
* @throws ObjectNotFoundException
*
* @return AttributeInterface
*/
protected function getAttribute($code)
{
if (!array_key_exists($code, $this->attributes)) {
$attribute = $this->attributeRepository->findOneByIdentifier($code);
if (!$attribute) {
throw new ObjectNotFoundException(sprintf('Attribute with code "%s" was not found.', $code));
}
$this->attributes[$code] = $attribute;
}
return $this->attributes[$code];
}
/**
* Prepare product values
*
* @param ProductInterface $product
* @param array $actions
*
* @return array
*/
protected function prepareProductValues(ProductInterface $product, array $actions)
{
$normalizedValues = json_decode($actions['normalized_values'], true);
$filteredValues = [];
foreach ($normalizedValues as $attributeCode => $values) {
$attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
if ($product->isAttributeEditable($attribute)) {
$filteredValues[$attributeCode] = $values;
}
}
return $filteredValues;
}
/**
* @param GroupInterface $group
* @param string[] $attributeCodes
*
* @throws \InvalidArgumentException
*/
protected function setAxis(GroupInterface $group, array $attributeCodes)
{
$attributes = [];
foreach ($attributeCodes as $attributeCode) {
$attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
if (null === $attribute) {
throw new \InvalidArgumentException(sprintf('Attribute "%s" does not exist', $attributeCode));
}
$attributes[] = $attribute;
}
$group->setAxisAttributes($attributes);
}
/**
* Change users' data (example: "12,45") into storable data (example: "12.45").
*
* @param array $data
* @param string $uiLocaleCode
*
* @return array
*/
protected function delocalizeData(array $data, $uiLocaleCode)
{
foreach ($data as $code => $values) {
$attribute = $this->attributeRepository->findOneByIdentifier($code);
$localizer = $this->localizerRegistry->getLocalizer($attribute->getAttributeType());
if (null !== $localizer) {
$values = array_map(function ($value) use($localizer, $uiLocaleCode) {
$value['data'] = $localizer->delocalize($value['data'], ['locale' => $uiLocaleCode]);
return $value;
}, $values);
$data[$code] = $values;
}
}
return $data;
}
/**
* @param GroupInterface $variantGroup
* @param array $axes
*
* @throws \InvalidArgumentException
*/
protected function setAxes(GroupInterface $variantGroup, array $axes)
{
if (null !== $variantGroup->getId()) {
if (array_diff($this->getOriginalAxes($variantGroup->getAxisAttributes()), array_values($axes))) {
throw new \InvalidArgumentException('Attributes: This property cannot be changed.');
}
}
foreach ($axes as $axis) {
$attribute = $this->attributeRepository->findOneByIdentifier($axis);
if (null !== $attribute) {
$variantGroup->addAxisAttribute($attribute);
} else {
throw new \InvalidArgumentException(sprintf('Attribute "%s" does not exist', $axis));
}
}
}
/**
* {@inheritdoc}
*/
public function addFilter($field, $operator, $value, array $context = [])
{
$attribute = $this->attributeRepository->findOneByIdentifier(FieldFilterHelper::getCode($field));
if (null !== $attribute) {
$filter = $this->filterRegistry->getAttributeFilter($attribute, $operator);
} else {
$filter = $this->filterRegistry->getFieldFilter($field, $operator);
}
if (null === $filter) {
throw new \LogicException(sprintf('Filter on property "%s" is not supported or does not support operator "%s"', $field, $operator));
}
$context = $this->getFinalContext($context);
if (null !== $attribute) {
$context['field'] = $field;
$this->addAttributeFilter($filter, $attribute, $operator, $value, $context);
} else {
$this->addFieldFilter($filter, $field, $operator, $value, $context);
}
$this->rawFilters[] = ['field' => $field, 'operator' => $operator, 'value' => $value, 'context' => $context];
return $this;
}
/**
* Prepare product values
*
* @param ProductInterface $product
* @param array $actions
*
* @return array
*/
protected function prepareProductValues(ProductInterface $product, array $actions)
{
$normalizedValues = json_decode($actions['normalized_values'], true);
$attributeLocale = $actions['attribute_locale'];
$filteredValues = [];
foreach ($normalizedValues as $attributeCode => $values) {
$attribute = $this->attributeRepository->findOneByIdentifier($attributeCode);
if ($product->isAttributeEditable($attribute)) {
$values = array_filter($values, function ($value) use($attributeLocale) {
return $attributeLocale === $value['locale'] || null === $value['locale'];
});
$localizer = $this->localizerRegistry->getLocalizer($attribute->getAttributeType());
if (null !== $localizer) {
$locale = $actions['ui_locale'];
$values = array_map(function ($value) use($localizer, $locale) {
$value['data'] = $localizer->delocalize($value['data'], ['locale' => $locale]);
return $value;
}, $values);
}
$filteredValues[$attributeCode] = $values;
}
}
return $filteredValues;
}
/**
* @param string $code
*
* @return AttributeInterface|null
*/
protected function findAttribute($code)
{
$attribute = $this->attributeRepository->findOneByIdentifier($code);
return $attribute;
}
public function it_should_not_remove_identifier_requirements_when_other_requirements_are_provided($attrRequiFactory, $channelRepository, FamilyInterface $family, AttributeRepositoryInterface $attributeRepository, AttributeInterface $skuAttribute, AttributeInterface $nameAttribute, AttributeInterface $descAttribute, AttributeRequirementInterface $skuMobileRqrmt, AttributeRequirementInterface $skuPrintRqrmt, AttributeRequirementInterface $namePrintRqrmt, AttributeRequirementInterface $descPrintRqrmt, ChannelInterface $mobileChannel, ChannelInterface $printChannel)
{
$values = ['code' => 'mycode', 'requirements' => ['print' => ['name', 'description']]];
$family->getAttributeRequirements()->willReturn([$skuMobileRqrmt, $skuPrintRqrmt]);
$family->getId()->willReturn(42);
$skuMobileRqrmt->getAttribute()->willReturn($skuAttribute);
$skuPrintRqrmt->getAttribute()->willReturn($skuAttribute);
$skuMobileRqrmt->getChannelCode()->willReturn('mobile');
$skuPrintRqrmt->getChannelCode()->willReturn('print');
$skuAttribute->getAttributeType()->willReturn(AttributeTypes::IDENTIFIER);
$channelRepository->findOneByIdentifier('print')->willReturn($printChannel);
$attributeRepository->findOneByIdentifier('name')->willReturn($nameAttribute);
$attributeRepository->findOneByIdentifier('description')->willReturn($descAttribute);
$attrRequiFactory->createAttributeRequirement($nameAttribute, $printChannel, true)->willReturn($namePrintRqrmt);
$attrRequiFactory->createAttributeRequirement($descAttribute, $printChannel, true)->willReturn($descPrintRqrmt);
$namePrintRqrmt->getAttribute()->willReturn($nameAttribute);
$descPrintRqrmt->getAttribute()->willReturn($descAttribute);
$channelRepository->getChannelCodes()->willReturn(['mobile', 'print']);
$channelRepository->findOneByIdentifier('mobile')->willReturn($mobileChannel);
$channelRepository->findOneByIdentifier('print')->willReturn($printChannel);
$attributeRepository->getIdentifier()->willReturn($skuAttribute);
$family->setCode('mycode')->shouldBeCalled();
$family->setAttributeRequirements([$skuMobileRqrmt, $skuPrintRqrmt, $namePrintRqrmt, $descPrintRqrmt])->shouldBeCalled();
$this->update($family, $values, []);
}
