コード例 #1
0
 /**
  * {@inheritdoc}
  */
 public function getVariant(ProductInterface $subject)
 {
     if ($subject->getVariants()->isEmpty()) {
         return null;
     }
     return $subject->getVariants()->first();
 }
コード例 #2
0
 function it_does_not_add_violation_if_conflictual_product_and_validated_one_are_the_same($productRepository, ProductInterface $product, $context)
 {
     $constraint = new ProductUnique(array('property' => 'name', 'message' => 'Product with given name already exists'));
     $product->getName()->willReturn('iPhone');
     $productRepository->findOneBy(array('name' => 'iPhone'))->shouldBeCalled()->willReturn($product);
     $context->addViolationAt(Argument::any())->shouldNotBeCalled();
     $this->validate($product, $constraint);
 }
コード例 #3
0
 function it_transforms_product_associations_to_array(ProductAssociationInterface $productAssociation, ProductAssociationTypeInterface $productAssociationType, ProductInterface $firstAssociatedProduct, ProductInterface $secondAssociatedProduct)
 {
     $productAssociation->getType()->willReturn($productAssociationType);
     $productAssociation->getAssociatedProducts()->willReturn(new ArrayCollection([$firstAssociatedProduct->getWrappedObject(), $secondAssociatedProduct->getWrappedObject()]));
     $firstAssociatedProduct->getId()->willReturn(7);
     $secondAssociatedProduct->getId()->willReturn(21);
     $productAssociationType->getCode()->willReturn('accessories');
     $this->transform([$productAssociation])->shouldReturn(['accessories' => '7,21']);
 }
コード例 #4
0
 function it_assigns_prototype_attributes_and_options_to_product($attributeValueRepository, PrototypeInterface $prototype, ProductInterface $product, AttributeInterface $attribute, AttributeValueInterface $attributeValue, OptionInterface $option)
 {
     $prototype->getAttributes()->willReturn(array($attribute))->shouldBeCalled();
     $prototype->getOptions()->willReturn(array($option))->shouldBeCalled();
     $attributeValueRepository->createNew()->shouldBeCalled()->willReturn($attributeValue);
     $attributeValue->setAttribute($attribute)->shouldBeCalled();
     $product->addAttribute($attributeValue)->shouldBeCalled();
     $product->addOption($option)->shouldBeCalled();
     $this->build($prototype, $product);
 }
コード例 #5
0
 function it_add_violation_if_product_is_simple_and_code_has_been_used_in_other_product_variant(ExecutionContextInterface $context, ProductInterface $product, ProductVariantInterface $existingProductVariant, ProductVariantRepositoryInterface $productVariantRepository, ConstraintViolationBuilderInterface $constraintViolationBuilder)
 {
     $constraint = new UniqueSimpleProductCode(['message' => 'Simple product code has to be unique']);
     $product->isSimple()->willReturn(true);
     $product->getCode()->willReturn('AWESOME_PRODUCT');
     $context->buildViolation('Simple product code has to be unique', Argument::cetera())->willReturn($constraintViolationBuilder);
     $constraintViolationBuilder->atPath('code')->shouldBeCalled()->willReturn($constraintViolationBuilder);
     $constraintViolationBuilder->addViolation()->shouldBeCalled()->willReturn($constraintViolationBuilder);
     $productVariantRepository->findOneBy(['code' => 'AWESOME_PRODUCT'])->willReturn($existingProductVariant);
     $this->validate($product, $constraint);
 }
コード例 #6
0
ファイル: PrototypeBuilder.php プロジェクト: bcremer/Sylius
 /**
  * {@inheritdoc}
  */
 public function build(PrototypeInterface $prototype, ProductInterface $product)
 {
     foreach ($prototype->getAttributes() as $attribute) {
         $attributeValue = $this->attributeValueRepository->createNew();
         $attributeValue->setAttribute($attribute);
         $product->addAttribute($attributeValue);
     }
     foreach ($prototype->getOptions() as $option) {
         $product->addOption($option);
     }
 }
コード例 #7
0
ファイル: ProductFactorySpec.php プロジェクト: Spomky/Sylius
 function it_creates_new_product_from_archetype(FactoryInterface $factory, ProductInterface $product, RepositoryInterface $archetypeRepository, ArchetypeBuilderInterface $archetypeBuilder, ArchetypeInterface $archetype, VariantInterface $variant, FactoryInterface $variantFactory)
 {
     $variantFactory->createNew()->willReturn($variant);
     $variant->setMaster(true)->shouldBeCalled();
     $product->setMasterVariant($variant)->shouldBeCalled();
     $factory->createNew()->willReturn($product);
     $archetypeRepository->findOneBy(array('code' => 'book'))->willReturn($archetype);
     $product->setArchetype($archetype)->shouldBeCalled();
     $archetypeBuilder->build($product)->shouldBeCalled();
     $this->createFromArchetype('book')->shouldReturn($product);
 }
コード例 #8
0
 /**
  * @param ProductOptionValueInterface[] $optionValues
  *
  * @return ProductVariantInterface|null
  */
 private function matches(array $optionValues)
 {
     foreach ($this->product->getVariants() as $variant) {
         foreach ($optionValues as $optionValue) {
             if (null === $optionValue || !$variant->hasOptionValue($optionValue)) {
                 continue 2;
             }
         }
         return $variant;
     }
     return null;
 }
コード例 #9
0
 /**
  * {@inheritdoc}
  */
 public function checkParity(ProductVariantInterface $variant, ProductInterface $product)
 {
     foreach ($product->getVariants() as $existingVariant) {
         // This check is require, because this function has to look for any other different variant with same option values set
         if ($variant === $existingVariant || count($variant->getOptionValues()) !== count($product->getOptions())) {
             continue;
         }
         if ($this->matchOptions($variant, $existingVariant)) {
             return true;
         }
     }
     return false;
 }
コード例 #10
0
ファイル: ProductBuilder.php プロジェクト: kongqingfu/Sylius
 /**
  * {@inheritdoc}
  */
 public function addAttribute($name, $value, $presentation = null)
 {
     $attribute = $this->attributeRepository->findOneBy(array('name' => $name));
     if (null === $attribute) {
         $attribute = $this->attributeRepository->createNew();
         $attribute->setName($name);
         $attribute->setPresentation($presentation ?: $name);
         $this->productManager->persist($attribute);
         $this->productManager->flush($attribute);
     }
     $attributeValue = $this->attributeValueRepository->createNew();
     $attributeValue->setAttribute($attribute);
     $attributeValue->setValue($value);
     $this->product->addAttribute($attributeValue);
     return $this;
 }
コード例 #11
0
 function it_generates_variants_for_every_possible_permutation_of_an_objects_options_and_option_values(ProductInterface $productVariable, ProductOptionInterface $colorOption, ProductOptionInterface $sizeOption, ProductOptionValueInterface $blackColor, ProductOptionValueInterface $largeSize, ProductOptionValueInterface $mediumSize, ProductOptionValueInterface $redColor, ProductOptionValueInterface $smallSize, ProductOptionValueInterface $whiteColor, ProductVariantFactoryInterface $productVariantFactory, ProductVariantInterface $permutationVariant)
 {
     $productVariable->hasOptions()->willReturn(true);
     $productVariable->getOptions()->willReturn([$colorOption, $sizeOption]);
     $colorOption->getValues()->willReturn([$blackColor, $whiteColor, $redColor]);
     $sizeOption->getValues()->willReturn([$smallSize, $mediumSize, $largeSize]);
     $blackColor->getId()->willReturn('black1');
     $whiteColor->getId()->willReturn('white2');
     $redColor->getId()->willReturn('red3');
     $smallSize->getId()->willReturn('small4');
     $mediumSize->getId()->willReturn('medium5');
     $largeSize->getId()->willReturn('large6');
     $productVariantFactory->createForProduct($productVariable)->willReturn($permutationVariant);
     $permutationVariant->addOptionValue(Argument::type(ProductOptionValueInterface::class))->shouldBeCalled();
     $productVariable->addVariant($permutationVariant)->shouldBeCalled();
     $this->generate($productVariable);
 }
コード例 #12
0
 /**
  * {@inheritdoc}
  */
 public function generate(ProductInterface $product)
 {
     Assert::true($product->hasOptions(), 'Cannot generate variants for an object without options.');
     $optionSet = [];
     $optionMap = [];
     foreach ($product->getOptions() as $key => $option) {
         foreach ($option->getValues() as $value) {
             $optionSet[$key][] = $value->getId();
             $optionMap[$value->getId()] = $value;
         }
     }
     $permutations = $this->setBuilder->build($optionSet);
     foreach ($permutations as $permutation) {
         $variant = $this->createVariant($product, $optionMap, $permutation);
         $product->addVariant($variant);
     }
 }
コード例 #13
0
 /**
  * @param ProductVariantInterface  $variant
  * @param ProductInterface $variable
  *
  * @return bool
  */
 private function matches(ProductVariantInterface $variant, ProductInterface $variable)
 {
     foreach ($variable->getVariants() as $existingVariant) {
         if ($variant === $existingVariant || !$variant->getOptionValues()->count()) {
             continue;
         }
         $matches = true;
         foreach ($variant->getOptionValues() as $optionValue) {
             if (!$existingVariant->hasOptionValue($optionValue)) {
                 $matches = false;
             }
         }
         if ($matches) {
             return true;
         }
     }
     return false;
 }
コード例 #14
0
 /**
  * {@inheritdoc}
  */
 public function generate(ProductInterface $variable)
 {
     if (!$variable->hasOptions()) {
         throw new \InvalidArgumentException('Cannot generate variants for an object without options.');
     }
     $optionSet = [];
     $optionMap = [];
     foreach ($variable->getOptions() as $key => $option) {
         foreach ($option->getValues() as $value) {
             $optionSet[$key][] = $value->getId();
             $optionMap[$value->getId()] = $value;
         }
     }
     $permutations = $this->setBuilder->build($optionSet);
     foreach ($permutations as $permutation) {
         $variant = $this->createVariant($variable, $optionMap, $permutation);
         $variable->addVariant($variant);
     }
 }
コード例 #15
0
ファイル: ShowPage.php プロジェクト: ReissClothing/Sylius
 /**
  * {@inheritdoc}
  */
 public function hasProductOutOfStockValidationMessage(ProductInterface $product)
 {
     $message = sprintf('%s does not have sufficient stock.', $product->getName());
     if (!$this->hasElement('validation-errors')) {
         return false;
     }
     return $this->getElement('validation-errors')->getText() === $message;
 }
コード例 #16
0
 function it_does_not_reverse_transform_variable_with_variants_if_options_are_missing(ProductInterface $variable, ProductVariantInterface $variant)
 {
     $variable->getVariants()->willReturn([$variant]);
     $this->reverseTransform([null])->shouldReturn(null);
 }
コード例 #17
0
ファイル: CartContext.php プロジェクト: sylius/sylius
 /**
  * @Given /^(this product) should have ([^"]+) "([^"]+)"$/
  */
 public function thisItemShouldHaveOptionValue(ProductInterface $product, $optionName, $optionValue)
 {
     Assert::true($this->summaryPage->hasItemWithOptionValue($product->getName(), $optionName, $optionValue), sprintf('Product in cart "%s" should have option %s with value %s, but it has not.', $product->getName(), $optionName, $optionValue));
 }
コード例 #18
0
 function it_returns_null_if_first_variant_is_not_defined(Collection $variants, ProductInterface $product)
 {
     $product->getVariants()->willReturn($variants);
     $variants->isEmpty()->willReturn(true);
     $this->getVariant($product)->shouldReturn(null);
 }