/** * @Route("/update/{id}", name="oro_entityextend_field_update", requirements={"id"="\d+"}, defaults={"id"=0}) * Acl( * id="oro_entityextend_field_update", * label="Update custom field", * type="action", * group_name="" * ) */ public function updateAction(EntityConfigModel $entity) { $request = $this->getRequest(); $fieldName = $request->getSession()->get(sprintf(self::SESSION_ID_FIELD_NAME, $entity->getId())); $fieldType = $request->getSession()->get(sprintf(self::SESSION_ID_FIELD_TYPE, $entity->getId())); if (!$fieldName || !$fieldType) { return $this->redirect($this->generateUrl('oro_entityextend_field_create', ['id' => $entity->getId()])); } /** @var ConfigManager $configManager */ $configManager = $this->get('oro_entity_config.config_manager'); $extendProvider = $configManager->getProvider('extend'); $extendEntityConfig = $extendProvider->getConfig($entity->getClassName()); $relationValues = []; $relationOptions = explode('||', $fieldType); $relationName = $relationOptions[0]; if (isset($relationOptions[1])) { $fieldName = $relationOptions[1]; } $relationOptions = explode('|', $relationOptions[0]); /** * fieldType example: relation|manyToOne|testentity5_relation_7 * check if fieldType has 3rd option [fieldName] */ if (count($relationOptions) == 4) { $fieldType = ExtendHelper::getReversRelationType($relationOptions[0]); $relations = $extendEntityConfig->get('relation'); if (isset($relations[$relationName])) { $relationValues['target_entity'] = $relations[$relationName]['target_entity']; $relationValues['relation_key'] = $relationName; } } $newFieldModel = $configManager->createConfigFieldModel($entity->getClassName(), $fieldName, $fieldType); $extendFieldConfig = $extendProvider->getConfig($entity->getClassName(), $fieldName); $extendFieldConfig->set('owner', ExtendManager::OWNER_CUSTOM); $extendFieldConfig->set('state', ExtendManager::STATE_NEW); $extendFieldConfig->set('extend', true); foreach ($relationValues as $key => $value) { $extendFieldConfig->set($key, $value); } $form = $this->createForm('oro_entity_config_type', null, ['config_model' => $newFieldModel]); if ($request->getMethod() == 'POST') { $form->submit($request); if ($form->isValid()) { //persist data inside the form $this->get('session')->getFlashBag()->add('success', $this->get('translator')->trans('oro.entity_extend.controller.config_field.message.saved')); if ($extendEntityConfig->get('state') != ExtendManager::STATE_NEW) { $extendEntityConfig->set('state', ExtendManager::STATE_UPDATED); } $extendEntityConfig->set('upgradeable', true); $configManager->persist($extendEntityConfig); $configManager->flush(); return $this->get('oro_ui.router')->actionRedirect(['route' => 'oro_entityconfig_field_update', 'parameters' => ['id' => $newFieldModel->getId()]], ['route' => 'oro_entityconfig_view', 'parameters' => ['id' => $entity->getId()]]); } } /** @var ConfigProvider $entityConfigProvider */ $entityConfigProvider = $this->get('oro_entity_config.provider.entity'); $entityConfig = $entityConfigProvider->getConfig($entity->getClassName()); $fieldConfig = $entityConfigProvider->getConfig($entity->getClassName(), $newFieldModel->getFieldName()); return $this->render('OroEntityConfigBundle:Config:fieldUpdate.html.twig', ['entity_config' => $entityConfig, 'field_config' => $fieldConfig, 'field' => $newFieldModel, 'form' => $form->createView(), 'formAction' => $this->generateUrl('oro_entityextend_field_update', array('id' => $entity->getId())), 'require_js' => $configManager->getProvider('extend')->getPropertyConfig()->getRequireJsModules()]); }
public function testType() { $formData = array('className' => 'NewEntityClassName'); $form = $this->factory->create($this->type); $form->submit($formData); $object = new EntityConfigModel(); $object->setClassName('NewEntityClassName'); $this->assertTrue($form->isSynchronized()); $this->assertEquals($object, $form->getData()); }
public function setUp() { $this->settingsProvider = $this->getMockBuilder('OroCRM\\Bundle\\ChannelBundle\\Provider\\SettingsProvider')->disableOriginalConstructor()->getMock(); $this->settingsProvider->expects($this->once())->method('getSettings')->will($this->returnvalue($this->testConfig)); $this->entityProvider = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\Provider\\EntityProvider')->disableOriginalConstructor()->getMock(); $this->configManager = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigManager')->disableOriginalConstructor()->getMock(); $this->entityConfigModel1 = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Entity\\EntityConfigModel'); $this->entityConfigModel2 = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Entity\\EntityConfigModel'); $this->entityConfigModel1->expects($this->any())->method('getId')->will($this->returnvalue($this->entityId1)); $this->entityConfigModel2->expects($this->any())->method('getId')->will($this->returnvalue($this->entityId2)); $this->router = $this->getMockBuilder('Symfony\\Component\\Routing\\RouterInterface')->disableOriginalConstructor()->getMock(); }
/** * @dataProvider canFieldBeRestoredProvider * * @param string $fieldName * @param bool $expectedResult */ public function testCanFieldBeRestored($fieldName, $expectedResult) { $entity = new EntityConfigModel(self::ENTITY_CLASS); $field = new FieldConfigModel($fieldName); $entity->addField($field); $this->addFieldConfig($fieldName, 'int'); $this->addFieldConfig('active_field', 'int'); $this->addFieldConfig('active_hidden_field', 'int', [], true); $this->addFieldConfig('deleted_field', 'int', ['is_deleted' => true]); $this->addFieldConfig('to_be_deleted_field', 'int', ['state' => ExtendScope::STATE_DELETE]); $this->assertEquals($expectedResult, $this->validationHelper->canFieldBeRestored($field)); }
/** * @Route("/update/{id}", name="oro_entityextend_field_update", requirements={"id"="\d+"}, defaults={"id"=0}) * Acl( * id="oro_entityextend_field_update", * label="oro.entity_extend.action.config_field_grid.update", * type="action", * group_name="" * ) */ public function updateAction(EntityConfigModel $entity) { $request = $this->getRequest(); $fieldName = $request->getSession()->get(sprintf(self::SESSION_ID_FIELD_NAME, $entity->getId())); $fieldType = $request->getSession()->get(sprintf(self::SESSION_ID_FIELD_TYPE, $entity->getId())); if (!$fieldName || !$fieldType) { return $this->redirect($this->generateUrl('oro_entityextend_field_create', ['id' => $entity->getId()])); } /** @var ConfigManager $configManager */ $configManager = $this->get('oro_entity_config.config_manager'); $extendProvider = $configManager->getProvider('extend'); $extendEntityConfig = $extendProvider->getConfig($entity->getClassName()); $fieldOptions = ['extend' => ['is_extend' => true, 'owner' => ExtendScope::OWNER_CUSTOM, 'state' => ExtendScope::STATE_NEW]]; // check if a field type is complex, for example reverse relation or public enum $fieldTypeParts = explode('||', $fieldType); if (count($fieldTypeParts) > 1) { if (in_array($fieldTypeParts[0], ['enum', 'multiEnum'])) { // enum $fieldType = $fieldTypeParts[0]; $fieldOptions['enum']['enum_code'] = $fieldTypeParts[1]; } else { $firstPartItems = explode('|', $fieldTypeParts[0]); if (count($firstPartItems) === 4) { // reverse relation $fieldType = ExtendHelper::getReverseRelationType($firstPartItems[0]); $relationKey = $fieldTypeParts[0]; $fieldOptions['extend']['relation_key'] = $relationKey; $relations = $extendEntityConfig->get('relation'); $fieldOptions['extend']['target_entity'] = $relations[$relationKey]['target_entity']; } } } $newFieldModel = $configManager->createConfigFieldModel($entity->getClassName(), $fieldName, $fieldType); $this->updateFieldConfigs($configManager, $newFieldModel, $fieldOptions); $form = $this->createForm('oro_entity_config_type', null, ['config_model' => $newFieldModel]); if ($request->getMethod() == 'POST') { $form->submit($request); if ($form->isValid()) { //persist data inside the form $this->get('session')->getFlashBag()->add('success', $this->get('translator')->trans('oro.entity_extend.controller.config_field.message.saved')); $extendEntityConfig->set('upgradeable', true); $configManager->persist($extendEntityConfig); $configManager->flush(); return $this->get('oro_ui.router')->redirectAfterSave(['route' => 'oro_entityconfig_field_update', 'parameters' => ['id' => $newFieldModel->getId()]], ['route' => 'oro_entityconfig_view', 'parameters' => ['id' => $entity->getId()]]); } } /** @var ConfigProvider $entityConfigProvider */ $entityConfigProvider = $this->get('oro_entity_config.provider.entity'); $entityConfig = $entityConfigProvider->getConfig($entity->getClassName()); $fieldConfig = $entityConfigProvider->getConfig($entity->getClassName(), $newFieldModel->getFieldName()); return $this->render('OroEntityConfigBundle:Config:fieldUpdate.html.twig', ['entity_config' => $entityConfig, 'field_config' => $fieldConfig, 'field' => $newFieldModel, 'form' => $form->createView(), 'formAction' => $this->generateUrl('oro_entityextend_field_update', ['id' => $entity->getId()]), 'require_js' => $configManager->getProvider('extend')->getPropertyConfig()->getRequireJsModules()]); }
/** * Test class is NOT extend and should NOT be persisted */ public function testNewNotExtendEntity() { $configModel = new EntityConfigModel('Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2'); $entityConfig = new Config(new EntityConfigId('Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2', 'extend')); /** * value of NEW Config should be empty */ $this->assertEquals([], $entityConfig->all()); $this->configProvider->expects($this->any())->method('getConfig')->will($this->returnValue($entityConfig)); $event = new EntityConfigEvent($configModel->getClassName(), $this->configManager); $listener = new EntityConfigListener(); $listener->updateEntity($event); $this->assertEquals([], $this->configManager->getUpdateConfig()); }
protected function doImport() { $this->client->followRedirects(false); $this->client->request('GET', $this->getUrl('oro_importexport_import_process', ['_format' => 'json', 'processorAlias' => 'oro_entity_config_entity_field.add_or_replace', 'importJob' => 'entity_fields_import_from_csv', 'options[entity_id]' => $this->entity->getId()])); $data = $this->getJsonResponseContent($this->client->getResponse(), 200); $this->assertEquals(['success' => true, 'message' => 'File was successfully imported.', 'errorsUrl' => null], $data); }
/** * @dataProvider validateProvider * * @param string $fieldName * @param string $fieldType * @param string $expectedValidationMessageType */ public function testValidate($fieldName, $fieldType, $expectedValidationMessageType) { $entity = new EntityConfigModel(self::ENTITY_CLASS); $field = new FieldConfigModel($fieldName, $fieldType); $entity->addField($field); $context = $this->getMock('Symfony\\Component\\Validator\\Context\\ExecutionContextInterface'); $this->validator->initialize($context); $constraint = new DefaultRelationField(); if ($expectedValidationMessageType) { $message = PropertyAccess::createPropertyAccessor()->getValue($constraint, $expectedValidationMessageType); $violation = $this->getMock('Symfony\\Component\\Validator\\Violation\\ConstraintViolationBuilderInterface'); $context->expects($this->once())->method('buildViolation')->with($message)->willReturn($violation); $violation->expects($this->once())->method('atPath')->with('fieldName')->willReturnSelf(); $violation->expects($this->once())->method('addViolation'); } else { $context->expects($this->never())->method('buildViolation'); } $this->validator->validate($field, $constraint); }
/** * Test class is NOT extend and should NOT be persisted */ public function testNewNotExtendEntity() { $configModel = new EntityConfigModel('Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2'); $entityConfig = new Config(new EntityConfigId('Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2', 'extend')); /** * value of NEW Config should be empty */ $this->assertEquals([], $entityConfig->all()); $configProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $configProvider->expects($this->any())->method('getConfig')->will($this->returnValue($entityConfig)); $configManager = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigManager')->disableOriginalConstructor()->setMethods(['getProvider'])->getMock(); $configManager->expects($this->any())->method('getProvider')->with('extend')->will($this->returnValue($configProvider)); $event = new EntityConfigEvent($configModel->getClassName(), $configManager); $extendConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $configSubscriber = new ConfigSubscriber($extendConfigProvider); $configSubscriber->updateEntityConfig($event); /** @var ConfigManager $cm */ $cm = $event->getConfigManager(); $this->assertObjectHasAttribute('persistConfigs', $cm); $this->assertAttributeEquals(null, 'persistConfigs', $cm); }
public function testToFromArray() { $this->configValue->setCode('doctrine')->setScope('datagrid')->setValue('a:2:{s:4:"code";s:8:"test_001";s:4:"type";s:6:"string";}'); $values = array('is_searchable' => true, 'is_sortable' => false, 'doctrine' => $this->configValue); $serializable = array('doctrine' => true); $this->configField->addValue(new ConfigModelValue('is_searchable', 'datagrid', false)); $this->configField->fromArray('datagrid', $values, $serializable); $this->assertEquals(array('is_searchable' => 1, 'is_sortable' => 0, 'doctrine' => $this->configValue), $this->configField->toArray('datagrid')); $this->configEntity->addValue(new ConfigModelValue('is_searchable', 'datagrid', false)); $this->configEntity->fromArray('datagrid', $values, $serializable); $this->assertEquals(array('is_searchable' => 1, 'is_sortable' => 0, 'doctrine' => $this->configValue), $this->configEntity->toArray('datagrid')); }
public function testFieldsCollectionOfEntityConfigModel() { $entityModel = new EntityConfigModel(); $this->assertCount(0, $entityModel->getFields()); $fieldModel1 = new FieldConfigModel('field1', 'string'); $fieldModel2 = new FieldConfigModel('field2', 'integer'); $entityModel->addField($fieldModel1); $entityModel->addField($fieldModel2); $fields = $entityModel->getFields(); $this->assertCount(2, $fields); $this->assertSame($fieldModel1, $fields->first()); $this->assertSame($fieldModel2, $fields->last()); $this->assertSame($fieldModel1, $entityModel->getField('field1')); $this->assertSame($fieldModel2, $entityModel->getField('field2')); $fields = $entityModel->getFields(function (FieldConfigModel $model) { return $model->getFieldName() === 'field2'; }); $this->assertCount(1, $fields); $this->assertSame($fieldModel2, $fields->first()); $entityModel->setFields(new ArrayCollection([$fieldModel1])); $fields = $entityModel->getFields(); $this->assertCount(1, $fields); $this->assertSame($fieldModel1, $fields->first()); }
/** * @param string|null $className * @param string|null $mode * @return EntityConfigModel * @throws \InvalidArgumentException */ public function createEntityModel($className = null, $mode = self::MODE_DEFAULT) { if (!in_array($mode, array(self::MODE_DEFAULT, self::MODE_HIDDEN, self::MODE_READONLY))) { throw new \InvalidArgumentException(sprintf('Invalid $mode: "%s"', $mode)); } $entityModel = new EntityConfigModel($className); $entityModel->setMode($mode); if (!empty($className)) { $this->ensureEntityLocalCacheWarmed(); $this->entityLocalCache[$className] = $entityModel; } return $entityModel; }
/** * @param EntityConfigModel $entityModel * @param string $fieldName * @return FieldConfigModel */ public static function createFieldModel($entityModel, $fieldName) { $fieldModel = new FieldConfigModel($fieldName, 'string'); $entityModel->addField($fieldModel); return $fieldModel; }
/** * Return configured layout actions and requirejs modules * * @param EntityConfigModel $entity * @return array */ protected function getLayoutParams(EntityConfigModel $entity) { $configManager = $this->get('oro_entity_config.config_manager'); $actions = []; $requireJsModules = []; foreach ($configManager->getProviders() as $provider) { $layoutActions = $provider->getPropertyConfig()->getLayoutActions(PropertyConfigContainer::TYPE_FIELD); foreach ($layoutActions as $config) { if (isset($config['filter'])) { foreach ($config['filter'] as $key => $value) { if (is_array($value)) { $error = true; foreach ($value as $v) { if ($provider->getConfig($entity->getClassName())->get($key) == $v) { $error = false; } } if ($error) { continue 2; } } elseif ($provider->getConfig($entity->getClassName())->get($key) != $value) { continue 2; } } } if (isset($config['entity_id']) && $config['entity_id'] == true) { $config['args'] = ['id' => $entity->getId()]; } $actions[] = $config; } $requireJsModules = array_merge($requireJsModules, $provider->getPropertyConfig(PropertyConfigContainer::TYPE_FIELD)->getRequireJsModules()); } return [$actions, $requireJsModules]; }
/** * @return EntityConfigModel[] */ protected function getEntityConfigModels() { $models = []; for ($i = 1; $i <= self::NUMBER_OF_ENTITIES; $i++) { $model = new EntityConfigModel('Entity' . $i); if ($i % 20 === 0) { $model->setMode(ConfigModel::MODE_HIDDEN); } foreach ($this->getFieldConfigModels() as $field) { $model->addField($field); } $models[] = $model; } return $models; }
/** * @return string */ public function getClassName() { return $this->configModel->getClassName(); }
public function testCreateEntityModel() { $result = new EntityConfigModel(DemoEntity::ENTITY_NAME); $result->setMode(ConfigModelManager::MODE_DEFAULT); $this->assertEquals($result, $this->configModelManager->createEntityModel(DemoEntity::ENTITY_NAME)); }
/** * @param EntityConfigModel $configEntityModel * * @return array */ protected function getEntityLinks(EntityConfigModel $configEntityModel) { return ['entity_id' => $configEntityModel->getId(), 'edit_link' => $this->generateUrl(self::ENTITY_EDIT_ROUTE, ['id' => $configEntityModel->getId()]), 'view_link' => $this->generateUrl(self::ENTITY_VIEW_ROUTE, ['id' => $configEntityModel->getId()])]; }
/** * @dataProvider customEntityDataProvider */ public function testGetEntityAliasForCustomEntity($entityClass, $expectedAlias) { $entityConfigModel = new EntityConfigModel(); $entityConfigModel->setClassName($entityClass); $entityConfigModel->setMode(ConfigModelManager::MODE_DEFAULT); $enumConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $enumConfig = new Config(new EntityConfigId('enum', $entityClass)); $groupingConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $groupingConfig = new Config(new EntityConfigId('grouping', $entityClass)); $this->configManager->expects($this->once())->method('getConfigEntityModel')->with($entityClass)->willReturn($entityConfigModel); $this->configManager->expects($this->exactly(2))->method('getProvider')->willReturnMap([['enum', $enumConfigProvider], ['grouping', $groupingConfigProvider]]); $enumConfigProvider->expects($this->once())->method('getConfig')->with($entityClass)->willReturn($enumConfig); $groupingConfigProvider->expects($this->once())->method('getConfig')->with($entityClass)->willReturn($groupingConfig); $result = $this->entityAliasProvider->getEntityAlias($entityClass); $this->assertEntityAlias($expectedAlias, $result); }
/** * @param string|null $className * @param string|null $mode * * @return EntityConfigModel * * @throws \InvalidArgumentException if $mode is invalid * @throws RuntimeException if models are locked */ public function createEntityModel($className = null, $mode = ConfigModel::MODE_DEFAULT) { if (!$this->isValidMode($mode)) { throw new \InvalidArgumentException(sprintf('Invalid $mode: "%s"', $mode)); } if ($this->lockObject->isLocked()) { throw new RuntimeException(sprintf('Cannot create entity model for "%s" because config models are locked.', $className)); } $entityModel = new EntityConfigModel($className); $entityModel->setMode($mode); if (!empty($className)) { $this->ensureEntityCacheWarmed(); $this->entities[$className] = $entityModel; } return $entityModel; }
/** * @Route( * "/unremove/{id}", * name="oro_entityextend_entity_unremove", * requirements={"id"="\d+"}, * defaults={"id"=0} * ) * Acl( * id="oro_entityextend_entity_unremove", * label="oro.entity_extend.action.config_entity_grid.unremove", * type="action", * group_name="" * ) */ public function unremoveAction(EntityConfigModel $entity) { if (!$entity) { throw $this->createNotFoundException('Unable to find EntityConfigModel entity.'); } /** @var ConfigManager $configManager */ $configManager = $this->get('oro_entity_config.config_manager'); $entityConfig = $configManager->getProvider('extend')->getConfig($entity->getClassName()); if ($entityConfig->get('owner') == ExtendScope::OWNER_SYSTEM) { return new Response('', Codes::HTTP_FORBIDDEN); } $entityConfig->set('state', class_exists($entity->getClassName()) ? ExtendScope::STATE_UPDATE : ExtendScope::STATE_NEW); $configManager->persist($entityConfig); $configManager->flush(); return new JsonResponse(array('message' => 'Item was restored', 'successful' => true), Codes::HTTP_OK); }
/** * Gets config id for the given model * * @param EntityConfigModel|FieldConfigModel $model * @param string $scope * @return ConfigIdInterface */ public function getConfigIdByModel($model, $scope) { if ($model instanceof FieldConfigModel) { return new FieldConfigId($scope, $model->getEntity()->getClassName(), $model->getFieldName(), $model->getType()); } else { return new EntityConfigId($scope, $model->getClassName()); } }
/** * @param array $action * @param EntityConfigModel $entity * @param ConfigProvider $provider * * @return bool */ protected function isLayoutActionApplicable(array $action, EntityConfigModel $entity, ConfigProvider $provider) { if (!isset($action['filter'])) { return true; } $result = true; foreach ($action['filter'] as $key => $value) { if ($key === 'mode') { if ($entity->getMode() !== $value) { $result = false; break; } } else { $config = $provider->getConfig($entity->getClassName()); if (is_array($value)) { if (!$config->in($key, $value)) { $result = false; break; } } elseif ($config->get($key) != $value) { $result = false; break; } } } return $result; }
protected function createEntityConfigModel($className, $mode = ConfigModel::MODE_DEFAULT) { $result = new EntityConfigModel($className); $result->setMode($mode); return $result; }
/** * @param string $className * @param string $mode * @throws \InvalidArgumentException * @return EntityConfigModel */ public function createEntityModel($className, $mode = self::MODE_DEFAULT) { if (!in_array($mode, array(self::MODE_DEFAULT, self::MODE_READONLY))) { throw new \InvalidArgumentException(sprintf('EntityConfigModel give invalid parameter "mode" : "%s"', $mode)); } $entityModel = new EntityConfigModel($className); $entityModel->setMode($mode); $this->localCache->set($className, $entityModel); return $entityModel; }