/** * Checks if the given constraint is applied or not * * @param Options $options * @param string|null $constraintName Can be: null, 'add', 'delete' * * @return bool */ protected function isDisabled($options, $constraintName = null) { /** @var ConfigIdInterface $configId */ $configId = $options['config_id']; $className = $configId->getClassName(); if (empty($className)) { return false; } $fieldName = $this->typeHelper->getFieldName($configId); if (empty($fieldName)) { return false; } $enumCode = $this->typeHelper->getEnumCode($className, $fieldName); if (!empty($enumCode)) { if ($options['config_is_new']) { // a new field reuses public enum return true; } if ($constraintName) { $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); if ($this->typeHelper->isImmutable('enum', $enumValueClassName, null, $constraintName)) { // is immutable return true; } } } return false; }
/** * {@inheritdoc} */ public function setDefaultOptions(OptionsResolverInterface $resolver) { $defaultFieldOptions = ['multiple' => true]; $resolver->setDefaults(['dictionary_code' => null, 'class' => null, 'field_options' => $defaultFieldOptions]); $resolver->setNormalizers(['class' => function (Options $options, $value) { if ($value !== null) { return $value; } if (empty($options['dictionary_code'])) { throw new InvalidOptionsException('Either "class" or "dictionary_code" must option must be set.'); } $class = ExtendHelper::buildEnumValueClassName($options['dictionary_code']); if (!is_a($class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue', true)) { throw new InvalidOptionsException(sprintf('"%s" must be a child of "%s"', $class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue')); } return $class; }, 'field_options' => function (Options $options, $value) use(&$defaultFieldOptions) { if (isset($options['class'])) { $nullValue = null; if ($options->has('null_value')) { $nullValue = $options->get('null_value'); } $value['choices'] = $this->getChoices($options['class'], $nullValue); } else { $value['choices'] = []; } return array_merge($defaultFieldOptions, $value); }]); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $defaultFieldOptions = ['multiple' => true]; $resolver->setDefaults(['enum_code' => null, 'class' => null, 'field_options' => $defaultFieldOptions, 'operator_choices' => [self::TYPE_IN => $this->translator->trans('oro.filter.form.label_type_in'), self::TYPE_NOT_IN => $this->translator->trans('oro.filter.form.label_type_not_in')]]); $resolver->setNormalizer('class', function (Options $options, $value) { if ($value !== null) { return $value; } if (empty($options['enum_code'])) { throw new InvalidOptionsException('Either "class" or "enum_code" must option must be set.'); } $class = ExtendHelper::buildEnumValueClassName($options['enum_code']); if (!is_a($class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue', true)) { throw new InvalidOptionsException(sprintf('"%s" must be a child of "%s"', $class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue')); } return $class; }); // this normalizer allows to add/override field_options options outside $resolver->setNormalizer('field_options', function (Options $options, $value) use(&$defaultFieldOptions) { if (isset($options['class'])) { $nullValue = null; if ($options->offsetExists('null_value')) { $nullValue = $options->offsetGet('null_value'); } $value['choices'] = $this->getChoices($options['class'], $nullValue); } else { $value['choices'] = []; } return array_merge($defaultFieldOptions, $value); }); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $internalRatings = $manager->getRepository(ExtendHelper::buildEnumValueClassName(Account::INTERNAL_RATING_CODE))->findAll(); /** @var \Oro\Bundle\UserBundle\Entity\User $accountOwner */ $accountOwner = $manager->getRepository('OroUserBundle:User')->findOneBy([]); foreach ($this->accounts as $accountName => $accountData) { /** @var \OroB2B\Bundle\AccountBundle\Entity\AccountGroup $accountGroup */ $accountGroup = $this->getReference(LoadAccountGroupDemoData::ACCOUNT_GROUP_REFERENCE_PREFIX . $accountData['group']); $account = new Account(); $account->setName($accountName)->setGroup($accountGroup)->setParent(null)->setOrganization($accountOwner->getOrganization())->setOwner($accountOwner)->setInternalRating($internalRatings[array_rand($internalRatings)]); $manager->persist($account); $this->addReference(static::ACCOUNT_REFERENCE_PREFIX . $account->getName(), $account); if (isset($accountData['subsidiaries'])) { foreach ($accountData['subsidiaries'] as $subsidiaryName => $subsidiaryData) { /** @var \OroB2B\Bundle\AccountBundle\Entity\AccountGroup $subsidiaryGroup */ $subsidiaryGroup = $this->getReference(LoadAccountGroupDemoData::ACCOUNT_GROUP_REFERENCE_PREFIX . $subsidiaryData['group']); $subsidiary = new Account(); $subsidiary->setName($subsidiaryName)->setGroup($subsidiaryGroup)->setParent($account)->setOrganization($accountOwner->getOrganization())->setOwner($accountOwner)->setInternalRating($internalRatings[array_rand($internalRatings)]); $manager->persist($subsidiary); $this->addReference(static::ACCOUNT_REFERENCE_PREFIX . $subsidiary->getName(), $subsidiary); } } } $manager->flush(); }
/** * Checks if the form type should be read-only or not * * @param Options $options * * @return bool */ protected function isReadOnly($options) { /** @var ConfigIdInterface $configId */ $configId = $options['config_id']; $className = $configId->getClassName(); if (empty($className)) { return false; } $fieldName = $this->typeHelper->getFieldName($configId); if (empty($fieldName)) { return false; } if ($this->typeHelper->isSystem($className, $fieldName)) { // it is a system field return true; } $enumCode = $this->typeHelper->getEnumCode($className, $fieldName); if (!empty($enumCode)) { if ($options['config_is_new']) { // a new field reuses public enum return true; } $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); if ($this->typeHelper->isImmutable('enum', $enumValueClassName, null, 'public')) { // is immutable return true; } if ($this->typeHelper->hasOtherReferences($enumCode, $className, $fieldName)) { // an enum is reused by other fields return true; } } return false; }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { /** @var AccountUser[] $accountUsers */ $accountUsers = $manager->getRepository('OroB2BCustomerBundle:AccountUser')->findAll(); $internalRatings = $manager->getRepository(ExtendHelper::buildEnumValueClassName(Customer::INTERNAL_RATING_CODE))->findAll(); $rootCustomer = null; $firstLevelCustomer = null; // create customer groups $rootGroup = $this->createCustomerGroup('Root'); $firstLevelGroup = $this->createCustomerGroup('First'); $secondLevelGroup = $this->createCustomerGroup('Second'); $manager->persist($rootGroup); $manager->persist($firstLevelGroup); $manager->persist($secondLevelGroup); // create customers foreach ($accountUsers as $index => $accountUser) { $customer = $accountUser->getCustomer(); switch ($index % 3) { case 0: $customer->setGroup($rootGroup); $rootCustomer = $customer; break; case 1: $customer->setGroup($firstLevelGroup)->setParent($rootCustomer); $firstLevelCustomer = $customer; break; case 2: $customer->setGroup($secondLevelGroup)->setParent($firstLevelCustomer); break; } $customer->setInternalRating($internalRatings[array_rand($internalRatings)]); } $manager->flush(); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { /** @var UserManager $userManager */ $userManager = $this->container->get('oro_user.manager'); $admin = $userManager->findUserByEmail(LoadAdminUserData::DEFAULT_ADMIN_EMAIL); $organization = $manager->getRepository('OroOrganizationBundle:Organization')->getFirst(); /** @var Store $store */ $store = $this->getReference('store'); /** @var Channel $channel */ $channel = $this->getReference('default_channel'); /** @var Integration $integration */ $integration = $this->getReference('integration'); $className = ExtendHelper::buildEnumValueClassName('mage_subscr_status'); $enumRepo = $manager->getRepository($className); foreach ($this->subscriberData as $data) { $subscriber = new NewsletterSubscriber(); $date = new \DateTime(); $date->modify('-1 day'); /** @var AbstractEnumValue $status */ $status = $enumRepo->find($data['status']); $subscriber->setEmail($data['email'])->setStatus($status)->setConfirmCode(uniqid())->setStore($store)->setOwner($admin)->setOrganization($organization)->setOriginId($data['originId'])->setChangeStatusAt($date)->setCreatedAt($date)->setUpdatedAt($date)->setChannel($integration)->setDataChannel($channel); if (!empty($data['customer'])) { /** @var Customer $customer */ $customer = $this->getReference($data['customer']); $subscriber->setCustomer($customer); } $this->setReference($data['reference'], $subscriber); $manager->persist($subscriber); } $manager->flush(); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { parent::load($manager); $className = ExtendHelper::buildEnumValueClassName($this->getEnumCode()); /** @var AbstractEnumValue[] $enumData */ $enumData = $manager->getRepository($className)->findAll(); foreach ($enumData as $enumItem) { $this->addReference($enumItem->getName(), $enumItem); } }
/** * {@inheritdoc} */ public function setDefaultOptions(OptionsResolverInterface $resolver) { $resolver->setDefaults(['enum_code' => null, 'class' => null, 'query_builder' => function (EntityRepository $repo) { return $repo->createQueryBuilder('o')->orderBy('o.priority'); }, 'property' => 'name', 'multiple' => null]); $resolver->setNormalizers(['class' => function (Options $options, $value) { return !empty($value) ? $value : ExtendHelper::buildEnumValueClassName($options['enum_code']); }, 'multiple' => function (Options $options, $value) { return $value !== null ? $value : $this->configManager->getProvider('enum')->getConfig($options['class'])->is('multiple'); }]); }
/** * {@inheritdoc} */ public function setDefaultOptions(OptionsResolverInterface $resolver) { $defaultFieldOptions = ['multiple' => true]; $resolver->setDefaults(['enum_code' => null, 'class' => null, 'field_options' => $defaultFieldOptions]); $resolver->setNormalizers(['class' => function (Options $options, $value) { return $value !== null ? $value : ExtendHelper::buildEnumValueClassName($options['enum_code']); }, 'field_options' => function (Options $options, $value) use(&$defaultFieldOptions) { $value['choices'] = $options['class'] !== null ? $this->getChoices($options['class'], $options['null_value']) : []; return array_merge($defaultFieldOptions, $value); }]); }
/** * @param ObjectManager $manager */ public function load(ObjectManager $manager) { $className = ExtendHelper::buildEnumValueClassName('lead_source'); /** @var EnumValueRepository $enumRepo */ $enumRepo = $manager->getRepository($className); $priority = 1; foreach ($this->data as $name => $isDefault) { $enumOption = $enumRepo->createEnumValue($name, $priority++, $isDefault); $manager->persist($enumOption); } $manager->flush(); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $className = ExtendHelper::buildEnumValueClassName('mage_subscr_status'); /** @var EnumValueRepository $enumValueRepository */ $enumValueRepository = $manager->getRepository($className); $priority = 1; foreach ($this->data as $id => $name) { $enumOption = $enumValueRepository->createEnumValue($name, $priority++, false, $id); $manager->persist($enumOption); } $manager->flush(); }
protected function initSupportingEntities(ObjectManager $manager = null) { if ($manager) { $this->em = $manager; } $this->users = $this->em->getRepository('OroUserBundle:User')->findAll(); $this->countries = $this->em->getRepository('OroAddressBundle:Country')->findAll(); $className = ExtendHelper::buildEnumValueClassName('lead_source'); $enumRepo = $manager->getRepository($className); $this->sources = $enumRepo->findAll(); $this->channel = $this->channelBuilderFactory->createBuilder()->setChannelType(DefaultChannelData::B2B_CHANNEL_TYPE)->setStatus(Channel::STATUS_ACTIVE)->setEntities()->getChannel(); $manager->persist($this->channel); $manager->flush($this->channel); }
/** * {@inheritdoc} */ public function init($name, array $params) { $params[FilterUtility::FRONTEND_TYPE_KEY] = 'dictionary'; if (isset($params['class'])) { $params[FilterUtility::FORM_OPTIONS_KEY]['class'] = $params['class']; unset($params['class']); } if (isset($params['enum_code'])) { $params[FilterUtility::FORM_OPTIONS_KEY] = ['enum_code' => $params['enum_code'], 'class' => ExtendHelper::buildEnumValueClassName($params['enum_code'])]; $params['class'] = ExtendHelper::buildEnumValueClassName($params['enum_code']); unset($params['enum_code']); } parent::init($name, $params); }
/** * {@inheritdoc} * * @SuppressWarnings(PHPMD.NPathComplexity) */ public function preUpdate() { $enumConfigProvider = $this->configManager->getProvider('enum'); $extendConfigProvider = $this->configManager->getProvider('extend'); $entityConfigs = $extendConfigProvider->getConfigs(); foreach ($entityConfigs as $entityConfig) { if (!$entityConfig->is('is_extend')) { continue; } $fieldConfigs = $extendConfigProvider->getConfigs($entityConfig->getId()->getClassName()); foreach ($fieldConfigs as $fieldConfig) { if (!$fieldConfig->in('state', [ExtendScope::STATE_NEW, ExtendScope::STATE_UPDATE])) { continue; } /** @var FieldConfigId $fieldConfigId */ $fieldConfigId = $fieldConfig->getId(); $fieldType = $fieldConfigId->getFieldType(); if (!in_array($fieldType, ['enum', 'multiEnum'])) { continue; } // prepare input parameters $fieldOptions = []; $enumFieldConfig = $enumConfigProvider->getConfig($fieldConfigId->getClassName(), $fieldConfigId->getFieldName()); $enumCode = $enumFieldConfig->get('enum_code'); $enumName = $enumFieldConfig->get('enum_name'); $isPublic = $enumFieldConfig->get('enum_public'); if (empty($enumCode) && $isPublic && empty($enumName)) { throw new \LogicException(sprintf('Both "enum_code" and "enum_name" cannot be empty for a public enum. Field: %s::%s.', $fieldConfigId->getClassName(), $fieldConfigId->getFieldName())); } if (empty($enumCode)) { $enumCode = $enumName !== null ? ExtendHelper::buildEnumCode($enumName) : ExtendHelper::generateEnumCode($fieldConfigId->getClassName(), $fieldConfigId->getFieldName()); $fieldOptions['enum']['enum_code'] = $enumCode; } $isMultiple = $this->fieldTypeHelper->getUnderlyingType($fieldType) === RelationType::MANY_TO_MANY; $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); // create an entity is used to store enum values $this->createEnumValueConfigEntityModel($enumValueClassName, $enumCode, $isMultiple, $isPublic); // create a relation if ($isMultiple) { $fieldOptions['extend']['without_default'] = true; $this->relationBuilder->addManyToManyRelation($entityConfig, $enumValueClassName, $fieldConfigId->getFieldName(), ['name'], ['name'], ['name'], $fieldOptions, $fieldType); } else { $this->relationBuilder->addManyToOneRelation($entityConfig, $enumValueClassName, $fieldConfigId->getFieldName(), 'name', $fieldOptions, $fieldType); } } } }
/** * @param ObjectManager $manager */ public function loadSources(ObjectManager $manager) { $className = ExtendHelper::buildEnumValueClassName('lead_source'); /** @var EnumValueRepository $enumRepo */ $enumRepo = $manager->getRepository($className); /** @var AbstractEnumValue[] $sources */ $sources = $enumRepo->findAll(); $randomSource = count($sources) - 1; $leads = $this->em->getRepository('OroCRMSalesBundle:Lead')->findAll(); foreach ($leads as $lead) { /** @var Lead $lead */ $source = $sources[mt_rand(0, $randomSource)]; $lead->setSource($source); $manager->persist($lead); } $manager->flush(); }
/** * {@inheritdoc} */ public function up(Schema $schema, QueryBag $queries) { $existingEnumTables = $this->getExistingEnumTables($schema); $optionSets = $this->dataStorageExtension->get('existing_option_sets'); foreach ($optionSets as &$optionSet) { $entityTableName = $this->extendExtension->getTableNameByEntityClass($optionSet['class_name']); $data = $optionSet['data']; $enumCode = $this->buildEnumCode($optionSet['class_name'], $optionSet['field_name'], $existingEnumTables); $enumTable = $this->extendExtension->addEnumField($schema, $entityTableName, $optionSet['field_name'], $enumCode, $data['extend']['set_expanded'], false, ['extend' => ['owner' => $data['extend']['owner']]]); $existingEnumTables[] = $enumTable->getName(); $optionSet['table_name'] = $entityTableName; $optionSet['enum_class_name'] = ExtendHelper::buildEnumValueClassName($enumCode); $optionSet['enum_table_name'] = $enumTable->getName(); } $this->fillEnumValues($queries, $optionSets); $this->assignEnumValues($queries, $optionSets); $this->removeOptionSetAttributes($queries, $optionSets); }
/** * {@inheritdoc} */ protected function setUp() { $this->objectManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock(); $this->doctrineHelper = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\ORM\\DoctrineHelper')->disableOriginalConstructor()->getMock(); $this->eventDispatcher = $this->getMockBuilder('Symfony\\Component\\EventDispatcher\\EventDispatcherInterface')->disableOriginalConstructor()->getMock(); $this->skuIncrementor = $this->getMockBuilder('OroB2B\\Bundle\\ProductBundle\\Duplicator\\SkuIncrementorInterface')->disableOriginalConstructor()->getMock(); $this->attachmentManager = $this->getMockBuilder('Oro\\Bundle\\AttachmentBundle\\Manager\\AttachmentManager')->disableOriginalConstructor()->getMock(); $this->attachmentProvider = $this->getMockBuilder('Oro\\Bundle\\AttachmentBundle\\Provider\\AttachmentProvider')->disableOriginalConstructor()->getMock(); $this->productStatusRepository = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock(); $this->productStatusDisabled = $this->getMockBuilder('Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue')->disableOriginalConstructor()->getMockForAbstractClass(); $this->connection = $this->getMockBuilder('Doctrine\\DBAL\\Connection')->disableOriginalConstructor()->getMock(); $this->doctrineHelper->expects($this->once())->method('getEntityRepository')->with(ExtendHelper::buildEnumValueClassName('prod_status'))->will($this->returnValue($this->productStatusRepository)); $this->doctrineHelper->expects($this->any())->method('getEntityManager')->with($this->anything())->will($this->returnValue($this->objectManager)); $this->objectManager->expects($this->any())->method('getConnection')->will($this->returnValue($this->connection)); $this->productStatusRepository->expects($this->once())->method('find')->with(Product::STATUS_DISABLED)->will($this->returnValue($this->productStatusDisabled)); $this->duplicator = new ProductDuplicator($this->doctrineHelper, $this->eventDispatcher, $this->attachmentManager, $this->attachmentProvider); $this->duplicator->setSkuIncrementor($this->skuIncrementor); }
/** * @dataProvider setDefaultOptionsProvider */ public function testSetDefaultOptions(ConfigIdInterface $configId, $isNewConfig, $enumCode, $isSystem, $isImmutablePublic, $hasOtherReferences, $options, $expectedOptions) { $fieldName = $configId instanceof FieldConfigId ? $configId->getFieldName() : null; $enumValueClassName = $enumCode ? ExtendHelper::buildEnumValueClassName($enumCode) : null; $this->typeHelper->expects($this->any())->method('getEnumCode')->with($configId->getClassName(), $fieldName)->will($this->returnValue($enumCode)); $this->typeHelper->expects($this->any())->method('isSystem')->with($configId->getClassName(), $fieldName)->will($this->returnValue($isSystem)); $this->typeHelper->expects($this->any())->method('isImmutable')->with('enum', $enumValueClassName, null, 'public')->will($this->returnValue($isImmutablePublic)); $this->typeHelper->expects($this->any())->method('hasOtherReferences')->with($enumCode, $configId->getClassName(), $fieldName)->will($this->returnValue($hasOtherReferences)); $resolver = $this->getOptionsResolver(); $this->type->setDefaultOptions($resolver); $options['config_id'] = $configId; $options['config_is_new'] = $isNewConfig; $resolvedOptions = $resolver->resolve($options); $this->assertSame($configId, $resolvedOptions['config_id']); unset($resolvedOptions['config_id']); $this->assertEquals($isNewConfig, $resolvedOptions['config_is_new']); unset($resolvedOptions['config_is_new']); $this->assertEquals($expectedOptions, $resolvedOptions); }
public function testTransEnumLocalCache() { $enumCode1 = 'test_enum1'; $enumCode2 = 'test_enum2'; $enumValueEntityClass1 = ExtendHelper::buildEnumValueClassName($enumCode1); $enumValueEntityClass2 = ExtendHelper::buildEnumValueClassName($enumCode2); $repo1 = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock(); $repo2 = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock(); $this->doctrine->expects($this->exactly(2))->method('getRepository')->will($this->returnValueMap([[$enumValueEntityClass1, null, $repo1], [$enumValueEntityClass2, null, $repo2]])); $repo1->expects($this->once())->method('findAll')->will($this->returnValue([])); $repo2->expects($this->once())->method('findAll')->will($this->returnValue([])); $this->extension->transEnum('val1', $enumValueEntityClass1); $this->extension->transEnum('val1', $enumValueEntityClass2); // call one more time to check local cache $this->extension->transEnum('val1', $enumValueEntityClass1); $this->extension->transEnum('val1', $enumValueEntityClass2); // call with enum code to check local cache keys $this->extension->transEnum('val1', $enumCode1); $this->extension->transEnum('val1', $enumCode2); }
/** * @dataProvider setDefaultOptionsProvider */ public function testSetDefaultOptions(ConfigIdInterface $configId, $isNewConfig, $enumCode, $isImmutableAdd, $isImmutableDelete, $options, $expectedOptions) { $enumValueClassName = $enumCode ? ExtendHelper::buildEnumValueClassName($enumCode) : null; $this->typeHelper->expects($this->any())->method('getEnumCode')->with($configId->getClassName(), $configId instanceof FieldConfigId ? $configId->getFieldName() : null)->will($this->returnValue($enumCode)); $this->typeHelper->expects($this->any())->method('isImmutable')->will($this->returnValueMap([['enum', $enumValueClassName, null, 'add', $isImmutableAdd], ['enum', $enumValueClassName, null, 'delete', $isImmutableDelete]])); $resolver = $this->getOptionsResolver(); $this->type->setDefaultOptions($resolver); $options['config_id'] = $configId; $options['config_is_new'] = $isNewConfig; $resolvedOptions = $resolver->resolve($options); $this->assertSame($configId, $resolvedOptions['config_id']); unset($resolvedOptions['config_id']); $this->assertEquals($isNewConfig, $resolvedOptions['config_is_new']); unset($resolvedOptions['config_is_new']); $this->assertFalse($resolvedOptions['handle_primary']); unset($resolvedOptions['handle_primary']); $this->assertEquals('oro_entity_extend_enum_value', $resolvedOptions['type']); unset($resolvedOptions['type']); $this->assertEquals($expectedOptions, $resolvedOptions); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $newsletterSubscribers = []; $customers = new ArrayCollection($manager->getRepository('OroCRMMagentoBundle:Customer')->findAll()); $className = ExtendHelper::buildEnumValueClassName('mage_subscr_status'); $statuses = new ArrayCollection($manager->getRepository($className)->findAll()); /** @var Customer $customer */ foreach ($customers as $customer) { $newsletterSubscriber = new NewsletterSubscriber(); $newsletterSubscriber->setOwner($customer->getOwner())->setOrganization($customer->getOrganization())->setChangeStatusAt($customer->getCreatedAt())->setCreatedAt($customer->getCreatedAt())->setUpdatedAt($customer->getUpdatedAt())->setConfirmCode(uniqid('', true))->setChannel($customer->getChannel())->setEmail($customer->getEmail())->setStore($customer->getStore())->setStatus($statuses->get(array_rand($statuses->toArray())))->setDataChannel($customer->getDataChannel()); if (rand(0, 1)) { $newsletterSubscriber->setCustomer($customer); } $newsletterSubscribers[] = $newsletterSubscriber; } foreach ($newsletterSubscribers as $newsletterSubscriber) { $manager->persist($newsletterSubscriber); } if ($newsletterSubscribers) { $manager->flush($newsletterSubscribers); } }
/** * @param ObjectManager $manager */ public function load(ObjectManager $manager) { /** @var ConfigManager $configManager */ $configManager = $this->container->get('oro_entity_config.config_manager'); $configFieldModel = $configManager->getConfigFieldModel('OroCRM\\Bundle\\SalesBundle\\Entity\\Lead', 'extend_source'); if (is_null($configFieldModel)) { // no old options found return; } $enumOptions = []; $options = $this->getLeadSourceOptions($manager, $configFieldModel); if (empty($options)) { // no old options found return; } $className = ExtendHelper::buildEnumValueClassName('lead_source'); /** @var EnumValueRepository $enumRepo */ $enumRepo = $manager->getRepository($className); /** @var OptionSet $option */ foreach ($options as $option) { $enumOption = $enumRepo->createEnumValue($option->getLabel(), $option->getPriority(), $option->getIsDefault()); $manager->persist($enumOption); $enumOptions[$option->getId()] = $enumOption; } $qBuilder = $manager->getRepository('OroCRMSalesBundle:Lead')->createQueryBuilder('lead'); $relRepo = $manager->getRepository('OroEntityConfigBundle:OptionSetRelation'); $paginator = new Paginator($qBuilder, false); /** @var Lead $lead */ foreach ($paginator as $lead) { /** @var OptionSetRelation $relEntity */ $relEntity = $relRepo->createQueryBuilder('r')->select('IDENTITY(r.option) as option_id')->where('r.field = ?0', 'r.entity_id = ?1')->getQuery()->execute([$configFieldModel, $lead->getId()]); $sourceOptionId = $relEntity[0]['option_id']; $source = empty($enumOptions[$sourceOptionId]) ? null : $enumOptions[$sourceOptionId]; $lead->setSource($source); } $manager->flush(); }
/** * {@inheritdoc} */ public function setDefaultOptions(OptionsResolverInterface $resolver) { $resolver->setDefaults(['enum_code' => null, 'class' => null, 'query_builder' => function (EnumValueRepository $repo) { return $repo->getValuesQueryBuilder(); }, 'property' => 'name', 'multiple' => null]); $resolver->setNormalizers(['class' => function (Options $options, $value) { if ($value !== null) { return $value; } if (empty($options['enum_code'])) { throw new InvalidOptionsException('Either "class" or "enum_code" must option must be set.'); } $class = ExtendHelper::buildEnumValueClassName($options['enum_code']); if (!is_a($class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue', true)) { throw new InvalidOptionsException(sprintf('"%s" must be a child of "%s"', $class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue')); } return $class; }, 'multiple' => function (Options $options, $value) { if ($value === null && !empty($options['class'])) { $value = $this->configManager->getProvider('enum')->getConfig($options['class'])->is('multiple'); } return $value; }]); }
protected function doTestSetDefaultOptions(AbstractType $type, OptionsResolver $resolver, $enumCode, $multiple = false, $expanded = false, array $options = []) { $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); $enumConfig = new Config(new EntityConfigId('enum', $enumValueClassName)); $enumConfig->set('multiple', $multiple); $enumConfigProvider = $this->getConfigProviderMock(); $this->configManager->expects($this->once())->method('getProvider')->with('enum')->will($this->returnValue($enumConfigProvider)); $enumConfigProvider->expects($this->once())->method('getConfig')->with($enumValueClassName)->will($this->returnValue($enumConfig)); $type->setDefaultOptions($resolver); $resolvedOptions = $resolver->resolve(array_merge($options, ['enum_code' => $enumCode, 'expanded' => $expanded])); $this->assertEquals($multiple, $resolvedOptions['multiple']); $this->assertEquals($expanded, $resolvedOptions['expanded']); $this->assertEquals($enumCode, $resolvedOptions['enum_code']); $this->assertEquals($enumValueClassName, $resolvedOptions['class']); $this->assertEquals('name', $resolvedOptions['property']); $this->assertNotNull($resolvedOptions['query_builder']); unset($resolvedOptions['multiple']); unset($resolvedOptions['expanded']); unset($resolvedOptions['enum_code']); unset($resolvedOptions['class']); unset($resolvedOptions['property']); unset($resolvedOptions['query_builder']); return $resolvedOptions; }
/** * @param array $data * @param string $className * @param string $fieldName */ protected function setEnumData(array $data, $className, $fieldName) { $provider = $this->configManager->getProvider('enum'); if (!$provider) { return; } $enumCode = $provider->getConfig($className, $fieldName)->get('enum_code'); if (!$enumCode || !isset($data['enum_options'])) { return; } $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); $enumOptions = array_map(function ($option) { if (!isset($option['id'])) { $option['id'] = $option['label']; } return $option; }, $data['enum_options']); if ($provider->hasConfig($enumValueClassName)) { $this->enumSynchronizer->applyEnumOptions($enumValueClassName, $enumOptions, $this->translationHelper->getLocale()); } }
protected function doTestSetDefaultOptions(AbstractEnumType $type, OptionsResolver $resolver, $enumCode, $multiple = false, $expanded = false, array $options = []) { $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); // AbstractEnumType require class to be instance of AbstractEnumValue // This may be achieved with Stub. Stub namespace does not reflect Stub path. So we have to load it manually $fileName = ExtendHelper::getShortClassName($enumValueClassName) . '.php'; require_once realpath(__DIR__ . DIRECTORY_SEPARATOR . 'Stub' . DIRECTORY_SEPARATOR . $fileName); $enumConfig = new Config(new EntityConfigId('enum', $enumValueClassName)); $enumConfig->set('multiple', $multiple); $enumConfigProvider = $this->getConfigProviderMock(); $this->configManager->expects($this->once())->method('getProvider')->with('enum')->will($this->returnValue($enumConfigProvider)); $enumConfigProvider->expects($this->once())->method('getConfig')->with($enumValueClassName)->will($this->returnValue($enumConfig)); $type->setDefaultOptions($resolver); $resolvedOptions = $resolver->resolve(array_merge($options, ['enum_code' => $enumCode, 'expanded' => $expanded])); $this->assertEquals($multiple, $resolvedOptions['multiple']); $this->assertEquals($expanded, $resolvedOptions['expanded']); $this->assertEquals($enumCode, $resolvedOptions['enum_code']); $this->assertEquals($enumValueClassName, $resolvedOptions['class']); $this->assertEquals('name', $resolvedOptions['property']); $this->assertNotNull($resolvedOptions['query_builder']); unset($resolvedOptions['multiple'], $resolvedOptions['expanded'], $resolvedOptions['enum_code'], $resolvedOptions['class'], $resolvedOptions['property'], $resolvedOptions['query_builder']); return $resolvedOptions; }
/** * Post submit event handler * * @param FormEvent $event * * @SuppressWarnings(PHPMD.NPathComplexity) */ public function postSubmit(FormEvent $event) { $form = $event->getForm(); $configModel = $form->getConfig()->getOption('config_model'); if (!$configModel instanceof FieldConfigModel) { return; } if (!in_array($configModel->getType(), ['enum', 'multiEnum'])) { return; } if (!$form->isValid()) { return; } $data = $event->getData(); $enumConfig = $configModel->toArray('enum'); $enumName = $this->getValue($data['enum'], 'enum_name'); $enumCode = $this->getValue($enumConfig, 'enum_code'); if (empty($enumCode)) { $enumCode = $enumName !== null ? ExtendHelper::buildEnumCode($enumName) : ExtendHelper::generateEnumCode($configModel->getEntity()->getClassName(), $configModel->getFieldName()); } $locale = $this->translator->getLocale(); $enumValueClassName = ExtendHelper::buildEnumValueClassName($enumCode); $enumConfigProvider = $this->configManager->getProvider('enum'); if ($enumConfigProvider->hasConfig($enumValueClassName)) { // existing enum if ($configModel->getId()) { if ($enumName !== null) { $this->enumSynchronizer->applyEnumNameTrans($enumCode, $enumName, $locale); } $enumOptions = $this->getValue($data['enum'], 'enum_options'); if ($enumOptions !== null) { $this->enumSynchronizer->applyEnumOptions($enumValueClassName, $enumOptions, $locale); } $enumPublic = $this->getValue($data['enum'], 'enum_public'); if ($enumPublic !== null) { $this->enumSynchronizer->applyEnumEntityOptions($enumValueClassName, $enumPublic); } } unset($data['enum']['enum_name']); unset($data['enum']['enum_options']); unset($data['enum']['enum_public']); $event->setData($data); } else { // new enum $this->sortOptions($data['enum']['enum_options']); $data['enum']['enum_locale'] = $locale; $event->setData($data); } }
/** * @param string $columnName column name * @param string $dataName property path of the field, e.g. entity.enum_field * @param string $enumCode enum code * @param bool $isMultiple allow to filter by several values * * @return DatagridConfiguration */ public function addEnumFilter($columnName, $dataName, $enumCode, $isMultiple = false) { $this->addFilter($columnName, ['type' => 'entity', 'data_name' => $dataName, 'options' => ['field_options' => ['class' => ExtendHelper::buildEnumValueClassName($enumCode), 'property' => 'name', 'query_builder' => function (EntityRepository $entityRepository) { return $entityRepository->createQueryBuilder('c')->orderBy('c.name', 'ASC'); }, 'multiple' => $isMultiple]]]); return $this; }
/** * @SuppressWarnings(PHPMD.ExcessiveMethodLength) */ public function setDefaultOptionsProvider() { return [['enumCode' => 'test_enum', 'class' => null, 'nullValue' => null, 'values' => ['val1' => 'Value1'], 'fieldOptions' => null, 'expectedOptions' => ['enum_code' => 'test_enum', 'class' => ExtendHelper::buildEnumValueClassName('test_enum'), 'null_value' => null, 'field_options' => ['multiple' => true, 'choices' => ['val1' => 'Value1']]]], ['enumCode' => 'test_enum', 'class' => null, 'nullValue' => ':empty:', 'values' => ['val1' => 'Value1'], 'fieldOptions' => null, 'expectedOptions' => ['enum_code' => 'test_enum', 'class' => ExtendHelper::buildEnumValueClassName('test_enum'), 'null_value' => ':empty:', 'field_options' => ['multiple' => true, 'choices' => [':empty:' => 'None', 'val1' => 'Value1']]]], ['enumCode' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'nullValue' => null, 'values' => ['val1' => 'Value1'], 'fieldOptions' => null, 'expectedOptions' => ['enum_code' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'null_value' => null, 'field_options' => ['multiple' => true, 'choices' => ['val1' => 'Value1']]]], ['enumCode' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'nullValue' => ':empty:', 'values' => ['val1' => 'Value1'], 'fieldOptions' => null, 'expectedOptions' => ['enum_code' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'null_value' => ':empty:', 'field_options' => ['multiple' => true, 'choices' => [':empty:' => 'None', 'val1' => 'Value1']]]], ['enumCode' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'nullValue' => null, 'values' => ['val1' => 'Value1'], 'fieldOptions' => ['multiple' => false], 'expectedOptions' => ['enum_code' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'null_value' => null, 'field_options' => ['multiple' => false, 'choices' => ['val1' => 'Value1']]]], 'numeric choice keys' => ['enumCode' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'nullValue' => ':empty:', 'values' => [1 => 'Value1'], 'fieldOptions' => ['multiple' => false], 'expectedOptions' => ['enum_code' => null, 'class' => 'Extend\\Entity\\EV_Test_Enum', 'null_value' => ':empty:', 'field_options' => ['multiple' => false, 'choices' => [':empty:' => 'None', 1 => 'Value1']]]]]; }