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