function it_provides_formatted_batch_config_for_the_job(FamilyInterface $mugs) { $mugs->getCode()->willReturn('amazing_mugs'); $this->setFamily($mugs); $this->setFilters([['id', 'IN', ['1003', '1002']]]); $this->getBatchConfig()->shouldReturn('{\\"filters\\":[[\\"id\\",\\"IN\\",[\\"1003\\",\\"1002\\"]]],\\"actions\\":[{\\"field\\":\\"family\\",\\"value\\":\\"amazing_mugs\\"}]}'); }
function it_adds_missing_product_values_from_family_on_new_product($valuesResolver, FamilyInterface $family, ProductInterface $product, AttributeInterface $sku, AttributeInterface $name, AttributeInterface $desc, ProductValueInterface $skuValue) { $sku->getCode()->willReturn('sku'); $sku->getAttributeType()->willReturn('pim_catalog_identifier'); $sku->isLocalizable()->willReturn(false); $sku->isScopable()->willReturn(false); $name->getCode()->willReturn('name'); $name->getAttributeType()->willReturn('pim_catalog_text'); $name->isLocalizable()->willReturn(true); $name->isScopable()->willReturn(false); $desc->getCode()->willReturn('description'); $desc->getAttributeType()->willReturn('pim_catalog_text'); $desc->isLocalizable()->willReturn(true); $desc->isScopable()->willReturn(true); // get expected attributes $product->getAttributes()->willReturn([$sku]); $family->getAttributes()->willReturn([$sku, $name, $desc]); $product->getFamily()->willReturn($family); // get eligible values $valuesResolver->resolveEligibleValues(['sku' => $sku, 'name' => $name, 'description' => $desc], null, null)->willReturn([['attribute' => 'sku', 'type' => 'pim_catalog_identifier', 'locale' => null, 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => null], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'print'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'print']]); // get existing values $skuValue->getAttribute()->willReturn($sku); $skuValue->getLocale()->willReturn(null); $skuValue->getScope()->willReturn(null); $product->getValues()->willReturn([$skuValue]); // add 6 new values : 4 desc (locales x scopes) + 2 name (locales $product->addValue(Argument::any())->shouldBeCalledTimes(6); $this->addMissingProductValues($product); }
function it_provides_formatted_batch_config_for_the_job(FamilyInterface $mugs) { $mugs->getCode()->willReturn('amazing_mugs'); $this->setFamily($mugs); $this->setFilters([['id', 'IN', ['1003', '1002']]]); $this->getBatchConfig()->shouldReturn(['filters' => [['id', 'IN', ['1003', '1002']]], 'actions' => [['field' => 'family', 'value' => 'amazing_mugs']]]); }
function it_normalizes_the_properties_of_the_product($filter, $serializer, ProductInterface $product, AttributeInterface $attribute, ProductValueInterface $value, FamilyInterface $family, ArrayCollection $values, \ArrayIterator $iterator, ProductValueInterface $identifier) { $values->getIterator()->willReturn($iterator); $family->getCode()->willReturn('my_family'); $product->getFamily()->willReturn($family); $product->getGroupCodes()->willReturn([]); $product->getVariantGroup()->willReturn(null); $product->getCategoryCodes()->willReturn([]); $product->isEnabled()->willReturn(true); $value->getAttribute()->willReturn($attribute); $attribute->getCode()->willReturn('name'); $product->getIdentifier()->willReturn($identifier); $identifier->getData()->willReturn('my_code'); $product->getValues()->willReturn($values); $filter->filterCollection($values, 'pim.transform.product_value.structured', Argument::type('array'))->shouldBeCalled()->willReturn($values); $iterator->rewind()->willReturn(null); $valueCount = 1; $iterator->valid()->will(function () use(&$valueCount) { return $valueCount-- > 0; }); $iterator->current()->willReturn($value); $iterator->next()->willReturn(null); $context = ['filter_types' => ['pim.transform.product_value.structured']]; $serializer->normalize($value, 'standard', $context)->willReturn(['locale' => null, 'scope' => null, 'value' => 'foo']); $created = new \DateTime('2010-06-23'); $product->getCreated()->willReturn($created); $serializer->normalize($created, 'standard')->willReturn('2010-06-23T00:00:00+01:00'); $updated = new \DateTime('2010-06-23 23:00:00'); $product->getUpdated()->willReturn($updated); $serializer->normalize($updated, 'standard')->willReturn('2010-06-23T23:00:00+01:00'); $this->normalize($product, 'standard', $context)->shouldReturn(['identifier' => 'my_code', 'family' => 'my_family', 'groups' => [], 'variant_group' => null, 'categories' => [], 'enabled' => true, 'values' => ['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']]], 'created' => '2010-06-23T00:00:00+01:00', 'updated' => '2010-06-23T23:00:00+01:00']); }
function it_normalizes_family($normalizer, FamilyInterface $family, AttributeInterface $sku) { $sku->getCode()->willReturn('sku'); $family->getCode()->willReturn('mongo'); $family->getAttributeAsLabel()->willReturn($sku); $normalizer->normalize($family, 'mongodb_json', [])->willReturn(['label' => 'translations']); $this->normalize($family, 'mongodb_json', [])->shouldReturn(['code' => 'mongo', 'label' => 'translations', 'attributeAsLabel' => 'sku']); }
public function let(AttributeRequirementFactory $requirementFactory, LifecycleEventArgs $eventArgs, ChannelInterface $channel, EntityManagerInterface $entityManager, EntityRepository $repository, FamilyInterface $family) { $this->beConstructedWith($requirementFactory); $eventArgs->getEntity()->willReturn($channel); $eventArgs->getEntityManager()->willReturn($entityManager); $entityManager->getRepository(Argument::exact('PimCatalogBundle:Family'))->willReturn($repository); $repository->findAll()->willReturn([$family]); $family->getAttributes()->willReturn([]); }
function it_sets_attribute_when_new_value_is_different_from_product_value($builder, AttributeInterface $attribute, ProductInterface $product, FamilyInterface $family, ProductValue $productValue) { $family->getAttributeCodes()->willReturn(['sku', 'is_color']); $product->getFamily()->willReturn($family); $attribute->getCode()->willReturn('is_color'); $product->getValue('is_color', null, null)->willReturn(null); $builder->addProductValue($product, $attribute, null, null)->willReturn($productValue); $this->setAttributeData($product, $attribute, true, ['locale' => null, 'scope' => null]); }
function it_returns_filters_on_family_grid($massActionDispatcher, Request $request, FamilyInterface $family1, FamilyInterface $family2) { $request->get('gridName')->willReturn('family-grid'); $massActionDispatcher->dispatch($request)->willReturn([$family1, $family2]); $family1->getId()->willReturn(45); $family2->getId()->willReturn(70); $massActionDispatcher->getRawFilters($request)->shouldNotBeCalled(); $this->adapt($request)->shouldReturn([['field' => 'id', 'operator' => 'IN', 'value' => [45, 70]]]); }
/** * {@inheritdoc} */ public function getFullFamilies(FamilyInterface $family = null, ChannelInterface $channel = null) { $qb = $this->createQueryBuilder('f')->select('f, c, l, r, a, cu')->join('f.requirements', 'r')->join('r.attribute', 'a')->join('r.channel', 'c')->join('c.locales', 'l')->join('c.currencies', 'cu')->where('r.required = 1'); if (null !== $channel) { $qb->andWhere('r.channel = :channel')->setParameter('channel', $channel); } if (null !== $family) { $qb->andWhere('f.id = :familyId')->setParameter('familyId', $family->getId()); } return $qb->getQuery()->getResult(); }
function it_saves_a_family_and_does_not_schedule($completenessManager, $optionsResolver, $objectManager, $eventDispatcher, FamilyInterface $family) { $family->getCode()->willReturn('my_code'); $optionsResolver->resolveSaveOptions(['schedule' => false])->shouldBeCalled()->willReturn(['flush' => true, 'schedule' => false]); $objectManager->persist($family)->shouldBeCalled(); $objectManager->flush()->shouldBeCalled(); $completenessManager->scheduleForFamily($family)->shouldNotBeCalled($family); $eventDispatcher->dispatch(StorageEvents::PRE_SAVE, Argument::cetera())->shouldBeCalled(); $eventDispatcher->dispatch(StorageEvents::POST_SAVE, Argument::cetera())->shouldBeCalled(); $this->save($family, ['schedule' => false]); }
function it_builds_the_view(FormView $formView, FormInterface $form, FamilyRepositoryInterface $familyRepository, FamilyInterface $familyMugs, FamilyInterface $familyWebcams) { $options['repository'] = $familyRepository; $options['multiple'] = true; $form->getData()->willReturn('mugs,webcams'); $familyRepository->findBy(["code" => ["mugs", "webcams"]])->willReturn([$familyMugs, $familyWebcams]); $familyMugs->getLabel()->willReturn('Mugs'); $familyWebcams->getLabel()->willReturn('Webcams'); $familyMugs->getCode()->willReturn('mugs'); $familyWebcams->getCode()->willReturn('webcams'); $this->buildView($formView, $form, $options); }
function it_does_not_validate_families_with_missing_identifier_requirements($attributeRepository, $channelRepository, $context, $minimumRequirements, FamilyInterface $family, AttributeRequirementInterface $requirementEcommerce, AttributeRequirementInterface $requirementMobile, ConstraintViolationBuilderInterface $violation) { $family->getAttributeRequirements()->willReturn([$requirementEcommerce, $requirementMobile]); $attributeRepository->getIdentifierCode()->willReturn('sku'); $requirementEcommerce->getAttributeCode()->willReturn('sku'); $requirementEcommerce->getChannelCode()->willReturn('ecommerce'); $requirementMobile->getAttributeCode()->willReturn('sku'); $requirementMobile->getChannelCode()->willReturn('mobile'); $channelRepository->getChannelCodes()->willReturn(['ecommerce', 'mobile', 'print']); $family->getCode()->willReturn('familyCode'); $context->buildViolation(Argument::any(), Argument::any())->willReturn($violation)->shouldBeCalled(); $this->validate($family, $minimumRequirements); }
/** * @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; }
/** * Normalize the requirements * * @param FamilyInterface $family * * @return array */ protected function normalizeRequirements(FamilyInterface $family) { $required = []; foreach ($family->getAttributeRequirements() as $requirement) { $channelCode = $requirement->getChannel()->getCode(); if (!isset($required['requirements-' . $channelCode])) { $required['requirements-' . $channelCode] = []; } if ($requirement->isRequired()) { $required['requirements-' . $channelCode][] = $requirement->getAttribute()->getCode(); } } return $required; }
function it_saves_multiple_family($completenessManager, $objectManager, $eventDispatcher, FamilyInterface $family1, FamilyInterface $family2) { $family1->getCode()->willReturn('my_code1'); $family1->getCode()->willReturn('my_code2'); $objectManager->persist($family1)->shouldBeCalled(); $objectManager->persist($family2)->shouldBeCalled(); $completenessManager->scheduleForFamily($family1)->shouldBeCalled($family1); $completenessManager->scheduleForFamily($family2)->shouldBeCalled($family2); $objectManager->flush()->shouldBeCalled(); $eventDispatcher->dispatch(StorageEvents::PRE_SAVE_ALL, Argument::cetera())->shouldBeCalled(); $eventDispatcher->dispatch(StorageEvents::POST_SAVE_ALL, Argument::cetera())->shouldBeCalled(); $eventDispatcher->dispatch(StorageEvents::PRE_SAVE, Argument::cetera())->shouldBeCalledTimes(2); $eventDispatcher->dispatch(StorageEvents::POST_SAVE, Argument::cetera())->shouldBeCalledTimes(2); $this->saveAll([$family1, $family2]); }
/** * Schedule recalculation of completenesses for all product * of a family * * @param FamilyInterface $family */ public function scheduleForFamily(FamilyInterface $family) { if ($family->getId()) { $this->generator->scheduleForFamily($family); } }
/** * Sets the requirements for a channel * * @param string $class * @param FamilyInterface $family * @param string $channelCode * @param array $attributeCodes */ protected function setChannelRequirements($class, FamilyInterface $family, $channelCode, $attributeCodes) { foreach ($attributeCodes as $attributeCode) { $data = ['attribute' => $attributeCode, 'channel' => $channelCode, 'required' => true]; $requirement = $this->transformNestedEntity($class, 'requirements', $this->requirementClass, $data); if ($requirement->getAttribute() === null) { throw new \Exception(sprintf('The attribute "%s" used as requirement in family "%s" is not known', $attributeCode, $family->getCode())); } $family->addAttributeRequirement($requirement); } }
/** * {@inheritdoc} */ public function scheduleForFamily(FamilyInterface $family) { $productQb = $this->documentManager->createQueryBuilder($this->productClass); $productQb->update()->multiple(true)->field('family')->equals($family->getId())->field('completenesses')->unsetField()->field('normalizedData.completenesses')->unsetField()->getQuery()->execute(); }
/** * Normalizes a family * * @param FamilyInterface $family * * @return string */ protected function normalizeFamily(FamilyInterface $family = null) { return $family ? $family->getCode() : ''; }
/** * Normalizes a family * * @param FamilyInterface $family */ protected function normalizeFamily(FamilyInterface $family = null) { $this->results[self::FIELD_FAMILY] = $family ? $family->getCode() : ''; }
function it_is_not_attribute_removable_with_family_containing_attribute(AttributeInterface $attribute, FamilyInterface $family, ArrayCollection $familyAttributes) { $familyAttributes->contains($attribute)->willReturn(true); $family->getId()->willReturn(42); $family->getAttributes()->willReturn($familyAttributes); $this->setFamily($family); $this->isAttributeRemovable($attribute)->shouldReturn(false); }
function it_normalizes_product_with_price($filter, ProductInterface $product, AttributeInterface $priceAttribute, ProductValueInterface $price, Collection $prices, Collection $values, ProductPriceInterface $productPrice, FamilyInterface $family, SerializerInterface $serializer) { $family->getCode()->willReturn('shoes'); $priceAttribute->getCode()->willReturn('price'); $priceAttribute->getAttributeType()->willReturn('pim_catalog_price_collection'); $priceAttribute->isLocalizable()->willReturn(false); $priceAttribute->isScopable()->willReturn(false); $price->getAttribute()->willReturn($priceAttribute); $price->getData()->willReturn(null); $productPrice->getData()->willReturn("356.00"); $productPrice->getCurrency()->willReturn("EUR"); $prices->add($productPrice); $price->getPrices()->willReturn($prices); $product->getIdentifier()->willReturn($price); $product->getFamily()->willReturn($family); $product->isEnabled()->willReturn(true); $product->getGroupCodes()->willReturn(['group1', 'group2', 'variant_group_1']); $product->getCategoryCodes()->willReturn(['nice shoes', 'converse']); $product->getAssociations()->willReturn([]); $values->add($price); $product->getValues()->willReturn($values); $filter->filterCollection($values, 'pim.transform.product_value.flat', Argument::cetera())->willReturn([$price]); $serializer->normalize($price, 'flat', Argument::any())->willReturn(['price-EUR' => '356.00']); $this->normalize($product, 'flat', ['price-EUR' => ''])->shouldReturn(['price-EUR' => '356.00', 'family' => 'shoes', 'groups' => 'group1,group2,variant_group_1', 'categories' => 'nice shoes,converse', 'enabled' => 1]); }
function it_throws_an_exception_if_channel_not_found($channelRepository, $attributeRepository, AttributeInterface $attribute, FamilyInterface $family) { $data = ['code' => 'mycode', 'requirements' => ['mobile' => ['sku', 'name'], 'print' => ['sku', 'name', 'description']]]; $family->getAttributeRequirements()->willReturn([]); $family->setCode('mycode')->shouldBeCalled(); $attributeRepository->findOneByIdentifier('sku')->willReturn($attribute); $attributeRepository->findOneByIdentifier('name')->willReturn($attribute); $attributeRepository->findOneByIdentifier('description')->willReturn($attribute); $attributeRepository->findOneByIdentifier('price')->willReturn($attribute); $channelRepository->findOneByIdentifier('print')->willReturn(null); $channelRepository->findOneByIdentifier('mobile')->willReturn(null); $this->shouldThrow(new \InvalidArgumentException(sprintf('Channel with "%s" code does not exist', 'mobile')))->during('update', [$family, $data]); }
/** * {@inheritdoc} */ public function hasAttributeInFamily(AttributeInterface $attribute) { return null !== $this->family && $this->family->getAttributes()->contains($attribute); }
/** * {@inheritdoc} */ public function findAllIdsForFamily(FamilyInterface $family) { $qb = $this->createQueryBuilder('p')->hydrate(false)->field('family')->equals($family->getId())->select('_id'); $results = $qb->getQuery()->execute()->toArray(); return array_keys($results); }
/** * @param FamilyInterface $family * @param array $requirements * @param array $oldRequirements */ protected function removeRequirements(FamilyInterface $family, array $requirements, array $oldRequirements) { $checkRequirements = new ArrayCollection($requirements); foreach ($oldRequirements as $requirement) { if (!$checkRequirements->contains($requirement)) { $family->removeAttributeRequirement($requirement); } } }
/** * Normalize the requirements * * @param FamilyInterface $family * * @return array */ protected function normalizeRequirements(FamilyInterface $family) { $required = []; $flat = []; foreach ($family->getAttributeRequirements() as $requirement) { $channelCode = $requirement->getChannel()->getCode(); if (!isset($required['requirements-' . $channelCode])) { $required['requirements-' . $channelCode] = []; } if ($requirement->isRequired()) { $required['requirements-' . $channelCode][] = $requirement->getAttribute()->getCode(); } } foreach ($required as $key => $attributes) { $flat[$key] = implode(',', $attributes); } return $flat; }
/** * {@inheritdoc} */ public function findAttributesByFamily(FamilyInterface $family) { $qb = $this->createQueryBuilder('a'); $qb->select('a, g')->join('a.group', 'g')->innerJoin('a.families', 'f', 'WITH', 'f.id = :family')->setParameter(':family', $family->getId()); return $qb->getQuery()->getResult(); }
function it_normalizes_an_existing_product_into_mongodb_document($mongoFactory, $serializer, ProductInterface $product, \MongoId $mongoId, \MongoDate $mongoDate, Association $assoc1, Association $assoc2, CategoryInterface $category1, CategoryInterface $category2, GroupInterface $group1, GroupInterface $group2, ProductValueInterface $value1, ProductValueInterface $value2, FamilyInterface $family) { $mongoFactory->createMongoId('product1')->willReturn($mongoId); $mongoFactory->createMongoDate()->willReturn($mongoDate); $family->getId()->willReturn(36); $category1->getId()->willReturn(12); $category2->getId()->willReturn(34); $group1->getId()->willReturn(56); $group2->getId()->willReturn(78); $product->getId()->willReturn('product1'); $product->getCreated()->willReturn(null); $product->getFamily()->willReturn($family); $product->isEnabled()->willReturn(true); $product->getGroups()->willReturn([$group1, $group2]); $product->getCategories()->willReturn([$category1, $category2]); $product->getAssociations()->willReturn([$assoc1, $assoc2]); $product->getValues()->willReturn([$value1, $value2]); $context = ['_id' => $mongoId]; $serializer->normalize($product, 'mongodb_json')->willReturn(['data' => 'data', 'completenesses' => 'completenesses']); $serializer->normalize($value1, 'mongodb_document', $context)->willReturn('my_value_1'); $serializer->normalize($value2, 'mongodb_document', $context)->willReturn('my_value_2'); $serializer->normalize($assoc1, 'mongodb_document', $context)->willReturn('my_assoc_1'); $serializer->normalize($assoc2, 'mongodb_document', $context)->willReturn('my_assoc_2'); $this->normalize($product, 'mongodb_document')->shouldReturn(['_id' => $mongoId, 'created' => $mongoDate, 'updated' => $mongoDate, 'family' => 36, 'enabled' => true, 'groupIds' => [56, 78], 'categoryIds' => [12, 34], 'associations' => ['my_assoc_1', 'my_assoc_2'], 'values' => ['my_value_1', 'my_value_2'], 'normalizedData' => ['data' => 'data'], 'completenesses' => []]); }
/** * {@inheritdoc} */ public function scheduleForFamily(FamilyInterface $family) { $sql = ' DELETE c FROM pim_catalog_completeness c JOIN %product_table% p ON p.id = c.product_id WHERE p.family_id = :family_id'; $sql = $this->applyTableNames($sql); $stmt = $this->connection->prepare($sql); $stmt->bindValue('family_id', $family->getId()); $stmt->execute(); }