PHP Repository\IdentifiableObjectRepositoryInterface类代码示例

 function it_builds_form(FormBuilderInterface $builder, IdentifiableObjectRepositoryInterface $repository, DataTransformerInterface $transformer, $transformerFactory)
 {
     $options = ['repository' => $repository->getWrappedObject(), 'multiple' => false];
     $transformerFactory->create($repository, ['multiple' => false])->willReturn($transformer);
     $builder->addViewTransformer($transformer, true)->shouldBeCalled();
     $this->buildForm($builder, $options);
 }

 function let(IdentifiableObjectRepositoryInterface $repository, \stdClass $entity)
 {
     $entity->code = 'foo';
     $repository->getIdentifierProperties()->willReturn(['code']);
     $repository->findOneByIdentifier('foo')->willReturn($entity);
     $this->beConstructedWith($repository, ['multiple' => false]);
 }

 /**
  * Find an object according to its identifiers from a repository.
  *
  * @param IdentifiableObjectRepositoryInterface $repository the repository to search inside
  * @param array                                 $data       the data that is currently processed
  *
  * @throws MissingIdentifierException in case the processed data do not allow to retrieve an object
  *                                    by its identifiers properly
  *
  * @return object|null
  */
 protected function findObject(IdentifiableObjectRepositoryInterface $repository, array $data)
 {
     $properties = $repository->getIdentifierProperties();
     $references = [];
     foreach ($properties as $property) {
         if (!isset($data[$property])) {
             throw new MissingIdentifierException(sprintf('Missing identifier column "%s". Columns found: %s.', $property, implode(', ', array_keys($data))));
         }
         $references[] = $data[$property];
     }
     return $repository->findOneByIdentifier(implode('.', $references));
 }

 /**
  * Find an object according to its identifiers from a repository.
  *
  * @param IdentifiableObjectRepositoryInterface $repository the repository to search inside
  * @param array                                 $data       the data that is currently processed
  *
  * @throws MissingIdentifierException in case the processed data do not allow to retrieve an object
  *                                    by its identifiers properly
  *
  * @return object|null
  */
 protected function findObject(IdentifiableObjectRepositoryInterface $repository, array $data)
 {
     $properties = $repository->getIdentifierProperties();
     $references = [];
     foreach ($properties as $property) {
         if (!isset($data[$property])) {
             throw new MissingIdentifierException();
         }
         $references[] = $data[$property];
     }
     return $repository->findOneByIdentifier(implode('.', $references));
 }

 function it_returns_no_products_when_they_all_are_duplicated($productRepository, $paginatorFactory, $stepExecution, ProductInterface $product, $pqbFactory, ProductQueryBuilder $pqb, ProductQueryBuilder $pqb2, Cursor $cursor, Cursor $cursor2, JobParameters $jobParameters, IdentifiableObjectRepositoryInterface $groupRepository, GroupInterface $variantGroup, AttributeInterface $axe, PaginatorInterface $paginator)
 {
     $configuration = ['filters' => [['field' => 'id', 'operator' => 'IN', 'value' => [12, 13]]], 'actions' => ['value' => 'variantGroupCode']];
     $stepExecution->getJobParameters()->willReturn($jobParameters);
     $jobParameters->get('filters')->willReturn($configuration['filters']);
     $jobParameters->get('actions')->willReturn($configuration['actions']);
     $groupRepository->findOneByIdentifier('variantGroupCode')->willReturn($variantGroup);
     $variantGroup->getAxisAttributes()->willReturn([$axe]);
     $variantGroup->getId()->willReturn(42);
     $axe->getCode()->willReturn('axe');
     $productRepository->getEligibleProductIdsForVariantGroup(42)->willReturn([]);
     $pqbFactory->create(['filters' => $configuration['filters']])->willReturn($pqb);
     $pqb->execute()->willReturn($cursor);
     $paginatorFactory->createPaginator($cursor)->willReturn($paginator);
     $pqbFactory->create(['filters' => [['field' => 'id', 'operator' => 'IN', 'value' => ['']]]])->willReturn($pqb2);
     $pqb2->execute()->willReturn($cursor2);
     $this->initialize();
     $this->read()->shouldReturn(null);
 }

 /**
  * @param string $code
  *
  * @return string
  */
 public function getAttributeLabelFromCode($code)
 {
     if (null !== ($attribute = $this->attributeRepository->findOneByIdentifier($code))) {
         return (string) $attribute;
     }
     return $code;
 }

 /**
  * {@inheritdoc}
  */
 public function transform($model)
 {
     if (null === $model) {
         return null;
     }
     if (count($this->repository->getIdentifierProperties()) > 1) {
         throw new \InvalidArgumentException('Cannot transform object with multiple identifiers');
     }
     $identifierProperty = $this->repository->getIdentifierProperties()[0];
     $propertyAccessor = PropertyAccess::createPropertyAccessor();
     if ($this->multiple) {
         if (!is_array($model)) {
             throw new UnexpectedTypeException($model, 'array');
         }
         $identifiers = [];
         foreach ($model as $object) {
             $identifiers[] = $propertyAccessor->getValue($object, $identifierProperty);
         }
         return $identifiers;
     }
     if (!is_object($model)) {
         throw new UnexpectedTypeException($model, 'object');
     }
     return $propertyAccessor->getValue($model, $identifierProperty);
 }

 /**
  * Find a variant group by its id or return a 404 response
  *
  * @param string $code
  *
  * @throws NotFoundHttpException
  *
  * @return GroupInterface
  */
 protected function findVariantGroupOr404($code)
 {
     $group = $this->groupRepository->findOneByIdentifier($code);
     if (null === $group || false === $group->getType()->isVariant()) {
         throw new NotFoundHttpException(sprintf('Variant group with id %d could not be found.', $id));
     }
     return $group;
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : "family_code"
  */
 public function setFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     if (null !== $data) {
         $family = $this->familyRepository->findOneByIdentifier($data);
         if (null === $family) {
             throw InvalidArgumentException::expected($field, 'existing family code', 'setter', 'family', $data);
         }
         $product->setFamily($family);
     } else {
         $product->setFamily(null);
     }
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : ["category_code", "another_category_code"]
  */
 public function removeFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     $categories = [];
     foreach ($data as $categoryCode) {
         $category = $this->categoryRepository->findOneByIdentifier($categoryCode);
         if (null === $category) {
             throw InvalidArgumentException::expected($field, 'existing category code', 'remover', 'category', $categoryCode);
         }
         $categories[] = $category;
     }
     foreach ($categories as $categoryToRemove) {
         $product->removeCategory($categoryToRemove);
     }
 }

 /**
  * @param string $code
  *
  * @return Group|null
  */
 protected function findGroup($code)
 {
     $group = $this->groupRepository->findOneByIdentifier($code);
     if (null === $group) {
         throw new \InvalidArgumentException(sprintf('Group %s was not found', $code));
     }
     return $group;
 }

 /**
  * {@inheritdoc}
  */
 public function sort(array $columns, array $context = [])
 {
     $identifier = $this->productRepository->getIdentifierProperties()[0];
     if (isset($context['filters']['structure']['attributes']) && !empty($context['filters']['structure']['attributes'])) {
         $rawColumns = array_merge([$identifier], $this->firstDefaultColumns, array_map(function ($associationType) {
             return $associationType->getCode();
         }, $this->associationTypeRepository->findAll()), $context['filters']['structure']['attributes']);
         $sortedColumns = [];
         foreach ($rawColumns as $columnCode) {
             $sortedColumns = array_merge($sortedColumns, array_filter($columns, function ($columnCandidate) use($columnCode) {
                 return 0 !== preg_match(sprintf('/^%s(-.*)*/', $columnCode), $columnCandidate);
             }));
         }
         return $sortedColumns;
     }
     array_unshift($this->firstDefaultColumns, $identifier);
     return parent::sort($columns);
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : ["group_code"]
  */
 public function addFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     $groups = [];
     foreach ($data as $groupCode) {
         $group = $this->groupRepository->findOneByIdentifier($groupCode);
         if (null === $group) {
             throw InvalidArgumentException::expected($field, 'existing group code', 'adder', 'groups', $groupCode);
         } elseif ($group->getType()->isVariant()) {
             throw InvalidArgumentException::expected($field, 'non variant group code', 'adder', 'groups', $groupCode);
         } else {
             $groups[] = $group;
         }
     }
     foreach ($groups as $group) {
         $product->addGroup($group);
     }
 }

 /**
  * @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));
 }

 /**
  * @param AssociationInterface $association
  * @param array                $groupsCodes
  */
 protected function setAssociatedGroups(AssociationInterface $association, $groupsCodes)
 {
     foreach ($groupsCodes as $groupCode) {
         $associatedGroup = $this->groupRepository->findOneByIdentifier($groupCode);
         if (!$associatedGroup) {
             throw InvalidArgumentException::expected('associations', 'existing group code', 'setter', 'association', $groupCode);
         }
         $association->addGroup($associatedGroup);
     }
 }