public function process($item)
{
$sku = (string) $item['sku'];
$attribute = $this->productManager->getIdentifierAttribute();
$product = $this->productManager->findByIdentifier($sku);
// if (!$product) {
// $product = $this->productManager->createProduct();
// $value = $this->productManager->createProductValue();
// $value->setAttribute($attribute);
// $value->setData($sku);
// $product->addValue($value);
// $this->stepExecution->incrementSummaryInfo('create');
// return $product;
// } else {
if (!$product) {
$data = current((array) $item);
$this->stepExecution->incrementSummaryInfo('skip');
throw new InvalidItemException(sprintf('Skip the existing %s product', $sku), $data);
} else {
$product_tab = array();
$product_tab[] = $product;
$this->productUpdater->setValue($product_tab, 'price', [['data' => (string) $item['price'], 'currency' => (string) $item['currency']]]);
return $product;
}
// }
}
public function write(array $items)
{
foreach ($items as $product) {
$this->productManager->save($product);
$this->stepExecution->incrementSummaryInfo('save');
}
}
/**
* @param ProductManager $manager the product manager
* @param ProductInterface $product the entity
* @param array $attributes the attributes
*/
protected function addValues(ProductManager $manager, ProductInterface $product, $attributes)
{
foreach ($attributes as $attribute) {
$value = $manager->createProductValue();
$value->setAttribute($attribute);
$product->addValue($value);
}
}
/**
* Displays completeness for a product
*
* @param int $id
*
* @return Response
*/
public function completenessAction($id)
{
$product = $this->productManager->getProductRepository()->getFullProduct($id);
$channels = $this->channelManager->getFullChannels();
$locales = $this->userContext->getUserLocales();
$completenesses = $this->completenessManager->getProductCompleteness($product, $channels, $locales, $this->userContext->getCurrentLocale()->getCode());
return $this->templating->renderResponse('PimEnrichBundle:Completeness:_completeness.html.twig', array('product' => $product, 'channels' => $channels, 'locales' => $locales, 'completenesses' => $completenesses));
}
/**
* Find a product by its id or return a 404 response
*
* @param integer $id the product id
*
* @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
*
* @return \Pim\Bundle\CatalogBundle\Model\ProductInterface
*/
protected function findProductOr404($id)
{
$product = $this->productManager->find($id);
if (null === $product) {
throw new NotFoundHttpException(sprintf('Product with id %s could not be found.', (string) $id));
}
return $product;
}
/**
* Don't allow creating an identifier attribute if one already exists
*
* @param AbstractAttribute $attribute
* @param Constraint $constraint
*/
public function validate($attribute, Constraint $constraint)
{
if ($attribute->getAttributeType() === 'pim_catalog_identifier') {
$identifier = $this->manager->getIdentifierAttribute();
if ($identifier && $identifier->getId() !== $attribute->getId()) {
$this->context->addViolationAt('attributeType', $constraint->message);
}
}
}
/**
* Constraint is applied on ProductValue data property.
* That's why we use the current property path to guess the code
* of the attribute to which the data belongs to.
* @param object $rawValue
* @param Constraint $constraint
*
* @see Pim\Bundle\CatalogBundle\Validator\ConstraintGuesser\UniqueValueGuesser
*/
public function validate($rawValue, Constraint $constraint)
{
if (empty($rawValue)) {
return;
}
$value = $this->getProductValue();
if ($value instanceof ProductValueInterface && $this->productManager->valueExists($value)) {
$this->context->addViolation($constraint->message);
}
}
/**
* @param ProductManager $manager the product manager
* @param ProductInterface $product the entity
* @param array $attributes the attributes
*/
protected function addValues(ProductManager $manager, ProductInterface $product, $attributes)
{
foreach ($attributes as $attribute) {
$value = $manager->createProductValue();
$value->setAttribute($attribute);
if ($attribute->getDefaultValue() !== null) {
$value->setData($attribute->getDefaultValue());
}
$product->addValue($value);
}
}
/**
* Create and configure a family intance
*
* @return Family
*/
public function createFamily()
{
$family = new Family();
$identifier = $this->productManager->getIdentifierAttribute();
$family->addAttribute($identifier);
$family->setAttributeAsLabel($identifier);
foreach ($this->getChannels() as $channel) {
$family->addAttributeRequirement($this->factory->createAttributeRequirement($identifier, $channel, true));
}
return $family;
}
/**
* @return array
*/
protected function prepareParameters()
{
$queryParameters = parent::prepareParameters();
$variantGroupId = $queryParameters['currentGroup'];
if (null !== $variantGroupId) {
$productIds = $this->productManager->getProductRepository()->getEligibleProductIdsForVariantGroup($variantGroupId);
if (count($productIds) === 0) {
$productIds = [0];
}
} else {
$productIds = [0];
}
$queryParameters['productIds'] = $productIds;
return $queryParameters;
}
function let(ProductManager $productManager, UserContext $userContext, CurrencyManager $currencyManager, Locale $en, Locale $de, AttributeRepository $attributeRepository, AbstractProductValue $productValue, CatalogContext $catalogContext, ProductBuilder $productBuilder, ProductMassActionManager $massActionManager, MetricFactory $metricFactory)
{
$en->getCode()->willReturn('en_US');
$de->getCode()->willReturn('de_DE');
$userContext->getCurrentLocale()->willReturn($en);
$userContext->getUserLocales()->willReturn([$en, $de]);
$catalogContext->setLocaleCode(Argument::any())->willReturn($catalogContext);
$productManager->createProductValue()->willReturn($productValue);
$productValue->setAttribute(Argument::any())->willReturn($productValue);
$productValue->setLocale(Argument::any())->willReturn($productValue);
$productValue->setScope(Argument::any())->willReturn($productValue);
$productValue->addPrice(Argument::any())->willReturn($productValue);
$productManager->getAttributeRepository()->willReturn($attributeRepository);
$this->beConstructedWith($productManager, $userContext, $currencyManager, $catalogContext, $productBuilder, $massActionManager, $metricFactory, ['product_price' => 'Pim\\Bundle\\CatalogBundle\\Model\\ProductPrice', 'product_media' => 'Pim\\Bundle\\CatalogBundle\\Model\\ProductMedia']);
}
/**
* {@inheritdoc}
*/
public function write(array $products)
{
$this->collection = $this->documentManager->getDocumentCollection($this->productClass);
$productsToInsert = array();
$productsToUpdate = array();
foreach ($products as $product) {
if (null === $product->getId()) {
$productsToInsert[] = $product;
$product->setId($this->mongoFactory->createMongoId());
} else {
$productsToUpdate[] = $product;
}
}
$this->productManager->handleAllMedia($products);
$this->eventDispatcher->dispatch(self::PRE_INSERT, new GenericEvent($productsToInsert));
$this->eventDispatcher->dispatch(self::PRE_UPDATE, new GenericEvent($productsToUpdate));
$insertDocs = $this->getDocsFromProducts($productsToInsert);
$updateDocs = $this->getDocsFromProducts($productsToUpdate);
if (count($insertDocs) > 0) {
$this->insertDocuments($insertDocs);
}
if (count($updateDocs) > 0) {
$this->updateDocuments($updateDocs);
}
$this->pendingPersister->persistPendingVersions($products);
$this->eventDispatcher->dispatch(self::POST_INSERT, new GenericEvent($productsToInsert));
$this->eventDispatcher->dispatch(self::POST_UPDATE, new GenericEvent($productsToUpdate));
$this->documentManager->clear();
$this->cacheClearer->clear();
}
/**
* Due to constraint guesser, the constraint is applied on :
* - ProductValueInterface data when applied through form
* - ProductValueInterface when applied directly through validator
*
* The constraint guesser should be re-worked in a future version to avoid such behavior
*
* @param ProductValueInterface|mixed $data
* @param Constraint $constraint
*
* @see Pim\Bundle\CatalogBundle\Validator\ConstraintGuesser\UniqueValueGuesser
*/
public function validate($data, Constraint $constraint)
{
if (empty($data)) {
return;
}
if (is_object($data) && $data instanceof ProductValueInterface) {
$productValue = $data;
} else {
$productValue = $this->getProductValueFromForm();
}
if ($productValue instanceof ProductValueInterface && $this->productManager->valueExists($productValue)) {
if ($productValue->getData() !== null && $productValue->getData() !== '') {
$this->context->addViolation($constraint->message);
}
}
}
/**
* Persists an object
*
* @param object $object
*/
protected function persistObject($object)
{
if ($object instanceof \Pim\Bundle\CatalogBundle\Model\ProductInterface) {
$this->productManager->handleMedia($object);
}
$this->objectManager->persist($object);
$this->doctrineCache->setReference($object);
}
/**
* Find previous sequential edit entity
*
* @param SequentialEdit $sequentialEdit
* @param int $currentKey
*
* @return null|ProductInterface
*/
protected function findPrevious(SequentialEdit $sequentialEdit, $currentKey)
{
$previous = null;
$objectSet = $sequentialEdit->getObjectSet();
while ($currentKey-- > 0 && null === $previous) {
$previous = $this->productManager->find($objectSet[$currentKey]);
}
return $previous;
}
/**
* @return ProductInterface
*/
protected function getCurrentProduct()
{
$productId = $this->extractor->getDatagridParameter('product');
if (!$productId) {
throw new \LogicException('The current product type must be configured');
}
$product = $this->manager->find($productId);
return $product;
}
/**
* {@inheritdoc}
*/
public function write(array $items)
{
$this->versionManager->setRealTimeVersioning($this->realTimeVersioning);
foreach ($items as $item) {
$this->incrementCount($item);
}
$this->productManager->handleAllMedia($items);
$this->productManager->saveAllProducts($items, ['recalculate' => false]);
$this->cacheClearer->clear();
}
/**
* Get attributes configuration for attribute that can be used in grid (as column or filter)
*
* @return array
*/
protected function getAttributesConfig()
{
$attributeIds = $this->getAttributeIds();
if (empty($attributeIds)) {
return [];
}
$currentLocale = $this->getCurrentLocaleCode();
$repository = $this->productManager->getAttributeRepository();
$configuration = $repository->getAttributesAsArray(true, $currentLocale, $attributeIds);
return $configuration;
}
/**
* Find a product by its id or return a 404 response
*
* @param int $id the product id
*
* @throws NotFoundHttpException
*
* @return ProductInterface
*/
protected function findProductOr404($id)
{
$product = $this->productManager->find($id);
if (!$product) {
throw $this->createNotFoundException(sprintf('Product with id %s could not be found.', (string) $id));
}
// With this version of the form we need to add missing values from family
$this->productBuilder->addMissingProductValues($product);
$this->productBuilder->addMissingAssociations($product);
return $product;
}
/**
* Get matching products
*
* @param GroupInterface $variantGroup the variant group
* @param ProductInterface $entity the product
* @param array $criteria query criterias
*
* @return ProductInterface[]
*/
protected function getMatchingProducts(GroupInterface $variantGroup, ProductInterface $entity = null, array $criteria = [])
{
if (!$variantGroup->getId()) {
return [];
}
$repository = $this->manager->getProductRepository();
$matchingProducts = $repository->findAllForVariantGroup($variantGroup, $criteria);
if ($entity) {
$matchingProducts = array_filter($matchingProducts, function ($product) use($entity) {
return $product->getId() !== $entity->getId();
});
}
return $matchingProducts;
}
/**
* @param ProductValueInterface $productValue
* @param ProductValueInterface $value
*/
protected function setProductOption(ProductValueInterface $productValue, ProductValueInterface $value)
{
foreach ($productValue->getOptions() as $option) {
if (!$value->getOptions()->contains($option)) {
$productValue->removeOption($option);
}
}
// TODO: Clean this code removing flush for ORM
if (!class_exists(PimCatalogBundle::DOCTRINE_MONGODB)) {
$this->productManager->getObjectManager()->flush();
}
foreach ($value->getOptions() as $option) {
$productValue->addOption($option);
}
}
/**
* @param object $product
* @param null $format
* @param array $context
* @return array|\Symfony\Component\Serializer\Normalizer\scalar
*/
public function normalize($product, $format = null, array $context = [])
{
$normalizedAssociations = [];
$identifierAttributeCode = $this->productManager->getIdentifierAttribute()->getCode();
$sku = $product->getValue($this->productManager->getIdentifierAttribute()->getCode())->getData();
$normalizedAssociations['sku'] = $sku;
$normalizedAssociations['family'] = $product->getFamily()->getCode();
$normalizedAssociations['associations'] = [];
foreach ($product->getAssociations() as $association) {
$associationCode = $association->getAssociationType()->getCode();
if ($association->getGroups()->count() > 0 || $association->getProducts()->count() > 0) {
/**@var Product $product * */
$normalizedAssociations['associations'][$associationCode] = ['type' => null, 'groups' => [], 'products' => []];
$normalizedAssociations['associations'][$associationCode]['type'] = $associationCode;
foreach ($association->getGroups() as $group) {
$normalizedAssociations['associations'][$associationCode]['groups'][] = $group->getCode();
}
foreach ($association->getProducts() as $product) {
$normalizedAssociations['associations'][$associationCode]['products'][] = $product->getValue($identifierAttributeCode)->getData();
}
}
}
return $normalizedAssociations;
}
public function process($item)
{
$sku = $item['sku'];
$attribute = $this->productManager->getIdentifierAttribute();
$product = $this->productManager->findByIdentifier($sku);
if (!$product) {
$product = $this->productManager->createProduct();
$value = $this->productManager->createProductValue();
$value->setAttribute($attribute);
$value->setData($sku);
$product->addValue($value);
$this->stepExecution->incrementSummaryInfo('create');
return $product;
} else {
$data = current(((array) $item));
$this->stepExecution->incrementSummaryInfo('skip');
throw new InvalidItemException(sprintf('Skip the existing %s product', $sku), $data);
}
}
/**
* @param ProductInterface $product
* @param array $drupalProduct
*/
protected function computeProductAssociation(ProductInterface $product, array &$drupalProduct)
{
$identifierAttributeCode = $this->productManager->getIdentifierAttribute()->getCode();
/** @var Group $group */
foreach ($product->getAssociations() as $association) {
$associationCode = $association->getAssociationType()->getCode();
if ($association->getGroups()->count() > 0 || $association->getProducts()->count() > 0) {
/**@var Product $product * */
$drupalProduct['associations'][$associationCode] = ['type' => null, 'groups' => [], 'products' => []];
$drupalProduct['associations'][$associationCode]['type'] = $associationCode;
foreach ($association->getGroups() as $group) {
$drupalProduct['associations'][$associationCode]['groups'][] = $group->getCode();
}
foreach ($association->getProducts() as $product) {
$drupalProduct['associations'][$associationCode]['products'][] = $product->getValue($identifierAttributeCode)->getData();
}
}
}
}
/**
* Checks the uniqueness of product values that should be unique
* As the uniqueness check is normally executed against the database
* and imported products have not been persisted yet, this effectively
* checks that the items in the current batch don't contain duplicate values
* for unique attributes.
*
* @param object $entity
* @param array $columnsInfo
* @param array $data
*
* @throws DuplicateProductValueException When duplicate values are encountered
*/
protected function checkUniqueValues($entity, array $columnsInfo, array $data)
{
foreach ($columnsInfo as $columnInfo) {
if ($columnInfo->getAttribute()) {
$value = $this->getProductValue($entity, $columnInfo);
if ($value->getAttribute()->isUnique()) {
$code = $value->getAttribute()->getCode();
$valueData = (string) $value;
if ($valueData !== '') {
if ($this->productManager->valueExists($value)) {
throw new DuplicateProductValueException($code, $valueData, $data);
}
$this->uniqueValues[$code] = isset($this->uniqueValues[$code]) ? $this->uniqueValues[$code] : [];
if (isset($this->uniqueValues[$code][$valueData])) {
throw new DuplicateProductValueException($code, $valueData, $data);
} else {
$this->uniqueValues[$code][$valueData] = "";
}
}
}
}
}
}
/**
* @param string $code
*
* @return AbstractAttribute
*/
public function getAttribute($code)
{
$attributeRepo = $this->productManager->getAttributeRepository();
$attribute = $attributeRepo->findOneByCode($code);
return $attribute;
}
/**
* Prepare available attribute ids
*
* @param array $productIds
*/
protected function prepareAvailableAttributeIds($productIds)
{
$productRepo = $this->productManager->getProductRepository();
$this->attributeIds = $productRepo->getAvailableAttributeIdsToExport($productIds);
}
/**
* {@inheritdoc}
*/
public function getTransformedColumnsInfo($class)
{
return array_merge(parent::getTransformedColumnsInfo($class), $this->transformedColumns[$this->productManager->getProductValueName()]);
}
function it_does_not_validate_with_empty_value(ProductManager $productManager, ProductValueInterface $value, ExecutionContextInterface $context, Constraint $constraint)
{
$productManager->valueExists($value)->shouldNotBeCalled();
$context->addViolation(Argument::any())->shouldNotBeCalled();
$this->validate("", $constraint)->shouldReturn(null);
}
