/** * {@inheritdoc} */ public function apply(DatasourceInterface $datasource, $field, $direction) { $attribute = $this->attributeRepository->findOneByCode($field); $qb = $datasource->getQueryBuilder(); $pqb = $this->productRepository->getProductQueryBuilder($qb); $pqb->addAttributeSorter($attribute, $direction); }
/** * Update product association export date for the given product. * * @param JobInstance $jobInstance * @param string $identifier */ public function updateProductAssociationExport(JobInstance $jobInstance, $identifier) { $product = $this->productRepository->findByReference((string) $identifier); if ($product) { $this->updateExport($product, $jobInstance, $this->tableNameBuilder->getTableName('pim_magento_connector.entity.delta_product_association_export.class')); } }
function it_checks_value_existence(ProductRepositoryInterface $productRepository, ProductValueInterface $value) { $productRepository->valueExists($value)->willReturn(true); $this->valueExists($value)->shouldReturn(true); $productRepository->valueExists($value)->willReturn(false); $this->valueExists($value)->shouldReturn(false); }
/** * Display the products of a group * * @param string $identifier * * @return JsonResponse * * @AclAncestor("pim_enrich_product_index") */ public function listProductsAction($identifier) { $group = $this->groupRepository->findOneBy(['code' => $identifier]); if (!$group) { throw new NotFoundHttpException(sprintf('Group with code "%s" not found', $identifier)); } return new JsonResponse($this->normalizer->normalize(['products' => $this->productRepository->getProductsByGroup($group, self::MAX_PRODUCTS), 'productCount' => $this->productRepository->getProductCountByGroup($group)], 'internal_api')); }
/** * Find a product by its id or return a 404 response * * @param string $id the product id * * @throws NotFoundHttpException * * @return ProductInterface */ protected function findProductOr404($id) { $product = $this->productRepository->findOneByWithValues($id); if (!$product) { throw new NotFoundHttpException(sprintf('Product with id %s could not be found.', (string) $id)); } return $product; }
/** * Displays completeness for a product * * @param int $id * * @return Response */ public function completenessAction($id) { $product = $this->productRepository->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', ['product' => $product, 'channels' => $channels, 'locales' => $locales, 'completenesses' => $completenesses]); }
/** * 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->productRepository->findOneById($id); if (!$product) { throw new NotFoundHttpException(sprintf('Product with id %s could not be found.', $id)); } $this->productBuilder->addMissingAssociations($product); return $product; }
/** * Get completeness for a product * * @param int $id * * @return JSONResponse */ public function getAction($id) { $product = $this->productRepository->getFullProduct($id); $this->completenessManager->generateMissingForProduct($product); $channels = $this->channelRepository->getFullChannels(); $locales = $this->userContext->getUserLocales(); $filteredLocales = $this->collectionFilter->filterCollection($locales, 'pim.internal_api.locale.view'); $completenesses = $this->completenessManager->getProductCompleteness($product, $channels, $filteredLocales, $this->userContext->getCurrentLocale()->getCode()); return new JsonResponse($this->completenessNormalizer->normalize($completenesses, 'internal_api')); }
/** * {@inheritdoc} */ public function apply(DatasourceInterface $datasource, $field, $direction) { $qb = $datasource->getQueryBuilder(); $groupId = $this->requestParams->get('currentGroup', null); if (!$groupId) { throw new \LogicException('The current product group must be configured'); } $field = 'in_group_' . $groupId; $pqb = $this->repository->getProductQueryBuilder($qb); $pqb->addFieldSorter($field, $direction); }
/** * @return array */ protected function prepareParameters() { $queryParameters = parent::prepareParameters(); $variantGroupId = $queryParameters['currentGroup']; if (null !== $variantGroupId) { $productIds = $this->productRepository->getEligibleProductIdsForVariantGroup($variantGroupId); if (count($productIds) === 0) { $productIds = [0]; } } else { $productIds = [0]; } $queryParameters['productIds'] = $productIds; return $queryParameters; }
/** * Inject current product in the datagrid configuration */ protected function addCurrentProduct() { $path = $this->getSourcePath(self::CURRENT_PRODUCT_KEY); $id = $this->requestParams->get('product', null); $product = null !== $id ? $this->productRepository->findOneByWithValues($id) : null; $this->configuration->offsetSetByPath($path, $product); }
/** * {@inheritdoc} */ protected function findEntity($class, array $data) { if (!$this->identifierAttribute) { throw new MissingIdentifierException(); } return $this->productRepository->findOneByIdentifier($data[$this->identifierAttribute->getCode()]); }
/** * {@inheritdoc} */ public function read() { $this->documentManager->clear(); if (!$this->executed) { $this->executed = true; if (!is_object($this->channel)) { $this->channel = $this->channelManager->getChannelByCode($this->channel); } if ($this->missingCompleteness) { $this->completenessManager->generateMissingForChannel($this->channel); } $this->query = $this->repository->buildByChannelAndCompleteness($this->channel)->getQuery(); $this->products = $this->getQuery()->execute(); // MongoDB Cursor are not positioned on first element (whereas ArrayIterator is) // as long as getNext() hasn't be called $this->products->getNext(); } $result = $this->products->current(); if ($result) { $this->metricConverter->convert($result, $this->channel); $this->stepExecution->incrementSummaryInfo('read'); $this->products->next(); } return $result; }
/** * Get matching products for variant group * * @param GroupInterface $variantGroup the variant group * * @return ProductInterface[] */ protected function getMatchingProductsForVariantGroup(GroupInterface $variantGroup) { if (!$variantGroup->getId()) { return []; } return $this->repository->findAllForVariantGroup($variantGroup); }
/** * {@inheritdoc} */ protected function quickExport() { $productIds = $this->massActionDispatcher->dispatch($this->request); $fieldsList = $this->fieldsBuilder->getFieldsList($productIds); $attributeIds = $this->fieldsBuilder->getAttributeIds(); $context = $this->getContext() + ['fields' => $fieldsList]; // batch output to avoid memory leak $offset = 0; $batchSize = 100; while ($productsList = array_slice($productIds, $offset, $batchSize)) { $results = $this->productRepository->getFullProducts($productsList, $attributeIds); echo $this->serializer->serialize($results, $this->getFormat(), $context); $offset += $batchSize; flush(); } }
/** * 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->productRepository->findOneByWithValues($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->productRepository->findOneByWithValues($productId); return $product; }
/** * @param array $configuration */ public function execute(array $configuration) { $actions = $configuration['actions']; $variantGroupCode = $actions['value']; $variantGroup = $this->groupRepository->findOneByIdentifier($variantGroupCode); $axisAttributeCodes = $this->getAxisAttributeCodes($variantGroup); $eligibleProductIds = $this->productRepository->getEligibleProductIdsForVariantGroup($variantGroup->getId()); $cursor = $this->getProductsCursor($configuration['filters']); $paginator = $this->paginatorFactory->createPaginator($cursor); list($productAttributeAxis, $acceptedIds) = $this->filterDuplicateAxisCombinations($paginator, $eligibleProductIds, $axisAttributeCodes); $excludedIds = $this->addSkippedMessageForDuplicatedProducts($productAttributeAxis); $acceptedIds = array_diff($acceptedIds, $excludedIds); $configuration['filters'] = [['field' => 'id', 'operator' => 'IN', 'value' => $acceptedIds]]; if (0 === count($acceptedIds)) { $configuration = null; } $this->setJobConfiguration(json_encode($configuration)); }
/** * Find a product by its id or return a 404 response * * @param string $id the product id * * @throws NotFoundHttpException * * @return ProductInterface */ protected function findProductOr404($id) { $product = $this->productRepository->findOneByWithValues($id); $product = $this->objectFilter->filterObject($product, 'pim.internal_api.product.view') ? null : $product; if (!$product) { throw new NotFoundHttpException(sprintf('Product with id %s could not be found.', $id)); } return $product; }
/** * {@inheritdoc} */ public function process($group) { $this->form->setData($group); if ($this->request->isMethod('POST')) { // TODO : how to fix this ? Load products when ODM storage is used to enable validation if (null === $group->getProducts()) { $products = $this->productRepository->findAllForGroup($group)->toArray(); $group->setProducts($products); } $this->form->submit($this->request); if ($this->form->isValid()) { $this->onSuccess($group); return true; } elseif ($group->getType()->isVariant() && $group->getId()) { $products = $this->productRepository->findAllForVariantGroup($group); $group->setProducts($products); } } return false; }
/** * 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->productRepository->findOneByWithValues($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 []; } $matchingProducts = $this->repository->findAllForVariantGroup($variantGroup, $criteria); if ($entity) { $matchingProducts = array_filter($matchingProducts, function ($product) use($entity) { return $product->getId() !== $entity->getId(); }); } return $matchingProducts; }
/** * Get next products batch from DB * * @return \ArrayIterator */ protected function getNextProducts() { $this->entityManager->clear(); $products = null; if (null === $this->ids) { $this->ids = $this->getIds(); } $currentIds = array_slice($this->ids, $this->offset, $this->limit); if (!empty($currentIds)) { $items = $this->repository->findByIds($currentIds); $products = new \ArrayIterator($items); $this->offset += $this->limit; } return $products; }
/** * 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->productRepository->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] = ""; } } } } } }
/** * {@inheritdoc} */ public function collect() { return ['nb_channels' => $this->channelRepository->countAll(), 'nb_products' => $this->productRepository->countAll(), 'nb_attributes' => $this->attributeRepository->countAll(), 'nb_locales' => $this->localeRepository->countAllActivated(), 'nb_families' => $this->familyRepository->countAll(), 'nb_users' => $this->userRepository->countAll()]; }
/** * Prepare available attribute ids * * @param array $productIds */ protected function prepareAvailableAttributeIds($productIds) { $this->attributeIds = $this->productRepository->getAvailableAttributeIdsToExport($productIds); }
/** * Returns an array containing a limited number of product groups, and the total number of products * * @param GroupInterface $group * @param int $maxResults * * @deprecated will be removed in 1.5 * * @return array */ public function getProductList(GroupInterface $group, $maxResults) { $products = $this->productRepository->getProductsByGroup($group, $maxResults); $count = $this->productRepository->getProductCountByGroup($group); return ['products' => $products, 'productCount' => $count]; }
/** * {@inheritdoc} */ public function apply(DatasourceInterface $datasource, $field, $direction) { $qb = $datasource->getQueryBuilder(); $pqb = $this->repository->getProductQueryBuilder($qb); $pqb->addFieldSorter('family', $direction); }
/** * Check if a product value with a specific value already exists * * @param ProductValueInterface $value * * @return bool * * @deprecated will be removed in 1.5, please use ProductRepositoryInterface::valueExists */ public function valueExists(ProductValueInterface $value) { return $this->productRepository->valueExists($value); }
function it_does_not_validate_with_empty_value(ProductRepositoryInterface $productRepository, ProductValueInterface $value, ExecutionContextInterface $context, Constraint $constraint) { $productRepository->valueExists($value)->shouldNotBeCalled(); $context->buildViolation(Argument::any())->shouldNotBeCalled(); $this->validate("", $constraint)->shouldReturn(null); }