/** * Get the media attributes * * @return string[] */ public function getMediaAttributes() { if (null === $this->mediaAttributes) { $this->mediaAttributes = $this->attributeRepository->findMediaAttributeCodes(); } return $this->mediaAttributes; }
/** * @return array */ public function resolveAttributeColumns() { if (empty($this->attributesFields)) { // TODO: Put a Cursor to avoid a findAll on attributes (╯°□°)╯︵ ┻━┻ $attributes = $this->attributeRepository->findAll(); $currencyCodes = $this->currencyRepository->getActivatedCurrencyCodes(); $values = $this->valuesResolver->resolveEligibleValues($attributes); foreach ($values as $value) { $field = $this->resolveFlatAttributeName($value['attribute'], $value['locale'], $value['scope']); if (AttributeTypes::PRICE_COLLECTION === $value['type']) { $this->attributesFields[] = $field; foreach ($currencyCodes as $currencyCode) { $currencyField = sprintf('%s-%s', $field, $currencyCode); $this->attributesFields[] = $currencyField; } } elseif (AttributeTypes::METRIC === $value['type']) { $this->attributesFields[] = $field; $metricField = sprintf('%s-%s', $field, 'unit'); $this->attributesFields[] = $metricField; } else { $this->attributesFields[] = $field; } } } return $this->attributesFields; }
/** * {@inheritdoc} */ public function getFilter($code, $operator) { $attribute = $this->attributeRepository->findOneBy(['code' => FieldFilterHelper::getCode($code)]); if (null !== $attribute) { return $this->getAttributeFilter($attribute, $operator); } return $this->getFieldFilter($code, $operator); }
/** * Find common attributes * Common attributes are: * - not unique (and not identifier) * - without value AND link to family * - with value * * @param ProductInterface[] $products * * @return AttributeInterface[] */ public function findCommonAttributes(array $products) { $productIds = []; foreach ($products as $product) { $productIds[] = $product->getId(); } $attributeIds = $this->massActionRepository->findCommonAttributeIds($productIds); return $this->attributeRepository->findWithGroups(array_unique($attributeIds), ['conditions' => ['unique' => 0]]); }
/** * Load the attribute for this filter * Required to prepare choice url params and filter configuration * * @throws \LogicException * * @return AttributeInterface */ protected function getAttribute() { $fieldName = $this->get(ProductFilterUtility::DATA_NAME_KEY); $attribute = $this->attributeRepository->findOneByCode($fieldName); if (!$attribute) { throw new \LogicException(sprintf('There is no attribute with code %s.', $fieldName)); } return $attribute; }
/** * Don't allow creating an identifier attribute if one already exists * * @param AttributeInterface $attribute * @param Constraint $constraint */ public function validate($attribute, Constraint $constraint) { if (AttributeTypes::IDENTIFIER === $attribute->getAttributeType()) { $identifier = $this->attributeRepository->getIdentifier(); if ($identifier && $identifier->getId() !== $attribute->getId()) { $this->context->buildViolation($constraint->message)->atPath('attribute_type')->addViolation(); } } }
/** * 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; }
/** * Get fields for products * * @param array $productIds * * @return array */ public function getFieldsList($productIds) { $this->prepareAvailableAttributeIds($productIds); $attributes = $this->getAttributeIds(); if (empty($attributes)) { return []; } $attributes = $this->attributeRepository->findBy(['id' => $this->getAttributeIds()]); return $this->prepareFieldsList($attributes); }
/** * Normalize the attributes * * @param FamilyInterface $family * * @return array */ protected function normalizeAttributes(FamilyInterface $family) { $attributes = $this->collectionFilter->filterCollection($this->attributeRepository->findAttributesByFamily($family), 'pim.internal_api.attribute.view'); $normalizedAttributes = []; foreach ($attributes as $attribute) { $normalizedAttributes[] = $attribute->getCode(); } sort($normalizedAttributes); return $normalizedAttributes; }
/** * Get axis as choice list * * @deprecated not used anymore except in datagrid configuration, will be removed in 1.5 * * @return array */ public function getAvailableAxisChoices() { $attributes = $this->attributeRepository->findAllAxis(); $choices = []; foreach ($attributes as $attribute) { $choices[$attribute->getId()] = $attribute->getLabel(); } asort($choices); return $choices; }
/** * {@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; }
/** * @return FamilyInterface */ public function createFamily() { $family = new $this->familyClass(); $identifier = $this->attributeRepository->getIdentifier(); $family->addAttribute($identifier); $family->setAttributeAsLabel($identifier); foreach ($this->getChannels() as $channel) { $requirement = $this->factory->createAttributeRequirement($identifier, $channel, true); $family->addAttributeRequirement($requirement); } return $family; }
/** * {@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 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); }
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++; } } }
/** * {@inheritdoc} */ public function dump(OutputInterface $output, HelperSet $helperSet) { $output->writeln("<info>Useable attributes filters...</info>"); $attributeFilters = $this->getAttributeFilters(); $attributes = $this->repository->findAll(); $rows = []; foreach ($attributes as $attribute) { $rows = array_merge($rows, $this->getFilterInformationForAttribute($attribute, $attributeFilters)); } $table = $helperSet->get('table'); $headers = ['attribute', 'localizable', 'scopable', 'attribute type', 'operators', 'filter_class']; $table->setHeaders($headers)->setRows($rows); $table->render($output); }
/** * @param FamilyInterface $family * * @return string[] */ protected function getMissingChannelCodes(FamilyInterface $family) { $requirements = $family->getAttributeRequirements(); $identifierCode = $this->attributeRepository->getIdentifierCode(); $currentChannelCodes = []; foreach ($requirements as $requirement) { if ($requirement->getAttributeCode() === $identifierCode) { $currentChannelCodes[] = $requirement->getChannelCode(); } } $expectedChannelCodes = $this->channelRepository->getChannelCodes(); $missingChannelCodes = array_diff($expectedChannelCodes, $currentChannelCodes); return $missingChannelCodes; }
/** * Get the attribute collection * * @return JsonResponse */ public function indexAction(Request $request) { $criteria = []; if ($request->query->has('identifiers')) { $criteria['code'] = explode(',', $request->query->get('identifiers')); } if ($request->query->has('types')) { $criteria['attributeType'] = explode(',', $request->query->get('types')); } $attributes = $this->attributeRepository->findBy($criteria); $filteredAttributes = $this->collectionFilter->filterCollection($attributes, 'pim.internal_api.attribute.view'); $normalizedAttributes = $this->normalizer->normalize($filteredAttributes, 'internal_api'); return new JsonResponse($normalizedAttributes); }
/** * @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); } }
/** * Transforms a relative path to absolute. Data must be provided in the pivot format. * * $item exemple: * [ * 'side_view' => [ * [ * 'locale' => null, * 'scope' => null, * 'data' => [ * 'filePath' => 'cat_003.png', * 'originalFilename' => 'cat_003.png' * ] * ] * ] * ] * * @param array $attributeValues An associative array (attribute_code => values) * @param string $filePath The absolute path * * @return array */ public function transform(array $attributeValues, $filePath) { $mediaAttributes = $this->attributeRepository->findMediaAttributeCodes(); foreach ($attributeValues as $code => $values) { if (in_array($code, $mediaAttributes)) { foreach ($values as $index => $value) { if (isset($value['data']) && isset($value['data']['filePath'])) { $dataFilePath = $value['data']['filePath']; $attributeValues[$code][$index]['data']['filePath'] = sprintf('%s%s%s', $filePath, DIRECTORY_SEPARATOR, $dataFilePath); } } } } return $attributeValues; }
/** * {@inheritdoc} */ public function convertDefaultToLocalizedValue($code, $data, $options = []) { $attribute = $this->attributeRepository->findOneBy(['code' => $code]); if (null === $attribute) { return $data; } $attributeType = $attribute->getAttributeType(); if (null === $attributeType) { return $data; } $localizer = $this->localizerRegistry->getLocalizer($attributeType); if (null === $localizer) { return $data; } return $localizer->localize($data, $options); }
/** * - Add the media to the $this->writtenFiles to be archive later * - Update the value of each media in the standard format to add the final path of media in archive. * * The standard format for a media contains only the filePath (which is the unique key of the media): * { * "values": { * "picture": [ * { * "locale": "en_US", * "scope": "ecommerce", * "data": [ * "filePath": "a/b/c/d/e/it_s_my_filename.jpg" * ] * } * ] * } * } * * In exported files, we don't want to see the key, but the original filename. As the standard format does not * contain this information, we use the Finder() to find the media in the temporary directory created in processor. * * After: * { * "values": { * "picture": [ * { * "locale": "en_US", * "scope": "ecommerce", * "data": [ * "filePath": "files/item_identifier/picture/en_US/ecommerce/it's my filename.jpg" * ] * } * ] * } * } * * @param array $item standard format of an item * @param string $tmpDirectory directory where media have been copied before to be exported * * @return array */ protected function resolveMediaPaths(array $item, $tmpDirectory) { $attributeTypes = $this->attributeRepository->getAttributeTypeByCodes(array_keys($item['values'])); $mediaAttributeTypes = array_filter($attributeTypes, function ($attributeCode) { return in_array($attributeCode, $this->mediaAttributeTypes); }); $identifier = $this->getItemIdentifier($item); foreach ($mediaAttributeTypes as $attributeCode => $attributeType) { foreach ($item['values'][$attributeCode] as $index => $value) { if (null !== $value['data']) { $exportDirectory = $this->fileExporterPath->generate($value, ['identifier' => $identifier, 'code' => $attributeCode]); $finder = new Finder(); if (is_dir($tmpDirectory . $exportDirectory)) { $files = iterator_to_array($finder->files()->in($tmpDirectory . $exportDirectory)); if (!empty($files)) { $path = $exportDirectory . current($files)->getFilename(); $this->writtenFiles[$tmpDirectory . $path] = $path; $item['values'][$attributeCode][$index]['data']['filePath'] = $path; } } } } } return $item; }
/** * Remove an attribute * * @param int $familyId * @param int $attributeId * * @AclAncestor("pim_enrich_family_edit_attributes") * * @throws DeleteException * * @return \Symfony\Component\HttpFoundation\RedirectResponse */ public function removeAttributeAction($familyId, $attributeId) { $family = $this->familyRepository->find($familyId); if (null === $family) { throw new NotFoundHttpException(sprintf('%s entity not found', $this->familyClass)); } $attribute = $this->attributeRepo->find($attributeId); if (null === $attribute) { throw new NotFoundHttpException(sprintf('%s entity not found', $this->attributeClass)); } if (false === $family->hasAttribute($attribute)) { throw new DeleteException($this->translator->trans('flash.family.attribute not found')); } elseif (AttributeTypes::IDENTIFIER === $attribute->getAttributeType()) { throw new DeleteException($this->translator->trans('flash.family.identifier not removable')); } elseif ($attribute === $family->getAttributeAsLabel()) { throw new DeleteException($this->translator->trans('flash.family.label attribute not removable')); } else { $family->removeAttribute($attribute); foreach ($family->getAttributeRequirements() as $requirement) { if ($requirement->getAttribute() === $attribute) { $family->removeAttributeRequirement($requirement); $this->doctrine->getManagerForClass(ClassUtils::getClass($requirement))->remove($requirement); } } $this->familySaver->save($family); } if ($this->request->isXmlHttpRequest()) { return new Response('', 204); } else { return new RedirectResponse($this->router->generate('pim_enrich_family_edit', ['id' => $family->getId()])); } }
/** * {@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; }
/** * @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 convertLocalizedToDefaultValues(array $items, array $options = []) { $this->violations = new ConstraintViolationList(); $attributeTypes = $this->attributeRepository->getAttributeTypeByCodes(array_keys($items)); foreach ($items as $code => $item) { if (isset($attributeTypes[$code])) { $localizer = $this->localizerRegistry->getLocalizer($attributeTypes[$code]); if (null !== $localizer) { foreach ($item as $index => $data) { $items[$code][$index] = $this->convertLocalizedToDefaultValue($localizer, $data, $options, $this->buildPropertyPath($data, $code)); } } } } return $items; }
/** * Find an attribute by its id or return a 404 response * * @param int $id the attribute id * * @throws NotFoundHttpException * * @return AttributeInterface */ protected function findAttributeOr404($id) { $attribute = $this->attributeRepository->find($id); if (!$attribute) { throw new NotFoundHttpException(sprintf('Attribute with id %d could not be found.', $id)); } return $attribute; }
/** * @param int $id * * @return AttributeInterface */ protected function findAttributeOr404($id) { $result = $this->attributeRepo->find($id); if (!$result) { throw new NotFoundHttpException('Attribute not found'); } return $result; }
/** * {@inheritdoc} */ public function createProduct($identifier = null, $familyCode = null) { $product = new $this->productClass(); $identifierAttribute = $this->attributeRepository->getIdentifier(); $productValue = $this->createProductValue($identifierAttribute); $product->addValue($productValue); if (null !== $identifier) { $productValue->setData($identifier); } if (null !== $familyCode) { $family = $this->familyRepository->findOneByIdentifier($familyCode); $product->setFamily($family); } $event = new GenericEvent($product); $this->eventDispatcher->dispatch(ProductEvents::CREATE, $event); return $product; }