/**
* @dataProvider valueDataProvider
* @param mixed $fieldValue
*/
public function testFixEntityAssociationFieldsEntity($fieldValue)
{
$entity = new \stdClass();
$entity->field = $fieldValue;
if ($fieldValue instanceof ArrayCollection) {
$linkedEntity = $fieldValue->getIterator()->offsetGet(0);
} else {
$linkedEntity = $fieldValue;
}
$this->fieldHelper->expects($this->once())->method('getRelations')->with(get_class($entity))->will($this->returnValue([['name' => 'field']]));
$metadata = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\ClassMetadata')->disableOriginalConstructor()->getMock();
$metadata->expects($this->once())->method('getIdentifierValues')->with($linkedEntity)->will($this->returnValue('id'));
$this->entityManager->expects($this->once())->method('getClassMetadata')->with(get_class($entity))->will($this->returnValue($metadata));
$uow = $this->getMockBuilder('\\Doctrine\\ORM\\UnitOfWork')->disableOriginalConstructor()->getMock();
$uow->expects($this->once())->method('getEntityState')->with($linkedEntity)->will($this->returnValue(UnitOfWork::STATE_DETACHED));
$this->entityManager->expects($this->once())->method('getUnitOfWork')->will($this->returnValue($uow));
$this->entityManager->expects($this->once())->method('getReference')->with(get_class($entity), 'id')->will($this->returnCallback(function () use($entity) {
$entity->reloaded = true;
return $entity;
}));
$this->fixer->fixEntityAssociationFields($entity, 0);
if ($fieldValue instanceof ArrayCollection) {
$this->assertTrue($entity->field->getIterator()->offsetGet(0)->reloaded);
} else {
$this->assertTrue($entity->field->reloaded);
}
}
/**
* @param string $entityName
* @param string $fieldName
* @return string|null
*/
protected function getRelationEntityName($entityName, $fieldName)
{
$fields = $this->fieldHelper->getFields($entityName, true);
foreach ($fields as $field) {
if ($field['name'] == $fieldName && $this->fieldHelper->isMultipleRelation($field)) {
return $field['related_entity_name'];
}
}
return null;
}
/**
* @param mixed $expected
* @param array $data
*
* @dataProvider denormalizeDataProvider
*/
public function testDenormalize($expected, array $data)
{
$this->fieldHelper->expects($this->once())->method('getFields')->willReturn([['name' => 'incrementId'], ['name' => 'paymentDetails']]);
$this->fieldHelper->expects($this->once())->method('setObjectValue')->will($this->returnCallback(function ($result, $fieldName, $value) {
$propertyAccessor = PropertyAccess::createPropertyAccessor();
$propertyAccessor->setValue($result, $fieldName, $value);
}));
/** @var Order $order */
$order = $this->normalizer->denormalize($data, 'OroCRM\\Bundle\\MagentoBundle\\Entity\\Order');
$this->assertEquals($expected, $order->getPaymentDetails());
}
/**
* @param object $basicEntity
* @param object $importedEntity
* @param array $excludedProperties
* @throws InvalidArgumentException
*/
public function importEntity($basicEntity, $importedEntity, array $excludedProperties = array())
{
$basicEntityClass = ClassUtils::getClass($basicEntity);
if ($basicEntityClass != ClassUtils::getClass($importedEntity)) {
throw new InvalidArgumentException('Basic and imported entities must be instances of the same class');
}
$entityMetadata = $this->getEntityManager($basicEntityClass)->getClassMetadata($basicEntityClass);
$importedEntityProperties = array_diff(array_merge($entityMetadata->getFieldNames(), $entityMetadata->getAssociationNames()), $excludedProperties);
foreach ($importedEntityProperties as $propertyName) {
$importedValue = $this->fieldHelper->getObjectValue($importedEntity, $propertyName);
$this->fieldHelper->setObjectValue($basicEntity, $propertyName, $importedValue);
}
}
protected function setUp()
{
$this->eventDispatcher = $this->getMock('Symfony\\Component\\EventDispatcher\\EventDispatcherInterface');
$this->fieldHelper = $this->getMockBuilder('Oro\\Bundle\\ImportExportBundle\\Field\\FieldHelper')->disableOriginalConstructor()->getMock();
$this->fieldHelper->expects($this->any())->method('getIdentityValues')->willReturn([]);
$this->fieldHelper->expects($this->any())->method('getFields')->willReturn([]);
$this->databaseHelper = $this->getMockBuilder('Oro\\Bundle\\ImportExportBundle\\Field\\DatabaseHelper')->disableOriginalConstructor()->getMock();
$this->strategyHelper = $this->getMockBuilder('Oro\\Bundle\\ImportExportBundle\\Strategy\\Import\\ImportStrategyHelper')->disableOriginalConstructor()->getMock();
$this->defaultOwnerHelper = $this->getMockBuilder('Oro\\Bundle\\IntegrationBundle\\ImportExport\\Helper\\DefaultOwnerHelper')->disableOriginalConstructor()->getMock();
$this->channelHelper = $this->getMockBuilder('OroCRM\\Bundle\\ChannelBundle\\ImportExport\\Helper\\ChannelHelper')->disableOriginalConstructor()->getMock();
$this->addressHelper = $this->getMockBuilder('OroCRM\\Bundle\\MagentoBundle\\ImportExport\\Strategy\\StrategyHelper\\AddressImportHelper')->disableOriginalConstructor()->getMock();
$this->stepExecution = $this->getMockBuilder('Akeneo\\Bundle\\BatchBundle\\Entity\\StepExecution')->disableOriginalConstructor()->getMock();
$this->jobExecution = $this->getMockBuilder('Akeneo\\Bundle\\BatchBundle\\Entity\\JobExecution')->disableOriginalConstructor()->getMock();
$this->stepExecution->expects($this->any())->method('getJobExecution')->will($this->returnValue($this->jobExecution));
$this->logger = new NullLogger();
}
/**
* @param string $entityName
* @param bool $fullData
* @param int $singleRelationDeepLevel
* @param int $multipleRelationDeepLevel
* @return array
*/
protected function getEntityRulesAndBackendHeaders($entityName, $fullData = false, $singleRelationDeepLevel = 0, $multipleRelationDeepLevel = 0)
{
// get fields data
$fields = $this->fieldHelper->getFields($entityName, true);
$rules = array();
$backendHeaders = array();
$defaultOrder = 10000;
// generate conversion rules and backend header
foreach ($fields as $field) {
$fieldName = $field['name'];
if ($this->fieldHelper->getConfigValue($entityName, $fieldName, 'excluded')) {
continue;
}
// get import/export config parameters
$fieldHeader = $this->fieldHelper->getConfigValue($entityName, $fieldName, 'header', $field['label']);
$fieldOrder = $this->fieldHelper->getConfigValue($entityName, $fieldName, 'order');
if ($fieldOrder === null || $fieldOrder === '') {
$fieldOrder = $defaultOrder;
$defaultOrder++;
}
$fieldOrder = (int) $fieldOrder;
// process relations
if ($this->fieldHelper->isRelation($field) && !$this->fieldHelper->processRelationAsScalar($entityName, $fieldName)) {
$isSingleRelation = $this->fieldHelper->isSingleRelation($field) && $singleRelationDeepLevel > 0;
$isMultipleRelation = $this->fieldHelper->isMultipleRelation($field) && $multipleRelationDeepLevel > 0;
// if relation must be included
if ($fullData && ($isSingleRelation || $isMultipleRelation)) {
$relatedEntityName = $field['related_entity_name'];
$fieldFullData = $this->fieldHelper->getConfigValue($entityName, $fieldName, 'full', false);
// process and merge relation rules and backend header for relation
list($relationRules, $relationBackendHeaders) = $this->getEntityRulesAndBackendHeaders($relatedEntityName, $fieldFullData, $singleRelationDeepLevel - 1, $multipleRelationDeepLevel - 1);
$relationRules = $this->buildRelationRules($relationRules, $isSingleRelation, $isMultipleRelation, $fieldName, $fieldHeader, $fieldOrder);
$rules = array_merge($rules, $relationRules);
$relationBackendHeaders = $this->buildBackendHeaders($relationBackendHeaders, $isSingleRelation, $isMultipleRelation, $entityName, $fieldName, $fieldOrder);
$backendHeaders = array_merge($backendHeaders, $relationBackendHeaders);
}
} else {
// process scalars
if ($fullData || $this->fieldHelper->getConfigValue($entityName, $fieldName, 'identity')) {
$rules[$fieldHeader] = array('value' => $fieldName, 'order' => $fieldOrder);
$backendHeaders[] = $rules[$fieldHeader];
}
}
}
return array($this->sortData($rules), $this->sortData($backendHeaders));
}
public function testGetRelations()
{
$entityName = 'TestEntity';
$expectedRelations = [['name' => 'field']];
$this->fieldProvider->expects($this->once())->method('getRelations')->with($entityName)->will($this->returnValue($expectedRelations));
$this->assertEquals($expectedRelations, $this->helper->getRelations($entityName));
// do not call twice
$this->assertEquals($expectedRelations, $this->helper->getRelations($entityName));
}
/**
* @param string $entityName
* @return bool
*/
protected function hasIdentityFields($entityName)
{
$fields = $this->fieldHelper->getFields($entityName, true);
foreach ($fields as $field) {
$fieldName = $field['name'];
if ($this->fieldHelper->getConfigValue($entityName, $fieldName, 'identity')) {
return true;
}
}
return false;
}
public function testGetIdentityValues()
{
$this->config['stdClass'] = array('excludedField' => array('excluded' => true), 'identityField' => array('identity' => true), 'regularField' => array());
$fields = array(array('name' => 'excludedField'), array('name' => 'identityField'), array('name' => 'regularField'));
$entity = new \stdClass();
$entity->excludedField = 'excludedValue';
$entity->identityField = 'identityValue';
$entity->regularField = 'regularValue';
$this->fieldProvider->expects($this->once())->method('getFields')->with(get_class($entity), true)->will($this->returnValue($fields));
$this->assertEquals(array('identityField' => 'identityValue'), $this->helper->getIdentityValues($entity, $fields));
}
/**
* {@inheritdoc}
*/
public function getMaxRelatedEntities($entityName, $fieldName)
{
$maxFields = 1;
$fixtures = $this->templateManager->getEntityFixture($entityName)->getData();
foreach ($fixtures as $fixture) {
try {
$fieldValue = $this->fieldHelper->getObjectValue($fixture, $fieldName);
if ($fieldValue instanceof \Countable || is_array($fieldValue)) {
$itemsCount = count($fieldValue);
if ($itemsCount > $maxFields) {
$maxFields = $itemsCount;
}
}
} catch (\Exception $e) {
// there is no $fieldName in fixture
continue;
}
}
return $maxFields;
}
/**
* @param object $entity
* @param array $searchContext
*
* @return object|null
*/
protected function findExistingEntityByIdentityFields($entity, array $searchContext = [])
{
$entityName = ClassUtils::getClass($entity);
$identityValues = $searchContext;
$identityValues += $this->fieldHelper->getIdentityValues($entity);
foreach ($identityValues as $fieldName => $value) {
if ($value !== null || $this->fieldHelper->isRequiredIdentityField($entityName, $fieldName)) {
continue;
}
unset($identityValues[$fieldName]);
}
return $this->findEntityByIdentityValues($entityName, $identityValues);
}
/**
* Finds detached properties in entity and reloads them from UnitOfWork
*
* @param object $entity doctrine entity
* @param int $level maximum nesting level
*/
public function fixEntityAssociationFields($entity, $level = 0)
{
if ($level < 0) {
return;
}
// we should use entityFieldProvider through fieldHelper
// to get relations data and avoid deleted relations in result list
$relations = $this->fieldHelper->getRelations(ClassUtils::getClass($entity));
if (!$relations) {
return;
}
foreach ($relations as $associationMapping) {
$fieldName = $associationMapping['name'];
$value = $this->propertyAccessor->getValue($entity, $fieldName);
if ($value && is_object($value)) {
if ($value instanceof Collection) {
$this->fixCollectionField($value, $level);
} else {
$this->fixEntityField($entity, $fieldName, $value, $level);
}
}
}
}
/**
* @param object $entity
* @param array $searchContext
* @return null|object
*/
protected function findExistingEntity($entity, array $searchContext = array())
{
$entityName = ClassUtils::getClass($entity);
$identifier = $this->databaseHelper->getIdentifier($entity);
$existingEntity = null;
// find by identifier
if ($identifier) {
$existingEntity = $this->databaseHelper->find($entityName, $identifier);
}
// find by identity fields
if (!$existingEntity && (!$searchContext || $this->databaseHelper->getIdentifier(current($searchContext)))) {
$identityValues = $searchContext;
$identityValues += $this->fieldHelper->getIdentityValues($entity);
$existingEntity = $this->findEntityByIdentityValues($entityName, $identityValues);
}
return $existingEntity;
}
/**
* @param string $entityName
* @param bool $fullData
* @param int $singleRelationDeepLevel
* @param int $multipleRelationDeepLevel
* @param array $field
* @param string $fieldHeader
* @param int $fieldOrder
*
* @return array
*/
protected function getRelatedEntityRulesAndBackendHeaders($entityName, $fullData, $singleRelationDeepLevel, $multipleRelationDeepLevel, $field, $fieldHeader, $fieldOrder, $isIdentifier = false)
{
$fieldName = $field['name'];
$relationRules = [];
$relationBackendHeaders = [];
$isSingleRelation = $this->fieldHelper->isSingleRelation($field) && $singleRelationDeepLevel > 0;
$isMultipleRelation = $this->fieldHelper->isMultipleRelation($field) && $multipleRelationDeepLevel > 0;
// if relation must be included
if ($fullData && ($isSingleRelation || $isMultipleRelation)) {
$relatedEntityName = $field['related_entity_name'];
$fieldFullData = $this->fieldHelper->getConfigValue($entityName, $fieldName, 'full', false);
// process and merge relation rules and backend header for relation
list($relationRules, $relationBackendHeaders) = $this->getEntityRulesAndBackendHeaders($relatedEntityName, $fieldFullData, $singleRelationDeepLevel - 1, $multipleRelationDeepLevel - 1);
$relationRules = $this->buildRelationRules($relationRules, $isSingleRelation, $isMultipleRelation, $fieldName, $fieldHeader, $fieldOrder);
$relationBackendHeaders = $this->buildBackendHeaders($relationBackendHeaders, $isSingleRelation, $isMultipleRelation, $entityName, $fieldName, $fieldOrder);
}
return [$relationRules, $relationBackendHeaders];
}
